Importer des données depuis Cloud SQL vers Spanner

Cette page explique comment importer des données depuis Cloud SQL pour MySQL vers Spanner.

Le processus utilise Cloud Shell sur la console Google Cloud pour exécuter des commandes qui configurent et exécutent un job Dataflow afin d'importer une base de données depuis Cloud SQL vers Spanner.

Présentation du processus

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

1. Vous effectuez un workflow de la console Google Cloud dans lequel vous fournissez des informations sur vos bases de données sources et cibles :
   • Informations sur la base de données source : nom de l'instance Cloud SQL, nom de la base de données et vos identifiants.
   • Détails 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 des résultats : nom du bucket Cloud Storage dans lequel stocker les fichiers de sortie.
2. 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. Étant donné que Cloud Shell se trouve sur son propre réseau, il a besoin d'accéder à Cloud SQL à l'aide de l'adresse IP publique. Toutefois, vous n'avez pas besoin d'ajouter de sous-réseaux à la liste d'autorisation 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 un job Dataflow pour la migration des données. Le job lit les données de la base de données source directement via son adresse IP privée et les écrit dans Spanner. Ce job s'exécute à l'aide du compte de service Compute Engine par défaut. Enfin, la commande affiche l'URL du job 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 du schéma est automatisée. Vous ne pouvez pas l'ajuster pendant l'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 :

1. Assurez-vous que votre instance Cloud SQL possède une adresse IP publique et une adresse IP privée activées. Pour en savoir plus, consultez les pages Configurer la connectivité IP publique et Configurer une adresse IP privée.

2. 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.

3. 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.

4. Assurez-vous de disposer d'un bucket Cloud Storage. Dataflow utilise ce bucket pour stocker les fichiers de configuration et les sorties des jobs Dataflow.

5. Assurez-vous que Spanner et Cloud SQL se trouvent dans le même projet Google Cloud.

6. 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 Service Usage (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 le job Dataflow, demandez à votre administrateur d'accorder les rôles IAM suivants au compte de service Compute Engine par défaut dans votre projet :

Important : Vous devez attribuer ces rôles au compte de service Compute Engine par défaut, et non à votre compte utilisateur. Si vous ne les accordez pas au bon compte principal, vous risquez de rencontrer des erreurs d'autorisation.

• 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 pour 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

Voici les exigences concernant les quotas :

• 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 d'autres réglages à effectuer. 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 des données depuis 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  :

1. Accédez à la page Instances de Spanner.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance dans laquelle la base de données doit être importée.

3. Cliquez sur le bouton Importer depuis Cloud SQL.

4. Une fois que Spanner a vérifié que toutes les API requises sont activées, cliquez sur le bouton Suivant.

5. Sélectionnez l'instance Cloud SQL pour MySQL à importer, puis cliquez sur le bouton Suivant.

6. 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.

7. Saisissez le nom d'utilisateur et le code secret, puis cliquez sur le bouton Suivant.

8. Parcourez et sélectionnez le bucket Cloud Storage, puis cliquez sur le bouton Suivant.

9. Saisissez le nom de la base de données Spanner, puis cliquez sur le bouton Importer. Spanner ouvre Cloud Shell et renseigne une commande.

10. Exécutez la commande automatiquement renseignée pour lancer l'importation :

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

    Les paramètres suivants sont fournis par la console Google Cloud à 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 projet Google Cloud
    • 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 du réseau de l'instance Cloud SQL source
    • SUBNETWORK_NAME : nom du 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 configuration et de sortie Dataflow

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

    Une fois la commande exécutée, suivez le lien fourni pour surveiller le job Dataflow dans la console Google Cloud .

Étape suivante

• Découvrez comment mettre à jour un schéma.