3 postagens marcadas com "etl"

Armazéns de Dados em Nuvem​

Nos últimos anos, vimos um rápido crescimento no uso de data warehouses em nuvem (assim como o paradigma "warehouse-first"). Duas plataformas DWH em nuvem populares são BigQuery e Snowflake. Confira o gráfico abaixo para ver sua evolução ao longo do tempo.

Imagem: Gartner via Adam Ronthal (@aronthal) no Twitter.

BigQuery, em 4º lugar em 2021, é um serviço de armazenamento de dados sem servidor totalmente gerenciado oferecido pelo Google Cloud Platform (GCP). Ele permite uma análise fácil e escalável em petabytes de dados e é conhecido há muito tempo por sua facilidade de uso e natureza livre de manutenção.

Snowflake, é um serviço similar oferecido pela empresa Snowflake Inc. Uma das principais diferenças é que o Snowflake permite hospedar a instância em Amazon Web Services (AWS), Azure (Microsoft) ou GCP (Google). Essa é uma grande vantagem se você já estiver estabelecido em um ambiente não GCP.

Exportando e Carregando os dados​

Conforme as circunstâncias, às vezes é necessário ou desejado copiar dados de um ambiente BigQuery para um ambiente Snowflake. Vamos dar uma olhada e detalhar as várias etapas lógicas necessárias para mover adequadamente esses dados, pois nenhum dos serviços concorrentes possui uma função integrada para fazer isso facilmente. Para o nosso exemplo, vamos supor que nosso ambiente Snowflake de destino está hospedado na AWS.

Procedimento Passo a Passo​

Para migrar dados do BigQuery para o Snowflake (AWS), estas são as etapas essenciais:

1. Identifique a tabela ou consulta e execute a consulta EXPORT DATA OPTIONS para exportar para o Google Cloud Storage (GCS).

2. Execute o script na VM ou máquina local para copiar os dados do GCS para o palco interno do Snowflake. Também poderíamos ler diretamente do GCS com uma integração de armazenamento, mas isso envolve outra camada de configuração de acesso seguro (que pode ser preferível para seu caso de uso).

3. Gere manualmente CREATE TABLE DDL com os tipos de dados de coluna corretos e execute no Snowflake.

4. Execute uma consulta COPY no Snowflake para importar arquivos de teste.

5. Opcionalmente, limpe (exclua) dados temporários no GCP e no Palco Interno.

   Imagem: etapas para exportar manualmente do BigQuery para o Snowflake.

   Conforme demonstrado acima, existem várias etapas para que isso aconteça, onde sistemas independentes precisam interagir. Isso pode ser complicado para automatizar, especialmente gerando o DDL correto (#3) com os tipos de coluna apropriados no sistema de destino (o que eu pessoalmente acho mais trabalhoso, tente fazer isso para tabelas com mais de 50 colunas).

   Felizmente, existe uma maneira mais fácil de fazer isso, e é usando uma ferramenta bacana chamada Sling. Sling é uma ferramenta de integração de dados que permite a movimentação fácil e eficiente de dados (Extrair e Carregar) de/para Bancos de Dados, Plataformas de Armazenamento e aplicativos SaaS. Existem duas maneiras de usá-lo: Sling CLI e Sling Cloud. Faremos o mesmo procedimento acima, mas apenas fornecendo entradas para o sling e ele fará automaticamente os passos intrincados para nós!

Usando Sling CLI​

Se você é fanático por linha de comando, o Sling CLI é para você. Ele é integrado ao go (o que o torna super rápido) e funciona com arquivos, bancos de dados e vários endpoints saas. Ele também pode trabalhar com Unix Pipes (lê a entrada padrão e grava na saída padrão). Podemos instalá-lo rapidamente a partir do nosso shell:

#  No Mac
brew install slingdata-io/sling/sling

#  No Windows Powershell
scoop bucket add org https://github.com/slingdata-io/scoop-sling.git
scoop install sling

#  Usando Python Wrapper via pip
pip install sling

Por favor, veja aqui para outras opções de instalação (incluindo Linux). Há também uma biblioteca Python wrapper, que é útil se você preferir interagir com o Sling dentro do Python.

Uma vez instalado, devemos ser capazes de executar o comando sling, que deve nos dar esta saída:

sling - An Extract-Load tool | https://slingdata.io/pt
Slings data from a data source to a data target.
Version 0.86.52

  Usage:
    sling [conns|run|update]

  Subcommands:
    conns    Manage local connections
    run      Execute an ad-hoc task
    update   Update Sling to the latest version

  Flags:
       --version   Displays the program version string.
    -h --help      Displays help with available flag, subcommand, and positional value parameters.

Agora, há muitas maneiras de configurar tarefas, mas para nosso escopo neste artigo, primeiro precisamos adicionar credenciais de conexão para BigQuery e Snowflake (uma tarefa de uma vez). Podemos fazer isso abrindo o arquivo ~/.sling/env.yaml e adicionando as credenciais, que devem ficar assim:

connections:

  BIGQUERY:
    type: bigquery
    project: sling-project-123
    location: US
    dataset: public
    gc_key_file: ~/.sling/sling-project-123-ce219ceaef9512.json
    gc_bucket: sling_us_bucket # this is optional but recommended for bulk export.

  SNOWFLAKE:
    type: snowflake
    username: fritz
    password: my_pass23
    account: abc123456.us-east-1
    database: sling
    schema: public

Ótimo, agora vamos testar nossas conexões:

$ sling conns list
+------------+------------------+-----------------+
| CONN NAME  | CONN TYPE        | SOURCE          |
+------------+------------------+-----------------+
| BIGQUERY   | DB - Snowflake   | sling env yaml  |
| SNOWFLAKE  | DB - PostgreSQL  | sling env yaml  |
+------------+------------------+-----------------+

$ sling conns test BIGQUERY
6:42PM INF success!

$ sling conns test SNOWFLAKE
6:42PM INF success!

Fantástico, agora que temos nossas conexões configuradas, podemos executar nossa tarefa:

$ sling run --src-conn BIGQUERY --src-stream "select user.name, activity.* from public.activity join public.user on user.id = activity.user_id where user.type != 'external'" --tgt-conn SNOWFLAKE --tgt-object 'public.activity_user' --mode full-refresh
11:37AM INF connecting to source database (bigquery)
11:37AM INF connecting to target database (snowflake)
11:37AM INF reading from source database
11:37AM INF writing to target database [mode: full-refresh]
11:37AM INF streaming data
11:37AM INF dropped table public.activity_user
11:38AM INF created table public.activity_user
11:38AM INF inserted 77668 rows
11:38AM INF execution succeeded

Uau, isso foi fácil! O Sling fez todas as etapas que descrevemos anteriormente automaticamente. Podemos até exportar os dados do Snowflake de volta para nosso shell sdtout (no formato CSV) fornecendo apenas o identificador de tabela (public.activity_user) para o sinalizador --src-stream e contando as linhas para validar nossos dados:

$ sling run --src-conn SNOWFLAKE --src-stream public.activity_user --stdout | wc -l
11:39AM INF connecting to source database (snowflake)
11:39AM INF reading from source database
11:39AM INF writing to target stream (stdout)
11:39AM INF wrote 77668 rows
11:39AM INF execution succeeded
77669 # CSV output includes a header row (77668 + 1)

Usando Sling Cloud​

Agora vamos fazer o mesmo com o aplicativo Sling Cloud. O Sling Cloud usa o mesmo mecanismo que o Sling CLI, exceto que é uma plataforma totalmente hospedada para executar todas as suas necessidades de Extract-Load a um preço competitivo (confira nossa [página de preços](https://slingdata.io/pt/ preços)). Com o Sling Cloud, podemos:

• Colabore com muitos membros da equipe

• Gerenciar vários espaços de trabalho/projetos

• Agendar Tarefas Extract-Load (EL) para serem executadas em um intervalo ou em horários fixos (CRON)

• Colete e analise Logs para depuração

• Notificações de erro via e-mail ou Slack

• Executar a partir de regiões mundiais ou modo auto-hospedado, se desejado (onde Sling Cloud é o orquestrador).

• Interface de usuário intuitiva (UI) para configuração e execução rápidas

  A primeira coisa é se inscrever para uma conta gratuita aqui. Depois de fazer login, podemos selecionar o Cloud Mode (mais sobre o modo Self-Hosted posteriormente). Agora podemos executar etapas semelhantes às acima, mas usando a IU do Sling Cloud:

Adicionando a conexão do BigQuery​

Adicionando a Conexão Floco de Neve​

Criar replicação​

Criar e Executar Tarefa​

Assim que a execução da tarefa for concluída, podemos inspecionar os logs.

É isso! Temos nossa configuração de tarefa e podemos executá-la novamente sob demanda ou configurá-la em um cronograma. Como você pode notar, o Sling Cloud lida com mais algumas coisas para nós e oferece aos usuários orientados à interface do usuário uma experiência melhor em comparação com o Sling CLI.

Conclusão​

Estamos em uma era em que dados valem ouro, e mover dados de uma plataforma para outra não deve ser difícil. Como demonstramos, o Sling oferece uma alternativa poderosa ao reduzir o atrito associado à integração de dados. Abordaremos como exportar do Snowflake e carregar no BigQuery em outra postagem.

Introdução ao Sling CLI​

Sling CLI é uma ferramenta de linha de comando que permite a movimentação fácil e eficiente de dados (Extrair e Carregar) de/para Bancos de Dados, Plataformas de Armazenamento e aplicativos SaaS. É trivial começar, você pode simplesmente executar pip install sling se tiver o pip do Python instalado. Ou você pode baixar o binário para sua máquina aqui.

Credenciais de Conexão​

Para usar sling, devemos primeiro configurar as credenciais de conexão, e o Sling CLI as procura em vários lugares. Isso permite uma natureza “plug & play” se você já estiver usando outra ferramenta, como dbt, ou tiver URLs de conexão definidos em variáveis ​​de ambiente. No entanto, é recomendável usar o arquivo env.yaml do Sling, pois permite uma experiência mais consistente e flexível.

Arquivo Env Sling​

Na primeira vez que você executa o comando sling, a pasta .sling é criada no diretório inicial do usuário atual (~/.sling), que por sua vez contém um arquivo chamado env.yaml. A estrutura do arquivo Env do Sling é simples, você coloca a credencial de suas conexões na chave connections conforme mostrado abaixo:

connections:
  marketing_pg:
    url: 'postgres://...'
    ssh_tunnel: 'ssh://...' # opcional

# ou perfil dbt estilizado
  marketing_pg:
    type: postgres
    host: [hostname]
    user: [username]
    password: [password]
    port: [port]
    dbname: [database name]
    schema: [dbt schema]
    ssh_tunnel: 'ssh://...'

  finance_bq:
    type: bigquery
    method: service-account
    project: [GCP project id]
    dataset: [the name of your dbt dataset]
    keyfile: [/path/to/bigquery/keyfile.json]

# variáveis ​​globais, disponíveis para todas as conexões em tempo de execução (opcional)
variables:
  aws_access_key: '...'
  aws_secret_key: '...'

Consulte aqui para todos os tipos de conexão aceitos e seus respectivos pontos de dados necessários.

Ao usar o comando sling conns list com credenciais Sling Env, a coluna SOURCE será exibida como sling env yaml.

Variáveis ​​de ambiente​

Se você preferir usar variáveis ​​de ambiente, basta defini-las em seu ambiente de shell da maneira usual:

# Mac/Linux
export MY_PG='postgresql://user:mypassw@pg.host:5432/db1'
export MY_SNOWFLAKE='snowflake://user:mypassw@sf.host/db1'
export ORACLE_DB='oracle://user:mypassw@orcl.host:1521/db1'

# Windows Powershell
set MY_PG 'postgresql://user:mypassw@pg.host:5432/db1'
set MY_SNOWFLAKE 'snowflake://user:mypassw@sf.host/db1'
set ORACLE_DB 'oracle://user:mypassw@orcl.host:1521/db1'

Ao usar o comando sling conns list com variáveis ​​de ambiente, a coluna SOURCE será exibida como env variable.

Perfis DBT​

dbt é outra ferramenta popular que muitos profissionais de dados usam diariamente, e o suporte a perfis locais existentes facilita o uso cruzado. A localização típica das credenciais dbt está no arquivo ~/dbt/profiles.yml. Veja aqui para mais detalhes.

Se você tiver credenciais dbt e usar o comando sling conns list, a coluna SOURCE será exibida como dbt profiles yaml.

O subcomando conns​

Agora que você definiu as credenciais, o sling oferece um subcomando conns para interagir com as conexões. Podemos realizar as seguintes operações: list, test e discover.

$ sling conns -h
conns - Manage local connections

  Usage:
    conns [discover|list|test]

  Subcommands:
    discover   list available streams in connection
    list       list local connections detected
    test       test a local connection

  Flags:
       --version   Displays the program version string.
    -h --help      Displays help with available flag, subcommand, and positional value parameters.

Listando Conexões​

É conveniente ver e listar todas as conexões disponíveis em nosso ambiente. Podemos simplesmente executar o comando sling conns list. Aqui está um exemplo:

$ sling conns list
+----------------------+------------------+-------------------+
| CONN NAME            | CONN TYPE        | SOURCE            |
+----------------------+------------------+-------------------+
| AWS_S3               | FileSys - S3     | sling env yaml    |
| AZURE_STORAGE        | FileSys - Azure  | sling env yaml    |
| BIGQUERY             | DB - BigQuery    | sling env yaml    |
| BIONIC_DB1           | DB - PostgreSQL  | dbt profiles yaml |
| BTD_S3               | FileSys - S3     | sling env yaml    |
| CLICKHOUSE           | DB - Clickhouse  | sling env yaml    |
| DEMO_POSTGRES        | DB - PostgreSQL  | sling env yaml    |
| GITHUB_DBIO          | API - GitHub     | sling env yaml    |
| NOTION               | API - Notion     | sling env yaml    |
| SNOWFLAKE            | DB - Snowflake   | env variable      |
| STEAMPIPE            | DB - PostgreSQL  | sling env yaml    |
+----------------------+------------------+-------------------+

Testando Conexões​

A ferramenta Sling CLI também permite testar conexões. Assim que soubermos o nome da conexão, podemos usar o comando sling conns test:

$ sling conns test -h
test - test a local connection

  Usage:
    test [name]

  Positional Variables:
    name   The name of the connection to test (Required)
  Flags:
       --version   Displays the program version string.
    -h --help      Displays help with available flag, subcommand, and positional value parameters.

Aqui está um exemplo real:

$ sling conns test MSSQL
6:42PM INF success!

Descobrindo fluxos de conexão​

Este é outro subcomando bacana que permite ver quais fluxos de dados estão disponíveis para que sling seja lido para uma conexão específica: o comando sling conns discover.

$ sling conns discover -h
discover - list available streams in connection

  Usage:
    discover [name]

  Positional Variables:
    name   The name of the connection to test (Required)
  Flags:
       --version   Displays the program version string.
    -h --help      Displays help with available flag, subcommand, and positional value parameters.
    -f --filter    filter stream name by pattern (e.g. account_*)
       --folder    discover streams in a specific folder (for file connections)
       --schema    discover streams in a specific schema (for database connections)

Para conexões de banco de dados, listará as tabelas e visualizações disponíveis. Para conexões de armazenamento, ele listará os objetos de arquivo não recursivos localizados na pasta de origem especificada. Para conexões SaaS/API, ele listará todos os objetos disponíveis que existem para consumo. Abaixo estão alguns exemplos.

Conexões de Banco de Dados​

$ sling conns discover CLICKHOUSE
6:57PM INF Found 68 streams:
 - "default"."docker_logs"
 - "default"."sling_docker_logs"
 - "system"."aggregate_function_combinators"
 - "system"."asynchronous_metric_log"
 - "system"."asynchronous_metrics"
 - "system"."build_options"
 - "system"."clusters"
 ....

Se quisermos filtrar por um shema específico, podemos fazer:

$ sling conns discover CLICKHOUSE --schema default
8:29PM INF Found 2 streams:
 - "default"."docker_logs"
 - "default"."sling_docker_logs"

Conexões SaaS​

$ sling conns discover NOTION
6:58PM INF Found 4 streams:
 - blocks
 - databases
 - pages
 - users

Conexões de Armazenamento​

$ sling conns discover AWS_S3
6:52PM INF Found 7 streams:
 - s3://my-sling-bucket/logging/
 - s3://my-sling-bucket/part.01.0001.csv
 - s3://my-sling-bucket/sling/
 - s3://my-sling-bucket/temp/
 - s3://my-sling-bucket/test.fs.write/
 - s3://my-sling-bucket/test/
 - s3://my-sling-bucket/test_1000.csv

Se quisermos ver os arquivos em uma subpasta, podemos fazer isso:

$ sling conns discover AWS_S3 --folder s3://my-sling-bucket/logging/
6:55PM INF Found 1 streams:
 - s3://my-sling-bucket/logging/1/1.log.gz

Executando Tarefas EL​

Agora que suas conexões estão definidas, você está pronto para executar algumas tarefas de extração e carregamento! Cobrimos isso em detalhes em um post separado, você pode ler sobre isso aqui. Na linha de comando, você também pode executar sling run -e, que imprimirá vários exemplos.

Conclusão​

Considerando tudo, o Sling CLI facilita o gerenciamento e a interação com vários tipos de conexões do seu shell. Se você tiver alguma dúvida ou sugestão, sinta-se à vontade para entrar em contato conosco aqui. Além disso, certifique-se de conferir o Sling Cloud, que é um serviço de nuvem que lida com suas várias necessidades de extração e carregamento em um modelo de preços competitivo.

O Sling é uma ferramenta de integração de dados moderna e poderosa que extrai e carrega dados de fontes de dados populares para destinos com alto desempenho e facilidade.

Por que Sling?​

• Desempenho ultrarrápido - O mecanismo Core é escrito em Go e adota um design de streaming, tornando-o super eficiente, mantendo o mínimo de dados na memória.
• Replicar dados rapidamente - Replicar facilmente dados de um banco de dados de origem, arquivo ou conexão SaaS para um banco de dados ou arquivo de destino.
• Transparente e de baixo custo - O Sling opera em um modelo eficiente e de baixo custo. Nosso objetivo é ser transparente com o custo de usar nossa plataforma.

Saiba mais sobre como o Sling funciona Inscreva-se no Sling