Importa desde Cloud SQL a Spanner

En esta página, se describe cómo importar datos de Cloud SQL para MySQL a Spanner.

El proceso usa Cloud Shell en Google Cloud console para ejecutar comandos que configuran y ejecutan un trabajo de Dataflow para importar una base de datos de Cloud SQL a Spanner.

Descripción general del proceso

El proceso de importación implica lo siguiente:

1. Completas un flujo de trabajo de la consola Google Cloud en el que proporcionas información sobre tus bases de datos de origen y destino:
   • Detalles de la base de datos de origen: Nombre de la instancia de Cloud SQL, nombre de la base de datos y tus credenciales
   • Detalles de Spanner: El nombre de tu instancia de Spanner y el nombre de la base de datos El comando crea la base de datos si aún no existe.
   • Almacenamiento de salida: Nombre de un bucket de Cloud Storage para almacenar archivos de salida.
2. Spanner abre Cloud Shell y completa un comando. El comando realiza las siguientes acciones:
   • Migra el esquema: El comando migra el esquema con la herramienta de migración de Spanner. Esta migración se ejecuta en Cloud Shell y usa una dirección IP pública para conectarse a tu instancia de Cloud SQL. Como Cloud Shell está en su propia red, necesita acceder a Cloud SQL con la dirección IP pública. Sin embargo, no es necesario que agregues ninguna subred a la lista de entidades permitidas en relación con la dirección IP pública.
   • Inicia una migración de datos: Después de que la herramienta migra el esquema, el comando inicia un trabajo de Dataflow para la migración de datos. El trabajo lee directamente desde la base de datos de origen a través de su dirección IP privada y escribe en Spanner. Este trabajo se ejecuta con la cuenta de servicio predeterminada de Compute Engine. Por último, el comando imprime la URL del trabajo de Dataflow.

Limitaciones

Se aplica la siguiente limitación:

• Esta importación de datos solo admite una instancia de Cloud SQL para MySQL.
• La conversión del esquema es automática, por lo que no puedes realizar ajustes en el esquema durante esta importación.
• Esta importación de datos es una carga masiva única y no admite la replicación continua.

Antes de comenzar

Antes de importar tu base de datos, completa los siguientes requisitos previos:

1. Asegúrate de que tu instancia de Cloud SQL tenga habilitadas una dirección IP pública y una dirección IP privada. Para obtener más información, consulta Configura la conectividad de IP pública y Configura la IP privada.

2. Crea un usuario y una contraseña para tu instancia de Cloud SQL que se puedan usar para consultar la base de datos.

3. Almacena la contraseña en Secret Manager. Necesitas el version ID de la versión del secreto. Para obtener más información, consulta Crea un secreto.

4. Asegúrate de tener un bucket de Cloud Storage. Dataflow usa este bucket para almacenar los archivos de configuración y los resultados de los trabajos de Dataflow.

5. Asegúrate de que Spanner y Cloud SQL estén en el mismo proyecto Google Cloud.

6. Habilita las APIs de Dataflow, Cloud Storage, Spanner, Cloud SQL y Secret Manager.

   Roles necesarios para habilitar las APIs

   Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.

   Habilitar las API

Roles obligatorios

Para asegurarte de que la cuenta de servicio predeterminada de Compute Engine tenga los permisos necesarios para ejecutar el trabajo de Dataflow, pídele a tu administrador que otorgue los siguientes roles de IAM a la cuenta de servicio predeterminada de Compute Engine en tu proyecto:

Importante: Debes otorgar estos roles a la cuenta de servicio predeterminada de Compute Engine, no a tu cuenta de usuario. Si no se otorgan los roles a la principal correcta, es posible que se produzcan errores de permisos.

• Usuario con acceso a secretos de Secret Manager (roles/secretmanager.secretAccessor)
• Cliente de Cloud SQL (roles/cloudsql.client)
• Administrador de bases de datos de Cloud Spanner (roles/spanner.databaseAdmin)
• Administrador de objetos de Storage (roles/storage.objectAdmin)
• Trabajador de Dataflow (roles/dataflow.worker)

Para obtener los permisos que necesitas para configurar la importación, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

• Cliente de Cloud SQL (roles/cloudsql.client)
• Administrador de bases de datos de Cloud Spanner (roles/spanner.databaseAdmin)
• Usuario con acceso a secretos de Secret Manager (roles/secretmanager.secretAccessor)
• Administrador de almacenamiento (roles/storage.admin)
• Desarrollador de Dataflow (roles/dataflow.developer)
• Usuario de la cuenta de servicio (roles/iam.serviceAccountUser)

Estos roles predefinidos contienen los permisos necesarios para configurar la importación. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para configurar la importación:

• 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

Requisitos de cuota

Los requisitos de cuota son los siguientes:

• Spanner: Debes tener capacidad de procesamiento suficiente para admitir la cantidad de datos que deseas importar. Recomendamos comenzar con un mínimo de un nodo de Spanner. Es posible que debas agregar más capacidad de procesamiento para que el trabajo se complete en un tiempo razonable. No se requiere capacidad de procesamiento adicional para importar un esquema de base de datos. Para obtener más información, consulta Descripción general del ajuste de escala automático.
• Dataflow: Los trabajos de importación están sujetos a las mismas cuotas de Compute Engine de direcciones IP, uso del disco y CPU que otros trabajos de Dataflow.

• Compute Engine: Antes de ejecutar el trabajo de importación, debes establecer las cuotas iniciales para Compute Engine, que usa Dataflow. Estas cuotas representan la cantidad máxima de recursos que permites que Dataflow use para tu trabajo. Los valores iniciales recomendados son los siguientes:

  • CPU: 200
  • Direcciones IP en uso: 200
  • Disco persistente estándar: 50 TB

  Por lo general, no es necesario hacer ningún otro ajuste. Dataflow proporciona ajuste de escala automático para que solo pagues por los recursos que sí se usan durante la importación. Si tu trabajo puede usar más recursos, la IU de Dataflow muestra un ícono de advertencia. El trabajo puede completarse incluso si hay un ícono de advertencia.

Importa desde Cloud SQL a Spanner

Para importar una base de datos de Cloud SQL para MySQL a Spanner, haz lo siguiente en la consola de Google Cloud :

1. Ve a la página Instancias de Spanner.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia en la que se debe importar la base de datos.

3. Haz clic en el botón Importar desde Cloud SQL.

4. Después de que Spanner verifique que todas las APIs obligatorias estén habilitadas, haz clic en el botón Siguiente.

5. Selecciona la instancia de Cloud SQL para MySQL que deseas importar y, luego, haz clic en el botón Siguiente.

6. Selecciona la base de datos que deseas importar y, luego, haz clic en el botón Siguiente. Spanner verifica si la IP pública de tu instancia de Cloud SQL está habilitada.

7. Ingresa el nombre de usuario y el secreto, y luego haz clic en el botón Siguiente.

8. Busca y selecciona el bucket de Cloud Storage y, luego, haz clic en el botón Siguiente.

9. Ingresa el nombre de la base de datos de Spanner y, luego, haz clic en el botón Importar. Spanner abre Cloud Shell y completa un comando.

10. Ejecuta el comando propagado automáticamente para iniciar la importación:

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

    Los siguientes parámetros se proporcionan desde la consola de Google Cloud al comando:

    • SOURCE_DATABASE_NAME: Es el nombre de la base de datos de Cloud SQL de origen.
    • SOURCE_DATABASE_USER: Es el nombre de usuario de la base de datos de Cloud SQL de origen.
    • PROJECT_ID: El ID de tu proyecto de Google Cloud
    • SECRET_ID: Es el ID del secreto que contiene la contraseña.
    • VERSION: Es la versión del secreto.
    • SOURCE_PROJECT_ID: Es el ID del proyecto que contiene la instancia de origen de Cloud SQL.
    • SOURCE_REGION: Es la región de la instancia de Cloud SQL de origen.
    • SOURCE_INSTANCE_NAME: El nombre de la instancia de Cloud SQL de origen
    • SOURCE_PRIVATE_IP: La dirección IP privada de la instancia de Cloud SQL
    • NETWORK_NAME: Es el nombre de la red de la instancia de Cloud SQL de origen.
    • SUBNETWORK_NAME: El nombre de la subred de la instancia de Cloud SQL de origen
    • SPANNER_PROJECT_ID: Es el ID del proyecto que contiene la instancia de Spanner de destino.
    • SPANNER_INSTANCE_ID: Es el ID de la instancia de Spanner de destino.
    • SPANNER_DATABASE_ID: Es el ID de la base de datos de Spanner de destino, que Spanner crea si no existe.
    • BUCKET_NAME: El nombre del bucket de Cloud Storage para almacenar los archivos de configuración y los archivos de salida de Dataflow

    El comando verifica que la cuenta de servicio de Compute predeterminada tenga los permisos necesarios, instala la herramienta de migración de Spanner, migra el esquema y, luego, inicia el trabajo de Dataflow.

    Una vez que finalice el comando, sigue el vínculo proporcionado para supervisar el trabajo de Dataflow en la consola de Google Cloud .

Pasos siguientes

• Obtén más información para realizar actualizaciones de esquemas.