Diese Seite wurde von der Cloud Translation API übersetzt.

Push-Abos erstellen

In diesem Dokument wird beschrieben, wie Sie ein Push-Abo erstellen. Sie können die Die Google Cloud Console, die Google Cloud CLI, die Clientbibliothek oder die Pub/Sub API zum Erstellen eines Push-Abos

Hinweise

Weitere Informationen zu Abos
Machen Sie sich mit der Funktionsweise von Push-Abos vertraut.

Erforderliche Rollen und Berechtigungen

Zum Erstellen eines Abos müssen Sie die Zugriffssteuerung auf der Seite auf Projektebene. Sie benötigen auch Berechtigungen auf Ressourcenebene, wenn Ihre Abos Themen und Themen sich in verschiedenen Projekten befinden, wie später in diesem Abschnitt erläutert wird.

Um die Berechtigungen zu erhalten, die Sie zum Erstellen von Push-Abos benötigen, bitten Sie Ihren Administrator, Ihnen IAM-Rolle Pub/Sub-Bearbeiter (roles/pubsub.editor) für das Projekt Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.

Diese vordefinierte Rolle enthält Berechtigungen, die zum Erstellen von Push-Abos erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Erstellen von Push-Abos erforderlich:

Abo erstellen: pubsub.subscriptions.create
So löschen Sie ein Abo: pubsub.subscriptions.delete
Abo abschließen: pubsub.subscriptions.get
So listen Sie ein Abo auf: pubsub.subscriptions.list
So aktualisieren Sie ein Abo: pubsub.subscriptions.update
So hängen Sie ein Abo an ein Thema an: pubsub.topics.attachSubscription
Rufen Sie die IAM-Richtlinie für ein Abo ab: pubsub.subscriptions.getIamPolicy
Konfigurieren Sie die IAM-Richtlinie für ein Abo: pubsub.subscriptions.setIamPolicy

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Wenn Sie Push-Benachrichtigungen Abos in einem Projekt, die mit einem Thema in einem anderen verknüpft sind Projekt verwenden, bitten Sie Ihren Themenadministrator, Ihnen auch den Pub/Sub Editor zu gewähren. Die IAM-Rolle (roles/pubsub.editor) für das Thema.

Push-Aboeigenschaften

Beim Konfigurieren eines Push-Abos können Sie Folgendes angeben: Eigenschaften.

Allgemeine Eigenschaften

Weitere Informationen zu allgemeinen Abo-Properties das Sie für alle Abos festlegen können.

Endpunkte

Endpunkt-URL (erforderlich): Eine öffentlich zugängliche HTTPS-Adresse. Der Server für die Push-Übertragung Endpunkt muss ein gültiges SSL-Zertifikat haben, das von einer Zertifizierungsstelle signiert ist. Der Pub/Sub-Dienst sendet Nachrichten an Push-Endpunkte aus derselben Google Cloud-Region, in der der Pub/Sub-Dienst die Nachrichten speichert. Der Pub/Sub-Dienst sendet Nachrichten aus derselben Google Cloud-Region auf Best-Effort-Basis.

Pub/Sub erfordert für Push keinen Nachweis der Inhaberschaft mehr Abo-URL-Domains. Wenn Ihre Domain unerwartete POST-Anfragen erhält aus Pub/Sub verwenden, können Sie einen verdächtigen Missbrauch melden.

Authentifizierung

Authentifizierung aktivieren. Wenn diese Option aktiviert ist, enthalten Nachrichten, die von Pub/Sub an den Push-Endpunkt gesendet werden, einen Autorisierungsheader, damit der Endpunkt die Anfrage authentifizieren kann. Automatische Authentifizierung und Autorisierungsmechanismen sind für App Engine Standard- und Cloud Functions-Endpunkte verfügbar, die im selben Projekt wie das Abo gehostet werden.

Die Authentifizierungskonfiguration für ein authentifiziertes Push-Abo besteht aus einem vom Nutzer verwalteten Dienstkonto, und die Zielgruppenparameter, in einem create angegeben werden, Patchen oder ModifyPushConfig aufrufen. Sie müssen einem Dienst-Agent auch eine bestimmte Rolle zuweisen, wie in im nächsten Abschnitt.

Nutzerverwaltetes Dienstkonto (erforderlich). Das mit dem Push verknüpfte Dienstkonto Abo. Dieses Konto wird als email-Anforderung des generierten JSON-Webtokens (JWT) verwendet. Im Folgenden finden Sie eine Liste der Anforderungen für das Dienstkonto:
- Dieses Dienstkonto muss sich im selben Projekt wie das Push-Abo befinden.
- Das Hauptkonto, das das Push-Abo erstellt oder ändert, muss Sie haben die Berechtigung iam.serviceAccounts.actAs für das Dienstkonto. Sie können entweder eine Rolle mit dieser Berechtigung für das Projekt, den Ordner, oder Organisation die Identität mehrerer Dienstkonten übernehmen oder eine Rolle mit diesem Berechtigung für den Dienst Konto, damit der Anrufer die Identität dieses Dienstkontos übernehmen.
Zielgruppe: Ein einzelner String ohne Berücksichtigung der Groß- und Kleinschreibung, den der Webhook enthält verwendet, um die beabsichtigte Zielgruppe dieses bestimmten Tokens zu validieren.
Dienst-Agent (erforderlich).
- Pub/Sub erstellt automatisch ein Dienstkonto für Sie mit dem Format service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com
- Diesem Dienst-Agent muss die Berechtigung iam.serviceAccounts.getOpenIdToken (enthalten im roles/iam.serviceAccountTokenCreator Rolle), damit Pub/Sub JWT-Tokens für authentifizierte Push-Anfragen.

Entpacken der Nutzlast

Mit der Option Entpacken der Nutzlast aktivieren wird Pub/Sub entfernt. Nachrichten aller Metadaten der Nachricht mit Ausnahme der Nachrichtendaten. Mit Nutzlast werden die Nachrichtendaten direkt als HTTP-Text gesendet.

Metadaten schreiben Fügt zuvor entfernte Nachrichtenmetadaten wieder hinzu Anfrageheader.

VPC Service Controls

Für ein Projekt, das durch VPC Service Controls Beachten Sie die folgenden Einschränkungen für Push-Abos:

Sie können nur neue Push-Abos erstellen, für die der Push-Endpunkt auf einen Cloud Run-Dienst mit einer run.app-Standard-URL oder einem Workflows ausführen. Benutzerdefinierte Domains funktionieren nicht.
Beim Weiterleiten von Ereignissen über Eventarc an Workflows Ziele, für die der Push-Endpunkt auf einen Workflow festgelegt ist ausgeführt wird, können Sie neue Push-Abos nur über Eventarc erstellen.
Vorhandene Push-Abos können nicht aktualisiert werden. Diese Push-Abos funktionieren weiterhin, sind aber nicht durch VPC Service Controls geschützt.

Push-Abo erstellen

Die folgenden Beispiele zeigen, wie Sie ein Abo mit Push erstellen. Auslieferung unter Verwendung der bereitgestellten Standardeinstellungen.

Standardmäßig verwenden Abos Pull-Zustellung es sei denn, Sie legen explizit eine Push-Konfiguration fest, wie in den folgenden Beispielen gezeigt.

Console

So erstellen Sie ein Push-Abo:

Öffnen Sie in der Google Cloud Console die Seite Abos.
Zu „Abos“
Klicken Sie auf Abo erstellen.
Geben Sie im Feld Abo-ID einen Namen ein.
Weitere Informationen zur Benennung von Abos finden Sie unter Richtlinien für die Benennung von Themen oder Abos.
Wählen Sie im Drop-down-Menü ein Thema aus oder erstellen Sie ein Thema. Das Abo erhält Nachrichten aus dem Thema.
Wählen Sie als Zustellungstyp Push aus.
Geben Sie eine Endpunkt-URL an.
Behalten Sie alle anderen Standardwerte bei.
Klicken Sie auf Erstellen.

Sie können ein Abo auch im Abschnitt Themen erstellen. Diese Verknüpfung ist nützlich, um Themen mit Abos zu verknüpfen.

Rufen Sie in der Google Cloud Console die Seite Themen auf.
Themen aufrufen
Klicken Sie neben dem Thema, für das Sie ein Abo erstellen möchten, auf .
Wählen Sie im Kontextmenü Abo erstellen aus.
Geben Sie die Abo-ID ein.
Weitere Informationen zur Benennung von Abos finden Sie unter Richtlinien für die Benennung von Themen oder Abos.
Wählen Sie als Zustellungstyp Push aus.
Geben Sie eine Endpunkt-URL an.
Behalten Sie alle anderen Standardwerte bei.
Klicken Sie auf Erstellen.

gcloud

Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.
Führen Sie den Befehl gcloud pubsub subscriptions create aus, um ein Push-Abo zu erstellen.
```
gcloud pubsub subscriptions create SUBSCRIPTION_ID \
    --topic=TOPIC_ID \
    --push-endpoint=PUSH_ENDPOINT
```
Ersetzen Sie Folgendes:
- SUBSCRIPTION_ID: Name oder ID des neuen Push-Vorgangs. Abo.
- TOPIC_ID: Der Name oder die ID des Themas.
- PUSH_ENDPOINT: Die URL, die als Endpunkt für dieses Abo verwendet werden soll. Beispiel: https://myproject.appspot.com/myhandler.

REST

Verwenden Sie zum Erstellen eines Push-Abos den projects.subscriptions.create :

Anfrage:

Die Anfrage muss mit einem Zugriffstoken im Header Authorization authentifiziert werden. Zugriffstoken für die aktuellen Standardanmeldedaten für Anwendungen abrufen: gcloud auth application-default print-access-token

PUT https://pubsub.googleapis.com/v1/projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID
Authorization: Bearer ACCESS_TOKEN

Anfragetext:

{
  "topic": "projects/PROJECT_ID/topics/TOPIC_ID",
  // Only needed if you are using push delivery
  "pushConfig": {
    "pushEndpoint": "PUSH_ENDPOINT"
  }
}

Wobei:

PROJECT_ID ist die Projekt-ID.

SUBSCRIPTION_ID ist Ihre Abo-ID.

TOPIC_ID ist Ihre Themen-ID.

PUSH_ENDPOINT ist eine URL, die als Endpunkt verwendet werden soll. Beispiel: https://myproject.appspot.com/myhandler.

Lösung:

{
  "name": "projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID",
  "topic": "projects/PROJECT_ID/topics/TOPIC_ID",
  "pushConfig": {
    "pushEndpoint": "https://PROJECT_ID.appspot.com/myhandler",
    "attributes": {
      "x-goog-version": "v1"
    }
  },
  "ackDeadlineSeconds": 10,
  "messageRetentionDuration": "604800s",
  "expirationPolicy": {
    "ttl": "2678400s"
  }
}

C++

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für C++ in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C++ API.

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::SubscriptionAdminClient client,
   std::string const& project_id, std::string const& topic_id,
   std::string const& subscription_id, std::string const& endpoint) {
  google::pubsub::v1::Subscription request;
  request.set_name(
      pubsub::Subscription(project_id, subscription_id).FullName());
  request.set_topic(pubsub::Topic(project_id, topic_id).FullName());
  request.mutable_push_config()->set_push_endpoint(endpoint);
  auto sub = client.CreateSubscription(request);
  if (sub.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The subscription already exists\n";
    return;
  }
  if (!sub) throw std::move(sub).status();

  std::cout << "The subscription was successfully created: "
            << sub->DebugString() << "\n";

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für C# in der Pub/Sub-Schnellstart mit Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub C# API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.


using Google.Cloud.PubSub.V1;

public class CreatePushSubscriptionSample
{
    public Subscription CreatePushSubscription(string projectId, string topicId, string subscriptionId, string pushEndpoint)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
        SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);

        PushConfig pushConfig = new PushConfig { PushEndpoint = pushEndpoint };

        // The approximate amount of time in seconds (on a best-effort basis) Pub/Sub waits for the
        // subscriber to acknowledge receipt before resending the message.
        var ackDeadlineSeconds = 60;
        var subscription = subscriber.CreateSubscription(subscriptionName, topicName, pushConfig, ackDeadlineSeconds);
        return subscription;
    }
}

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Go in der Pub/Sub-Schnellstart mit Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub Go API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/pubsub"
)

func createWithEndpoint(w io.Writer, projectID, subID string, topic *pubsub.Topic, endpoint string) error {
	// projectID := "my-project-id"
	// subID := "my-sub"
	// topic of type https://godoc.org/cloud.google.com/go/pubsub#Topic
	// endpoint := "https://my-test-project.appspot.com/push"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	sub, err := client.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
		Topic:       topic,
		AckDeadline: 10 * time.Second,
		PushConfig:  pubsub.PushConfig{Endpoint: endpoint},
	})
	if err != nil {
		return fmt.Errorf("CreateSubscription: %w", err)
	}
	fmt.Fprintf(w, "Created push subscription: %v\n", sub)
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Java in der Pub/Sub-Schnellstart mit Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub Java API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.


import com.google.cloud.pubsub.v1.SubscriptionAdminClient;
import com.google.pubsub.v1.PushConfig;
import com.google.pubsub.v1.Subscription;
import com.google.pubsub.v1.SubscriptionName;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;

public class CreatePushSubscriptionExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String subscriptionId = "your-subscription-id";
    String topicId = "your-topic-id";
    String pushEndpoint = "https://my-test-project.appspot.com/push";

    createPushSubscriptionExample(projectId, subscriptionId, topicId, pushEndpoint);
  }

  public static void createPushSubscriptionExample(
      String projectId, String subscriptionId, String topicId, String pushEndpoint)
      throws IOException {
    try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      TopicName topicName = TopicName.of(projectId, topicId);
      SubscriptionName subscriptionName = SubscriptionName.of(projectId, subscriptionId);
      PushConfig pushConfig = PushConfig.newBuilder().setPushEndpoint(pushEndpoint).build();

      // Create a push subscription with default acknowledgement deadline of 10 seconds.
      // Messages not successfully acknowledged within 10 seconds will get resent by the server.
      Subscription subscription =
          subscriptionAdminClient.createSubscription(subscriptionName, topicName, pushConfig, 10);
      System.out.println("Created push subscription: " + subscription.getName());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const pushEndpoint = 'YOUR_ENDPOINT_URL';
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';

// Imports the Google Cloud client library
const {PubSub} = require('@google-cloud/pubsub');

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

async function createPushSubscription(
  pushEndpoint,
  topicNameOrId,
  subscriptionNameOrId
) {
  const options = {
    pushConfig: {
      // Set to an HTTPS endpoint of your choice. If necessary, register
      // (authorize) the domain on which the server is hosted.
      pushEndpoint,
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);
  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const pushEndpoint = 'YOUR_ENDPOINT_URL';
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';

// Imports the Google Cloud client library
import {PubSub, CreateSubscriptionOptions} from '@google-cloud/pubsub';

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

async function createPushSubscription(
  pushEndpoint: string,
  topicNameOrId: string,
  subscriptionNameOrId: string
) {
  const options: CreateSubscriptionOptions = {
    pushConfig: {
      // Set to an HTTPS endpoint of your choice. If necessary, register
      // (authorize) the domain on which the server is hosted.
      pushEndpoint,
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);
  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

PHP

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für PHP in der Pub/Sub-Schnellstart mit Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub PHP API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

use Google\Cloud\PubSub\PubSubClient;

/**
 * Creates a Pub/Sub push subscription.
 *
 * @param string $projectId  The Google project ID.
 * @param string $topicName  The Pub/Sub topic name.
 * @param string $subscriptionName  The Pub/Sub subscription name.
 * @param string $endpoint  The endpoint for the push subscription.
 */
function create_push_subscription($projectId, $topicName, $subscriptionName, $endpoint)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);
    $topic = $pubsub->topic($topicName);
    $subscription = $topic->subscription($subscriptionName);
    $subscription->create([
        'pushConfig' => ['pushEndpoint' => $endpoint]
    ]);

    printf('Subscription created: %s' . PHP_EOL, $subscription->name());
}

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Python in der Pub/Sub-Schnellstart mit Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub Python API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

from google.cloud import pubsub_v1

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# endpoint = "https://my-test-project.appspot.com/push"

publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)

push_config = pubsub_v1.types.PushConfig(push_endpoint=endpoint)

# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
    subscription = subscriber.create_subscription(
        request={
            "name": subscription_path,
            "topic": topic_path,
            "push_config": push_config,
        }
    )

print(f"Push subscription created: {subscription}.")
print(f"Endpoint for subscription is: {endpoint}")

Ruby

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Ruby in der Pub/Sub-Schnellstart mit Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub Ruby API Referenzdokumentation.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

# topic_id          = "your-topic-id"
# subscription_id   = "your-subscription-id"
# endpoint          = "https://your-test-project.appspot.com/push"

pubsub = Google::Cloud::Pubsub.new

topic        = pubsub.topic topic_id
subscription = topic.subscribe subscription_id,
                               endpoint: endpoint

puts "Push subscription #{subscription_id} created."

Nächste Schritte

Erstellen oder ändern Sie ein Abo mit gcloud-Befehlen.
Abo mit REST APIs erstellen oder ändern