Nachrichten in eine Reihenfolge bringen

Die Nachrichtenreihenfolge ist ein Feature in Pub/Sub, mit dem Sie Nachrichten in Ihren Abonnentenclients in der Reihenfolge empfangen können, 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 in dieser Reihenfolge. Bei der Nachrichtenreihenfolge empfängt der Abonnentenclient die veröffentlichten Nachrichten in derselben Reihenfolge. Damit die Nachrichten in der richtigen Reihenfolge zugestellt werden, muss der Publisher-Client sie in derselben Region veröffentlichen. Abonnenten können sich jedoch mit jeder Region verbinden und die Bestellgarantie bleibt weiterhin bestehen.

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

Auf dieser Seite wird das Konzept der Nachrichtenreihenfolge erläutert und beschrieben, wie Sie Ihre Abonnentenclients so einrichten, dass sie Nachrichten in der richtigen Reihenfolge empfangen. Informationen zum Konfigurieren Ihrer Publisher-Clients für die Nachrichtenreihenfolge finden Sie unter Sortierungsschlüssel verwenden, um eine Nachricht zu veröffentlichen.

Nachrichtenreihenfolge – Übersicht

Die Reihenfolge in Pub/Sub wird durch Folgendes bestimmt:

  • Bestellschlüssel: Ein Reihenfolgeschlüssel ist ein String, der zusammengehörige Nachrichten identifiziert, die sortiert werden sollen. Beispiele für Sortierschlüssel sind Kunden-IDs oder der Primärschlüssel einer Zeile in einer Datenbank. Ein Sortierschlüssel kann bis zu 1 KB lang sein.

    Wenn Sie die Nachrichtenreihenfolge erzielen möchten, legen Sie für alle zugehörigen Nachrichten, die in der richtigen Reihenfolge empfangen werden sollen, denselben Reihenfolgeschlüssel fest. Außerdem müssen Sie alle Nachrichten mit demselben Reihenfolgeschlüssel in derselben Region veröffentlichen. Weitere Informationen finden Sie unter Sortierungsschlüssel verwenden, um eine Nachricht zu veröffentlichen.

    Nachrichten mit einem leeren Reihenfolgeschlüssel werden nicht sortiert.

  • Nachrichtenreihenfolge aktivieren. Damit Sie Nachrichten in der richtigen Reihenfolge erhalten, müssen Sie die Nachrichtenreihenfolge im Abo aktivieren. Weitere Informationen finden Sie unter Nachrichtenreihenfolge aktivieren.

    Wenn die Nachrichtenreihenfolge nicht aktiviert ist, werden Nachrichten für ein Abo ohne erwartete Reihenfolge empfangen. Angenommen, die Abos A und B sind beide dem Thema T zugeordnet und die Bestellung ist im Abo A, aber nicht im Abo B aktiviert. Obwohl beide Abos dieselben Nachrichten aus dem Thema T empfangen, wird die Reihenfolge nur für das Abo A beibehalten.

Der Veröffentlichungsdurchsatz für jeden Bestellschlüssel ist auf 1 MB/s begrenzt. Der Durchsatz für alle Bestellschlüssel zu einem Thema ist auf das Kontingent beschränkt, das in einer Veröffentlichungsregion verfügbar ist. Dieses Limit kann auf mehrere Gbit/s erhöht werden.

Wenn für Ihre Lösung Publisher-Clients erforderlich sind, die sowohl geordnete als auch ungeordnete Nachrichten senden, sollten Sie im Allgemeinen separate Themen erstellen, eines für geordnete und eines für ungeordnete Nachrichten.

Überlegungen bei der Verwendung von geordneten Nachrichten

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

  • Kardinalität Ein Sortierschlüssel entspricht nicht einer Partition in einem partitionsbasierten Messaging-System, da Sortierschlüssel eine viel höhere Kardinalität als Partitionen haben.

  • Sortierung innerhalb des Schlüssels: Nachrichten, die mit demselben Reihenfolgeschlüssel veröffentlicht werden, sollten in der richtigen Reihenfolge empfangen werden. Angenommen, Sie veröffentlichen die Nachrichten 1, 2 und 3 für den Sortierungsschlüssel A. Wenn die Bestellung aktiviert ist, wird erwartet, dass 1 vor 2 und 2 vor 3 geliefert wird.

  • Schlüsselübergreifende Sortierung: Nachrichten, die mit unterschiedlichen Reihenfolgeschlüsseln veröffentlicht werden, werden nicht in der Reihenfolge ihrer Veröffentlichung empfangen. Angenommen, Sie haben die Sortierschlüssel A und B. Bei Reihenfolgeschlüssel A werden die Nachrichten 1 und 2 in der richtigen Reihenfolge veröffentlicht. Für den Bestellschlüssel B werden die Nachrichten 3 und 4 in der richtigen Reihenfolge veröffentlicht. Nachricht 1 kann jedoch vor oder nach Nachricht 4 eintreffen.

  • Erneute Nachrichtenzustellung: Pub/Sub stellt jede Nachricht mindestens einmal zu. Der Pub/Sub-Dienst kann Nachrichten also noch einmal zustellen. Durch die erneute Zustellung einer Nachricht wird die erneute Zustellung aller nachfolgenden Nachrichten für diesen Schlüssel ausgelöst, auch der bestätigten. Angenommen, ein Abonnentenclient empfängt die Nachrichten 1, 2 und 3 für einen bestimmten Sortierschlüssel. Wenn Nachricht 2 noch einmal gesendet wird (weil die Bestätigungsfrist abgelaufen ist oder die Best-Effort-Bestätigung in Pub/Sub nicht beibehalten wurde), wird auch Nachricht 3 noch einmal gesendet. Wenn sowohl die Nachrichtenreihenfolge als auch ein Thema für unzustellbare Nachrichten für ein Abo aktiviert sind, gilt dieses Verhalten möglicherweise nicht, da Pub/Sub Nachrichten nach bestem Wissen und Gewissen an Themen für unzustellbare Nachrichten weiterleitet.

  • Verzögerungen bei Bestätigungen und Themen für unzustellbare Nachrichten: Nicht bestätigte Nachrichten für einen bestimmten Sortierschlüssel können die Zustellung von Nachrichten für andere Sortierschlüssel verzögern, insbesondere bei Serverneustarts oder Änderungen des Traffics. Um bei solchen Ereignissen für Ordnung zu sorgen, sollten Sie alle Nachrichten rechtzeitig bestätigen. Wenn eine rechtzeitige Bestätigung nicht möglich ist, sollten Sie ein Thema für unzustellbare Nachrichten verwenden, um zu verhindern, dass Nachrichten unbegrenzt lange zurückgehalten werden. 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 in der Regel an denselben streamingPull-Abonnentenclient gesendet. Affinität wird erwartet, wenn Nachrichten für einen Bestellschlüssel für einen bestimmten Abonnentenclient ausstehen. Wenn keine ausstehenden Nachrichten vorhanden sind, kann sich die Affinität aufgrund von Load Balancing oder Clientverbindungsunterbrechungen ändern.

    Damit die Verarbeitung auch bei potenziellen Änderungen der Affinität reibungslos abläuft, ist es wichtig, dass Ihre streamingPull-Anwendung so konzipiert ist, dass sie Nachrichten in jedem Client für einen bestimmten Sortierschlüssel verarbeiten kann.

  • Integration in Dataflow: Aktivieren Sie die Nachrichtenreihenfolge für Abos nicht, wenn Sie Dataflow mit Pub/Sub konfigurieren. Dataflow hat einen eigenen Mechanismus für die vollständige Nachrichtenreihenfolge, der im Rahmen von Fensterungsvorgängen für die chronologische Reihenfolge aller Nachrichten sorgt. Diese Methode der Sortierung unterscheidet sich vom schlüsselbasierten Ansatz von Pub/Sub. Die Verwendung von Sortierschlüsseln mit Dataflow kann die Pipelineleistung beeinträchtigen.

  • Automatische Skalierung: Die geordnete Zustellung von Pub/Sub lässt sich auf Milliarden von Sortierschlüsseln skalieren. Eine größere Anzahl von Reihenfolgeschlüsseln ermöglicht eine parallele Zustellung an Abonnenten, da die Reihenfolge für alle Nachrichten mit demselben Reihenfolgeschlüssel gilt.

  • Kompromisse bei der Leistung: Die geordnete Zustellung bringt einige Kompromisse mit sich. Im Vergleich zur ungeordneten Zustellung verringert die geordnete Zustellung die Verfügbarkeit von Veröffentlichungen und erhöht die End-to-End-Latenz bei der Nachrichtenübermittlung. Im Fall einer geordneten Zustellung ist für das Failover eine Koordination erforderlich, damit die Nachrichten in der richtigen Reihenfolge geschrieben und gelesen werden.

  • Hot Key: Bei Verwendung der Nachrichtenreihenfolge werden alle Nachrichten mit demselben Reihenfolgeschlüssel in der Reihenfolge, in der sie vom Dienst empfangen werden, an den Abonnentenclient gesendet. Der Nutzer-Callback wird erst ausgeführt, wenn der Callback für die vorherige Nachricht abgeschlossen ist. Der maximale Durchsatz für Nachrichten mit demselben Reihenfolgeschlüssel bei der Zustellung an Abonnenten wird nicht durch Pub/Sub , sondern durch die Verarbeitungsgeschwindigkeit des Abonnentenclients begrenzt. Ein Hotkey tritt auf, wenn sich auf einem einzelnen Bestellschlüssel ein Backlog bildet, weil die Anzahl der pro Sekunde erstellten Nachrichten die Anzahl der Nachrichten überschreitet, die der Abonnent pro Sekunde verarbeiten kann. Um Hotkeys zu vermeiden, sollten Sie die detailliertesten verfügbaren Schlüssel verwenden und die Verarbeitungszeit pro Nachricht minimieren. Sie können auch den Messwert subscription/oldest_unacked_message_age auf einen steigenden Wert hin beobachten, der auf einen Hotkey hindeuten könnte.

Weitere Informationen zur Verwendung der Nachrichtenreihenfolge finden Sie in den folgenden Best Practices:

Verhalten von Abonnentenclients bei der Nachrichtenreihenfolge

Abonnentenclients empfangen 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 der Empfang von Nachrichten in der richtigen Reihenfolge für die einzelnen Arten von Abonnentenclients 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 einen bestimmten Bestellschlüssel für Nachrichten in der richtigen Reihenfolge ausgeführt. Wenn die Nachrichten in diesem Callback bestätigt werden, erfolgen alle Berechnungen für eine Nachricht in der richtigen Reihenfolge. Wenn der Nutzer-Callback jedoch andere asynchrone Vorgänge für Nachrichten plant, muss der Abonnentenclient dafür sorgen, dass die asynchronen Vorgänge in der richtigen Reihenfolge ausgeführt werden. Eine Möglichkeit besteht darin, Nachrichten einer lokalen Arbeitswarteschlange hinzuzufügen, die der Reihe nach verarbeitet wird.

Abonnentenclients abrufen

Für Abonnentenclients, die mit Pull-Abos verbunden sind, wird die Reihenfolge von Pub/Sub-Nachrichten in folgenden Fällen unterstützt:

  • Alle Nachrichten für einen Bestellschlüssel in der PullResponse sind in der richtigen Reihenfolge in der Liste.

  • Es kann jeweils nur ein Batch von Nachrichten für einen Bestellschlüssel ausstehend sein.

Die Anforderung, dass jeweils nur ein Batch von Nachrichten ausstehend sein darf, ist erforderlich, um die geordnete Zustellung aufrechtzuerhalten, da der Pub/Sub-Dienst den Erfolg oder die Latenz der Antwort, die er für die Pull-Anfrage eines Abonnenten sendet, nicht garantieren kann.

Push-Abonnentenclients

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

Abonnenten-Clients exportieren

Beim Export von Abos werden geordnete Nachrichten unterstützt. Bei BigQuery-Abos werden Nachrichten mit demselben Reihenfolgeschlüssel in der Reihenfolge in ihre BigQuery-Tabelle geschrieben. Bei Cloud Storage-Abos werden Nachrichten mit demselben Reihenfolgeschlüssel möglicherweise nicht alle in dieselbe Datei geschrieben. Innerhalb derselben Datei sind Nachrichten für einen Reihenfolgeschlüssel in der richtigen Reihenfolge. Wenn sie auf mehrere Dateien verteilt sind, können spätere Nachrichten für einen Bestellschlüssel in einer Datei mit einem Namen angezeigt werden, der einen früheren Zeitstempel als der Zeitstempel im Namen der Datei mit den früheren Nachrichten hat.

Nachrichtenreihenfolge 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. Nachdem Sie ein Abo erstellt haben, können Sie die Property für die Nachrichtenreihenfolge nicht mehr ändern.

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

Console

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

  1. Rufen Sie in der Google Cloud Console die Seite Abos auf.

Zu den Abos

  1. Klicken Sie auf Abo erstellen.

  2. Geben Sie eine Abo-ID ein.

  3. Wählen Sie ein Thema aus, zu 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 der Eigenschaft 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 der Eigenschaft 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 Pub/Sub C++ API-Referenzdokumentation. 

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

Go

Im folgenden Beispiel wird die Hauptversion der Go Pub/Sub-Clientbibliothek (v2) verwendet. Wenn Sie noch die v1-Bibliothek verwenden, finden Sie hier die Migrationsanleitung zu v2. Eine Liste der Codebeispiele für Version 1 finden Sie unter Eingestellte Codebeispiele.

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Go-Einrichtungsanleitung in der Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Go API.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub/v2"
	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
)

func createWithOrdering(w io.Writer, projectID, topic, subscription string) error {
	// projectID := "my-project-id"
	// topic := "projects/my-project-id/topics/my-topic"
	// subscription := "projects/my-project/subscriptions/my-sub"
	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.SubscriptionAdminClient.CreateSubscription(ctx, &pubsubpb.Subscription{
		Name:                  subscription,
		Topic:                 topic,
		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

Im folgenden Beispiel wird die Ruby Pub/Sub-Clientbibliothek v3 verwendet. Wenn Sie noch die v2-Bibliothek verwenden, finden Sie hier die Migrationsanleitung für v3. Eine Liste der Ruby v2-Codebeispiele finden Sie unter eingestellte Codebeispiele.

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Anleitung zur Einrichtung von Ruby in der Kurzanleitung zur Verwendung von Clientbibliotheken. 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
subscription_admin = pubsub.subscription_admin

subscription = subscription_admin.create_subscription \
  name: pubsub.subscription_path(subscription_id),
  topic: pubsub.topic_path(topic_id),
  enable_message_ordering: true

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

Rust

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Rust in der Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Pub/Sub Rust API-Referenzdokumentation. 

use google_cloud_pubsub::client::SubscriptionAdmin;

pub async fn sample(
    client: &SubscriptionAdmin,
    project_id: &str,
    topic_id: &str,
    subscription_id: &str,
) -> anyhow::Result<()> {
    let subscription_name = format!("projects/{project_id}/subscriptions/{subscription_id}");
    let topic_name = format!("projects/{project_id}/topics/{topic_id}");

    let subscription = client
        .create_subscription()
        .set_name(subscription_name)
        .set_topic(topic_name)
        .set_enable_message_ordering(true)
        .send()
        .await?;

    println!("successfully created subscription {subscription:?}");
    Ok(())
}

Nächste Schritte