Verwalten von Snowflake-Stagingbereichen

Mit den Befehlen snow stage können Sie zusätzliche Stagingbereichs-spezifische Aufgaben durchführen:

Benannten Stagingbereich erstellen

Der Befehl snow stage create erstellt einen benannten Stagingbereich, wenn er noch nicht existiert.

snow stage create <stage_name>

Um beispielsweise einen Stagingbereich mit dem Namen new_stage zu erstellen, geben Sie den folgenden Befehl ein:

snow stage create new_stage

+-----------------------------------------------------+
| key    | value                                      |
|--------+--------------------------------------------|
| status | Stage area NEW_STAGE successfully created. |
+-----------------------------------------------------+

Das folgende Beispiel zeigt, was passiert, wenn Sie versuchen, einen Stagingbereich namens packages zu erstellen, der bereits existiert.

# stage that already exists
snow stage create packages

+--------------------------------------------------------+
| key    | value                                         |
|--------+-----------------------------------------------|
| status | PACKAGES already exists, statement succeeded. |
+--------------------------------------------------------+

Wenn Sie die Art der Verschlüsselung angeben möchten, die für alle im Stagingbereich gespeicherten Dateien verwendet werden soll, fügen Sie die Option --encryption hinzu, um anzugeben, ob Sie eine vollständige Verschlüsselung (SNOWFLAKE_FULL) oder nur eine serverseitige Verschlüsselung (SNOWFLAKE_SSE) wünschen.

snow stage create new_stage --encryption SNOWFLAKE_FULL

+-----------------------------------------------------+
| key    | value                                      |
|--------+--------------------------------------------|
| status | Stage area NEW_STAGE successfully created. |
+-----------------------------------------------------+

Dateien in und aus einem Stagingbereich kopieren

Der Befehl snow stage copy kopiert eine Datei vom lokalen Rechner in einen Stagingbereich oder von einem Stagingbereich auf einen lokalen Rechner sowie zwischen benannten Stagingbereichen.

snow stage copy <source_path> <destination_path>

Beachten Sie die folgenden Richtlinien:

  • Der Stagingbereichspfad muss mit @ beginnen, wie in den folgenden Beispielen gezeigt.

  • Wenn Sie eine einzelne Datei kopieren, <destination_path> müssen Sie statt einer Datei ein Verzeichnis angeben. Wenn das angegebene Verzeichnis nicht existiert, wird es vom Befehl erstellt.

  • Wenn Sie ein lokales Verzeichnis in einen Stagingbereich kopieren, darf das lokale Verzeichnis standardmäßig nur Dateien enthalten. Sie können die Option --recursive verwenden, um Unterverzeichnisse im lokalen Verzeichnis hochzuladen. Sie können glob-Muster mit der Option --recursive verwenden.

  • Wenn Sie ein Verzeichnis aus einem Stagingbereich in ein lokales Dateisystem kopieren, vereinfacht der Befehl aktuell die interne Baumstruktur. Zur Veranschaulichung nehmen wir an, dass Ihr lokales Verzeichnis Folgendes enthält:

    test_case.py
tests/abc.py
tests/test1/x1.txt
tests/test1/x2.txt

    Nach dem Kopieren des Verzeichnisses aus dem Stagingbereich enthält das Verzeichnis des lokalen Dateisystems Folgendes:

    test_case.py
abc.py
x1.txt
x2.txt

    Bemerkung

    Wenn Sie die Dateistruktur aus dem Quellverzeichnis beibehalten möchten, können Sie die Option --recursive einfügen.

Dateien in einen Stagingbereich hochladen

  • Um Dateien vom lokalen Rechner in einen Stagingbereich zu kopieren, geben Sie einen Befehl ähnlich dem folgenden ein:

    snow stage copy local_example_app @example_app_stage/app

    put file:///.../local_example_app/* @example_app_stage/app4 auto_compress=false parallel=4 overwrite=False
+--------------------------------------------------------------------------------------
| source           | target           | source_size | target_size | source_compression...
|------------------+------------------+-------------+-------------+--------------------
| environment.yml  | environment.yml  | 62          | 0           | NONE             ...
| snowflake.yml    | snowflake.yml    | 252         | 0           | NONE             ...
| streamlit_app.py | streamlit_app.py | 109         | 0           | NONE             ...
+--------------------------------------------------------------------------------------

Sie können den Befehl snow stage list-files verwenden, um zu überprüfen, ob der Befehl die Dateien erfolgreich kopiert hat:

snow stage list-files example_app_stage

ls @example_app_stage
​+------------------------------------------------------------------------------------
| name                                   | size | md5                              | ...
|----------------------------------------+------+----------------------------------+-
| example_app_stage/app/environment.yml  | 64   | 45409c8da098125440bfb7ffbcd900f5 | ...
| example_app_stage/app/snowflake.yml    | 256  | a510b1d59fa04f451b679d43c703b6d4 | ...
| example_app_stage/app/streamlit_app.py | 112  | e6c2a89c5a164e34a0faf60b086bbdfc | ...
+------------------------------------------------------------------------------------

Dateien aus einem Stagingbereich kopieren

  • Um Dateien aus einem Stagingbereich in ein Verzeichnis auf dem lokalen Rechner zu kopieren, geben Sie einen Befehl ähnlich dem folgenden ein:

    mkdir local_app_backup
snow stage copy @example_app_stage/app local_app_backup

    get @example_app_stage/app file:///.../local_app_backup/ parallel=4
+------------------------------------------------+
| file             | size | status     | message |
|------------------+------+------------+---------|
| environment.yml  | 62   | DOWNLOADED |         |
| snowflake.yml    | 252  | DOWNLOADED |         |
| streamlit_app.py | 109  | DOWNLOADED |         |
+------------------------------------------------+

Sie können den Inhalt des Verzeichnisses auflisten, um zu überprüfen, ob der Befehl die Dateien korrekt kopiert hat:

ls local_app_backup

environment.yml  snowflake.yml    streamlit_app.py

Beachten Sie, dass das lokale Verzeichnis existieren muss.

Sie können von einem Benutzer-Stagingbereich (@~) kopieren:

snow stage copy "@~" . --recursive

+------------------------------------------------+
| file             | size | status     | message |
|------------------+------+------------+---------|
| environment.yml  | 62   | DOWNLOADED |         |
| snowflake.yml    | 252  | DOWNLOADED |         |
| streamlit_app.py | 109  | DOWNLOADED |         |
+------------------------------------------------+

Dateien zwischen Stagingbereichen kopieren

Sie können Dateien direkt zwischen zwei benannten Stagingbereichen kopieren, ohne sie vorher auf Ihren lokalen Computer herunterladen zu müssen. Dies kann nützlich sein, um Dateien über verschiedene Stagingbereiche hinweg zu organisieren oder Backups zu erstellen.

  • Um Dateien von einem Stagingbereich in einen anderen zu kopieren, verwenden Sie die folgende Syntax:

    snow stage copy @source_stage @destination_stage

Das folgende Beispiel kopiert alle Dateien aus production_stage nach backup_stage:

snow stage copy @production_stage @backup_stage

+------------------------------------------------------------+
| file                                                       |
|------------------------------------------------------------|
| __init__.py                                                |
| main.py                                                    |
| procedure.py                                               |
+------------------------------------------------------------+

Bemerkung

Beim Kopieren von einem Stagingbereich in einen anderen kann das Ziel kein Benutzer-Stagingbereich (@~) sein. Sie müssen benannte Stagingbereiche für die Quelle und das Ziel angeben.

Glob-Muster zur Angabe von Dateien verwenden

Sie können mehrere Dateien angeben, die einem regulären Ausdruck entsprechen, indem Sie ein glob-Muster für das source_path-Argument verwenden. Sie müssen das glob-Muster in einfache oder doppelte Anführungszeichen einschließen.

Das folgende Beispiel kopiert alle .txt-Dateien eines Verzeichnisses in einen Stagingbereich.

snow stage copy "testdir/*.txt" @TEST_STAGE_3

put file:///.../testdir/*.txt @TEST_STAGE_3 auto_compress=false parallel=4 overwrite=False
+------------------------------------------------------------------------------------------------------------+
| source | target | source_size | target_size | source_compression | target_compression | status   | message |
|--------+--------+-------------+-------------+--------------------+--------------------+----------+---------|
| b1.txt | b1.txt | 3           | 16          | NONE               | NONE               | UPLOADED |         |
| b2.txt | b2.txt | 3           | 16          | NONE               | NONE               | UPLOADED |         |
+------------------------------------------------------------------------------------------------------------+

Inhalt eines Stagingbereichs auflisten

Der Befehl snow stage list-files listet den Inhalt des Stagingbereichs auf.

snow stage list-files <stage_path>

Um beispielsweise die Pakete in einem Stagingbereich aufzulisten, geben Sie den folgenden Befehl ein:

snow stage list-files packages

ls @packages
+-------------------------------------------------------------------------------------
| name                 | size     | md5                              | last_modified
|----------------------+----------+----------------------------------+----------------
| packages/plp.Ada.zip | 824736   | 90639175a0ac7735e67525118b81047c | Tue, 16 Jan ...
| packages/samrand.zip | 13721024 | 648f0bae2f65fd4c9f178b17c23de7e5 | Tue, 16 Jan ...
+-------------------------------------------------------------------------------------

Dateien aus einem Stagingbereich ausführen

Bemerkung

Snowflake CLI unterstützt die Ausführung von Python-Dateien für Python-Versionen 3.12 und höher nicht.

Der Befehl snow stage execute führt SQL- oder Python-Dateien aus einem Stagingbereich aus.

snow stage execute <stage_path>

  • Für .sql-Dateien führt er einen EXECUTE IMMEDIATE FROM- Befehl für .sql-Dateien aus einem Stagingbereich aus.

  • Für .py-Dateien führt es eine in der Sitzung enthaltene Snowpark Python Prozedur aus.

    Snowflake CLI führt die Prozedur in Snowflake aus, um eine konsistente Umgebung für die Ausführung zu gewährleisten. Wenn Ihre Python-Skripte zusätzliche Anforderungen erfordern, sollten Sie diese in einer requirements.txt-Datei angeben, die sich im selben Verzeichnis wie die Dateien im Stagingbereich befindet. Der Befehl snow stage execute unterstützt nur Pakete aus dem Snowflake-Anaconda-Kanal.

    Standardmäßig sucht der Befehl nach der requirements.txt-Datei in der folgenden Rangfolge:

    • Pfad des Stagingbereichs, der im stage_path-Parameter des Befehls angegeben ist.

    • Übergeordnete Verzeichnisse der Hierarchie des angegebenen Pfads im Stagingbereich, bis der Stagingbereich erreicht ist.

    • Wenn Sie keine requirements.txt-Datei angeben, geht der Befehl davon aus, dass keine weiteren Pakete erforderlich sind.

    Wenn Sie zum Beispiel snow stage execute @my_stage/ml/app1/scripts ausführen, sucht der Befehl die Datei wie folgt:

    • my_stage/ml/app1/scripts/requirements.txt

    • my_stage/ml/app1/requirements.txt

    • my_stage/ml/requirements.txt

    • my_stage/ml/requirements.txt

Die folgenden Beispiele zeigen, wie Sie verschiedene Sätze von .sql-Dateien aus einem Stagingbereich ausführen können:

  • Geben Sie nur den Namen eines Stagingbereichs an, um alle .sql-Dateien im Stagingbereich auszuführen:

    snow stage execute "@scripts"

    SUCCESS - scripts/script1.sql
SUCCESS - scripts/script2.sql
SUCCESS - scripts/dir/script.sql
+------------------------------------------+
| File                   | Status  | Error |
|------------------------+---------+-------|
| scripts/script1.sql    | SUCCESS | None  |
| scripts/script2.sql    | SUCCESS | None  |
| scripts/dir/script.sql | SUCCESS | None  |
+------------------------------------------+

  • Geben Sie einen Benutzer-Stagingbereich (@~) an, um die script.sql-Dateien im Benutzer-Stagingbereich auszuführen:

    snow stage execute "@~/script1.sql"

    SUCCESS - scripts/script1.sql
+------------------------------------------+
| File                   | Status  | Error |
|------------------------+---------+-------|
| @~/script.sql          | SUCCESS | None  |
+------------------------------------------+

Glob-Muster verwenden, um Teilmengen von Dateien auszuwählen

  • Geben Sie ein glob-ähnliches Muster an, um alle .sql-Dateien im Verzeichnis dir auszuführen:

    snow stage execute "@scripts/dir/*"

    SUCCESS - scripts/dir/script.sql
+------------------------------------------+
| File                   | Status  | Error |
|------------------------+---------+-------|
| scripts/dir/script.sql | SUCCESS | None  |
+------------------------------------------+

  • Geben Sie ein glob-ähnliches Muster an, um nur .sql-Dateien im Verzeichnis dir auszuführen, die mit „script“, gefolgt von einem Zeichen beginnen:

    snow stage execute "@scripts/script?.sql"

    SUCCESS - scripts/script1.sql
SUCCESS - scripts/script2.sql
+---------------------------------------+
| File                | Status  | Error |
|---------------------+---------+-------|
| scripts/script1.sql | SUCCESS | None  |
| scripts/script2.sql | SUCCESS | None  |
+---------------------------------------+

  • Geben Sie einen direkten Dateipfad mit der Option --silent an:

    snow stage execute "@scripts/script1.sql" --silent

    +---------------------------------------+
| File                | Status  | Error |
|---------------------+---------+-------|
| scripts/script1.sql | SUCCESS | None  |
+---------------------------------------+

Datei aus einem Stagingbereich entfernen

Der Befehl snow stage remove entfernt eine Datei aus einem Stagingbereich.

snow stage remove <stage_name> <file_name>

Um zum Beispiel eine Datei aus einem Stagingbereich zu entfernen, geben Sie einen Befehl ähnlich dem folgenden ein:

snow stage remove example_app_stage app/pages/my_page.py

+-------------------------------------------------+
| key    | value                                  |
|--------+----------------------------------------|
| name   | example_app_stage/app/pages/my_page.py |
| result | removed                                |
+-------------------------------------------------+