Importar do Cloud SQL para o Spanner

Nesta página, descrevemos como importar dados do Cloud SQL para MySQL para o Spanner.

O processo usa o Cloud Shell on Google Cloud console para executar comandos que configuram e executam um job do Dataflow para importar um banco de dados do Cloud SQL para o Spanner.

Visão geral do processo

O processo de importação envolve o seguinte:

  1. Você conclui um Google Cloud fluxo de trabalho doconsole em que fornece informações sobre os bancos de dados de origem e destino:
    • Detalhes do banco de dados de origem: nome da instância do Cloud SQL, nome do banco de dados, e suas credenciais.
    • Detalhes do Spanner: nome da instância do Spanner e nome do banco de dados. O comando cria o banco de dados se ele ainda não existir.
    • Armazenamento de saída: um nome de bucket do Cloud Storage para armazenar arquivos de saída.
  2. O Spanner abre o Cloud Shell e preenche um comando. O comando executa as seguintes ações:
    • Migra o esquema: o comando migra o esquema usando a ferramenta de migração do Spanner. Essa migração é executada no Cloud Shell e usa um endereço IP público para se conectar à instância do Cloud SQL. Como o Cloud Shell está na própria rede, ele precisa de acesso ao Cloud SQL usando o endereço IP público. No entanto, não é necessário permitir nenhuma sub-rede em relação ao endereço IP público.
    • Inicia uma migração de dados: depois que a ferramenta migra o esquema, o comando inicia um job do Dataflow para migração de dados. O job lê diretamente do banco de dados de origem pelo endereço IP particular e grava no Spanner. Esse job é executado usando a conta de serviço padrão do Compute Engine. Por fim, o comando imprime o URL do job do Dataflow.

Limitações

Considere as seguintes limitações:

  • Essa importação de dados só oferece suporte a uma única instância do Cloud SQL para MySQL.
  • A conversão de esquema é automatizada. Não é possível fazer ajustes no esquema durante essa importação.
  • Essa importação de dados é um carregamento em massa único. Ela não oferece suporte à replicação contínua.

Antes de começar

Antes de importar o banco de dados, conclua os seguintes pré-requisitos:

  1. Verifique se a instância do Cloud SQL tem um endereço IP público e um endereço IP particular ativados. Para mais informações, consulte Configurar a conectividade de IP público e Configurar o IP particular.

  2. Crie um usuário e uma senha para a instância do Cloud SQL que possam ser usados para consultar o banco de dados.

  3. Armazene a senha no Secret Manager. Você precisa do version ID da versão do secret. Para mais informações, consulte Criar um secret.

  4. Verifique se você tem um bucket do Cloud Storage. O Dataflow usa esse bucket para armazenar arquivos de configuração e saídas dos jobs do Dataflow.

  5. Verifique se o Spanner e o Cloud SQL estão no mesmo Google Cloud projeto.

  6. Ative as APIs Dataflow, Cloud Storage, Spanner, Cloud SQL e Secret Manager.

    Funções necessárias para ativar APIs

    Para ativar as APIs, é necessário ter o papel do IAM de administrador de uso do serviço (roles/serviceusage.serviceUsageAdmin), que contém a permissão serviceusage.services.enable. Saiba como conceder papéis.

    Ativar as APIs

Funções exigidas

Para garantir que a conta de serviço padrão do Compute Engine tenha as permissões necessárias para executar o job do Dataflow, peça ao administrador para conceder os seguintes papéis do IAM à conta de serviço padrão do Compute Engine no projeto:

Para receber as permissões necessárias para configurar a importação, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Esses papéis predefinidos contêm as permissões necessárias para configurar a importação. Para acessar as permissões exatas que são necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para configurar a importação:

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

Os requisitos de cota são os seguintes:

  • Spanner: é preciso ter capacidade de computação suficiente para aceitar a quantidade de dados que você está importando. Recomendamos começar com um mínimo de um nó do Spanner. Talvez seja necessário adicionar mais capacidade de computação para que o job seja concluído em um período razoável. Nenhuma capacidade de computação extra é necessária para importar um esquema de banco de dados. Para mais informações, consulte Visão geral do escalonamento automático.
  • Dataflow: os jobs de importação estão sujeitos às mesmas cotas do Compute Engine para endereço IP, uso da CPU e do disco aplicadas a outros jobs do Dataflow.

  • Compute Engine: antes de executar um job de importação, é necessário configurar cotas iniciais para o Compute Engine, que serão usadas pelo Dataflow. Essas cotas representam o número máximo de recursos que você permite que o Dataflow use para seu job. Os valores iniciais recomendados são:

    • CPUs: 200
    • Endereços IP em uso: 200
    • Disco permanente padrão: 50 TB

    Geralmente, não é necessário fazer outros ajustes. O Dataflow fornece escalonamento automático para que você pague apenas pelos recursos efetivamente utilizados durante a importação. Se seu job puder usar mais recursos, a IU do Dataflow exibirá um ícone de aviso. O job pode ser concluído mesmo que haja um ícone de aviso.

Importar do Cloud SQL para o Spanner

Para importar um banco de dados do Cloud SQL para MySQL para o Spanner, faça o seguinte no Google Cloud console:

  1. Acesse a página Instâncias do Spanner.

    Acesse a página "Instâncias"

  2. Clique no nome da instância em que o banco de dados precisa ser importado.

  3. Clique no botão Importar do Cloud SQL.

  4. Depois que o Spanner verificar se todas as APIs necessárias estão ativadas, clique no botão Próximo.

  5. Selecione a instância do Cloud SQL para MySQL a ser importada e clique no botão Próximo.

  6. Selecione o banco de dados a ser importado e clique no botão Próximo. O Spanner verifica se o IP público da instância do Cloud SQL está ativado.

  7. Insira o nome de usuário e o secret e clique no botão Próximo.

  8. Navegue e selecione o bucket do Cloud Storage e clique no botão Próximo.

  9. Insira o nome do banco de dados do Spanner e clique no botão Importar. O Spanner abre o Cloud Shell e preenche um comando.

  10. Execute o comando preenchido automaticamente para iniciar a importação:

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

    Os parâmetros a seguir são fornecidos pelo Google Cloud console ao comando:

    • SOURCE_DATABASE_NAME: o nome do banco de dados de origem do Cloud SQL
    • SOURCE_DATABASE_USER: o nome de usuário do banco de dados de origem do Cloud SQL
    • PROJECT_ID: o ID do seu Google Cloud projeto
    • SECRET_ID: o ID do secret que contém a senha
    • VERSION: a versão do secret
    • SOURCE_PROJECT_ID: o ID do projeto que contém a instância de origem do Cloud SQL
    • SOURCE_REGION: a região da instância de origem do Cloud SQL
    • SOURCE_INSTANCE_NAME: o nome da instância de origem do Cloud SQL
    • SOURCE_PRIVATE_IP: o endereço IP particular da instância do Cloud SQL
    • NETWORK_NAME: o nome da rede da instância de origem do Cloud SQL
    • SUBNETWORK_NAME: o nome da sub-rede da instância de origem do Cloud SQL
    • SPANNER_PROJECT_ID: o ID do projeto que contém a instância de destino do Spanner
    • SPANNER_INSTANCE_ID: o ID da instância de destino do Spanner
    • SPANNER_DATABASE_ID: o ID do banco de dados de destino do Spanner, que o Spanner cria se ele não existir
    • BUCKET_NAME: o nome do bucket do Cloud Storage para armazenar arquivos de saída e de configuração do Dataflow

    O comando verifica se a conta de serviço de computação padrão tem as permissões necessárias, instala a ferramenta de migração do Spanner, migra o esquema e inicia o job do Dataflow.

    Depois que o comando terminar, siga o link fornecido para monitorar o job do Dataflow no Google Cloud console.

A seguir