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.

Objetivos

• Escreva, crie e implemente um serviço no Cloud Run
• Chame o serviço publicando uma mensagem num tópico do Pub/Sub.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

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

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

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.

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

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.

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

Verify that billing is enabled for your Google Cloud project.

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

   Enable the APIs

2. Instale e inicialize a CLI gcloud.
3. Atualize os componentes:

   gcloud components update

Funções necessárias

Para receber as autorizações de que precisa para concluir o tutorial, peça ao seu administrador para lhe conceder as seguintes funções da 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)
• Project IAM Admin (roles/resourcemanager.projectIamAdmin)
• Editor do Pub/Sub (roles/pubsub.editor)
• Utilizador da conta de serviço (roles/iam.serviceAccountUser)
• Consumidor de utilização do serviço (roles/serviceusage.serviceUsageConsumer)
• Administrador de armazenamento (roles/storage.admin)

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Nota: as funções básicas da IAM também podem conter autorizações para concluir o tutorial. Não deve conceder funções básicas num ambiente de produção, mas pode concedê-las num ambiente de desenvolvimento ou de teste.

Configure as predefinições do gcloud

Para configurar o gcloud com as predefinições do 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 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) Baixo CO₂
• 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 imagem de contentor:

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

Substituir:

• 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.23-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 precisar de um Dockerfile nem 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 seu Google Cloud ID do 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 seu Google Cloud ID do 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 seu Google Cloud ID do 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 seu Google Cloud ID do 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 tiver êxito, 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 seu Google Cloud ID do 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 seu Google Cloud ID do 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ços.

   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

      Substituir:

      • PROJECT_ID com o seu Google Cloud ID do 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

      Substituir:

      • 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 seu Google Cloud ID do 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 o token é válido e uma verificação de autorização que 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.

Limpar

Para ver um exemplo de utilização mais detalhado do Cloud Run com o Pub/Sub, ignore a limpeza por agora e continue com o tutorial de processamento de imagens com o Cloud Run.

Se criou um novo projeto para este tutorial, elimine o projeto. Se usou um projeto existente e quer mantê-lo sem as alterações adicionadas neste tutorial, elimine os recursos criados para o tutorial.

Eliminar o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o projeto:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

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.

Eliminar recursos do tutorial

1. Elimine o serviço do Cloud Run que implementou neste tutorial:

   gcloud run services delete SERVICE-NAME

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

   Também pode eliminar serviços do Cloud Run a partir da Google Cloud consola.

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

    gcloud config unset run/region
   

3. Remova a configuração do projeto:

    gcloud config unset project
   

4. Elimine outros Google Cloud recursos criados neste tutorial:

   • Elimine o tópico do Pub/Sub myRunTopic
   • Elimine a subscrição do Pub/Sub myRunSubscription
   • Elimine a imagem de contentor denominada REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub do Artifact Registry.
   • Elimine a conta de serviço do invocador cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com

O que se segue?

• Consulte o artigo Restringir a entrada para ver informações sobre como aumentar a segurança da produção através da utilização de controlos de entrada internos para limitar a entrada.
• Expanda o serviço de exemplo implementado neste tutorial para adicionar funcionalidade de processamento de imagens que modifica as imagens carregadas para o Cloud Storage.
• Saiba como os tópicos se enquadram na arquitetura Pub/Sub e como gerir tópicos
• Saiba mais sobre as subscrições do Pub/Sub na secção Gerir subscrições.
• Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.