Aus Cloud SQL in Spanner importieren

Auf dieser Seite wird beschrieben, wie Sie Daten aus Cloud SQL for MySQL in Spanner importieren.

Bei diesem Prozess werden in der Google Cloud -Konsole Befehle in Cloud Shell ausgeführt, mit denen ein Dataflow-Job zum Importieren einer Datenbank aus Cloud SQL in Spanner konfiguriert und ausgeführt wird.

Prozessübersicht

Der Importprozess umfasst Folgendes:

1. Sie führen einen Google Cloud -Konsolenworkflow aus, in dem Sie Informationen zu Ihren Quell- und Zieldatenbanken angeben:
   • Details zur Quelldatenbank: Name der Cloud SQL-Instanz, Datenbankname und Ihre Anmeldedaten.
   • Spanner-Details: Name Ihrer Spanner-Instanz und Name der Datenbank. Mit dem Befehl wird die Datenbank erstellt, falls sie noch nicht vorhanden ist.
   • Ausgabespeicher: Ein Cloud Storage-Bucket-Name zum Speichern von Ausgabedateien.
2. Spanner öffnet Cloud Shell und füllt einen Befehl aus. Mit dem Befehl werden die folgenden Aktionen ausgeführt:
   • Schema migrieren: Mit dem Befehl wird das Schema mit dem Spanner-Migrationstool migriert. Diese Migration wird in Cloud Shell ausgeführt und verwendet eine öffentliche IP-Adresse, um eine Verbindung zu Ihrer Cloud SQL-Instanz herzustellen. Da Cloud Shell sich in einem eigenen Netzwerk befindet, muss über die öffentliche IP-Adresse auf Cloud SQL zugegriffen werden. Sie müssen jedoch keine Subnetze für die öffentliche IP-Adresse auf die Zulassungsliste setzen.
   • Datenmigration starten: Nachdem das Schema migriert wurde, wird mit dem Befehl ein Dataflow-Job für die Datenmigration gestartet. Der Job liest Daten direkt über die private IP-Adresse aus der Quelldatenbank und schreibt sie in Spanner. Dieser Job wird mit dem Compute Engine-Standarddienstkonto ausgeführt. Schließlich wird die Dataflow-Job-URL ausgegeben.

Beschränkungen

Es gelten folgende Einschränkungen:

• Für diesen Datenimport wird nur eine einzelne Cloud SQL for MySQL-Instanz unterstützt.
• Die Schema-Konvertierung erfolgt automatisch. Sie können während dieses Imports keine Anpassungen am Schema vornehmen.
• Bei diesem Datenimport handelt es sich um einen einmaligen Bulk-Load. Eine kontinuierliche Replikation wird nicht unterstützt.

Hinweis

Bevor Sie Ihre Datenbank importieren, müssen Sie die folgenden Voraussetzungen erfüllen:

1. Achten Sie darauf, dass für Ihre Cloud SQL-Instanz eine öffentliche und eine private IP-Adresse aktiviert sind. Weitere Informationen finden Sie unter Öffentliche IP-Verbindungen konfigurieren und Private IP-Adresse konfigurieren.

2. Erstellen Sie einen Nutzer und ein Passwort für Ihre Cloud SQL-Instanz, die zum Abfragen der Datenbank verwendet werden können.

3. Speichern Sie das Passwort in Secret Manager. Sie benötigen die version ID der Secret-Version. Weitere Informationen finden Sie unter Secret erstellen.

4. Sie benötigen einen Cloud Storage-Bucket. Dataflow verwendet diesen Bucket zum Speichern von Konfigurationsdateien und Ausgaben der Dataflow-Jobs.

5. Achten Sie darauf, dass sich Spanner und Cloud SQL im selben Google CloudProjekt befinden.

6. Aktivieren Sie die APIs für Dataflow, Cloud Storage, Spanner, Cloud SQL und Secret Manager.

   Rollen, die zum Aktivieren von APIs erforderlich sind

   Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Weitere Informationen zum Zuweisen von Rollen

   APIs aktivieren

Erforderliche Rollen

Bitten Sie Ihren Administrator, dem Compute Engine-Standarddienstkonto die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, damit das Compute Engine-Standarddienstkonto die erforderlichen Berechtigungen zum Ausführen des Dataflow-Jobs hat:

Wichtig:Sie müssen diese Rollen dem Compute Engine-Standarddienstkonto und nicht Ihrem Nutzerkonto zuweisen. Wenn die Rollen nicht dem richtigen Hauptkonto zugewiesen werden, können Berechtigungsfehler auftreten.

• Zugriffsperson für Secret Manager-Secret (roles/secretmanager.secretAccessor)
• Cloud SQL-Client (roles/cloudsql.client)
• Cloud Spanner-Datenbank-Administrator (roles/spanner.databaseAdmin)
• Storage-Objekt-Administrator (roles/storage.objectAdmin)
• Dataflow-Worker (roles/dataflow.worker)

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, damit Sie die nötigen Berechtigungen für die Konfiguration des Imports haben:

• Cloud SQL-Client (roles/cloudsql.client)
• Cloud Spanner-Datenbank-Administrator (roles/spanner.databaseAdmin)
• Zugriffsperson für Secret Manager-Secret (roles/secretmanager.secretAccessor)
• Storage-Administrator (roles/storage.admin)
• Dataflow-Entwickler (roles/dataflow.developer)
• Service Account User (roles/iam.serviceAccountUser)

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Konfigurieren des Imports erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen, um die notwendigen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um den Import zu konfigurieren:

• cloudsql.instances.connect
• cloudsql.instances.get
• cloudsql.instances.login
• spanner.instances.list
• spanner.instances.get
• spanner.databases.create
• spanner.databases.list
• spanner.databases.get
• spanner.databases.getDdl
• spanner.databases.updateDdl
• spanner.databases.read
• spanner.databases.write
• spanner.databases.select
• secretmanager.versions.access
• storage.objects.create
• storage.objects.get
• storage.buckets.get
• dataflow.jobs.create
• dataflow.jobs.get
• dataflow.jobs.list
• iam.serviceAccounts.actAs

Kontingentanforderungen

Es gelten die folgenden Kontingentanforderungen:

• Spanner: Sie müssen für die zu importierenden Daten ausreichend Rechenkapazität haben. Wir empfehlen, mit mindestens einem Spanner-Knoten zu beginnen. Möglicherweise müssen Sie zusätzliche Rechenkapazität hinzufügen, damit der Job in angemessener Zeit abgeschlossen werden kann. Für den Import eines Datenbankschemas ist keine zusätzliche Rechenkapazität erforderlich. Weitere Informationen finden Sie unter Autoscaling.
• Dataflow: Für Importjobs gelten dieselben Compute Engine-Kontingente für CPU, Laufwerksnutzung und IP-Adressen wie für andere Dataflow-Jobs.

• Compute Engine: Bevor Sie den Importjob ausführen, müssen Sie Kontingente für Compute Engine einrichten, die von Dataflow verwendet werden. Diese Kontingente stellen die maximale Anzahl an Ressourcen dar, die Dataflow für Ihren Job verwenden darf. Empfohlene Anfangswerte sind:

  • CPUs: 200
  • Verwendete IP-Adressen: 200
  • Nichtflüchtiger Standardspeicher: 50 TB

  In der Regel sind keine weiteren Anpassungen erforderlich. Dataflow bietet Autoscaling, sodass Sie nur für die Ressourcen zahlen, die beim Import tatsächlich verwendet werden. Wenn Ihr Job mehr Ressourcen verwenden kann, wird in der Dataflow-UI ein Warnsymbol angezeigt. Der Job kann trotz dieses Warnsymbols beendet werden.

Aus Cloud SQL in Spanner importieren

So importieren Sie eine Cloud SQL for MySQL-Datenbank in Spanner: Google Cloud

1. Rufen Sie die Spanner-Seite Instanzen auf.

   Zur Seite "Instanzen"

2. Klicken Sie auf den Namen der Instanz, in die die Datenbank importiert werden soll.

3. Klicken Sie auf die Schaltfläche Aus Cloud SQL importieren.

4. Nachdem Spanner überprüft hat, ob alle erforderlichen APIs aktiviert sind, klicken Sie auf die Schaltfläche Weiter.

5. Wählen Sie die Cloud SQL for MySQL-Instanz aus, die importiert werden soll, und klicken Sie auf die Schaltfläche Weiter.

6. Wählen Sie die Datenbank aus, die Sie importieren möchten, und klicken Sie auf die Schaltfläche Weiter. Spanner prüft, ob die öffentliche IP-Adresse für Ihre Cloud SQL-Instanz aktiviert ist.

7. Geben Sie den Nutzernamen und das Secret ein und klicken Sie auf die Schaltfläche Weiter.

8. Suchen Sie nach dem Cloud Storage-Bucket und wählen Sie ihn aus. Klicken Sie dann auf die Schaltfläche Weiter.

9. Geben Sie den Namen der Spanner-Datenbank ein und klicken Sie auf die Schaltfläche Importieren. Spanner öffnet Cloud Shell und füllt einen Befehl ein.

10. Führen Sie den automatisch eingefügten Befehl aus, um den Import zu starten:

    export SOURCE_PROJECT_NUMBER=$(gcloud projects describe \
        "SOURCE_PROJECT_ID" \
        --format="value(projectNumber)") && \
    export GSA_EMAIL="${SOURCE_PROJECT_NUMBER}[e-mail]" && \
    echo "Verifying permissions for ${GSA_EMAIL}..." && \
    export CURRENT_ROLES=$(gcloud projects get-iam-policy \
        "SOURCE_PROJECT_ID" \
        --flatten="bindings[].members" \
        --filter="bindings.members:serviceAccount:${GSA_EMAIL}" \
        --format="value(bindings.role)") && \
    ERR=0 && \
    for ROLE in roles/secretmanager.secretAccessor \
        roles/cloudsql.client roles/spanner.databaseAdmin \
        roles/storage.objectAdmin roles/dataflow.worker; do \
      if echo "${CURRENT_ROLES}" | awk -v r="$ROLE" '$1 == r {found=1} END {exit 1-found}'; then \
        echo "[OK] $ROLE"; \
      else \
        echo "[MISSING] $ROLE. Run: gcloud projects add-iam-policy-binding SOURCE_PROJECT_ID --member='serviceAccount:${GSA_EMAIL}' --role='${ROLE}'"; \
        ERR=1; \
      fi; \
    done && \
    [[ "$ERR" -eq 0 ]] && \
    export JOB_NAME="csql-to-spanner-$(date +%Y%m%d-%H%M%S)" && \
    export OUTPUT_DIR="gs://BUCKET_NAME/output/${JOB_NAME}" && \
    export SHARD_CONFIG_PATH="gs://BUCKET_NAME/config/${JOB_NAME}_shard_config.json" && \
    export WORKER_MACHINE_TYPE="n2-highmem-8" && \
    export TEMPLATE_PATH="gs://dataflow-templates/latest/flex/Sourcedb_to_Spanner_Flex" && \
    export SHARD_CONFIG_JSON='{
      "shardConfigurationBulk": {
        "dataShards": [
          {
            "host": "SOURCE_PRIVATE_IP",
            "port": "3306",
            "user": "SOURCE_DATABASE_USER",
            "secretManagerUri": "projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION",
            "databases": [
              {
                "dbName": "SOURCE_DATABASE_NAME",
                "databaseId": "SOURCE_DATABASE_NAME"
              }
            ]
          }
        ]
      }
    }' && \
    echo "${SHARD_CONFIG_JSON}" | gcloud storage cp - "${SHARD_CONFIG_PATH}" && \
    sudo apt-get update && \
    sudo apt-get install google-cloud-cli-spanner-migration-tool -y && \
    gcloud alpha spanner migrate schema \
        --source=mysql \
        --source-profile="project=SOURCE_PROJECT_ID,instance=SOURCE_INSTANCE_NAME,secretManagerUri=projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION,dbName=SOURCE_DATABASE_NAME,region=SOURCE_REGION,user=SOURCE_DATABASE_USER" \
        --target-profile="instance=SPANNER_INSTANCE_ID,project=SPANNER_PROJECT_ID,dbName=SPANNER_DATABASE_ID" && \
    JOB_OUTPUT=$(gcloud dataflow flex-template run "${JOB_NAME}" \
        --project="SOURCE_PROJECT_ID" \
        --region="SOURCE_REGION" \
        --template-file-gcs-location="${TEMPLATE_PATH}" \
        --network="NETWORK_NAME" \
        --subnetwork="https://www.googleapis.com/compute/v1/projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/subnetworks/SUBNETWORK_NAME" \
        --worker-machine-type="${WORKER_MACHINE_TYPE}" \
        --parameters "instanceId=SPANNER_INSTANCE_ID" \
        --parameters "databaseId=SPANNER_DATABASE_ID" \
        --parameters "projectId=SPANNER_PROJECT_ID" \
        --parameters "sourceConfigURL=${SHARD_CONFIG_PATH}" \
        --parameters "sourceDbDialect=MYSQL" \
        --parameters "jdbcDriverClassName=com.mysql.jdbc.Driver" \
        --parameters "outputDirectory=${OUTPUT_DIR}" \
        --format="get(job.id)") && \
    echo "--------------------------------------------------------" && \
    echo "Dataflow Job Submitted." && \
    echo "Monitor: https://console.cloud.google.com/dataflow/jobs/SOURCE_REGION/${JOB_OUTPUT}?project=SOURCE_PROJECT_ID" && \
    echo "--------------------------------------------------------"
    

    Die folgenden Parameter werden von der Google Cloud Console an den Befehl übergeben:

    • SOURCE_DATABASE_NAME: der Name der Cloud SQL-Quelldatenbank
    • SOURCE_DATABASE_USER: der Nutzername für die Cloud SQL-Quelldatenbank
    • PROJECT_ID: Ihre Google Cloud Projekt-ID
    • SECRET_ID: Die ID des Secrets, das das Passwort enthält.
    • VERSION: die Version des Secrets
    • SOURCE_PROJECT_ID: die Projekt-ID mit der Cloud SQL-Quellinstanz
    • SOURCE_REGION: die Region der Cloud SQL-Quellinstanz
    • SOURCE_INSTANCE_NAME: der Name der Cloud SQL-Quellinstanz
    • SOURCE_PRIVATE_IP: die private IP-Adresse der Cloud SQL-Instanz
    • NETWORK_NAME: Der Netzwerkname der Cloud SQL-Quellinstanz.
    • SUBNETWORK_NAME: Der Name des Subnetzwerks der Cloud SQL-Quellinstanz.
    • SPANNER_PROJECT_ID: Die Projekt-ID, die die Ziel-Spanner-Instanz enthält
    • SPANNER_INSTANCE_ID: die ID der Ziel-Spanner-Instanz
    • SPANNER_DATABASE_ID: Die ID der Spanner-Zieldatenbank, die von Spanner erstellt wird, falls sie nicht vorhanden ist
    • BUCKET_NAME: der Name des Cloud Storage-Buckets zum Speichern von Dataflow-Ausgabedateien und Konfigurationsdateien

    Mit dem Befehl wird geprüft, ob das Standarddienstkonto für Compute die erforderlichen Berechtigungen hat. Außerdem wird das Spanner-Migrations-Tool installiert, das Schema migriert und der Dataflow-Job gestartet.

    Klicken Sie nach Abschluss des Befehls auf den bereitgestellten Link, um den Dataflow-Job in der Google Cloud Console zu überwachen.

Weitere Informationen

• Schema aktualisieren