Instructivo de uso de Pub/Sub con Cloud Run

En este instructivo, se muestra cómo escribir un servicio de Cloud Run desde una suscripción de envío a Pub/Sub, cómo implementarlo y cómo llamarlo.

Objetivos

Escribir, compilar y, también, implementar un servicio en Cloud Run
Llamar al servicio mediante la publicación de un mensaje en un tema de Pub/Sub

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las API de Artifact Registry, Cloud Build, Pub/Sub y Cloud Run.
Habilita las API

Instala e inicializa gcloud CLI
Actualiza los componentes, como se indica a continuación:
```
gcloud components update
```

Roles obligatorios

Si quieres obtener los permisos que necesitas para completar el instructivo, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Editor de Cloud Build (roles/cloudbuild.builds.editor)
Administrador de Cloud Run (roles/run.admin)
Crea cuentas de servicio (roles/iam.serviceAccountCreator)
Administrador de IAM de proyecto (roles/resourcemanager.projectIamAdmin)
Editor de Pub/Sub (roles/pubsub.editor)
Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrador de almacenamiento (roles/storage.admin)

Si quieres obtener más información para otorgar roles, consulta Administra el acceso.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Configura los valores predeterminados de gcloud

A fin de configurar gcloud con los valores predeterminados para el servicio de Cloud Run, sigue estos pasos:

Configura el proyecto predeterminado:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el nombre del proyecto que creaste para este instructivo.
Configura gcloud en la región que elegiste:
```
gcloud config set run/region REGION
```
Reemplaza REGION por la región de Cloud Run compatible que prefieras.

Ubicaciones de Cloud Run

Cloud Run es regional, lo que significa que la infraestructura que ejecuta los servicios se ubica en una región específica, y Google la administra para que esté disponible de manera redundante en todas las zonas de esa región.

El cumplimiento de los requisitos de latencia, disponibilidad o durabilidad es el factor principal para seleccionar la región en la que se ejecutan los servicios de Cloud Run. Por lo general, puedes seleccionar la región más cercana a los usuarios, pero debes considerar la ubicación de los otros productos de Google Cloud que usa el servicio de Cloud Run. Si usas productos de Google Cloud en varias ubicaciones, la latencia y el costo del servicio pueden verse afectados.

Cloud Run está disponible en las siguientes regiones:

Sujetas a los Precios del nivel 1

asia-east1 (Taiwán)
asia-northeast1 (Tokio)
asia-northeast2 (Osaka)
europe-north1 (Finlandia) Bajo nivel de CO₂
europe-southwest1 (Madrid)
europe-west1 (Bélgica) Bajo nivel de CO₂
europe-west4 (Países Bajos)
europe-west8 (Milán)
europe-west9 (París) Bajo nivel de CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) Bajo nivel de CO₂
us-east1 (Carolina del Sur)
us-east4 (Virginia del Norte)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregón) Bajo nivel de CO₂

Sujetas a los Precios del nivel 2

africa-south1 (Johannesburgo)
asia-east2 (Hong Kong)
asia-northeast3 (Seúl, Corea del Sur)
asia-southeast1 (Singapur)
asia-southeast2 (Yakarta)
asia-south1 (Bombay, India)
asia-south2 Delhi (India)
australia-southeast1 (Sídney)
australia-southeast2 (Melbourne)
europe-central2 (Varsovia, Polonia)
europe-west10 (Berlín)
europe-west12 (Turín)
europe-west2 (Londres, Reino Unido) Bajo nivel de CO₂
europe-west3 (Fráncfort, Alemania) Bajo nivel de CO₂
europe-west6 (Zúrich, Suiza) Bajo nivel de CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Bajo nivel de CO₂
northamerica-northeast2 (Toronto) Bajo nivel de CO₂
southamerica-east1 (São Paulo, Brasil) Bajo nivel de CO₂
southamerica-west1 (Santiago, Chile) Bajo nivel de CO₂
us-west2 (Los Ángeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Si ya creaste un servicio de Cloud Run, puedes ver la región en el panel de Cloud Run en la consola de Google Cloud.

Crea un repositorio estándar de Artifact Registry

Crea un repositorio estándar de Artifact Registry para almacenar tu imagen de contenedor:

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

Reemplaza lo siguiente:

REPOSITORY por un nombre único para el repositorio.
REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.

Crear un tema de Pub/Sub

El servicio de muestra se activa mediante mensajes publicados en un tema de Pub/Sub, por lo que deberás crear un tema en Pub/Sub.

Línea de comandos

Para crear un tema nuevo de Pub/Sub, usa el siguiente comando:

gcloud pubsub topics create myRunTopic

Puedes usar myRunTopic o reemplazarlo por un nombre de tema único dentro de tu proyecto de Google Cloud.

Terraform

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Para crear un tema de Pub/Sub, agrega lo siguiente al archivo main.tf existente:

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

Puedes usar un nombre de tema único dentro de tu proyecto de Cloud.

Recupera la muestra de código

A fin de recuperar la muestra de código para su uso, haz lo siguiente:

Clona el repositorio de la app de muestra en tu máquina local:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.
C#
```
git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
```
De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.

Ve al directorio que contiene el código de muestra de 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/pubsub/

Revisa el código

El código de este instructivo consta de los siguientes elementos:

Un servidor que maneja las solicitudes entrantes

Node.js

Para que el servicio de Node.js sea fácil de probar, la configuración del servidor es independiente del inicio del servidor.

El servidor web de Node.js está configurado en app.js.

const express = require('express');
const app = express();

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

El servidor web se inicia en 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("PORT");
if (port != null)
{
    app.Urls.Add($"http://0.0.0.0:{port}");
}

Un controlador que procesa el mensaje de Pub/Sub y registra un saludo.

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 {target}!");

    return Results.NoContent();
});

Debes codificar el servicio para mostrar un código de respuesta HTTP preciso. Los códigos de éxito, como HTTP 200 o 204, confirman la recepción del procesamiento completo del mensaje de Pub/Sub. Los códigos de error, como HTTP 400 o 500, indican que se volverá a intentar enviar el mensaje, como se describe en la Guía de recepción de mensajes mediante suscripciones de envío.

Un Dockerfile que define el entorno operativo del servicio. El contenido del Dockerfile varía según el lenguaje

Node.js


# Use the official lightweight Node.js image.
# https://hub.docker.com/_/node
FROM node:18-slim

# Create and change to the app directory.
WORKDIR /usr/src/app

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure both package.json AND package-lock.json are copied.
# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./

# Install dependencies.
# If you add a package-lock.json speed your build by switching to 'npm ci'.
# RUN npm ci --only=production
RUN npm install --production

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

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

Python


# 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

En esta muestra, se usa Jib para compilar imágenes de Docker mediante herramientas de Java comunes. Jib optimiza las compilaciones de contenedores sin la necesidad de tener un Dockerfile o tener Docker instalado. Obtén más información sobre la compilación de contenedores de Java con Jib.

<plugin>
  <groupId>com.google.cloud.tools</groupId>
  <artifactId>jib-maven-plugin</artifactId>
  <version>3.4.0</version>
  <configuration>
    <to>
      <image>gcr.io/PROJECT_ID/pubsub</image>
    </to>
  </configuration>
</plugin>

C#

# Build in SDK base image
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -r linux-x64 --no-self-contained -p:PublishReadyToRun=true -c Release -o out

# Copy to runtime image
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .

# Port passed in by Cloud Run via environment variable PORT.  Default 8080.
ENV PORT=8080

ENTRYPOINT ["dotnet", "Run.Samples.Pubsub.MinimalApi.dll"]

Para obtener detalles sobre cómo autenticar el origen de las solicitudes de Pub/Sub, consulta Integra en Pub/Sub.

Envía el código

El código de envío consta de tres pasos: compilar una imagen de contenedor con Cloud Build, subir la imagen de contenedor a Artifact Registry y, luego, implementar la imagen de contenedor en Cloud Run.

Para enviar el código, haz lo siguiente:

Compila el contenedor y publica en Artifact Registry:
Node.js
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Reemplaza:
- PROJECT_ID por el ID del proyecto de Google Cloud.
- REPOSITORY por el nombre del repositorio de Artifact Registry
- REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.
pubsub es el nombre de la imagen.

Si la operación se completa de manera correcta, deberías ver un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Artifact Registry y puede volver a usarse si es necesario.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Reemplaza:
- PROJECT_ID por el ID del proyecto de Google Cloud.
- REPOSITORY por el nombre del repositorio de Artifact Registry
- REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.
pubsub es el nombre de la imagen.

Si la operación se completa de manera correcta, deberías ver un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Artifact Registry y puede volver a usarse si es necesario.
Go
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Reemplaza:
- PROJECT_ID por el ID del proyecto de Google Cloud.
- REPOSITORY por el nombre del repositorio de Artifact Registry
- REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.
pubsub es el nombre de la imagen.

Si la operación se completa de manera correcta, deberías ver un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Artifact Registry y puede volver a usarse si es necesario.
Java
- Usa el auxiliar de credenciales de gcloud CLI para autorizar a Docker a que envíe contenido a tu Artifact Registry.
```
gcloud auth configure-docker
```
- Usa el complemento de Maven para Jib a fin de compilar y enviar el contenedor a Artefact Registry.
```
mvn compile jib:build -D image=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
  Reemplaza:
  - PROJECT_ID por el ID del proyecto de Google Cloud.
  - REPOSITORY por el nombre del repositorio de Artifact Registry
  - REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.
  pubsub es el nombre de la imagen.
  
  Si se ejecuta de forma correcta, deberías ver un mensaje de COMPILACIÓN EXITOSA. La imagen se almacena en Artifact Registry y puede volver a usarse si es necesario.
C#
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Reemplaza:
- PROJECT_ID por el ID del proyecto de Google Cloud.
- REPOSITORY por el nombre del repositorio de Artifact Registry
- REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.
pubsub es el nombre de la imagen.

Si la operación se completa de manera correcta, deberías ver un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Artifact Registry y puede volver a usarse si es necesario.
Implementa tu aplicación:
Línea de comandos
1. Ejecuta el comando siguiente para implementar tu app:
```
gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub  --no-allow-unauthenticated
```
  Reemplaza:
  - PROJECT_ID por el ID del proyecto de Google Cloud.
  - REPOSITORY por el nombre del repositorio de Artifact Registry
  - REGION por la región de Google Cloud que se usará para el repositorio de Artifact Registry.
  pubsub es el nombre de la imagen y pubsub-tutorial es el nombre del servicio. Ten en cuenta que la imagen de contenedor se implementa en el servicio y en la región que configuraste antes en Configura gcloud.
  
  La marca --no-allow-unauthenticated restringe el acceso no autenticado al servicio. Si mantienes el servicio privado, puedes confiar en la integración automática de Pub/Sub de Cloud Run para autenticar las solicitudes. Consulta Integra en Pub/Sub para obtener más detalles sobre cómo se configura. Para obtener más detalles sobre la autenticación basada en la administración de identidades y accesos (IAM), consulta Administra el acceso mediante la IAM.
  
  Espera hasta que finalice la implementación; esto puede tomar alrededor de medio minuto. Si la operación se completa de forma correcta, la línea de comandos mostrará la URL de servicio. Esta URL se usa para configurar una suscripción a Pub/Sub.
2. Si deseas implementar una actualización de código en el servicio, repite los pasos anteriores. Cada implementación en un servicio crea una revisión nueva y comienza a entregar tráfico de forma automática cuando está lista.
Terraform

Para crear un servicio de Cloud Run, agrega lo siguiente al archivo .tf existente.

Reemplaza el valor de image por la URL de tu imagen: 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]
}
```

Integra en Pub/Sub

Para integrar el servicio en Pub/Sub, sigue estos pasos:

Línea de comandos

Crea o selecciona una cuenta de servicio para representar la identidad de suscripción a Pub/Sub.
```
gcloud iam service-accounts create cloud-run-pubsub-invoker \
    --display-name "Cloud Run Pub/Sub Invoker"
```
Puedes usar cloud-run-pubsub-invoker o reemplazarlo por un nombre único dentro de tu proyecto de Google Cloud.
Crea una suscripción a Pub/Sub con la cuenta de servicio:
1. Usa este comando para permitir que la cuenta de servicio invoque el servicio 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
```
  Es posible que los cambios de IAM tomen varios minutos en propagarse. Mientras tanto, puede que veas errores HTTP 403 en los registros del servicio.
2. Permite que Pub/Sub cree tokens de autenticación en el proyecto:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
   --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
   --role=roles/iam.serviceAccountTokenCreator
```
  Reemplaza lo siguiente:
  - PROJECT_ID por el ID del proyecto de Google Cloud.
  - PROJECT_NUMBER por tu número de proyecto de Google Cloud
  El ID y el número del proyecto se enumeran en el panel Información del proyecto en la consola de Google Cloud para el proyecto.
3. Crea una suscripción a Pub/Sub con la cuenta de servicio:
```
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
```
  Reemplaza lo siguiente:
  - myRunTopic por el tema que creaste antes.
  - SERVICE-URL por la URL HTTPS proporcionada en la implementación del servicio. Esta URL funciona incluso si también agregaste una asignación de dominio
  - PROJECT_ID por el ID del proyecto de Google Cloud.
  La marca --push-auth-service-account activa las funciones de envío de Pub/Sub para la autenticación y la autorización.
  
  Tu dominio del servicio de Cloud Run se registra de manera automática para que se use con las suscripciones a Pub/Sub.
  
  Solo para Cloud Run, hay una verificación de autenticación integrada de que el token sea válido y una verificación de autorización de que la cuenta de servicio tenga permiso para invocar el servicio de Cloud Run.

Tu servicio ahora está completamente integrado en Pub/Sub.

Terraform

Crea o selecciona una cuenta de servicio para representar la identidad de suscripción a Pub/Sub.

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

Crea una suscripción a Pub/Sub con la cuenta de servicio:

Usa este comando para permitir que la cuenta de servicio invoque el servicio 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}"]
}

Permite que Pub/Sub cree tokens de autenticación en el proyecto:

resource "google_project_service_identity" "pubsub_agent" {
  provider = google-beta
  project  = data.google_project.project.project_id
  service  = "pubsub.googleapis.com"
}

resource "google_project_iam_binding" "project_token_creator" {
  project = data.google_project.project.project_id
  role    = "roles/iam.serviceAccountTokenCreator"
  members = ["serviceAccount:${google_project_service_identity.pubsub_agent.email}"]
}

Crea una suscripción a Pub/Sub con la cuenta de servicio:

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

Tu servicio ahora está completamente integrado en Pub/Sub.

Probarlo

Para probar la solución de extremo a extremo, sigue estos pasos:

Envía un mensaje de Pub/Sub al tema:
```
gcloud pubsub topics publish myRunTopic --message "Runner"
```
También puedes publicar mensajes de manera programática en lugar de usar la línea de comandos como se muestra en este instructivo. Para obtener más información, consulta Publica mensajes.
Navega a los registros de servicio:
1. Navega a la consola de Google Cloud.
2. Haz clic en el servicio pubsub-tutorial.
3. Selecciona la pestaña Registros.
  
  Los registros pueden tomar un tiempo en aparecer. Si no los ves de inmediato, vuelve a revisar en unos minutos.
Busca el mensaje “Hello Runner!”.

Limpia

Para revisar un caso práctico más detallado del uso de Cloud Run con Pub/Sub, omite la limpieza por ahora y continúa con el Instructivo de procesamiento de imágenes con Cloud Run.

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y deseas conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra los recursos del instructivo

Usa este comando para borrar el servicio de Cloud Run que implementaste en este instructivo:
```
gcloud run services delete SERVICE-NAME
```
En el ejemplo anterior, SERVICE-NAME es el nombre del servicio que elegiste.

También puedes borrar los servicios de Cloud Run desde la consola de Google Cloud.
Quita la configuración de región predeterminada de gcloud que agregaste durante la configuración en el instructivo:
```
 gcloud config unset run/region
```
Quita la configuración del proyecto:
```
 gcloud config unset project
```
Borra otros recursos de Google Cloud que creaste en este instructivo:
- Borra el tema de Pub/Sub myRunTopic.
- Borra la suscripción a Pub/Sub myRunSubscription.
- Borra la imagen de contenedor con el nombre REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub de Artifact Registry.
- Borra la cuenta de servicio de invocador cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com.

¿Qué sigue?

Consulta Restringe el ingreso con el fin de obtener información sobre cómo aumentar la seguridad de producción mediante el uso de controles de entrada internos para limitar el ingreso.
Expande el servicio de muestra implementado en este instructivo para agregar una funcionalidad de procesamiento de imágenes que modifique las imágenes subidas a Cloud Storage.
Obtén más información sobre cómo se ajustan los temas a la arquitectura de Pub/Sub y cómo administrarlos.
Obtén más información sobre las suscripciones a Pub/Sub en Administra suscripciones.
Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.