订购消息

消息排序是 Pub/Sub 中的一项功能，可让您按照发布者客户端发布消息的顺序在订阅者客户端中接收消息。

例如，假设某个区域中的发布者客户端按顺序发布消息 1、2 和 3。通过消息排序，订阅者客户端以相同顺序接收发布的消息。如需按顺序传送，发布者客户端必须在同一区域中发布消息。

对于数据库变更捕获、用户会话跟踪和流式应用等场景，消息排序是一项实用功能，在这些场景中，保留事件年表非常重要。

本页面介绍了消息排序的概念，以及如何设置订阅者客户端以按顺序接收消息。如需为消息排序配置发布者客户端，请参阅使用排序键发布消息。

消息排序概览

Pub/Sub 中的排序由以下因素确定：

  • 排序键：这是 Pub/Sub 消息元数据中使用的字符串，表示必须为消息排序的实体。排序键不得超过 1 KB。如需接收某个区域中的一组有序消息，您必须在同一区域中发布具有相同排序键的所有消息。排序键的一些示例包括客户 ID 和数据库中某一行的主键。

    每个排序键的发布吞吐量上限为 1 MBps。主题上所有排序键的吞吐量不得超过发布区域中可用的配额。此限制可增加到许多 GBps 的单位。

    在基于分区的消息传递系统中，排序键并不等同于分区，因为排序键的基数应比分区高得多。

  • 启用消息排序：这是一项订阅设置。如果订阅启用了消息排序功能，订阅者客户端将按服务收到消息的顺序，使用同一排序键接收在同一区域中发布的消息。您必须在订阅中启用此设置。

    假设您有两个订阅 A 和 B 连接到同一主题 T。订阅 A 配置为启用消息排序，订阅 B 配置为未启用消息排序。在此架构中，订阅 A 和订阅 B 都从主题 T 接收同一组消息。如果您在同一区域中发布带有排序键的消息，则订阅 A 会按发布顺序接收消息。而订阅 B 收到的消息不会进行任何排序。

一般来说，如果您的解决方案要求发布者客户端同时发送有序消息和无序消息，请创建单独的主题，一个针对有序消息，另一个针对无序消息。

使用有序消息传递时的注意事项

以下列表包含有关 Pub/Sub 中有序消息传递的行为的重要信息：

  • 键内排序：应按顺序接收具有相同排序键发布的消息。假设在对键 A 进行排序时，您发布了消息 1、2 和 3。启用订购功能后，1 的预计送达日期为 2 之前，2 的预计送达时间在 3 之前。

  • 跨键排序：使用不同的排序键发布的消息预计不会按顺序接收。假设您有排序键 A 和 B。对于排序键 A，消息 1 和 2 将按顺序发布。对于排序键 B，消息 3 和 4 将按顺序发布。但是，消息 1 可能会在消息 4 之前或之后到达。

  • 消息重新传送：Pub/Sub 将每条消息至少传送一次，因此 Pub/Sub 服务可能会重新传送消息。重新提交消息会触发重新提交该键的所有后续消息，即使是已确认的消息。假设订阅者客户端接收特定排序键的消息 1、2 和 3。如果消息 2 再次传送（由于确认截止期限已过，或尽最大努力确认在 Pub/Sub 中未保留），则消息 3 也会重新提交。如果对订阅启用了消息排序和死信主题，则此行为可能并非如此，因为 Pub/Sub 会尽最大努力将消息转发到死信主题。

  • 确认延迟和死信主题：给定排序键的未确认消息可能会延迟其他排序键的消息传送，尤其是在服务器重启或流量更改期间。为了保持此类事件的顺序，请确保及时确认所有消息。如果无法及时确认，请考虑使用死信主题以防止无限期保留消息。请注意，将消息写入死信主题时，系统可能不会保留顺序。

  • 消息亲和性（streamingPull 客户端）：相同密钥的消息通常会传送到同一个 streamingPull 订阅者客户端。当发送给特定订阅者客户端的排序键的消息未完成时，应显示亲和性。如果没有未完成的消息，亲和性可能会因为负载均衡或客户端断开连接而转移。

    为了确保即使发生潜在的亲和性更改，也能顺畅处理，在设计 streamPull 应用时，请务必使应用能够处理任何客户端中给定排序键的消息。

  • 与 Dataflow 集成：在使用 Pub/Sub 配置 Dataflow 时，请勿为订阅启用消息排序。Dataflow 拥有自己的消息总排序机制，可在窗口操作过程中确保所有消息按时间顺序排列。这种排序方法与 Pub/Sub 基于键的排序方法不同。将排序键与 Dataflow 搭配使用可能会降低流水线性能。

  • 自动伸缩：Pub/Sub 的有序传送可扩容至数十亿个排序键。排序键越多，向订阅者越平行地传送内容，因为排序适用于所有具有相同排序键的消息。

不过，下单配送需要做出一些取舍。与无序传送相比，有序传送可能会略微降低发布可用性并增加端到端消息传送延迟时间。在有序传送的情况下，故障切换需要协调，以确保按正确的顺序写入和读取消息。

如需详细了解如何使用消息排序，请参阅以下最佳做法主题：

用于消息排序的订阅者客户端行为

订阅者客户端会按照消息在特定区域中发布的顺序接收消息。Pub/Sub 支持不同的消息接收方式，例如连接到拉取和推送订阅的订阅者客户端。客户端库使用 streamPull（PHP 除外）。

如需详细了解这些订阅类型，请参阅选择订阅类型。

以下各部分按顺序讨论了接收消息对于每种类型的订阅者客户端来说意味着什么。

StreamingPull 订阅者客户端

将客户端库与 streamPull 搭配使用时，您必须指定一个用户回调，该回调会在订阅者客户端收到消息时运行。使用客户端库时，对于任何给定的排序键，回调都会按正确顺序运行以完成消息。如果消息在该回调中得到确认，则对消息的所有计算将按顺序进行。但是，如果用户回调在消息上安排其他异步工作，则订阅者客户端必须确保异步工作按顺序完成。一种方案是将消息添加到按顺序处理的本地工作队列中。

拉取订阅者客户端

对于连接到拉取订阅的订阅者客户端，Pub/Sub 消息排序支持以下各项：

  • PullResponse 中某个排序键的所有消息在列表中均按正确的顺序排列。

  • 对于一个排序键，一次只能发出一批消息。

为了保持有序传送，必须一次只有一批消息可以发出，因为 Pub/Sub 服务无法保证它针对订阅者的拉取请求发送的响应是否成功或延迟时间。

推送订阅者客户端

推送方面的限制比拉取的限制更为严格。 对于推送订阅，Pub/Sub 一次仅支持每个排序键有一条未完成消息。每条消息都会作为单独的请求发送到推送端点。因此，并行发送请求与针对同一排序键传送多批消息以同时拉取订阅者的问题相同。对于频繁使用相同的排序键发布消息或对延迟极为重要的主题，推送订阅可能不是理想的选择。

导出订阅者客户端

导出订阅支持有序消息。对于 BigQuery 订阅，具有相同排序键的消息会按顺序写入其 BigQuery 表。对于 Cloud Storage 订阅，具有相同排序键的消息可能不会全部写入同一个文件。在同一个文件中时，排序键的消息是按顺序排列的。当分布在多个文件中时，某个排序键的较晚消息可能会出现在名称中，且时间戳早于包含较早消息的文件的名称中的时间戳。

启用消息排序

要按顺序接收消息，请在从中接收消息的订阅上设置消息排序属性。按顺序接收消息可能会增加延迟时间。创建订阅后，您将无法更改消息排序属性。

使用 Google Cloud 控制台、Google Cloud CLI 或 Pub/Sub API 创建订阅时，您可以设置消息排序属性。

控制台

要使用消息排序属性创建订阅，请执行以下操作：

  1. 在 Google Cloud 控制台中，进入订阅页面。

前往订阅页面

  1. 点击创建订阅。

  2. 输入订阅 ID。

  3. 选择要从中接收消息的主题。

  4. 在消息排序部分，选择使用排序键对消息排序。

  5. 点击创建。

gcloud

如需使用消息排序属性创建订阅，请使用 gcloud pubsub subscriptions create 命令和 --enable-message-ordering 标志：

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

将 SUBSCRIPTION_ID 替换为订阅的 ID。

如果请求成功，命令行会显示一条确认消息：

Created subscription [SUBSCRIPTION_ID].

REST

如需使用消息排序属性创建订阅，请发送如下所示的 PUT 请求：

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

替换以下内容：

  • PROJECT_ID：包含主题的项目的 ID
  • SUBSCRIPTION_ID：订阅的 ID

在请求正文中，指定以下内容：

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

将 TOPIC_ID 替换为要附加到订阅的主题的 ID。

如果请求成功，则响应为 JSON 格式的订阅：

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

C++

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 C++ 设置说明进行操作。如需了解详情，请参阅 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#

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 C# 设置说明进行操作。 如需了解详情，请参阅 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

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 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

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 Java 设置说明进行操作。 如需了解详情，请参阅 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

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 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

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 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

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 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

在尝试此示例之前，请按照《快速入门：使用客户端库》中的 Ruby 设置说明进行操作。 如需了解详情，请参阅 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."

后续步骤