Tutoriel : Déboguer des événements de routage vers Cloud Run

Ce tutoriel explique comment corriger les erreurs d'exécution rencontrées lorsque vous utilisez Eventarc pour acheminer des événements de Cloud Storage vers un service Cloud Run non authentifié à l'aide de Cloud Audit Logs.

Objectifs

Ce guide vous explique comment effectuer les tâches suivantes :

  1. Créer un dépôt standard Artifact Registry pour stocker votre image de conteneur.
  2. Créer un bucket Cloud Storage qui servira de source d'événements.
  3. Créer, importer et déployer une image de conteneur dans Cloud Run
  4. Créer des déclencheurs Eventarc
  5. Importer un fichier dans le bucket Cloud Storage
  6. Corriger les erreurs d'exécution

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Les contraintes de sécurité définies par votre organisation peuvent vous empêcher d'effectuer les étapes suivantes. Pour obtenir des informations de dépannage, consultez la page Développer des applications dans un environnement Google Cloud limité.

  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 vous êtes le créateur du projet, vous disposez du rôle de base Propriétaire (roles/owner). Par défaut, ce rôle Identity and Access Management (IAM) inclut les autorisations nécessaires pour accéder à la plupart des ressources Google Cloud. Vous pouvez ignorer cette étape.

    Si vous n'êtes pas le créateur du projet, les autorisations requises doivent être accordées au compte principal approprié sur le projet. Par exemple, un compte principal peut être un compte Google (pour les utilisateurs finaux) ou un compte de service (pour les applications et les charges de travail de calcul). Pour en savoir plus, consultez la page Rôles et autorisations pour la destination de votre événement.

    Notez que par défaut, les autorisations Cloud Build incluent des autorisations permettant d'importer et de télécharger des artefacts Artifact Registry.

    Autorisations requises

    Pour obtenir les autorisations nécessaires pour suivre ce tutoriel, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

    Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

    Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

  13. Pour Cloud Storage, activez la journalisation d'audit pour les types d'accès aux données ADMIN_READ, DATA_WRITE et DATA_READ.

    1. Lisez la stratégie IAM (Identity and Access Management) associée à votre projet, dossier ou organisation Google Cloud, et stockez-la dans un fichier temporaire : 
      gcloud projects get-iam-policy PROJECT_ID > /tmp/policy.yaml

    2. Dans un éditeur de texte, ouvrez /tmp/policy.yaml, puis ajoutez ou modifiez uniquement la configuration du journal d'audit dans la section auditConfigs :

      auditConfigs:
- auditLogConfigs:
  - logType: ADMIN_READ
  - logType: DATA_WRITE
  - logType: DATA_READ
  service: storage.googleapis.com
bindings:
- members:
[...]
etag: BwW_bHKTV5U=
version: 1
    3. Rédigez votre nouvelle stratégie IAM : 
      gcloud projects set-iam-policy PROJECT_ID /tmp/policy.yaml

      Si la commande précédente signale un conflit avec une autre modification, répétez ces étapes en commençant par la lecture de la stratégie IAM. Pour en savoir plus, consultez la page Configurer les journaux d'audit pour l'accès aux données à l'aide de l'API.

  14. Attribuez le rôle eventarc.eventReceiver au compte de service 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 vous avez activé le compte de service Pub/Sub le 8 avril 2021 ou avant cette date, attribuez le rôle iam.serviceAccountTokenCreator au compte de service 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. Définissez les valeurs par défaut utilisées dans ce tutoriel : 
    export REGION=us-central1
gcloud config set run/region ${REGION}
gcloud config set run/platform managed
gcloud config set eventarc/location ${REGION}

Créer un dépôt standard Artifact Registry

Créez un dépôt standard Artifact Registry pour stocker votre image de conteneur :

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

Remplacez REPOSITORY par un nom unique pour le dépôt.

Créer un bucket Cloud Storage

Créez un bucket Cloud Storage dans chacune des deux régions qui servira de source d'événements pour le service Cloud Run :

  1. Créez un bucket dans us-east1 :

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

  2. Créez un bucket dans us-west1 :

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

Une fois la source d'événements créée, déployez le service récepteur d'événements sur Cloud Run.

Déployer le récepteur d'événements

Déployez un service Cloud Run qui reçoit et consigne les événements.

  1. Récupérez l'exemple de code en clonant le dépôt GitHub :

    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. Examinez le code de ce tutoriel, composé des éléments suivants :

    • Un gestionnaire d'événements qui reçoit l'événement entrant en tant que CloudEvent dans la requête 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 serveur qui utilise le gestionnaire d'événements :

      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 qui définit l'environnement d'exploitation du service. Le contenu du Dockerfile varie selon le langage :

      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. Créez votre image de conteneur avec Cloud Build, puis importez-la dans 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. Déployez l'image de conteneur dans Cloud Run :

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

    Une fois le déploiement effectué, la ligne de commande affiche l'URL du service.

Créer un déclencheur

Après avoir déployé un service Cloud Run, configurez un déclencheur pour écouter les événements de Cloud Storage via des journaux d'audit.

  1. Créez un déclencheur Eventarc pour écouter les événements Cloud Storage acheminés à l'aide de Cloud Audit Logs :

    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

    Cette action crée un déclencheur appelé troubleshoot-trigger.

  2. Pour vérifier que troubleshoot-trigger a été créé, exécutez la commande suivante :

    gcloud eventarc triggers list

    La sortie devrait ressembler à ce qui suit :

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

Générer et afficher un événement

Vérifiez que le service a bien été déployé et que vous pouvez recevoir des événements de Cloud Storage.

  1. Créez et importez un fichier dans le premier bucket de stockage BUCKET1 :

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

  2. Surveillez les journaux pour vérifier si le service a reçu un événement. Pour afficher l'entrée de journal, procédez comme suit :

    1. Filtrez les entrées de journal et renvoyez la sortie au format JSON :

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

    2. Recherchez une entrée de journal semblable à ceci :

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

Notez que, dans un premier temps, aucune entrée de journal n'est renvoyée. Cela indique qu'il existe un problème dans la configuration que vous devez examiner.

Examiner le problème

Suivez le processus permettant de déterminer pourquoi le service ne reçoit pas d'événements.

Délai d'initialisation

Bien que votre déclencheur soit créé immédiatement, sa propagation et le filtrage d'événements peuvent prendre jusqu'à deux minutes. Exécutez la commande suivante pour vérifier qu'un déclencheur est actif :

gcloud eventarc triggers list

Le résultat indique l'état du déclencheur. Dans l'exemple suivant, troubleshoot-trigger sera actif à 14:16:56 :

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

Une fois le déclencheur actif, importez à nouveau un fichier dans le bucket de stockage. Les événements sont écrits dans les journaux du service Cloud Run. Si le service ne reçoit pas d'événements, cela peut être lié à la taille des événements.

Journaux d'audit

Dans ce tutoriel, les événements Cloud Storage sont acheminés à l'aide de Cloud Audit Logs et envoyés à Cloud Run. Vérifiez que les journaux d'audit sont activés pour Cloud Storage.

  1. Dans la console Google Cloud, accédez à la page Journaux d'audit.

    Accéder aux journaux d'audit

  2. Cochez la case Google Cloud Storage.
  3. Assurez-vous que les types de journaux Lecture administrateur, Lecture de données et Écriture de données sont sélectionnés.

Une fois que vous avez activé Cloud Audit Logs, importez à nouveau le fichier dans le bucket de stockage et vérifiez les journaux. Si le service ne reçoit toujours pas d'événements, cela peut être lié à l'emplacement du déclencheur.

Emplacement du déclencheur

Plusieurs ressources peuvent se trouver à différents emplacements. Vous devez filtrer les événements des sources situées dans la même région que la cible Cloud Run. Pour en savoir plus, consultez les pages Emplacements compatibles avec Eventarc et Comprendre les emplacements Eventarc.

Dans ce tutoriel, vous avez déployé le service Cloud Run dans la zone us-central1. Comme vous avez défini eventarc/location sur us-central1, vous avez également créé un déclencheur au même emplacement.

Cependant, vous avez créé deux buckets Cloud Storage dans les emplacements us-east1 et us-west1. Pour recevoir des événements de ces emplacements, vous devez y créer des déclencheurs Eventarc.

Créez un déclencheur Eventarc situé dans us-east1 :

  1. Confirmez l'emplacement du déclencheur existant :

    gcloud eventarc triggers describe troubleshoot-trigger

  2. Définissez l'emplacement et la région sur us-east1 :

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

  3. Déployez à nouveau le récepteur d'événements en créant et en déployant l'image de conteneur dans Cloud Run.

  4. Créez un nouveau déclencheur situé dans 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. Vérifiez que le déclencheur a été créé :

    gcloud eventarc triggers list

    Un déclencheur peut prendre jusqu'à deux minutes pour s'initialiser avant de commencer à acheminer des événements.

  6. Pour vérifier que le déclencheur est désormais déployé correctement, générez et affichez un événement.

Autres problèmes que vous pouvez rencontrer

Vous pouvez rencontrer d'autres problèmes lors de l'utilisation d'Eventarc.

Taille des événements

Les événements que vous envoyez ne doivent pas dépasser les limites de taille des événements.

Un déclencheur ayant déjà diffusé des événements a cessé de fonctionner

  1. Vérifiez que la source génère des événements. Vérifiez les journaux Cloud Audit Logs et assurez-vous que le service surveillé émet des journaux. Si les journaux sont enregistrés, mais que les événements ne sont pas diffusés, contactez l'assistance.

  2. Vérifiez qu'un sujet Pub/Sub avec le même nom de déclencheur existe. Eventarc utilise Pub/Sub comme couche de transport et utilisera un sujet Pub/Sub existant ou créera automatiquement un sujet et le gérera pour vous.

    1. Pour lister les déclencheurs, consultez la section gcloud eventarc triggers list.

    2. Pour répertorier les sujets Pub/Sub, exécutez la commande suivante :

      gcloud pubsub topics list

    3. Vérifiez que le nom du sujet Pub/Sub inclut le nom du déclencheur créé. Exemple :

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

    Si le sujet Pub/Sub est manquant, recréez le déclencheur pour un fournisseur, un type d'événement et une destination Cloud Run spécifiques.

  3. Vérifiez que le déclencheur a été configuré pour le service.

    1. Dans Google Cloud Console, accédez à la page Services.

      Accéder aux services

    2. Cliquez sur le nom du service pour ouvrir la page Informations sur le service.

    3. Cliquez sur l'onglet Triggers (Déclencheurs).

      Le déclencheur Eventarc associé au service doit apparaître dans la liste.

  4. Vérifiez l'état du sujet et de l'abonnement Pub/Sub à l'aide des types de métriques Pub/Sub.

    • Vous pouvez surveiller les messages non distribuables transférés à l'aide de la métrique subscription/dead_letter_message_count. Cette métrique indique le nombre de messages non distribuables que Pub/Sub transfère à partir d'un abonnement.

      Si les messages ne sont pas publiés dans le sujet, vérifiez les journaux Cloud Audit Logs et assurez-vous que le service surveillé émet des journaux. Si les journaux sont enregistrés, mais que les événements ne sont pas diffusés, contactez l'assistance.

    • Vous pouvez surveiller les abonnements push à l'aide de la métrique subscription/push_request_count et en regroupant la métrique par response_code et subcription_id.

      Si des erreurs de transmission sont signalées, consultez les journaux du service Cloud Run. Si le point de terminaison de réception renvoie un code d'état autre que OK, cela signifie que le code Cloud Run ne fonctionne pas comme prévu et que vous devez contacter l'assistance.

    Pour plus d'informations, consultez la page Créer des règles d'alerte basées sur un seuil de métrique.

Effectuer un nettoyage

Si vous avez créé un projet pour ce tutoriel, supprimez-le. Si vous avez utilisé un projet existant et que vous souhaitez le conserver sans les modifications du présent tutoriel, supprimez les ressources créées pour ce tutoriel.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  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.

Supprimer les ressources du tutoriel

  1. Supprimez le service Cloud Run que vous avez déployé dans ce tutoriel :

    gcloud run services delete SERVICE_NAME

    Où SERVICE_NAME est le nom de service que vous avez choisi.

    Vous pouvez également supprimer des services Cloud Run à partir de Google Cloud Console.

  2. Supprimez les configurations gcloud CLI par défaut que vous avez ajoutées lors de la configuration du tutoriel.

    Exemple :

    gcloud config unset run/region

    ou

    gcloud config unset project

  3. Supprimez les autres ressources Google Cloud créées dans ce tutoriel :

    • Supprimez le déclencheur Eventarc : 
      gcloud eventarc triggers delete TRIGGER_NAME
      Remplacez TRIGGER_NAME par le nom de votre déclencheur.

Étapes suivantes