Importa da Cloud SQL a Spanner

Questa pagina descrive come importare i dati da Cloud SQL per MySQL in Spanner.

Il processo utilizza Cloud Shell nella console Google Cloud per eseguire comandi che configurano ed eseguono un job Dataflow per importare un database da Cloud SQL in Spanner.

Panoramica della procedura

Il processo di importazione prevede quanto segue:

  1. Completi un flusso di lavoro della console Google Cloud in cui fornisci informazioni sui database di origine e di destinazione:
    • Dettagli del database di origine: nome dell'istanza Cloud SQL, nome del database e le tue credenziali.
    • Dettagli Spanner: il nome dell'istanza Spanner e del database. Il comando crea il database se non esiste già.
    • Archiviazione output: il nome di un bucket Cloud Storage in cui archiviare i file di output.
  2. Spanner apre Cloud Shell e compila un comando. Il comando esegue le seguenti azioni:
    • Esegue la migrazione dello schema: il comando esegue la migrazione dello schema utilizzando lo strumento di migrazione di Spanner. Questa migrazione viene eseguita in Cloud Shell e utilizza un indirizzo IP pubblico per connettersi all'istanza Cloud SQL. Poiché Cloud Shell si trova su una rete propria, ha bisogno di accedere a Cloud SQL utilizzando l'indirizzo IP pubblico; tuttavia, non è necessario inserire in una lista consentita alcuna subnet rispetto all'indirizzo IP pubblico.
    • Avvia una migrazione dei dati: dopo che lo strumento ha eseguito la migrazione dello schema, il comando avvia un job Dataflow per la migrazione dei dati. Il job legge direttamente dal database di origine tramite il suo indirizzo IP privato e scrive in Spanner. Questo job viene eseguito utilizzando il account di servizio predefinito di Compute Engine. Infine, il comando stampa l'URL del job Dataflow.

Limitazioni

Si applicano le seguenti limitazioni:

  • Questa importazione di dati supporta solo una singola istanza Cloud SQL per MySQL.
  • La conversione dello schema è automatizzata; non puoi apportare modifiche allo schema durante questa importazione.
  • Questa importazione di dati è un caricamento collettivo una tantum e non supporta la replica continua.

Prima di iniziare

Prima di importare il database, completa i seguenti prerequisiti:

  1. Assicurati che l'istanza Cloud SQL abbia un indirizzo IP pubblico e un indirizzo IP privato abilitato. Per ulteriori informazioni, consulta Configurazione della connettività IP pubblica e Configura l'IP privato.

  2. Crea un utente e una password per l'istanza Cloud SQL che possono essere utilizzati per eseguire query sul database.

  3. Memorizza la password in Secret Manager. Devi avere il version ID della versione del secret. Per saperne di più, vedi Creare un secret.

  4. Assicurati di avere un bucket Cloud Storage. Dataflow utilizza questo bucket per archiviare i file di configurazione e gli output dei job Dataflow.

  5. Assicurati che Spanner e Cloud SQL si trovino nello stesso progetto Google Cloud.

  6. Abilita le API Dataflow, Cloud Storage, Spanner, Cloud SQL e Secret Manager.

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

    Abilita le API

Ruoli obbligatori

Per assicurarti che il account di servizio Compute Engine predefinito disponga delle autorizzazioni necessarie per eseguire il job Dataflow, chiedi all'amministratore di concedere i seguenti ruoli IAM al account di servizio Compute Engine predefinito sul tuo progetto:

Per ottenere le autorizzazioni necessarie per configurare l'importazione, chiedi all'amministratore di concederti i seguenti ruoli IAM sul progetto:

Questi ruoli predefiniti contengono le autorizzazioni necessarie per configurare l'importazione. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per configurare l'importazione sono necessarie le seguenti autorizzazioni:

  • 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

Requisiti di quota

I requisiti di quota sono i seguenti:

  • Spanner: devi disporre di una capacità di calcolo sufficiente per supportare la quantità di dati che stai importando. Ti consigliamo di iniziare con un minimo di un nodo Spanner. Potresti dover aggiungere ulteriore capacità di calcolo in modo che il job venga completato in un periodo di tempo ragionevole. Per importare uno schema di database non è necessaria capacità di calcolo aggiuntiva. Per saperne di più, consulta Panoramica della scalabilità automatica.
  • Dataflow: i job di importazione sono soggetti alle stesse quote di CPU, utilizzo del disco e indirizzi IP di Compute Engine degli altri job Dataflow.

  • Compute Engine: prima di eseguire il job di importazione, devi configurare le quote iniziali per Compute Engine, che Dataflow utilizza. Queste quote rappresentano il numero massimo di risorse che consenti a Dataflow di utilizzare per il tuo job. I valori iniziali consigliati sono:

    • CPU: 200
    • Indirizzi IP in uso: 200
    • Standard Persistent Disk: 50 TB

    In genere, non devi apportare altre modifiche. Dataflow fornisce la scalabilità automatica in modo da pagare solo le risorse effettivamente utilizzate durante l'importazione. Se il job può utilizzare più risorse, l'interfaccia utente Dataflow mostra un'icona di avviso. Il lavoro può essere completato anche se è presente un'icona di avviso.

Importa da Cloud SQL a Spanner

Per importare un database Cloud SQL per MySQL in Spanner, procedi nel seguente modo nella console Google Cloud :

  1. Vai alla pagina Istanze di Spanner.

    Vai alla pagina delle istanze

  2. Fai clic sul nome dell'istanza in cui deve essere importato il database.

  3. Fai clic sul pulsante Importa da Cloud SQL.

  4. Dopo che Spanner verifica che tutte le API richieste siano abilitate, fai clic sul pulsante Avanti.

  5. Seleziona l'istanza Cloud SQL per MySQL da importare, poi fai clic sul pulsante Avanti.

  6. Seleziona il database da importare e poi fai clic sul pulsante Avanti. Spanner verifica se l'IP pubblico per l'istanza Cloud SQL è abilitato.

  7. Inserisci il nome utente e il secret, poi fai clic sul pulsante Avanti.

  8. Sfoglia e seleziona il bucket Cloud Storage, poi fai clic sul pulsante Avanti.

  9. Inserisci il nome del database Spanner, poi fai clic sul pulsante Importa. Spanner apre Cloud Shell e compila un comando.

  10. Esegui il comando compilato automaticamente per avviare l'importazione:

    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 "--------------------------------------------------------"

    I seguenti parametri vengono forniti dalla console Google Cloud al comando:

    • SOURCE_DATABASE_NAME: il nome del database Cloud SQL di origine
    • SOURCE_DATABASE_USER: il nome utente per il database Cloud SQL di origine
    • PROJECT_ID: il tuo Google Cloud ID progetto
    • SECRET_ID: l'ID del secret contenente la password
    • VERSION: la versione del secret
    • SOURCE_PROJECT_ID: l'ID progetto contenente l'istanza Cloud SQL di origine
    • SOURCE_REGION: la regione dell'istanza Cloud SQL di origine
    • SOURCE_INSTANCE_NAME: il nome dell'istanza Cloud SQL di origine
    • SOURCE_PRIVATE_IP: l'indirizzo IP privato dell'istanza Cloud SQL
    • NETWORK_NAME: il nome di rete dell'istanza Cloud SQL di origine
    • SUBNETWORK_NAME: il nome della subnet dell'istanza Cloud SQL di origine
    • SPANNER_PROJECT_ID: l'ID progetto contenente l'istanza Spanner di destinazione
    • SPANNER_INSTANCE_ID: l'ID dell'istanza Spanner di destinazione
    • SPANNER_DATABASE_ID: l'ID del database Spanner di destinazione, che Spanner crea se non esiste
    • BUCKET_NAME: il nome del bucket Cloud Storage in cui archiviare i file di output e di configurazione di Dataflow

    Il comando verifica che l'account di servizio predefinito di Compute Engine disponga delle autorizzazioni richieste, installa lo strumento di migrazione di Spanner, esegue la migrazione dello schema e avvia il job Dataflow.

    Al termine del comando, segui il link fornito per monitorare il job Dataflow nella console Google Cloud .

Passaggi successivi