Exporta mensajes de Pub/Sub Lite a Pub/Sub

En este documento, se describe cómo configurar la exportación automática de mensajes de Pub/Sub Lite a Pub/Sub.

Estas son algunas situaciones en las que puedes usar esta función:

• Interopera entre cargas de trabajo que usan una combinación de Pub/Sub Lite y Pub/Sub.
• Migra una carga de trabajo de Pub/Sub Lite a Pub/Sub.
• Usar funciones avanzadas de Pub/Sub, como suscripciones de envío y filtros, desde una aplicación existente que se base en Pub/Sub Lite
• Consolida varias canalizaciones de datos.

Descripción general

Para exportar mensajes de Pub/Sub Lite a Pub/Sub, debes crear un tipo especial de suscripción llamada suscripción de exportación. Una suscripción de exportación recibe mensajes de un tema Lite, los convierte en mensajes de Pub/Sub y los envía a un tema de Pub/Sub de destino.

Un tema Lite puede tener una combinación de suscripciones estándar y de exportación. Los dos tipos de suscripción son idénticos en términos de uso de la cuota y cantidad de reservas por segundo. Una suscripción de exportación consume la capacidad de procesamiento de las suscripciones a Lite y se le cobra por la capacidad de procesamiento de publicación de Pub/Sub.

Una suscripción de exportación conecta un tema de Lite a un tema de Pub/Sub exactamente. Sin embargo, un tema Lite puede tener varias suscripciones de exportación que se conectan a diferentes temas de Pub/Sub (arquitectura de fan-out). También puedes exportar desde varios temas de Lite al mismo tema de Pub/Sub (arquitectura de convergencia).

Autenticación

Una suscripción de exportación accede a los recursos de Pub/Sub Lite y de Pub/Sub. Para crear una suscripción de exportación, necesitas los siguientes permisos:

• pubsublite.subscriptions.create. Los siguientes roles predefinidos contienen este permiso:

  • roles/pubsublite.admin
  • roles/pubsublite.editor

  Consulta Control de acceso de Pub/Sub Lite.

• pubsub.topics.get. Los siguientes roles predefinidos contienen este permiso:

  • roles/pubsub.admin
  • roles/pubsub.editor
  • roles/pubsub.viewer

  Consulta Control de acceso de Pub/Sub.

Agentes de servicio

Una suscripción de exportación publica en un tema de Pub/Sub en tu nombre. Para ello, usa un agente de servicio.

Después de crear la primera suscripción de exportación en un proyecto, se crea automáticamente un agente de servicio de Pub/Sub Lite. Si creas suscripciones de exportación adicionales en el mismo proyecto, estas usarán el mismo agente de servicio. El agente de servicio tiene el siguiente esquema de nombres: service-<your_project_number>@gcp-sa-pubsublite.iam.gserviceaccount.com.

El agente de servicio se crea con permisos para publicar en todos los temas de Pub/Sub y Pub/Sub Lite dentro del mismo proyecto que la suscripción de exportación. Si tu tema de Pub/Sub de destino se encuentra en un proyecto diferente al de la suscripción de exportación, debes otorgarle permisos adicionales al agente de servicio. Para ello, agrega el rol de publicador de Pub/Sub (roles/pubsub.publisher). Puedes otorgar permisos para un proyecto completo o un tema individual. Te recomendamos que otorgues permisos a nivel del tema, según el principio de privilegio mínimo.

Para obtener más información, consulta Controla el acceso a través de la consola de Google Cloud. También puedes usar el comando gcloud projects add-iam-policy-binding para agregar roles de IAM:

gcloud pubsub topics add-iam-policy-binding TOPIC_NAME \
 --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsublite.iam.gserviceaccount.com
 --role=roles/pubsub.publisher

Reemplaza lo siguiente:

• TOPIC_NAME: Es el nombre del tema de Pub/Sub de destino para agregar la vinculación de políticas de IAM.
• PROJECT_NUMBER: Es el número de proyecto del proyecto de la suscripción a la exportación de Pub/Sub Lite.

Crea una suscripción de exportación

Puedes crear una suscripción de exportación Lite con la consola de Google Cloud, Google Cloud CLI o la API de Pub/Sub Lite.

Una suscripción a la exportación de Lite debe estar en el mismo proyecto y la misma ubicación que el tema de Lite al que está vinculada. Para crear el tema de Lite, consulta Crear y administrar temas de Lite.

Si adjuntas una suscripción de exportación a un tema de Lite, asegúrate de que todos los mensajes publicados en el tema de Lite sean compatibles con Pub/Sub. Para obtener más información, consulta Compatibilidad de mensajes.

Una vez que se crea, no puedes cambiar una suscripción de exportación a una suscripción estándar ni viceversa.

gcloud pubsub lite-subscriptions create SUBSCRIPTION_ID \
  --location=LOCATION \
  --topic=TOPIC_ID \
  --export-pubsub-topic=PUBSUB_TOPIC_NAME \
  --export-dead-letter-topic=DEAD_LETTER_TOPIC_ID \
  --export-desired-state=DESIRED_STATE

Created [SUBSCRIPTION_ID].

POST https://REGION-pubsublite.googleapis.com/v1/admin/projects/PROJECT_NUMBER/locations/LOCATION/subscriptions/SUBSCRIPTION_ID
Authorization: Bearer $(gcloud auth print-access-token)

{
  "topic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/TOPIC_ID",
  "deliveryConfig": {
      "deliveryRequirement": "DELIVERY_REQUIREMENT",
  },
  "exportConfig": {
      "desiredState": "DESIRED_STATE",
      "deadLetterTopic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/DEAD_LETTER_TOPIC_ID",
      "pubsubConfig": {
          "topic": "PUBSUB_TOPIC_NAME"
      }
  }
}

{
  "deliveryConfig": {
      "deliveryRequirement": "DELIVERY_REQUIREMENT",
  },
  "exportConfig": {
      "desiredState": "DESIRED_STATE",
      "deadLetterTopic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/DEAD_LETTER_TOPIC_ID",
      "pubsubConfig": {
          "topic": "PUBSUB_TOPIC_NAME"
      },
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/subscriptions/SUBSCRIPTION_ID",
  "topic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/TOPIC_ID",
}

import (
	"context"
	"fmt"
	"io"

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

func createPubsubExportSubscription(w io.Writer, projectID, region, location, topicID, subID, pubsubTopicID string) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// NOTE: location can be either a region ("us-central1") or a zone ("us-central1-a")
	// For a list of valid locations, see https://cloud.google.com/pubsub/lite/docs/locations.
	// location := "us-central1"
	// NOTE: topic and subscription must be in the same region/zone (e.g. "us-central1-a")
	// topicID := "my-topic"
	// subID := "my-subscription"
	// pubsubTopicID := "destination-topic-id"
	ctx := context.Background()
	client, err := pubsublite.NewAdminClient(ctx, region)
	if err != nil {
		return fmt.Errorf("pubsublite.NewAdminClient: %w", err)
	}
	defer client.Close()

	// Initialize the subscription to the oldest retained messages for each
	// partition.
	targetLocation := pubsublite.AtTargetLocation(pubsublite.Beginning)

	sub, err := client.CreateSubscription(ctx, pubsublite.SubscriptionConfig{
		Name:                fmt.Sprintf("projects/%s/locations/%s/subscriptions/%s", projectID, location, subID),
		Topic:               fmt.Sprintf("projects/%s/locations/%s/topics/%s", projectID, location, topicID),
		DeliveryRequirement: pubsublite.DeliverImmediately, // Can also be DeliverAfterStored.
		// Configures an export subscription that writes messages to a Pub/Sub topic.
		ExportConfig: &pubsublite.ExportConfig{
			DesiredState: pubsublite.ExportActive, // Can also be ExportPaused.
			Destination: &pubsublite.PubSubDestinationConfig{
				Topic: fmt.Sprintf("projects/%s/topics/%s", projectID, pubsubTopicID),
			},
		},
	}, targetLocation)
	if err != nil {
		return fmt.Errorf("client.CreateSubscription got err: %w", err)
	}
	fmt.Fprintf(w, "Created export subscription: %s\n", sub.Name)
	return nil
}

import com.google.api.gax.rpc.AlreadyExistsException;
import com.google.cloud.pubsublite.AdminClient;
import com.google.cloud.pubsublite.AdminClientSettings;
import com.google.cloud.pubsublite.BacklogLocation;
import com.google.cloud.pubsublite.CloudRegion;
import com.google.cloud.pubsublite.CloudRegionOrZone;
import com.google.cloud.pubsublite.CloudZone;
import com.google.cloud.pubsublite.ProjectNumber;
import com.google.cloud.pubsublite.SeekTarget;
import com.google.cloud.pubsublite.SubscriptionName;
import com.google.cloud.pubsublite.SubscriptionPath;
import com.google.cloud.pubsublite.TopicName;
import com.google.cloud.pubsublite.TopicPath;
import com.google.cloud.pubsublite.proto.ExportConfig;
import com.google.cloud.pubsublite.proto.ExportConfig.PubSubConfig;
import com.google.cloud.pubsublite.proto.ExportConfig.State;
import com.google.cloud.pubsublite.proto.Subscription;
import com.google.cloud.pubsublite.proto.Subscription.DeliveryConfig;
import com.google.cloud.pubsublite.proto.Subscription.DeliveryConfig.DeliveryRequirement;
import java.util.concurrent.ExecutionException;

public class CreatePubsubExportSubscriptionExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String cloudRegion = "your-cloud-region";
    char zoneId = 'b';
    String topicId = "your-topic-id";
    String subscriptionId = "your-subscription-id";
    String pubsubTopicId = "destination-topic-id";
    long projectNumber = Long.parseLong("123456789");
    // True if using a regional location. False if using a zonal location.
    // https://cloud.google.com/pubsub/lite/docs/topics
    boolean regional = false;

    createPubsubExportSubscriptionExample(
        cloudRegion, zoneId, projectNumber, topicId, subscriptionId, pubsubTopicId, regional);
  }

  public static void createPubsubExportSubscriptionExample(
      String cloudRegion,
      char zoneId,
      long projectNumber,
      String topicId,
      String subscriptionId,
      String pubsubTopicId,
      boolean regional)
      throws Exception {

    CloudRegionOrZone location;
    if (regional) {
      location = CloudRegionOrZone.of(CloudRegion.of(cloudRegion));
    } else {
      location = CloudRegionOrZone.of(CloudZone.of(CloudRegion.of(cloudRegion), zoneId));
    }

    TopicPath topicPath =
        TopicPath.newBuilder()
            .setProject(ProjectNumber.of(projectNumber))
            .setLocation(location)
            .setName(TopicName.of(topicId))
            .build();

    SubscriptionPath subscriptionPath =
        SubscriptionPath.newBuilder()
            .setLocation(location)
            .setProject(ProjectNumber.of(projectNumber))
            .setName(SubscriptionName.of(subscriptionId))
            .build();

    com.google.pubsub.v1.TopicName pubsubTopicName =
        com.google.pubsub.v1.TopicName.of(String.valueOf(projectNumber), pubsubTopicId);

    Subscription subscription =
        Subscription.newBuilder()
            .setDeliveryConfig(
                // Possible values for DeliveryRequirement:
                // - `DELIVER_IMMEDIATELY`
                // - `DELIVER_AFTER_STORED`
                // You may choose whether to wait for a published message to be successfully written
                // to storage before the server delivers it to subscribers. `DELIVER_IMMEDIATELY` is
                // suitable for applications that need higher throughput.
                DeliveryConfig.newBuilder()
                    .setDeliveryRequirement(DeliveryRequirement.DELIVER_IMMEDIATELY))
            .setExportConfig(
                // Configures an export subscription that writes messages to a Pub/Sub topic.
                ExportConfig.newBuilder()
                    // Possible values for State:
                    // - `ACTIVE`: enable message processing.
                    // - `PAUSED`: suspend message processing.
                    .setDesiredState(State.ACTIVE)
                    .setPubsubConfig(
                        PubSubConfig.newBuilder().setTopic(pubsubTopicName.toString())))
            .setName(subscriptionPath.toString())
            .setTopic(topicPath.toString())
            .build();

    // Target location within the message backlog that the subscription should be initialized to.
    SeekTarget initialLocation = SeekTarget.of(BacklogLocation.BEGINNING);

    AdminClientSettings adminClientSettings =
        AdminClientSettings.newBuilder().setRegion(location.extractRegion()).build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources, or
    // use "try-with-close" statement to do this automatically.
    try (AdminClient adminClient = AdminClient.create(adminClientSettings)) {
      Subscription response = adminClient.createSubscription(subscription, initialLocation).get();
      System.out.println(response.getAllFields() + " created successfully.");
    } catch (ExecutionException e) {
      try {
        throw e.getCause();
      } catch (AlreadyExistsException alreadyExists) {
        System.out.println("This subscription already exists.");
      } catch (Throwable throwable) {
        throwable.printStackTrace();
      }
    }
  }
}

from google.api_core.exceptions import AlreadyExists
from google.cloud.pubsub_v1 import PublisherClient
from google.cloud.pubsublite import AdminClient, Subscription, ExportConfig
from google.cloud.pubsublite.types import (
    BacklogLocation,
    CloudRegion,
    CloudZone,
    SubscriptionPath,
    TopicPath,
)


def create_lite_pubsub_export_subscription(
    project_number,
    cloud_region="us-central1",
    zone_id="a",
    topic_id="my-topic-id",
    subscription_id="my-subscription-id",
    pubsub_topic_id="destination-topic-id",
    regional=True,
    target_location=BacklogLocation.BEGINNING,
):
    if regional:
        location = CloudRegion(cloud_region)
    else:
        location = CloudZone(CloudRegion(cloud_region), zone_id)

    topic_path = TopicPath(project_number, location, topic_id)
    subscription_path = SubscriptionPath(project_number, location, subscription_id)
    destination_topic_path = PublisherClient.topic_path(project_number, pubsub_topic_id)

    subscription = Subscription(
        name=str(subscription_path),
        topic=str(topic_path),
        delivery_config=Subscription.DeliveryConfig(
            # Possible values for delivery_requirement:
            # - `DELIVER_IMMEDIATELY`
            # - `DELIVER_AFTER_STORED`
            # You may choose whether to wait for a published message to be successfully written
            # to storage before the server delivers it to subscribers. `DELIVER_IMMEDIATELY` is
            # suitable for applications that need higher throughput.
            delivery_requirement=Subscription.DeliveryConfig.DeliveryRequirement.DELIVER_IMMEDIATELY,
        ),
        # Configures an export subscription that writes messages to a Pub/Sub topic.
        export_config=ExportConfig(
            # Possible values for desired_state:
            # - `ACTIVE`: enable message processing.
            # - `PAUSED`: suspend message processing.
            desired_state=ExportConfig.State.ACTIVE,
            pubsub_config=ExportConfig.PubSubConfig(
                topic=destination_topic_path,
            ),
        ),
    )

    # Initialize client that will be used to send requests across threads. This
    # client only needs to be created once, and can be reused for multiple requests.
    client = AdminClient(cloud_region)
    try:
        response = client.create_subscription(subscription, target_location)
        print(f"{response.name} created successfully.")
    except AlreadyExists:
        print(f"{subscription_path} already exists.")

Actualiza una suscripción de exportación

Puedes actualizar las suscripciones Lite con la consola de Google Cloud, Google Cloud CLI o la API de Pub/Sub Lite. La nueva configuración puede demorar hasta 30 segundos en aplicarse.

gcloud pubsub lite-subscriptions update SUBSCRIPTION_ID \
--location=LOCATION \
--delivery-requirement=DELIVERY_REQUIREMENT \
--export-pubsub-topic=PUBSUB_TOPIC_NAME \
--export-dead-letter-topic=DEAD_LETTER_TOPIC_ID \
--export-desired-state=DESIRED_STATE

Updated subscription [SUBSCRIPTION_ID].
deliveryConfig:
deliveryRequirement: DELIVERY_REQUIREMENT
exportConfig:
currentState: DESIRED_STATE
deadLetterTopic: projects/PROJECT_NUMBER/locations/LOCATION/topics/DEAD_LETTER_TOPIC_ID
desiredState: DESIRED_STATE
pubsubConfig:
  topic: PUBSUB_TOPIC_NAME
name: projects/PROJECT_NUMBER/locations/LOCATION/subscriptions/SUBSCRIPTION_ID
topic: projects/PROJECT_NUMBER/locations/LOCATION/topics/TOPIC_ID

PATCH https://REGION-pubsublite.googleapis.com/v1/admin/projects/PROJECT_NUMBER/locations/LOCATION/subscriptions/SUBSCRIPTION_ID?updateMask=deliveryConfig.deliveryRequirement,exportConfig
Authorization: Bearer $(gcloud auth print-access-token)

{
  "deliveryConfig": {
      "deliveryRequirement": "DELIVERY_REQUIREMENT",
  },
  "exportConfig": {
      "desiredState": "DESIRED_STATE",
      "deadLetterTopic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/DEAD_LETTER_TOPIC_ID",
      "pubsubConfig": {
          "topic": "PUBSUB_TOPIC_NAME"
      }
  }
}

{
"deliveryConfig": {
  "deliveryRequirement": "DELIVERY_REQUIREMENT",
},
"exportConfig": {
  "desiredState": "DESIRED_STATE",
  "deadLetterTopic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/DEAD_LETTER_TOPIC_ID",
  "pubsubConfig": { "topic": "PUBSUB_TOPIC_NAME" }
},
"name": "projects/PROJECT_NUMBER/locations/LOCATION/subscriptions/SUBSCRIPTION_ID",
"topic": "projects/PROJECT_NUMBER/locations/LOCATION/topics/TOPIC_ID",
}

Cómo pausar o iniciar una suscripción a exportaciones

Las suscripciones de exportación tienen un parámetro de configuración llamado estado deseado, que tiene uno de los siguientes valores:

• Activo: La suscripción exporta mensajes Lite a Pub/Sub.
• Pausada: Se suspendió la exportación de mensajes Lite.

Para cambiar el estado deseado en la consola de Google Cloud, sigue estos pasos:

1. Ve a la página Suscripciones Lite.

   Ir a Suscripciones Lite

2. Haz clic en el ID de suscripción Lite.

3. En la página Detalles de la suscripción Lite, haz clic en Pausa o Iniciar.

También puedes actualizar el estado deseado con Google Cloud CLI o la API de Pub/Sub Lite. Consulta Cómo actualizar una suscripción de exportación.

Prácticas recomendadas

En esta sección, se describen algunas prácticas recomendadas para usar las suscripciones de exportación.

Reservas

Te recomendamos que uses una suscripción de exportación con una reserva, en lugar de establecer de forma explícita la capacidad de rendimiento de la suscripción.

Compatibilidad de mensajes

Si un mensaje de Pub/Sub Lite no es compatible con Pub/Sub, la suscripción de exportación no lo publica en Pub/Sub. En su lugar, coloca el mensaje en el tema de mensajes no entregados, si se asignó uno. Si no se asignó un tema de mensajes no entregados, los mensajes incompatibles simplemente se descartan.

Cuando publiques mensajes en el tema Lite, ten en cuenta los siguientes problemas de compatibilidad:

• Claves. Las claves de Pub/Sub Lite tienen el tipo bytes, mientras que las claves de ordenamiento de Pub/Sub son del tipo string. Para ser compatible, la clave de Pub/Sub Lite solo debe contener caracteres UTF-8.

• Atributos: Los atributos del mensaje tienen los siguientes requisitos:

  • Para ser compatibles, todos los atributos de los mensajes de Pub/Sub Lite deben tener un solo valor. Pub/Sub Lite admite atributos de mensaje con varios valores, pero Pub/Sub solo admite atributos de un solo valor.
  • Los atributos de los mensajes no deben exceder los límites de mensajes de Pub/Sub, incluidos los atributos máximos por mensaje y el tamaño máximo de clave y valor por atributo.

Tema de mensajes no entregados

Para conservar y controlar los mensajes incompatibles, te recomendamos que uses un tema de mensajes no entregados. Puedes asignar un tema de mensajes no entregados cuando creas la suscripción de exportación, o bien puedes actualizar una suscripción de exportación existente para usar un tema de mensajes no entregados. Si la suscripción recibe un mensaje incompatible con Pub/Sub, lo publica en el tema de mensajes no entregados.

Un tema de mensajes no entregados es un tema normal de Pub/Sub Lite. Debe estar en la misma ubicación y proyecto que la suscripción de exportación, y debe ser un tema diferente del tema de origen.

Por lo general, un tema de mensajes no entregados tiene una baja utilización de la capacidad de procesamiento. Por lo tanto, te recomendamos que asignes una reserva al tema de mensajes no entregados, en lugar de asignarle capacidad de procesamiento.

Errores de publicación

Una suscripción de exportación intenta entregar todos los mensajes compatibles al tema de Pub/Sub de destino. Si la entrega de mensajes falla, se suspenderá la suscripción a la exportación. Para encontrar la categoría de error, consulta la métrica subscription/export_status. Los siguientes valores indican un error:

• PERMISSION_DENIED: No tienes permisos suficientes para exportar mensajes.
• NOT_FOUND: No se encontró uno o más recursos, por ejemplo, el tema de destino no existe.

Para obtener más información sobre la solución de problemas, consulta Soluciona problemas de las suscripciones de exportación.

Después de resolver el error, la suscripción a la exportación se reinicia automáticamente debido a los reintentos periódicos.

Precios

Se te cobra por los recursos de Pub/Sub Lite y Pub/Sub que consume la suscripción de exportación. Específicamente, se te cobra por la capacidad de procesamiento y el almacenamiento de la suscripción asignada en la suscripción a Pub/Sub Lite, que se configuran para el tema de Pub/Sub Lite. También se te cobrará por publicar en el tema de Pub/Sub de destino. Consulta los precios de Pub/Sub.

No se aplican cargos adicionales por usar la función de exportación, y no hay diferencia de precio entre las suscripciones a la exportación de Pub/Sub Lite y las suscripciones estándar.

Soluciona problemas de exportación de suscripciones

En esta sección, se describen algunas sugerencias para solucionar problemas relacionados con las suscripciones de exportación.

La suscripción a la exportación está pausada

Si la suscripción está pausada, no se exportarán mensajes.

Para detectar este problema, haz lo siguiente:

• Consola de Google Cloud: Consulta los detalles de la suscripción. Si la suscripción está pausada, Estado deseado y Estado actual son Paused.

• Métricas: La métrica subscription/export_status es PAUSED.

Para resolver este problema, inicia la suscripción.

Se borró el tema de destino o el tema de mensajes no entregados

Si borras el tema de Pub/Sub adjunto a una suscripción de exportación o el tema de mensajes no entregados, se producirá un error.

Para detectar este problema, haz lo siguiente:

• Consola de Google Cloud: Consulta los detalles de la suscripción. Si se borró el tema, el estado actual es Not found.

• Métricas: La métrica subscription/export_status. Si se borró el tema, el valor es NOT_FOUND.

Para resolver este problema, verifica el tema de Pub/Sub de destino y el tema de mensajes no entregados (si se configuró uno).

Si se borró el Pub/Sub de destino, vuelve a crear el tema con el mismo nombre. La suscripción de exportación reanuda la publicación, siempre que los permisos no hayan cambiado.

Si se borró el tema de mensajes no entregados, crea uno nuevo y actualiza la suscripción de exportación para hacer referencia a él.

Mensajes incompatibles

Si los mensajes son incompatibles con Pub/Sub, no se exportan.

Para detectar este problema, haz lo siguiente:

• Métricas: La métrica subscription/unexportable_message_count muestra el recuento de mensajes incompatibles que no se pudieron exportar.

Para resolver este problema, usa un tema de mensajes no entregados para retener los mensajes incompatibles. Examina los mensajes para determinar la causa y, luego, transfórmalos y vuelve a publicarlos si es necesario. Consulta Compatibilidad de mensajes.

La exportación se limita

Para detectar este problema, haz lo siguiente:

• Métricas: La métrica subscription/flow_control_status muestra un motivo de control de flujo de NO_CLIENT_TOKENS, lo que indica que se alcanzó el límite por partición de bytes o mensajes pendientes. Hasta que se resuelva el problema, aumentará la lista de tareas pendientes de las suscripciones de exportación asociadas.

Este error tiene varias causas raíz posibles. La mayoría de las causas posibles ocurren en el backend, pero verifica lo siguiente:

• Asegúrate de publicar mensajes Lite que compartan la misma clave a una velocidad inferior a 1 MiB/s por clave. La suscripción de exportación escribe claves de mensajes Lite como claves de ordenamiento de Pub/Sub, y Pub/Sub tiene un límite de 1 MiB/s en cada clave de ordenamiento. Superar este límite puede causar limitación.

El usuario no tiene autorización para realizar esta acción

El agente de servicio de Pub/Sub Lite debe tener permisos para publicar en el tema de Pub/Sub de destino.

Para detectar este problema, haz lo siguiente:

• Consola de Google Cloud: Consulta los detalles de la suscripción. Si hay errores de permiso, el estado actual es Permission denied.

• Métricas: La métrica subscription/export_status es PERMISSON_DENIED.

Por ejemplo, las siguientes situaciones pueden causar este error:

• Al agente de servicio de Pub/Sub Lite le falta el permiso o rol correcto para publicar mensajes en el tema de Pub/Sub de destino en un proyecto diferente.
• Se quitó el agente de servicio de la política de IAM del proyecto superior de la suscripción de exportación.
• El agente de servicio de Pub/Sub Lite aún se está configurando. Un agente de servicio se crea automáticamente cuando creas la primera suscripción de exportación en un proyecto. El error de permiso debería resolverse automáticamente en un plazo de 10 minutos.

Para resolver el problema, verifica si se le otorgó al agente de servicio el permiso o rol correcto. Consulta Agentes de servicio.

¿Qué sigue?

Elige entre Pub/Sub o Pub/Sub Lite.