Tutoriel : Utiliser Pub/Sub avec Cloud Run

Ce tutoriel explique comment écrire, déployer et appeler un service Cloud Run à partir d'un abonnement push Pub/Sub.

Objectifs

Écrire, créer et déployer un service sur Cloud Run
Appeler le service en publiant un message dans un sujet Pub/Sub

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

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

Enable the Artifact Registry, Cloud Build, Pub/Sub et Cloud Run APIs.
Enable the APIs

Installez et initialisez gcloud CLI.
Mettez à jour les composants :
```
gcloud components update
```

Rôles requis

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

Éditeur Cloud Build (roles/cloudbuild.builds.editor)
Administrateur Cloud Run (roles/run.admin)
Créateur de comptes de service (roles/iam.serviceAccountCreator)
Administrateur de projet IAM (roles/resourcemanager.projectIamAdmin)
Éditeur Pub/Sub (roles/pubsub.editor)
Utilisateur du compte de service (roles/iam.serviceAccountUser)
Consommateur Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrateur de l'espace de stockage (roles/storage.admin)

Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

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

Configurer les paramètres par défaut de gcloud

Pour configurer gcloud avec les valeurs par défaut pour votre service Cloud Run, procédez comme suit :

Définissez le projet par défaut :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par le nom du projet que vous avez créé pour ce tutoriel.
Configurez gcloud pour la région choisie :
```
gcloud config set run/region REGION
```
Remplacez REGION par la région Cloud Run compatible de votre choix.

Emplacements Cloud Run

Cloud Run est régional, ce qui signifie que l'infrastructure qui exécute vos services Cloud Run est située dans une région spécifique et gérée par Google pour être disponible de manière redondante dans toutes les zones de cette région.

Lors de la sélection de la région dans laquelle exécuter vos services Cloud Run, vous devez tout d'abord considérer vos exigences en matière de latence, de disponibilité et de durabilité. Vous pouvez généralement sélectionner la région la plus proche de vos utilisateurs, mais vous devez tenir compte de l'emplacement des autres produits Google Cloud utilisés par votre service Cloud Run. L'utilisation conjointe de produits Google Cloud dans plusieurs emplacements peut avoir une incidence sur la latence et le coût de votre service.

Cloud Run est disponible dans les régions suivantes :

Soumis aux tarifs de niveau 1

asia-east1 (Taïwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
europe-north1 (Finlande) Faibles émissions de CO₂
europe-southwest1 (Madrid)
europe-west1 (Belgique) Faibles émissions de CO₂
europe-west4 (Pays-Bas)
europe-west8 (Milan)
europe-west9 (Paris) Faibles émissions de CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) Faibles émissions de CO₂
us-east1 (Caroline du Sud)
us-east4 (Virginie du Nord)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) Faibles émissions de CO₂

Soumis aux tarifs de niveau 2

africa-south1 (Johannesburg)
asia-east2 (Hong Kong)
asia-northeast3 (Séoul, Corée du Sud)
asia-southeast1 (Singapour)
asia-southeast2 (Jakarta)
asia-south1 (Mumbai, Inde)
asia-south2 (Delhi, Inde)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Varsovie, Pologne)
europe-west10 (Berlin)
europe-west12 (Turin)
europe-west2 (Londres, Royaume-Uni) Faibles émissions de CO₂
europe-west3 (Francfort, Allemagne) Faibles émissions de CO₂
europe-west6 (Zurich, Suisse) Faibles émissions de CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montréal) Faibles émissions de CO₂
northamerica-northeast2 (Toronto) Faibles émissions de CO₂
southamerica-east1 (São Paulo, Brésil) Faibles émissions de CO₂
southamerica-west1 (Santiago, Chili) Faibles émissions de CO₂
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Si vous avez déjà créé un service Cloud Run, vous pouvez afficher la région dans le tableau de bord Cloud Run de la console Google Cloud.

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
REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.

Créer un sujet Pub/Sub

L'exemple de service est déclenché par les messages publiés dans un sujet Pub/Sub. Vous devez donc créer un sujet dans Pub/Sub.

Ligne de commande

Pour créer un sujet Pub/Sub, utilisez la commande suivante :

gcloud pubsub topics create myRunTopic

Vous pouvez conserver le nom myRunTopic ou le remplacer par un nom de sujet unique dans votre projet Google Cloud.

Terraform

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

Pour créer un sujet Pub/Sub, ajoutez le code suivant à votre fichier main.tf existant :

resource "google_pubsub_topic" "default" {
  name = "pubsub_topic"
}

Vous pouvez utiliser un nom de sujet unique dans votre projet Cloud.

Récupérer l'exemple de code

Pour récupérer l’exemple de code à utiliser, procédez comme suit :

Clonez le dépôt de l'exemple d'application sur votre machine locale :
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
C#
```
git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

Accédez au répertoire contenant l'exemple de code Cloud Run :

Node.js

cd nodejs-docs-samples/run/pubsub/

Python

cd python-docs-samples/run/pubsub/

Go

cd golang-samples/run/pubsub/

Java

cd java-docs-samples/run/pubsub/

C#

cd dotnet-docs-samples/run/pubsub/

Examiner le code

Le code de ce tutoriel comprend les éléments suivants :

Un serveur qui gère les requêtes entrantes.

Node.js

Pour que le service Node.js reste facile à tester, la configuration du serveur est distincte du démarrage du serveur.

Le serveur Web Node.js est configuré dans app.js.

const express = require('express');
const app = express();

// This middleware is available in Express v4.16.0 onwards
app.use(express.json());

Le serveur Web est démarré dans index.js :

const app = require('./app.js');
const PORT = parseInt(parseInt(process.env.PORT)) || 8080;

app.listen(PORT, () =>
  console.log(`nodejs-pubsub-tutorial listening on port ${PORT}`)
);

Python

import base64

from flask import Flask, request

app = Flask(__name__)

Go


// Sample run-pubsub is a Cloud Run service which handles Pub/Sub messages.
package main

import (
	"encoding/json"
	"io/ioutil"
	"log"
	"net/http"
	"os"
)

func main() {
	http.HandleFunc("/", HelloPubSub)
	// Determine port for HTTP service.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("Defaulting to port %s", port)
	}
	// 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 PubSubApplication {
  public static void main(String[] args) {
    SpringApplication.run(PubSubApplication.class, args);
  }
}

C#

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var port = Environment.GetEnvironmentVariable("PORT");
if (port != null)
{
    app.Urls.Add($"http://0.0.0.0:{port}");
}

Un gestionnaire qui traite le message Pub/Sub et enregistre un message d'accueil.

Node.js

app.post('/', (req, res) => {
  if (!req.body) {
    const msg = 'no Pub/Sub message received';
    console.error(`error: ${msg}`);
    res.status(400).send(`Bad Request: ${msg}`);
    return;
  }
  if (!req.body.message) {
    const msg = 'invalid Pub/Sub message format';
    console.error(`error: ${msg}`);
    res.status(400).send(`Bad Request: ${msg}`);
    return;
  }

  const pubSubMessage = req.body.message;
  const name = pubSubMessage.data
    ? Buffer.from(pubSubMessage.data, 'base64').toString().trim()
    : 'World';

  console.log(`Hello ${name}!`);
  res.status(204).send();
});

Python

@app.route("/", methods=["POST"])
def index():
    """Receive and parse Pub/Sub messages."""
    envelope = request.get_json()
    if not envelope:
        msg = "no Pub/Sub message received"
        print(f"error: {msg}")
        return f"Bad Request: {msg}", 400

    if not isinstance(envelope, dict) or "message" not in envelope:
        msg = "invalid Pub/Sub message format"
        print(f"error: {msg}")
        return f"Bad Request: {msg}", 400

    pubsub_message = envelope["message"]

    name = "World"
    if isinstance(pubsub_message, dict) and "data" in pubsub_message:
        name = base64.b64decode(pubsub_message["data"]).decode("utf-8").strip()

    print(f"Hello {name}!")

    return ("", 204)

Go


// PubSubMessage is the payload of a Pub/Sub event.
// See the documentation for more details:
// https://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage
type PubSubMessage struct {
	Message struct {
		Data []byte `json:"data,omitempty"`
		ID   string `json:"id"`
	} `json:"message"`
	Subscription string `json:"subscription"`
}

// HelloPubSub receives and processes a Pub/Sub push message.
func HelloPubSub(w http.ResponseWriter, r *http.Request) {
	var m PubSubMessage
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Printf("ioutil.ReadAll: %v", err)
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}
	// byte slice unmarshalling handles base64 decoding.
	if err := json.Unmarshal(body, &m); err != nil {
		log.Printf("json.Unmarshal: %v", err)
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}

	name := string(m.Message.Data)
	if name == "" {
		name = "World"
	}
	log.Printf("Hello %s!", name)
}

Java

import com.example.cloudrun.Body;
import java.util.Base64;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

// PubsubController consumes a Pub/Sub message.
@RestController
public class PubSubController {
  @RequestMapping(value = "/", method = RequestMethod.POST)
  public ResponseEntity<String> receiveMessage(@RequestBody Body body) {
    // Get PubSub message from request body.
    Body.Message message = body.getMessage();
    if (message == null) {
      String msg = "Bad Request: invalid Pub/Sub message format";
      System.out.println(msg);
      return new ResponseEntity<>(msg, HttpStatus.BAD_REQUEST);
    }

    String data = message.getData();
    String target =
        !StringUtils.isEmpty(data) ? new String(Base64.getDecoder().decode(data)) : "World";
    String msg = "Hello " + target + "!";

    System.out.println(msg);
    return new ResponseEntity<>(msg, HttpStatus.OK);
  }
}

C#

app.MapPost("/", (Envelope envelope) =>
{
    if (envelope?.Message?.Data == null)
    {
        app.Logger.LogWarning("Bad Request: Invalid Pub/Sub message format.");
        return Results.BadRequest();
    }

    var data = Convert.FromBase64String(envelope.Message.Data);
    var target = System.Text.Encoding.UTF8.GetString(data);

    app.Logger.LogInformation($"Hello {target}!");

    return Results.NoContent();
});

Vous devez coder le service pour renvoyer un code de réponse HTTP précis. Les codes de réussite, tels que HTTP 200 ou 204, confirment le traitement complet du message Pub/Sub. Les codes d'erreur, tels que HTTP 400 ou 500, indiquent qu'une nouvelle tentative d'envoi sera effectuée, comme décrit dans le guide Recevoir des messages en mode push.

Un fichier Dockerfile qui définit l'environnement d'exploitation du service. Le contenu du fichier Dockerfile varie selon le langage.

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

# 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.
# Timeout is set to 0 to disable the timeouts of the workers to allow Cloud Run to handle instance scaling.
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

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

Cet exemple utilise Jib pour créer des images Docker à l'aide d'outils Java courants. Jib optimise les builds de conteneurs sans requérir de fichier Dockerfile ni d'installation Docker. Découvrez comment créer des conteneurs Java avec Jib.

<plugin>
  <groupId>com.google.cloud.tools</groupId>
  <artifactId>jib-maven-plugin</artifactId>
  <version>3.4.0</version>
  <configuration>
    <to>
      <image>gcr.io/PROJECT_ID/pubsub</image>
    </to>
  </configuration>
</plugin>

C#

# Build in SDK base image
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -r linux-x64 --no-self-contained -p:PublishReadyToRun=true -c Release -o out

# Copy to runtime image
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .

# Port passed in by Cloud Run via environment variable PORT.  Default 8080.
ENV PORT=8080

ENTRYPOINT ["dotnet", "Run.Samples.Pubsub.MinimalApi.dll"]

Pour en savoir plus sur l'authentification de l'origine des requêtes Pub/Sub, consultez la page Effectuer l'intégration à Pub/Sub.

Envoyer le code

La transmission du code se déroule en trois étapes : création d'une image de conteneur avec Cloud Build, importation de l'image de conteneur dans Artifact Registry, puis déploiement de cette image dans Cloud Run.

Pour transmettre votre code, procédez comme suit :

Créez votre conteneur et publiez-le dans Artifact Registry :
Node.js
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Remplacez :
- PROJECT_ID par l'ID de votre projet Google Cloud
- REPOSITORY par le nom du dépôt Artifact Registry ;
- REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.
pubsub correspond au nom de l'image.

En cas de réussite, un message SUCCESS apparaît contenant l'ID, l'heure de création et le nom de l'image. L'image est stockée dans Artifact Registry et peut être réutilisée si nécessaire.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Remplacez :
- PROJECT_ID par l'ID de votre projet Google Cloud
- REPOSITORY par le nom du dépôt Artifact Registry ;
- REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.
pubsub correspond au nom de l'image.

En cas de réussite, un message SUCCESS apparaît contenant l'ID, l'heure de création et le nom de l'image. L'image est stockée dans Artifact Registry et peut être réutilisée si nécessaire.
Go
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Remplacez :
- PROJECT_ID par l'ID de votre projet Google Cloud
- REPOSITORY par le nom du dépôt Artifact Registry ;
- REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.
pubsub correspond au nom de l'image.

En cas de réussite, un message SUCCESS apparaît contenant l'ID, l'heure de création et le nom de l'image. L'image est stockée dans Artifact Registry et peut être réutilisée si nécessaire.
Java
- Utilisez l'assistant d'identification gcloud CLI pour autoriser Docker à transférer du contenu vers Artifact Registry.
  gcloud auth configure-docker
- Utilisez le plug-in Maven Jib pour créer et transférer le conteneur dans Artifact Registry.
  mvn compile jib:build -D image=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
  Remplacez :
  - PROJECT_ID par l'ID de votre projet Google Cloud
  - REPOSITORY par le nom du dépôt Artifact Registry ;
  - REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.
  pubsub correspond au nom de l'image.
  
  En cas de réussite, un message BUILD SUCCESS apparaît. L'image est stockée dans Artifact Registry et peut être réutilisée si nécessaire.
C#
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Remplacez :
- PROJECT_ID par l'ID de votre projet Google Cloud
- REPOSITORY par le nom du dépôt Artifact Registry ;
- REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.
pubsub correspond au nom de l'image.

En cas de réussite, un message SUCCESS apparaît contenant l'ID, l'heure de création et le nom de l'image. L'image est stockée dans Artifact Registry et peut être réutilisée si nécessaire.
Déployez votre application :
Ligne de commande
1. Exécutez la commande suivante pour déployer votre application :
  gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub --no-allow-unauthenticated
  Remplacez :
  - PROJECT_ID par l'ID de votre projet Google Cloud
  - REPOSITORY par le nom du dépôt Artifact Registry ;
  - REGION par la région Google Cloud à utiliser pour le dépôt Artifact Registry.
  pubsub correspond au nom de l'image et pubsub-tutorial au nom du service. Notez que l'image de conteneur est déployée sur le service et la région que vous avez précédemment configurés dans la section Configurer gcloud.
  
  L'option --no-allow-unauthenticated limite l'accès non authentifié au service. En gardant le service privé, le processus d'intégration automatique à Pub/Sub de Cloud Run assure l'authentification des requêtes. Cette configuration est présentée en détail dans la section Effectuer l'intégration à Pub/Sub. Pour en savoir plus sur l'authentification basée sur Identity and Access Management (IAM), consultez la page Gérer les accès à l'aide d'IAM.
  
  Patientez jusqu'à la fin du déploiement, soit environ 30 secondes. En cas de réussite, la ligne de commande affiche l'URL du service. Cette URL est utilisée pour configurer un abonnement Pub/Sub.
2. Si vous souhaitez déployer une mise à jour de code sur le service, répétez les opérations précédentes. Chaque déploiement sur un service crée une nouvelle révision et commence automatiquement à acheminer le trafic une fois prêt.
Terraform

Pour créer un service Cloud Run, ajoutez le code suivant à votre fichier .tf existant.

Remplacez la valeur d'image par l'URL de votre image : REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub.
resource "google_cloud_run_v2_service" "default" { name = "pubsub-tutorial" location = "us-central1" template { containers { image = "us-docker.pkg.dev/cloudrun/container/hello" # Replace with newly created image gcr.io/<project_id>/pubsub } } depends_on = [google_project_service.cloudrun_api] }

Effectuer l'intégration à Pub/Sub

Pour intégrer le service à Pub/Sub, procédez comme suit :

Ligne de commande

Créez ou sélectionnez un compte de service pour représenter l'identité de l'abonnement Pub/Sub.
```
gcloud iam service-accounts create cloud-run-pubsub-invoker \
    --display-name "Cloud Run Pub/Sub Invoker"
```
Vous pouvez utiliser l'identité cloud-run-pubsub-invoker ou la remplacer par un nom unique dans votre projet Google Cloud Platform.
Créez un abonnement Pub/Sub avec le compte de service :
1. Autorisez le compte de service demandeur à appeler votre service pubsub-tutorial :
```
gcloud run services add-iam-policy-binding pubsub-tutorial \
--member=serviceAccount:cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com \
--role=roles/run.invoker
```
  La diffusion des modifications IAM peut prendre plusieurs minutes. Pendant ce temps, des erreurs HTTP 403 peuvent s'afficher dans les journaux de service.
2. Autorisez Pub/Sub à créer des jetons d'authentification dans votre projet :
```
gcloud projects add-iam-policy-binding PROJECT_ID \
   --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
   --role=roles/iam.serviceAccountTokenCreator
```
  Remplacez :
  - PROJECT_ID par l'ID de votre projet Google Cloud
  - PROJECT_NUMBER par le numéro de votre projet Google Cloud
  L'ID et le numéro du projet sont répertoriés dans le panneau Informations sur le projet de la console Google Cloud pour votre projet.
3. Créez un abonnement Pub/Sub avec le compte de service :
```
gcloud pubsub subscriptions create myRunSubscription --topic myRunTopic \
--ack-deadline=600 \
--push-endpoint=SERVICE-URL/ \
--push-auth-service-account=cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com
```
  Remplacez :
  - myRunTopic par le sujet que vous avez créé précédemment
  - SERVICE-URL par l'URL HTTPS fournie lors du déploiement du service. Cette URL fonctionne même si vous avez également ajouté un mappage de domaine.
  - PROJECT_ID par l'ID de votre projet Google Cloud
  L'option --push-auth-service-account active la fonctionnalité push de Pub/Sub pour l'authentification et l'autorisation.
  
  Votre domaine de service Cloud Run est automatiquement enregistré pour une utilisation avec les abonnements Pub/Sub.
  
  Cloud Run dispose de vérifications intégrées permettant de confirmer que le jeton d'authentification est valide et que le compte de service est autorisé à appeler le service Cloud Run.

Votre service est maintenant entièrement intégré à Pub/Sub.

Terraform

Créez ou sélectionnez un compte de service pour représenter l'identité de l'abonnement Pub/Sub.

resource "google_service_account" "sa" {
  account_id   = "cloud-run-pubsub-invoker"
  display_name = "Cloud Run Pub/Sub Invoker"
}

Créez un abonnement Pub/Sub avec le compte de service :

Autorisez le compte de service demandeur à appeler votre service pubsub-tutorial :

resource "google_cloud_run_service_iam_binding" "binding" {
  location = google_cloud_run_v2_service.default.location
  service  = google_cloud_run_v2_service.default.name
  role     = "roles/run.invoker"
  members  = ["serviceAccount:${google_service_account.sa.email}"]
}

Autorisez Pub/Sub à créer des jetons d'authentification dans votre projet :

resource "google_project_service_identity" "pubsub_agent" {
  provider = google-beta
  project  = data.google_project.project.project_id
  service  = "pubsub.googleapis.com"
}

resource "google_project_iam_binding" "project_token_creator" {
  project = data.google_project.project.project_id
  role    = "roles/iam.serviceAccountTokenCreator"
  members = ["serviceAccount:${google_project_service_identity.pubsub_agent.email}"]
}

Créez un abonnement Pub/Sub avec le compte de service :

resource "google_pubsub_subscription" "subscription" {
  name  = "pubsub_subscription"
  topic = google_pubsub_topic.default.name
  push_config {
    push_endpoint = google_cloud_run_v2_service.default.uri
    oidc_token {
      service_account_email = google_service_account.sa.email
    }
    attributes = {
      x-goog-version = "v1"
    }
  }
  depends_on = [google_cloud_run_v2_service.default]
}

Votre service est maintenant entièrement intégré à Pub/Sub.

Essayer

Pour tester la solution de bout en bout, procédez comme suit :

Envoyez un message au sujet sur Pub/Sub :
```
gcloud pubsub topics publish myRunTopic --message "Runner"
```
Au lieu d'utiliser la ligne de commande comme décrit dans ce tutoriel, vous pouvez programmer la publication des messages. Reportez-vous à la page Publier des messages pour en savoir plus.
Accédez aux journaux du service :
1. Accédez à Google Cloud Console.
2. Cliquez sur le service pubsub-tutorial.
3. Sélectionnez l'onglet Journaux.
  
  L'affichage des journaux peut nécessiter quelques instants. S'ils n'apparaissent pas immédiatement, patientez et vérifiez de nouveau.
Recherchez le message "Hello Runner!".

Nettoyer

Pour mieux comprendre comment utiliser Cloud Run avec Pub/Sub, ignorez le nettoyage pour le moment et poursuivez avec le tutoriel sur le traitement d'images avec Cloud Run.

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 :

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Supprimer les ressources du tutoriel

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.
Supprimez la configuration régionale gcloud par défaut que vous avez ajoutée lors de la configuration du tutoriel :
```
 gcloud config unset run/region
```
Supprimez la configuration du projet :
```
 gcloud config unset project
```
Supprimez les autres ressources Google Cloud créées dans ce tutoriel :
- Supprimez le sujet Pub/Sub myRunTopic.
- Supprimez l'abonnement Pub/Sub myRunSubscription.
- Supprimez de Artifact Registry votre image de conteneur, nommée REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub.
- Supprimez le compte de service demandeur cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com.

Étape suivante

Pour en savoir plus sur l'augmentation de la sécurité de production à l'aide des contrôles d'entrée internes afin de limiter le trafic entrant, consultez la page Restreindre le trafic entrant.
Développez l'exemple de service déployé dans ce tutoriel pour ajouter une fonctionnalité de traitement d'images qui modifie les images importées dans Cloud Storage.
Découvrez comment les sujets s'intègrent à l'architecture Pub/Sub et comment gérer les sujets.
Pour en savoir plus sur les abonnements Pub/Sub, consultez la section Gérer les abonnements.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.