Programa exportaciones de bases de datos de Cloud SQL mediante Cloud Scheduler

En este instructivo, se muestra cómo usar Cloud Scheduler y Cloud Functions con el fin de exportar de forma automática una base de datos de Cloud SQL para MySQL a Cloud Storage. Tener exportaciones de bases de datos en Cloud Storage te permite crear un plan sólido y diverso de recuperación ante desastres. Por ejemplo, puedes exportar a una región diferente e importar a otras instancias de Cloud SQL o a otras bases de datos de MySQL.

Arquitectura

En este instructivo, se incluyen los siguientes componentes de Google Cloud:

Un trabajo de Cloud Scheduler publica un mensaje en un tema de Pub/Sub con información sobre el nombre de la instancia de Cloud SQL, la base de datos, el ID del proyecto y la ubicación de Cloud Storage en la que se almacenará la copia de seguridad. Este evento activa una función de Cloud Functions que obtiene esta carga útil y comienza una exportación de la base de datos en Cloud SQL a través de la API de Administrador de SQL. La base de datos genera la exportación y la guarda en Cloud Storage. En el diagrama a continuación, se muestra este proceso.

Flujo de trabajo de Cloud Scheduler a Pub/Sub, que activa una función de Cloud Functions que inicia la exportación.

Objetivos

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener una prueba gratuita.

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta cómo hacer una limpieza.

Antes de comenzar

  1. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir a la página del selector de proyectos

  2. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

  3. En Cloud Console, activa Cloud Shell.

    Activar Cloud Shell

  4. Habilita las Cloud SQL Admin, Cloud Functions, Cloud Scheduler, and App Engine APIs.

    Habilita la API

A lo largo de este instructivo, ejecutarás todos los comandos desde Cloud Shell.

Configura tu entorno

Para comenzar, primero clona el repositorio que contiene los datos de muestra. Luego, configura tu entorno y crea funciones personalizadas que tengan los permisos necesarios para este instructivo.

  1. Clona el repositorio que contiene los datos de muestra:

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

    Usa los datos del repositorio training-data-analyst para crear una base de datos con algunos registros ficticios.

  2. Configura las siguientes variables de entorno:

    export PROJECT_ID=`gcloud config get-value project`
    export DEMO="sql-export-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="sqlExporter"
    export STORAGE_ROLE="simpleStorageRole"
    export REGION="us-west2"
    
  3. Crea dos funciones personalizadas que solo tengan los permisos necesarios para este instructivo:

    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 Exporter Role" \
        --description "Grant permissions to export data from a Cloud SQL instance to a Cloud Storage bucket as a SQL dump or CSV file" \
        --permissions "cloudsql.instances.export"
    

    Estas funciones reducen el permiso de acceso de las cuentas de servicio de Cloud Functions y Cloud SQL, según el principio de menor privilegio.

Crea un bucket de Cloud Storage y una instancia de Cloud SQL

En esta sección, primero crearás un bucket de Cloud Storage y una instancia de Cloud SQL para MySQL. Luego, crearás una base de datos de muestra y la propagarás con datos de muestra.

Cree un bucket de Cloud Storage

Usa la herramienta de línea de comandos de gsutil para crear un bucket de Cloud Storage.

  • Crea un bucket de Cloud Storage en el que desees guardar las exportaciones de datos:

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

Crea una instancia de Cloud SQL y otórgale permisos a su cuenta de servicio

A continuación, crea una instancia de Cloud SQL y otorga a su cuenta de servicio los permisos para exportar datos a Cloud Storage.

  1. Crea una instancia de Cloud SQL para MySQL 5.7:

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

    Esta operación tardará unos minutos en completarse.

  2. Verifica que la instancia de Cloud SQL esté en ejecución:

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

    El resultado es similar a este:

    NAME                     DATABASE_VERSION  LOCATION    TIER              PRIMARY_ADDRESS  PRIVATE_ADDRESS  STATUS
    sql-export-tutorial-sql  MYSQL_5_7         us-west2-b  db-n1-standard-1  34.94.173.98     -                RUNNABLE
    
  3. Otorga a tu cuenta de servicio de Cloud SQL los permisos para exportar datos a Cloud Storage con la función de almacenamiento simple:

    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}
    

Propaga la instancia de Cloud SQL con datos de muestra

Ahora puedes subir archivos a tu bucket y crear y propagar tu base de datos de muestra.

  1. Ve al repositorio que clonaste:

    cd training-data-analyst/CPB100/lab3a/cloudsql
    
  2. Sube los archivos del directorio a tu bucket nuevo:

    gsutil cp * gs://${BUCKET_NAME}
    
  3. Crea y propaga una base de datos de muestra; cada vez que se te solicite, haz clic en yes para continuar:

    gcloud sql import sql ${SQL_INSTANCE} gs://${BUCKET_NAME}/table_creation.sql --project ${PROJECT_ID}
    
    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 tema de Pub/Sub, una función de Cloud Functions y un trabajo de Cloud Scheduler

En esta sección, crearás una cuenta de servicio personalizada y la vincularás a la función de SQL personalizada que creaste. Luego, crea un tema de Pub/Sub que se usa para activar la ejecución de una función de Cloud Functions. También creas un trabajo de Cloud Scheduler para ejecutar de forma periódica la función de exportación de datos.

Crea una cuenta de servicio para la función de Cloud Functions

El primer paso es crear una cuenta de servicio personalizada y vincularla a la función de SQL personalizada que creas.

  1. Crea una cuenta de servicio de IAM para que la use Cloud Functions:

    gcloud iam service-accounts create ${GCF_NAME} \
        --display-name "Service Account for GCF and SQL Admin API"
    
  2. Otorga a la cuenta de servicio de Cloud Functions acceso a la función de SQL personalizada:

    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 tema de Pub/Sub

El siguiente paso es crear un tema de Pub/Sub que se use para activar la función de Cloud Functions que interactúa con la base de datos de Cloud SQL.

  • Crea el tema de Pub/Sub:

    gcloud pubsub topics create ${PUBSUB_TOPIC}
    

Crea una función de Cloud Functions

A continuación, crea la función de Cloud Functions.

  1. Para crear un archivo main.py, pega lo siguiente en 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)
    
        datestamp = datetime.now().strftime("%Y%m%d%H%M") # format timestamp: YearMonthDayHourMinute
        uri = "{0}/backup-{1}-{2}.gz".format(pubsub_message['gs'], pubsub_message['db'], datestamp)
    
        instances_export_request_body = {
          "exportContext": {
            "kind": "sql#exportContext",
            "fileType": "SQL",
            "uri": uri,
            "databases": [
              pubsub_message['db']
            ]
          }
        }
    
        try:
          request = service.instances().export(
                project=pubsub_message['project'],
                instance=pubsub_message['instance'],
                body=instances_export_request_body
            )
          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. Para crear un archivo requirements.txt, pega lo siguiente en Cloud Shell:

    cat <<EOF > requirements.txt
    google-api-python-client
    Oauth2client
    EOF
    
  3. Implementa el código. Cuando se te pregunte si deseas permitir invocaciones no autenticadas de la función nueva, responde no.

    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 trabajo de Cloud Scheduler

Por último, crea un trabajo de Cloud Scheduler para ejecutar de forma periódica la función de exportación de datos.

  1. Crea una instancia de App Engine para el trabajo de Cloud Scheduler:

    gcloud app create --region=${REGION}
    
  2. Crea un trabajo de Cloud Scheduler para ejecutar de forma periódica la función de exportación de datos:

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

    Este trabajo está programado para ejecutarse a las 11:00 p.m. todos los días.

Prueba tu solución

El último paso es probar la solución. Para comenzar, ejecuta el trabajo de Cloud Scheduler.

  1. Ejecuta el trabajo de Cloud Scheduler de forma manual para activar un volcado de MySQL de tu base de datos.

    gcloud scheduler jobs run ${SCHEDULER_JOB}
    
  2. Enumera las operaciones realizadas en la instancia de MySQL y verifica que haya una operación de tipo EXPORT:

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

    El resultado muestra un trabajo de exportación completado, por ejemplo:

    NAME                                  TYPE    START                          END                            ERROR  STATUS
    8b031f0b-9d66-47fc-ba21-67dc20193749  EXPORT  2020-02-06T21:55:22.240+00:00  2020-02-06T21:55:32.614+00:00  -      DONE
    
  3. Verifica el bucket de Cloud Storage para ver si se creó el archivo de volcado de la base de datos:

    gsutil ls gs://${BUCKET_NAME} | grep backup-recommendation_spark
    

    Verás un archivo llamado backup-database_name-timestamp.gz después de que la operación STATUS del paso anterior muestre DONE.

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo. La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?