Bemerkung

Snowflake Connector for PostgreSQL und Snowflake Connector for MySQL unterliegen den Nutzungsbedingungen für Konnektoren.

Verwenden von MySQL- und PostgreSQL-Konnektoren für Snowflake

Einführung

Willkommen bei unserem Tutorial zur Verwendung der Snowflake Database Connectors. Diese Anleitung hilft Ihnen, Daten aus relationalen Datenbanken nahtlos in Snowflake zu übertragen.

In diesem Tutorial lernen Sie, wie Sie:

  • MySQL und PostgreSQL in Docker einrichten, vollständig mit Beispieldaten für die Datenaufnahme.

  • Installieren und konfigurieren Sie zwei native Anwendungen, eine für jede Datenbank.

  • Richten Sie zwei Agenten ein, und nehmen Sie eine Feinabstimmung vor, wiederum einen für jede Datenbank.

  • Initiieren und verwalten Sie die Datenaufnahmeprozesse.

  • Überwachen Sie den Workflow der Datenaufnahme.

Fangen wir an!

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, sollten Sie sicherstellen, dass Sie die folgenden Anforderungen erfüllen:

  • Docker ist auf Ihrem lokalen Rechner installiert und betriebsbereit.

  • Sie haben ein Tool zur Verbindung mit der Datenbank zur Verfügung. Dies kann ein datenbankspezifisches Tool oder ein allgemeines Tool wie IntelliJ oder Visual Studio Code sein.

Erstellen von MySQL- und PostgreSQL-Quelldatenbanken

In diesem Abschnitt werden wir Sie durch die folgenden Schritte führen:

Starten der Datenbank-Instanzen

Um die Konfiguration der MySQL- und PostgreSQL-Datenbanken mit Docker zu beginnen, erstellen Sie die Datei docker-compose.yaml. Der Inhalt der Datei sollte so aussehen:

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

Sobald Ihre docker-compose.yaml fertig ist, folgen Sie diesen Schritten:

  1. Öffnen Sie ein Terminal.

  2. Navigieren Sie zu dem Verzeichnis, das die Datei docker-compose.yaml enthält.

  3. Führen Sie den folgenden Befehl aus, um Quelldatenbanken in Containern zu starten:

    docker compose up -d
    Copy

Nachdem Sie diesen Befehl ausgeführt haben, sollten Sie zwei Container sehen, in denen die Quelldatenbanken aktiv ausgeführt werden.

Verbindung zur Datenbank herstellen

Um eine Verbindung zu den vorkonfigurierten Datenbanken herzustellen, indem Sie die Datenbankverbindungen von IntelliJ oder Visual Studio Code verwenden, führen Sie die folgenden Schritte mit den bereitgestellten Anmeldeinformationen aus:

  1. Öffnen Sie das Tool Ihrer Wahl für die Verbindung mit MySQL.

  2. Klicken Sie auf das ‚+‘-Zeichen oder Ähnliches, um eine Datenquelle hinzuzufügen.

  3. Geben Sie die Details der Verbindung ein:

    • Benutzer: root

    • Kennwort: mysql

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

  4. Testen Sie die Verbindung, und speichern Sie.

Laden von Beispieldaten

Um das Beispiel zu initialisieren und zu laden, führen Sie diese Skripte in diesen Verbindungen aus.

Führen Sie das Skript aus, um Beispieldaten zu erzeugen

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

Sie sollten drei Zeilen in jeder befüllten Datenbank sehen.

Installieren und konfigurieren Sie die Native App

Während dieses Schritts werden Sie:

Native Applications installieren

Folgen Sie diesen Schritten, um die Anwendung vom Snowflake Native Apps Marketplace zu installieren:

  1. Melden Sie sich bei Snowsight an.

  2. Wählen Sie im Navigationsmenü die Option Data Products » Marketplace aus.

  3. Installieren Sie die Anwendungen Snowflake Connector für MySQL und Snowflake Connector für PostgreSQL.

  4. Installieren Sie beide Anwendungen.

Nach der Installation sehen Sie die neuen Anwendungen in der Liste unter Data Products » Apps.

Native Applications konfigurieren

  1. Melden Sie sich bei Snowsight an.

  2. Wählen Sie im Navigationsmenü die Option Data Products » Apps aus.

  3. Öffnen Sie jede Anwendung, und gehen Sie wie folgt vor:

  1. Wählen Sie Download Driver , und speichern Sie die Datei. Der Name der Datei ähnelt :file:`mariadb-java-client-3.4.1.jar oder einer neueren Version, sofern verfügbar. Speichern Sie diese Datei zur Verwendung bei der Konfiguration des Agenten.

  2. Wählen Sie Mark all as done, da wir die Quelldatenbanken von Grund auf neu erstellen und befüllen werden.

    Bemerkung

    An dieser Stelle ist keine zusätzliche Konfiguration des Netzwerks erforderlich, da wir den Agenten später im Tutorial konfigurieren werden.

  3. Klicken Sie auf Start configuration.

  4. Wählen Sie auf dem Bildschirm Configure Connector die Option Configure aus. Die Seite Verify Agent Connection wird angezeigt.

  5. Wählen Sie Generate file, um eine Datei für die Konfiguration des Agenten zu erstellen. Der Name der Datei sollte snowflake.json ähneln. Speichern Sie diese Datei zur späteren Verwendung im Abschnitt zur Konfiguration der Agenten.

Konfigurieren der Agenten

In diesem Abschnitt konfigurieren wir den Agenten, der mit Ihren Quelldatenbanken arbeiten soll.

Der erste Schritt besteht darin, die Verzeichnisse agent-mysql und agent-postgresql zu erstellen.

Erstellen Sie innerhalb jedes Verzeichnisses die Unterverzeichnisse agent-keys und configuration. Die Struktur Ihres Verzeichnisses sollte folgendermaßen aussehen:

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

Erstellen von Dateien für die Konfiguration

In diesem Abschnitt fügen wir den Konfigurationsdateien Inhalte hinzu, damit die einzelnen Agenten korrekt funktionieren. Die Dateien für die Konfiguration umfassen:

  • snowflake.json-Datei, um eine Verbindung zu Snowflake herzustellen.

  • datasources.json-Datei, um eine Verbindung zu den Quelldatenbanken herzustellen.

  • postgresql.conf/mysql.conf-Dateien mit zusätzlichen Umgebungsvariablen des Agenten.

  • JDBC-Datei mit Treibern für den MySQL-Agenten.

  1. Navigieren Sie in einem Terminal zum Verzeichnis agent-mysql.

  2. Erstellen Sie die Docker Compose-Datei docker-compose.yaml mit dem folgenden Inhalt:

    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. Verschieben Sie die zuvor heruntergeladene snowflake.json-Datei in das Verzeichnis configuration.

  4. Verschieben Sie die zuvor heruntergeladene mariadb-java-client-3.4.1.jar-Datei in das Verzeichnis configuration.

  5. Erstellen Sie im Verzeichnis configuration datasources.json mit dem Inhalt:

    {
  "MYSQLDS1": {
    "url": "jdbc:mariadb://host.docker.internal:3306/?allowPublicKeyRetrieval=true&useSSL=false",
    "username": "root",
    "password": "mysql",
    "ssl": false
  }
}
    Copy

  6. Erstellen Sie im Verzeichnis configuration mysql.conf mit dem Inhalt:

    JAVA_OPTS=-Xmx5g
MYSQL_DATASOURCE_DRIVERPATH=/home/agent/libs/mariadb-java-client-3.4.1.jar
    Copy

  7. Starten Sie den Agenten mit folgendem Befehl. Es sollte zu keiner Fehlermeldung kommen, und der Agent sollte ein Schlüsselpaar aus öffentlichem und privatem Schlüssel für die Authentifizierung bei Snowflake erzeugen.

    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. Bitte beachten Sie, dass der Name der Treiber jar-Datei identisch sein muss mit dem Namen, der in den Dateien docker-compose.yaml und mysql.conf verwendet wird.

Wenn Sie fertig sind, sollte Ihre Verzeichnisstruktur wie folgt aussehen. Bitte beachten Sie die Aufnahme der automatisch generierten privaten und öffentlichen Schlüssel in die Verzeichnisse der Agent-Schlüssel.

.
├── 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

Überprüfen der Verbindung mit Snowflake

Gehen Sie zurück zu Ihren zuvor erstellten Native Apps. Klicken Sie auf die Schaltfläche Aktualisieren im Abschnitt Agent-Verbindung.

Nach erfolgreicher Konfiguration sollten Sie sehen:

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

Konfigurieren und überwachen Sie den Datenaufnahmeprozess

In diesem Schritt weisen wir den Konnektor an, mit der Replikation der ausgewählten Tabellen zu beginnen. Lassen Sie uns zunächst eine gemeinsame Datenbank in Snowflake erstellen.

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

Sobald die Datenbank fertig ist, können wir mit der Konfiguration fortfahren.

  1. Um mit der Replikation von Tabellen zu beginnen, müssen Sie zunächst eine Datenquelle hinzufügen, von der aus repliziert werden soll, und dann die Tabelle angeben, die repliziert werden soll.

    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. Um die Replikation zu überwachen, führen Sie die folgenden Abfragen aus:

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

Erläuterungen zum Status des Konnektors

Die Ansicht REPLICATION_STATE ist entscheidend für die Überwachung des Status der Tabellenreplikation. Dieser Prozess besteht aus drei verschiedenen Phasen:

  1. SCHEMA_INTROSPECTION: Stellt sicher, dass das Schema der Quelltabelle genau repliziert wird.

  2. INITIAL_LOAD: Überträgt die vorhandenen Daten aus der Quelltabelle in die Zieltabelle.

  3. INCREMENTAL_LOAD: Repliziert fortlaufend die laufenden Änderungen von der Quelle.

Nach erfolgreicher Replikation sieht die Statusanzeige wie folgt aus:

REPLICATION_PHASE

SCHEMA_INTROSPECTION_STATUS

SNAPSHOT_REPLICATION_STATUS

INCREMENTAL_REPLICATION_STATUS

INCREMENTAL_LOAD

DONE

DONE

IN PROGRESS

Mehr dazu finden Sie in der offiziellen Dokumentation zum Konnektor .

Daten anzeigen

Führen Sie die folgenden Befehle aus, um die Daten anzuzeigen, die etwa 3 Zeilen pro Datenbank umfassen sollten.

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

Bereinigen und zusätzliche Ressourcen

Herzlichen Glückwunsch! Sie haben dieses Tutorial erfolgreich abgeschlossen.

Um Ihre Umgebung zu bereinigen, führen Sie die unten aufgeführten Befehle aus. Wenn Sie dies nicht tun, bleibt der Konnektor in Betrieb und verursacht Kosten.

Entfernen der Native App

DROP APPLICATION SNOWFLAKE_CONNECTOR_FOR_POSTGRESQL CASCADE;
DROP APPLICATION SNOWFLAKE_CONNECTOR_FOR_MYSQL CASCADE;
Copy

Entfernen von Warehouses, Rollen und Benutzern

Während der Installation wurden mehrere Warehouses, Rollen und Benutzer erstellt. Führen Sie die folgenden Abfragen aus, um diese Objekte zu löschen.

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

Anhalten von Datenbank-Containern

Um die laufenden Container mit MySQL und PostgreSQL zu stoppen, navigieren Sie zu dem Verzeichnis, das die Dateien docker-compose.yaml enthält, und führen Sie dann docker compose down -v aus.

Zusätzliche Ressourcen

Erfahren Sie mehr über Konnektoren mithilfe der folgenden Ressourcen:

Sprache: Deutsch