Use o tutorial do Pub/Sub com o Cloud Run

Este tutorial mostra como escrever, implementar e chamar um serviço do Cloud Run a partir de uma subscrição push do Pub/Sub.

Configure as predefinições do gcloud

Para configurar o gcloud com predefinições para o seu serviço do Cloud Run:

1. Defina o projeto predefinido:

   gcloud config set project PROJECT_ID

   Substitua PROJECT_ID pelo nome do projeto que criou para este tutorial.

2. Configure o gcloud para a região escolhida:

   gcloud config set run/region REGION

   Substitua REGION pela região do Cloud Run suportada à sua escolha.

Localizações do Cloud Run

O Cloud Run é regional, o que significa que a infraestrutura que executa os seus serviços do Cloud Run está localizada numa região específica e é gerida pela Google para estar disponível de forma redundante em todas as zonas dessa região.

O cumprimento dos seus requisitos de latência, disponibilidade ou durabilidade são fatores principais para selecionar a região onde os seus serviços do Cloud Run são executados. Geralmente, pode selecionar a região mais próxima dos seus utilizadores, mas deve considerar a localização dos outros Google Cloudprodutos usados pelo seu serviço do Cloud Run. A utilização Google Cloud de produtos em conjunto em várias localizações pode afetar a latência do seu serviço, bem como o custo.

O Cloud Run está disponível nas seguintes regiões:

Sujeito aos preços de Nível 1

• asia-east1 (Taiwan)
• asia-northeast1 (Tóquio)
• asia-northeast2 (Osaca)
• asia-south1 (Mumbai, Índia)
• europe-north1 (Finlândia) Baixo CO₂
• europe-north2 (Estocolmo) Baixo CO₂
• europe-southwest1 (Madrid) Baixo CO₂
• europe-west1 (Bélgica) Baixo CO₂
• europe-west4 (Países Baixos) Baixo CO₂
• europe-west8 (Milão)
• europe-west9 (Paris) Baixo CO₂
• me-west1 (Telavive)
• northamerica-south1 (México)
• us-central1 (Iowa) Baixo CO₂
• us-east1 (Carolina do Sul)
• us-east4 (Virgínia do Norte)
• us-east5 (Columbus)
• us-south1 (Dallas) Baixo CO₂
• us-west1 (Oregão) Baixo CO₂

Sujeito aos preços de Nível 2

• africa-south1 (Joanesburgo)
• asia-east2 (Hong Kong)
• asia-northeast3 (Seul, Coreia do Sul)
• asia-southeast1 (Singapura)
• asia-southeast2 (Jacarta)
• asia-south2 (Deli, Índia)
• australia-southeast1 (Sydney)
• australia-southeast2 (Melbourne)
• europe-central2 (Varsóvia, Polónia)
• europe-west10 (Berlim)
• europe-west12 (Turim)
• europe-west2 (Londres, Reino Unido) Baixo CO₂
• europe-west3 (Frankfurt, Alemanha)
• europe-west6 (Zurique, Suíça) Baixo CO₂
• me-central1 (Doha)
• me-central2 (Dammam)
• northamerica-northeast1 (Montreal) Baixo CO₂
• northamerica-northeast2 (Toronto) Baixo CO₂
• southamerica-east1 (São Paulo, Brasil) Baixo CO₂
• southamerica-west1 (Santiago, Chile) Baixo CO₂
• us-west2 (Los Angeles)
• us-west3 (Salt Lake City)
• us-west4 (Las Vegas)

Se já criou um serviço do Cloud Run, pode ver a região no painel de controlo do Cloud Run na Google Cloud consola.

OK

Crie um repositório padrão do Artifact Registry

Crie um repositório padrão do Artifact Registry para armazenar a sua imagem de contentor:

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

Substituição:

• REPOSITORY com um nome exclusivo para o repositório.
• REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

Crie um tópico do Pub/Sub

O serviço de exemplo é acionado por mensagens publicadas num tópico do Pub/Sub, pelo que tem de criar um tópico no Pub/Sub.

gcloud

Para criar um novo tópico do Pub/Sub, use o comando:

gcloud pubsub topics create myRunTopic

Pode usar myRunTopic ou substituir por um nome de tópico exclusivo no seu projeto. Google Cloud

Terraform

Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform.

Para criar um tópico do Pub/Sub, adicione o seguinte ao seu ficheiro main.tf existente:

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

Pode usar um nome de tópico único no seu projeto do Google Cloud.

Obtenha o exemplo de código

Para obter o exemplo de código para utilização:

1. Clone o repositório da app de exemplo para a sua máquina local:

   Node.js

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

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   Python

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

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   Ir

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

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   Java

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

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

   C#

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

   Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

2. Altere para o diretório que contém o código de exemplo do Cloud Run:

   Node.js

   cd nodejs-docs-samples/run/pubsub/

   Python

   cd python-docs-samples/run/pubsub/

   Ir

   cd golang-samples/run/pubsub/

   Java

   cd java-docs-samples/run/pubsub/

   C#

   cd dotnet-docs-samples/run/Run.Samples.Pubsub.MinimalApi/

Reveja o código

O código deste tutorial consiste no seguinte:

• Um servidor que processa pedidos recebidos.

  Node.js

  Para manter o serviço Node.js fácil de testar, a configuração do servidor está separada do arranque do servidor.

  O servidor Web Node.js está configurado em app.js.

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

  O servidor Web é iniciado em 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__)
  

  Ir

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

• Um controlador que processa a mensagem do Pub/Sub e regista uma saudação.

  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)
  
  

  Ir

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

  Tem de programar o serviço para devolver um código de resposta HTTP preciso. Os códigos de êxito, como HTTP 200 ou 204, confirmam o processamento completo da mensagem do Pub/Sub. Os códigos de erro, como HTTP 400 ou 500, indicam que a mensagem vai ser repetida, conforme descrito no guia de receção de mensagens através de push.

• Um Dockerfile que define o ambiente operacional do serviço. O conteúdo do Dockerfile varia consoante o idioma.

  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
  

  Ir

  
  # 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.24-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

  Este exemplo usa o Jib para criar imagens do Docker com ferramentas Java comuns. O Jib otimiza as compilações de contentores sem necessidade de um Dockerfile ou de ter o Docker instalado. Saiba mais sobre como criar contentores Java com o 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"]

Para ver detalhes sobre como autenticar a origem dos pedidos do Pub/Sub, consulte o artigo Integre com o Pub/Sub.

Envie o código

O código de envio consiste em três passos: criar uma imagem de contentor com o Cloud Build, carregar a imagem de contentor para o Artifact Registry e implementar a imagem de contentor no Cloud Run.

Para enviar o código:

1. Crie o contentor e publique-o no Artifact Registry:

   Node.js

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub

   Substituir:

   • PROJECT_ID com o ID do seu Google Cloud projeto.
   • REPOSITORY com o nome do repositório do Artifact Registry.
   • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após o êxito, deve ver uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.

   Python

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub

   Substituir:

   • PROJECT_ID com o ID do seu Google Cloud projeto.
   • REPOSITORY com o nome do repositório do Artifact Registry.
   • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após o êxito, deve ver uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.

   Ir

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub

   Substituir:

   • PROJECT_ID com o ID do seu Google Cloud projeto.
   • REPOSITORY com o nome do repositório do Artifact Registry.
   • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após o êxito, deve ver uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.

   Java

   • Use o auxiliar de credenciais da CLI gcloud para autorizar o Docker a enviar para o seu Artifact Registry.

     gcloud auth configure-docker

   • Use o plugin Jib Maven para criar e enviar o contentor para o Artifact Registry.

     mvn compile jib:build -D image=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub

     Substituir:
     • PROJECT_ID com o ID do seu Google Cloud projeto.
     • REPOSITORY com o nome do repositório do Artifact Registry.
     • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

     pubsub é o nome da imagem.

     Se for bem-sucedido, deve ver a mensagem BUILD SUCCESS. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.

   C#

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub

   Substituir:

   • PROJECT_ID com o ID do seu Google Cloud projeto.
   • REPOSITORY com o nome do repositório do Artifact Registry.
   • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após o êxito, deve ver uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.

2. Implemente a sua aplicação:

   Linha de comandos

   1. Execute o seguinte comando para implementar a sua app:

      gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub  --no-allow-unauthenticated

      Substituir:
      • PROJECT_ID com o ID do seu Google Cloud projeto.
      • REPOSITORY com o nome do repositório do Artifact Registry.
      • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

      pubsub é o nome da imagem e pubsub-tutorial é o nome do serviço. Repare que a imagem do contentor é implementada no serviço e na região que configurou anteriormente em Configurar o gcloud

      A flag --no-allow-unauthenticated restringe o acesso não autenticado ao serviço. Ao manter o serviço privado, pode confiar na integração automática do Pub/Sub do Cloud Run para autenticar pedidos. Consulte o artigo Integre com o Pub/Sub para ver mais detalhes sobre como esta opção é configurada. Para mais detalhes sobre a autenticação baseada na gestão de identidade e de acesso (IAM), consulte o artigo Gerir o acesso através da IAM.

      Aguarde até que a implementação esteja concluída. Este processo pode demorar cerca de meio minuto. Se for bem-sucedido, a linha de comandos apresenta o URL do serviço. Este URL é usado para configurar uma subscrição do Pub/Sub.

   2. Se quiser implementar uma atualização de código no serviço, repita os passos anteriores. Cada implementação num serviço cria uma nova revisão e começa automaticamente a publicar tráfego quando estiver pronta.

   Terraform

   Para criar um serviço do Cloud Run, adicione o seguinte ao seu ficheiro .tf existente.

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

   Substituir:

   • IMAGE_URL com o URL da imagem: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
   • REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

Faça a integração com o Pub/Sub

Importante: se o seu projeto foi criado a 8 de abril de 2021 ou antes, tem de conceder a função iam.serviceAccountTokenCreator ao agente de serviço service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com no projeto para permitir que o Pub/Sub crie tokens. No entanto, se o seu projeto tiver sido criado após essa data, não precisa de lhe conceder esta função, porque tem a função roles/pubsub.serviceAgent com autorizações idênticas.

Para integrar o serviço com o Pub/Sub:

gcloud

1. Crie ou selecione uma conta de serviço para representar a identidade da subscrição do Pub/Sub.

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

   Pode usar cloud-run-pubsub-invoker ou substituir por um nome exclusivo no seu projeto. Google Cloud

2. Crie uma subscrição do Pub/Sub com a conta de serviço:

   1. Conceda à conta de serviço do invocador autorização para invocar o seu serviço 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

      As alterações à IAM podem demorar vários minutos a propagar-se. Entretanto, pode ver HTTP 403 erros nos registos de serviço.

   2. Permita que o Pub/Sub crie tokens de autenticação no seu projeto:

      gcloud projects add-iam-policy-binding PROJECT_ID \
         --member=serviceAccount:[e-mail] \
         --role=roles/iam.serviceAccountTokenCreator

      Substituição:

      • PROJECT_ID com o ID do seu Google Cloud projeto.
      • PROJECT_NUMBER com o seu Google Cloud número do projeto.

      O ID do projeto e o número do projeto estão listados no painel Informações do projeto na Google Cloud consola do seu projeto.

   3. Crie uma subscrição do Pub/Sub com a conta de serviço:

      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

      Substituição:

      • myRunTopic com o tópico que criou anteriormente.
      • SERVICE-URL com o URL HTTPS fornecido na implementação do serviço. Este URL funciona mesmo que também tenha adicionado um mapeamento de domínio.
      • PROJECT_ID com o ID do seu Google Cloud projeto.

      O sinalizador --push-auth-service-account ativa a funcionalidade de envio do Pub/Sub para autenticação e autorização.

      O domínio do serviço do Cloud Run é registado automaticamente para utilização com subscrições do Pub/Sub.

      Apenas para o Cloud Run, existe uma verificação de autenticação incorporada que confirma se o token é válido e uma verificação de autorização que confirma se a conta de serviço tem autorização para invocar o serviço do Cloud Run.

O seu serviço está agora totalmente integrado com o Pub/Sub.

Terraform

1. Crie ou selecione uma conta de serviço para representar a identidade da subscrição do Pub/Sub.

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

2. Crie uma subscrição do Pub/Sub com a conta de serviço:

   1. Conceda à conta de serviço do invocador autorização para invocar o seu serviço 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. Permita que o Pub/Sub crie tokens de autenticação no seu projeto:

      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. Crie uma subscrição do Pub/Sub com a conta de serviço:

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

O seu serviço está agora totalmente integrado com o Pub/Sub.

Experimentar

Para testar a solução completa:

1. Envie uma mensagem Pub/Sub para o tópico:

   gcloud pubsub topics publish myRunTopic --message "Runner"

   Também pode publicar mensagens de forma programática em vez de usar a linha de comandos, como mostrado neste tutorial. Para mais informações, consulte o artigo Publicar mensagens.

2. Navegue para os registos de serviço:

   1. Navegue para a Google Cloud consola
   2. Clique no serviço pubsub-tutorial.

   3. Selecione o separador Registos.

      Os registos podem demorar alguns momentos a aparecer. Se não os vir imediatamente, verifique novamente após alguns momentos.

3. Procure a mensagem "Olá, corredor!".

Êxito: implementou um serviço do Cloud Run que responde automaticamente a mensagens do Pub/Sub.