Criar um pipeline de processamento do BigQuery para exibição do Knative com o Eventarc

Criar uma chave da API SendGrid

O SendGrid é um provedor de e-mail baseado em nuvem que permite enviar e-mails sem precisar manter servidores de e-mail.

1. Faça login no SendGrid e acesse Configurações > Chaves de API.
2. Clique em Criar chave de API.
3. Selecione as permissões para a chave. Para enviar e-mails, a chave precisa, no mínimo, de permissões de envio de e-mail.
4. Clique em Save para criar a chave.
5. O SendGrid gera uma nova chave. Esta é a única cópia da chave, portanto, faça uma cópia dela e salve-a para uso futuro.

Crie um cluster do GKE

Crie um cluster com a Identidade da carga de trabalho ativada para que ele possa acessar os serviços do Google Cloud a partir de aplicativos em execução no GKE. Você também precisa da Identidade da carga de trabalho para encaminhar eventos usando o Eventarc.

1. Crie um cluster do GKE para exibição do Knative com os complementos CloudRun, HttpLoadBalancing e HorizontalPodAutoscaling ativados:

   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. Aguarde alguns minutos para que a criação do cluster seja concluída. Durante o processo, talvez você veja avisos que podem ser ignorados com segurança. Depois da criação do cluster, a saída é semelhante a esta:

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

3. Crie um repositório padrão do Artifact Registry para armazenar a imagem do contêiner do Docker:

   gcloud artifacts repositories create REPOSITORY \
       --repository-format=docker \
       --location=$CLUSTER_LOCATION

   Substitua REPOSITORY por um nome exclusivo para o repositório.

Configurar a conta de serviço do GKE

Configure uma conta de serviço do GKE para atuar como a conta de serviço de computação padrão.

1. Crie uma vinculação do Identity and Access Management (IAM) entre as contas de serviço:

   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. Adicione a anotação iam.gke.io/gcp-service-account à conta de serviço do GKE usando o endereço de e-mail da conta de serviço de computação:

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

Ativar destinos do GKE

Para permitir que o Eventarc gerencie recursos no cluster do GKE, ative os destinos do GKE e vincule a conta de serviço do Eventarc aos papéis necessários.

1. Ative os destinos do GKE para o Eventarc:

   gcloud eventarc gke-destinations init
   

2. No prompt para vincular os papéis necessários, digite y.

   Os papéis a seguir estão vinculados:

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

Criar uma conta de serviço e vincular papéis de acesso

Antes de criar o gatilho do Eventarc, configure uma conta de serviço gerenciada pelo usuário e conceda a ela papéis específicos para que o Eventarc possa encaminhar eventos do Pub/Sub.

1. Crie uma conta de serviço chamada TRIGGER_GSA:

   TRIGGER_GSA=eventarc-bigquery-triggers
   gcloud iam service-accounts create $TRIGGER_GSA

2. Conceda os papéis pubsub.subscriber, monitoring.metricWriter e eventarc.eventReceiver à conta de serviço:

   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"
   

crie um bucket do Cloud Storage

Crie um bucket do Cloud Storage para salvar os gráficos. Verifique se o bucket e os gráficos estão disponíveis publicamente e na mesma região do serviço do GKE:

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

Clonar o repositório

Clonar o repositório GitHub.

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

Implantar o serviço notificador

No diretório bigquery/notifier/python, implante um serviço de exibição Knative que receba eventos de criação de gráficos e use o SendGrid para enviar links por e-mail aos gráficos gerados.

1. Crie e envie a imagem do contêiner:

   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
   

2. Implante a imagem do contêiner no Knative serving, passando um endereço para enviar e-mails e a chave de API SendGrid:

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

   Substitua:

   • EMAIL_ADDRESS por um endereço de e-mail para enviar os links para os gráficos gerados.
   • YOUR_SENDGRID_API_KEY: pela chave de API SendGrid que você anotou anteriormente.

Quando você vir o URL do serviço, a implantação estará concluída.

Criar um gatilho para o serviço notificador

O gatilho do Eventarc para o serviço do Notificador implantado nos filtros do Knative serving para registros de auditoria do Cloud Storage em que o methodName é storage.objects.create.

1. Crie o gatilho:

   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
   

   Isso cria um gatilho chamado trigger-notifier-gke.

Implantar o serviço criador de gráficos

No diretório bigquery/chart-creator/python, implante um serviço do Knative serving que receba eventos do executor de consultas, recupere dados de uma tabela do BigQuery de um país específico e gere um gráfico usando Matplotlib, dados. O upload do gráfico é feito para um bucket do Cloud Storage.

1. Crie e envie a imagem do contêiner:

   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
   

2. Implante a imagem do contêiner do Knative serving, transmitindo BUCKET:

   gcloud run deploy ${SERVICE_NAME} \
       --image $CLUSTER_LOCATION-docker.pkg.dev/$(gcloud config get-value project)/REPOSITORY/${SERVICE_NAME}:v1 \
       --update-env-vars BUCKET=${BUCKET}
   

Quando você vir o URL do serviço, a implantação estará concluída.

Criar um gatilho para o serviço criador de gráficos

O gatilho do Eventarc para o serviço de criação de gráficos implantado nos filtros do Knative serving para mensagens publicadas em um tópico do Pub/Sub.

1. Crie o gatilho:

   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
   

   Isso cria um gatilho chamado trigger-chart-creator-gke.

2. Defina a variável de ambiente de tópico Pub/Sub.

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

Implantar o serviço executor de consultas

No diretório processing-pipelines, implante um serviço do Knative serving que receba eventos do Cloud Scheduler, recupere dados de um conjunto de dados público da COVID-19 e salve os resultados em uma nova tabela do BigQuery.

1. Crie e envie a imagem do contêiner:

   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
   

2. Implante a imagem do contêiner do Knative serving, transmitindo PROJECT_ID e TOPIC_QUERY_COMPLETED:

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

Quando você vir o URL do serviço, a implantação estará concluída.

Criar um gatilho para o serviço executor de consultas

O gatilho do Eventarc para o serviço do executor de consultas implantado nos filtros do Knative serving para mensagens publicadas em um tópico do Pub/Sub.

1. Crie o gatilho:

   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
   

   Isso cria um gatilho chamado trigger-query-runner-gke.

2. Defina uma variável de ambiente para o tópico do Pub/Sub.

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

Programar os jobs

O pipeline de processamento é acionado por dois jobs do Cloud Scheduler.

1. Crie um aplicativo do App Engine que seja exigido pelo Cloud Scheduler e especifique um local apropriado (por exemplo, europe-west):

   export APP_ENGINE_LOCATION=LOCATION
   gcloud app create --region=${APP_ENGINE_LOCATION}
   

2. Crie dois jobs do Cloud Scheduler que publiquem em um tópico do Pub/Sub uma vez por dia:

   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"
   

   A programação é especificada no formato unix-cron. Por exemplo, 0 16 * * * significa que os jobs são executados às 16h (16h) UTC todos os dias.

Executar o canal

1. Confirme a criação de todos os gatilhos:

   gcloud eventarc triggers list
   

   A saída será semelhante a esta:

   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
   

2. Recupere os IDs dos jobs do Cloud Scheduler:

   gcloud scheduler jobs list
   

   A saída será semelhante a:

   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. Os jobs estão programados para serem executados diariamente às 16h e às 17h, mas também é possível executar os jobs do Cloud Scheduler manualmente:

   gcloud scheduler jobs run cre-scheduler-cy
   gcloud scheduler jobs run cre-scheduler-uk
   

4. Após alguns minutos, confirme se há dois gráficos no bucket do Cloud Storage:

   gcloud storage ls gs://${BUCKET}
   

   A saída será semelhante a:

   gs://PROJECT_ID-charts/chart-cyprus.png
   gs://PROJECT_ID-charts/chart-unitedkingdom.png
   

Parabéns! Você também receberá dois e-mails com links para os gráficos.