Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Crea una pipeline di elaborazione BigQuery per GKE con Eventarc

Standard

Questo tutorial mostra come utilizzare Eventarc per creare una pipeline di elaborazione che pianifica query su un set di dati BigQuery pubblico, genera grafici in base ai dati e condivide i link ai grafici tramite email.

Obiettivi

In questo tutorial, creerai ed eseguirai il deployment di tre servizi Google Kubernetes Engine (GKE) in esecuzione in un cluster GKE che ricevono eventi utilizzando Eventarc:

Query Runner: attivato quando i job di Cloud Scheduler pubblicano un messaggio in un argomento Pub/Sub. Questo servizio utilizza l'API BigQuery per recuperare i dati da un set di dati pubblico sul COVID-19 e salva i risultati in una nuova tabella BigQuery.
Creatore di grafici: attivato quando il servizio di esecuzione delle query pubblica un messaggio in un argomento Pub/Sub; questo servizio genera grafici utilizzando la libreria di tracciamento Python, Matplotlib, e salva i grafici in un bucket Cloud Storage.
Notifier: attivato dai log di controllo quando il servizio di creazione dei grafici archivia un grafico in un bucket Cloud Storage; questo servizio utilizza il servizio email SendGrid per inviare i link dei grafici a un indirizzo email.

Il seguente diagramma mostra l'architettura di alto livello:

Architettura di alto livello della pipeline di elaborazione BigQuery

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

Installa Google Cloud CLI.

Nota: se hai già installato gcloud CLI, assicurati di avere l'ultima versione eseguendo gcloud components update.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per cui ti è stato concesso un ruolo.
Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Crea un progetto Google Cloud :
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Abilita le API Artifact Registry, BigQuery, Cloud Build, Cloud Logging, Cloud Scheduler, Eventarc, GKE, Pub/Sub e API Resource Manager, se non sono già abilitate:

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

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

Installa Google Cloud CLI.

Nota: se hai già installato gcloud CLI, assicurati di avere l'ultima versione eseguendo gcloud components update.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per cui ti è stato concesso un ruolo.
Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Crea un progetto Google Cloud :
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Abilita le API Artifact Registry, BigQuery, Cloud Build, Cloud Logging, Cloud Scheduler, Eventarc, GKE, Pub/Sub e API Resource Manager, se non sono già abilitate:

Ruoli richiesti per abilitare le API

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

Per Cloud Storage, abilita l'audit logging per i tipi di accesso ai dati ADMIN_READ, DATA_WRITE e DATA_READ.
1. Leggi il criterio Identity and Access Management (IAM) associato al tuo Google Cloud progetto, alla tua cartella o alla tua organizzazione e archivialo in un file temporaneo:
```
gcloud projects get-iam-policy PROJECT_ID > /tmp/policy.yaml
```
2. In un editor di testo, apri /tmp/policy.yaml e aggiungi o modifica solo la configurazione del log di controllo nella sezione auditConfigs:
  
  Attenzione: devi conservare le sezioni bindings: e etag: senza modifiche. La modifica di parti della policy non correlate alla registrazione degli audit log potrebbe rendere il tuo Google Cloud progetto inaccessibile.
```
  auditConfigs:
  - auditLogConfigs:
    - logType: ADMIN_READ
    - logType: DATA_WRITE
    - logType: DATA_READ
    service: storage.googleapis.com
  bindings:
  - members:
  [...]
  etag: BwW_bHKTV5U=
  version: 1
```
3. Scrivi la nuova policy IAM:
```
gcloud projects set-iam-policy PROJECT_ID /tmp/policy.yaml
```
  Se il comando precedente segnala un conflitto con un'altra modifica, ripeti questi passaggi, iniziando dalla lettura della policy IAM. Per saperne di più, consulta Configura i log di controllo dell'accesso ai dati con l'API.

Imposta i valori predefiniti utilizzati in questo tutorial:

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

Sostituisci PROJECT_ID con l'ID progetto.

Crea una chiave API SendGrid

SendGrid è un provider email basato su cloud che ti consente di inviare email senza dover gestire i server email.

Accedi a SendGrid e vai a Impostazioni > Chiavi API.
Fai clic su Crea chiave API.
Seleziona le autorizzazioni per la chiave. Per inviare email, la chiave deve disporre come minimo delle autorizzazioni per l'invio di email.
Fai clic su Salva per creare la chiave.
SendGrid genera una nuova chiave. Si tratta dell'unica copia della chiave, quindi assicurati di copiarla e salvarla per utilizzarla in un secondo momento.

Crea un cluster GKE

Crea un cluster con Workload Identity Federation for GKE abilitato in modo che possa accedere ai servizi Google Cloud dalle applicazioni in esecuzione in GKE. Devi anche utilizzare Workload Identity Federation for GKE per inoltrare gli eventi utilizzando Eventarc.

Crea un cluster GKE con i componenti aggiuntivi HttpLoadBalancing e HorizontalPodAutoscaling abilitati:

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

Attendi qualche minuto per il completamento della creazione del cluster. Durante la procedura, potresti visualizzare avvisi che puoi ignorare tranquillamente. Una volta creato il cluster, l'output è simile al seguente:
```
Creating cluster ...done.
Created [https://container.googleapis.com/v1/projects/my-project/zones/us-central1/clusters/events-cluster].
```
Aggiorna il file kubeconfig con le credenziali e le informazioni sull'endpoint per indirizzare kubectl al cluster GKE:
```
gcloud container clusters get-credentials $CLUSTER_NAME \
    --region=$CLUSTER_LOCATION
```
Crea un repository standard di Artifact Registry in cui puoi archiviare l'immagine container Docker:
```
gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=$CLUSTER_LOCATION
```
Sostituisci REPOSITORY con un nome univoco per il repository.

Configura i service account

Per consentire ai nodi GKE di eseguire il pull delle immagini container da Artifact Registry, concedi il ruolo Lettore Artifact Registry (roles/artifactregistry.reader) sul progetto al account di servizio predefinito di Compute Engine utilizzato dai nodi del cluster:

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"

Per consentire ai servizi GKE di eseguire query e scrivere su BigQuery, pubblicare su Pub/Sub e caricare grafici su Cloud Storage, concedi i ruoli BigQuery Data Editor (roles/bigquery.dataEditor), BigQuery Job User (roles/bigquery.jobUser), Pub/Sub Publisher (roles/pubsub.publisher) e Storage Object Admin (roles/storage.objectAdmin) nel progetto al ServiceAccount Kubernetes default nello spazio dei nomi 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"

Abilita le destinazioni GKE

Per consentire a Eventarc di gestire le risorse nel cluster GKE, abilita le destinazioni GKE e associa il account di servizio Eventarc ai ruoli richiesti.

Abilita le destinazioni GKE per Eventarc:
```
gcloud eventarc gke-destinations init
```
Al prompt per associare i ruoli richiesti, inserisci y.

Sono associati i seguenti ruoli:
- roles/compute.viewer
- roles/container.developer
- roles/iam.serviceAccountAdmin

Crea un bucket Cloud Storage

Crea un bucket Cloud Storage nella stessa regione del tuo servizio GKE per salvare i grafici e concedi al tuo account l'accesso in lettura (roles/storage.objectViewer) per visualizzare i grafici generati:

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 il repository

Clona il repository GitHub.

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

Crea un account di servizio e associa i ruoli di accesso

Prima di creare i trigger Eventarc, configura un account di servizio gestito dall'utente e concedigli ruoli specifici in modo che Eventarc possa inoltrare gli eventi Pub/Sub.

Crea un account di servizio denominato eventarc-triggers-test-sa:

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

Concedi i ruoli pubsub.subscriber, monitoring.metricWriter e eventarc.eventReceiver al account di servizio:

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"

Esegui il deployment del servizio di notifica

Dalla directory bigquery/notifier/python, esegui il deployment di un servizio GKE che riceve gli eventi del generatore di grafici e utilizza SendGrid per inviare via email i link ai grafici generati.

Crea ed esegui il push dell'immagine container:

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 un deployment Kubernetes per l'immagine container e imposta le variabili di ambiente richieste, tra cui un indirizzo a cui inviare le email e la chiave API 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}

Sostituisci quanto segue:

EMAIL_ADDRESS: un indirizzo email a cui inviare i link ai grafici generati
YOUR_SENDGRID_API_KEY: la chiave API SendGrid che hai annotato in precedenza
REPOSITORY: il nome del repository Artifact Registry

Esponi il deployment come servizio Kubernetes:

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

Crea un trigger per il servizio di notifica

Crea un trigger Eventarc per il servizio di notifica di cui è stato eseguito il deployment su GKE che filtra gli audit log di Cloud Storage per il bucket Cloud Storage specificato e dove methodName è 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

Viene creato un trigger denominato trigger-notifier-gke.

Esegui il deployment del servizio di creazione dei grafici

Dalla directory bigquery/chart-creator/python, implementa un servizio GKE che riceve eventi di esecuzione di query, recupera i dati da una tabella BigQuery per un paese specifico e poi genera un grafico, utilizzando Matplotlib, dai dati. Il grafico viene caricato in un bucket Cloud Storage.

Crea ed esegui il push dell'immagine container:

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 un deployment Kubernetes per l'immagine container e imposta la variabile di ambiente 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}

Esponi il deployment come servizio Kubernetes:

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

Crea un trigger per il servizio di creazione di grafici

Crea un trigger Eventarc per il servizio di creazione di grafici di cui è stato eseguito il deployment su GKE che filtra i messaggi pubblicati in un topic Pub/Sub.

Crea il trigger:

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

Viene creato un trigger denominato trigger-chart-creator-gke.

Imposta la variabile di ambiente dell'argomento Pub/Sub.

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

Esegui il deployment del servizio di esecuzione delle query

Dalla directory processing-pipelines, esegui il deployment di un servizio GKE che riceve gli eventi di Cloud Scheduler, recupera i dati da un set di dati pubblico sul COVID-19 e salva i risultati in una nuova tabella BigQuery.

Crea ed esegui il push dell'immagine container:

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 un deployment Kubernetes per l'immagine container e imposta le variabili di ambiente PROJECT_ID e 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}

Esporre il deployment come servizio Kubernetes:

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

Crea un trigger per il servizio di esecuzione delle query

Crea un trigger Eventarc per il servizio di esecuzione delle query di cui è stato eseguito il deployment su GKE che filtra i messaggi pubblicati in un argomento Pub/Sub.

Crea il trigger:

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

Viene creato un trigger denominato trigger-query-runner-gke.

Imposta una variabile di ambiente per l'argomento Pub/Sub.

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

Pianifica i job

La pipeline di elaborazione viene attivata da due job Cloud Scheduler. Crea due job Cloud Scheduler che pubblicano in un argomento Pub/Sub una volta al giorno:

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"

La pianificazione è specificata nel formato unix-cron. Ad esempio, 0 16 * * * significa che i job vengono eseguiti alle 16:00 (4 PM) UTC ogni giorno.

esegui la pipeline.

Verifica che tutti i trigger siano stati creati correttamente:

gcloud eventarc triggers list

L'output dovrebbe essere simile al seguente:

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 gli ID job di Cloud Scheduler:

gcloud scheduler jobs list --location=$CLUSTER_LOCATION

L'output dovrebbe essere simile al seguente:

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

Anche se i job sono programmati per essere eseguiti ogni giorno alle 16:00 e alle 17:00, puoi anche eseguire manualmente i job di Cloud Scheduler:

gcloud scheduler jobs run cre-scheduler-cy --location=$CLUSTER_LOCATION

gcloud scheduler jobs run cre-scheduler-uk --location=$CLUSTER_LOCATION

Dopo qualche minuto, verifica che nel bucket Cloud Storage siano presenti due grafici:
```
gcloud storage ls gs://${BUCKET}
```
L'output dovrebbe essere simile al seguente:
```
gs://PROJECT_ID-charts/chart-cyprus.png
gs://PROJECT_ID-charts/chart-unitedkingdom.png
```

Complimenti! Dovresti anche ricevere due email con i link ai grafici.

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Elimina un progetto Google Cloud :

gcloud projects delete PROJECT_ID

Elimina le risorse del tutorial

Elimina i servizi e i deployment Kubernetes di cui hai eseguito il deployment in questo tutorial ed elimina il cluster 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

Elimina tutti i trigger Eventarc che hai creato in questo tutorial:
```
gcloud eventarc triggers delete TRIGGER_NAME
```
Sostituisci TRIGGER_NAME con il nome del trigger.

Elimina le immagini da 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

Elimina il repository Artifact Registry:

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

Elimina il bucket e tutti gli oggetti al suo interno:
```
gcloud storage rm --recursive gs://${BUCKET}/
```

Elimina i job Cloud Scheduler:

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

Rimuovi le configurazioni predefinite di Google Cloud CLI che hai aggiunto durante la configurazione del tutorial:
```
gcloud config unset project
gcloud config unset eventarc/location
```

Crea una pipeline di elaborazione BigQuery per GKE con Eventarc Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Crea una chiave API SendGrid

Crea un cluster GKE

Configura i service account

Abilita le destinazioni GKE

Crea un bucket Cloud Storage

Clona il repository

Crea un account di servizio e associa i ruoli di accesso

Esegui il deployment del servizio di notifica

Crea un trigger per il servizio di notifica

Esegui il deployment del servizio di creazione dei grafici

Crea un trigger per il servizio di creazione di grafici

Esegui il deployment del servizio di esecuzione delle query

Crea un trigger per il servizio di esecuzione delle query

Pianifica i job

esegui la pipeline.

Esegui la pulizia

Elimina le risorse del tutorial

Passaggi successivi

Crea una pipeline di elaborazione BigQuery per GKE con Eventarc