Programar backups de banco de dados do Cloud SQL

configure o ambiente

Para começar, faça primeiro um clone do repositório que contém os dados de amostra. Em seguida, configure o ambiente e crie papéis personalizados com as permissões necessárias para este tutorial.

É possível fazer tudo neste tutorial no Cloud Shell.

1. Faça um clone do repositório que contém os dados de amostra:

   git clone https://github.com/GoogleCloudPlatform/training-data-analyst.git
   

   Use os dados do repositório training-data-analyst para criar um banco de dados com alguns registros simulados.

2. Configure as seguintes variáveis de ambiente:

   export PROJECT_ID=`gcloud config get-value project`
   export DEMO="sql-backup-tutorial"
   export BUCKET_NAME=${USER}-MySQL-$(date +%s)
   export SQL_INSTANCE="${DEMO}-sql"
   export GCF_NAME="${DEMO}-gcf"
   export PUBSUB_TOPIC="${DEMO}-topic"
   export SCHEDULER_JOB="${DEMO}-job"
   export SQL_ROLE="sqlBackupCreator"
   export STORAGE_ROLE="simpleStorageRole"
   export REGION="us-west2"
   

3. Crie dois papéis personalizados que tenham apenas as permissões necessárias para este tutorial:

   gcloud iam roles create ${STORAGE_ROLE} --project ${PROJECT_ID} \
       --title "Simple Storage role" \
       --description "Grant permissions to view and create objects in Cloud Storage" \
       --permissions "storage.objects.create,storage.objects.get"
   

   gcloud iam roles create ${SQL_ROLE} --project ${PROJECT_ID} \
       --title "SQL Backup role" \
       --description "Grant permissions to backup data from a Cloud SQL instance" \
       --permissions "cloudsql.backupRuns.create"
   

   Esses papéis reduzem o escopo de acesso das contas de serviço do Cloud Functions e do Cloud SQL, seguindo o princípio do menor privilégio.

crie uma instância do Cloud SQL

Nesta seção, você criará um bucket do Cloud Storage e uma instância do Cloud SQL para MySQL. Em seguida, faça upload do banco de dados de teste para o bucket do Cloud Storage e importe o banco de dados para a instância do Cloud SQL.

crie um bucket do Cloud Storage

Use a ferramenta de linha de comando gsutil para criar um bucket do Cloud Storage.

```sh
gsutil mb -l ${REGION} gs://${BUCKET_NAME}
```

Crie uma instância do Cloud SQL e conceda permissões à conta de serviço

Em seguida, crie uma instância do Cloud SQL e conceda à conta de serviço as permissões para criar execuções de backup.

1. Crie uma instância do Cloud SQL para MySQL:

   sh gcloud sql instances create ${SQL_INSTANCE} --database-version MYSQL_5_7 --region ${REGION}

   Essa operação leva alguns minutos para ser concluída.

2. Verifique se a instância do Cloud SQL está em execução:

   gcloud sql instances list --filter name=${SQL_INSTANCE}
   

   A resposta será semelhante a:

   NAME                     DATABASE_VERSION  LOCATION    TIER              PRIMARY_ADDRESS  PRIVATE_ADDRESS  STATUS
   sql-backup-tutorial      MYSQL_5_7         us-west2-b  db-n1-standard-1  x.x.x.x     -                RUNNABLE
   

3. Conceda à sua conta de serviço do Cloud SQL as permissões para exportar dados para o Cloud Storage com o papel de armazenamento simples:

   export SQL_SA=(`gcloud sql instances describe ${SQL_INSTANCE} \
       --project ${PROJECT_ID} \
       --format "value(serviceAccountEmailAddress)"`)
   
   gsutil iam ch serviceAccount:${SQL_SA}:projects/${PROJECT_ID}/roles/${STORAGE_ROLE} gs://${BUCKET_NAME}
   

Preencher a instância do Cloud SQL com dados de amostra

Agora é possível fazer upload de arquivos para o bucket e criar e preencher o banco de dados de amostra.

1. Acesse o repositório que você clonou:

   cd training-data-analyst/CPB100/lab3a/cloudsql
   

2. Faça o upload dos arquivos do diretório para o novo bucket:

   gsutil cp * gs://${BUCKET_NAME}
   

3. Crie um banco de dados de amostra; no prompt "Do you want to continue (Y/n)?", digite Y (Sim) para continuar.

   gcloud sql import sql ${SQL_INSTANCE} gs://${BUCKET_NAME}/table_creation.sql --project ${PROJECT_ID}
   

4. Preencha o banco de dados no prompt "Do you want to continue (Y/n)?", digite Y (Sim) para continuar.

   gcloud sql import csv ${SQL_INSTANCE} gs://${BUCKET_NAME}/accommodation.csv \
       --database recommendation_spark \
       --table Accommodation
   

   gcloud sql import csv ${SQL_INSTANCE} gs://${BUCKET_NAME}/rating.csv \
       --database recommendation_spark \
       --table Rating
   

Criar um tópico, uma função e um job do programador

Nesta seção, você cria uma conta de serviço do IAM personalizada e a vincula ao papel SQL personalizado que você criou em Configurar seu ambiente. Em seguida, crie um tópico do Pub/Sub e uma função do Cloud que se inscreva no tópico e use a API Cloud SQL Admin para iniciar um backup. Por fim, você cria um job do Cloud Scheduler para postar uma mensagem no tópico do Pub/Sub periodicamente.

Criar uma conta de serviço para o Cloud Function

O primeiro passo é criar uma conta de serviço personalizada e vinculá-la ao papel SQL personalizado que você criou em Configurar seu ambiente.

1. Crie uma conta de serviço do IAM para ser usada pelo Cloud Function:

   gcloud iam service-accounts create ${GCF_NAME} \
       --display-name "Service Account for GCF and SQL Admin API"
   

2. Conceda à conta de serviço do Cloud Function acesso ao papel SQL personalizado:

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
       --member="serviceAccount:${GCF_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
       --role="projects/${PROJECT_ID}/roles/${SQL_ROLE}"
   

Criar um tópico do Pub/Sub

A próxima etapa é criar um tópico do Pub/Sub usado para ativar a função do Cloud que interage com o banco de dados do Cloud SQL.

```sh
gcloud pubsub topics create ${PUBSUB_TOPIC}
```

Criar uma função do Cloud

Em seguida, crie a função do Cloud.

1. Crie um arquivo main.py colando o seguinte no Cloud Shell:

   cat <<EOF > main.py
   
   import base64
   import logging
   import json
   
   from datetime import datetime
   from httplib2 import Http
   
   from googleapiclient import discovery
   from googleapiclient.errors import HttpError
   from oauth2client.client import GoogleCredentials
   
   def main(event, context):
       pubsub_message = json.loads(base64.b64decode(event['data']).decode('utf-8'))
       credentials = GoogleCredentials.get_application_default()
   
       service = discovery.build('sqladmin', 'v1beta4', http=credentials.authorize(Http()), cache_discovery=False)
   
       try:
         request = service.backupRuns().insert(
               project=pubsub_message['project'],
               instance=pubsub_message['instance']
           )
         response = request.execute()
       except HttpError as err:
           logging.error("Could NOT run backup. Reason: {}".format(err))
       else:
         logging.info("Backup task status: {}".format(response))
   EOF
   

2. Crie um arquivo requirements.txt colando o seguinte no Cloud Shell:

   cat <<EOF > requirements.txt
   google-api-python-client
   Oauth2client
   EOF
   

3. Implante o código:

   gcloud functions deploy ${GCF_NAME} \
       --trigger-topic ${PUBSUB_TOPIC} \
       --runtime python37 \
       --entry-point main \
       --service-account ${GCF_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
   

Criar um job do Cloud Scheduler

Por fim, você cria um job do Cloud Scheduler para acionar periodicamente a função de backup de dados de hora em hora. O Cloud Scheduler usa uma instância do App Engine para implantação.

1. Crie uma instância do App Engine para o job do Cloud Scheduler:

   gcloud app create --region=${REGION}
   

2. Crie um job do Cloud Scheduler:

   gcloud scheduler jobs create pubsub ${SCHEDULER_JOB} \
   --schedule "0 * * * *" \
   --topic ${PUBSUB_TOPIC} \
   --message-body '{"instance":'\"${SQL_INSTANCE}\"',"project":'\"${PROJECT_ID}\"'}' \
   --time-zone 'America/Los_Angeles'
   

Testar a solução

A etapa final é testar a solução. Para começar, execute o job do Cloud Scheduler.

1. Execute o job do Cloud Scheduler manualmente para ativar um dump do MySQL do banco de dados.

   gcloud scheduler jobs run ${SCHEDULER_JOB}
   

2. Liste as operações realizadas na instância do MySQL e verifique se há uma operação do tipo BACKUP_VOLUME:

   gcloud sql operations list --instance ${SQL_INSTANCE} --limit 1
   

   A saída mostra um job de backup concluído, por exemplo:

   NAME                                  TYPE           START                          END                            ERROR  STATUS
   8b031f0b-9d66-47fc-ba21-67dc20193749  BACKUP_VOLUME  2020-02-06T21:55:22.240+00:00  2020-02-06T21:55:32.614+00:00  -      DONE