Note

Les connecteurs Snowflake Connector for PostgreSQL et Snowflake Connector for MySQL sont soumis aux Conditions des connecteurs.

Utilisation de MySQL et PostgreSQL Connectors pour Snowflake

Introduction

Bienvenue dans notre didacticiel sur l’utilisation des connecteurs de base de données Snowflake. Ce guide vous aidera à transférer en toute transparence des données de bases de données relationnelles vers Snowflake.

Dans ce didacticiel, vous allez apprendre à maîtriser les opérations suivantes :

  • Configuration de MySQL et de PostgreSQL dans Docker, avec des échantillons de données pour l’ingestion.

  • Installation et configuration de deux applications natives, une pour chaque base de données.

  • Configuration et réglage fin de deux agents, encore une fois un pour chaque base de données.

  • Lancement et démarrage des processus d’ingestion de données.

  • Surveillance du flux de travail d’ingestion de données.

C’est parti !

Conditions préalables

Avant de démarrer ce didacticiel, vérifiez que les conditions suivantes sont remplies :

  • Docker est installé et opérationnel sur votre poste local.

  • Vous disposez d’un outil permettant de vous connecter à la base de données. Il peut s’agir d’un outil spécifique à une base de données ou d’un outil à usage général tel que IntelliJ ou Visual Studio Code.

Création de bases de données sources MySQL et PostgreSQL

Dans cette section, nous allons vous guider tout au long des étapes suivantes :

Démarrage des instances de base de données

Pour démarrer le processus de configuration des bases de données MySQL et PostgreSQL à l’aide de Docker, créez le fichier docker-compose.yaml. Le contenu du fichier doit ressembler à ceci :

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

Une fois votre docker-compose.yaml prêt, procédez comme suit :

  1. Ouvrez un terminal.

  2. Accédez au répertoire contenant le fichier docker-compose.yaml.

  3. Exécutez la commande suivante pour démarrer les bases de données sources dans les conteneurs :

    docker compose up -d
    
    Copy

Après avoir exécuté cette commande, vous devriez voir deux conteneurs exécutant activement les bases de données sources.

Connexion à la base de données

Pour se connecter aux bases de données préconfigurées à l’aide de connexions de base de données IntelliJ ou Visual Studio Code, procédez comme suit à l’aide des identifiants de connexion fournis :

  1. Ouvrez l’outil de votre choix pour vous connecter à MySQL.

  2. Cliquez sur le signe « + » ou similaire pour ajouter une source de données.

  3. Fournissez les informations de connexion :

    • Utilisateur : root

    • Mot de passe : mysql

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

  4. Testez la connexion et enregistrez.

Chargement des échantillons de données

Pour initialiser et charger les échantillons, exécutez ces scripts dans ces connexions.

Exécuter le script pour générer les échantillons de données

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

Vous devriez voir trois lignes dans chaque base de données renseignée.

Installer et configurer Native App

Au cours de cette étape, vous allez :

Installer Native Applications

Procédez comme suit pour installer l’application à partir de Snowflake Native Apps Marketplace :

  1. Connectez-vous à Snowsight.

  2. Dans le menu de navigation, sélectionnez Data Products » Marketplace.

  3. Installez les applications Snowflake Connector pour MySQL et Snowflake Connector pour PostgreSQL.

  4. Installez les deux applications.

Après l’installation, vous verrez les nouvelles applications répertoriées dans Data Products » Apps.

Configurer Native Applications

  1. Connectez-vous à Snowsight.

  2. Dans le menu de navigation, sélectionnez Data Products » Apps.

  3. Ouvrez chaque application et procédez comme suit :

  1. Sélectionnez Download Driver ` et enregistrez le fichier. Le nom de fichier ressemblera à mariadb-java-client-3.4.1.jar ou à une version plus récente si elle est disponible. Enregistrez ce fichier pour pouvoir l’utiliser lors de la configuration de l’agent.

  2. Sélectionnez Mark all as done, car nous allons créer et renseigner des bases de données sources à partir de rien.

    Note

    Aucune configuration réseau supplémentaire n’est requise à ce stade, car nous configurerons l’agent ultérieurement dans le didacticiel.

  3. Cliquez sur Start configuration.

  4. Sur l’écran Configure Connector, sélectionnez Configure. La page Verify Agent Connection s’affiche.

  5. Sélectionnez Generate file pour générer un fichier de configuration d’agent. Le nom de fichier doit ressembler à snowflake.json. Enregistrez ce fichier à des fins d’utilisation ultérieure à la section Configuration de l’Agent.

Configurer les agents

Dans cette section, nous allons configurer l’agent qui fonctionnera avec vos bases de données sources.

La première étape consiste à créer les répertoires agent-mysql et agent-postgresql.

Dans chaque répertoire, créez les sous-répertoires agent-keys et configuration. La structure de vos répertoires doit ressembler à ceci :

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

Création des fichiers de configuration

Dans cette section, nous allons ajouter du contenu aux fichiers de configuration pour que chaque agent fonctionne correctement. Les fichiers de configuration incluent :

  • Le fichier snowflake.json pour se connecter à Snowflake.

  • Le fichier datasources.json pour se connecter aux bases de données sources.

  • Les fichiers postgresql.conf/mysql.conf avec des variables d’environnement d’agent supplémentaires.

  • Le fichier du pilote JDBC pour l’agent MySQL.

  1. Sur un terminal, accédez au répertoire agent-mysql.

  2. Créez le fichier Docker Compose docker-compose.yaml avec le contenu suivant :

    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. Déplacez le fichier snowflake.json précédemment téléchargé dans le répertoire configuration.

  4. Déplacez le fichier mariadb-java-client-3.4.1.jar précédemment téléchargé dans le répertoire configuration.

  5. Dans le répertoire configuration, créez datasources.json avec le contenu :

    {
      "MYSQLDS1": {
        "url": "jdbc:mariadb://host.docker.internal:3306/?allowPublicKeyRetrieval=true&useSSL=false",
        "username": "root",
        "password": "mysql",
        "ssl": false
      }
    }
    
    Copy
  6. Dans le répertoire configuration, créez mysql.conf avec le contenu :

    JAVA_OPTS=-Xmx5g
    MYSQL_DATASOURCE_DRIVERPATH=/home/agent/libs/mariadb-java-client-3.4.1.jar
    
    Copy
  7. Démarrez l’agent à l’aide de la commande suivante. Il ne devrait y avoir aucun message d’erreur et l’agent devrait générer une paire de clés publique et privée pour l’authentification auprès de 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. Notez que le nom du fichier jar du pilote doit être identique à celui téléchargé et utilisé dans les fichiers docker-compose.yaml et mysql.conf.

Une fois terminé, la structure de votre répertoire devrait ressembler à ce qui suit. Notez l’inclusion des clés privées et publiques automatiquement générées dans les répertoires 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

Vérification de la connexion auprès de Snowflake

Revenez aux applications natives précédemment créées. Cliquez sur le bouton Actualiser à la section Connexion de l’Agent.

Une fois la configuration correctement terminée, vous devriez voir :

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

Configurer et surveiller le processus d’ingestion de données

À cette étape, nous allons demander au connecteur de commencer à répliquer les tables sélectionnées. Tout d’abord, créons une base de données de récepteur partagée dans 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

Une fois la base de données prête, nous pouvons passer au processus de configuration.

  1. Pour démarrer la réplication de tables, vous devez commencer par ajouter une source de données à partir de laquelle effectuer la réplication, puis spécifier la table à répliquer.

    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. Pour surveiller la réplication, exécutez les requêtes suivantes :

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

Comprendre le statut du connecteur

La vue REPLICATION_STATE est essentielle pour surveiller le statut de réplication des tables. Ce processus comprend trois phases distinctes :

  1. SCHEMA_INTROSPECTION : garantit la réplication correcte du schéma de la table source.

  2. INITIAL_LOAD : transfère les données existantes de la table source vers la destination.

  3. INCREMENTAL_LOAD : réplique en continu les modifications en cours à partir de la source.

Une fois la réplication correctement effectuée, l’affichage du statut ressemblera à ce qui suit :

REPLICATION_PHASE

SCHEMA_INTROSPECTION_STATUS

SNAPSHOT_REPLICATION_STATUS

INCREMENTAL_REPLICATION_STATUS

INCREMENTAL_LOAD

DONE

DONE

IN PROGRESS

Vous trouverez plus d’informations à ce sujet dans la Documentation officielle du connecteur.

Affichage des données

Exécutez les commandes suivantes pour afficher les données, qui doivent inclure environ 3 lignes par base de données.

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

Nettoyage et ressources supplémentaires

Félicitations ! Vous avez terminé ce tutoriel.

Pour nettoyer votre environnement, exécutez les commandes répertoriées ci-dessous. Sinon, le connecteur risque de continuer à fonctionner et de générer des coûts.

Retrait de l’application native

DROP APPLICATION SNOWFLAKE_CONNECTOR_FOR_POSTGRESQL CASCADE;
DROP APPLICATION SNOWFLAKE_CONNECTOR_FOR_MYSQL CASCADE;
Copy

Retrait d’entrepôts, de rôles et d’utilisateurs

Lors de l’installation, plusieurs entrepôts, rôles et utilisateurs ont été créés. Exécutez les requêtes suivantes pour abandonner ces objets.

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

Arrêt des conteneurs de base de données

Pour arrêter l’exécution des conteneurs avec MySQL et PostgreSQL, accédez au répertoire contenant les fichiers docker-compose.yaml, puis exécutez docker compose down -v.

Ressources supplémentaires

Découvrez-en plus sur les connecteurs en consultant les ressources suivantes :