Instructivo: Depura eventos de enrutamiento a Cloud Run

En este instructivo, aprenderás a solucionar errores del entorno de ejecución que se encuentran cuando usas Eventarc para enrutar eventos de Cloud Storage a un servicio de Cloud Run sin autenticar mediante Registros de auditoría de Cloud.

Objetivos

En este instructivo, se muestra cómo completar las siguientes tareas:

  1. Crea un repositorio estándar de Artifact Registry para almacenar tu imagen de contenedor.
  2. Crear un bucket de Cloud Storage para que sea la fuente del evento
  3. Compilar, subir y, luego, implementar una imagen de contenedor en Cloud Run.
  4. Crear activadores de Eventarc.
  5. Subir un archivo al bucket de Cloud Storage.
  6. Solucionar problemas y corregir errores de entorno de ejecución.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Es posible que las restricciones de seguridad que define tu organización no te permitan completar los siguientes pasos. Para obtener información sobre la solución de problemas, consulta Desarrolla aplicaciones en un entorno de Google Cloud restringido.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the Artifact Registry, Cloud Build, Cloud Logging, Cloud Run, Cloud Storage, Eventarc, and Pub/Sub APIs: 

    gcloud services enable artifactregistry.googleapis.com cloudbuild.googleapis.com eventarc.googleapis.com logging.googleapis.com pubsub.googleapis.com run.googleapis.com storage.googleapis.com
  7. Install the Google Cloud CLI.

  8. To initialize the gcloud CLI, run the following command: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Make sure that billing is enabled for your Google Cloud project.

  11. Enable the Artifact Registry, Cloud Build, Cloud Logging, Cloud Run, Cloud Storage, Eventarc, and Pub/Sub APIs: 

    gcloud services enable artifactregistry.googleapis.com cloudbuild.googleapis.com eventarc.googleapis.com logging.googleapis.com pubsub.googleapis.com run.googleapis.com storage.googleapis.com

  12. Si eres el creador del proyecto, se te otorga el rol de propietario básico (roles/owner). De forma predeterminada, este rol de Identity and Access Management (IAM) incluye los permisos necesarios para obtener acceso completo a la mayoría de los recursos de Google Cloud, pero puedes omitir este paso.

    Si no eres el creador del proyecto, se deben otorgar los permisos necesarios en el proyecto a la principal correspondiente. Por ejemplo, una principal puede ser una Cuenta de Google (para usuarios finales) o una cuenta de servicio (para aplicaciones y cargas de trabajo de procesamiento). Para obtener más información, consulta la página Roles y permisos para el destino del evento.

    Ten en cuenta que, de forma predeterminada, los permisos de Cloud Build incluyen permisos para subir y descargar artefactos de Artifact Registry.

    Permisos necesarios

    Si quieres obtener los permisos que necesitas para completar este instructivo, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

    Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

    También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

  13. En Cloud Storage, habilita el registro de auditoría para los tipos de acceso a los datos ADMIN_READ, DATA_WRITE y DATA_READ.

    1. Lee la política de Identity and Access Management (IAM) asociada con tu organización, carpeta o proyecto de Google Cloud y almacénala en un archivo temporal: 
      gcloud projects get-iam-policy PROJECT_ID > /tmp/policy.yaml

    2. En un editor de texto, abre /tmp/policy.yaml y agrega o cambia solo la configuración del registro de auditoría en la sección auditConfigs:

      auditConfigs:
- auditLogConfigs:
  - logType: ADMIN_READ
  - logType: DATA_WRITE
  - logType: DATA_READ
  service: storage.googleapis.com
bindings:
- members:
[...]
etag: BwW_bHKTV5U=
version: 1
    3. Escribe tu nueva política de IAM: 
      gcloud projects set-iam-policy PROJECT_ID /tmp/policy.yaml

      Si el comando anterior informa de un conflicto con otro cambio, repite estos pasos y comienza por la lectura de la política de IAM. Para obtener más información, consulta Configura los registros de auditoría de acceso a los datos con la API.

  14. Otorga el rol eventarc.eventReceiver a la cuenta de servicio de Compute Engine:

    export PROJECT_NUMBER="$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')"

gcloud projects add-iam-policy-binding $(gcloud config get-value project) \
    --member=serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \
    --role='roles/eventarc.eventReceiver'

  15. Si habilitaste la cuenta de servicio de Pub/Sub el 8 de abril de 2021 o antes de esa fecha, otorga el rol iam.serviceAccountTokenCreator a la cuenta de servicio de Pub/Sub:

    gcloud projects add-iam-policy-binding $(gcloud config get-value project) \
    --member="serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com"\
    --role='roles/iam.serviceAccountTokenCreator'

  16. Establece los valores predeterminados que se usan en este instructivo: 
    export REGION=us-central1
gcloud config set run/region ${REGION}
gcloud config set run/platform managed
gcloud config set eventarc/location ${REGION}

Crea un repositorio estándar de Artifact Registry

Crea un repositorio estándar de Artifact Registry para almacenar tu imagen de contenedor:

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

Reemplaza REPOSITORY por un nombre único para el repositorio.

Crea un bucket de Cloud Storage

Crea un bucket de Cloud Storage en cada una de las dos regiones como fuente de eventos para el servicio de Cloud Run:

  1. Crea un bucket en us-east1:

    export BUCKET1="troubleshoot-bucket1-PROJECT_ID"
gcloud storage buckets create gs://${BUCKET1} --location=us-east1

  2. Crea un bucket en us-west1:

    export BUCKET2="troubleshoot-bucket2-PROJECT_ID"
gcloud storage buckets create gs://${BUCKET2} --location=us-west1

Después de crear la fuente del evento, implementa el servicio del receptor de eventos en Cloud Run.

Implementa el receptor de eventos

Implementa un servicio de Cloud Run que reciba y registre eventos.

  1. Clona el repositorio de GitHub para recuperar la muestra de código:

    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

  2. Revisa el código de este instructivo, que consta de los siguientes elementos:

    • Un controlador de eventos que recibe el evento entrante como un CloudEvent dentro de la solicitud 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)

    • Un servidor que usa el controlador de eventos:

      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)))

    • Un Dockerfile que define el entorno operativo del servicio. El contenido del Dockerfile varía según el lenguaje

      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.12_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/sdk:8.0-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/aspnet:8.0-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:20-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 need a deterministic and repeatable build create a 
# package-lock.json file and use npm ci:
# RUN npm ci --omit=dev
# if you need to include development dependencies during development
# of your application, use:
# RUN npm install --dev

RUN npm install --omit=dev

# 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

  3. Compila tu imagen de contenedor con Cloud Build y sube la imagen a Artifact Registry:

    export PROJECT_ID=$(gcloud config get-value project)
export SERVICE_NAME=troubleshoot-service
gcloud builds submit --tag $REGION-docker.pkg.dev/${PROJECT_ID}/REPOSITORY/${SERVICE_NAME}:v1

  4. Implementa la imagen del contenedor en Cloud Run:

    gcloud run deploy ${SERVICE_NAME} \
    --image $REGION-docker.pkg.dev/${PROJECT_ID}/REPOSITORY/${SERVICE_NAME}:v1 \
    --allow-unauthenticated

    Cuando la implementación se realiza correctamente, la línea de comandos muestra la URL del servicio.

Crear un activador

Después de implementar un servicio de Cloud Run, configura un activador para escuchar eventos de Cloud Storage a través de registros de auditoría.

  1. Crea un activador de Eventarc para detectar los eventos de Cloud Storage que se enrutan mediante los Registros de auditoría de Cloud:

    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

    Esto crea un activador llamado troubleshoot-trigger.

  2. Para confirmar que se creó troubleshoot-trigger, ejecuta el siguiente comando:

    gcloud eventarc triggers list

    El resultado debería ser similar al siguiente ejemplo:

    NAME: troubleshoot-trigger
TYPE: google.cloud.audit.log.v1.written
DESTINATION: Cloud Run service: troubleshoot-service
ACTIVE: By 20:03:37
LOCATION: us-central1

Genera y visualiza un evento

Confirma que implementaste correctamente el servicio y que puedes recibir eventos de Cloud Storage.

  1. Crea y sube un archivo al bucket de almacenamiento BUCKET1:

     echo "Hello World" > random.txt
 gcloud storage cp random.txt gs://${BUCKET1}/random.txt

  2. Supervisa los registros para verificar si el servicio recibió un evento. Para ver la entrada de registro, completa los siguientes pasos:

    1. Filtra las entradas de registro y muestra el resultado en formato JSON:

      gcloud logging read "resource.labels.service_name=troubleshoot-service \
    AND textPayload:random.txt" \
    --format=json

    2. Busca una entrada de registro similar a lo siguiente:

      "textPayload": "Detected change in Cloud Storage bucket: ..."

Ten en cuenta que, en un principio, no se muestra ninguna entrada de registro. Esto indica que hay un problema en la configuración que debes investigar.

Investiga el problema

Revisa el proceso de investigar por qué el servicio no recibe eventos.

Hora de inicialización

Aunque tu activador se crea de inmediato, puede tardar hasta dos minutos en propagarse y filtrar los eventos. Ejecuta el siguiente comando para confirmar que un activador esté activo:

gcloud eventarc triggers list

El resultado indica el estado del activador. En el siguiente ejemplo, troubleshoot-trigger estará activo a las 14:16:56:

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

Una vez que el activador esté activo, vuelve a subir un archivo al bucket de almacenamiento. Los eventos se escriben en los registros del servicio de Cloud Run. Si el servicio no recibe eventos, podría estar relacionado con el tamaño de los eventos.

Registros de auditoría

En este instructivo, los eventos de Cloud Storage se enrutan mediante Registros de auditoría de Cloud y se envían a Cloud Run. Confirma que los registros de auditoría estén habilitados para Cloud Storage.

  1. En la consola de Google Cloud, ve a la página Registros de auditoría.

    Ve a Registros de auditoría

  2. Selecciona la casilla de verificación Google Cloud Storage.
  3. Asegúrate de que los tipos de registro Lectura de administrador, Lectura de datos y Escritura de datos estén seleccionados.

Una vez que hayas habilitado los Registros de auditoría de Cloud, vuelve a subir el archivo al bucket de almacenamiento y verifica los registros. Si el servicio aún no recibe eventos, esto podría estar relacionado con la ubicación del activador.

Ubicación del activador

Puede haber varios recursos en diferentes ubicaciones y debes filtrar los eventos de fuentes que se encuentran en la misma región que el destino de Cloud Run. Para obtener más información, consulta las ubicaciones compatibles con Eventarc e Información sobre las ubicaciones de Eventarc.

En este instructivo, implementaste el servicio de Cloud Run en us-central1. Debido a que configuraste eventarc/location como us-central1, también creaste un activador en la misma ubicación.

Sin embargo, creaste dos buckets de Cloud Storage en ubicaciones us-east1 y us-west1. Para recibir eventos de esas ubicaciones, debes crear activadores de Eventarc en esas ubicaciones.

Crea un activador de Eventarc ubicado en us-east1:

  1. Confirma la ubicación del activador existente:

    gcloud eventarc triggers describe troubleshoot-trigger

  2. Establece la ubicación y la región en us-east1:

    gcloud config set eventarc/location us-east1
gcloud config set run/region us-east1

  3. Implementa el receptor de eventos de nuevo mediante la compilación y la implementación de la imagen de contenedor en Cloud Run.

  4. Crea un activador nuevo ubicado en us-east1:

    gcloud eventarc triggers create troubleshoot-trigger-new \
  --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. Verifica que se haya creado el activador:

    gcloud eventarc triggers list

    La inicialización de un activador puede tomar hasta dos minutos antes de comenzar a enrutar eventos.

  6. Para confirmar que el activador ahora se implementó de forma correcta, genera y visualiza un evento.

Otros problemas que puedes tener

Es posible que tengas otros problemas cuando uses Eventarc.

Tamaño del evento

Los eventos que envíe no deben exceder los límites de tamaño del evento.

Dejó de funcionar un activador que ya se publicó antes

  1. Verifica que la fuente genere eventos. Verifica los Registros de auditoría de Cloud y asegúrate de que el servicio supervisado emita registros. Si se registran registros, pero los eventos no se entregan, comunícate con el equipo de asistencia.

  2. Verifica que exista un tema de Pub/Sub con el mismo nombre de activador. Eventarc usa Pub/Sub como su capa de transporte y usará un tema de Pub/Sub existente o creará un tema y lo administrará automáticamente.

    1. Para enumerar los activadores, consulta gcloud eventarc triggers list.

    2. Para enumerar los temas de Pub/Sub, ejecuta el siguiente comando:

      gcloud pubsub topics list

    3. Verifica que el nombre del tema de Pub/Sub incluya el nombre del activador creado. Por ejemplo:

      name: projects/PROJECT_ID/topics/eventarc-us-east1-troubleshoot-trigger-new-123

    Si falta el tema de Pub/Sub, vuelve a crear el activador para un proveedor, un tipo de evento y un destino de Cloud Run específicos.

  3. Verifica que el activador se haya configurado para el servicio.

    1. En la consola de Google Cloud, ve a la página Servicios.

      Ir a Servicios

    2. Haz clic en el nombre del servicio para abrir la página Detalles del servicio.

    3. Hacer clic en la pestaña Activadores

      Se debería mostrar el activador de Eventarc asociado con el servicio.

  4. Verifica el estado del tema y la suscripción de Pub/Sub mediante los tipos de métricas de Pub/Sub.

    Para obtener más información, consulta Crea políticas de alertas de límite de métrica.

Realiza una limpieza

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y deseas conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, haz lo siguiente:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina recursos de instructivos

  1. Usa este comando para borrar el servicio de Cloud Run que implementaste en este instructivo:

    gcloud run services delete SERVICE_NAME

    En el ejemplo anterior, SERVICE_NAME es el nombre del servicio que elegiste.

    También puedes borrar los servicios de Cloud Run desde la consola de Google Cloud.

  2. Quita todas las opciones de configuración predeterminadas de gcloud CLI que agregaste durante la configuración del instructivo.

    Por ejemplo:

    gcloud config unset run/region

    o

    gcloud config unset project

  3. Borra otros recursos de Google Cloud que creaste en este instructivo:

    • Borrar el activador de Eventarc: 
      gcloud eventarc triggers delete TRIGGER_NAME
      Reemplaza TRIGGER_NAME por el nombre de tu activador.

¿Qué sigue?