Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Compila una canalización de procesamiento de BigQuery para GKE con Eventarc

Estándar

En este instructivo, se muestra cómo usar Eventarc para compilar una canalización de procesamiento que programe consultas a un conjunto de datos públicos de BigQuery, genere gráficos basados en los datos y comparta vínculos a los gráficos por correo electrónico.

Objetivos

En este instructivo, compilarás e implementarás tres servicios de Google Kubernetes Engine (GKE) que se ejecutan en un clúster de GKE y que reciben eventos con Eventarc:

Ejecutor de consultas: Se activa cuando los trabajos de Cloud Scheduler publican un mensaje en un tema de Pub/Sub. Este servicio usa la API de BigQuery para recuperar datos de un conjunto de datos públicos sobre el COVID-19 y guardar los resultados en una nueva tabla de BigQuery.
Creador de gráficos: Se activa cuando el servicio del ejecutor de consultas publica un mensaje en un tema de Pub/Sub. Este servicio genera gráficos con la biblioteca de trazado de Python Matplotlib y guarda los gráficos en un bucket de Cloud Storage.
Notificador: Se activa mediante registros de auditoría cuando el servicio Creador de gráficos almacena un gráfico en un bucket de Cloud Storage; este servicio usa el servicio de correo electrónico SendGrid para enviar vínculos de los gráficos a una dirección de correo electrónico.

En el siguiente diagrama, se muestra la arquitectura de alto nivel:

Arquitectura de alto nivel de la canalización de procesamiento de BigQuery

Costos

En este documento, usarás 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 cumplan con los requisitos para acceder a una prueba gratuita.

Antes de comenzar

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Instala Google Cloud CLI.

Nota: Si ya instalaste gcloud CLI, ejecuta gcloud components update para asegurarte de tener la versión más reciente.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un Google Cloud proyecto.

Roles necesarios para seleccionar o crear un proyecto

Selecciona un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
Crea un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Crea un proyecto de Google Cloud :
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre de tu proyecto de Google Cloud .

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita las APIs de Artifact Registry, BigQuery, Cloud Build, Cloud Logging, Cloud Scheduler, Eventarc, GKE, Pub/Sub y Resource Manager, si aún no están habilitadas:

Roles necesarios para habilitar las APIs

Para habilitar APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

gcloud services enable artifactregistry.googleapis.com bigquery.googleapis.com cloudbuild.googleapis.com cloudresourcemanager.googleapis.com cloudscheduler.googleapis.com container.googleapis.com eventarc.googleapis.com pubsub.googleapis.com logging.googleapis.com

Instala Google Cloud CLI.

Nota: Si ya instalaste gcloud CLI, ejecuta gcloud components update para asegurarte de tener la versión más reciente.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un Google Cloud proyecto.

Roles necesarios para seleccionar o crear un proyecto

Selecciona un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
Crea un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Crea un proyecto de Google Cloud :
```
gcloud projects create PROJECT_ID
```
Reemplaza PROJECT_ID por un nombre para el proyecto de Google Cloud que estás creando.
Selecciona el proyecto de Google Cloud que creaste:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre de tu proyecto de Google Cloud .

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita las APIs de Artifact Registry, BigQuery, Cloud Build, Cloud Logging, Cloud Scheduler, Eventarc, GKE, Pub/Sub y Resource Manager, si aún no están habilitadas:

Roles necesarios para habilitar las APIs

gcloud services enable artifactregistry.googleapis.com bigquery.googleapis.com cloudbuild.googleapis.com cloudresourcemanager.googleapis.com cloudscheduler.googleapis.com container.googleapis.com eventarc.googleapis.com pubsub.googleapis.com logging.googleapis.com

En Cloud Storage, habilita el registro de auditoría para los tipos de acceso a los datos ADMIN_READ, DATA_WRITE y DATA_READ.
1. Lee la política de Identity and Access Management (IAM) asociada con tu organización, carpeta o proyecto de Google Cloud y almacénala en un archivo temporal:
```
gcloud projects get-iam-policy PROJECT_ID > /tmp/policy.yaml
```
2. En un editor de texto, abre /tmp/policy.yaml y agrega o cambia solo la configuración del registro de auditoría en la sección auditConfigs:
  
  Precaución: Debes conservar las secciones bindings: y etag: sin cambios. Si cambias partes de la política que no estén relacionadas con el registro de auditoría, esto podría hacer que tu Google Cloud proyecto sea inaccesible.
```
  auditConfigs:
  - auditLogConfigs:
    - logType: ADMIN_READ
    - logType: DATA_WRITE
    - logType: DATA_READ
    service: storage.googleapis.com
  bindings:
  - members:
  [...]
  etag: BwW_bHKTV5U=
  version: 1
```
3. Escribe tu nueva política de IAM:
```
gcloud projects set-iam-policy PROJECT_ID /tmp/policy.yaml
```
  Si el comando anterior informa de un conflicto con otro cambio, repite estos pasos y comienza por la lectura de la política de IAM. Para obtener más información, consulta Configura los registros de auditoría de acceso a los datos con la API.

Establece los valores predeterminados que se usan en este instructivo:

CLUSTER_NAME=events-cluster
CLUSTER_LOCATION=us-central1
PROJECT_ID=PROJECT_ID
gcloud config set project $PROJECT_ID
gcloud config set eventarc/location $CLUSTER_LOCATION

Reemplaza PROJECT_ID con el ID del proyecto.

Crea una clave de API de SendGrid

SendGrid es un proveedor de correo electrónico basado en la nube que te permite enviar correos electrónicos sin tener que mantener servidores de correo electrónico.

Accede a Sendgrid y ve a Configuración > Claves de API.
Haz clic en Crear clave de API.
Selecciona los permisos de la clave. La clave debe tener como mínimo permisos de envío de correo electrónico para enviar correos electrónicos.
Haz clic en Guardar para crear la clave.
SendGrid genera una clave nueva. Esta es la única copia de la clave, así que asegúrate de copiarla y guardarla para más adelante.

Crea un clúster de GKE

Crea un clúster con la Workload Identity Federation for GKE habilitada para que pueda acceder a los servicios de Google Cloud desde aplicaciones que se ejecutan en GKE. También necesitas Workload Identity Federation for GKE para reenviar eventos con Eventarc.

Crea un clúster de GKE con los complementos HttpLoadBalancing y HorizontalPodAutoscaling habilitados:

gcloud container clusters create $CLUSTER_NAME \
    --addons=HttpLoadBalancing,HorizontalPodAutoscaling \
    --machine-type=n1-standard-4 \
    --enable-autoscaling --min-nodes=2 --max-nodes=10 \
    --no-issue-client-certificate --num-nodes=2 \
    --logging=SYSTEM,WORKLOAD \
    --monitoring=SYSTEM \
    --scopes=cloud-platform,logging-write,monitoring-write,pubsub \
    --region=$CLUSTER_LOCATION \
    --release-channel=rapid \
    --workload-pool=$PROJECT_ID.svc.id.goog

Espera unos minutos a que finalice la creación del clúster. Durante el proceso, es posible que veas advertencias que puedes ignorar de forma segura. Cuando se crea el clúster, el resultado es similar al siguiente:
```
Creating cluster ...done.
Created [https://container.googleapis.com/v1/projects/my-project/zones/us-central1/clusters/events-cluster].
```
Actualiza el archivo kubeconfig con las credenciales y la información del extremo para que kubectl apunte al clúster de GKE:
```
gcloud container clusters get-credentials $CLUSTER_NAME \
    --region=$CLUSTER_LOCATION
```
Crea un repositorio estándar de Artifact Registry para almacenar tu imagen de contenedor de Docker:
```
gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=$CLUSTER_LOCATION
```
Reemplaza REPOSITORY por un nombre único para el repositorio.

Configura las cuentas de servicio

Para permitir que los nodos de GKE extraigan imágenes de contenedor de Artifact Registry, otorga el rol de lector de Artifact Registry (roles/artifactregistry.reader) en el proyecto a la cuenta de servicio predeterminada de Compute Engine que usan los nodos del clúster:

PROJECT_NUMBER="$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
  --condition=None \
  --role "roles/artifactregistry.reader"

Para permitir que los servicios de GKE consulten y escriban en BigQuery, publiquen en Pub/Sub y suban gráficos a Cloud Storage, otorga los roles de editor de datos de BigQuery (roles/bigquery.dataEditor), usuario de trabajos de BigQuery (roles/bigquery.jobUser), publicador de Pub/Sub (roles/pubsub.publisher) y administrador de objetos de Storage (roles/storage.objectAdmin) en el proyecto a la ServiceAccount de Kubernetes default en el espacio de nombres default:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
  --condition=None \
  --role "roles/bigquery.dataEditor"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
  --condition=None \
  --role "roles/bigquery.jobUser"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
  --condition=None \
  --role "roles/pubsub.publisher"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
  --condition=None \
  --role "roles/storage.objectAdmin"

Habilita los destinos de GKE

Para permitir que Eventarc administre recursos en el clúster de GKE, habilita los destinos de GKE y vincula la cuenta de servicio de Eventarc con los roles necesarios.

Habilita los destinos de GKE para Eventarc:
```
gcloud eventarc gke-destinations init
```
Cuando se te solicite vincular los roles necesarios, ingresa y.

Los siguientes roles están vinculados:
- roles/compute.viewer
- roles/container.developer
- roles/iam.serviceAccountAdmin

Cree un bucket de Cloud Storage

Crea un bucket de Cloud Storage en la misma región que tu servicio de GKE para guardar los gráficos y otorga a tu cuenta acceso de lectura (roles/storage.objectViewer) para ver los gráficos generados:

export BUCKET="$(gcloud config get-value core/project)-charts"
gcloud storage buckets create gs://${BUCKET} --location=$CLUSTER_LOCATION
gcloud storage buckets update gs://${BUCKET} --uniform-bucket-level-access
gcloud storage buckets add-iam-policy-binding gs://${BUCKET} \
    --member="user:$(gcloud config get-value core/account)" \
    --role=roles/storage.objectViewer

Clona el repositorio

Clona el repositorio de GitHub.

git clone https://github.com/GoogleCloudPlatform/eventarc-samples
cd eventarc-samples/processing-pipelines

Crea una cuenta de servicio y vincula los roles de acceso

Antes de crear los activadores de Eventarc, configura una cuenta de servicio administrada por el usuario y asígnale roles específicos para que Eventarc pueda reenviar los eventos de Pub/Sub.

Crea una cuenta de servicio llamada eventarc-triggers-test-sa:

TRIGGER_GSA=eventarc-triggers-test-sa
gcloud iam service-accounts create $TRIGGER_GSA

Otorga las funciones pubsub.subscriber, monitoring.metricWriter y eventarc.eventReceiver a la cuenta de servicio:

PROJECT_ID=$(gcloud config get-value project)

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member "serviceAccount:$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com" \
    --condition=None \
    --role "roles/pubsub.subscriber"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member "serviceAccount:$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com" \
    --condition=None \
    --role "roles/monitoring.metricWriter"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member "serviceAccount:$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com" \
    --condition=None \
    --role "roles/eventarc.eventReceiver"

Implementa el servicio de notificador

Desde el directorio bigquery/notifier/python, implementa un servicio de GKE que reciba eventos del creador de gráficos y use SendGrid para enviar vínculos por correo electrónico a los gráficos generados.

Compila y envía la imagen del contenedor:

pushd bigquery/notifier/python
export SERVICE_NAME=notifier
docker build -t $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1 .
docker push $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1
popd

Crea una implementación de Kubernetes para la imagen de contenedor y configura las variables de entorno necesarias, incluida una dirección a la que se enviarán los correos electrónicos y la clave de API de SendGrid:
```
export TO_EMAILS=EMAIL_ADDRESS
export SENDGRID_API_KEY=YOUR_SENDGRID_API_KEY
kubectl create deployment ${SERVICE_NAME} \
    --image=$CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1
kubectl set env deployment/${SERVICE_NAME} \
    TO_EMAILS=${TO_EMAILS} \
    SENDGRID_API_KEY=${SENDGRID_API_KEY} \
    BUCKET=${BUCKET}
```
Reemplaza lo siguiente:
- EMAIL_ADDRESS: una dirección de correo electrónico para enviar los vínculos a los gráficos generados
- YOUR_SENDGRID_API_KEY: la clave de API de SendGrid que anotaste antes
- REPOSITORY: Es el nombre de tu repositorio de Artifact Registry.

Expón la implementación como un servicio de Kubernetes:

kubectl expose deployment ${SERVICE_NAME} \
    --type=ClusterIP --port=80 --target-port=8080

Crea un activador para el servicio Notificador

Crea un activador de Eventarc para el servicio de notificador implementado en GKE que filtre los registros de auditoría de Cloud Storage para el bucket de Cloud Storage especificado y donde el methodName sea storage.objects.create:

gcloud eventarc triggers create trigger-${SERVICE_NAME}-gke \
      --destination-gke-cluster=$CLUSTER_NAME \
      --destination-gke-location=$CLUSTER_LOCATION \
      --destination-gke-namespace=default \
      --destination-gke-service=$SERVICE_NAME \
      --destination-gke-path=/ \
      --event-filters="type=google.cloud.audit.log.v1.written" \
      --event-filters="serviceName=storage.googleapis.com" \
      --event-filters="methodName=storage.objects.create" \
      --event-filters-path-pattern="resourceName=/projects/_/buckets/$BUCKET/objects/*" \
      --service-account=$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com

Esto crea un activador llamado trigger-notifier-gke.

Implementa el servicio del creador de gráficos

Desde el directorio bigquery/chart-creator/python, implementa un servicio de GKE que reciba eventos del ejecutor de consultas, recupere datos de una tabla de BigQuery para un país específico y, luego, genere un gráfico con Matplotlib a partir de los datos. El gráfico se sube a un bucket de Cloud Storage.

Compila y envía la imagen del contenedor:

pushd bigquery/chart-creator/python
export SERVICE_NAME=chart-creator
docker build -t $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1 .
docker push $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1
popd

Crea una implementación de Kubernetes para la imagen de contenedor y configura la variable de entorno BUCKET:

kubectl create deployment ${SERVICE_NAME} \
    --image=$CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1
kubectl set env deployment/${SERVICE_NAME} \
    BUCKET=${BUCKET}

Expón la implementación como un servicio de Kubernetes:

kubectl expose deployment ${SERVICE_NAME} \
    --type=ClusterIP --port=80 --target-port=8080

Crea un activador para el servicio Creador de gráficos

Crea un activador de Eventarc para el servicio de creador de gráficos implementado en GKE que filtre los mensajes publicados en un tema de Pub/Sub.

Crea el activador:

gcloud eventarc triggers create trigger-${SERVICE_NAME}-gke \
    --destination-gke-cluster=$CLUSTER_NAME \
    --destination-gke-location=$CLUSTER_LOCATION \
    --destination-gke-namespace=default \
    --destination-gke-service=$SERVICE_NAME \
    --destination-gke-path=/ \
    --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
    --service-account=$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com

Esto crea un activador llamado trigger-chart-creator-gke.

Configura la variable de entorno del tema de Pub/Sub.

export TOPIC_QUERY_COMPLETED=$(basename $(gcloud eventarc triggers describe trigger-${SERVICE_NAME}-gke --format='value(transport.pubsub.topic)'))

Implementa el servicio del ejecutor de consultas

Desde el directorio processing-pipelines, implementa un servicio de GKE que reciba eventos de Cloud Scheduler, recupera datos de un conjunto de datos públicos del COVID-19 y guarda los resultados en una tabla de BigQuery nueva.

Compila y envía la imagen del contenedor:

export SERVICE_NAME=query-runner
docker build -t $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1 -f Dockerfile .
docker push $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1

Crea una implementación de Kubernetes para la imagen de contenedor y establece las variables de entorno PROJECT_ID y TOPIC_ID:

kubectl create deployment ${SERVICE_NAME} \
    --image=$CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1
kubectl set env deployment/${SERVICE_NAME} \
    PROJECT_ID=$(gcloud config get-value project) \
    TOPIC_ID=${TOPIC_QUERY_COMPLETED}

Expón la implementación como un servicio de Kubernetes:

kubectl expose deployment ${SERVICE_NAME} \
    --type=ClusterIP --port=80 --target-port=8080

Crea un activador para el servicio Ejecutor de consultas

Crea un activador de Eventarc para el servicio del ejecutor de consultas implementado en GKE que filtre los mensajes publicados en un tema de Pub/Sub.

Crea el activador:

gcloud eventarc triggers create trigger-${SERVICE_NAME}-gke \
    --destination-gke-cluster=$CLUSTER_NAME \
    --destination-gke-location=$CLUSTER_LOCATION \
    --destination-gke-namespace=default \
    --destination-gke-service=$SERVICE_NAME \
    --destination-gke-path=/ \
    --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
    --service-account=$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com

Esto crea un activador llamado trigger-query-runner-gke.

Configura una variable de entorno para el tema de Pub/Sub.

export TOPIC_QUERY_SCHEDULED=$(basename $(gcloud eventarc triggers describe trigger-${SERVICE_NAME}-gke --format='value(transport.pubsub.topic)'))

Programa los trabajos

La canalización de procesamiento se activa mediante dos trabajos de Cloud Scheduler. Crea dos trabajos de Cloud Scheduler que se publiquen en un tema de Pub/Sub una vez al día:

gcloud scheduler jobs create pubsub cre-scheduler-uk \
      --location=$CLUSTER_LOCATION \
      --schedule="0 16 * * *" \
      --topic=${TOPIC_QUERY_SCHEDULED} \
      --message-body="United Kingdom"

gcloud scheduler jobs create pubsub cre-scheduler-cy \
      --location=$CLUSTER_LOCATION \
      --schedule="0 17 * * *" \
      --topic=${TOPIC_QUERY_SCHEDULED} \
      --message-body="Cyprus"

El programa se especifica en formato unix-cron. Por ejemplo, 0 16 * * * significa que los trabajos se ejecutan a las 16:00 (4 p.m.) UTC todos los días.

Ejecuta la canalización

Confirma que todos los activadores se hayan creado de forma correcta:

gcloud eventarc triggers list

El resultado debería ser similar al siguiente ejemplo:

NAME                       TYPE                                            DESTINATION         ACTIVE  LOCATION
trigger-chart-creator-gke  google.cloud.pubsub.topic.v1.messagePublished   GKE:chart-creator   Yes     us-central1
trigger-notifier-gke       google.cloud.audit.log.v1.written               GKE:notifier        Yes     us-central1
trigger-query-runner-gke   google.cloud.pubsub.topic.v1.messagePublished   GKE:query-runner    Yes     us-central1

Recupera los ID de trabajo de Cloud Scheduler:

gcloud scheduler jobs list --location=$CLUSTER_LOCATION

El resultado debería ser similar al ejemplo siguiente:

ID                LOCATION      SCHEDULE (TZ)         TARGET_TYPE  STATE
cre-scheduler-cy  us-central1   0 17 * * * (Etc/UTC)  Pub/Sub      ENABLED
cre-scheduler-uk  us-central1   0 16 * * * (Etc/UTC)  Pub/Sub      ENABLED

Aunque los trabajos están programados para ejecutarse a diario a las 4 y 5 p.m., también puedes ejecutar los trabajos de Cloud Scheduler de forma manual:
```
gcloud scheduler jobs run cre-scheduler-cy --location=$CLUSTER_LOCATION
```
```
gcloud scheduler jobs run cre-scheduler-uk --location=$CLUSTER_LOCATION
```
Después de unos minutos, confirma que haya dos gráficos en el bucket de Cloud Storage:
```
gcloud storage ls gs://${BUCKET}
```
El resultado debería ser similar al ejemplo siguiente:
```
gs://PROJECT_ID-charts/chart-cyprus.png
gs://PROJECT_ID-charts/chart-unitedkingdom.png
```

¡Felicitaciones! También deberías recibir dos correos electrónicos con vínculos a los gráficos.

Realiza una limpieza

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y quieres conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo su contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

Borra un proyecto de Google Cloud :

gcloud projects delete PROJECT_ID

Elimina recursos de instructivos

Borra los servicios y los objetos Deployment de Kubernetes que implementaste en este instructivo, y borra el clúster de GKE:

kubectl delete service notifier chart-creator query-runner
kubectl delete deployment notifier chart-creator query-runner
gcloud container clusters delete $CLUSTER_NAME --region=$CLUSTER_LOCATION

Borra cualquier activador de Eventarc que hayas creado en este instructivo:
```
gcloud eventarc triggers delete TRIGGER_NAME
```
Reemplaza TRIGGER_NAME por el nombre de tu activador.

Borra las imágenes de Artifact Registry:

gcloud artifacts docker images delete $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/notifier:v1
gcloud artifacts docker images delete $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/chart-creator:v1
gcloud artifacts docker images delete $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/query-runner:v1

Borra el repositorio de Artifact Registry:

gcloud artifacts repositories delete REPOSITORY \
    --location=$CLUSTER_LOCATION

Borra el bucket, junto con todos los objetos dentro del bucket:
```
gcloud storage rm --recursive gs://${BUCKET}/
```

Borra los trabajos de Cloud Scheduler:

gcloud scheduler jobs delete cre-scheduler-cy --location=$CLUSTER_LOCATION
gcloud scheduler jobs delete cre-scheduler-uk --location=$CLUSTER_LOCATION

Quita las opciones de configuración predeterminadas de Google Cloud CLI que agregaste durante la configuración del instructivo:
```
gcloud config unset project
gcloud config unset eventarc/location
```

Compila una canalización de procesamiento de BigQuery para GKE con Eventarc Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Objetivos

Costos

Antes de comenzar

Crea una clave de API de SendGrid

Crea un clúster de GKE

Configura las cuentas de servicio

Habilita los destinos de GKE

Cree un bucket de Cloud Storage

Clona el repositorio

Crea una cuenta de servicio y vincula los roles de acceso

Implementa el servicio de notificador

Crea un activador para el servicio Notificador

Implementa el servicio del creador de gráficos

Crea un activador para el servicio Creador de gráficos

Implementa el servicio del ejecutor de consultas

Crea un activador para el servicio Ejecutor de consultas

Programa los trabajos

Ejecuta la canalización

Realiza una limpieza

Elimina recursos de instructivos

¿Qué sigue?

Compila una canalización de procesamiento de BigQuery para GKE con Eventarc