Pianifica backup dei database Cloud SQL

Configura l'ambiente

Per iniziare, clona il repository che contiene i dati di esempio. Poi configurerai l'ambiente e crei ruoli personalizzati con le le autorizzazioni necessarie per questo tutorial.

Puoi svolgere tutte le operazioni di questo tutorial in Cloud Shell.

1. Clona il repository che contiene i dati di esempio:

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

   Puoi utilizzare i dati del repository training-data-analyst per creare un con alcuni record fittizi.

2. Configura le seguenti variabili di 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. Crea due ruoli personalizzati che abbiano solo le autorizzazioni necessarie per questo 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"
   

   Questi ruoli riducono l'ambito di accesso a Cloud Functions gli account di servizio Cloud SQL, che seguono principio del privilegio minimo.

Crea un'istanza Cloud SQL

In questa sezione creerai un bucket Cloud Storage Cloud SQL per MySQL. Quindi carichi il database di test nel bucket Cloud Storage e importa il database da lì di Cloud SQL.

Crea un bucket Cloud Storage

Utilizzerai gcloud CLI per creare un bucket Cloud Storage.

```sh
gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}
```

Creare un'istanza Cloud SQL e concedere le autorizzazioni al relativo account di servizio.

Successivamente, creerai un'istanza Cloud SQL e concedi il relativo account di servizio le autorizzazioni per creare esecuzioni di backup.

1. Crea un'istanza Cloud SQL per MySQL:

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

   Il completamento dell'operazione richiede alcuni minuti.

2. Verifica che l'istanza Cloud SQL sia in esecuzione:

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

   L'output è simile al seguente:

   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. Concedi al tuo account di servizio Cloud SQL le autorizzazioni per l'esportazione in Cloud Storage con il ruolo Simple Storage:

   export SQL_SA=(`gcloud sql instances describe ${SQL_INSTANCE} \
       --project ${PROJECT_ID} \
       --format "value(serviceAccountEmailAddress)"`)
   
   gcloud storage buckets add-iam-policy-binding gs://${BUCKET_NAME} \
       --member=serviceAccount:${SQL_SA} \
       --role=projects/${PROJECT_ID}/roles/${STORAGE_ROLE}
   

Completa l'istanza Cloud SQL con dati di esempio

Ora puoi caricare i file nel bucket per creare e completare l'esempio per configurare un database.

1. Vai al repository che hai clonato:

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

2. Carica i file della directory nel nuovo bucket:

   gcloud storage cp * gs://${BUCKET_NAME}
   

3. Creare un database di esempio. alla domanda "Vuoi continuare (Y/N)?" di prompt, inserisci Y (Sì) per continuare.

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

4. Compilare il database. alla domanda "Vuoi continuare (Y/N)?" di prompt, inserisci Y (Sì) per continuare.

   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
   

Crea un job per argomento, una funzione e uno scheduler

In questa sezione, creerai un account di servizio IAM personalizzato associalo al ruolo SQL personalizzato che hai creato Configura l'ambiente. Quindi creerai un un argomento Pub/Sub e un la Cloud Function che sottoscrive l'argomento e utilizza API Cloud SQL Admin per avviare un backup. Infine, devi creare del job Cloud Scheduler per pubblicare un messaggio Pub/Sub periodicamente.

Crea un account di servizio per la Cloud Function

Il primo passaggio consiste nel creare un account di servizio personalizzato e associarlo all'account Ruolo SQL che hai creato in Configurare l'ambiente.

1. Crea un account di servizio IAM che deve essere utilizzato dalla Cloud Function:

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

2. Concedi all'account di servizio della funzione Cloud Function l'accesso all'istanza Ruolo SQL:

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

crea un argomento Pub/Sub

Il passaggio successivo consiste nel creare un argomento Pub/Sub da utilizzare per attivare la Cloud Function che interagisce con l'API Cloud SQL per configurare un database.

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

Crea una funzione Cloud

Quindi, creerai la Cloud Function.

1. Crea un file main.py incollando quanto segue in 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. Crea un file requirements.txt incollando quanto segue in Cloud Shell:

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

3. Esegui il deployment del codice:

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

Crea un job Cloud Scheduler

Infine, creerai un job Cloud Scheduler per attivare periodicamente il backup dei dati su base oraria. Cloud Scheduler utilizza un di un'istanza di App Engine per il deployment.

1. Crea un'istanza App Engine per il job Cloud Scheduler:

   gcloud app create --region=${REGION}
   

2. Crea un job 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'
   

Testa la tua soluzione

Il passaggio finale consiste nel testare la soluzione. Per prima cosa, esegui Job Cloud Scheduler.

1. Esegui manualmente il job Cloud Scheduler per attivare un dump MySQL del tuo database.

   gcloud scheduler jobs run ${SCHEDULER_JOB}
   

2. Elenca le operazioni eseguite sull'istanza MySQL e verifica che viene eseguita un'operazione di tipo BACKUP_VOLUME:

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

   L'output mostra un job di backup completato. Ad esempio:

   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