Tutorial: usa Pub/Sub con Cloud Run

Questo tutorial mostra come scrivere, eseguire il deployment e chiamare un Cloud Run da una sottoscrizione push di Pub/Sub.

Obiettivi

  • Scrivi, crea ed esegui il deployment di un servizio in Cloud Run
  • Chiama il servizio pubblicando un messaggio in un argomento Pub/Sub.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

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

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

    Go to project selector

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  6. Abilita le API Artifact Registry, Cloud Build, Pub/Sub and Cloud Run.

    Abilita le API

  7. Installa e inizializza gcloud CLI.
  8. Aggiorna i componenti: 
    gcloud components update

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial: chiedi all'amministratore di concederti i seguenti ruoli IAM sul tuo progetto:

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.

Configura le impostazioni predefinite di gcloud

Per configurare gcloud con i valori predefiniti per il tuo servizio Cloud Run:

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con il nome del progetto per cui hai creato questo tutorial.

  2. Configura gcloud per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con il Cloud Run supportato regione di tua scelta.

Località Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura dei tuoi servizi Cloud Run si trova in una regione specifica gestiti da Google affinché siano disponibili in modo ridondante tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. Generalmente puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la località dell'altro account Google Cloud prodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire nonché la latenza del tuo servizio.

Cloud Run è disponibile nelle regioni seguenti:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Se hai già creato un servizio Cloud Run, puoi visualizzare nella dashboard di Cloud Run all'interno Console Google Cloud.

Crea un repository standard Artifact Registry

Crea un repository standard Artifact Registry per archiviare la tua immagine container:

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

Sostituisci:

  • REPOSITORY con un nome univoco per il repository.
  • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

crea un argomento Pub/Sub

Il servizio di esempio viene attivato dai messaggi pubblicati in Pub/Sub quindi dovrai crearne uno in Pub/Sub.

gcloud

Per creare un nuovo argomento Pub/Sub, utilizza il comando:

gcloud pubsub topics create myRunTopic

Puoi utilizzare myRunTopic o sostituirlo con un nome di argomento univoco all'interno del tuo progetto Google Cloud.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta: Comandi Terraform di base.

Per creare un argomento Pub/Sub, aggiungi quanto segue al file main.tf esistente:

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

Puoi utilizzare un nome argomento univoco all'interno del tuo progetto Cloud.

Recupera l'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

  1. Clona il repository dell'app di esempio nella tua macchina locale:

    Node.js 

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

    Python 

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

    Vai 

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

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

    Java 

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

    C# 

    git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git

    In alternativa, puoi scarica l'esempio . come file ZIP ed estrarlo.

  2. Passa alla directory che contiene l'esempio di Cloud Run codice:

    Node.js 

    cd nodejs-docs-samples/run/pubsub/

    Python 

    cd python-docs-samples/run/pubsub/

    Vai 

    cd golang-samples/run/pubsub/

    Java 

    cd java-docs-samples/run/pubsub/

    C# 

    cd dotnet-docs-samples/run/pubsub/

Esamina il codice

Il codice di questo tutorial è costituito dai seguenti elementi:

  • Un server che gestisce le richieste in entrata.

    Node.js

    Per semplificare il test del servizio Node.js, la configurazione del server è separata dall'avvio del server.

    Il server web Node.js è configurato in app.js. 

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

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

    Il server web è stato avviato in 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__)

    Vai 

    
// 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 gestore che elabora il messaggio Pub/Sub e registra un saluto.

    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)

    Vai 

    
// 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();
});

    Devi codificare il servizio in modo che restituisca un codice di risposta HTTP accurato. Operazione riuscita come HTTP 200 o 204, confermano l'elaborazione completa un messaggio Pub/Sub. I codici di errore, come HTTP 400 o 500, indicano verrà effettuato un nuovo tentativo del messaggio, come descritto Ricezione di messaggi con la guida alle notifiche push.

  • Un elemento Dockerfile che definisce l'ambiente operativo del servizio. La i contenuti di Dockerfile variano a seconda della lingua.

    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

    Vai 

    
# 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

    Questo esempio utilizza Jib per creare utilizzando strumenti Java comuni. Jib ottimizza le build di container senza la necessità di un Dockerfile o di avere Docker installato. Scopri di più sulla creazione di container Java con 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"]

Per maggiori dettagli su come autenticare l'origine delle richieste Pub/Sub, consulta Eseguire l'integrazione con Pub/Sub.

Spedisci il codice

Il codice di spedizione prevede tre passaggi: la creazione di un'immagine container con Cloud Build, caricando l'immagine container in Artifact Registry e il deployment dell'immagine container in Cloud Run.

Per spedire il codice:

  1. Crea il tuo container e pubblicalo su Artifact Registry:

    Node.js 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
    Sostituisci:
    • PROJECT_ID con il tuo ID progetto Google Cloud.
    • REPOSITORY con il nome del repository Artifact Registry.
    • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

    pubsub è il nome dell'immagine.

    Se l'operazione riesce, dovresti vedere il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

    Python 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
    Sostituisci:
    • PROJECT_ID con il tuo ID progetto Google Cloud.
    • REPOSITORY con il nome del repository Artifact Registry.
    • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

    pubsub è il nome dell'immagine.

    Se l'operazione riesce, dovresti vedere il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

    Vai 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
    Sostituisci:
    • PROJECT_ID con il tuo ID progetto Google Cloud.
    • REPOSITORY con il nome del repository Artifact Registry.
    • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

    pubsub è il nome dell'immagine.

    Se l'operazione riesce, dovresti visualizzare il messaggio SUCCESS contenente l'ID. data di creazione e nome immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

    Java

    • Utilizza l'helper delle credenziali dell'interfaccia a riga di comando gcloud per autorizzare Docker a eseguire il push in Artifact Registry. 
      gcloud auth configure-docker
    • Usa il plug-in Jib Maven per creare il container ed eseguirne il push ad Artifact Registry. 
      mvn compile jib:build -D image=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
      Sostituisci:
      • PROJECT_ID con il tuo ID progetto Google Cloud.
      • REPOSITORY con il nome del repository Artifact Registry.
      • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

      pubsub è il nome dell'immagine.

      Se l'operazione riesce, dovresti visualizzare il messaggio BUILD SUCCESS. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

    C# 

    gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
    Sostituisci:
    • PROJECT_ID con il tuo ID progetto Google Cloud.
    • REPOSITORY con il nome del repository Artifact Registry.
    • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

    pubsub è il nome dell'immagine.

    Se l'operazione riesce, dovresti vedere il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

  2. Esegui il deployment dell'applicazione:

    Riga di comando

    1. Esegui questo comando per eseguire il deployment della tua app:

      gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub  --no-allow-unauthenticated
      Sostituisci:
      • PROJECT_ID con il tuo ID progetto Google Cloud.
      • REPOSITORY con il nome del repository Artifact Registry.
      • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

      pubsub è il nome dell'immagine e pubsub-tutorial è il nome del servizio. Tieni presente che viene eseguito il deployment dell'immagine container nel servizio e nella regione che che hai configurato in precedenza in Impostazione di gcloud

      Il flag --no-allow-unauthenticated limita l'accesso non autenticato al completamente gestito di Google Cloud. Mantenendo privato il servizio puoi fare Cloud Run e l'integrazione automatica di Pub/Sub per autenticare le richieste. Consulta Eseguire l'integrazione con Pub/Sub per e ulteriori dettagli sulla configurazione. Per ulteriori dettagli sull'autenticazione basato su Identity and Access Management (IAM), consulta Gestione dell'accesso tramite IAM.

      Attendi il completamento del deployment: l'operazione può richiedere circa mezzo minuto. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio. Questo URL viene utilizzato per e configurare una sottoscrizione Pub/Sub.

    2. Se vuoi eseguire il deployment di un aggiornamento del codice nel servizio, ripeti la precedente passaggi. Ogni deployment in un servizio crea una nuova revisione e, e inizia a gestire il traffico quando è pronto.

    Terraform

    Per creare un servizio Cloud Run, aggiungi quanto segue al file .tf esistente.

    Sostituisci il valore di image con l'URL dell'immagine: 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]
}

Integrazione con Pub/Sub

Per integrare il servizio con Pub/Sub:

gcloud

  1. Crea o seleziona un account di servizio per rappresentare Pub/Sub e l'identità dell'abbonamento.

    gcloud iam service-accounts create cloud-run-pubsub-invoker \
    --display-name "Cloud Run Pub/Sub Invoker"

    Puoi utilizzare cloud-run-pubsub-invoker o sostituire con un nome univoco all'interno del tuo progetto Google Cloud.

  2. Crea un abbonamento Pub/Sub con l'account di servizio:

    1. Concedi all'account di servizio fetchr l'autorizzazione per richiamare il tuo servizio 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

      Potrebbero essere necessari diversi minuti prima che le modifiche IAM propagarsi. Nel frattempo, potresti visualizzare HTTP 403 errore nel log di servizio.

    2. Consenti a Pub/Sub di creare token di autenticazione nel tuo progetto:

      gcloud projects add-iam-policy-binding PROJECT_ID \
   --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
   --role=roles/iam.serviceAccountTokenCreator

      Sostituisci:

      • PROJECT_ID con il tuo ID progetto Google Cloud.
      • PROJECT_NUMBER con il numero del tuo progetto Google Cloud.

      L'ID e il numero del progetto sono elencati nel riquadro Informazioni sul progetto in alla console Google Cloud per il tuo progetto.

    3. Crea un abbonamento Pub/Sub con l'account di servizio:

      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

      Sostituisci:

      • myRunTopic con l'argomento che creati in precedenza.
      • SERVICE-URL con l'URL HTTPS fornito al momento del deployment dell'elemento completamente gestito di Google Cloud. Questo URL funziona anche se hai aggiunto una mappatura di dominio.
      • PROJECT_ID con il tuo ID progetto Google Cloud.

      Il flag --push-auth-service-account attiva il push di Pub/Sub per Autenticazione e autorizzazione.

      Il tuo dominio di servizio Cloud Run viene registrato automaticamente per l'utilizzo con le sottoscrizioni Pub/Sub.

      Solo per Cloud Run, è disponibile un controllo di autenticazione integrato che il token sia valido e un controllo dell'autorizzazione che il servizio l'account di servizio dispone dell'autorizzazione per richiamare il servizio Cloud Run.

Il tuo servizio è ora completamente integrato con Pub/Sub.

Terraform

  1. Crea o seleziona un account di servizio per rappresentare Pub/Sub e l'identità dell'abbonamento.

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

  2. Crea un abbonamento Pub/Sub con l'account di servizio:

    1. Concedi all'account di servizio fetchr l'autorizzazione per richiamare il tuo servizio 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}"]
}

    2. Consenti a Pub/Sub di creare token di autenticazione nel tuo progetto:

      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}"]
}

    3. Crea un abbonamento Pub/Sub con l'account di servizio:

      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]
}

Il tuo servizio è ora completamente integrato con Pub/Sub.

Fai una prova

Per testare la soluzione end-to-end:

  1. Invia un messaggio Pub/Sub all'argomento:

    gcloud pubsub topics publish myRunTopic --message "Runner"

    Puoi anche pubblicare i messaggi in modo programmatico anziché utilizzare il dalla riga di comando, come mostrato in questo tutorial. Per ulteriori informazioni, vedi Pubblicazione di messaggi.

  2. Accedi ai log del servizio:

    1. Vai alla console Google Cloud.
    2. Fai clic sul servizio pubsub-tutorial.

    3. Seleziona la scheda Log.

      La visualizzazione dei log potrebbe richiedere alcuni istanti. Se non li vedi ricontrolla dopo qualche istante.

  3. Cerca il messaggio "Hello Runner!". .

Esegui la pulizia

Per analizzare un caso d'uso più approfondito di utilizzo Cloud Run con Pub/Sub, per il momento ignora la pulizia e continua con il tutorial sull'elaborazione delle immagini con Cloud Run.

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi mantenerlo senza l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione creato per il tutorial.

Per eliminare il progetto:

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione delle risorse del tutorial in corso...

  1. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial:

    gcloud run services delete SERVICE-NAME

    Dove SERVICE-NAME è il nome del servizio che hai scelto.

    I servizi Cloud Run possono essere eliminati anche Console Google Cloud.

  2. Rimuovi la configurazione predefinita della regione gcloud che hai aggiunto durante il tutorial configurazione:

     gcloud config unset run/region

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

  4. Elimina altre risorse Google Cloud create in questo tutorial:

Passaggi successivi