Aus Cloud SQL in Spanner importieren

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

Dabei wird Cloud Shell in der Google Cloud Console verwendet, um Befehle auszuführen, mit denen ein Dataflow Job konfiguriert und ausgeführt wird, um eine Datenbank aus Cloud SQL in Spanner zu importieren.

Prozessübersicht

Der Importprozess umfasst Folgendes:

  1. Sie führen einen Google Cloud Console-Workflow 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 der Spanner-Instanz und Datenbankname. Mit dem Befehl wird die Datenbank erstellt, falls sie noch nicht vorhanden ist.
    • Ausgabespeicher: Name eines Cloud Storage-Bucket 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 sich Cloud Shell in einem eigenen Netzwerk befindet, muss sie über die öffentliche IP-Adresse auf Cloud SQL zugreifen können. Sie müssen jedoch keine Subnetze auf die Zulassungsliste der öffentlichen IP-Adresse setzen.
    • Datenmigration starten: Nachdem das Tool das Schema migriert hat, startet der Befehl einen Dataflow-Job für die Datenmigration. Der Job liest Daten direkt aus der Quelldatenbank über ihre private IP-Adresse und schreibt sie in Spanner. Dieser Job wird mit dem Compute Engine-Standarddienstkonto ausgeführt. Schließlich gibt der Befehl die Dataflow-Job-URL aus.

Beschränkungen

Es gelten folgende Einschränkungen:

  • Dieser Datenimport unterstützt nur eine einzelne Cloud SQL for MySQL-Instanz.
  • Die Schemaumwandlung erfolgt automatisch. Sie können während dieses Imports keine Anpassungen am Schema vornehmen.
  • Dieser Datenimport ist ein einmaliger Bulk-Load und unterstützt keine kontinuierliche Replikation.

Hinweis

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

  1. Ihre Cloud SQL-Instanz muss eine öffentliche und eine private IP-Adresse haben. 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. Spanner und Cloud SQL müssen sich im selben Google Cloud Projekt befinden.

  6. Aktivieren Sie die Dataflow API, die Cloud Storage API, die Spanner API, die Cloud SQL API und die Secret Manager API.

    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 es die erforderlichen Berechtigungen zum Ausführen des Dataflow-Jobs hat:

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren des Imports benötigen:

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

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Konfigurieren des Imports erforderlich:

  • 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 benötigen Sie weitere Rechenkapazität, 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 CPU-, Laufwerksnutzungs- und IP-Adressen- Compute Engine-Kontingente wie für andere Dataflow-Jobs.

  • Compute Engine: Bevor Sie den Importjob ausführen, müssen Sie die anfänglichen Kontingente festlegen für Compute Engine, 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

    Im Allgemeinen 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 in der Console: Google Cloud

  1. Rufen Sie die Seite Instanzen von 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 geprü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 Sie importieren möchten, und klicken Sie dann auf die Schaltfläche Weiter.

  6. Wählen Sie die Datenbank aus, die Sie importieren möchten, und klicken Sie dann 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 dann auf die Schaltfläche Weiter.

  8. Suchen Sie den 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 dann auf die Schaltfläche Importieren. Spanner öffnet Cloud Shell und füllt einen Befehl aus.

  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}-compute@developer.gserviceaccount.com" && \
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 Subnetzwerkname der Cloud SQL-Quellinstanz
    • SPANNER_PROJECT_ID: die Projekt-ID, die die Spanner-Zielinstanz enthält
    • SPANNER_INSTANCE_ID: die ID der Spanner-Zielinstanz
    • 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

    Der Befehl prüft, ob das Compute Engine-Standarddienstkonto die erforderlichen Berechtigungen hat, installiert das Spanner-Migrationstool, migriert das Schema und startet den Dataflow-Job.

    Nachdem der Befehl abgeschlossen ist, folgen Sie dem Link, um den Dataflow-Job in der Google Cloud Console zu beobachten.

Weitere Informationen