Utilizzo di Pub/Sub con Cloud Run for Anthos

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

Obiettivi

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

Costi

In questo documento utilizzi 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 essere idonei per una prova gratuita.

Prima di iniziare

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

    Go to project selector

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

  3. Abilita l'API Cloud Run for Anthos
  4. Installa e inizializza l'interfaccia alla gcloud CLI.
  5. Installa il componente kubectl: 
    gcloud components install kubectl
  6. Aggiorna i componenti: 
    gcloud components update
  7. Se utilizzi Cloud Run for Anthos, crea un nuovo cluster seguendo le istruzioni della configurazione di Cloud Run for Anthos.

Configurazione dei valori predefiniti gcloud

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

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con il nome del progetto che utilizzi per questo tutorial.

  2. Configura gcloud per il tuo cluster:

    gcloud config set run/platform gke
gcloud config set run/cluster CLUSTER-NAME
gcloud config set run/cluster_location REGION

    Sostituisci:

    • CLUSTER-NAME con il nome utilizzato per il cluster,
    • REGION con la località del cluster supportata di tua scelta.

Creazione di un argomento Pub/Sub

Il servizio di esempio viene attivato dai messaggi pubblicati in un argomento Pub/Sub, quindi devi creare un argomento in Pub/Sub.

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

gcloud pubsub topics create myRunTopic

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

Recupero dell'esempio di codice

Per recuperare l'esempio di codice da utilizzare:

  1. Clona il repository dell'app di esempio nella 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.

  2. Passa alla directory che contiene il codice campione di Cloud Run for Anthos:

    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/

Guardando il codice

Il codice di questo tutorial è costituito dai seguenti elementi:

  • Un server che gestisce le richieste in entrata.

    Node.js

    Per mantenere il servizio Node.js facile da testare, la configurazione del server è separata dall'avvio del server.

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

    run/pubsub/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 è avviato in index.js:
    run/pubsub/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

    run/pubsub/main.py 
    import base64

from flask import Flask, request

app = Flask(__name__)

    Go

    run/pubsub/main.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

    run/pubsub/src/main/java/com/example/cloudrun/PubSubApplication.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);
  }
}

  • Un gestore che elabora il messaggio Pub/Sub e registra un annuncio.

    Node.js

    run/pubsub/app.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

    run/pubsub/main.py 
    @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

    run/pubsub/main.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

    run/pubsub/src/main/java/com/example/cloudrun/PubSubController.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);
  }
}

    Devi programmare 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 sul messaggio, come descritto nella sezione Ricevere messaggi tramite la guida push.

  • Un Dockerfile che definisce l'ambiente operativo per il servizio. I contenuti di Dockerfile variano in base alla lingua.

    Node.js

    run/pubsub/Dockerfile 
    
# Use the official lightweight Node.js image.
# https://hub.docker.com/_/node
FROM node:18-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 add a package-lock.json speed your build by switching to 'npm ci'.
# RUN npm ci --only=production
RUN npm install --production

# Copy local code to the container image.
COPY . .

# Run the web service on container startup.
CMD [ "npm", "start" ]

    Python

    run/pubsub/Dockerfile 
    
# 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

    run/pubsub/Dockerfile 
    
# 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.17-buster 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:buster-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 bisogno di un Dockerfile o senza installare Docker. Scopri di più sulla creazione di container Java con Jib.
    run/pubsub/pom.xml 
    <plugin>
  <groupId>com.google.cloud.tools</groupId>
  <artifactId>jib-maven-plugin</artifactId>
  <version>3.3.2</version>
  <configuration>
    <to>
      <image>gcr.io/PROJECT_ID/pubsub</image>
    </to>
  </configuration>
</plugin>

Per dettagli su come autenticare l'origine delle richieste Pub/Sub, leggi la sezione seguente su integrazione con Pub/Sub.

Spedizione del codice

Il codice di spedizione è composto da tre passaggi: la creazione di un'immagine container con Cloud Build, il caricamento dell'immagine container in Container Registry e il deployment dell'immagine container su Cloud Run for Anthos.

Per spedire il codice:

  1. Crea il container e pubblicalo su Container Registry:

    Node.js 

    gcloud builds submit --tag gcr.io/PROJECT_ID/pubsub

    Dove PROJECT_ID è l'ID progetto Google Cloud e pubsub è il nome che vuoi assegnare al servizio.

    In caso di esito positivo, dovresti vedere un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e, se necessario, può essere riutilizzata.

    Python 

    gcloud builds submit --tag gcr.io/PROJECT_ID/pubsub

    Dove PROJECT_ID è l'ID progetto Google Cloud e pubsub è il nome che vuoi assegnare al servizio.

    In caso di esito positivo, dovresti vedere un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e, se necessario, può essere riutilizzata.

    Go 

    gcloud builds submit --tag gcr.io/PROJECT_ID/pubsub

    Dove PROJECT_ID è l'ID progetto Google Cloud e pubsub è il nome che vuoi assegnare al servizio.

    In caso di esito positivo, dovresti vedere un messaggio di operazione riuscita contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Container Registry e, se necessario, può essere riutilizzata.

    Java 

    mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/pubsub

    Dove PROJECT_ID è l'ID progetto Google Cloud e pubsub è il nome che vuoi assegnare al servizio.

    In caso di esito positivo, dovresti visualizzare un messaggio BUILD SUCCESS (Stabilisci edificio). L'immagine è archiviata in Container Registry e, se lo desideri, può essere riutilizzata.

  2. Esegui questo comando per eseguire il deployment dell'app:

    gcloud run deploy pubsub-tutorial --image gcr.io/PROJECT_ID/pubsub

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud. pubsub è il nome del container e pubsub-tutorial è il nome del servizio. Tieni presente che viene eseguito il deployment dell'immagine container sul servizio e sul cluster configurati in precedenza in Configurazione di gcloud

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

  3. Se vuoi eseguire il deployment di un aggiornamento del codice al servizio, ripeti i passaggi precedenti. Ogni deployment in un servizio crea una nuova revisione e avvia automaticamente la gestione del traffico quando è pronto.

Integrazione con Pub/Sub

Ora che abbiamo eseguito il deployment del nostro servizio Cloud Run for Anthos, configureremo Pub/Sub in modo che esegua il push dei messaggi.

Per integrare il servizio con Pub/Sub:

  1. Abilita Pub/Sub per 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 tuo numero di progetto Google Cloud.

  2. 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 for Anthos Pub/Sub Invoker"

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

  3. Crea una sottoscrizione Pub/Sub con l'account di servizio:

    1. Abilita TLS e HTTPS automatici per il tuo cluster e aggiungi una mappatura di dominio al tuo servizio.

    2. Registra la proprietà del dominio per Pub/Sub.

    3. Aggiungi codice per convalidare il token di autenticazione associato ai messaggi Pub/Sub. Il codice campione è fornito in Autenticazione e autorizzazione da parte dell'endpoint push.

      L'autenticazione deve assicurare che il token sia valido e associato all'account di servizio previsto. A differenza di Cloud Run, Cloud Run for Anthos non ha un controllo dell'autorizzazione integrato che il token sia valido o che l'account di servizio abbia l'autorizzazione per richiamare il servizio Cloud Run for Anthos.

    4. Crea una sottoscrizione Pub/Sub con l'account di servizio:

      gcloud pubsub subscriptions create myRunSubscription --topic myRunTopic \
     --push-endpoint=SERVICE-URL/ \
     --push-auth-service-account=cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com

      Sostituisci

      • myRunTopic con l'argomento creato in precedenza.
      • SERVICE-URL con il tuo URL di servizio personalizzato. Specifica https come protocollo.
      • PROJECT_ID con il tuo ID progetto Google Cloud.

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

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

Prova in corso

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 la riga di comando come mostrato in questo tutorial. Per ulteriori informazioni, consulta la pagina Pubblicare messaggi.

  2. Accedi ai log del servizio:

    1. Vai alla pagina Cloud Run for Anthos nella console Google Cloud:

      Vai a Cloud Run for Anthos

    2. Fai clic sul servizio pubsub-tutorial.

    3. Seleziona la scheda Log.

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

  3. Cerca il messaggio "Hello Runner!".

Esegui la pulizia

Per analizzare un caso d'uso più approfondito utilizzando Cloud Run for Anthos con Pub/Sub, salta ora la pulizia e continua con il tutorial Elaborazione delle immagini.

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

Elimina il progetto

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

Per eliminare il progetto:

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

    Go to Manage resources

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

Eliminazione delle risorse del tutorial

  1. Elimina il servizio Cloud Run for Anthos 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.

    Puoi anche eliminare i servizi Cloud Run for Anthos dalla console Google Cloud:

    Vai a Cloud Run for Anthos

  2. Rimuovi le configurazioni gcloud predefinite che hai aggiunto durante la configurazione del tutorial:

     gcloud config unset run/platform
 gcloud config unset run/cluster
 gcloud config unset run/cluster_location

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

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

Passaggi successivi