Tutorial Usar o Pub/Sub com o Cloud Run

---

Este tutorial mostra como gravar, implantar e chamar um serviço do Cloud Run a partir de uma assinatura de push do Pub/Sub.

Objetivos

• Escrever, criar e implantar um serviço no Cloud Run
• Chame o serviço publicando uma mensagem em um tópico do Pub/Sub.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• Artifact Registry
• Cloud Build
• Pub/Sub
• Cloud Run

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Enable the APIs

7. Instale e inicialize a CLI gcloud.
8. Atualize os componentes:

   gcloud components update

Funções exigidas

Para conseguir as permissões necessárias para concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:

• Editor do Cloud Build (roles/cloudbuild.builds.editor)
• Administrador do Cloud Run (roles/run.admin)
• Criar contas de serviço (roles/iam.serviceAccountCreator)
• Administrador de projetos do IAM (roles/resourcemanager.projectIamAdmin)
• Editor do Pub/Sub (roles/pubsub.editor)
• Usuário da conta de serviço (roles/iam.serviceAccountUser)
• Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)
• Administrador de armazenamento (roles/storage.admin)

Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Observação: os papéis básicos do IAM também podem conter permissões para concluir o tutorial. Não conceda papéis básicos em um ambiente de produção, mas é possível fazer isso em um ambiente de desenvolvimento ou teste.

Configurar os padrões da gcloud

Para configurar a gcloud com os padrões do serviço do Cloud Run, realize as etapas a seguir:

1. Defina seu projeto padrão:

   gcloud config set project PROJECT_ID

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

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

   gcloud config set run/region REGION

   Substitua REGION pela região compatível do Cloud Run.

Locais do Cloud Run

O Cloud Run é regional, o que significa que a infraestrutura que executa seus serviços do Cloud Run está localizada em uma região específica e é gerenciada pelo Google para estar disponível de maneira redundante em todas as zonas da região.

Atender aos seus requisitos de latência, disponibilidade ou durabilidade são os principais fatores para selecionar a região em que seus serviços do Cloud Run são executados. Geralmente, é possível selecionar a região mais próxima de seus usuários, mas considere a localização dos outros produtos do Google Cloud usados pelo serviço do Cloud Run. O uso de produtos do Google Cloud em vários locais pode afetar a latência e o custo do serviço.

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

Sujeitas aos preços do nível 1

• asia-east1 (Taiwan)
• asia-northeast1 (Tóquio)
• asia-northeast2 (Osaka)
• europe-north1 (Finlândia) Baixo CO₂
• europe-southwest1 (Madri) 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 (Tel Aviv)
• us-central1 (Iowa) Baixo CO₂
• us-east1 (Carolina do Sul)
• us-east4 (Norte da Virgínia)
• us-east5 (Columbus)
• us-south1 (Dallas) Baixo CO₂
• us-west1 (Oregon) Baixo CO₂

Sujeitas aos preços do nível 2

• africa-south1 (Johannesburgo)
• asia-east2 (Hong Kong)
• asia-northeast3 (Seul, Coreia do Sul)
• asia-southeast1 (Singapura)
• asia-southeast2 (Jacarta)
• asia-south1 (Mumbai, Índia)
• asia-south2 (Déli, Índia)
• australia-southeast1 (Sydney)
• australia-southeast2 (Melbourne)
• europe-central2 (Varsóvia, Polônia)
• europe-west10 (Berlim) Baixo CO₂
• europe-west12 (Turim)
• europe-west2 (Londres, Reino Unido) Baixo CO₂
• europe-west3 (Frankfurt, Alemanha) Baixo CO₂
• europe-west6 (Zurique, Suíça) Baixo CO₂
• me-central1 (Doha)
• me-central2 (Damã)
• 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 você já criou um serviço do Cloud Run, é possível visualizar a região no painel do Cloud Run no console do Google Cloud.

OK

Criar um repositório padrão do Artifact Registry

Crie um repositório padrão do Artifact Registry para armazenar a imagem do contêiner:

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

Substitua:

• REPOSITORY por um nome exclusivo para o repositório.
• REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

Criar um tópico do Pub/Sub.

O serviço de amostra é acionado por mensagens publicadas em um tópico do Pub/Sub. Portanto, é necessário 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

É possível usar myRunTopic ou substituir por um nome de tópico exclusivo no seu projeto do Google Cloud.

Terraform

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

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

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

É possível usar um nome de tópico exclusivo no seu projeto do Cloud.

Recuperar a amostra de código

Para recuperar o exemplo de código para uso, siga estas etapas:

1. Clone o repositório do aplicativo de amostra na máquina local:

   Node.js

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

   Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

   Python

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

   Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

   Go

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

   Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

   Java

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

   Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

   C#

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

   Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

2. Mude para o diretório que contém o código de amostra do 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/

Revisar o código

O código deste tutorial consiste nisto:

• Um servidor que processa solicitações recebidas.

  Node.js

  Para que a facilidade no teste do serviço do Node.js seja mantida, a configuração do servidor é separada da inicialização dele.

  O servidor da 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 da 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__)
  

  Go

  
  // Sample run-pubsub is a Cloud Run service which handles Pub/Sub messages.
  package main
  
  import (
  	"encoding/json"
  	"io/ioutil"
  	"log"
  	"net/http"
  	"os"
  )
  
  func main() {
  	http.HandleFunc("/", HelloPubSub)
  	// Determine port for HTTP service.
  	port := os.Getenv("PORT")
  	if port == "" {
  		port = "8080"
  		log.Printf("Defaulting to port %s", port)
  	}
  	// Start HTTP server.
  	log.Printf("Listening on port %s", port)
  	if err := http.ListenAndServe(":"+port, nil); err != nil {
  		log.Fatal(err)
  	}
  }
  

  Java

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  
  @SpringBootApplication
  public class PubSubApplication {
    public static void main(String[] args) {
      SpringApplication.run(PubSubApplication.class, args);
    }
  }

  C#

  var builder = WebApplication.CreateBuilder(args);
  var app = builder.Build();
  
  var port = Environment.GetEnvironmentVariable(POR"T);
  "if (port != null)
  {
      app.Urls.Add($http:/"/0.0.0.0:{port});
  }"

• Um gerenciador que processa a mensagem do Pub/Sub e registra 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)
  

  Go

  
  // PubSubMessage is the payload of a Pub/Sub event.
  // See the documentation for more details:
  // https://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage
  type PubSubMessage struct {
  	Message struct {
  		Data []byte `json:"data,omitempty"`
  		ID   string `json:"id"`
  	} `json:"message"`
  	Subscription string `json:"subscription"`
  }
  
  // HelloPubSub receives and processes a Pub/Sub push message.
  func HelloPubSub(w http.ResponseWriter, r *http.Request) {
  	var m PubSubMessage
  	body, err := ioutil.ReadAll(r.Body)
  	if err != nil {
  		log.Printf("ioutil.ReadAll: %v", err)
  		http.Error(w, "Bad Request", http.StatusBadRequest)
  		return
  	}
  	// byte slice unmarshalling handles base64 decoding.
  	if err := json.Unmarshal(body, &m); err != nil {
  		log.Printf("json.Unmarshal: %v", err)
  		http.Error(w, "Bad Request", http.StatusBadRequest)
  		return
  	}
  
  	name := string(m.Message.Data)
  	if name == "" {
  		name = "World"
  	}
  	log.Printf("Hello %s!", name)
  }
  

  Java

  import com.example.cloudrun.Body;
  import java.util.Base64;
  import org.apache.commons.lang3.StringUtils;
  import org.springframework.http.HttpStatus;
  import org.springframework.http.ResponseEntity;
  import org.springframework.web.bind.annotation.RequestBody;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestMethod;
  import org.springframework.web.bind.annotation.RestController;
  
  // PubsubController consumes a Pub/Sub message.
  @RestController
  public class PubSubController {
    @RequestMapping(value = "/", method = RequestMethod.POST)
    public ResponseEntity<String> receiveMessage(@RequestBody Body body) {
      // Get PubSub message from request body.
      Body.Message message = body.getMessage();
      if (message == null) {
        String msg = "Bad Request: invalid Pub/Sub message format";
        System.out.println(msg);
        return new ResponseEntity<>(msg, HttpStatus.BAD_REQUEST);
      }
  
      String data = message.getData();
      String target =
          !StringUtils.isEmpty(data) ? new String(Base64.getDecoder().decode(data)) : "World";
      String msg = "Hello " + target + "!";
  
      System.out.println(msg);
      return new ResponseEntity<>(msg, HttpStatus.OK);
    }
  }

  C#

  app.MapPost("/", (Envelope envelope) =>
  {
      if (envelope?.Message?.Data == null)
      {
          app.Logger.LogWarning(Bad "Request: Invalid Pub/Sub message format.);
   "       return Results.BadRequest();
      }
  
      var data = Convert.FromBase64String(envelope.Message.Data);
      var target = System.Text.Encoding.UTF8.GetString(data);
  
      app.Logger.LogInformation($Hello {targ"et}!);
  
      ret"urn Results.NoContent();
  });

  É necessário codificar o serviço para retornar um código de resposta HTTP preciso. Códigos de êxito, como HTTP 200 ou 204, confirmam o processamento completo da mensagem do Pub/Sub. Códigos de erro, como HTTP 400 ou 500, indicam que a mensagem será repetida, conforme descrito no guia Como receber mensagens usando push.

• Um Dockerfile que define o ambiente operacional do serviço. O conteúdo do Dockerfile varia de acordo com 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
  

  Go

  
  # Use the offical golang image to create a binary.
  # This is based on Debian and sets the GOPATH to /go.
  # https://hub.docker.com/_/golang
  FROM golang:1.21-bookworm as builder
  
  # Create and change to the app directory.
  WORKDIR /app
  
  # Retrieve application dependencies.
  # This allows the container build to reuse cached dependencies.
  # Expecting to copy go.mod and if present go.sum.
  COPY go.* ./
  RUN go mod download
  
  # Copy local code to the container image.
  COPY . ./
  
  # Build the binary.
  RUN go build -v -o server
  
  # Use the official Debian slim image for a lean production container.
  # https://hub.docker.com/_/debian
  # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
  FROM debian:bookworm-slim
  RUN set -x && apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
      ca-certificates && \
      rm -rf /var/lib/apt/lists/*
  
  # Copy the binary to the production image from the builder stage.
  COPY --from=builder /app/server /server
  
  # Run the web service on container startup.
  CMD ["/server"]
  

  Java

  Esta amostra usa o Jib (em inglês) para criar imagens do Docker usando ferramentas comuns do Java. O Jib otimiza builds de contêiner sem a necessidade de um Dockerfile ou de ter o Docker (em inglês) instalado. Saiba mais sobre como criar contêineres Java com o Jib.

  <plugin>
    g<roupIdc>om.google.cloud.tools/<groupId
  >  ar<tifactIdji>b-maven-plugin/a<rtifactId
   > ver<sion3.4>.0/ve<rsion
    >conf<iguration
     > to
    <  >  imageg<cr.io>/PROJECT_ID/pubsub/image<
      />to
    /<con>figu<ration
  /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 saber detalhes sobre como autenticar a origem das solicitações do Pub/Sub, consulte Integrar com o Pub/Sub.

Enviar o código

O código de envio consiste em três etapas: criar uma imagem de contêiner com o Cloud Build, fazer upload da imagem de contêiner no Container Artifact e implantar a imagem de contêiner no Cloud Run.

Para enviar o código, siga estas etapas:

1. Compile seu contêiner e publique no Artifact Registry:

   Node.js

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

   Substituir:

   • PROJECT_ID pelo ID de projeto do Google Cloud;
   • REPOSITORY pelo nome do repositório do Artifact Registry.
   • REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após a conclusão, você verá uma mensagem de "SUCESSO" contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.

   Python

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

   Substituir:

   • PROJECT_ID pelo ID de projeto do Google Cloud;
   • REPOSITORY pelo nome do repositório do Artifact Registry.
   • REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após a conclusão, você verá uma mensagem de "SUCESSO" contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.

   Go

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

   Substituir:

   • PROJECT_ID pelo ID de projeto do Google Cloud;
   • REPOSITORY pelo nome do repositório do Artifact Registry.
   • REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após a conclusão, você verá uma mensagem de "SUCESSO" contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.

   Java

   • Use o auxiliar de credencial do gcloud CLI para autorizar o Docker a enviar por push ao Artifact Registry.

     gcloud auth configure-docker

   • Use o plug-in do Maven do Jib para criar e enviar por push o contêiner ao Artifact Registry.

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

     Substituir:
     • PROJECT_ID pelo ID de projeto do Google Cloud;
     • REPOSITORY pelo nome do repositório do Artifact Registry.
     • REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

     pubsub é o nome da imagem.

     Após a conclusão, você verá uma mensagem "BUILD SUCCESS". A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.

   C#

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

   Substituir:

   • PROJECT_ID pelo ID de projeto do Google Cloud;
   • REPOSITORY pelo nome do repositório do Artifact Registry.
   • REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

   pubsub é o nome da imagem.

   Após a conclusão, você verá uma mensagem de "SUCESSO" contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.

2. Implante sua aplicação:

   Linha de comando

   1. Execute o comando a seguir para implantar o app:

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

      Substituir:
      • PROJECT_ID pelo ID de projeto do Google Cloud;
      • REPOSITORY pelo nome do repositório do Artifact Registry.
      • REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

      pubsub é o nome da imagem e pubsub-tutorial é o nome do serviço. A imagem do contêiner é implantada no serviço e na região que você configurou anteriormente em Como configurar o gcloud

      A sinalização --no-allow-unauthenticated restringe o acesso não autenticado ao serviço. Mantendo o serviço particular, é possível contar com a integração automática do Pub/Sub no Cloud Run para autenticar as solicitações. Consulte Integrar com Pub/Sub para mais detalhes sobre como isso é configurado. Para mais detalhes sobre autenticação baseada em Identity and Access Management (IAM), consulte Como gerenciar o acesso usando o IAM.

      Aguarde até que a implantação esteja concluída. Isso pode levar cerca de 30 segundos. Em caso de sucesso, a linha de comando exibe o URL de serviço. Esse URL é usado para configurar uma assinatura do Pub/Sub.

   2. Se você quer implantar uma atualização de código no serviço, repita as etapas anteriores. Cada implantação em um serviço cria uma nova revisão e inicia automaticamente o tráfego de serviço quando estiver pronto.

   Terraform

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

   Substitua o valor de image pelo URL da imagem: 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]
   }

Integrar com o Pub/Sub

Importante: se o projeto foi criado em 8 de abril de 2021 ou antes disso, você precisa conceder o papel iam.serviceAccountTokenCreator para a conta 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 projeto tiver sido criado após essa data, não será necessário conceder esse papel porque ele tem o papel roles/pubsub.serviceAgent com permissõ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 assinatura de Pub/Sub.

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

   É possível usar cloud-run-pubsub-invoker ou substituir por um nome exclusivo no seu projeto do Google Cloud.

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

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

      Pode levar vários minutos para que as alterações do IAM sejam propagadas. Enquanto isso, talvez você veja erros HTTP 403 nos registros 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

      Substitua:

      • PROJECT_ID pelo ID de projeto do Google Cloud;
      • PROJECT_NUMBER pelo número do projeto do Google Cloud.

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

   3. Crie uma assinatura 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

      Substitua:

      • myRunTopic pelo tópico que você criou anteriormente.
      • SERVICE-URL pelo URL de HTTPS fornecido na implantação do serviço. Esse URL funciona mesmo se você também tiver adicionado um mapeamento de domínio.
      • PROJECT_ID pelo ID de projeto do Google Cloud;

      A sinalização --push-auth-service-account ativa a funcionalidade de push do Pub/Sub para Autenticação e autorização.

      Seu domínio do serviço Cloud Run é registrado automaticamente para uso com assinaturas do Pub/Sub.

      Somente para o Cloud Run, há uma verificação de autenticação integrada que verifica se o token é válido e uma autorização para verificar se a conta de serviço tem permissão para invocar o serviço do Cloud Run.

Seu serviço agora está totalmente integrado ao Pub/Sub.

Terraform

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

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

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

   1. Conceda permissão à conta de serviço do invocador para invocar 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 assinatura 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]
      }

Seu serviço agora está totalmente integrado ao Pub/Sub.

Faça um teste

Para testar a solução de ponta a ponta, siga estas etapas:

1. Para enviar uma mensagem do Pub/Sub para o tópico:

   gcloud pubsub topics publish myRunTopic --message "Runner"

   Também é possível publicar mensagens programaticamente em vez de usar a linha de comando, conforme mostrado neste tutorial. Para mais informações, consulte Como publicar mensagens.

2. Navegue até os registros de serviço:

   1. Navegue até o Console do Google Cloud.
   2. Clique no serviço pubsub-tutorial.

   3. Selecione a guia Registros.

      Os registros podem demorar alguns instantes para aparecer. Se você não os vir imediatamente, verifique novamente após alguns instantes.

3. Procure a mensagem "Hello Runner!".

Limpar

Para ver mais detalhes sobre o caso de uso do Cloud Run com o Pub/Sub, pule a limpeza por enquanto e continue com o tutorial de processamento de imagens com o Cloud Run.

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Como excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

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.

Como excluir recursos do tutorial

1. Exclua o serviço do Cloud Run que você implantou neste tutorial:

   gcloud run services delete SERVICE-NAME

   SERVICE-NAME é o nome escolhido do serviço.

   Também é possível excluir os serviços do Cloud Run no Console do Google Cloud.

2. Remova a configuração da região padrão da gcloud que você adicionou durante a configuração do tutorial:

    gcloud config unset run/region
   

3. Remova a configuração do projeto:

    gcloud config unset project
   

4. Exclua outros recursos do Google Cloud criados neste tutorial:

   • Exclua o tópico Pub/Sub myRunTopic
   • Exclua a assinatura do Pub/Sub myRunSubscription.
   • Exclua a imagem do contêiner chamada REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub do Artifact Registry.
   • Exclua a conta de serviço do invocador cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com.

A seguir

• Consulte Como restringir a entrada para ver informações sobre como aumentar a segurança de produção usando controles de entrada internos para limitar a entrada.
• Expanda o serviço de amostra implantado neste tutorial para adicionar a funcionalidade de processamento de imagens que modifica as imagens enviadas ao Cloud Storage.
• Saiba mais sobre como os tópicos se encaixam na arquitetura do Pub/Sub e como gerenciar tópicos
• Saiba mais sobre assinaturas do Pub/Sub em Como gerenciar assinaturas.
• Confira arquiteturas de referência, diagramas e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.