Criar um tópico

No Pub/Sub, um tópico é um recurso nomeado que representa um feed de mensagens. É necessário criar um tópico para poder publicar ou assinar. O Pub/Sub é compatível com dois tipos de tópicos: um padrão e um de importação.

Este documento descreve como criar um tópico padrão do Pub/Sub. Para saber mais sobre um tópico de importação e como criar um, consulte Sobre tópicos de importação.

Para criar um tópico, use o console Trusted Cloud , a Google Cloud CLI, a biblioteca de cliente ou a API Pub/Sub.

Antes de começar

• Saiba mais sobre o serviço do Pub/Sub e a terminologia dele.

• Saiba mais sobre o processo de publicação.

Papéis e permissões necessárias

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

Esse papel predefinido contém as permissões necessárias para criar um tópico. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Essas permissões também podem ser concedidas com funções personalizadas 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.

Propriedades de um tema

Ao criar ou atualizar um tópico, você precisa especificar as propriedades dele.

Adicione uma assinatura padrão

Adiciona uma assinatura padrão ao tópico do Pub/Sub. Você pode criar outra assinatura para o tópico depois que ele for criado. A assinatura padrão tem as seguintes propriedades:

• ID da assinatura de -sub
• Tipo de entrega pull
• Duração da retenção de mensagens de sete dias
• Expiração após 31 dias de inatividade
• Prazo de confirmação de recebimento de 10 segundos
• Política de repetição imediata

Ativar ingestão

Ao ativar essa propriedade, você pode ingerir dados de streaming de fontes externas em um tópico para usar os recursos do Trusted Cloud. Para criar um tópico de importação para ingestão, consulte o seguinte:

• Criar um tópico de importação do Amazon Kinesis Data Streams

• Criar um tópico de importação do Cloud Storage

• Criar um tópico do Azure Event Hubs

• Criar um tópico do Amazon MSK

• Criar um tópico do Confluent Cloud

Ativar retenção de mensagens

Especifica por quanto tempo o tópico do Pub/Sub retém as mensagens após a publicação. Após o período de retenção de mensagens, o Pub/Sub pode descartar a mensagem, independentemente do estado de confirmação. As tarifas de armazenamento de mensagens são cobradas pelo armazenamento de todas as mensagens publicadas no tópico.

• Padrão = não ativado
• Valor mínimo = 10 minutos
• Valor máximo = 31 dias

Exportar dados de mensagem para o BigQuery

Ao ativar essa propriedade, é possível criar uma assinatura do BigQuery que grava mensagens em uma tabela do BigQuery conforme elas são recebidas. Não é necessário configurar um cliente assinante separado. Para mais informações sobre as assinaturas do BigQuery, consulte Assinaturas do BigQuery.

Fazer backup de dados de mensagens no Cloud Storage

Ao ativar essa propriedade, é possível criar uma assinatura do Cloud Storage que grava mensagens em uma tabela do Cloud Storage à medida que elas são recebidas. Não é necessário configurar um cliente assinante separado. Para mais informações sobre as assinaturas do Cloud Storage, consulte Assinaturas do Cloud Storage.

Transformações

As SMTs de tópico permitem modificações leves nos dados e atributos das mensagens diretamente no Pub/Sub. Esse recurso permite a limpeza, filtragem ou conversão de formato de dados antes que as mensagens sejam publicadas no tópico.

Para mais informações sobre SMTs, consulte a visão geral das SMTs.

Google Cloud-powered encryption key

Especifica que o tópico está criptografado usando Google Cloud-powered encryption keys. O Pub/Sub criptografa mensagens com Google Cloud-powered encryption keys por padrão. Portanto, escolher essa opção mantém o comportamento padrão. O Google lida com o gerenciamento e a rotação de chaves automaticamente, garantindo que suas mensagens estejam sempre protegidas com a criptografia mais forte disponível. Essa opção não exige mais configurações. Para mais informações sobre Google Cloud-powered encryption keys, consulte Criptografia padrão com Google Cloud-powered encryption keys.

Chave do Cloud KMS

Especifica se o tópico é criptografado com uma chave de criptografia gerenciada pelo cliente (CMEK). O Pub/Sub criptografa mensagens com Google Cloud-powered encryption keys por padrão. Se você especificar essa opção, o Pub/Sub usará o padrão de criptografia de envelope com CMEK. Nessa abordagem, o Cloud KMS não criptografa as mensagens. Em vez disso, o Cloud KMS criptografa as chaves de criptografia de dados (DEKs) que o Pub/Sub cria para cada tópico. O Pub/Sub criptografa as mensagens usando a DEK mais recente gerada para o tópico. O Pub/Sub descriptografa as mensagens pouco antes de elas serem entregues aos assinantes. Para mais informações sobre como criar uma chave, consulte Configurar a criptografia de mensagens.

Criar um tópico

Crie um tópico antes de publicar ou assinar.

gcloud pubsub topics create TOPIC_ID

PUT https://pubsub.googleapis.com/v1/projects/PROJECT_ID/topics/TOPIC_ID
Authorization: Bearer ACCESS_TOKEN

{
"name": "projects/PROJECT_ID/topics/TOPIC_ID"
}

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::TopicAdminClient client, std::string project_id,
   std::string topic_id) {
  auto topic = client.CreateTopic(
      pubsub::Topic(std::move(project_id), std::move(topic_id)).FullName());
  // Note that kAlreadyExists is a possible error when the library retries.
  if (topic.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The topic already exists\n";
    return;
  }
  if (!topic) throw std::move(topic).status();

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

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

public class CreateTopicSample
{
    public Topic CreateTopic(string projectId, string topicId)
    {
        PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
        var topicName = TopicName.FromProjectTopic(projectId, topicId);
        Topic topic = null;

        try
        {
            topic = publisher.CreateTopic(topicName);
            Console.WriteLine($"Topic {topic.Name} created.");
        }
        catch (RpcException e) when (e.Status.StatusCode == StatusCode.AlreadyExists)
        {
            Console.WriteLine($"Topic {topicName} already exists.");
        }
        return topic;
    }
}

import (
	"context"
	"fmt"
	"io"

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

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: %w", err)
	}
	defer client.Close()

	topic := &pubsubpb.Topic{
		Name: fmt.Sprintf("projects/%s/topics/%s", projectID, topicID),
	}
	t, err := client.TopicAdminClient.CreateTopic(ctx, topic)
	if err != nil {
		return fmt.Errorf("CreateTopic: %w", err)
	}
	fmt.Fprintf(w, "Topic created: %v\n", t)
	return nil
}

import com.google.cloud.pubsub.v1.TopicAdminClient;
import com.google.pubsub.v1.Topic;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;

public class CreateTopicExample {
  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";

    createTopicExample(projectId, topicId);
  }

  public static void createTopicExample(String projectId, String topicId) throws IOException {
    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      TopicName topicName = TopicName.of(projectId, topicId);
      Topic topic = topicAdminClient.createTopic(topicName);
      System.out.println("Created topic: " + topic.getName());
    }
  }
}

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

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

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());
}

from google.cloud import pubsub_v1

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"

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

topic = publisher.create_topic(request={"name": topic_path})

print(f"Created topic: {topic.name}")

# topic_id = "your-topic-id"

pubsub = Google::Cloud::PubSub.new

topic_admin = pubsub.topic_admin

topic = topic_admin.create_topic name: pubsub.topic_path(topic_id)

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

A seguir

• Escolha o tipo de assinatura para seu tópico.

• Saiba como publicar uma mensagem em um tópico.

• Resolver um problema com um tema.

• Crie ou modifique um tópico com a CLI gcloud, as APIs REST ou as bibliotecas de cliente.