Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Ordena mensajes

En esta página, se explica cómo recibir mensajes en orden.

Si deseas obtener más información sobre cómo recibir mensajes, consulta la descripción general de los suscriptores.

Recibe mensajes en orden

Si los mensajes tienen la misma clave de ordenamiento y están en la misma región, puedes habilitar el orden de los mensajes y recibirlos en el orden en que el servicio Pub/Sub las recibe.

Pub/Sub entrega cada mensaje al menos una vez, por lo que el servicio de Pub/Sub podría volver a entregarlos. Cuando recibes mensajes en orden y el servicio de Pub/Sub vuelve a entregar un mensaje con una clave de ordenamiento, Pub/Sub mantiene el orden y vuelve a entregar los mensajes posteriores con la misma clave de ordenamiento. El servicio Pub/Sub vuelve a enviar estos mensajes en el orden en que los recibió de forma original.

Cuando el servicio de Pub/Sub vuelve a enviar un mensaje con una clave de ordenamiento, el servicio de Pub/Sub también vuelve a entregar todos los mensajes posteriores con la misma clave de ordenamiento, incluidos los mensajes con confirmación de recepción. Vuelve a confirmar la recepción de estos mensajes.

Habilita el ordenamiento de mensajes

Para recibir los mensajes en orden, configura la propiedad de ordenamiento de mensajes de la suscripción de la que recibes mensajes. Recibir mensajes en orden puede aumentar la latencia.

Puedes configurar la propiedad de orden de los mensajes cuando creas una suscripción con Cloud Console, la herramienta de línea de comandos de gcloud o la API de Pub/Sub.

Console

Para crear una suscripción con la propiedad de ordenamiento de mensajes, sigue estos pasos:

  1. En Cloud Console, ve a la página Suscripciones.

    Ir a la página Suscripciones

  2. Haz clic en Crear suscripción.

  3. Ingresa un ID de suscripción.

  4. Elige un tema para recibir mensajes de él.

  5. En la sección Ordenamiento de mensajes, selecciona Ordenar mensajes con una clave de ordenamiento.

  6. Haga clic en Crear.

gcloud

Para crear una suscripción con la propiedad de ordenamiento de mensajes, usa el comando gcloud pubsub subscriptions create y la marca --enable-message-ordering:

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

Reemplaza SUBSCRIPTION_ID por el ID de la suscripción.

Si la solicitud es exitosa, la línea de comandos muestra una confirmación:

Created subscription [SUBSCRIPTION_ID].

REST

Para crear una suscripción con la propiedad de ordenamiento de mensajes, envía una solicitud PUT como la siguiente:

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

Reemplaza lo siguiente:

  • PROJECT_ID: El ID del proyecto con el tema
  • SUBSCRIPTION_ID: El ID de la suscripción

Especifica lo siguiente en el cuerpo de la solicitud:

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

Reemplaza TOPIC_ID por el ID del tema que deseas adjuntar a la suscripción.

Si la solicitud se realiza de forma correcta, la respuesta es la suscripción en formato JSON:

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

C++

Antes de probar esta muestra, sigue las instrucciones de configuración de C++ en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para C++. 

namespace pubsub = google::cloud::pubsub;
[](pubsub::SubscriptionAdminClient client, std::string const& project_id,
   std::string const& topic_id, std::string const& subscription_id) {
  auto sub = client.CreateSubscription(
      pubsub::Topic(project_id, std::move(topic_id)),
      pubsub::Subscription(project_id, std::move(subscription_id)),
      pubsub::SubscriptionBuilder{}.enable_message_ordering(true));
  if (sub.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The subscription already exists\n";
    return;
  }
  if (!sub) throw std::runtime_error(sub.status().message());

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

C#

Antes de probar esta muestra, sigue las instrucciones de configuración de C# en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para C#. 


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

public class CreateSubscriptionWithOrderingSample
{
    public Subscription CreateSubscriptionWithOrdering(string projectId, string subscriptionId, string topicId)
    {
        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

Antes de probar esta muestra, sigue las instrucciones de configuración de Go en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Go. 

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: %v", err)
	}

	// 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: %v", err)
	}
	fmt.Fprintf(w, "Created subscription: %v\n", sub)
	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Java. 

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

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Node.js. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicName = 'YOUR_TOPIC_NAME';
// const subscriptionName = 'YOUR_SUBSCRIPTION_NAME';

// 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() {
  // Creates a new subscription
  await pubSubClient.topic(topicName).createSubscription(subscriptionName, {
    enableMessageOrdering: true,
  });
  console.log(
    `Created subscription ${subscriptionName} with ordering enabled.`
  );
  console.log(
    'To process messages in order, remember to add an ordering key to your messages.'
  );
}

createSubscriptionWithOrdering().catch(console.error);

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Python. 

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

Antes de probar esta muestra, sigue las instrucciones de configuración de Ruby en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Ruby. 

# topic_name        = "Your Pubsub topic name"
# subscription_name = "Your Pubsub subscription name"
require "google/cloud/pubsub"

pubsub = Google::Cloud::Pubsub.new

topic        = pubsub.topic topic_name
subscription = topic.subscribe subscription_name,
                               message_ordering: true

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

Una vez que se configura la propiedad de ordenamiento de mensajes, el servicio de Pub/Sub entrega mensajes con la misma clave de ordenamiento en el orden en que el servicio de Pub/Sub recibe los mensajes. Por ejemplo, si un publicador envía dos mensajes con la misma clave de ordenamiento, el servicio de Pub/Sub entrega primero el mensaje más antiguo.