Tópicos com mensagens inativas

Os assinantes podem não conseguir processar mensagens por vários motivos. Por exemplo, pode haver problemas temporários ao recuperar os dados necessários para processar uma mensagem. Ou uma mensagem pode estar em um formato que o assinante não espera.

Para gerenciar mensagens não entregues que os assinantes não podem confirmar, o Pub/Sub pode encaminhá-las para um tópico de mensagens inativas (também conhecido como fila de mensagens inativas).

Antes de começar

• Crie um tópico para a configuração de tópico de mensagens inativas.

  Ou, se você seguir todas as instruções desta página de ponta a ponta, poderá criar o tópico em uma etapa posterior.

Funções exigidas

Para receber as permissões necessárias para gerenciar tópicos e assinaturas, peça ao administrador para conceder a você o papel do IAM de Editor do Pub/Sub (roles/pubsub.editor) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

É possível configurar o controle de acesso no nível do projeto e no nível do recurso individual. É possível criar uma assinatura em um projeto e anexá-la a um tópico localizado em um projeto diferente. Verifique se você tem as permissões necessárias para cada projeto.

Como funcionam os tópicos de mensagens inativas

Quando um aplicativo de assinatura não consegue confirmar uma mensagem, o Pub/Sub tenta fazer a entrega até que o prazo de confirmação seja cumprido ou a mensagem expire. Depois de um número aproximadamente configurado de tentativas de entrega, o Pub/Sub pode encaminhar a mensagem não entregue para um tópico de mensagens inativas.

Quando o Pub/Sub encaminha uma mensagem não entregue, ele encapsula a mensagem original em uma nova e adiciona atributos que identificam a assinatura de origem. A mensagem é enviada para o tópico de mensagens inativas especificado. Uma assinatura separada anexada ao tópico de mensagens inativas pode receber essas mensagens encaminhadas para análise e depuração off-line.

Como o número máximo de tentativas de entrega é calculado

O Pub/Sub só conta as tentativas de entrega quando um tópico de mensagens inativas é configurado corretamente e inclui as permissões do IAM corretas.

O número máximo de tentativas de entrega é aproximado, porque o Pub/Sub encaminha mensagens não entregues com base no melhor esforço. O serviço pode encaminhar uma mensagem após menos tentativas do que o configurado ou tentar a entrega algumas vezes mais antes de encaminhar.

O número rastreado de tentativas de entrega de uma mensagem também pode ser redefinido para zero, especialmente para uma assinatura por pull com assinantes inativos. Como resultado, as mensagens podem ser entregues ao cliente assinante mais vezes do que o número máximo configurado de tentativas de entrega.

Propriedades do tópico de mensagens inativas

É possível definir as seguintes propriedades de assinatura em um tópico de mensagens inativas.

• Número máximo de tentativas de entrega: um valor numérico que significa o número de tentativas de entrega que o Pub/Sub faz para uma mensagem específica. Se o cliente assinante não conseguir confirmar a mensagem dentro do número configurado de tentativas de entrega, ela será encaminhada para um tópico de mensagens inativas.

  • Valor padrão = 5
  • Valor máximo = 100
  • Valor mínimo = 5

• Projeto com o tópico de mensagens inativas: se o tópico de mensagens inativas estiver em um projeto diferente da assinatura, será preciso especificar esse projeto. Defina o tópico de mensagens inativas em um tópico diferente daquele a que a assinatura está anexada.

Configurar um tópico de mensagens inativas

As etapas a seguir descrevem o fluxo de trabalho para usar tópicos de mensagens inativas.

1. Crie um tópico (para usar como um tópico de mensagens inativas).

2. Crie uma assinatura para o tópico de mensagens inativas.

3. Ative Mensagens mortas na sua assinatura.

4. Anexe o tópico que você criou antes à sua assinatura.

5. Conceda os papéis necessários para usar tópicos de mensagens inativas à sua conta de serviço do Pub/Sub.

Criar um tópico para usar com tópicos de mensagens inativas

Se você já criou um tópico para usar na sua assinatura, pule esta etapa.

1. No console do Google Cloud , acesse a página Tópicos.

   Acesse Tópicos

2. Selecione Criar tópico.

3. Insira um ID do tópico, por exemplo, my-test-topic.

4. Mantenha a opção de assinatura padrão e clique em Criar.

Definir um tópico de mensagens inativas em uma assinatura

É possível definir um tópico de mensagens inativas em uma assinatura nova ou atual.

Definir um tópico de mensagens inativas em uma nova assinatura

É possível criar uma assinatura e definir um tópico de mensagens inativas usando o consoleGoogle Cloud , a Google Cloud CLI, as bibliotecas de cliente ou a API Pub/Sub.

gcloud pubsub subscriptions create subscription-id \
  --topic=topic-id \
  --dead-letter-topic=dead-letter-topic-name \
  [--max-delivery-attempts=max-delivery-attempts] \
  [--dead-letter-topic-project=dead-letter-topic-project]

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,
   std::string const& dead_letter_topic_id,
   int dead_letter_delivery_attempts) {
  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.mutable_dead_letter_policy()->set_dead_letter_topic(
      pubsub::Topic(project_id, dead_letter_topic_id).FullName());
  request.mutable_dead_letter_policy()->set_max_delivery_attempts(
      dead_letter_delivery_attempts);
  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";

  std::cout << "It will forward dead letter messages to: "
            << sub->dead_letter_policy().dead_letter_topic() << "\n";

  std::cout << "After " << sub->dead_letter_policy().max_delivery_attempts()
            << " delivery attempts.\n";
}

using Google.Cloud.PubSub.V1;
using System;

public class CreateSubscriptionWithDeadLetterPolicySample
{
    public Subscription CreateSubscriptionWithDeadLetterPolicy(string projectId, string topicId, string subscriptionId, string deadLetterTopicId)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        // This is the subscription you want to create with a dead letter policy.
        var subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
        // This is an existing topic that you want to attach the subscription with dead letter policy to.
        var topicName = TopicName.FromProjectTopic(projectId, topicId);
        // This is an existing topic that the subscription with dead letter policy forwards dead letter messages to.
        var deadLetterTopic = TopicName.FromProjectTopic(projectId, deadLetterTopicId).ToString();
        var subscriptionRequest = new Subscription
        {
            SubscriptionName = subscriptionName,
            TopicAsTopicName = topicName,
            DeadLetterPolicy = new DeadLetterPolicy
            {
                DeadLetterTopic = deadLetterTopic,
                // The maximum number of times that the service attempts to deliver a
                // message before forwarding it to the dead letter topic. Must be [5-100].
                MaxDeliveryAttempts = 10
            },
            AckDeadlineSeconds = 30
        };

        var subscription = subscriber.CreateSubscription(subscriptionRequest);
        Console.WriteLine("Created subscription: " + subscription.SubscriptionName.SubscriptionId);
        Console.WriteLine($"It will forward dead letter messages to: {subscription.DeadLetterPolicy.DeadLetterTopic}");
        Console.WriteLine($"After {subscription.DeadLetterPolicy.MaxDeliveryAttempts} delivery attempts.");
        // Remember to attach a subscription to the dead letter topic because
        // messages published to a topic with no subscriptions are lost.
        return subscription;
    }
}

import (
	"context"
	"fmt"
	"io"

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

// createSubWithDeadLetter creates a subscription with a dead letter policy.
func createSubWithDeadLetter(w io.Writer, projectID, topic, subscription, fullyQualifiedDeadLetterTopic string) error {
	// projectID := "my-project-id"
	// topic := "projects/my-project-id/topics/my-topic"
	// subscription := "projects/my-project-id/subscriptions/my-sub"
	// fullyQualifiedDeadLetterTopic := "projects/my-project-id/topics/my-dead-letter-topic"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf(