Importa da Cloud SQL a Spanner

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

La procedura utilizza Cloud Shell su Google Cloud console per eseguire i comandi che configurano ed eseguono un job Dataflow per importare un database da Cloud SQL in Spanner.

Panoramica della procedura

La procedura di importazione prevede quanto segue:

Completi un Google Cloud flusso di lavoro suconsole in cui fornisci informazioni su database di origine e di destinazione:
- Dettagli del database di origine: nome dell'istanza Cloud SQL, nome del database, e credenziali.
- Dettagli di Spanner: nome dell'istanza Spanner e nome del database. Il comando crea il database se non esiste già.
- Archiviazione dell'output: il nome di un bucket Cloud Storage in cui archiviare i file di output.
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 sulla propria rete, deve accedere a Cloud SQL utilizzando l'indirizzo IP pubblico; tuttavia, non è necessario consentire l'accesso a nessuna subnet 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; non supporta la replica continua.

Prima di iniziare

Prima di importare il database, completa i seguenti prerequisiti:

Assicurati che l'istanza Cloud SQL abbia un indirizzo IP pubblico e un indirizzo IP privato abilitati. Per ulteriori informazioni, consulta Configurare la connettività IP pubblica e Configurare l'IP privato.
Crea un utente e una password per l'istanza Cloud SQL che possono essere utilizzati per eseguire query sul database.
Archivia la password in Secret Manager. Ti serve il version ID di lla versione del secret. Per ulteriori informazioni, consulta Creare un secret.
Assicurati di avere un bucket Cloud Storage. Dataflow utilizza questo bucket per archiviare i file di configurazione e gli output dei job Dataflow.
Assicurati che Spanner e Cloud SQL si trovino nello stesso Google Cloud progetto.
Abilita le API Dataflow, Cloud Storage, Spanner, Cloud SQL e Secret Manager.
Ruoli necessari per abilitare le API
Per abilitare le API, devi disporre del ruolo IAM Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin), che contiene l'autorizzazione serviceusage.services.enable. Scopri come concedere i ruoli.
Abilita le API

Ruoli obbligatori

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

Accessore secret Secret Manager (roles/secretmanager.secretAccessor)
Client Cloud SQL (roles/cloudsql.client)
Amministratore database Cloud Spanner (roles/spanner.databaseAdmin)
Storage Object Admin (roles/storage.objectAdmin)
Dataflow Worker (roles/dataflow.worker)

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

Client Cloud SQL (roles/cloudsql.client)
Amministratore database Cloud Spanner (roles/spanner.databaseAdmin)
Accessore secret Secret Manager (roles/secretmanager.secretAccessor)
Storage Admin (roles/storage.admin)
Dataflow Developer (roles/dataflow.developer)
Utente Service Account (roles/iam.serviceAccountUser)

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 per consentire al job di terminare in un periodo di tempo ragionevole. Non è necessaria ulteriore capacità di calcolo per importare uno schema di database. Per ulteriori informazioni, 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
- Persistent disk standard: 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 di Dataflow mostra un'icona di avviso. Il job può terminare anche se è presente un'icona di avviso.

Importare da Cloud SQL a Spanner

Per importare un database Cloud SQL per MySQL in Spanner, procedi come segue su console: Google Cloud

Vai alla pagina Istanze di Spanner.

Vai alla pagina delle istanze
Fai clic sul nome dell'istanza in cui deve essere importato il database.
Fai clic sul pulsante Importa da Cloud SQL.
Dopo che Spanner ha verificato che tutte le API richieste sono abilitate, fai clic sul pulsante Avanti.
Seleziona l'istanza Cloud SQL per MySQL da importare, quindi fai clic sul pulsante Avanti.
Seleziona il database da importare, quindi fai clic sul pulsante Avanti. Spanner verifica se l'IP pubblico per l'istanza Cloud SQL è abilitato.
Inserisci il nome utente e il secret, quindi fai clic sul pulsante Avanti.
Sfoglia e seleziona il bucket Cloud Storage, quindi fai clic sul pulsante Avanti.
Inserisci il nome del database Spanner, quindi fai clic sul pulsante Importa. Spanner apre Cloud Shell e compila un comando.

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 da Google Cloud console a 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 della 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 i file di configurazione di Dataflow

Il comando verifica che il account di servizio di calcolo predefinito 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 su Google Cloud console.

Passaggi successivi

Scopri come apportare aggiornamenti dello schema.