Como gerenciar tópicos e assinaturas

Neste documento, apresentamos informações sobre como criar, excluir e administrar tópicos e assinaturas do Pub/Sub. Para saber mais sobre como publicar e acessar dados de mensagens, consulte o Guia do editor e a Visão geral do assinante.

Como gerenciar tópicos

É possível criar, excluir e visualizar tópicos por meio da API, do Console do Google Cloud ou da ferramenta de linha de comando gcloud. Consulte a referência do gcloud pubsub para uma lista completa de comandos gcloud da API Pub/Sub.

Para uma introdução sobre o Console do Cloud, consulte o Guia de início rápido do Console do Cloud.
Ao criar um tópico, é possível especificar chaves de criptografia próprias. Consulte Como usar chaves de criptografia gerenciadas pelo cliente.

Como criar um tópico

É necessário criar um tópico para poder publicar ou assiná-lo. Veja um exemplo de como criar um tópico:

Protocolo

Solicitação:

A solicitação precisa ser autenticada com um token de acesso no cabeçalho Authorization. Para conseguir um token de acesso para o Application Default Credentials: gcloud auth application-default print-access-token.

    PUT https://pubsub.googleapis.com/v1/projects/myproject/topics/mytopic
    Authorization: Bearer ACCESS_TOKEN

Saída:

200 OK

    {
     "name": "projects/myproject/topics/mytopic"
    }

Linha de comando

      gcloud pubsub topics create myTopic

C#

Antes de testar essa amostra, siga as instruções de configuração do C# no Guia de início rápido do Cloud Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para C# (em inglês).

Ver no GitHub Feedback

            PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();

                TopicName topicName = new TopicName(projectId, topicId);
                try
                {
                    publisher.CreateTopic(topicName);
                }
                catch (RpcException e)
                when (e.Status.StatusCode == StatusCode.AlreadyExists)
                {
                    // Already exists.  That's fine.
                }

Go

Antes de testar essa amostra, siga as instruções de configuração do Go no Guia de início rápido do Cloud Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para Go (em inglês).

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"
    	"io"

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

    func create(w io.Writer, projectID, topicID string) error {
    	// projectID := "my-project-id"
    	// topicID := "my-topic"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	t, err := client.CreateTopic(ctx, topicID)
    	if err != nil {
    		return fmt.Errorf("CreateTopic: %v", err)
    	}
    	fmt.Fprintf(w, "Topic created: %v\n", t)
    	return nil
    }

Java

Antes de testar essa amostra, siga as instruções de configuração do Java no guia de início rápido do Cloud Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para Java (em inglês).

Ver no GitHub Feedback

try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      // projectId <=  unique project identifier, eg. "my-project-id"
      // topicId <= "my-topic-id"
      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      Topic topic = topicAdminClient.createTopic(topicName);
      return topic;
    }

Node.js

Antes de testar essa amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Cloud Pub/Sub: como usar as bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para Node.js (em inglês).

Ver no GitHub Feedback

/**
     * TODO(developer): Uncomment this variable before running the sample.
     */
    // const topicName = 'YOUR_TOPIC_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 createTopic() {
      // Creates a new topic
      await pubSubClient.createTopic(topicName);
      console.log(`Topic ${topicName} created.`);
    }

    createTopic();

PHP

Antes de testar essa amostra, siga as instruções de configuração do PHP no Guia de início rápido do Cloud Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para PHP (em inglês).

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Creates a Pub/Sub topic.
     *
     * @param string $projectId  The Google project ID.
     * @param string $topicName  The Pub/Sub topic name.
     */
    function create_topic($projectId, $topicName)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        $topic = $pubsub->createTopic($topicName);

        printf('Topic created: %s' . PHP_EOL, $topic->name());
    }

Python

Antes de testar essa amostra, siga as instruções de configuração do Python no Guia de início rápido do Cloud Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para Python (em inglês).

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO topic_name = "Your Pub/Sub topic name"

    publisher = pubsub_v1.PublisherClient()
    topic_path = publisher.topic_path(project_id, topic_name)

    topic = publisher.create_topic(topic_path)

    print("Topic created: {}".format(topic))

Ruby

Antes de testar essa amostra, siga as instruções de configuração do Ruby no Guia de início rápido do Cloud Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Cloud Pub/Sub para Ruby (em inglês).

Ver no GitHub Feedback

# project_id = "Your Google Cloud Project ID"
    # topic_name = "Your Pubsub topic name"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    topic = pubsub.create_topic topic_name

    puts "Topic #{topic.name} created."

Como excluir um tópico

Veja um exemplo de como excluir um tópico:

Protocolo

Solicitação:

    DELETE https://pubsub.googleapis.com/v1/projects/myproject/topics/mytopic
    Authorization: Bearer ACCESS_TOKEN

Saída:

200 OK

    {
     "name": "projects/myproject/topics/mytopic"
    }

Comando gcloud

      gcloud pubsub topics delete myTopic

C#

Ver no GitHub Feedback

PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
    TopicName topicName = new TopicName(projectId, topicId);
    publisher.DeleteTopic(topicName);
    Console.WriteLine("Topic deleted.");

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"
    	"io"

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

    func delete(w io.Writer, projectID, topicID string) error {
    	// projectID := "my-project-id"
    	// topicID := "my-topic"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	t := client.Topic(topicID)
    	if err := t.Delete(ctx); err != nil {
    		return fmt.Errorf("Delete: %v", err)
    	}
    	fmt.Fprintf(w, "Deleted topic: %v\n", t)
    	return nil
    }

Java

Ver no GitHub Feedback

try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      topicAdminClient.deleteTopic(topicName);
      return topicName;
    }

Node.js

Ver no GitHub Feedback

/**
     * TODO(developer): Uncomment this variable before running the sample.
     */
    // const topicName = 'YOUR_TOPIC_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 deleteTopic() {
      /**
       * TODO(developer): Uncomment the following line to run the sample.
       */
      // const topicName = 'my-topic';

      // Deletes the topic
      await pubSubClient.topic(topicName).delete();
      console.log(`Topic ${topicName} deleted.`);
    }

    deleteTopic().catch(console.error);

PHP

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Creates a Pub/Sub topic.
     *
     * @param string $projectId  The Google project ID.
     * @param string $topicName  The Pub/Sub topic name.
     */
    function delete_topic($projectId, $topicName)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        $topic = $pubsub->topic($topicName);
        $topic->delete();

        printf('Topic deleted: %s' . PHP_EOL, $topic->name());
    }

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO topic_name = "Your Pub/Sub topic name"

    publisher = pubsub_v1.PublisherClient()
    topic_path = publisher.topic_path(project_id, topic_name)

    publisher.delete_topic(topic_path)

    print("Topic deleted: {}".format(topic_path))

Ruby

Ver no GitHub Feedback

# project_id = "Your Google Cloud Project ID"
    # topic_name = "Your Pubsub topic name"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    topic = pubsub.topic topic_name
    topic.delete

    puts "Topic #{topic_name} deleted."

Quando você exclui um tópico, as assinaturas dele não são excluídas, e o backlog da mensagem da assinatura fica disponível para os assinantes. Depois que um tópico é excluído, as assinaturas dele ficam com o nome de tópico _deleted-topic_. Se você tentar criar um tópico com o mesmo nome de um recém-excluído, verá um erro por um breve período de tempo após a exclusão.

Como listar tópicos

Veja um exemplo de como listar tópicos:

Protocolo

Solicitação:

    GET https://pubsub.googleapis.com/v1/projects/myproject/topics
    Authorization: Bearer ACCESS_TOKEN

Saída:

200 OK

    {
      "topics": [
        {
          "name": "projects/myproject/topics/mytopic1"
        },
        {
          "name": "projects/myproject/topics/mytopic2"
        }
      ]
    }

Comando gcloud

       gcloud pubsub topics list

C#

Ver no GitHub Feedback

ProjectName projectName = new ProjectName(projectId);
    IEnumerable<Topic> topics = publisher.ListTopics(projectName);
    foreach (Topic topic in topics)
    {
        Console.WriteLine($"{topic.Name}");
    }

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"

    	"cloud.google.com/go/pubsub"
    	"google.golang.org/api/iterator"
    )

    func list(projectID string) ([]*pubsub.Topic, error) {
    	// projectID := "my-project-id"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return nil, fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	var topics []*pubsub.Topic

    	it := client.Topics(ctx)
    	for {
    		topic, err := it.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			return nil, fmt.Errorf("Next: %v", err)
    		}
    		topics = append(topics, topic)
    	}

    	return topics, nil
    }

Java

Ver no GitHub Feedback

try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      ListTopicsRequest listTopicsRequest =
          ListTopicsRequest.newBuilder().setProject(ProjectName.format(projectId)).build();
      ListTopicsPagedResponse response = topicAdminClient.listTopics(listTopicsRequest);
      Iterable<Topic> topics = response.iterateAll();
      for (Topic topic : topics) {
        // do something with the topic
      }
      return response;
    }

Node.js

Ver no GitHub Feedback

// 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 listAllTopics() {
      // Lists all topics in the current project
      const [topics] = await pubSubClient.getTopics();
      console.log('Topics:');
      topics.forEach(topic => console.log(topic.name));
    }

    listAllTopics().catch(console.error);

PHP

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Lists all Pub/Sub topics.
     *
     * @param string $projectId  The Google project ID.
     */
    function list_topics($projectId)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        foreach ($pubsub->topics() as $topic) {
            printf('Topic: %s' . PHP_EOL, $topic->name());
        }
    }

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"

    publisher = pubsub_v1.PublisherClient()
    project_path = publisher.project_path(project_id)

    for topic in publisher.list_topics(project_path):
        print(topic)

Ruby

Ver no GitHub Feedback

# project_id = "Your Google Cloud Project ID"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    topics = pubsub.topics

    puts "Topics in project:"
    topics.each do |topic|
      puts topic.name
    end

Por padrão, são retornados no máximo 100 resultados por consulta. Você pode mudar essa quantidade para até 1.000 usando o parâmetro de tamanho de página.

Como gerenciar assinaturas

Nesta seção, você aprenderá a gerenciar assinaturas de push e pull. Para uma visão geral e comparação das assinaturas de pull e de push, consulte a visão geral do assinante.

É necessário criar uma assinatura em um tópico para que os assinantes possam receber mensagens publicadas no tópico.

Como criar assinaturas

É possível criar assinaturas com o Console do Cloud, a ferramenta de linha de comando gcloud ou a API Cloud Pub/Sub.

Console

Para criar uma assinatura, conclua as etapas a seguir.

No Console do Cloud, acesse a página Assinaturas.

Acessar a página "Assinaturas"
Clique em Criar assinatura.
Insira o ID da assinatura.
Escolha ou crie um tópico no menu suspenso. A assinatura recebe mensagens do tópico.
Clique em Criar

Você também pode criar uma assinatura na seção Tópicos. Esse atalho é útil para associar tópicos a assinaturas.

No Console do Cloud, acesse a página Tópicos.

Acessar a página "Tópicos"
Clique em ao lado do tópico no qual criar uma assinatura.
No menu de contexto, selecione Criar assinatura.
Insira o ID da assinatura.
Clique em Criar

gcloud

Para criar uma assinatura, execute o comando gcloud pubsub subscriptions create.

    gcloud pubsub subscriptions create SUBSCRIPTION_ID
      --topic=TOPIC_ID
      [--ack-deadline=ACK_DEADLINE]
      [--message-retention-duration=MESSAGE_RETENTION_DURATION]
      [--expiration-period=EXPIRATION_PERIOD]
      [--push-endpoint=PUSH_ENDPOINT]

API

Para criar uma assinatura, use o método projects.subscriptions.create.

Protocolo

Solicitação:

    PUT https://pubsub.googleapis.com/v1/projects/myproject/subscriptions/mysubscription
    Authorization: Bearer ACCESS_TOKEN

Especifique os campos a seguir no corpo da solicitação:

    {
      "topic": "projects/someproject/topics/sometopic"
      // Only needed if you are using push delivery
      "pushConfig": {
        "pushEndpoint": "https://myproject.appspot.com/myhandler"
      }
    }

Saída:

200 OK

    {
      "name": "projects/myproject/subscriptions/mysubscription",
      "topic": "projects/someproject/topics/sometopic",
      "pushConfig": {
        "pushEndpoint": "https://myproject.appspot.com/myhandler"
      },
      "ackDeadlineSeconds": 10
    }

C#

Ver no GitHub Feedback

SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
    TopicName topicName = new TopicName(projectId, topicId);
    SubscriptionName subscriptionName = new SubscriptionName(projectId,
        subscriptionId);
    try
    {
        Subscription subscription = subscriber.CreateSubscription(
            subscriptionName, topicName, pushConfig: null,
            ackDeadlineSeconds: 60);
    }
    catch (RpcException e)
    when (e.Status.StatusCode == StatusCode.AlreadyExists)
    {
        // Already exists.  That's fine.
    }

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"
    	"io"
    	"time"

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

    func create(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)
    	}

    	sub, err := client.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
    		Topic:       topic,
    		AckDeadline: 20 * time.Second,
    	})
    	if err != nil {
    		return fmt.Errorf("CreateSubscription: %v", err)
    	}
    	fmt.Fprintf(w, "Created subscription: %v\n", sub)
    	return nil
    }

Java

Ver no GitHub Feedback

try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      // eg. projectId = "my-test-project", topicId = "my-test-topic"
      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      // eg. subscriptionId = "my-test-subscription"
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);
      // create a pull subscription with default acknowledgement deadline
      Subscription subscription =
          subscriptionAdminClient.createSubscription(
              subscriptionName, topicName, PushConfig.getDefaultInstance(), 0);
      return subscription;
    }

Node.js

Ver no GitHub Feedback

/**
     * 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 createSubscription() {
      // Creates a new subscription
      await pubSubClient.topic(topicName).createSubscription(subscriptionName);
      console.log(`Subscription ${subscriptionName} created.`);
    }

    createSubscription().catch(console.error);

PHP

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Creates a Pub/Sub subscription.
     *
     * @param string $projectId  The Google project ID.
     * @param string $topicName  The Pub/Sub topic name.
     * @param string $subscriptionName  The Pub/Sub subscription name.
     */
    function create_subscription($projectId, $topicName, $subscriptionName)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        $topic = $pubsub->topic($topicName);
        $subscription = $topic->subscription($subscriptionName);
        $subscription->create();

        printf('Subscription created: %s' . PHP_EOL, $subscription->name());
    }

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO topic_name = "Your Pub/Sub topic name"
    # TODO subscription_name = "Your Pub/Sub subscription name"

    subscriber = pubsub_v1.SubscriberClient()
    topic_path = subscriber.topic_path(project_id, topic_name)
    subscription_path = subscriber.subscription_path(
        project_id, subscription_name
    )

    subscription = subscriber.create_subscription(
        subscription_path, topic_path
    )

    print("Subscription created: {}".format(subscription))

    subscriber.close()

Ruby

Ver no GitHub Feedback

# project_id        = "Your Google Cloud Project ID"
    # topic_name        = "Your Pubsub topic name"
    # subscription_name = "Your Pubsub subscription name"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    topic        = pubsub.topic topic_name
    subscription = topic.subscribe subscription_name

    puts "Pull subscription #{subscription_name} created."

Os exemplos a seguir mostram como criar uma assinatura com entrega por push. Por padrão, as assinaturas usam a entrega por pull.

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"
    	"io"
    	"time"

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

    func createWithEndpoint(w io.Writer, projectID, subID string, topic *pubsub.Topic, endpoint string) error {
    	// projectID := "my-project-id"
    	// subID := "my-sub"
    	// topic of type https://godoc.org/cloud.google.com/go/pubsub#Topic
    	// endpoint := "https://my-test-project.appspot.com/push"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	sub, err := client.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
    		Topic:       topic,
    		AckDeadline: 10 * time.Second,
    		PushConfig:  pubsub.PushConfig{Endpoint: endpoint},
    	})
    	if err != nil {
    		return fmt.Errorf("CreateSubscription: %v", err)
    	}
    	fmt.Fprintf(w, "Created subscription: %v\n", sub)
    	return nil
    }

Java

Ver no GitHub Feedback

try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);

      // eg. endpoint = "https://my-test-project.appspot.com/push"
      PushConfig pushConfig = PushConfig.newBuilder().setPushEndpoint(endpoint).build();

      // acknowledgement deadline in seconds for the message received over the push endpoint
      int ackDeadlineInSeconds = 10;

      Subscription subscription =
          subscriptionAdminClient.createSubscription(
              subscriptionName, topicName, pushConfig, ackDeadlineInSeconds);
      return subscription;
    }

Node.js

Ver no GitHub Feedback

/**
     * 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 createPushSubscription() {
      const options = {
        pushConfig: {
          // Set to an HTTPS endpoint of your choice. If necessary, register
          // (authorize) the domain on which the server is hosted.
          pushEndpoint: `https://${pubSubClient.projectId}.appspot.com/push`,
        },
      };

      await pubSubClient
        .topic(topicName)
        .createSubscription(subscriptionName, options);
      console.log(`Subscription ${subscriptionName} created.`);
    }

    createPushSubscription().catch(console.error);

PHP

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Creates a Pub/Sub push subscription.
     *
     * @param string $projectId  The Google project ID.
     * @param string $topicName  The Pub/Sub topic name.
     * @param string $subscriptionName  The Pub/Sub subscription name.
     * @param string $endpoint  The endpoint for the push subscription.
     */
    function create_push_subscription($projectId, $topicName, $subscriptionName, $endpoint)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        $topic = $pubsub->topic($topicName);
        $subscription = $topic->subscription($subscriptionName);
        $subscription->create([
            'pushConfig' => ['pushEndpoint' => $endpoint]
        ]);

        printf('Subscription created: %s' . PHP_EOL, $subscription->name());
    }

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO topic_name = "Your Pub/Sub topic name"
    # TODO subscription_name = "Your Pub/Sub subscription name"
    # TODO endpoint = "https://my-test-project.appspot.com/push"

    subscriber = pubsub_v1.SubscriberClient()
    topic_path = subscriber.topic_path(project_id, topic_name)
    subscription_path = subscriber.subscription_path(
        project_id, subscription_name
    )

    push_config = pubsub_v1.types.PushConfig(push_endpoint=endpoint)

    subscription = subscriber.create_subscription(
        subscription_path, topic_path, push_config
    )

    print("Push subscription created: {}".format(subscription))
    print("Endpoint for subscription is: {}".format(endpoint))

    subscriber.close()

Ruby

Ver no GitHub Feedback

# project_id        = "Your Google Cloud Project ID"
    # topic_name        = "Your Pubsub topic name"
    # subscription_name = "Your Pubsub subscription name"
    # endpoint          = "Endpoint where your app receives messages"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    topic        = pubsub.topic topic_name
    subscription = topic.subscribe subscription_name,
                                   endpoint: endpoint

    puts "Push subscription #{subscription_name} created."

Como usar propriedades de assinatura

Você pode definir as propriedades da assinatura ao criar ou atualizar uma assinatura. Para mais informações sobre como configurar propriedades de assinatura com a ferramenta de linha de comando gcloud, consulte as sinalizações opcionais gcloud pubsub subscriptions create ou gcloud pubsub subscriptions update.

As assinaturas têm as seguintes propriedades:

Property	Descrição	Padrão
Método de exibição	Você pode receber mensagens com entrega pull ou push. Na entrega pull, o aplicativo do seu assinante inicia solicitações para o servidor do Pub/Sub para recuperar mensagens. Na entrega push, o Pub/Sub inicia solicitações para o aplicativo do seu assinante enviar mensagens.	Se não for especificado, as assinaturas do Pub/Sub usarão a entrega pull.
Prazo de confirmação	Se o seu código não reconhecer a mensagem antes do prazo, a mensagem será enviada novamente.	10 segundos é o prazo de confirmação padrão. O máximo é 10 minutos.
Duração da retenção da mensagem	A duração da retenção de mensagens especifica por quanto tempo o Cloud Pub/Sub retém as mensagens após a publicação. Após a duração da retenção da mensagem, o Cloud Pub/Sub pode descartar a mensagem, independentemente do estado de confirmação. Para reter mensagens reconhecidas para a duração da retenção da mensagem, consulte Como reproduzir e descartar mensagens.	7 dias é a duração padrão da retenção de mensagens. O mínimo é 10 minutos e o máximo é 7 dias.
Período de expiração	As assinaturas sem atividade do assinante (como conexões abertas, pulls ativos ou pushes bem-sucedidos) expiram. Caso o Pub/Sub detecte atividade do assinante, o relógio de exclusão de assinatura será reiniciado.	31 dias é o período de expiração padrão. O mínimo é 1 dia. Para evitar que uma assinatura expire, defina o período de expiração como `never`.

Como modificar métodos de exibição

Você pode alternar entre assinaturas push e pull com o Console do Cloud, gcloud ferramenta de linha de comando ou a API Cloud Pub/Sub.

Console

No Console do Cloud, acesse a página Assinaturas.

Acessar a página "Assinaturas"
Clique em ao lado da assinatura para atualizar.
No menu de contexto, selecione Editar.
Em Tipo de entrega, escolha Pull ou Push.
Clique em Update.

gcloud

Para modificar o URL do endpoint de push, execute o comando modify-push-config:

    gcloud pubsub subscriptions modify-push-config SUBSCRIPTION_ID
      --push-endpoint=PUSH_ENDPOINT

Se a assinatura já estiver usando a entrega por pull, a configuração do endpoint de push alternará o método de entrega para a entrega por push.

É possível alternar a entrega de push para pull alterando o endpoint de push para uma string vazia.

API

Para modificar o URL do endpoint de push, use o método projects.subscriptions.modifyPushConfig.

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"
    	"io"

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

    func updateEndpoint(w io.Writer, projectID, subID string, endpoint string) error {
    	// projectID := "my-project-id"
    	// subID := "my-sub"
    	// endpoint := "https://my-test-project.appspot.com/push"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	subConfig, err := client.Subscription(subID).Update(ctx, pubsub.SubscriptionConfigToUpdate{
    		PushConfig: &pubsub.PushConfig{Endpoint: endpoint},
    	})
    	if err != nil {
    		return fmt.Errorf("Update: %v", err)
    	}
    	fmt.Fprintf(w, "Updated subscription config: %v\n", subConfig)
    	return nil
    }

Java

Ver no GitHub Feedback

try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);
      PushConfig pushConfig = PushConfig.newBuilder().setPushEndpoint(endpoint).build();
      subscriptionAdminClient.modifyPushConfig(subscriptionName, pushConfig);
    }

Node.js

Ver no GitHub Feedback

/**
     * 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 modifyPushConfig() {
      const options = {
        // Set to an HTTPS endpoint of your choice. If necessary, register
        // (authorize) the domain on which the server is hosted.
        pushEndpoint: `https://${pubSubClient.projectId}.appspot.com/push`,
      };

      await pubSubClient
        .topic(topicName)
        .subscription(subscriptionName)
        .modifyPushConfig(options);
      console.log(`Modified push config for subscription ${subscriptionName}.`);
    }

    modifyPushConfig().catch(console.error);

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO topic_name = "Your Pub/Sub topic name"
    # TODO subscription_name = "Your Pub/Sub subscription name"
    # TODO endpoint = "https://my-test-project.appspot.com/push"

    subscriber = pubsub_v1.SubscriberClient()
    subscription_path = subscriber.subscription_path(
        project_id, subscription_name
    )

    push_config = pubsub_v1.types.PushConfig(push_endpoint=endpoint)

    subscription = pubsub_v1.types.Subscription(
        name=subscription_path, push_config=push_config
    )

    update_mask = {"paths": {"push_config"}}
    subscriber.update_subscription(subscription, update_mask)
    result = subscriber.get_subscription(subscription_path)

    print("Subscription updated: {}".format(subscription_path))
    print("New endpoint for subscription is: {}".format(result.push_config))

    subscriber.close()

Ruby

Ver no GitHub Feedback

# project_id        = "Your Google Cloud Project ID"
    # subscription_name = "Your Pubsub subscription name"
    # new_endpoint      = "Endpoint where your app receives messages""
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    subscription          = pubsub.subscription subscription_name
    subscription.endpoint = new_endpoint

    puts "Push endpoint updated."

Se a assinatura já estiver usando a entrega por pull, a configuração do endpoint de push alternará o método de entrega para a entrega por push.

É possível alternar a entrega de push para pull alterando o endpoint de push para uma string vazia.

Como listar assinaturas

Você pode listar as assinaturas em um projeto do Google Cloud com o Console do Cloud, gcloud ferramenta de linha de comando ou Cloud Pub/Sub API.

Console

Para listar as assinaturas em um projeto, acesse a página Assinaturas.

Acessar a página "Assinaturas"

gcloud

Para listar as assinaturas em um projeto do Google Cloud, execute o comando gcloud pubsub subscriptions list:

    gcloud pubsub subscriptions list
       [--project=PROJECT_ID]

API

Para listar as assinaturas em um projeto do Google Cloud, use o método projects.subscriptions.list.

C#

Ver no GitHub Feedback

SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
    ProjectName projectName = new ProjectName(projectId);
    IEnumerable<Subscription> subscriptions =
        subscriber.ListSubscriptions(projectName);
    foreach (Subscription subscription in subscriptions)
    {
        Console.WriteLine($"{subscription}");
    }

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"

    	"cloud.google.com/go/pubsub"
    	"google.golang.org/api/iterator"
    )

    func list(projectID string) ([]*pubsub.Subscription, error) {
    	// projectID := "my-project-id"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return nil, fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	var subs []*pubsub.Subscription
    	it := client.Subscriptions(ctx)
    	for {
    		s, err := it.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			return nil, fmt.Errorf("Next: %v", err)
    		}
    		subs = append(subs, s)
    	}
    	return subs, nil
    }

Java

Ver no GitHub Feedback

try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      ListSubscriptionsRequest listSubscriptionsRequest =
          ListSubscriptionsRequest.newBuilder()
              .setProject(ProjectName.of(projectId).toString())
              .build();
      ListSubscriptionsPagedResponse response =
          subscriptionAdminClient.listSubscriptions(listSubscriptionsRequest);
      Iterable<Subscription> subscriptions = response.iterateAll();
      for (Subscription subscription : subscriptions) {
        // do something with the subscription
      }
      return response;
    }

Node.js

Ver no GitHub Feedback

// 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 listSubscriptions() {
      // Lists all subscriptions in the current project
      const [subscriptions] = await pubSubClient.getSubscriptions();
      console.log('Subscriptions:');
      subscriptions.forEach(subscription => console.log(subscription.name));
    }

    listSubscriptions().catch(console.error);

PHP

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Lists all Pub/Sub subscriptions.
     *
     * @param string $projectId  The Google project ID.
     */
    function list_subscriptions($projectId)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        foreach ($pubsub->subscriptions() as $subscription) {
            printf('Subscription: %s' . PHP_EOL, $subscription->name());
        }
    }

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"

    subscriber = pubsub_v1.SubscriberClient()
    project_path = subscriber.project_path(project_id)

    for subscription in subscriber.list_subscriptions(project_path):
        print(subscription.name)

    subscriber.close()

Ruby

Ver no GitHub Feedback

# project_id = Your Google Cloud Project ID
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    subscriptions = pubsub.list_subscriptions

    puts "Subscriptions:"
    subscriptions.each do |subscription|
      puts subscription.name
    end

É possível listar as assinaturas de um tópico com o Console do Cloud, a ferramenta de linha de comando gcloud ou a API Cloud Pub/Sub.

Console

No Console do Cloud, acesse a página Tópicos.

Acessar a página "Tópicos"
Selecione um ID de tópico para abrir a página Detalhes do tópico. A seção Assinaturas da página inclui uma lista de assinaturas do tópico.

gcloud

Para listar as assinaturas em um projeto do Google Cloud, execute o comando gcloud pubsub topics list-subscriptions:

    gcloud pubsub topics list-subscriptions TOPIC_ID

API

Para listar as assinaturas em um projeto do Google Cloud, use o método projects.topics.subscriptions.list.

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"

    	"cloud.google.com/go/pubsub"
    	"google.golang.org/api/iterator"
    )

    func listSubscriptions(projectID, topicID string) ([]*pubsub.Subscription, error) {
    	// projectID := "my-project-id"
    	// topicName := "projects/sample-248520/topics/ocr-go-test-topic"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return nil, fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	var subs []*pubsub.Subscription

    	it := client.Topic(topicID).Subscriptions(ctx)
    	for {
    		sub, err := it.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			return nil, fmt.Errorf("Next: %v", err)
    		}
    		subs = append(subs, sub)
    	}
    	return subs, nil
    }

Java

Ver no GitHub Feedback

try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      ListTopicSubscriptionsRequest request =
          ListTopicSubscriptionsRequest.newBuilder().setTopic(topicName.toString()).build();
      ListTopicSubscriptionsPagedResponse response =
          topicAdminClient.listTopicSubscriptions(request);
      Iterable<String> subscriptionNames = response.iterateAll();
      for (String subscriptionName : subscriptionNames) {
        // do something with the subscription name
      }
      return response;
    }

Node.js

Ver no GitHub Feedback

/**
     * TODO(developer): Uncomment this variable before running the sample.
     */
    // const topicName = 'YOUR_TOPIC_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 listTopicSubscriptions() {
      // Lists all subscriptions for the topic
      const [subscriptions] = await pubSubClient
        .topic(topicName)
        .getSubscriptions();

      console.log(`Subscriptions for ${topicName}:`);
      subscriptions.forEach(subscription => console.log(subscription.name));
    }

    listTopicSubscriptions().catch(console.error);

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO topic_name = "Your Pub/Sub topic name"

    publisher = pubsub_v1.PublisherClient()
    topic_path = publisher.topic_path(project_id, topic_name)

    for subscription in publisher.list_topic_subscriptions(topic_path):
        print(subscription)

Ruby

Ver no GitHub Feedback

# project_id = "Your Google Cloud Project ID"
    # topic_name = "Your Pubsub topic name"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    topic         = pubsub.topic topic_name
    subscriptions = topic.subscriptions

    puts "Subscriptions in topic #{topic.name}:"
    subscriptions.each do |subscription|
      puts subscription.name
    end

Como excluir assinaturas

É possível excluir assinaturas com o Console do Cloud, a ferramenta de linha de comando gcloud ou a API Cloud Pub/Sub.

Console

No Console do Cloud, acesse a página Assinaturas.

Acessar a página "Assinaturas"
Selecione a assinatura a ser excluída.
Clique em Excluir.

gcloud

Para excluir uma assinatura, execute o comando gcloud pubsub subscriptions delete:

    gcloud pubsub subscriptions delete SUBSCRIPTION_ID

API

Para excluir uma inscrição, use o método projects.topics.subscriptions.delete.

C#

Ver no GitHub Feedback

SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
    SubscriptionName subscriptionName = new SubscriptionName(projectId,
        subscriptionId);
    subscriber.DeleteSubscription(subscriptionName);
    Console.WriteLine("Subscription deleted.");

Go

Ver no GitHub Feedback

import (
    	"context"
    	"fmt"
    	"io"

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

    func delete(w io.Writer, projectID, subID string) error {
    	// projectID := "my-project-id"
    	// subID := "my-sub"
    	ctx := context.Background()
    	client, err := pubsub.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("pubsub.NewClient: %v", err)
    	}

    	sub := client.Subscription(subID)
    	if err := sub.Delete(ctx); err != nil {
    		return fmt.Errorf("Delete: %v", err)
    	}
    	fmt.Fprintf(w, "Subscription %q deleted.", subID)
    	return nil
    }

Java

Ver no GitHub Feedback

try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);
      subscriptionAdminClient.deleteSubscription(subscriptionName);
      return subscriptionName;
    }

Node.js

Ver no GitHub Feedback

/**
     * TODO(developer): Uncomment this variable before running the sample.
     */
    // 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 deleteSubscription() {
      // Deletes the subscription
      await pubSubClient.subscription(subscriptionName).delete();
      console.log(`Subscription ${subscriptionName} deleted.`);
    }

    deleteSubscription().catch(console.error);

PHP

Ver no GitHub Feedback

use Google\Cloud\PubSub\PubSubClient;

    /**
     * Creates a Pub/Sub subscription.
     *
     * @param string $projectId  The Google project ID.
     * @param string $subscriptionName  The Pub/Sub subscription name.
     */
    function delete_subscription($projectId, $subscriptionName)
    {
        $pubsub = new PubSubClient([
            'projectId' => $projectId,
        ]);
        $subscription = $pubsub->subscription($subscriptionName);
        $subscription->delete();

        printf('Subscription deleted: %s' . PHP_EOL, $subscription->name());
    }

Python

Ver no GitHub Feedback

from google.cloud import pubsub_v1

    # TODO project_id = "Your Google Cloud Project ID"
    # TODO subscription_name = "Your Pub/Sub subscription name"

    subscriber = pubsub_v1.SubscriberClient()
    subscription_path = subscriber.subscription_path(
        project_id, subscription_name
    )

    subscriber.delete_subscription(subscription_path)

    print("Subscription deleted: {}".format(subscription_path))

    subscriber.close()

Ruby

Ver no GitHub Feedback

# project_id        = "Your Google Cloud Project ID"
    # subscription_name = "Your Pubsub subscription name"
    require "google/cloud/pubsub"

    pubsub = Google::Cloud::Pubsub.new project: project_id

    subscription = pubsub.subscription subscription_name
    subscription.delete

    puts "Subscription #{subscription_name} deleted."

Nomes de recursos

Um nome de recurso do Pub/Sub identifica exclusivamente um recurso do Pub/Sub, como uma assinatura ou um tópico, e precisa ter o seguinte formato:

projects/project-identifier/collection/relative-name

O identificador do projeto precisa ser o ID do projeto, disponível no Console do Google Cloud. Por exemplo, projects/myproject/topics/mytopic.

A coleção precisa ser subscriptions ou topics.

O nome relativo precisa:

não começar com a string goog;
começar com uma letra;
conter entre 3 e 255 caracteres;
conter apenas os caracteres a seguir:
- letras: [A-Za-z]
- números: [0-9]
- traços: -
- sublinhados: _
- pontos: .
- sinais diacríticos: ~
- sinais de adição: +
- sinais de porcentagem: %
  
  Os caracteres especiais mencionados acima podem ser usados em nomes de recursos sem codificação para URLs. Mas, é preciso garantir que os demais caracteres especiais sejam codificados/decodificados corretamente quando usados em URLs. Por exemplo, mi-tópico é um nome relativo inválido. No entanto, mi-t%C3%B3pico é válido.
  
  Isso é particularmente importante para chamadas REST.