Criar um pipeline de processamento do BigQuery para o Cloud Run for Anthos com o Eventarc

Visualização

Este produto é coberto pelos Termos de ofertas pré-GA dos Termos de Serviço do Google Cloud. Os produtos pré-GA podem ter suporte limitado, e as mudanças realizadas podem não ser compatíveis com outras versões pré-GA. Para mais informações, consulte as descrições da fase de lançamento.

Veja neste tutorial como usar o Eventarc para criar um pipeline de processamento que programa consultas a um conjunto de dados público do BigQuery, gera gráficos com base nos dados e compartilha links para os gráficos por e-mail.

Objetivos

Neste tutorial, você vai criar e implantar três serviços do Cloud Run for Anthos executados em um cluster do Google Kubernetes Engine (GKE) e que recebem eventos usando o Eventarc:

1. Executor de consulta: acionado quando os jobs do Cloud Scheduler publicam uma mensagem em um tópico do Pub/Sub. Este serviço usa a API BigQuery para recuperar dados de um conjunto de dados público sobre a COVID-19 e salva os resultados em uma nova tabela do BigQuery.
2. Criador de gráficos: acionado quando o serviço executor de consultas publica uma mensagem em um tópico do Pub/Sub topic. Este serviço gera gráficos usando a biblioteca de plotagem do Python Matplotlib e salva os gráficos em um bucket do Cloud Storage.
3. Notificador: acionado por registros de auditoria quando o serviço criador de gráficos armazena um gráfico em um bucket do Cloud Storage. Este serviço usa o serviço de e-mail SendGrid para enviar links para os gráficos por um endereço de e-mail.

O diagrama a seguir mostra a arquitetura geral:

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

• BigQuery
• Cloud Build
• Cloud Run for Anthos
• Cloud Scheduler
• Cloud Storage
• Container Registry
• Eventarc
• Google Kubernetes Engine
• Pub/Sub

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

4. Ative as APIs Cloud Build, Cloud Logging, Cloud Run for Anthos, Cloud Scheduler, Container Registry, Eventarc, GKE, Pub/Sub, and Resource Manager .

   Ative as APIs

5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

6. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

7. Ative as APIs Cloud Build, Cloud Logging, Cloud Run for Anthos, Cloud Scheduler, Container Registry, Eventarc, GKE, Pub/Sub, and Resource Manager .

   Ative as APIs

8. Instale e inicialize a Google Cloud CLI.
9. Atualize os componentes da gcloud:

   gcloud components update

10. Faça login usando sua conta:

    gcloud auth login

11. Selecione Google Cloud Storage e ative a Leitura de administradores, a Leitura de dados e a Gravação de dados Tipos de registro: Acessar registros de auditoria do Cloud
12. Defina os padrões usados neste 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
    

    Substitua PROJECT_ID pela ID do seu projeto.
13. Faça o download e instale a ferramenta de gerenciamento de código-fonte Git.

Criar uma chave de API do 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.

Criar um cluster do GKE para o Cloud Run for Anthos

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. A Identidade da carga de trabalho também é necessária para encaminhar eventos usando o Eventarc.

1. Crie um cluster do GKE para o Cloud Run for Anthos 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/my-cluster].
   

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]" \
     $[e-mail]
   

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=$[e-mail]
   

Ativar os 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 que o serviço do 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}
  

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 do Cloud Run for Anthos que receba eventos do criador de gráficos e use o SendGrid para enviar links por e-mail para os gráficos gerados.

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

   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. Implante a imagem do contêiner no Cloud Run for Anthos, transmitindo um endereço para enviar e-mails e a chave da 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}
   

   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 da API SendGrid que você anotou anteriormente.

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

Observação: pode levar alguns minutos até que as permissões sejam propagadas para o serviço e antes da criação de um gatilho.

Criar um gatilho para o serviço notificador

O gatilho do Eventarc para o serviço notificador implantado no Cloud Run for Anthos filtra 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 Cloud Run for Anthos que receba eventos do executor de consultas, recupere dados de uma tabela do BigQuery para um país específico e gere um gráfico dos dados usando o Matplotlib. 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 gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1 .
   docker push gcr.io/$(gcloud config get-value project)/${SERVICE_NAME}:v1
   popd
   

2. Implante a imagem do contêiner no Cloud Run for Anthos, transmitindo BUCKET:

   gcloud run deploy ${SERVICE_NAME} \
     --image gcr.io/$(gcloud config get-value project)/${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 criador de gráficos implantado no Cloud Run for Anthos filtra 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 Cloud Run for Anthos que receba eventos do Cloud Scheduler, recupere dados de um conjunto de dados público sobre a 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 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. Implante a imagem do contêiner no Cloud Run for Anthos, transmitindo 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 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 executor de consultas implantado no Cloud Run for Anthos filtra 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
   

   Observação: pode levar até dois minutos para que os gatilhos funcionem totalmente.

   A saída será semelhante a:

   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. 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:

   gsutil ls gs://${BUCKET}
   

   A saída será semelhante a:

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

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

Limpar

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual, mas quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Exclua o projeto

O jeito mais fácil de evitar cobranças é excluir o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar vários tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

delete-tutorial-resources

1. Exclua todos os serviços do Cloud Run for Anthos que você implantou neste tutorial:

   gcloud run services delete SERVICE_NAME

   SERVICE_NAME é o nome escolhido do serviço.

   Também é possível excluir os serviços do Cloud Run for Anthos no Console do Google Cloud:

2. Exclua todos os gatilhos do Eventarc criados neste tutorial:

   gcloud eventarc triggers delete TRIGGER_NAME
   

   Substitua TRIGGER_NAME pelo nome da sua Entrada.

3. Remova as configurações padrão do gcloud que você adicionou durante a configuração do 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
   

   • Exclua a imagem de contêiner denominada gcr.io/PROJECT_ID/SERVICE_NAME do Container Registry.

A seguir

• Saiba mais sobre o Eventarc
• Conheça outros tutoriais