Crie um pipeline de processamento do BigQuery para o Knative Serving com o Eventarc

Este tutorial mostra como usar o Eventarc para criar um pipeline de processamento que agende consultas para um conjunto de dados público do BigQuery, gere gráficos com base nos dados e partilhe links para os gráficos por email.

Crie uma chave da API SendGrid

O SendGrid é um fornecedor de email baseado na nuvem que lhe permite enviar emails sem ter de manter servidores de email.

  1. Inicie sessão no SendGrid e aceda a Settings > API Keys.
  2. Clique em Criar chave da API.
  3. Selecione as autorizações para a chave. No mínimo, a chave tem de ter autorizações de Envio de correio para enviar emails.
  4. Clique em Guardar para criar a chave.
  5. O SendGrid gera uma nova chave. Esta é a única cópia da chave, por isso, certifique-se de que a copia e a guarda para mais tarde.

Crie um cluster do GKE

Crie um cluster com a federação de identidades da carga de trabalho para o GKE ativada para que possa aceder aos Google Cloud serviços a partir de aplicações em execução no GKE. Também precisa da Workload Identity Federation para o GKE para encaminhar eventos através do Eventarc.

  1. Crie um cluster do GKE para o Knative Serving com os suplementos 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 até que a criação do cluster esteja concluída. Durante o processo, pode ver avisos que pode ignorar com segurança. Quando o cluster é criado, o resultado é semelhante ao seguinte:

    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 sua imagem de contentor Docker:

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

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

Configure 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 predefinida.

  1. Crie uma associação de gestão de identidade e de acesso (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 email 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

Ative os destinos do GKE

Para permitir que o Eventarc faça a gestão de recursos no cluster do GKE, ative os destinos do GKE e associe a conta de serviço do Eventarc às funções necessárias.

  1. Ative os destinos do GKE para o Eventarc:

    gcloud eventarc gke-destinations init

  2. No comando para associar as funções necessárias, introduza y.

    As seguintes funções estão associadas:

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

Crie uma conta de serviço e associe funções de acesso

Antes de criar o acionador do Eventarc, configure uma conta de serviço gerida pelo utilizador e conceda-lhe funções específicas para que o Eventarc possa encaminhar eventos do Pub/Sub.

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

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

  2. Conceda as funções 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 contentor do Cloud Storage

Crie um contentor do Cloud Storage para guardar os gráficos. Certifique-se de que o contentor e os gráficos estão disponíveis publicamente e na mesma região que o seu serviço GKE:

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

Clonar o repositório

Clone o repositório do GitHub.

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

Implemente o serviço de notificação

A partir do diretório bigquery/notifier/python, implemente um serviço de fornecimento do Knative que receba eventos do criador de gráficos e use o SendGrid para enviar por email links para os gráficos gerados.

  1. Crie e envie a imagem de contentor:

    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. Implemente a imagem do contentor no Knative Serving, transmitindo um endereço para o qual enviar emails 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 $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 o seguinte:

    • EMAIL_ADDRESS: um endereço de email para enviar os links para os gráficos gerados
    • YOUR_SENDGRID_API_KEY: a chave da API do SendGrid que anotou anteriormente

Quando vir o URL do serviço, a implementação está concluída.

Crie um acionador para o serviço de notificação

O acionador do Eventarc para o serviço de notificação implementado no Knative serving filtra os registos de auditoria do Cloud Storage onde o methodName é storage.objects.create.

  1. Crie o acionador:

    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

    Esta ação cria um acionador denominado trigger-notifier-gke.

Implemente o serviço de criação de gráficos

A partir do diretório bigquery/chart-creator/python, implemente um serviço do Knative Serving que receba eventos do executor de consultas, obtenha dados de uma tabela do BigQuery para um país específico e, em seguida, gere um gráfico, através do Matplotlib, a partir dos dados. O gráfico é carregado para um contentor do Cloud Storage.

  1. Crie e envie a imagem de contentor:

    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. Implemente a imagem do contentor no Knative Serving, transmitindo o seguinte 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 vir o URL do serviço, a implementação está concluída.

Crie um acionador para o serviço de criação de gráficos

O acionador do Eventarc para o serviço de criação de gráficos implementado no Knative serving filtra mensagens publicadas num tópico do Pub/Sub.

  1. Crie o acionador:

    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

    Esta ação cria um acionador denominado trigger-chart-creator-gke.

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

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

Implemente o serviço de execução de consultas

A partir do diretório processing-pipelines, implemente um serviço de fornecimento do Knative que receba eventos do Cloud Scheduler, obtenha dados de um conjunto de dados público sobre a COVID-19 e guarde os resultados numa nova tabela do BigQuery.

  1. Crie e envie a imagem de contentor:

    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. Implemente a imagem do contentor no 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 vir o URL do serviço, a implementação está concluída.

Crie um acionador para o serviço de execução de consultas

O acionador do Eventarc para o serviço de execução de consultas implementado na publicação do Knative filtra as mensagens publicadas num tópico do Pub/Sub.

  1. Crie o acionador:

    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

    Esta ação cria um acionador denominado 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)')

Agende as tarefas

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

  1. Crie uma app do App Engine que é necessária para o Cloud Scheduler e especifique uma localização adequada (por exemplo, europe-west):

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

  2. Crie duas tarefas do Cloud Scheduler que publiquem num 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 as tarefas são executadas às 16:00 (16:00) UTC todos os dias.

Execute o pipeline

  1. Confirme que todos os acionadores foram criados com êxito:

    gcloud eventarc triggers list

    O resultado deve ser semelhante ao seguinte:

    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 das tarefas do Cloud Scheduler:

    gcloud scheduler jobs list

    O resultado deve ser semelhante ao seguinte:

    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. Embora as tarefas estejam agendadas para serem executadas diariamente às 16:00 e às 17:00, também pode executar as tarefas do Cloud Scheduler manualmente:

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

  4. Após alguns minutos, confirme que existem dois gráficos no contentor do Cloud Storage:

    gcloud storage ls gs://${BUCKET}

    O resultado deve ser semelhante ao seguinte:

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

Parabéns! Também deve receber dois emails com links para as tabelas.