Gerenciamento de estágios Snowflake

Os comandos snow stage permitem que você execute tarefas adicionais específicas do estágio:

Criação de um estágio nomeado

O comando snow stage create cria um estágio nomeado se ele ainda não existir.

snow stage create <stage_name>
Copy

Por exemplo, para criar um estágio chamado new_stage, digite o seguinte comando:

snow stage create new_stage
Copy
+-----------------------------------------------------+
| key    | value                                      |
|--------+--------------------------------------------|
| status | Stage area NEW_STAGE successfully created. |
+-----------------------------------------------------+

O exemplo a seguir mostra o que acontece se você tentar criar um estágio, packages, que já existe.

# stage that already exists
snow stage create packages
Copy
+--------------------------------------------------------+
| key    | value                                         |
|--------+-----------------------------------------------|
| status | PACKAGES already exists, statement succeeded. |
+--------------------------------------------------------+

Cópia de arquivos de e para um estágio

O comando snow stage copy copia um arquivo da máquina local para um estágio ou de um estágio para uma máquina local.

snow stage copy <source_path> <destination_path>
Copy

Um <caminho_de_origem> ou <caminho_de_destino> deve ser um caminho local, enquanto o outro deve ser um caminho para o estágio Snowflake. Observe o seguinte:

  • O caminho do estágio deve começar com @, conforme mostrado nos exemplos a seguir.

  • Ao copiar um único arquivo, o <caminho_de_destino> deve identificar um diretório, não um arquivo. Se o diretório especificado não existir, o comando o criará.

  • Ao copiar um diretório local para um estágio, o diretório local deve conter apenas arquivos; diretórios que contêm subdiretórios não são suportados.

  • Ao copiar um diretório de um estágio para um sistema de arquivos local, o comando atualmente nivela sua estrutura de árvore interna. Para ilustrar, suponha que seu diretório local contenha o seguinte:

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

    Após copiar o diretório do estágio, o diretório do sistema de arquivos local terá o seguinte:

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

    Nota

    Se você quiser manter a estrutura do arquivo do diretório de origem, você pode incluir a opção --recursive.

Como copiar arquivos para um estágio

Para copiar arquivos da máquina local para um estágio, insira um comando semelhante ao seguinte:

snow stage copy local_example_app @example_app_stage/app
Copy
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             ...
+--------------------------------------------------------------------------------------

Você pode usar o comando snow stage list-files para verificar se o comando copiou os arquivos com sucesso:

snow stage list-files example_app_stage
Copy
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 | ...
+------------------------------------------------------------------------------------

Cópia de arquivos de um estágio

O exemplo a seguir copia arquivos de um estágio para um diretório na máquina local:

mkdir local_app_backup
snow stage copy @example_app_stage/app local_app_backup
Copy
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 |         |
+------------------------------------------------+

Você pode listar o conteúdo do diretório para verificar se o comando copiou os arquivos corretamente:

ls local_app_backup
Copy
environment.yml  snowflake.yml    streamlit_app.py

Observe que o diretório local deve existir.

É possível copiar de um estágio de usuário (@~):

snow stage copy "@~" . --recursive
Copy
+------------------------------------------------+
| file             | size | status     | message |
|------------------+------+------------+---------|
| environment.yml  | 62   | DOWNLOADED |         |
| snowflake.yml    | 252  | DOWNLOADED |         |
| streamlit_app.py | 109  | DOWNLOADED |         |
+------------------------------------------------+

Use padrões glob para especificar arquivos

Você pode especificar vários arquivos que correspondem a uma expressão regular usando um padrão glob para o argumento source_path. Você deve colocar o padrão glob entre aspas simples ou duplas.

O exemplo a seguir copia todos os arquivos .txt em um diretório para um estágio.

snow stage copy "testdir/*.txt" @TEST_STAGE_3
Copy
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 |         |
+------------------------------------------------------------------------------------------------------------+

Listagem do conteúdo de um estágio

O comando snow stage list-files lista o conteúdo do estágio.

snow stage list-files <stage_path>
Copy

Por exemplo, para listar os pacotes em um estágio, digite o seguinte comando:

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

Execução de arquivos de um estágio

O comando snow stage execute executa arquivos SQL ou Python de um estágio.

snow stage execute <stage_path>
Copy

  • Para arquivos .sql, ele executa um comando EXECUTE IMMEDIATE FROM em arquivos .sql de um estágio.

  • Para arquivos .py, ele executa um procedimento Snowpark Python com escopo de sessão.

    Snowflake CLI executa o procedimento no Snowflake para garantir um ambiente de execução consistente. Se seus scripts Python exigirem requisitos adicionais, é necessário especificá-los em um arquivo requirements.txt que resida no mesmo diretório dos arquivos no estágio. O comando snow stage execute oferece suporte apenas a pacotes do canal Snowflake Anaconda.

    Por padrão, o comando procura o arquivo requirements.txt na seguinte precedência:

    • Caminho do estágio especificado no parâmetro stage_path do comando.

    • Diretórios pai da hierarquia de caminho do estágio especificado, até atingir o estágio.

    • Se você não especificar um arquivo requirements.txt, o comando assumirá que nenhum pacote adicional é necessário.

    Por exemplo, se você executar snow stage execute @my_stage/ml/app1/scripts, o comando procurará o arquivo da seguinte forma:

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

    • my_stage/ml/app1/requirements.txt

    • my_stage/ml/requirements.txt

    • my_stage/ml/requirements.txt

Os exemplos a seguir ilustram maneiras de executar diferentes conjuntos de arquivos .sql de um estágio:

  • Especifique apenas um nome de estágio para executar todos os arquivos .sql no estágio:

    snow stage execute "@scripts"
    Copy
    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  |
+------------------------------------------+

  • Especifique um estágio de usuário (@~) para executar os arquivos script.sql no estágio de usuário:

    snow stage execute "@~/script1.sql"
    Copy
    SUCCESS - scripts/script1.sql
+------------------------------------------+
| File                   | Status  | Error |
|------------------------+---------+-------|
| @~/script.sql          | SUCCESS | None  |
+------------------------------------------+

Use padrões glob para selecionar subconjuntos de arquivos

  • Especifique um padrão semelhante a um glob para executar todos os arquivos .sql no diretório dir:

    snow stage execute "@scripts/dir/*"
    Copy
    SUCCESS - scripts/dir/script.sql
+------------------------------------------+
| File                   | Status  | Error |
|------------------------+---------+-------|
| scripts/dir/script.sql | SUCCESS | None  |
+------------------------------------------+

  • Especifique um padrão semelhante a um glob para executar somente arquivos .sql no diretório dir que começa com «script», seguido por um caractere:

    snow stage execute "@scripts/script?.sql"
    Copy
    SUCCESS - scripts/script1.sql
SUCCESS - scripts/script2.sql
+---------------------------------------+
| File                | Status  | Error |
|---------------------+---------+-------|
| scripts/script1.sql | SUCCESS | None  |
| scripts/script2.sql | SUCCESS | None  |
+---------------------------------------+

  • Especifique um caminho de arquivo direto com a opção --silent:

    snow stage execute "@scripts/script1.sql" --silent
    Copy
    +---------------------------------------+
| File                | Status  | Error |
|---------------------+---------+-------|
| scripts/script1.sql | SUCCESS | None  |
+---------------------------------------+

Remoção de um arquivo de um estágio

O comando snow stage remove remove um arquivo de um estágio.

snow stage remove <stage_name> <file_name>
Copy

Por exemplo, para remover um arquivo de um estágio, digite um comando semelhante ao seguinte:

snow stage remove example_app_stage app/pages/my_page.py
Copy
+-------------------------------------------------+
| key    | value                                  |
|--------+----------------------------------------|
| name   | example_app_stage/app/pages/my_page.py |
| result | removed                                |
+-------------------------------------------------+
Linguagem: Português