Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Tutorial sull'utilizzo di Pub/Sub con Cloud Run

Questo tutorial mostra come scrivere, eseguire il deployment e chiamare un servizio Cloud Run da una sottoscrizione push 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 in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

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 senza costi per l'esecuzione, il test e il deployment dei workload.

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify 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.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Abilita le API Artifact Registry, Cloud Build, Pub/Sub e Cloud Run, se non sono già abilitate.
Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.
Abilita le API

Installa e inizializza gcloud CLI.
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 nel progetto:

Cloud Build Editor (roles/cloudbuild.builds.editor)
Cloud Run Admin (roles/run.admin)
Create Service Accounts (roles/iam.serviceAccountCreator)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Pub/Sub Editor (roles/pubsub.editor)
Utente Service Account (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
Storage Admin (roles/storage.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

Configura le impostazioni predefinite di gcloud

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

Imposta il progetto predefinito:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.
Configura gcloud per la regione scelta:
```
gcloud config set run/region REGION
```
Sostituisci REGION con la regione Cloud Run supportata che preferisci.

Località di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

La soddisfazione dei requisiti di latenza, disponibilità o durabilità è un fattore principale per la selezione della regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la posizione degli altri prodotti Google Cloud utilizzati dal tuo servizio Cloud Run. L'utilizzo di prodotti Google Cloud in sinergia in più località può influire sulla latenza del servizio e sui costi.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

asia-east1 (Taiwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
asia-south1 (Mumbai, India)
asia-southeast3 (Bangkok)
europe-north1 (Finlandia) Bassi livelli di CO₂
europe-north2 (Stoccolma) Bassi livelli di CO₂
europe-southwest1 (Madrid) Bassi livelli di CO₂
europe-west1 (Belgio) Bassi livelli di CO₂
europe-west4 (Paesi Bassi) Bassi livelli di CO₂
europe-west8 (Milano) Bassi livelli di CO₂
europe-west9 (Parigi) Bassi livelli di CO₂
me-west1 (Tel Aviv)
northamerica-south1 (Messico)
us-central1 (Iowa) Bassi livelli di CO₂
us-east1 (Carolina del Sud)
us-east4 (Virginia del Nord)
us-east5 (Columbus)
us-south1 (Dallas) Bassi livelli di CO₂
us-west1 (Oregon) Bassi livelli di CO₂

Soggetto ai prezzi di Livello 2

africa-south1 (Johannesburg)
asia-east2 (Hong Kong)
asia-northeast3 (Seul, Corea del Sud)
asia-southeast1 (Singapore)
asia-southeast2 (Giacarta)
asia-south2 (Delhi, India)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Varsavia, Polonia) Bassi livelli di CO₂
europe-west10 (Berlino)
europe-west12 (Torino) Bassi livelli di CO₂
europe-west2 (Londra, Regno Unito) Bassi livelli di CO₂
europe-west3 (Francoforte, Germania)
europe-west6 (Zurigo, Svizzera) A basse emissioni di CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Bassi livelli di CO₂
northamerica-northeast2 (Toronto) Bassi livelli di CO₂
southamerica-east1 (San Paolo, Brasile) Bassi livelli di CO₂
southamerica-west1 (Santiago, Cile) Bassi livelli di CO₂
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella consoleGoogle Cloud .

Crea un repository standard di Artifact Registry

Crea un repository standard di Artifact Registry per archiviare l'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 un argomento Pub/Sub, quindi dovrai creare un argomento 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 di argomento univoco all'interno del tuo progetto Cloud.

Recupera l'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

Clona il repository dell'app di esempio sulla tua macchina locale:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.
C#
```
git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
```
In alternativa puoi scaricare l'esempio come file ZIP ed estrarlo.

Passa alla directory che contiene il codice campione di 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/Run.Samples.Pubsub.MinimalApi/

Esamina il codice

Il codice per questo tutorial è costituito da quanto segue:

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

Go


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

import (
	"encoding/json"
	"io"
	"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)

Go


// WrappedMessage is the payload of a Pub/Sub event.
//
// For more information about receiving messages from a Pub/Sub event
// see: https://cloud.google.com/pubsub/docs/push#receive_push
type WrappedMessage 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 WrappedMessage
	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()
	if err != nil {
		log.Printf("io.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. I codici di operazione riuscita, come HTTP 200 o 204, confermano l'elaborazione completa del messaggio Pub/Sub. I codici di errore, come HTTP 400 o 500, indicano che verrà eseguito un nuovo tentativo di invio del messaggio, come descritto nella guida alla ricezione dei messaggi tramite push. A differenza delle funzioni create con l'API Cloud Functions v2, non puoi disabilitare i nuovi tentativi per le funzioni create con l'API Cloud Run Admin. Per saperne di più, consulta Configura i nuovi tentativi di esecuzione delle funzioni basate su eventi.

Un Dockerfile che definisce l'ambiente operativo del servizio. I contenuti della Dockerfile variano in base alla 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.14

# 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 official Go image to create a binary.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.25-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 immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei 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 informazioni dettagliate su come autenticare l'origine delle richieste Pub/Sub, consulta Integrazione con Pub/Sub.

Invia il codice

L'invio del codice prevede tre passaggi: la creazione di un'immagine container con Cloud Build, il caricamento dell'immagine container in Artifact Registry e il deployment dell'immagine container in Cloud Run.

Per spedire il codice:

Crea il container e pubblicalo su Artifact Registry:
Node.js
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Sostituisci:
- PROJECT_ID con l'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 va a buon fine, dovresti visualizzare un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Sostituisci:
- PROJECT_ID con l'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 va a buon fine, dovresti visualizzare un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.
Vai
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Sostituisci:
- PROJECT_ID con l'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 va a buon fine, dovresti visualizzare un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.
Java
- Utilizza l'helper per le credenziali di gcloud CLI per autorizzare Docker a eseguire il push ad Artifact Registry.
  gcloud auth configure-docker
- Utilizza 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 l'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 va a buon fine, dovresti visualizzare un 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 l'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 va a buon fine, dovresti visualizzare un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.
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 l'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 il deployment dell'immagine container viene eseguito nel servizio e nella regione che hai configurato in precedenza in Configurazione di gcloud
  
  Il flag --no-allow-unauthenticated limita l'accesso non autenticato al servizio. Se mantieni il servizio privato, puoi fare affidamento sull'integrazione automatica di Pub/Sub di Cloud Run per autenticare le richieste. Per maggiori dettagli su come viene configurata questa opzione, consulta Integrazione con Pub/Sub. Per maggiori dettagli sull'autenticazione basata su Identity and Access Management (IAM), consulta Gestione dell'accesso tramite IAM.
  
  Attendi il completamento del deployment: l'operazione può richiedere circa 30 secondi. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio. Questo URL viene utilizzato per configurare una sottoscrizione Pub/Sub.
2. Se vuoi eseguire il deployment di un aggiornamento del codice nel servizio, ripeti i passaggi precedenti. Ogni deployment in un servizio crea una nuova revisione e inizia automaticamente a gestire il traffico quando è pronto.
Terraform

Per creare un servizio Cloud Run, aggiungi quanto segue al file .tf esistente.
```
resource "google_project_service" "cloudrun_api" {
   service            = "run.googleapis.com"
   disable_on_destroy = false
}

resource "google_cloud_run_v2_service" "default" {
   name     = "pubsub-tutorial"
   location = "REGION"

   template {
      containers {
         image = "IMAGE_URL"
     }
   }
   depends_on = [google_project_service.cloudrun_api]
}
         
```
Sostituisci:
- IMAGE_URL con l'URL dell'immagine: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
- REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

Integrazione con Pub/Sub

Per integrare il servizio con Pub/Sub:

gcloud

Crea o seleziona un account di servizio per rappresentare l'identità della sottoscrizione Pub/Sub.
```
gcloud iam service-accounts create cloud-run-pubsub-invoker \
    --display-name "Cloud Run Pub/Sub Invoker"
```
Puoi utilizzare cloud-run-pubsub-invoker o sostituirlo con un nome univoco all'interno del tuo progetto Google Cloud .
Crea una sottoscrizione Pub/Sub con il account di servizio:
1. Concedi al account di servizio invoker 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
```
  La propagazione delle modifiche IAM può richiedere diversi minuti. Nel frattempo, potresti visualizzare errori HTTP 403 nei log del 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 l'ID progetto Google Cloud .
  - PROJECT_NUMBER con il numero di progetto Google Cloud .
  L'ID e il numero di progetto sono elencati nel riquadro Informazioni sul progetto nella consoleGoogle Cloud del progetto.
3. Crea una sottoscrizione Pub/Sub con il 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 hai creato in precedenza.
  - SERVICE-URL con l'URL HTTPS fornito durante il deployment del servizio. Questo URL funziona anche se hai aggiunto una mappatura del dominio.
  - PROJECT_ID con l'ID progetto Google Cloud .
  Il flag --push-auth-service-account attiva la funzionalità di push di Pub/Sub per Autenticazione e autorizzazione.
  
  Il dominio del servizio Cloud Run viene registrato automaticamente per l'utilizzo con le sottoscrizioni Pub/Sub.
  
  Solo per Cloud Run, esiste un controllo di autenticazione integrato per verificare che il token sia valido e un controllo di autorizzazione per verificare che il service account disponga dell'autorizzazione per richiamare il servizio Cloud Run.

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

Terraform

Crea o seleziona un account di servizio per rappresentare l'identità della sottoscrizione Pub/Sub.

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

Crea una sottoscrizione Pub/Sub con il account di servizio:

Concedi al account di servizio invoker 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}"]
}

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

Crea una sottoscrizione Pub/Sub con il 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:

Invia un messaggio Pub/Sub all'argomento:
```
gcloud pubsub topics publish myRunTopic --message "Runner"
```
Puoi anche pubblicare i messaggi in modo programmatico anziché utilizzare la riga di comando come mostrato in questo tutorial. Per saperne di più, consulta Pubblicazione dei messaggi.
Vai ai log del servizio:
1. Vai alla consoleGoogle Cloud
2. Fai clic sul servizio pubsub-tutorial.
3. Seleziona la scheda Log.
  
  La visualizzazione dei log potrebbe richiedere qualche istante. Se non li vedi subito, ricontrolla dopo qualche istante.
Cerca il messaggio "Hello Runner!".

Esegui la pulizia

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

Per evitare che al tuo account Google Cloud vengano addebitati costi aggiuntivi, elimina tutte le risorse di cui hai eseguito il deployment con questo tutorial.

Elimina il progetto

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

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

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud , vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Elimina le risorse del tutorial

Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial. I servizi Cloud Run non comportano costi finché non ricevono richieste.

Per eliminare il servizio Cloud Run, esegui questo comando:
```
gcloud run services delete SERVICE-NAME
```
Sostituisci SERVICE-NAME con il nome del servizio.

Puoi eliminare i servizi Cloud Run anche dalla consoleGoogle Cloud .
Rimuovi la configurazione della regione predefinita gcloud che hai aggiunto durante la configurazione del tutorial:
```
 gcloud config unset run/region
```
Rimuovi la configurazione del progetto:
```
 gcloud config unset project
```
Elimina le altre risorse Google Cloud create in questo tutorial:
- Elimina l'argomento Pub/Sub myRunTopic
- Elimina la sottoscrizione Pub/Sub myRunSubscription
- Elimina l'immagine container denominata REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub da Artifact Registry.
- Elimina il account di servizio invoker cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com

Passaggi successivi

Scopri come configurare i nuovi tentativi.
Consulta Limitazione del traffico in entrata per informazioni su come aumentare la sicurezza della produzione utilizzando i controlli in entrata interni per limitare il traffico in entrata.
Espandi il servizio di esempio di cui è stato eseguito il deployment in questo tutorial per aggiungere la funzionalità di elaborazione delle immagini che modifica le immagini caricate su Cloud Storage.
Scopri di più su come gli argomenti si inseriscono nell'architettura Pub/Sub e su come gestire gli argomenti.
Scopri di più sulle sottoscrizioni Pub/Sub in Gestione delle sottoscrizioni.
Esplora architetture, diagrammi e best practice di riferimento su Google Cloud. Consulta il nostro Cloud Architecture Center.

Tutorial sull'utilizzo di Pub/Sub con Cloud Run Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Ruoli obbligatori

Configura le impostazioni predefinite di gcloud

Località di Cloud Run

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Crea un repository standard di Artifact Registry

Crea un argomento Pub/Sub

gcloud

Terraform

Recupera l'esempio di codice

Node.js

Python

Go

Java

C#

Node.js

Python

Go

Java

C#

Esamina il codice

Node.js

Python

Go

Java

C#

Node.js

Python

Go

Java

C#

Node.js

Python

Go

Java

C#

Invia il codice

Node.js

Python

Vai

Java

C#

Riga di comando

Terraform

Integrazione con Pub/Sub

gcloud

Terraform

Fai una prova

Esegui la pulizia

Elimina il progetto

Elimina le risorse del tutorial

Passaggi successivi

Tutorial sull'utilizzo di Pub/Sub con Cloud Run