Tutorial: depurar um serviço do Cloud Run usando o Eventarc


Neste tutorial, você verá como solucionar erros de ambiente de execução encontrados ao implantar eventos do Cloud Storage usando os registros de auditoria do Cloud em um serviço não autenticado do Cloud Run.

Objetivos

  • Criar um bucket do Cloud Storage para ser a origem do evento.
  • Crie, faça upload e implante uma imagem de contêiner no Cloud Run.
  • Criar gatilhos do Eventarc
  • Faça upload do arquivo para o bucket do Cloud Storage.
  • Solucione problemas e corrija erros de ambiente de execução.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

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.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Siga os pré-requisitos em Receber um evento de registros de auditoria do Cloud.

crie um bucket do Cloud Storage

Crie dois buckets de armazenamento em duas regiões como a origem do evento para o serviço do Cloud Run:

us-east1

export BUCKET1="troubleshoot-bucket1-PROJECT_ID"
gsutil mb -l us-east1 gs://${BUCKET1}

us-west1

export BUCKET2="troubleshoot-bucket2-$PROJECT_ID"
gsutil mb -l us-west1 gs://${BUCKET2}

Depois que a origem do evento for criada, implante o serviço de receptor de eventos no Cloud Run.

Recuperar a amostra de código

Clone o repositório:

Go

git clone https://github.com/GoogleCloudPlatform/golang-samples.git
cd golang-samples/eventarc/audit_storage

Java

git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
cd java-docs-samples/eventarc/audit-storage

.NET

git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
cd dotnet-docs-samples/eventarc/audit-storage

Node.js

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
cd nodejs-docs-samples/eventarc/audit-storage

Python

git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
cd python-docs-samples/eventarc/audit-storage

Revisar o código

O código deste tutorial consiste em:

  • Um manipulador de eventos que recebe o evento de entrada como um CloudEvent na solicitação HTTP POST:

    Go

    
    // Processes CloudEvents containing Cloud Audit Logs for Cloud Storage
    package main
    
    import (
    	"fmt"
    	"log"
    	"net/http"
    	"os"
    
    	cloudevent "github.com/cloudevents/sdk-go/v2"
    )
    
    // HelloEventsStorage receives and processes a Cloud Audit Log event with Cloud Storage data.
    func HelloEventsStorage(w http.ResponseWriter, r *http.Request) {
    	if r.Method != http.MethodPost {
    		http.Error(w, "Expected HTTP POST request with CloudEvent payload", http.StatusMethodNotAllowed)
    		return
    	}
    
    	event, err := cloudevent.NewEventFromHTTPRequest(r)
    	if err != nil {
    		log.Printf("cloudevent.NewEventFromHTTPRequest: %v", err)
    		http.Error(w, "Failed to create CloudEvent from request.", http.StatusBadRequest)
    		return
    	}
    	s := fmt.Sprintf("Detected change in Cloud Storage bucket: %s", event.Subject())
    	fmt.Fprintln(w, s)
    }
    

    Java

    import io.cloudevents.CloudEvent;
    import io.cloudevents.rw.CloudEventRWException;
    import io.cloudevents.spring.http.CloudEventHttpUtils;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestHeader;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class EventController {
    
      @RequestMapping(value = "/", method = RequestMethod.POST, consumes = "application/json")
      public ResponseEntity<String> receiveMessage(
          @RequestBody String body, @RequestHeader HttpHeaders headers) {
        CloudEvent event;
        try {
          event =
              CloudEventHttpUtils.fromHttp(headers)
                  .withData(headers.getContentType().toString(), body.getBytes())
                  .build();
        } catch (CloudEventRWException e) {
          return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);
        }
    
        String ceSubject = event.getSubject();
        String msg = "Detected change in Cloud Storage bucket: " + ceSubject;
        System.out.println(msg);
        return new ResponseEntity<>(msg, HttpStatus.OK);
      }
    }

    .NET

    
    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.Hosting;
    using Microsoft.AspNetCore.Http;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Hosting;
    using Microsoft.Extensions.Logging;
    
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
        }
    
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
    
            logger.LogInformation("Service is starting...");
    
            app.UseRouting();
    
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapPost("/", async context =>
                {
                    logger.LogInformation("Handling HTTP POST");
    
                    var ceSubject = context.Request.Headers["ce-subject"];
                    logger.LogInformation($"ce-subject: {ceSubject}");
    
                    if (string.IsNullOrEmpty(ceSubject))
                    {
                        context.Response.StatusCode = 400;
                        await context.Response.WriteAsync("Bad Request: expected header Ce-Subject");
                        return;
                    }
    
                    await context.Response.WriteAsync($"GCS CloudEvent type: {ceSubject}");
                });
            });
        }
    }
    

    Node.js

    const express = require('express');
    const app = express();
    
    app.use(express.json());
    app.post('/', (req, res) => {
      if (!req.header('ce-subject')) {
        return res
          .status(400)
          .send('Bad Request: missing required header: ce-subject');
      }
    
      console.log(
        `Detected change in Cloud Storage bucket: ${req.header('ce-subject')}`
      );
      return res
        .status(200)
        .send(
          `Detected change in Cloud Storage bucket: ${req.header('ce-subject')}`
        );
    });
    
    module.exports = app;

    Python

    @app.route("/", methods=["POST"])
    def index():
        # Create a CloudEvent object from the incoming request
        event = from_http(request.headers, request.data)
        # Gets the GCS bucket name from the CloudEvent
        # Example: "storage.googleapis.com/projects/_/buckets/my-bucket"
        bucket = event.get("subject")
    
        print(f"Detected change in Cloud Storage bucket: {bucket}")
        return (f"Detected change in Cloud Storage bucket: {bucket}", 200)
    
    
  • Um servidor que usa o gerenciador acima:

    Go

    
    func main() {
    	http.HandleFunc("/", HelloEventsStorage)
    	// Determine port for HTTP service.
    	port := os.Getenv("PORT")
    	if port == "" {
    		port = "8080"
    	}
    	// Start HTTP server.
    	log.Printf("Listening on port %s", port)
    	if err := http.ListenAndServe(":"+port, nil); err != nil {
    		log.Fatal(err)
    	}
    }
    

    Java

    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class Application {
      public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
      }
    }

    .NET

        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }
        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            var port = Environment.GetEnvironmentVariable("PORT") ?? "8080";
            var url = $"http://0.0.0.0:{port}";
    
            return Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>().UseUrls(url);
                });
        }
    

    Node.js

    const app = require('./app.js');
    const PORT = parseInt(process.env.PORT) || 8080;
    
    app.listen(PORT, () =>
      console.log(`nodejs-events-storage listening on port ${PORT}`)
    );

    Python

    import os
    
    from cloudevents.http import from_http
    
    from flask import Flask, request
    
    app = Flask(__name__)
    if __name__ == "__main__":
        app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
  • Um Dockerfile que define o ambiente operacional do serviço. O conteúdo do Dockerfile varia por linguagem.

    Go

    
    # Use the offical golang image to create a binary.
    # This is based on Debian and sets the GOPATH to /go.
    # https://hub.docker.com/_/golang
    FROM golang:1.21-bookworm as builder
    
    # Create and change to the app directory.
    WORKDIR /app
    
    # Retrieve application dependencies.
    # This allows the container build to reuse cached dependencies.
    # Expecting to copy go.mod and if present go.sum.
    COPY go.* ./
    RUN go mod download
    
    # Copy local code to the container image.
    COPY . ./
    
    # Build the binary.
    RUN go build -v -o server
    
    # Use the official Debian slim image for a lean production container.
    # https://hub.docker.com/_/debian
    # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
    FROM debian:bookworm-slim
    RUN set -x && apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
        ca-certificates && \
        rm -rf /var/lib/apt/lists/*
    
    # Copy the binary to the production image from the builder stage.
    COPY --from=builder /app/server /server
    
    # Run the web service on container startup.
    CMD ["/server"]
    

    Java

    
    # Use the official maven image to create a build artifact.
    # https://hub.docker.com/_/maven
    FROM maven:3-eclipse-temurin-17-alpine as builder
    
    # Copy local code to the container image.
    WORKDIR /app
    COPY pom.xml .
    COPY src ./src
    
    # Build a release artifact.
    RUN mvn package -DskipTests
    
    # Use Eclipse Temurin for base image.
    # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
    FROM eclipse-temurin:17.0.10_7-jre-alpine
    
    # Copy the jar to the production image from the builder stage.
    COPY --from=builder /app/target/audit-storage-*.jar /audit-storage.jar
    
    # Run the web service on container startup.
    CMD ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/audit-storage.jar"]
    

    .NET

    
    # Use Microsoft's official build .NET image.
    # https://hub.docker.com/_/microsoft-dotnet-core-sdk/
    FROM mcr.microsoft.com/dotnet/core/sdk:3.1-alpine AS build
    WORKDIR /app
    
    # Install production dependencies.
    # Copy csproj and restore as distinct layers.
    COPY *.csproj ./
    RUN dotnet restore
    
    # Copy local code to the container image.
    COPY . ./
    WORKDIR /app
    
    # Build a release artifact.
    RUN dotnet publish -c Release -o out
    
    # Use Microsoft's official runtime .NET image.
    # https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
    FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-alpine AS runtime
    WORKDIR /app
    COPY --from=build /app/out ./
    
    # Run the web service on container startup.
    ENTRYPOINT ["dotnet", "AuditStorage.dll"]

    Node.js

    
    # Use the official lightweight Node.js image.
    # https://hub.docker.com/_/node
    FROM node:18-slim
    
    # Create and change to the app directory.
    WORKDIR /usr/src/app
    
    # Copy application dependency manifests to the container image.
    # A wildcard is used to ensure both package.json AND package-lock.json are copied.
    # Copying this separately prevents re-running npm install on every code change.
    COPY package*.json ./
    
    # Install dependencies.
    # If you add a package-lock.json speed your build by switching to 'npm ci'.
    # RUN npm ci --only=production
    RUN npm install --production
    
    # Copy local code to the container image.
    COPY . .
    
    # Run the web service on container startup.
    CMD [ "npm", "start" ]
    

    Python

    
    # Use the official Python image.
    # https://hub.docker.com/_/python
    FROM python:3.11-slim
    
    # Allow statements and log messages to immediately appear in the Cloud Run logs
    ENV PYTHONUNBUFFERED True
    
    # Copy application dependency manifests to the container image.
    # Copying this separately prevents re-running pip install on every code change.
    COPY requirements.txt ./
    
    # Install production dependencies.
    RUN pip install -r requirements.txt
    
    # Copy local code to the container image.
    ENV APP_HOME /app
    WORKDIR $APP_HOME
    COPY . ./
    
    # Run the web service on container startup.
    # Use gunicorn webserver with one worker process and 8 threads.
    # For environments with multiple CPU cores, increase the number of workers
    # to be equal to the cores available.
    CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

Enviar o código

Para enviar o código, siga estas etapas:

  1. Crie a imagem do contêiner com o Cloud Build e faça o upload para o Container Registry:

    Go

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    Após a conclusão, uma mensagem de "SUCESSO" é exibida com o ID, o horário de criação e o nome da imagem. A imagem é armazenada no Container Registry e poderá ser reutilizada, se você quiser.

    Java

    1. Use o auxiliar de credencial gcloud para autorizar o Docker a enviar o contêiner para o Container Registry.
      gcloud auth configure-docker
    2. Use o plug-in do Maven do Jib para criar e enviar por push o contêiner ao Container Registry.

      mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/audit-storage

      Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

      audit-storage é o nome do contêiner. Após a conclusão, uma mensagem de "SUCESSO" é exibida. A imagem é armazenada no Container Registry e poderá ser reutilizada, se você quiser.

    .NET

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    Após a conclusão, uma mensagem de "SUCESSO" é exibida com o ID, o horário de criação e o nome da imagem. A imagem é armazenada no Container Registry e poderá ser reutilizada, se você quiser.

    Node.js

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    Após a conclusão, uma mensagem de "SUCESSO" é exibida com o ID, o horário de criação e o nome da imagem. A imagem é armazenada no Container Registry e poderá ser reutilizada, se você quiser.

    Python

     gcloud builds submit --tag gcr.io/PROJECT_ID/audit-storage

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    Após a conclusão, uma mensagem de "SUCESSO" é exibida com o ID, o horário de criação e o nome da imagem. A imagem é armazenada no Container Registry e poderá ser reutilizada, se você quiser.

  2. Implante a imagem do contêiner no Cloud Run:

    gcloud run deploy troubleshoot-service --image gcr.io/PROJECT_ID/audit-storage \
      --allow-unauthenticated
    

    Substitua PROJECT_ID pela ID do seu projeto.
    audit-storage é o nome do contêiner e troubleshoot-service é o nome do serviço do Cloud Run.

    A imagem do contêiner é implantada no serviço e na região que você configurou anteriormente ao configurar o gcloud.

  3. Ao implantar no Cloud Run, responda y, "Sim", ao prompt permitir não autenticado. Para mais detalhes sobre a autenticação baseada em IAM, consulte Papéis e permissões do Eventarc.

    Quando a implantação for bem-sucedida, a linha de comando exibirá o URL de serviço.

Criar um gatilho

Agora que você implantou um serviço do Cloud Run, configure um gatilho para detectar eventos do Cloud Storage por meio de registros de auditoria.

  1. Crie um gatilho de registro de auditoria para detectar eventos do Cloud Storage:

    gcloud eventarc triggers create troubleshoot-trigger \
      --destination-run-service=troubleshoot-service \
      --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 cria um gatilho chamado troubleshoot-trigger.

  2. Para confirmar se troubleshoot-trigger foi criado, execute:

    gcloud eventarc triggers list
    

    troubleshoot-trigger é exibido listado com um destino de troubleshoot-service.

Gerar e visualizar um evento

Para confirmar que você implantou o serviço e pode receber eventos do Cloud Storage:

  1. Crie e faça upload de um arquivo no primeiro bucket de armazenamento:

     echo "Hello World" > random.txt
     gsutil cp random.txt gs://${BUCKET1}/random.txt
    
  2. Monitore os registros para verificar se o serviço recebeu um evento. Os registros de serviço mostram que o serviço está detectando eventos, indicando um problema na configuração:

    Now listening on: http://0.0.0.0:8080

Investigar o problema

Agora é possível passar pelo processo de investigação do motivo pelo qual o serviço não está recebendo eventos.

Registros de auditoria

Neste tutorial, os eventos do Cloud Storage são emitidos por meio de registros de auditoria e enviados ao Cloud Run. Verifique se os registros de auditoria estão ativados para o Cloud Storage.

  1. No console do Google Cloud, acesse a página Registros de auditoria e marque a caixa de seleção Google Cloud Storage.

    Vá para "Registros de Auditoria"

  2. Verifique se os tipos de registro de leitura, leitura e gravação dos registros de auditoria do Cloud estão selecionados.

Depois de ativar os registros de auditoria do Cloud, faça upload do arquivo novamente e verifique os registros. O serviço ainda não recebe eventos e isso pode estar relacionado à localização do gatilho.

Local do gatilho

Pode haver vários recursos em locais diferentes, e você precisa filtrar eventos de origens que estão na mesma região que o destino do Cloud Run. Para mais informações, consulte Locais compatíveis com o Eventarc.

Neste tutorial, você implantou o serviço do Cloud Run em us-central1. Você também criou um gatilho no mesmo local porque eventarc/location estava definido como us-central1.

Para listar o local do gatilho, descreva o gatilho:

gcloud eventarc triggers describe troubleshoot-trigger

No entanto, você criou dois buckets em locais us-east1 e us-west1. Para receber eventos desses locais, é necessário criar acionadores neles. Vamos criar um gatilho em us-east1.

  1. Exclua o gatilho existente no local us-central1:

    gcloud eventarc triggers delete troubleshoot-trigger
    
  2. Defina o local e a região como us-east1:

    gcloud config set eventarc/location us-east1
    gcloud config set run/region us-east1
    
  3. Envie o código novamente.

  4. Crie um novo gatilho no local us-east1:

     gcloud eventarc triggers create troubleshoot-trigger \
       --destination-run-service=troubleshoot-service \
       --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
    
  5. Verifique se o gatilho foi criado:

    gcloud eventarc triggers list
    

Um gatilho pode levar até dois minutos para ser inicializado antes de começar a entregar eventos.

Tempo de inicialização

Depois que os gatilhos são criados, há até dois minutos de tempo de inicialização antes do início dos eventos. Execute o seguinte comando para confirmar se os gatilhos estão ativos:

gcloud eventarc triggers list

Uma resposta semelhante é exibida para indicar o status do acionador:

NAME                   TYPE                               DESTINATION_RUN_SERVICE  DESTINATION_RUN_PATH  ACTIVE
troubleshoot-trigger3  google.cloud.audit.log.v1.written  troubleshoot-service2                          By 14:16:56
troubleshoot-trigger   google.cloud.audit.log.v1.written  troubleshoot-service                           Yes

Após 10 minutos, faça upload de um arquivo novamente para cada bucket. Os eventos de cada arquivo são gravados nos registros de serviço do Cloud Run. Se o serviço não receber eventos, ele poderá estar relacionado ao tamanho dos eventos.

Tamanho do evento

Os eventos enviados não podem exceder os limites de tamanho do evento (512 KB).

Um gatilho que enviou eventos anteriormente parou de funcionar

  1. Verifique se a origem está gerando eventos. Verifique os registros de auditoria do Cloud e se o serviço monitorado está emitindo registros. Se os registros forem gravados, mas os eventos não forem entregues, entre em contato com o suporte.

  2. Verifique se há um tópico do Pub/Sub com o mesmo nome de gatilho.

    1. Para listar acionadores, consulte gcloud eventarc trigger list.
    2. Para listar os tópicos do Pub/Sub, execute:

      gcloud pubsub topics list
      

    Verifique se o nome do tópico do Pub/Sub inclui o nome do gatilho criado. Se o tópico do Pub/Sub estiver ausente, crie um tópico ao criar o gatilho para um provedor específico, um tipo de evento e um destino do Cloud Run.

  3. Verifique a integridade do tópico do Pub/Sub:

    1. Verifique se há uma marca de seleção na guia Gatilhos. No Console do Cloud, acesse Cloud Run e selecione o serviço criado e acesse a guia Gatilhos.

    2. No console do Google Cloud, acesse a página Tópicos e clique no tópico do Pub/Sub.

      Acesse Tópicos

    3. Monitore se as mensagens forem publicadas no tópico com a métrica: topic/send_message_operation_count. Se as mensagens não forem publicadas no tópico, verifique os Registros de auditoria do Cloud e verifique se o serviço monitorado está emitindo registros. Se os registros forem gravados, mas os eventos não forem entregues, entre em contato com o suporte.

      Métrica de tópico

    4. Monitore se as mensagens forem enviadas por push para o Cloud Run com a métrica: subscription/push_request_count por response_code.

      1. No console do Google Cloud, acesse a página Visão geral do Cloud Monitoring.

        Ir para Visão geral

      2. Adicione seu projeto a um novo espaço de trabalho.

      3. Clique em Painéis e selecione o painel Cloud Pub/Sub.

      4. No painel Cloud Pub/Sub, clique no tópico do Pub/Sub que você criou.

      5. Na seção Incidents, clique em Create Policy.

      6. Na página Criar política de alertas, clique em Adicionar condição.

      7. Na guia Métrica, forneça as seguintes condições:

        • Assinatura do Cloud Pub/Sub como o Tipo de recurso.
        • Solicitações de envio como a Métrica.
        • response_code como o Agrupar por.
        • 0 como o Limite de configuração. Métrica de assinatura Para mais informações sobre métricas de uso do Pub/Sub, consulte Como monitorar assinaturas de push.
      8. Clique em Add para acessar a página Create alerting policy.

      9. Na seção Quais são as etapas para corrigir o problema?, forneça um nome de alerta, por exemplo, samplealert, e clique em Salvar.

      10. Para ver o alerta, acesse Monitoring > Dashboard > Cloud Pub/Sub. Clique no tópico Pub/Sub e na guia Assinatura.

      Se os erros de push forem informados, verifique os registros de serviço do Cloud Run. Se o endpoint de recebimento retornar um código de status não OK, isso indica que o código do Cloud Run não está funcionando como esperado e você precisa entrar em contato com o suporte.

Limpar

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto já existente e quer mantê-lo sem as alterações incluídas com este 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:

  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 o serviço do Cloud Run 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 no Console do Google Cloud.

  2. Remova as configurações padrão do gcloud CLI que você adicionou durante a configuração do tutorial.

    Exemplo:

    gcloud config unset run/region

    ou

    gcloud config unset project

  3. Exclua outros recursos do Google Cloud criados neste tutorial:

    • Exclua o gatilho do Eventarc:
      gcloud eventarc triggers delete TRIGGER_NAME
      
      Substitua TRIGGER_NAME pelo nome do gatilho.

    • Exclua a imagem de contêiner denominada gcr.io/PROJECT_ID/audit-storage do Container Registry. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

A seguir

  • Para resolver outros problemas que podem ser encontrados ao usar o Eventarc, consulte Resolver problemas.