Nachrichten ordnen

Die Nachrichtenreihenfolge ist eine Funktion in Pub/Sub, mit der du Nachrichten in deinen Abonnentenclients in der Reihenfolge empfangen kannst, in der sie von den Publisher-Clients veröffentlicht wurden.

Angenommen, ein Publisher-Client in einer Region veröffentlicht die Nachrichten 1, 2 und 3 der Reihe nach. Bei der Nachrichtensortierung erhält der Abonnentenclient die veröffentlichten Nachrichten in derselben Reihenfolge. Damit sie in der richtigen Reihenfolge zugestellt werden, muss der Publisher-Client die Nachrichten in derselben Region veröffentlichen.

Die Nachrichtenreihenfolge ist eine nützliche Funktion für Szenarien wie die Erfassung von Datenbankänderungen, das Tracking von Nutzersitzungen und Streaminganwendungen, bei denen es wichtig ist, die Chronologie von Ereignissen beizubehalten.

Auf dieser Seite wird das Konzept der Nachrichtenreihenfolge erläutert und wie Sie Ihre Abonnentenclients so einrichten, dass sie Nachrichten der Reihe nach empfangen. Informationen zum Konfigurieren Ihrer Publisher-Clients für die Nachrichtenreihenfolge finden Sie unter Nachrichten mit Sortierungsschlüsseln veröffentlichen.

Übersicht über die Nachrichtenreihenfolge

Die Reihenfolge in Pub/Sub wird durch Folgendes bestimmt:

• Reihenfolgesschlüssel: Dies ist ein String, der in den Metadaten der Pub/Sub-Nachrichten verwendet wird und die Entität darstellt, für die Nachrichten sortiert werden müssen. Der Reihenfolgeschlüssel kann bis zu 1 KB lang sein. Wenn Sie in einer Region einen Satz sortierter Nachrichten empfangen möchten, müssen Sie alle Nachrichten mit demselben Sortierungsschlüssel in derselben Region veröffentlichen. Beispiele für Sortierschlüssel sind Kundennummern und der Primärschlüssel einer Zeile in einer Datenbank.

  Der Veröffentlichungsdurchsatz für jeden Reihenfolgeschlüssel ist auf 1 Mbit/s begrenzt. Der Durchsatz aller Sortierschlüssel zu einem Thema ist auf das Kontingent beschränkt, das in einer Veröffentlichungsregion verfügbar ist. Dieses Limit kann auf viele GB/s erhöht werden.

  Ein Sortierungsschlüssel entspricht nicht einer Partition in einem partitionierungsbasierten Nachrichtensystem, da Sortierschlüssel eine wesentlich höhere Kardinalität als Partitionen haben.

• Nachrichtenreihenfolge aktivieren: Dies ist eine Aboeinstellung. Wenn für ein Abo die Nachrichtenreihenfolge aktiviert ist, empfangen die Abonnentenclients Nachrichten, die in derselben Region veröffentlicht wurden, mit demselben Sortierungsschlüssel in der Reihenfolge, in der sie vom Dienst empfangen wurden. Sie müssen diese Einstellung im Abo aktivieren.

  Angenommen, Sie haben zwei Abos A und B, die mit demselben Thema T verknüpft sind. Abo A ist mit aktivierter Nachrichtenreihenfolge konfiguriert und Abo B ist ohne aktivierte Nachrichtenreihenfolge konfiguriert. In dieser Architektur erhalten beide Abos A und B denselben Satz von Nachrichten vom Thema T. Wenn Sie Nachrichten mit Sortierungsschlüsseln in derselben Region veröffentlichen, erhält Abo A die Nachrichten in der Reihenfolge, in der sie veröffentlicht wurden. Im Gegensatz dazu empfängt Abo B die Nachrichten ohne erwartete Reihenfolge.

Wenn Publisher-Clients in Ihrer Lösung sowohl geordnete als auch ungeordnete Nachrichten senden müssen, sollten Sie separate Themen erstellen: ein Thema für sortierte Nachrichten und ein anderes für ungeordnete Nachrichten.

Überlegungen bei der Verwendung sortierter Nachrichten

Die folgende Liste enthält wichtige Informationen zum Verhalten von geordneten Nachrichten in Pub/Sub:

• Innerhalb der Schlüsselreihenfolge: Nachrichten, die mit demselben Sortierschlüssel veröffentlicht wurden, werden in der richtigen Reihenfolge empfangen. Nehmen wir an, dass Sie für die Sortierung von Schlüssel A die Nachrichten 1, 2 und 3 veröffentlichen. Wenn die Bestellung aktiviert ist, wird 1 voraussichtlich vor 2 und 2 vor 3 geliefert.

• Schlüsselübergreifende Reihenfolge: Nachrichten, die mit unterschiedlichen Sortierschlüsseln veröffentlicht wurden, gehen normalerweise nicht in der richtigen Reihenfolge ein. Angenommen, Sie haben die Sortierschlüssel A und B. Für den Reihenfolgeschlüssel A werden die Nachrichten 1 und 2 der Reihe nach veröffentlicht. Für die Reihenfolge Schlüssel B werden die Nachrichten 3 und 4 der Reihe nach veröffentlicht. Nachricht 1 könnte jedoch vor oder nach Nachricht 4 ankommen.

• Erneute Übermittlung von Nachrichten: Pub/Sub stellt jede Nachricht mindestens einmal zu. Der Pub/Sub-Dienst stellt daher Nachrichten möglicherweise noch einmal zu. Die erneute Zustellung einer Nachricht löst alle nachfolgenden Nachrichten für diesen Schlüssel aus, einschließlich der bestätigten. Angenommen, ein Abonnentenclient erhält die Nachrichten 1, 2 und 3 für einen bestimmten Reihenfolgeschlüssel. Wenn Nachricht 2 noch einmal zugestellt wird (weil die Bestätigungsfrist abgelaufen ist oder die Best-Effort-Bestätigung in Pub/Sub nicht erhalten geblieben ist), wird Nachricht 3 ebenfalls noch einmal zugestellt. Wenn für ein Abo sowohl die Nachrichtenreihenfolge als auch ein Thema für unzustellbare Nachrichten aktiviert sind, ist dieses Verhalten möglicherweise nicht wahr, da Pub/Sub Nachrichten auf Best-Effort-Basis an Themen für unzustellbare Nachrichten weiterleitet.

• Bestätigungsverzögerungen und Themen für unzustellbare Nachrichten: Nicht bestätigte Nachrichten für einen bestimmten Reihenfolgeschlüssel können die Zustellung von Nachrichten für andere Reihenfolgeschlüssel verzögern, insbesondere bei Serverneustarts oder Traffic-Änderungen. Um die Reihenfolge bei solchen Ereignissen aufrechtzuerhalten, müssen alle Nachrichten rechtzeitig bestätigt werden. Wenn eine zeitnahe Bestätigung nicht möglich ist, sollten Sie ein Thema für unzustellbare Nachrichten verwenden, um eine unbestimmte Aufbewahrung von Nachrichten zu vermeiden. Beachten Sie, dass die Reihenfolge möglicherweise nicht beibehalten wird, wenn Nachrichten in ein Thema für unzustellbare Nachrichten geschrieben werden.

• Nachrichtenaffinität (streamingPull-Clients): Nachrichten für denselben Schlüssel werden normalerweise an denselben StreamingPull-Abonnentenclient zugestellt. Eine Affinität wird erwartet, wenn Nachrichten für einen Reihenfolgeschlüssel für einen bestimmten Abonnentenclient ausstehen. Wenn keine ausstehenden Nachrichten vorhanden sind, kann sich die Affinität für das Load-Balancing oder die Verbindung des Clients verändern.

  Um auch bei potenziellen Affinitätsänderungen eine reibungslose Verarbeitung zu gewährleisten, ist es wichtig, Ihre StreamingPull-Anwendung so zu gestalten, dass sie Nachrichten in jedem Client für einen bestimmten Reihenfolgeschlüssel verarbeiten kann.

• Integration in Dataflow: Aktivieren Sie die Nachrichtenreihenfolge für Abos nicht, wenn Sie Dataflow mit Pub/Sub konfigurieren. Dataflow verfügt über einen eigenen Mechanismus für die Gesamtreihenfolge von Nachrichten, der eine chronologische Reihenfolge über alle Nachrichten als Teil der Windowing-Vorgänge gewährleistet. Diese Sortiermethode unterscheidet sich vom Ansatz in Pub/Sub, der auf Schlüsseln basiert. Die Verwendung von Sortierungsschlüsseln mit Dataflow kann die Pipelineleistung potenziell reduzieren.

• Automatische Skalierung: Die geordnete Bereitstellung von Pub/Sub skaliert auf Milliarden von Sortierschlüsseln. Eine größere Anzahl von Sortierschlüsseln ermöglicht eine parallelere Zustellung an Abonnenten, da die Sortierung für alle Nachrichten mit demselben Sortierungsschlüssel gilt.

Bei einer bestellten Lieferung müssen einige Kompromisse eingehen. Im Vergleich zur ungeordneten Zustellung kann die geordnete Zustellung die Verfügbarkeit der Veröffentlichung geringfügig verringern und die Latenz bei der End-to-End-Nachrichtenzustellung erhöhen. Bei der geordneten Zustellung erfordert der Failover eine Koordination, um sicherzustellen, dass die Nachrichten in der richtigen Reihenfolge geschrieben und gelesen werden.

Weitere Informationen zur Nachrichtensortierung finden Sie in den folgenden Best Practices-Themen:

• Best Practices für geordnete Mitteilungen bei der Veröffentlichung

• Best Practices für geordnete Mitteilungen bei Abos

Verhalten des Abonnentenclients für die Nachrichtenreihenfolge

Abonnentenclients erhalten Nachrichten in der Reihenfolge, in der sie in einer bestimmten Region veröffentlicht wurden. Pub/Sub unterstützt verschiedene Möglichkeiten zum Empfangen von Nachrichten, z. B. Abonnentenclients, die mit Pull- und Push-Abos verbunden sind. Die Clientbibliotheken verwenden StreamingPull (mit Ausnahme von PHP).

Weitere Informationen zu diesen Abotypen finden Sie unter Abotyp auswählen.

In den folgenden Abschnitten wird erläutert, was das Empfangen von Nachrichten für jeden Abonnentenclient-Typ bedeutet.

StreamingPull-Abonnentenclients

Wenn Sie die Clientbibliotheken mit StreamingPull verwenden, müssen Sie einen Nutzer-Callback angeben, der immer dann ausgeführt wird, wenn eine Nachricht von einem Abonnentenclient empfangen wird. Bei Clientbibliotheken wird der Callback für jeden Reihenfolgeschlüssel bis zum Abschluss für Nachrichten in der richtigen Reihenfolge ausgeführt. Wenn die Nachrichten innerhalb dieses Callbacks bestätigt werden, werden alle Berechnungen zu einer Nachricht der Reihe nach ausgeführt. Wenn der Nutzerrückruf jedoch andere asynchrone Arbeiten an Nachrichten plant, muss der Abonnentenclient dafür sorgen, dass die asynchrone Arbeit in der richtigen Reihenfolge ausgeführt wird. Eine Möglichkeit besteht darin, Nachrichten einer lokalen Arbeitswarteschlange hinzuzufügen, die der Reihe nach verarbeitet werden.

Pull-Abonnentenclients

Bei Abonnentenclients, die mit Pull-Abos verbunden sind, unterstützt die Pub/Sub-Nachrichtenreihenfolge Folgendes:

• Alle Nachrichten für einen Sortierungsschlüssel in der PullResponse befinden sich in der richtigen Reihenfolge in der Liste.

• Für einen Sortierungsschlüssel kann jeweils nur ein Nachrichtenstapel ausstehen.

Die Anforderung, dass jeweils nur ein Nachrichtenstapel ausstehend ist, ist für die Aufrechterhaltung einer geordneten Zustellung erforderlich, da der Pub/Sub-Dienst den Erfolg oder die Latenz der Antwort, die er auf die Pull-Anfrage eines Abonnenten sendet, nicht gewährleisten kann.

Push-Abonnentenclients

Die Einschränkungen bei Push sind noch strenger als bei Pull. Bei einem Push-Abo unterstützt Pub/Sub jeweils nur eine ausstehende Nachricht für jeden Bestellschlüssel. Jede Nachricht wird als separate Anfrage an einen Push-Endpunkt gesendet. Das parallele Senden der Anfragen würde also das gleiche Problem verursachen wie das Senden mehrerer Batches von Nachrichten für denselben Reihenfolgeschlüssel, um Abonnenten gleichzeitig abzurufen. Push-Abos sind möglicherweise keine gute Wahl für Themen, in denen Nachrichten häufig mit demselben Reihenfolgeschlüssel veröffentlicht werden oder bei denen die Latenz extrem wichtig ist.

Abonnentenclients exportieren

Beim Exportieren von Abos unterstützen Sie geordnete Nachrichten. Bei BigQuery-Abos werden Nachrichten mit demselben Reihenfolgeschlüssel der Reihe nach in die BigQuery-Tabelle geschrieben. Bei Cloud Storage-Abos werden Nachrichten mit demselben Reihenfolgeschlüssel möglicherweise nicht alle in dieselbe Datei geschrieben. In derselben Datei sind die Nachrichten für einen Reihenfolgeschlüssel geordnet. Bei der Verteilung auf mehrere Dateien können spätere Nachrichten für einen Sortierungsschlüssel in einer Datei mit einem Namen enthalten sein, der einen früheren Zeitstempel als der Zeitstempel der Datei mit den früheren Nachrichten hat.

Nachrichtensortierung aktivieren

Damit die Nachrichten der Reihe nach empfangen werden, legen Sie das Attribut für die Nachrichtenreihenfolge für das Abo fest, über das Sie Nachrichten erhalten. Das Empfangen von Nachrichten der Reihe nach kann die Latenz erhöhen. Sie können die Eigenschaft für die Nachrichtenreihenfolge nach dem Erstellen eines Abos nicht mehr ändern.

Sie können das Attribut für die Nachrichtenreihenfolge festlegen, wenn Sie ein Abo mit der Google Cloud Console, der Google Cloud CLI oder der Pub/Sub API erstellen.

Console

So erstellen Sie ein Abo mit dem Attribut für die Nachrichtenreihenfolge:

1. Öffnen Sie in der Google Cloud Console die Seite Abos.

Zu den Abos

1. Klicken Sie auf Abo erstellen.

2. Geben Sie eine Abo-ID ein.

3. Wählen Sie ein Thema aus, von dem Sie Nachrichten erhalten möchten.

4. Wählen Sie im Abschnitt Nachrichtenreihenfolge die Option Nachrichten mit einem Reihenfolgeschlüssel sortieren aus.

5. Klicken Sie auf Erstellen.

gcloud

Verwenden Sie den Befehl gcloud pubsub subscriptions create und das Flag --enable-message-ordering, um ein Abo mit dem Attribut für die Nachrichtenreihenfolge zu erstellen:

gcloud pubsub subscriptions create SUBSCRIPTION_ID \
  --enable-message-ordering

Ersetzen Sie SUBSCRIPTION_ID durch die ID des Abos.

Wenn die Anfrage erfolgreich ist, wird in der Befehlszeile eine Bestätigung angezeigt:

Created subscription [SUBSCRIPTION_ID].

REST

Senden Sie eine PUT-Anfrage wie die folgende, um ein Abo mit dem Attribut für die Nachrichtenreihenfolge zu erstellen:

PUT https://pubsub.googleapis.com/v1/projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID
Authorization: Bearer $(gcloud auth application-default print-access-token)

Ersetzen Sie Folgendes:

• PROJECT_ID: Projekt-ID des Projekts mit dem Thema
• SUBSCRIPTION_ID: die ID des Abos

Geben Sie im Anfragetext Folgendes an:

{
  "topic": TOPIC_ID,
  "enableMessageOrdering": true,
}

Ersetzen Sie TOPIC_ID durch die ID des Themas, das an das Abo angehängt werden soll.

Wenn die Anfrage erfolgreich ist, ist die Antwort das Lite-Abo im JSON-Format:

{
  "name": projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID,
  "topic": projects/PROJECT_ID/topics/TOPIC_ID,
  "enableMessageOrdering": true,
}

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) {
  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.set_enable_message_ordering(true);
  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 testen, folgen Sie der Einrichtungsanleitung für C# in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C# API.

using Google.Cloud.PubSub.V1;
using Grpc.Core;

public class CreateSubscriptionWithOrderingSample
{
    public Subscription CreateSubscriptionWithOrdering(string projectId, string topicId, string subscriptionId)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        var topicName = TopicName.FromProjectTopic(projectId, topicId);
        var subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);

        var subscriptionRequest = new Subscription
        {
            SubscriptionName = subscriptionName,
            TopicAsTopicName = topicName,
            EnableMessageOrdering = true
        };

        Subscription subscription = null;
        try
        {
            subscription = subscriber.CreateSubscription(subscriptionRequest);
        }
        catch (RpcException e) when (e.Status.StatusCode == StatusCode.AlreadyExists)
        {
            // Already exists.  That's fine.
        }
        return subscription;
    }
}

Einfach loslegen (Go)

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Go in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Go API.

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

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

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

	// Message ordering can only be set when creating a subscription.
	sub, err := client.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
		Topic:                 topic,
		AckDeadline:           20 * time.Second,
		EnableMessageOrdering: true,
	})
	if err != nil {
		return fmt.Errorf("CreateSubscription: %w", err)
	}
	fmt.Fprintf(w, "Created subscription: %v\n", sub)
	return nil
}

Java

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

import com.google.cloud.pubsub.v1.SubscriptionAdminClient;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.ProjectTopicName;
import com.google.pubsub.v1.Subscription;
import java.io.IOException;

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

    createSubscriptionWithOrderingExample(projectId, topicId, subscriptionId);
  }

  public static void createSubscriptionWithOrderingExample(
      String projectId, String topicId, String subscriptionId) throws IOException {
    try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {

      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);

      Subscription subscription =
          subscriptionAdminClient.createSubscription(
              Subscription.newBuilder()
                  .setName(subscriptionName.toString())
                  .setTopic(topicName.toString())
                  // Set message ordering to true for ordered messages in the subscription.
                  .setEnableMessageOrdering(true)
                  .build());

      System.out.println("Created a subscription with ordering: " + subscription.getAllFields());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für PHP in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Node.js API.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// 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 createSubscriptionWithOrdering(
  topicNameOrId,
  subscriptionNameOrId
) {
  // Creates a new subscription
  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, {
      enableMessageOrdering: true,
    });
  console.log(
    `Created subscription ${subscriptionNameOrId} with ordering enabled.`
  );
  console.log(
    'To process messages in order, remember to add an ordering key to your messages.'
  );
}

Node.js

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für PHP in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Node.js API.

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

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

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

async function createSubscriptionWithOrdering(
  topicNameOrId: string,
  subscriptionNameOrId: string
) {
  // Creates a new subscription
  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, {
      enableMessageOrdering: true,
    });
  console.log(
    `Created subscription ${subscriptionNameOrId} with ordering enabled.`
  );
  console.log(
    'To process messages in order, remember to add an ordering key to your messages.'
  );
}

Python

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Python in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Python API.

from google.cloud import pubsub_v1

# TODO(developer): Choose an existing topic.
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"

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)

with subscriber:
    subscription = subscriber.create_subscription(
        request={
            "name": subscription_path,
            "topic": topic_path,
            "enable_message_ordering": True,
        }
    )
    print(f"Created subscription with ordering: {subscription}")

Ruby

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Ruby in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Ruby API.

# topic_id        = "your-topic-id"
# subscription_id = "your-subscription-id"

pubsub = Google::Cloud::Pubsub.new

topic        = pubsub.topic topic_id
subscription = topic.subscribe subscription_id,
                               message_ordering: true

puts "Pull subscription #{subscription_id} created with message ordering."

Nächste Schritte

• Lesen Sie den Blogpost zur bestellbaren Lieferung.

• Informationen zum Veröffentlichen von Nachrichten bei Fehlern, die nicht wiederholt werden können, finden Sie unter Anfragen mit Reihenfolgeschlüsseln wiederholen.

• Abo im Blick behalten

• Weitere Informationen zum Veröffentlichen von Nachrichten mit Sortierschlüsseln