Pub/Sub mit Cloud Run verwenden

In dieser Anleitung erfahren Sie, wie Sie einen Cloud Run-Dienst über ein Pub/Sub-Push-Abo schreiben, bereitstellen und aufrufen.

Ziele

Einen Dienst schreiben, erstellen und in Cloud Run bereitstellen
Eine Nachricht in einem Pub/Sub-Thema veröffentlichen, um den Dienst aufzurufen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweise

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Artifact Registry, Cloud Build, Pub/Sub und Cloud Run APIs aktivieren.
Aktivieren Sie die APIs

Installieren und initialisieren Sie die gcloud CLI.
Aktualisieren Sie die Komponenten:
```
gcloud components update
```

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen der Anleitung benötigen:

Cloud Build-Bearbeiter (roles/cloudbuild.builds.editor)
Cloud Run-Administrator (roles/run.admin)
Create Service Accounts (roles/iam.serviceAccountCreator)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Pub/Sub-Bearbeiter (roles/pubsub.editor)
Dienstkontonutzer (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
Storage-Administrator (roles/storage.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

gcloud-Standardeinstellungen einrichten

So konfigurieren Sie gcloud mit Standardeinstellungen für den Cloud Run-Dienst:

Legen Sie ein Standardprojekt fest:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch den Namen des Projekts, das Sie für diese Anleitung erstellt haben.
Konfigurieren Sie gcloud für die von Ihnen ausgewählte Region:
```
gcloud config set run/region REGION
```
Ersetzen Sie REGION durch die unterstützte Cloud Run-Region Ihrer Wahl.

Cloud Run-Standorte

Cloud Run ist regional. Die Infrastruktur, in der die Cloud Run-Dienste ausgeführt werden, befindet sich demnach in einer bestimmten Region. Aufgrund der Verwaltung durch Google sind die Anwendungen in allen Zonen innerhalb dieser Region redundant verfügbar.

Bei der Auswahl der Region, in der Ihre Cloud Run-Dienste ausgeführt werden, ist vorrangig, dass die Anforderungen hinsichtlich Latenz, Verfügbarkeit oder Langlebigkeit erfüllt werden. Sie können im Allgemeinen die Region auswählen, die Ihren Nutzern am nächsten liegt, aber Sie sollten den Standort der anderen Google Cloud-Produkte berücksichtigen, die von Ihrem Cloud Run-Dienst verwendet werden. Die gemeinsame Nutzung von Google Cloud-Produkten an mehreren Standorten kann sich auf die Latenz und die Kosten des Dienstes auswirken.

Cloud Run ist in diesen Regionen verfügbar:

Unterliegt Preisstufe 1

asia-east1 (Taiwan)
asia-northeast1 (Tokio)
asia-northeast2 (Osaka)
europe-north1 (Finnland) Niedriger CO₂-Wert
europe-southwest1 (Madrid)
europe-west1 (Belgien) Niedriger CO₂-Ausstoß
europe-west4 (Niederlande)
europe-west8 (Mailand)
europe-west9 (Paris) Niedriger CO₂-Ausstoß
me-west1 (Tel Aviv)
us-central1 (Iowa) Niedriger CO₂-Ausstoß
us-east1 (South Carolina)
us-east4 (Northern Virginia)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) Niedriger CO₂-Ausstoß

Unterliegt Preisstufe 2

africa-south1 (Johannesburg)
asia-east2 (Hongkong)
asia-northeast3 (Seoul, Südkorea)
asia-southeast1 (Singapur)
asia-southeast2 (Jakarta)
asia-south1 (Mumbai, Indien)
asia-south2 (Delhi, Indien)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Warschau, Polen)
europe-west10 (Berlin)
europe-west12 (Turin)
europe-west2 (London, Vereinigtes Königreich) Niedriger CO₂-Ausstoß
europe-west3 (Frankfurt, Deutschland) Niedriger CO₂-Wert
europe-west6 (Zürich, Schweiz) Niedriger CO₂-Ausstoß
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Niedriger CO₂-Ausstoß
northamerica-northeast2 (Toronto) Niedriger CO₂-Ausstoß
southamerica-east1 (Sao Paulo, Brasilien) Niedriger CO₂-Ausstoß
southamerica-west1 (Santiago, Chile) Niedriger CO₂-Ausstoß
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Wenn Sie bereits einen Cloud Run-Dienst erstellt haben, können Sie dessen Region im Cloud Run-Dashboard der Google Cloud Console aufrufen.

Artifact Registry-Standard-Repository erstellen

Erstellen Sie ein Artifact Registry-Standard-Repository zum Speichern des Docker-Container-Images:

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

Ersetzen Sie:

REPOSITORY durch einen eindeutigen Namen für das Repository.
REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.

Pub/Sub-Thema erstellen

Der Beispieldienst wird durch Nachrichten ausgelöst, die in einem Pub/Sub-Thema veröffentlicht werden. Daher müssen Sie in Pub/Sub ein Thema erstellen.

Befehlszeile

Verwenden Sie den folgenden Befehl, um ein neues Pub/Sub-Thema zu erstellen:

gcloud pubsub topics create myRunTopic

Sie können myRunTopic verwenden oder durch einen Themennamen ersetzen, der in Ihrem Google Cloud-Projekt nur einmal vorkommt.

Terraform

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

Fügen Sie Ihrer vorhandenen main.tf-Datei Folgendes hinzu, um ein Pub/Sub-Thema zu erstellen:

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

Sie können einen Themennamen verwenden, der in Ihrem Cloud-Projekt eindeutig ist.

Codebeispiel abrufen

So rufen Sie das gewünschte Codebeispiel ab:

Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Einfach loslegen (Go)
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
C#
```
git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

Wechseln Sie in das Verzeichnis, das den Cloud Run-Beispielcode enthält:

Node.js

cd nodejs-docs-samples/run/pubsub/

Python

cd python-docs-samples/run/pubsub/

Einfach loslegen (Go)

cd golang-samples/run/pubsub/

Java

cd java-docs-samples/run/pubsub/

C#

cd dotnet-docs-samples/run/pubsub/

Code ansehen

Der Code dieser Anleitung besteht aus folgenden Elementen:

Einem Server, der eingehende Anfragen verarbeitet.

Node.js

Für einen einfacheren Test des Dienstes Node.js ist die Serverkonfiguration vom Serverstart getrennt.

Der Node.js-Webserver wird in app.js eingerichtet.

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

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

Der Webserver wird in index.js gestartet:

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__)

Einfach loslegen (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}");
}

Ein Handler, der die Pub/Sub-Nachricht verarbeitet und ein Greeting protokolliert.

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)

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

Sie müssen den Dienst so programmieren, dass ein genauer HTTP-Antwortcode zurückgegeben wird. Erfolgscodes wie HTTP 200 oder 204 bestätigen die vollständige Verarbeitung der Pub/Sub-Nachricht. Fehlercodes wie HTTP 400 oder 500 zeigen an, dass der Versand der Nachricht noch einmal versucht wird. Weitere Informationen finden Sie unter Nachrichten mit Push empfangen.

Einem Dockerfile, das die Betriebsumgebung für den Dienst definiert. Der Inhalt des Dockerfile variiert je nach Sprache.

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

Einfach loslegen (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

In diesem Beispiel wird Jib verwendet, um Docker-Images mit gängigen Java-Tools zu erstellen. Jib optimiert Container-Builds, ohne dass ein Dockerfile erforderlich ist oder Docker installiert sein muss. Weitere Informationen zum Erstellen von Java-Containern mit 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"]

Weitere Informationen zum Authentifizieren des Ursprungs von Pub/Sub-Anfragen finden Sie unter In Pub/Sub integrieren.

Code versenden

Das Versenden von Code erfolgt in drei Schritten: ein Container-Image mit Cloud Build erstellen, in Artifact Registry hochladen und in Cloud Run bereitstellen.

So versenden Sie den Code:

Erstellen Sie einen Container und veröffentlichen Sie ihn in Artifact Registry.
Node.js
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Ersetzen Sie:
- PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
- REPOSITORY durch den Namen des Artifact Registry-Repositorys.
- REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.
pubsub ist der Image-Name.

Bei Erfolg sollte eine Bestätigungsmeldung mit der ID, der Erstellungszeit und dem Image-Namen angezeigt werden. Das Image wird in Artifact Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Ersetzen Sie:
- PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
- REPOSITORY durch den Namen des Artifact Registry-Repositorys.
- REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.
pubsub ist der Image-Name.

Bei Erfolg sollte eine Bestätigungsmeldung mit der ID, der Erstellungszeit und dem Image-Namen angezeigt werden. Das Image wird in Artifact Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Go
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Ersetzen Sie:
- PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
- REPOSITORY durch den Namen des Artifact Registry-Repositorys.
- REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.
pubsub ist der Image-Name.

Bei Erfolg sollte eine Bestätigungsmeldung mit der ID, der Erstellungszeit und dem Image-Namen angezeigt werden. Das Image wird in Artifact Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Java
- Verwenden Sie den gcloud CLI Credential Helper, um Docker für das Übertragen per Push in Ihre Artifact Registry zu autorisieren.
```
gcloud auth configure-docker
```
- Verwenden Sie das Jib-Maven-Plug-in, um den Container zu erstellen und per Push in Artifact Registry zu übertragen.
```
mvn compile jib:build -D image=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
  Ersetzen Sie:
  - PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
  - REPOSITORY durch den Namen des Artifact Registry-Repositorys.
  - REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.
  pubsub ist der Image-Name.
  
  Bei Erfolg sollte die Nachricht „BUILD SUCCESS“ angezeigt werden. Das Image wird in Artifact Registry gespeichert und kann bei Bedarf wiederverwendet werden.
C#
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub
```
Ersetzen Sie:
- PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
- REPOSITORY durch den Namen des Artifact Registry-Repositorys.
- REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.
pubsub ist der Image-Name.

Bei Erfolg sollte eine Bestätigungsmeldung mit der ID, der Erstellungszeit und dem Image-Namen angezeigt werden. Das Image wird in Artifact Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Stellen Sie Ihre Anwendung bereit:
Befehlszeile
1. Stellen Sie die Anwendung mit dem folgenden Befehl bereit:
```
gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub  --no-allow-unauthenticated
```
  Ersetzen Sie:
  - PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
  - REPOSITORY durch den Namen des Artifact Registry-Repositorys.
  - REGION durch die Google Cloud-Region, die für das Artifact Registry-Repository verwendet werden soll.
  pubsub ist der Image-Name und pubsub-tutorial der Name des Dienstes. Beachten Sie, dass das Container-Image für den Dienst und die Region bereitgestellt wird, die Sie zuvor unter gcloud einrichten konfiguriert haben.
  
  Das Flag --no-allow-unauthenticated beschränkt den nicht authentifizierten Zugriff auf den Dienst. Wenn Sie den Dienst privat nutzen, können Sie sich bei der Authentifizierung von Anfragen auf die automatische Pub/Sub-Integration von Cloud Run verlassen. Weitere Informationen zur Konfiguration finden Sie unter In Pub/Sub integrieren. Weitere Informationen zur Authentifizierung auf Grundlage des Identity and Access Management (IAM) finden Sie unter Zugriff mit IAM verwalten.
  
  Warten Sie, bis die Bereitstellung abgeschlossen ist. Dies kann ungefähr eine halbe Minute dauern. Bei Erfolg wird in der Befehlszeile die Dienst-URL angezeigt. Diese URL wird zum Konfigurieren eines Pub/Sub-Abos verwendet.
2. Wenn Sie eine Codeaktualisierung für den Dienst bereitstellen möchten, wiederholen Sie die vorherigen Schritte. Bei jeder Bereitstellung für einen Dienst wird eine neue Version erstellt und der Traffic wird automatisch verarbeitet, sobald der Dienst bereit ist.
Terraform

Fügen Sie Ihrer vorhandenen .tf-Datei Folgendes hinzu, um einen Cloud Run-Dienst zu erstellen:

Ersetzen Sie den Wert für image durch Ihre Bild-URL: 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]
}
```

In Pub/Sub integrieren

So integrieren Sie den Dienst in Pub/Sub:

Befehlszeile

Erstellen oder wählen Sie ein Dienstkonto, das die Pub/Sub-Abo-Identität darstellen soll.
```
gcloud iam service-accounts create cloud-run-pubsub-invoker \
    --display-name "Cloud Run Pub/Sub Invoker"
```
Sie können cloud-run-pubsub-invoker verwenden oder durch einen Namen ersetzen, der in Ihrem Google Cloud-Projekt nur einmal vorkommt.
Erstellen Sie ein Pub/Sub-Abo mit dem Dienstkonto:
1. Gewähren Sie dem Aufrufer-Dienstkonto die Berechtigung zum Aufrufen Ihres pubsub-tutorial-Dienstes:
```
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 kann einige Minuten dauern, bis die IAM-Änderungen übertragen werden. In der Zwischenzeit werden möglicherweise HTTP 403-Fehler in den Dienstlogs angezeigt.
2. Erlauben Sie Pub/Sub, Authentifizierungstokens in Ihrem Projekt zu erstellen:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
   --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
   --role=roles/iam.serviceAccountTokenCreator
```
  Ersetzen Sie:
  - PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
  - PROJECT_NUMBER durch Ihre Google Cloud-Projektnummer.
  Die Projekt-ID und die Projektnummer werden im Bereich Projektinformationen in der Google Cloud Console für Ihr Projekt aufgeführt.
3. Erstellen Sie ein Pub/Sub-Abo mit dem Dienstkonto:
```
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
```
  Ersetzen Sie:
  - myRunTopic durch das zuvor erstellte Thema.
  - SERVICE-URL durch die HTTPS-URL, die bei der Bereitstellung des Dienstes angegeben wurde. Diese URL funktioniert sogar dann, wenn Sie auch eine Domainzuordnung hinzugefügt haben.
  - PROJECT_ID durch Ihre Google Cloud-Projekt-ID.
  Das Flag --push-auth-service-account aktiviert die Pub/Sub-Push-Funktion für die Authentifizierung und Autorisierung.
  
  Ihre Cloud Run-Dienstdomain wird automatisch für die Verwendung mit Pub/Sub-Abos registriert.
  
  Nur für Cloud Run gibt es eine integrierte Authentifizierungsprüfung, die das Token auf seine Gültigkeit untersucht, und eine Autorisierungsprüfung, mit der festgestellt wird, ob das Dienstkonto berechtigt ist, den Cloud Run-Dienst aufzurufen.

Ihr Dienst ist jetzt vollständig in Pub/Sub integriert.

Terraform

Erstellen oder wählen Sie ein Dienstkonto, das die Pub/Sub-Abo-Identität darstellen soll.

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

Erstellen Sie ein Pub/Sub-Abo mit dem Dienstkonto:

Gewähren Sie dem Aufrufer-Dienstkonto die Berechtigung zum Aufrufen Ihres pubsub-tutorial-Dienstes:

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

Erlauben Sie Pub/Sub, Authentifizierungstokens in Ihrem Projekt zu erstellen:

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

Erstellen Sie ein Pub/Sub-Abo mit dem Dienstkonto:

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

Ihr Dienst ist jetzt vollständig in Pub/Sub integriert.

Testen

So testen Sie die durchgängige Lösung:

Senden Sie eine Pub/Sub-Nachricht an das Thema:
```
gcloud pubsub topics publish myRunTopic --message "Runner"
```
Anstatt über die in dieser Anleitung beschriebene Befehlszeile können Sie Nachrichten auch programmatisch veröffentlichen. Weitere Informationen finden Sie unter Nachrichten veröffentlichen.
Rufen Sie die Dienstlogs auf:
1. Öffnen Sie die Google Cloud Console:
2. Klicken Sie auf den Dienst pubsub-tutorial.
3. Wählen Sie den Tab Logs aus.
  
  Es kann einige Momente dauern, bis Logs angezeigt werden. Falls sie nicht sofort angezeigt werden, warten Sie kurz ab und sehen Sie dann noch einmal nach.
Suchen Sie nach der Nachricht „Hello Runner!“.

Bereinigen

Wenn Sie einen ausführlicheren Anwendungsfall für die Verwendung von Cloud Run mit Pub/Sub durchgehen möchten, überspringen Sie die Bereinigung und fahren Sie mit der Anleitung zur Verarbeitung von Images mit Cloud Run fort.

Wenn Sie ein neues Projekt für diese Anleitung erstellt haben, löschen Sie das Projekt. Wenn Sie ein vorhandenes Projekt verwendet haben und es beibehalten möchten, ohne die Änderungen in dieser Anleitung hinzuzufügen, löschen Sie die für die Anleitung erstellten Ressourcen.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Anleitungsressourcen löschen

Löschen Sie den Cloud Run-Dienst, den Sie in dieser Anleitung bereitgestellt haben:
```
gcloud run services delete SERVICE-NAME
```
Dabei ist SERVICE-NAME der von Ihnen ausgewählte Dienstname.

Sie können Cloud Run-Dienste auch über die Google Cloud Console löschen.
Entfernen Sie die Konfiguration der Standardregion gcloud, die Sie während der Einrichtung für die Anleitung hinzugefügt haben:
```
 gcloud config unset run/region
```
Entfernen Sie die Projektkonfiguration:
```
 gcloud config unset project
```
Löschen Sie sonstige Google Cloud-Ressourcen, die in dieser Anleitung erstellt wurden:
- Löschen Sie das Pub/Sub-Thema myRunTopic.
- Löschen Sie das Pub/Sub-Abo myRunSubscription
- Löschen Sie Ihr Container-Image mit dem Namen REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/pubsub aus Artifact Registry.
- Löschen Sie das Aufrufer-Dienstkonto cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com

Nächste Schritte

Unter Eingehenden Traffic einschränken finden Sie Informationen zur Erhöhung der Produktionssicherheit. Dazu verwenden Sie die internen Ingress-Steuerelemente zur Begrenzung des eingehenden Traffics.
Erweitern Sie den in dieser Anleitung bereitgestellten Beispieldienst durch Hinzufügen der Funktionalität zur Image-Verarbeitung, mit der in Cloud Storage hochgeladene Images geändert werden.
Erfahren Sie mehr über Themen in der Pub/Sub-Architektur und wie Sie Themen verwalten.
Erfahren Sie mehr über Pub/Sub-Abos unter Abos verwalten.
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center