Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Importer des données depuis Cloud SQL vers Spanner

Cette page explique comment importer des données de Cloud SQL pour MySQL dans Spanner.

Le processus utilise Cloud Shell sur Google Cloud laconsole pour exécuter des commandes qui configurent et exécutent une tâche Dataflow afin d'importer une base de données de Cloud SQL dans Spanner.

Présentation du processus

Le processus d'importation implique les éléments suivants :

Vous effectuez un Google Cloud workflow dans laconsole, dans lequel vous fournissez des informations sur vos bases de données source et cible :
- Informations sur la base de données source : nom de l'instance Cloud SQL, nom de la base de données, et vos identifiants.
- Informations sur Spanner : nom de votre instance Spanner et nom de la base de données. La commande crée la base de données si elle n'existe pas déjà.
- Stockage de sortie : nom d'un bucket Cloud Storage pour stocker les fichiers de sortie.
Spanner ouvre Cloud Shell et renseigne une commande. La commande effectue les actions suivantes :
- Migre le schéma : la commande migre le schéma à l'aide de l' outil de migration Spanner. Cette migration s'exécute dans Cloud Shell et utilise une adresse IP publique pour se connecter à votre instance Cloud SQL. Comme Cloud Shell se trouve sur son propre réseau, il doit accéder à Cloud SQL à l'aide de l'adresse IP publique. Toutefois, vous n'avez pas besoin d'autoriser de sous-réseaux par rapport à l'adresse IP publique.
- Démarre une migration de données : une fois que l'outil a migré le schéma, la commande démarre une tâche Dataflow pour la migration des données. La tâche lit directement à partir de la base de données source via son adresse IP privée et écrit dans Spanner. Cette tâche s'exécute à l'aide du compte de service Compute Engine par défaut. Enfin, la commande affiche l'URL de la tâche Dataflow.

Limites

Les limites suivantes s'appliquent :

Cette importation de données n'est compatible qu'avec une seule instance Cloud SQL pour MySQL.
La conversion de schéma est automatisée. Vous ne pouvez pas ajuster le schéma lors de cette importation.
Cette importation de données est un chargement groupé unique. Elle n'est pas compatible avec la réplication continue.

Avant de commencer

Avant d'importer votre base de données, remplissez les conditions préalables suivantes :

Assurez-vous que votre instance Cloud SQL dispose d'une adresse IP publique et d'une adresse IP privée activées. Pour en savoir plus, consultez Configurer la connectivité IP publique et Configurer une adresse IP privée.
Créez un utilisateur et un mot de passe pour votre instance Cloud SQL qui pourront être utilisés pour interroger la base de données.
Stockez le mot de passe dans Secret Manager. Vous avez besoin du version ID de la version du secret. Pour en savoir plus, consultez Créer un secret.
Assurez-vous de disposer d'un bucket Cloud Storage. Dataflow utilise ce bucket pour stocker les fichiers de configuration et les sorties des tâches Dataflow.
Assurez-vous que Spanner et Cloud SQL se trouvent dans le même Google Cloud projet.
Activez les API Dataflow, Cloud Storage, Spanner, Cloud SQL et Secret Manager.
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur d'utilisation du service (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.
Activer les API

Rôles requis

Pour vous assurer que le compte de service Compute Engine par défaut dispose des autorisations nécessaires pour exécuter la tâche Dataflow, demandez à votre administrateur d'attribuer les rôles IAM suivants au compte de service Compute Engine par défaut sur votre projet :

Accesseur de secrets Secret Manager (roles/secretmanager.secretAccessor)
Client Cloud SQL (roles/cloudsql.client)
Administrateur de bases de données Cloud Spanner (roles/spanner.databaseAdmin)
Administrateur des objets de l'espace de stockage (roles/storage.objectAdmin)
Nœud de calcul Dataflow (roles/dataflow.worker)

Pour obtenir les autorisations nécessaires afin de configurer l'importation, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Client Cloud SQL (roles/cloudsql.client)
Administrateur de bases de données Cloud Spanner (roles/spanner.databaseAdmin)
Accesseur de secrets Secret Manager (roles/secretmanager.secretAccessor)
Administrateur de l'espace de stockage (roles/storage.admin)
Développeur Dataflow (roles/dataflow.developer)
Utilisateur du compte de service (roles/iam.serviceAccountUser)

Ces rôles prédéfinis contiennent les autorisations requises pour configurer l'importation. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour configurer l'importation :

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

Exigences en matière de quota

Les exigences en matière de quota sont les suivantes :

Spanner : vous devez disposer d'une capacité de calcul suffisante pour prendre en charge la quantité de données que vous importez. Nous vous recommandons de commencer avec au moins un nœud Spanner. Il peut s'avérer nécessaire d'ajouter de la capacité de calcul pour que la tâche se termine dans un délai raisonnable. Aucune capacité de calcul supplémentaire n'est requise pour importer un schéma de base de données. Pour en savoir plus, consultez la page Présentation de l'autoscaling.
Dataflow : les tâches d'importation sont soumises aux mêmes exigences que les autres tâches Dataflow en ce qui concerne les quotas Compute Engine, aussi bien pour l'utilisation de processeurs et d'espace disque que pour le nombre d'adresses IP.
Compute Engine : avant d'exécuter une tâche d'importation, vous devez définir les quotas initiaux Compute Engine utilisés par Dataflow. Ces quotas représentent le nombre maximal de ressources que vous permettez à Dataflow d'utiliser pour votre tâche. Les valeurs de départ recommandées sont les suivantes :
- Processeurs : 200
- Adresses IP en cours d'utilisation : 200
- Disque persistant standard : 50 To
En règle générale, vous n'avez pas besoin d'effectuer d'autres ajustements. Dataflow assure un autoscaling qui vous permet de ne payer que pour les ressources réellement utilisées lors de l'importation. S'il apparaît que votre tâche pourrait utiliser davantage de ressources, l'interface utilisateur de Dataflow affiche une icône d'avertissement, mais cela n'empêche normalement pas la tâche d'aboutir.

Importer de Cloud SQL vers Spanner

Pour importer une base de données Cloud SQL pour MySQL dans Spanner, procédez comme suit dans la console Google Cloud :

Accédez à la page Instances de Spanner.

Accéder à la page Instances
Cliquez sur le nom de l'instance dans laquelle la base de données doit être importée.
Cliquez sur le bouton Importer depuis Cloud SQL.
Une fois que Spanner a vérifié que toutes les API requises sont activées, cliquez sur le bouton Suivant.
Sélectionnez l'instance Cloud SQL pour MySQL à importer, puis cliquez sur le bouton Suivant.
Sélectionnez la base de données à importer, puis cliquez sur le bouton Suivant. Spanner vérifie si l'adresse IP publique de votre instance Cloud SQL est activée.
Saisissez le nom d'utilisateur et le secret, puis cliquez sur le bouton Suivant.
Parcourez et sélectionnez le bucket Cloud Storage, puis cliquez sur le bouton Suivant.
Saisissez le nom de la base de données Spanner, puis cliquez sur le bouton Importer. Spanner ouvre Cloud Shell et renseigne une commande.

Exécutez la commande automatiquement renseignée pour démarrer l'importation :

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

Les paramètres suivants sont fournis par la Google Cloud console à la commande :

SOURCE_DATABASE_NAME: nom de la base de données Cloud SQL source
SOURCE_DATABASE_USER: nom d'utilisateur de la base de données Cloud SQL source
PROJECT_ID: ID de votre Google Cloud projet
SECRET_ID: ID du secret contenant le mot de passe
VERSION : version du secret
SOURCE_PROJECT_ID: ID du projet contenant l'instance Cloud SQL source
SOURCE_REGION: région de l'instance Cloud SQL source
SOURCE_INSTANCE_NAME: nom de l'instance Cloud SQL source
SOURCE_PRIVATE_IP: adresse IP privée de l'instance Cloud SQL
NETWORK_NAME: nom de réseau de l'instance Cloud SQL source
SUBNETWORK_NAME: nom de sous-réseau de l'instance Cloud SQL source
SPANNER_PROJECT_ID: ID du projet contenant l'instance Spanner cible
SPANNER_INSTANCE_ID: ID de l'instance Spanner cible
SPANNER_DATABASE_ID: ID de la base de données Spanner cible, que Spanner crée si elle n'existe pas
BUCKET_NAME: nom du bucket Cloud Storage dans lequel stocker les fichiers de sortie et les fichiers de configuration Dataflow

La commande vérifie que le compte de service de calcul par défaut dispose des autorisations requises, installe l'outil de migration Spanner, migre le schéma et démarre la tâche Dataflow.

Une fois la commande terminée, suivez le lien fourni pour surveiller la tâche Dataflow dans la Google Cloud console.

Étape suivante

Découvrez comment effectuer des mises à jour de schéma.