Receber eventos usando os Registros de auditoria do Cloud (CLI gcloud)

Neste guia de início rápido, mostramos como configurar um serviço do Google Kubernetes Engine (GKE) como um destino para receber eventos do Cloud Storage usando o Eventarc.

Neste guia de início rápido, você vai:

Configure uma conta de serviço para que o Eventarc possa extrair eventos e encaminhá-los ao destino.
Criar um bucket do Cloud Storage para ser a origem do evento.
Criar um cluster do GKE.
Inicializar destinos do GKE no Eventarc.
Implantar um serviço do GKE que recebe eventos.
Crie um gatilho do Eventarc que envie eventos do Cloud Storage para o serviço do GKE.
Faça upload de um arquivo para o bucket do Cloud Storage para gerar um evento e ver o evento nos registros do pod do GKE.

Antes de começar

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.

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Crie ou selecione um projeto do Google Cloud.

Crie um projeto do Google Cloud:
```
gcloud projects create PROJECT_ID
```
Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.
Selecione o projeto do Google Cloud que você criou:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Crie ou selecione um projeto do Google Cloud.

Crie um projeto do Google Cloud:
```
gcloud projects create PROJECT_ID
```
Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.
Selecione o projeto do Google Cloud que você criou:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Atualize os componentes da CLI do Google Cloud:
```
gcloud components update
```

Ative as APIs Eventarc, Resource Manager e Google Kubernetes Engine:

gcloud services enable eventarc.googleapis.com \
    cloudresourcemanager.googleapis.com \
    container.googleapis.com

Defina as variáveis de configuração usadas neste guia de início rápido:

PROJECT_ID=$(gcloud config get-value project)
TRIGGER_SA=eventarc-sa
CLUSTER_NAME=events-cluster
SERVICE_NAME=hello-gke

Se você for o criador do projeto, receberá o papel de proprietário básico (roles/owner). Por padrão, esse papel do gerenciamento de identidade e acesso (IAM) inclui as permissões necessárias para acesso total à maioria dos recursos do Google Cloud, e você pode pular esta etapa.

Se você não é o criador do projeto, as permissões necessárias precisam ser concedidas ao principal apropriado. Por exemplo, um principal pode ser uma Conta do Google (para usuários finais) ou uma conta de serviço (para aplicativos e cargas de trabalho de computação). Para mais informações, consulte a página Papéis e permissões do destino do evento.
Permissões necessárias

Para conseguir as permissões necessárias para concluir o guia de início rápido, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:
- Administrador do Eventarc (roles/eventarc.admin)
- Administrador do Kubernetes Engine (roles/container.admin)
- Acessador de exibição de registros (roles/logging.viewAccessor)
- Administrador de projetos do IAM (roles/resourcemanager.projectIamAdmin)
- Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
- Usuário da conta de serviço (roles/iam.serviceAccountUser)
- Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin)
- Administrador de armazenamento (roles/storage.admin)
Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

A conta de serviço padrão do Compute Engine é criada automaticamente depois de ativar ou usar um serviço do Google Cloud que usa o Compute Engine.

Para fins de teste, é possível anexar essa conta de serviço a um gatilho do Eventarc para representar a identidade do gatilho. Observe o formato de e-mail a ser usado ao criar um acionador:
```
PROJECT_NUMBER-compute@developer.gserviceaccount.com
```
Substitua PROJECT_NUMBER pelo número do projeto do Google Cloud. Encontre o número do projeto na página Boas-vindas do console do Google Cloud ou executando o seguinte comando:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```
A conta de serviço do Compute Engine recebe o papel básico de Editor (roles/editor) de modo automático no projeto. No entanto, se as concessões automáticas de papéis tiverem sido desativadas, consulte as instruções aplicáveis em Papéis e permissões para criar uma nova conta de serviço e conceder os papéis necessários.

Cuidado: recomendamos o uso da conta de serviço padrão do Compute Engine apenas para fins de teste. Para ambientes de produção, recomendamos criar uma nova conta de serviço e conceder a ela um ou mais papéis do IAM que contenham as permissões mínimas necessárias e seguir o princípio de privilégio mínimo.

Conceda o papel de Assinante do Pub/Sub (roles/pubsub.subscriber) no projeto à conta de serviço padrão do Compute Engine para que o gatilho do Eventarc possa extrair eventos do Pub/Sub.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role=roles/pubsub.subscriber
```

Conceda o papel de receptor de eventos do Eventarc (roles/eventarc.eventReceiver) no projeto à conta de serviço padrão do Compute Engine para que o gatilho do Eventarc possa receber eventos de provedores de eventos.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role=roles/eventarc.eventReceiver
```

Se você ativou o agente de serviço do Cloud Pub/Sub até 8 de abril de 2021, para oferecer suporte a solicitações push autenticadas do Pub/Sub, conceda o papel Criador de token da conta de serviço. (roles/iam.serviceAccountTokenCreator) à conta de serviço gerenciada pelo Google. Caso contrário, esse papel é concedido por padrão:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
    --role=roles/iam.serviceAccountTokenCreator
```

No Google Cloud Storage, ative os tipos de registro destes serviços: Leitura de administradores, Leitura de dados e Gravação de dados:
1. Leia a política de IAM do projeto e guarde-a em um arquivo:
```
gcloud projects get-iam-policy PROJECT_ID > /tmp/policy.yaml
```
2. Edite a política em "/tmp/policy.yaml", adicionando ou alterando *apenas* a configuração de registros de auditoria do acesso a dados. Cuidado: é preciso preservar as seções "bindings:" e "etag:" sem alterações. Caso contrário, o projeto poderá ficar inutilizável.
```
auditConfigs:
  - auditLogConfigs:
    - logType: ADMIN_READ
    - logType: DATA_WRITE
    - logType: DATA_READ
    service: storage.googleapis.com
  bindings:
  - members:
    - user:EMAIL_ADDRESS
    role: roles/owner
  etag: BwW_bHKTV5U=
  version: 1
```
  Substitua EMAIL_ADDRESS pelo seu endereço de e-mail.
3. Grave a nova política de IAM:
```
gcloud projects set-iam-policy PROJECT_ID /tmp/policy.yaml
```
  Se o comando anterior relatar um conflito com outra alteração, repita essas etapas, começando com a leitura da política de IAM do projeto.

Crie um bucket do Cloud Storage

No guia de início rápido, usamos o Cloud Storage como origem do evento. Crie um bucket do Cloud Storage:

gsutil mb -l us-central1 gs://events-quickstart-$(gcloud config get-value project)/

Após a criação da origem do evento, é possível implantar o serviço receptor de eventos no GKE.

Criar um cluster do GKE

Um cluster do GKE consiste em pelo menos uma máquina de plano de controle de clusters e várias máquinas de worker chamadas de nós. Os nós são instâncias de máquina virtual (VM) do Compute Engine que executam os processos do Kubernetes necessários para integrá-los ao cluster. Você implanta os aplicativos nos clusters para que eles sejam executados nos nós.

Crie um cluster do Autopilot chamado events-cluster:

gcloud container clusters create-auto $CLUSTER_NAME --region us-central1

A criação do cluster pode levar vários minutos para ser concluída. Depois que o cluster é criado, a saída fica mais ou menos assim:

Creating cluster events-cluster...done.
Created [https://container.googleapis.com/v1/projects/MY_PROJECT/zones/us-central1/clusters/events-cluster].
[...]
STATUS: RUNNING

Isso cria um cluster do GKE chamado events-cluster em um projeto com um ID de projeto do Google Cloud de MY_PROJECT.

Ativar destinos do GKE

Para cada gatilho que segmenta um serviço do GKE, o Eventarc cria um componente de encaminhamento de eventos que extrai eventos do Pub/Sub e o encaminha ao destino. Para criar o componente e gerenciar recursos no cluster do GKE, conceda permissões ao agente de serviço do Eventarc:

Ative os destinos do GKE para o Eventarc:
```
gcloud eventarc gke-destinations init
```
No prompt para vincular os papéis necessários, digite y.

Os papéis a seguir estão vinculados à conta de serviço:
- compute.viewer
- container.developer
- iam.serviceAccountAdmin

Criar um destino de serviço do GKE

Usando uma imagem pré-criada, gcr.io/cloudrun/hello, implante um serviço do GKE que receberá e registrará eventos:

O Kubernetes usa um arquivo YAML chamado kubeconfig (em inglês) para armazenar informações de autenticação de cluster para kubectl. Atualize o arquivo kubeconfig com credenciais e informações de endpoint para apontar kubectl no cluster do GKE:
```
gcloud container clusters get-credentials $CLUSTER_NAME \
    --region us-central1
```

Crie uma implantação do Kubernetes:

kubectl create deployment $SERVICE_NAME \
    --image=gcr.io/cloudrun/hello

Exponha-a como um serviço do Kubernetes:

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

Criar um gatilho do Eventarc

Quando você faz upload de um arquivo para o Cloud Storage, o gatilho do Eventarc envia eventos do Cloud Storage para o serviço do GKE hello-gke.

Crie um gatilho dos Registros de auditoria do Cloud:

gcloud eventarc triggers create my-gke-trigger \
    --location="us-central1" \
    --destination-gke-cluster="events-cluster" \
    --destination-gke-location="us-central1" \
    --destination-gke-namespace="default" \
    --destination-gke-service="hello-gke" \
    --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="PROJECT_NUMBER-compute@developer.gserviceaccount.com"

Isso gera um gatilho chamado my-gke-trigger.

Confirme se o gatilho foi criado:

gcloud eventarc triggers list

A saída será semelhante a esta:

NAME: my-gke-trigger
TYPE: google.cloud.audit.log.v1.written
DESTINATION: GKE: hello-gke
ACTIVE: By 20:39:43
LOCATION: us-central1

Gerar e visualizar um evento

Faça upload de um arquivo de texto no Cloud Storage para gerar um evento e acionar o serviço do GKE. É possível visualizar a mensagem do evento nos registros do pod.

Faça upload de um arquivo de texto para o Cloud Storage:
```
echo "Hello World" > random.txt
gsutil cp random.txt gs://events-quickstart-$(gcloud config get-value project)/random.txt
```
O upload gera um evento e o pod do GKE registra a mensagem do evento.

Para visualizar a mensagem de evento:

Encontre o ID do pod:

kubectl get pods

A saída será semelhante a esta:

NAME                                         READY   STATUS             RESTARTS   AGE
hello-gke-645964f578-2mjjt                   1/1     Running            0          35s

Copie o NAME do pod para usar na próxima etapa.

Verifique os registros do pod:
```
kubectl logs NAME
```
Substitua NAME pelo nome do pod que você copiou.

Procure uma entrada de registro semelhante a esta:

2022/02/24 22:23:49 Hello from Cloud Run! The container started successfully and is listening for HTTP requests on $PORT
{"severity":"INFO","eventType":"google.cloud.audit.log.v1.written","message":"Received event of type google.cloud.audit.log.v1.written. [...]}

Limpar

Ainda que o Cloud Run não gere custos quando o serviço não está em uso, pode haver cobrança pelo armazenamento da imagem do contêiner no Container Registry, por recursos do Eventarc e mensagens do Pub/Sub e para o cluster do GKE.

Você pode excluir a imagem, excluir o bucket de armazenamento e excluir o cluster do GKE.

Para excluir o gatilho do Eventarc:

gcloud eventarc triggers delete my-gke-trigger

Se preferir, exclua o projeto do Google Cloud para evitar cobranças. A exclusão do projeto do Google Cloud interrompe o faturamento de todos os recursos usados no projeto.

gcloud projects delete PROJECT_ID_OR_NUMBER

Substitua PROJECT_ID_OR_NUMBER pelo código ou número do projeto.

A seguir

Receber eventos usando o Pub/Sub (Google Cloud CLI)