Nota

Snowflake Connector for PostgreSQL e Snowflake Connector for MySQL estão sujeitos aos termos do conector.

Como trabalhar com os conectores MySQL e PostgreSQL para o Snowflake

Introdução

Bem-vindo ao nosso tutorial sobre como usar os conectores do banco de dados Snowflake. Este guia ajudará você a transferir dados de bancos de dados relacionais ao Snowflake sem problemas.

Neste tutorial, você adquirirá habilidades para:

  • Configure MySQL e PostgreSQL no Docker e complete com dados de amostra para ingestão.

  • Instale e configure dois aplicativos nativos, um para cada banco de dados.

  • Configure e ajuste dois agentes, novamente um para cada banco de dados.

  • Inicie e gerencie processos de ingestão de dados.

  • Monitore o fluxo de trabalho de ingestão de dados.

Vamos começar!

Pré-requisitos

Antes de começar este tutorial, certifique-se de atender aos seguintes requisitos:

  • O Docker está instalado e operacional em sua máquina local.

  • Você tem uma ferramenta disponível para conectar ao banco de dados. Pode ser uma ferramenta específica de banco de dados ou uma ferramenta de uso geral, como IntelliJ ou Visual Studio Code.

Criação de bancos de dados de origem MySQL e PostgreSQL

Nesta seção, iremos guiá-lo através das seguintes etapas:

Como iniciar as instâncias do banco de dados

Para iniciar o processo de configuração do banco de dados MySQL e PostgreSQL usando o Docker, crie o arquivo docker-compose.yaml. O conteúdo do arquivo deve ser semelhante a:

services:
  mysql:
    container_name: mysql8
    restart: always
    image: mysql:8.0.28-oracle
    command: --log-bin=/var/lib/mysql/mysql-bin
      --max-binlog-size=4096
      --binlog-format=ROW
      --binlog-row-image=FULL
      --binlog-row-metadata=FULL
      --sql_mode="ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION,PAD_CHAR_TO_FULL_LENGTH"
    environment:
      MYSQL_ROOT_PASSWORD: 'mysql'
    volumes:
      - ./mysql-data:/var/lib/mysql
    ports:
      - "3306:3306"
  postgres:
    image: "postgres:11"
    container_name: "postgres11"
    environment:
      POSTGRES_USER: 'postgres'
      POSTGRES_PASSWORD: 'postgres'
    ports:
      - "5432:5432"
    command:
      - "postgres"
      - "-c"
      - "wal_level=logical"
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
Copy

Quando docker-compose.yaml estiver pronto, siga estes passos:

  1. Abra um terminal.

  2. Navegue até o diretório que com o arquivo docker-compose.yaml.

  3. Execute o seguinte comando para iniciar bancos de dados de origem em contêineres:

    docker compose up -d
    
    Copy

Após executar este comando, você deverá ver dois contêineres executando ativamente os bancos de dados de origem.

Como conectar ao banco de dados

Para se conectar aos bancos de dados pré-configurados usando conexões de banco de dados do IntelliJ ou do Visual Studio Code, execute as seguintes etapas com as credenciais fornecidas:

  1. Abra a ferramenta de sua escolha para se conectar ao MySQL.

  2. Clique no sinal de “+” ou similar para adicionar a fonte de dados.

  3. Preencha os detalhes de conexão:

    • Usuário: root

    • Senha: mysql

    • URL: jdbc:mysql://localhost:3306

  4. Teste a conexão e salve.

Carregamento de dados de amostra

Para inicializar e carregar a amostra, execute esses scripts nessas conexões.

Execute o script para gerar dados de amostra

CREATE DATABASE mysql_ingest_database;
USE mysql_ingest_database;

CREATE TABLE mysql_rows(
    id INT AUTO_INCREMENT PRIMARY KEY,
    random_string VARCHAR(255),
    random_number INT);

INSERT INTO mysql_rows (random_string, random_number) VALUES
    ('fukjxyiteb', 100),
    ('ndhbbipodi', 37),
    ('laebpztxzh', 83);

SELECT * FROM mysql_ingest_database.mysql_rows;
Copy

Você deverá ver três linhas em cada banco de dados preenchido.

Instalação e configuração do Native App

Durante esta etapa você irá:

Instalar Native Applications

Siga estas etapas para instalar o aplicativo a partir do marketplace Snowflake Native Apps:

  1. Faça login no Snowsight.

  2. No menu de navegação, selecione Data Products » Marketplace.

  3. Instale os aplicativos Snowflake Connector para MySQL e Snowflake Connector para PostgreSQL.

  4. Instale ambos os aplicativos.

Após a instalação, você verá os novos aplicativos listados em Data Products » Apps.

Configuração de Native Applications

  1. Faça login no Snowsight.

  2. No menu de navegação, selecione Data Products » Apps.

  3. Abra cada aplicativo e faça o seguinte:

  1. Selecione Download Driver ` e salve o arquivo. O nome do arquivo será semelhante a mariadb-java-client-3.4.1.jar ou a uma versão mais recente, se disponível. Salve este arquivo para uso durante a configuração do agente.

  2. Selecione Mark all as done, pois criaremos e preencheremos bancos de dados de origem do zero.

    Nota

    Nenhuma configuração de rede adicional é necessária neste momento, pois configuraremos o agente mais adiante no tutorial.

  3. Clique em Start configuration.

  4. Na tela Configure Connector, selecione Configure. A página Verify Agent Connection será exibida.

  5. Selecione Generate file para gerar um arquivo de configuração do agente. O nome de arquivo deve ser semelhante a snowflake.json. Salve este arquivo para uso posterior na seção Configuração do Agent.

Configuração de agentes

Nesta seção, configuraremos o agente que operará com seus bancos de dados de origem.

O primeiro passo é criar diretórios agent-mysql e agent-postgresql.

Dentro de cada diretório, crie os subdiretórios agent-keys e configuration. A estrutura de seu diretório deve ser semelhante a:

.
├── agent-mysql
│   ├── agent-keys
│   └── configuration
└── agent-postgresql
    ├── agent-keys
    └── configuration

Criação de arquivos de configuração

Nesta seção, adicionaremos conteúdo aos arquivos de configuração para que cada agente opere corretamente. Os arquivos de configuração incluem:

  • Arquivo snowflake.json para conectar ao Snowflake.

  • Arquivo datasources.json para conectar aos bancos de dados de origem.

  • Arquivos postgresql.conf/mysql.conf com variáveis de ambiente de agente adicionais.

  • Arquivo de driver JDBC para agente MySQL.

  1. Em um terminal, navegue até o diretório agent-mysql.

  2. Crie o arquivo Docker Compose docker-compose.yaml com o seguinte conteúdo:

    services:
      mysql-agent:
        container_name: mysql-agent
        image: snowflakedb/database-connector-agent:latest
        volumes:
          - ./agent-keys:/home/agent/.ssh
          - ./configuration/snowflake.json:/home/agent/snowflake.json
          - ./configuration/datasources.json:/home/agent/datasources.json
          - ./configuration/mariadb-java-client-3.4.1.jar:/home/agent/libs/mariadb-java-client-3.4.1.jar
        env_file:
          - configuration/mysql.conf
        mem_limit: 6g
    
    Copy
  3. Mova o arquivo snowflake.json baixado anteriormente para o diretório configuration.

  4. Mova o arquivo mariadb-java-client-3.4.1.jar baixado anteriormente para o diretório configuration.

  5. No diretório configuration, crie datasources.json com conteúdo:

    {
      "MYSQLDS1": {
        "url": "jdbc:mariadb://host.docker.internal:3306/?allowPublicKeyRetrieval=true&useSSL=false",
        "username": "root",
        "password": "mysql",
        "ssl": false
      }
    }
    
    Copy
  6. No diretório configuration, crie mysql.conf com conteúdo:

    JAVA_OPTS=-Xmx5g
    MYSQL_DATASOURCE_DRIVERPATH=/home/agent/libs/mariadb-java-client-3.4.1.jar
    
    Copy
  7. Inicie o agente usando o seguinte comando. Não deve haver nenhuma mensagem de erro e o agente deve gerar um par de chaves privadas para autenticação no Snowflake.

    docker compose stop  # stops the previous container in case you've launched it before
    docker compose rm -f # removes the agent container to recreate it with the latest image in case you had one before
    docker compose pull  # refresh remote latest tag in case you have cached previous version
    docker compose up -d # run the agent
    
    Copy
  8. Observe que o nome do arquivo jar do driver deve ser idêntico ao baixado e usado nos arquivos docker-compose.yaml e mysql.conf.

Quando concluído, a estrutura de seu diretório deverá ser semelhante à seguinte. Observe a inclusão das chaves públicas e privadas geradas automaticamente nos diretórios agent-keys.

.
├── agent-mysql
│   ├── agent-keys
│   │   ├── database-connector-agent-app-private-key.p8
│   │   └── database-connector-agent-app-public-key.pub
│   ├── configuration
│   │   ├── datasources.json
│   │   ├── mariadb-java-client-3.4.1.jar
│   │   ├── mysql.conf
│   │   └── snowflake.json
│   └── docker-compose.yaml
└── agent-postgresql
    ├── agent-keys
    │   ├── database-connector-agent-app-private-key.p8
    │   └── database-connector-agent-app-public-key.pub
    ├── configuration
    │   ├── datasources.json
    │   ├── postgresql.conf
    │   └── snowflake.json
    └── docker-compose.yaml

Verificação da conexão com o Snowflake

Retorne aos seus aplicativos nativos criados anteriormente. Clique no botão Atualizar na seção Conexão do Agent.

Quando configurado com sucesso, você deverá ver:

Agent is fully set up and connected. To select data to ingest Open Worksheet.
Copy

Configuração e monitoramento do processo de ingestão de dados

Nesta etapa, instruiremos o conector a começar a replicação das tabelas selecionadas. Primeiro, vamos criar um banco de dados coletor compartilhado no Snowflake.

CREATE DATABASE CONNECTORS_DEST_DB;
GRANT CREATE SCHEMA ON DATABASE CONNECTORS_DEST_DB TO APPLICATION SNOWFLAKE_CONNECTOR_FOR_POSTGRESQL;
GRANT CREATE SCHEMA ON DATABASE CONNECTORS_DEST_DB TO APPLICATION SNOWFLAKE_CONNECTOR_FOR_MYSQL;
Copy

Quando o banco de dados estiver pronto, podemos prosseguir para o processo de configuração.

  1. Para iniciar a replicação da tabela, você deve primeiro adicionar uma fonte de dados da qual replicar e, em seguida, especificar a tabela a ser replicada.

    CALL SNOWFLAKE_CONNECTOR_FOR_MYSQL.PUBLIC.ADD_DATA_SOURCE('MYSQLDS1', 'CONNECTORS_DEST_DB');
    CALL SNOWFLAKE_CONNECTOR_FOR_MYSQL.PUBLIC.ADD_TABLES('MYSQLDS1', 'mysql_ingest_database', ARRAY_CONSTRUCT('mysql_rows'));
    
    Copy
  2. Para monitorar a replicação, execute as seguintes consultas:

    SELECT * FROM SNOWFLAKE_CONNECTOR_FOR_MYSQL.PUBLIC.REPLICATION_STATE;
    SELECT * FROM SNOWFLAKE_CONNECTOR_FOR_MYSQL.PUBLIC.CONNECTOR_STATS;
    
    Copy

Status do conector

A exibição REPLICATION_STATE é crucial para monitorar o status da replicação de tabela. Este processo abrange três fases distintas:

  1. SCHEMA_INTROSPECTION: Garante que o esquema da tabela de origem seja replicado com precisão.

  2. INITIAL_LOAD: Transfere os dados existentes da tabela de origem para o destino.

  3. INCREMENTAL_LOAD: Replica continuamente as alterações em andamento da fonte.

Após a replicação bem-sucedida, a exibição de status será semelhante à seguinte:

REPLICATION_PHASE

SCHEMA_INTROSPECTION_STATUS

SNAPSHOT_REPLICATION_STATUS

INCREMENTAL_REPLICATION_STATUS

INCREMENTAL_LOAD

DONE

DONE

IN PROGRESS

É possível ler mais sobre isso na documentação oficial do conector.

Exibição de dados

Execute os seguintes comandos para exibição dados, que devem incluir aproximadamente 3 linhas por banco de dados.

SELECT * FROM CONNECTORS_DEST_DB."psql_rows_schema"."postgres_rows";
SELECT * FROM CONNECTORS_DEST_DB."mysql_ingest_database"."mysql_rows";
Copy

Limpeza e recursos adicionais

Parabéns! Você concluiu com êxito este tutorial.

Para limpar seu ambiente, execute os comandos listados abaixo. Não fazer isso deixará o conector em funcionamento e gerará custos.

Remoção do aplicativo nativo

DROP APPLICATION SNOWFLAKE_CONNECTOR_FOR_POSTGRESQL CASCADE;
DROP APPLICATION SNOWFLAKE_CONNECTOR_FOR_MYSQL CASCADE;
Copy

Remoção de warehouses, funções e usuários

Durante a instalação, vários warehouses, funções e usuários foram criados. Execute as seguintes consultas para descartar esses objetos.

DROP ROLE MYSQL_ADMINISTRATIVE_AGENT_ROLE;
DROP ROLE MYSQL_AGENT_ROLE;

DROP USER MYSQL_AGENT_USER;

DROP WAREHOUSE MYSQL_COMPUTE_WH;
DROP WAREHOUSE MYSQL_OPS_WH;
Copy

Parar contêineres de banco de dados

Para interromper a execução dos contêineres com MySQL e PostgreSQL, navegue até o diretório com os arquivos docker-compose.yaml e execute o docker compose down -v.

Recursos adicionais

Continue aprendendo sobre conectores usando os seguintes recursos: