Creazione di una pipeline di elaborazione di BigQuery con Eventarc per Cloud Run for Anthos

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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

Obiettivi

In questo tutorial, creerai ed eseguirai il deployment di tre servizi Cloud Run for Anthos in esecuzione in un cluster Google Kubernetes Engine (GKE) e che riceveranno eventi utilizzando Eventarc:

  1. Query runner: viene 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 COVID-19 e salva i risultati in una nuova tabella BigQuery.
  2. Creatore di grafici: viene 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.
  3. Notificatore: viene attivato dai log di controllo quando il servizio di creazione grafici archivia un grafico in un bucket Cloud Storage; questo servizio utilizza il servizio email, SendGrid, per inviare link ai grafici a un indirizzo email.

Il seguente diagramma mostra l'architettura generale:

Pipeline di elaborazione BigQuery

Costi

Questo tutorial utilizza 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 possono beneficiare di una prova gratuita.

Prima di iniziare

  1. 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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API Cloud Build, Cloud Logging, Cloud Run for Anthos, Cloud Scheduler, Container Registry, Eventarc, GKE, Pub/Sub, and Resource Manager .

    Abilita le API

  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Abilita le API Cloud Build, Cloud Logging, Cloud Run for Anthos, Cloud Scheduler, Container Registry, Eventarc, GKE, Pub/Sub, and Resource Manager .

    Abilita le API

  8. Installa e inizializza l'interfaccia a riga di comando di Google Cloud.
  9. Aggiorna i componenti gcloud:
    gcloud components update
  10. Accedi utilizzando il tuo account:
    gcloud auth login
  11. Seleziona Google Cloud Storage e abilita Lettura amministratore, Lettura dati e Tipi di log per la scrittura di dati: Vai agli audit log di Cloud
  12. Configura le impostazioni predefinite utilizzate in questo tutorial:
    CLUSTER_NAME=events-cluster
    CLUSTER_LOCATION=us-central1
    PROJECT_ID=PROJECT_ID
    
    gcloud config set project $PROJECT_ID
    gcloud config set run/region $CLUSTER_LOCATION
    gcloud config set run/cluster $CLUSTER_NAME
    gcloud config set run/cluster_location $CLUSTER_LOCATION
    gcloud config set run/platform gke
    gcloud config set eventarc/location $CLUSTER_LOCATION
    
    Sostituisci PROJECT_ID con l'ID progetto.
  13. Scarica e installa lo strumento di gestione del codice sorgente Git.

Creare una chiave API SendGrid

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

  1. Accedi a SendGrid e vai a Settings > API Keys (Impostazioni e chiavi API).
  2. Fai clic su Crea chiave API.
  3. Seleziona le autorizzazioni per la chiave. La chiave deve avere almeno le autorizzazioni Invio di posta per inviare email.
  4. Fai clic su Salva per creare la chiave.
  5. SendGrid genera una nuova chiave. Questa è l'unica copia della chiave, quindi assicurati di copiarla e di salvarla per un secondo momento.

Crea un cluster GKE per Cloud Run for Anthos

Crea un cluster con Workload Identity abilitato in modo da poter accedere ai servizi Google Cloud dalle applicazioni in esecuzione all'interno di GKE. Workload Identity è necessario anche per inoltrare gli eventi utilizzando Eventarc.

  1. Crea un cluster GKE per Cloud Run for Anthos con i componenti aggiuntivi CloudRun, HttpLoadBalancing e HorizontalPodAutoscaling abilitati:

    gcloud beta container clusters create $CLUSTER_NAME \
      --addons=HttpLoadBalancing,HorizontalPodAutoscaling,CloudRun \
      --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 \
      --zone us-central1 \
      --release-channel=rapid \
      --workload-pool=$PROJECT_ID.svc.id.goog
    
  2. Attendi qualche minuto per il completamento della creazione del cluster. Durante il processo, potresti visualizzare avvisi che puoi ignorare senza problemi. Dopo aver creato il cluster, l'output è simile al seguente:

    Creating cluster ...done.
    Created [https://container.googleapis.com/v1beta1/projects/my-project/zones/us-central1/clusters/my-cluster].
    

Configura l'account di servizio GKE

Configura un account di servizio GKE in modo che agisca come account di servizio di computing predefinito.

  1. Crea un'associazione IAM (Gestione di identità e accessi) tra gli account di servizio:

    PROJECT_NUMBER="$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')"
    
    gcloud iam service-accounts add-iam-policy-binding \
      --role roles/iam.workloadIdentityUser \
      --member "serviceAccount:$PROJECT_ID.svc.id.goog[default/default]" \
      $PROJECT_NUMBER-compute@developer.gserviceaccount.com
    
  2. Aggiungi l'annotazione iam.gke.io/gcp-service-account all'account di servizio GKE, utilizzando l'indirizzo email dell'account di servizio Compute:

    kubectl annotate serviceaccount \
      --namespace default \
      default \
      iam.gke.io/gcp-service-account=$PROJECT_NUMBER-compute@developer.gserviceaccount.com
    

Abilita destinazioni GKE

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

  1. Abilita destinazioni GKE per Eventarc:

    gcloud eventarc gke-destinations init
    
  2. Quando ti viene richiesto di associare i ruoli richiesti, inserisci y.

    Sono vincolati i seguenti ruoli:

    • roles/compute.viewer
    • roles/container.developer
    • roles/iam.serviceAccountAdmin

Crea un account di servizio e associa i ruoli di accesso

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

  1. Crea un account di servizio denominato TRIGGER_GSA:

    TRIGGER_GSA=eventarc-bigquery-triggers
    gcloud iam service-accounts create $TRIGGER_GSA
  2. Concedi i ruoli pubsub.subscriber, monitoring.metricWriter e eventarc.eventReceiver all'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" \
    --role "roles/pubsub.subscriber"
    
    gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member "serviceAccount:$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com" \
    --role "roles/monitoring.metricWriter"
    
    gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member "serviceAccount:$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com" \
    --role "roles/eventarc.eventReceiver"
    

Crea un bucket Cloud Storage

Crea un bucket Cloud Storage per salvare i grafici. Assicurati che il bucket e i grafici siano disponibili pubblicamente e nella stessa area geografica del servizio Cloud Run for Anthos:

  export BUCKET="$(gcloud config get-value core/project)-charts"
  gsutil mb -l $(gcloud config get-value run/region) gs://${BUCKET}
  gsutil uniformbucketlevelaccess set on gs://${BUCKET}
  gsutil iam ch allUsers:objectViewer gs://${BUCKET}
  

Clona il repository

Clona il repository GitHub.

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

Esegui il deployment del servizio di notifica

Dalla directory bigquery/notifier/python, esegui il deployment di un servizio Cloud Run for Anthos che riceve eventi di creazione di grafici e utilizza SendGrid per l'invio di link email ai grafici generati.

  1. Crea ed esegui il push dell'immagine container:

    pushd bigquery/notifier/python
    export SERVICE_NAME=notifier
    docker build -t gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 .
    docker push gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1
    popd
    
  2. Esegui il deployment dell'immagine container su Cloud Run for Anthos, trasmettendo un indirizzo a cui inviare email e la chiave API SendGrid:

    export TO_EMAILS=EMAIL_ADDRESS
    export SENDGRID_API_KEY=YOUR_SENDGRID_API_KEY
    gcloud run deploy ${SERVICE_NAME} \
        --image gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 \
        --update-env-vars TO_EMAILS=${TO_EMAILS},SENDGRID_API_KEY=${SENDGRID_API_KEY},BUCKET=${BUCKET}
    

    Sostituisci quanto segue:

    • EMAIL_ADDRESS con un indirizzo email per inviare i link ai grafici generati
    • YOUR_SENDGRID_API_KEY con la chiave API SendGrid annotata in precedenza

Quando viene visualizzato l'URL del servizio, il deployment è completo.

Crea un attivatore per il servizio di notifica

Il trigger Eventarc per il servizio di notifica eseguito il deployment sui filtri Cloud Run for Anthos per i log di controllo di Cloud Storage in cui il metodoName è storage.objects.create.

  1. Crea l'attivatore:

    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" \
        --service-account=$TRIGGER_GSA@$PROJECT_ID.iam.gserviceaccount.com
    

    Viene creato un trigger denominato trigger-notifier-gke.

Deployment del servizio di creazione grafici

Dalla directory bigquery/chart-creator/python, esegui il deployment di un servizio Cloud Run for Anthos che riceve eventi runner 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.

  1. Crea ed esegui il push dell'immagine container:

    pushd bigquery/chart-creator/python
    export SERVICE_NAME=chart-creator
    docker build -t gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 .
    docker push gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1
    popd
    
  2. Esegui il deployment dell'immagine container su Cloud Run for Anthos, passando in BUCKET:

    gcloud run deploy ${SERVICE_NAME} \
      --image gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 \
      --update-env-vars BUCKET=${BUCKET}
    

Quando viene visualizzato l'URL del servizio, il deployment è completo.

Crea un attivatore per il servizio di creazione grafici

Il trigger Eventarc per il servizio di creazione di grafici sottoposto a deployment su filtri di Cloud Run for Anthos per i messaggi pubblicati in un argomento Pub/Sub.

  1. Crea l'attivatore:

    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.

  2. 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 Runner della query

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

  1. Crea ed esegui il push dell'immagine container:

    export SERVICE_NAME=query-runner
    docker build -t gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 -f bigquery/${SERVICE_NAME}/csharp/Dockerfile .
    docker push gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1
    
  2. Esegui il deployment dell'immagine container su Cloud Run for Anthos, passando in PROJECT_ID e TOPIC_QUERY_COMPLETED:

    gcloud run deploy ${SERVICE_NAME} \
      --image gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 \
      --update-env-vars PROJECT_ID=$(gcloud config get-value project),TOPIC_ID=${TOPIC_QUERY_COMPLETED}
    

Quando viene visualizzato l'URL del servizio, il deployment è completo.

Crea un attivatore per il servizio Query runner

Il trigger Eventarc per il servizio Query runner con deployment su filtri di Cloud Run for Anthos per i messaggi pubblicati in un argomento Pub/Sub.

  1. Crea l'attivatore:

    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.

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

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

Programmare i job

La pipeline di elaborazione viene attivata da due job di Cloud Scheduler.

  1. Crea un'app App Engine obbligatoria da Cloud Scheduler e specifica una località appropriata (ad esempio: europe-west):

    export APP_ENGINE_LOCATION=LOCATION
    gcloud app create --region=${APP_ENGINE_LOCATION}
    
  2. Crea due job Cloud Scheduler che vengono pubblicati in un argomento Pub/Sub una volta al giorno:

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

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

Esegui la pipeline.

  1. Conferma che tutti gli attivatori siano stati creati correttamente:

    gcloud eventarc triggers list
    

    L'output dovrebbe essere simile al seguente:

    NAME                       TYPE                                            DESTINATION_RUN_SERVICE  DESTINATION_RUN_PATH  ACTIVE
    trigger-chart-creator-gke  google.cloud.pubsub.topic.v1.messagePublished                                                  Yes
    trigger-notifier-gke       google.cloud.audit.log.v1.written                                                              Yes
    trigger-query-runner-gke   google.cloud.pubsub.topic.v1.messagePublished                                                  Yes
    
  2. Recupera gli ID job di Cloud Scheduler:

    gcloud scheduler jobs list
    

    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
    
  3. Anche se i job sono pianificati per l'esecuzione giornaliera alle 16:00 e alle 17:00, puoi eseguire i job di Cloud Scheduler manualmente:

    gcloud scheduler jobs run cre-scheduler-cy
    gcloud scheduler jobs run cre-scheduler-uk
    
  4. Dopo qualche minuto, verifica che nel bucket Cloud Storage siano presenti due grafici:

    gsutil ls gs://${BUCKET}
    

    L'output dovrebbe essere simile al seguente:

    gs://BUCKET/chart-cyprus.png
    gs://BUCKET/chart-unitedkingdom.png
    

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

Esegui la pulizia

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

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

  1. In Google Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina risorse tutorial

  1. Elimina i servizi Cloud Run for Anthos di cui hai eseguito il deployment in questo tutorial:

    gcloud run services delete SERVICE_NAME

    Dove SERVICE_NAME è il nome del servizio che hai scelto.

    Puoi anche eliminare i servizi Cloud Run for Anthos da Google Cloud Console.

  2. Elimina tutti i trigger Eventarc che hai creato in questo tutorial:

    gcloud eventarc triggers delete TRIGGER_NAME
    

    Sostituisci TRIGGER_NAME con il nome dell'attivatore.

  3. Rimuovi le configurazioni gcloud predefinite che hai aggiunto durante la configurazione del tutorial.

    gcloud config unset project
    gcloud config unset run/cluster
    gcloud config unset run/cluster_location
    gcloud config unset run/platform
    gcloud config unset eventarc/location
    gcloud config unset compute/zone
    

Passaggi successivi