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 nele. O Pub/Sub oferece suporte a 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. Se quiser 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 Cloud de Confiance , a Google Cloud CLI, a biblioteca de cliente ou a API Pub/Sub.

Antes de começar

• Saiba mais sobre o serviço 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 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 acessar 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 de cada recurso. É possível criar uma assinatura em um projeto e anexá-la a um tópico localizado em outro projeto. Verifique se você tem as permissões necessárias para cada projeto.

Propriedades de um tema

Ao criar ou atualizar um tópico, é necessário 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 Cloud de Confiance. 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 dos Hubs de Eventos do Azure

• Criar um tópico do Amazon MSK

• Criar um tópico do Confluent Cloud

Ativar a retenção de mensagens de tópicos

Por padrão, um tópico do Pub/Sub descarta mensagens assim que são confirmadas por todas as assinaturas anexadas a ele. Também é possível configurar um tópico para reter mensagens por um período de até 31 dias, com um período mínimo de retenção de 10 minutos.

Com a retenção de mensagens, as assinaturas podem repetir mensagens confirmadas anteriormente ou mensagens publicadas antes da criação da assinatura. Para mais informações, consulte Reproduzir e limpar mensagens com busca.

Os custos de armazenamento das mensagens retidas pelo tópico são cobrados no projeto dele. Depois que o período de armazenamento de mensagens expira, o Pub/Sub pode descartar a mensagem, independente do estado de confirmação.

Para conferir métricas sobre mensagens retidas, use as seguintes métricas do Cloud Monitoring:

• topic/num_retained_messages: o número de mensagens retidas
• topic/oldest_retained_message_age: A idade da mensagem retida mais antiga
• topic/retained_bytes: o tamanho total das mensagens retidas, em bytes.

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, você pode 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

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

Para mais informações sobre SMTs, consulte a visão geral de 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 requer 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 a 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, na sigla em inglês) 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 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."

use google_cloud_pubsub::client::TopicAdmin;

pub async fn sample(client: &TopicAdmin, project_id: &str, topic_id: &str) -> anyhow::Result<()> {
    let topic = client
        .create_topic()
        .set_name(format!("projects/{project_id}/topics/{topic_id}"))
        .send()
        .await?;

    println!("successfully created topic {topic:?}");
    Ok(())
}

A seguir

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

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

• Resolver um problema de tema.

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