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 wird Cloud Shell in der Google Cloud -Konsole verwendet, um Befehle auszuführen, 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 durchlaufen einen Google Cloud -Konsolenworkflow, 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: Der Name eines Cloud Storage-Bucket zum Speichern von Ausgabedateien.
2. Spanner öffnet Cloud Shell und füllt einen Befehl ein. Mit dem Befehl werden die folgenden Aktionen ausgeführt:
   • Schema migrieren: Mit dem Befehl wird das Schema mit dem Cloud 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 es über die öffentliche IP-Adresse auf Cloud SQL zugreifen. 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 Schemakonvertierung erfolgt automatisch. Sie können das Schema während dieses Imports nicht anpassen.
• 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 die folgenden Voraussetzungen erfüllt sein:

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-Verbindung 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. Prüfen Sie, ob Sie einen Cloud Storage-Bucket haben. 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 Cloud-Projekt befinden.

6. Aktivieren Sie die Dataflow-, Cloud Storage-, Spanner-, Cloud SQL- und Secret Manager-APIs, falls sie noch nicht aktiviert sind.

   Rollen, die zum Aktivieren von APIs erforderlich sind

   Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. 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, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren des Imports benötigen:

• 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 benötigen genügend Rechenkapazität, um die Menge der Daten zu verarbeiten, die Sie importieren. Wir empfehlen, mit mindestens einem Spanner-Knoten zu beginnen. Möglicherweise müssen Sie zusätzliche Rechenkapazität hinzufügen, damit Ihr Job in angemessener Zeit abgeschlossen wird. 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 Ihren Importjob ausführen, müssen Sie anfängliche 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

  Normalerweise müssen Sie keine weiteren Anpassungen vornehmen. 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 auch dann abgeschlossen werden, wenn ein Warnsymbol angezeigt wird.

Aus Cloud SQL in Spanner importieren

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

1. Rufen Sie die Seite Instanzen für Spanner 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 bestätigt hat, dass alle erforderlichen APIs aktiviert sind, klicken Sie auf den Button 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, wählen Sie ihn aus und klicken Sie dann auf den Button Weiter.

9. Geben Sie den Namen der Spanner-Datenbank ein und klicken Sie auf den Button Importieren. Spanner öffnet Cloud Shell und fügt 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, die die Cloud SQL-Quellinstanz enthält
    • 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 Compute Engine-Standarddienstkonto die erforderlichen Berechtigungen hat. Außerdem wird das Spanner-Migrations-Tool installiert, das Schema migriert und der Dataflow-Job gestartet.

    Wenn der Befehl abgeschlossen ist, folgen Sie dem bereitgestellten Link, um den Dataflow-Job in der Google Cloud Console zu überwachen.

Weitere Informationen

• Informationen zum Aktualisieren des Schemas