Esta página foi traduzida pela API Cloud Translation.

Associar um esquema a um tópico

Neste documento, mostramos como associar esquemas para tópicos do Pub/Sub.

Antes de começar

Entenda como os esquemas do Pub/Sub funcionam.
Crie um esquema.

Papéis e permissões necessárias

Para ter as permissões necessárias para associar e gerenciar esquemas, 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 como conceder papéis, consulte Gerenciar acesso.

Esse papel predefinido contém as permissões necessárias para associar e gerenciar esquemas. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para associar e gerenciar esquemas:

Criar esquema: pubsub.schemas.create
Anexar esquema ao tópico: pubsub.schemas.attach
Confirmar uma revisão de esquema: pubsub.schemas.commit
Excluir um esquema ou uma revisão de esquema: pubsub.schemas.delete
Receber uma revisão de esquema ou esquema: pubsub.schemas.get
Listar esquemas: pubsub.schemas.list
Listar revisões de esquema: pubsub.schemas.listRevisions
Reverter um esquema: pubsub.schemas.rollback
Validar uma mensagem: pubsub.schemas.validate
Consiga a política do IAM para um esquema: pubsub.schemas.getIamPolicy
Configure a política do IAM para um esquema: pubsub.schemas.setIamPolicy

Talvez você também consiga receber essas permissões com papéis personalizados ou outros papéis predefinidos.

É possível conceder papéis e permissões a principais como usuários, grupos, domínios ou contas de serviço. É possível criar um esquema em um projeto e anexá-lo a um tópico localizado em outro projeto. Verifique se você tem as permissões necessárias para cada projeto.

Diretrizes para associar um esquema a um tópico

Você pode associar um esquema a um tópico ao criar ou editar um tópico. Estas são as diretrizes para associar um esquema a um tópico:

É possível associar um esquema a um ou mais tópicos.

Depois que um esquema é associado a um tópico, todas as mensagens que o tópico recebe dos editores precisam seguir esse esquema.
Ao associar um esquema a um tópico, você também precisa especificar a codificação das mensagens a serem publicadas como BINARY ou JSON. Se você estiver usando JSON com um esquema Avro, preste muita atenção às regras de codificação para uniões.
Se um esquema associado a um tópico tiver revisões, as mensagens precisarão corresponder à codificação e validar em relação a uma revisão dentro do intervalo disponível. Se eles não forem validados, a mensagem não será publicada.

As revisões são testadas em ordem cronológica inversa, com base no horário de criação. Para criar uma revisão de esquema, consulte Confirmar uma revisão de esquema.

Lógica de validação para um esquema de mensagem

Ao associar um esquema a um tópico e ele tiver revisões, será possível especificar um subconjunto de revisões a ser usada. Se você não especificar um intervalo, todo o intervalo será usado para validação.

Se você não especificar uma revisão como Primeira revisão permitida, a revisão atual mais antiga do esquema será usada para validação. Se você não especificar uma revisão como Última revisão permitida, a revisão atual mais recente para o esquema será usada.

Vamos usar o exemplo do esquema S anexado ao tópico T.

O esquema S tem os IDs de revisão A, B, C e D criados em ordem, em que A é a primeira ou a mais antiga. Nenhum dos esquemas é idêntico aos outros nem às reversões de um esquema atual.

Se você definir apenas o campo Primeira revisão permitida como B, as mensagens em conformidade apenas com o esquema A serão rejeitadas, enquanto as mensagens em conformidade com os esquemas B, C e D serão aceitas.
Se você definir apenas o campo Última revisão permitida como C, as mensagens que estiverem em conformidade com os esquemas A, B e C serão aceitas, e as mensagens em conformidade apenas com o esquema D serão rejeitadas.
Se você definir os campos Primeira revisão permitida como B e Última revisão permitida como C, as mensagens que estiverem em conformidade com os esquemas B e C serão aceitas.
Também é possível definir a primeira e a última revisão com o mesmo ID. Nesse caso, apenas as mensagens que estiverem em conformidade com essa revisão serão aceitas.

Criar e associar um esquema ao criar um tópico

É possível criar um tópico com um esquema usando o console do Google Cloud, a CLI gcloud, a API Pub/Sub ou as bibliotecas de cliente do Cloud.

Console

No console do Google Cloud, acesse a página de tópicos do Pub/Sub.

Acesse Tópicos
Selecione Criar tópico.
No campo Código do tópico, insira um código para o tópico.

Para nomear um tópico, consulte as diretrizes.
Marque a caixa Usar um esquema.

Mantenha as configurações padrão para os campos restantes.

É possível criar um esquema ou usar um existente.
Se você estiver criando um esquema, siga estas etapas: `
1. Em Selecionar um esquema do Pub/Sub, escolha Criar um novo esquema.
A página Criar esquema é exibida em uma guia secundária.

Siga as etapas em Criar um esquema.
1. Volte para a guia Criar tópico e clique em Atualizar.
2. Procure seu esquema no campo Selecionar um esquema do Pub/Sub.
3. Selecione a codificação de mensagens como JSON ou Binário.
O esquema que você acabou de criar tem um ID de revisão. É possível criar revisões de esquema adicionais, conforme discutido em Confirmar uma revisão de esquema.
Se você estiver associando um esquema já criado, siga estas etapas:
1. Em Selecionar um esquema do Pub/Sub, escolha um esquema atual.
2. Selecione a codificação de mensagens como JSON ou Binário.
Opcional: se o esquema selecionado tiver revisões, em Intervalo de revisões, use os menus suspensos de Primeira revisão permitida e Última revisão permitida.

É possível especificar os dois campos, especificar apenas um ou manter as configurações padrão com base nos seus requisitos.

Mantenha as configurações padrão para os campos restantes.
Clique em Criar para salvar o tópico e atribuí-lo ao esquema selecionado.

gcloud

Para criar um tópico atribuído com um esquema criado anteriormente, execute o comando gcloud pubsub topics create:

gcloud pubsub topics create TOPIC_ID \
        --message-encoding=ENCODING_TYPE \
        --schema=SCHEMA_ID \
        --first-revision-id=FIRST_REVISION_ID \
        --last-revision-id=LAST_REVISION_ID \

Em que:

TOPIC_ID é o ID do tópico que você está criando.
ENCODING_TYPE é a codificação de mensagens validadas em relação ao esquema. Esse valor precisa ser definido como JSON ou BINARY.
SCHEMA_ID é o ID de um esquema existente.
FIRST_REVISION_ID é o ID da revisão mais antiga para validação.
LAST_REVISION_ID é o ID da revisão mais recente para validação.

Tanto --first-revision-id quanto --last-revision-id são opcionais.

Também é possível atribuir um esquema de outro projeto do Google Cloud:

gcloud pubsub topics create TOPIC_ID \
        --message-encoding=ENCODING_TYPE \
        --schema=SCHEMA_ID \
        --schema-project=SCHEMA_PROJECT \
        --project=TOPIC_PROJECT

Em que:

SCHEMA_PROJECT é o ID do projeto do Google Cloud para o esquema.
TOPIC_PROJECT é o ID do projeto do Google Cloud para o tópico.

REST

Para criar um tópico, use o método projects.topics.create:

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/PROJECT_ID/topics/TOPIC_ID
Authorization: Bearer ACCESS_TOKEN

Corpo da solicitação:

{
  "schemaSettings": {
    "schema": "SCHEMA_NAME",
    "encoding": "ENCODING_TYPE"
    "firstRevisionId": "FIRST_REVISION_ID"
    "lastRevisionId": "LAST_REVISION_ID"
  }
}

Em que:

PROJECT_ID é o ID do projeto;
TOPIC_ID é o ID do tópico.
SCHEMA_NAME é o nome do esquema em que as mensagens publicadas precisam ser validadas. O formato é: projects/PROJECT_ID/schemas/SCHEMA_ID.
ENCODING_TYPE é a codificação de mensagens validadas em relação ao esquema. Precisa ser definido como JSON ou BINARY.
FIRST_REVISION_ID é o ID da revisão mais antiga para validação.
LAST_REVISION_ID é o ID da revisão mais recente para validação.

Tanto firstRevisionId quanto lastRevisionId são opcionais.

Resposta:

{
  "name": "projects/PROJECT_ID/topics/TOPIC_ID",
  "schemaSettings": {
    "schema": "SCHEMA_NAME",
    "encoding": "ENCODING_TYPE"
    "firstRevisionId": "FIRST_REVISION_ID"
    "lastRevisionId": "LAST_REVISION_ID"
  }
}

Tanto firstRevisionId quanto lastRevisionId serão omitidos se não forem fornecidos na solicitação.

C++

Antes de tentar esse exemplo, siga as instruções de configuração do C++ em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub C++.

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::TopicAdminClient client, std::string project_id,
   std::string topic_id, std::string schema_id, std::string const& encoding) {
  google::pubsub::v1::Topic request;
  request.set_name(pubsub::Topic(project_id, std::move(topic_id)).FullName());
  request.mutable_schema_settings()->set_schema(
      pubsub::Schema(std::move(project_id), std::move(schema_id)).FullName());
  request.mutable_schema_settings()->set_encoding(
      encoding == "JSON" ? google::pubsub::v1::JSON
                         : google::pubsub::v1::BINARY);
  auto topic = client.CreateTopic(request);

  // 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";
}

C#

Antes de tentar esse exemplo, siga as instruções de configuração do C# em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub C#.


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

public class CreateTopicWithSchemaSample
{
    public Topic CreateTopicWithSchema(string projectId, string topicId, string schemaId, Encoding encoding)
    {
        PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
        var topicName = TopicName.FromProjectTopic(projectId, topicId);
        Topic topic = new Topic
        {
            TopicName = topicName,
            SchemaSettings = new SchemaSettings
            {
                SchemaAsSchemaName = SchemaName.FromProjectSchema(projectId, schemaId),
                Encoding = encoding
            }
        };

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

Go

Antes de tentar esse exemplo, siga as instruções de configuração do Go em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Go.

import (
	"context"
	"fmt"
	"io"

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

func createTopicWithSchemaRevisions(w io.Writer, projectID, topicID, schemaID, firstRevisionID, lastRevisionID string, encoding pubsub.SchemaEncoding) error {
	// projectID := "my-project-id"
	// topicID := "my-topic"
	// schemaID := "my-schema-id"
	// firstRevisionID := "my-revision-id"
	// lastRevisionID := "my-revision-id"
	// encoding := pubsub.EncodingJSON
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}

	tc := &pubsub.TopicConfig{
		SchemaSettings: &pubsub.SchemaSettings{
			Schema:          fmt.Sprintf("projects/%s/schemas/%s", projectID, schemaID),
			FirstRevisionID: firstRevisionID,
			LastRevisionID:  lastRevisionID,
			Encoding:        encoding,
		},
	}
	t, err := client.CreateTopicWithConfig(ctx, topicID, tc)
	if err != nil {
		return fmt.Errorf("CreateTopicWithConfig: %w", err)
	}
	fmt.Fprintf(w, "Created topic with schema revision: %#v\n", t)
	return nil
}

Java

Antes de tentar essa amostra, siga as instruções de configuração do Java em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Java.


import com.google.api.gax.rpc.AlreadyExistsException;
import com.google.cloud.pubsub.v1.TopicAdminClient;
import com.google.pubsub.v1.Encoding;
import com.google.pubsub.v1.SchemaName;
import com.google.pubsub.v1.SchemaSettings;
import com.google.pubsub.v1.Topic;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;

public class CreateTopicWithSchemaRevisionsExample {

  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";
    // Use an existing schema.
    String schemaId = "your-schema-id";
    // Choose either BINARY or JSON message serialization in this topic.
    Encoding encoding = Encoding.BINARY;
    // Set the minimum and maximum revsion ID
    String firstRevisionId = "your-revision-id";
    String lastRevisionId = "your-revision-id";

    createTopicWithSchemaRevisionsExample(
        projectId, topicId, schemaId, firstRevisionId, lastRevisionId, encoding);
  }

  public static void createTopicWithSchemaRevisionsExample(
      String projectId,
      String topicId,
      String schemaId,
      String firstRevisionid,
      String lastRevisionId,
      Encoding encoding)
      throws IOException {
    TopicName topicName = TopicName.of(projectId, topicId);
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    SchemaSettings schemaSettings =
        SchemaSettings.newBuilder()
            .setSchema(schemaName.toString())
            .setFirstRevisionId(firstRevisionid)
            .setLastRevisionId(lastRevisionId)
            .setEncoding(encoding)
            .build();

    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {

      Topic topic =
          topicAdminClient.createTopic(
              Topic.newBuilder()
                  .setName(topicName.toString())
                  .setSchemaSettings(schemaSettings)
                  .build());

      System.out.println("Created topic with schema: " + topic.getName());
    } catch (AlreadyExistsException e) {
      System.out.println(schemaName + "already exists.");
    }
  }
}

Node.js

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

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const schemaName = 'YOUR_SCHEMA_NAME_OR_ID';
// const encodingType = 'BINARY';

// 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 createTopicWithSchema(
  topicNameOrId,
  schemaNameOrId,
  encodingType
) {
  // Get the fully qualified schema name.
  const schema = pubSubClient.schema(schemaNameOrId);
  const fullName = await schema.getName();

  // Creates a new topic with a schema. Note that you might also
  // pass Encodings.Json or Encodings.Binary here.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    schemaSettings: {
      schema: fullName,
      encoding: encodingType,
    },
  });
  console.log(`Topic ${topicNameOrId} created with schema ${fullName}.`);
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const schemaName = 'YOUR_SCHEMA_NAME_OR_ID';
// const encodingType = 'BINARY';

// 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 createTopicWithSchema(
  topicNameOrId: string,
  schemaNameOrId: string,
  encodingType: 'BINARY' | 'JSON'
) {
  // Get the fully qualified schema name.
  const schema = pubSubClient.schema(schemaNameOrId);
  const fullName = await schema.getName();

  // Creates a new topic with a schema. Note that you might also
  // pass Encodings.Json or Encodings.Binary here.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    schemaSettings: {
      schema: fullName,
      encoding: encodingType,
    },
  });
  console.log(`Topic ${topicNameOrId} created with schema ${fullName}.`);
}

PHP

Antes de tentar esse exemplo, siga as instruções de configuração do PHP em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub PHP.

use Google\Cloud\PubSub\PubSubClient;
use Google\Cloud\PubSub\Schema;

/**
 * Create a topic with a schema.
 *
 * @param string $projectId
 * @param string $topicId
 * @param string $schemaId
 * @param string $encoding
 */
function create_topic_with_schema($projectId, $topicId, $schemaId, $encoding)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);

    $schema = $pubsub->schema($schemaId);

    $topic = $pubsub->createTopic($topicId, [
        'schemaSettings' => [
            // The schema may be provided as an instance of the schema type,
            // or by using the schema ID directly.
            'schema' => $schema,
            // Encoding may be either `BINARY` or `JSON`.
            // Provide a string or a constant from Google\Cloud\PubSub\V1\Encoding.
            'encoding' => $encoding,
        ]
    ]);

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

Python

Antes de tentar esse exemplo, siga as instruções de configuração do Python em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Python.

from google.api_core.exceptions import AlreadyExists, InvalidArgument
from google.cloud.pubsub import PublisherClient, SchemaServiceClient
from google.pubsub_v1.types import Encoding

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# schema_id = "your-schema-id"
# first_revision_id = "your-revision-id"
# last_revision_id = "your-revision-id"
# Choose either BINARY or JSON as valid message encoding in this topic.
# message_encoding = "BINARY"

publisher_client = PublisherClient()
topic_path = publisher_client.topic_path(project_id, topic_id)

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)

if message_encoding == "BINARY":
    encoding = Encoding.BINARY
elif message_encoding == "JSON":
    encoding = Encoding.JSON
else:
    encoding = Encoding.ENCODING_UNSPECIFIED

try:
    response = publisher_client.create_topic(
        request={
            "name": topic_path,
            "schema_settings": {
                "schema": schema_path,
                "encoding": encoding,
                "first_revision_id": first_revision_id,
                "last_revision_id": last_revision_id,
            },
        }
    )
    print(f"Created a topic:\n{response}")

except AlreadyExists:
    print(f"{topic_id} already exists.")
except InvalidArgument:
    print("Please choose either BINARY or JSON as a valid message encoding type.")

Ruby

Antes de tentar esse exemplo, siga as instruções de configuração do Ruby em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Ruby.

# topic_id = "your-topic-id"
# schema_id = "your-schema-id"
# Choose either BINARY or JSON as valid message encoding in this topic.
# message_encoding = :binary

pubsub = Google::Cloud::Pubsub.new

topic = pubsub.create_topic topic_id, schema_name: schema_id, message_encoding: message_encoding

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

Editar um esquema associado a um tópico

É possível editar um tópico para anexar, remover ou atualizar o intervalo de revisão usado para validar mensagens. Em geral, se você tiver alterações planejadas para o esquema em uso, confirme uma nova revisão e atualize o intervalo de revisões usado para o tópico.

É possível editar um esquema associado a um tópico usando o console do Google Cloud, a CLI gcloud, a API Pub/Sub ou as bibliotecas de cliente do Cloud.

Console

No console do Google Cloud, acesse a página de tópicos do Pub/Sub.

Acesse Tópicos
Clique no ID do tópico.
Na página de detalhes do tópico, clique em Editar.
É possível fazer as alterações a seguir no esquema.

Pode levar alguns minutos para que as mudanças entrem em vigor.
- Se quiser remover o esquema do tópico, na página Editar tópico, desmarque a caixa de seleção Usar um esquema.
- Se você quiser alterar o esquema, na seção Esquema, selecione o nome dele.
Atualize os outros campos conforme necessário.
- Caso queira atualizar o intervalo de revisão, em Intervalo de revisão, use os menus suspensos de Primeira revisão permitida e Última revisão permitida.
É possível especificar os dois campos, especificar apenas um ou manter as configurações padrão com base nos seus requisitos.
Clique em Atualizar para salvar as mudanças.

gcloud

gcloud pubsub topics update TOPIC_ID \
        --message-encoding=ENCODING_TYPE \
        --schema=SCHEMA_NAME \
        --first-revision-id=FIRST_REVISION_ID \
        --last-revision-id=LAST_REVISION_ID \

Em que:

TOPIC_ID é o ID do tópico que você está criando.
ENCODING_TYPE é a codificação de mensagens validadas em relação ao esquema. Esse valor precisa ser definido como JSON ou BINARY.
SCHEMA_NAME é o nome de um esquema existente.
FIRST_REVISION_ID é o ID da revisão mais antiga para validação.
LAST_REVISION_ID é o ID da revisão mais recente para validação.

Tanto --first-revision-id quanto --last-revision-id são opcionais.

REST

Para atualizar um tópico, use o método projects.topics.patch:

Solicitação:

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

Corpo da solicitação:

{
  "schemaSettings": {
    "schema": "SCHEMA_NAME",
    "encoding": "ENCODING_TYPE"
    "firstRevisionId": "FIRST_REVISION_ID"
    "lastRevisionId": "LAST_REVISION_ID"
    "update_mask":
  }
}

Em que:

PROJECT_ID é o ID do projeto;
TOPIC_ID é o ID do tópico.
SCHEMA_NAME é o nome do esquema em que as mensagens publicadas precisam ser validadas. O formato é: projects/PROJECT_ID/schemas/SCHEMA_ID.
ENCODING_TYPE é a codificação de mensagens validadas em relação ao esquema. Precisa ser definido como JSON ou BINARY.
FIRST_REVISION_ID é o ID da revisão mais antiga para validação.
LAST_REVISION_ID é o ID da revisão mais recente para validação.

Tanto firstRevisionId quanto lastRevisionId são opcionais.

Resposta:

{
  "name": "projects/PROJECT_ID/topics/TOPIC_ID",
  "schemaSettings": {
    "schema": "SCHEMA_NAME",
    "encoding": "ENCODING_TYPE"
    "firstRevisionId": "FIRST_REVISION_ID"
    "lastRevisionId": "LAST_REVISION_ID"
  }
}

Os valores firstRevisionId e lastRevisionId não são definidos após a atualização.

C++

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::TopicAdminClient client, std::string project_id,
   std::string topic_id, std::string const& first_revision_id,
   std::string const& last_revision_id) {
  google::pubsub::v1::UpdateTopicRequest request;
  auto* request_topic = request.mutable_topic();
  request_topic->set_name(
      pubsub::Topic(std::move(project_id), std::move(topic_id)).FullName());
  request_topic->mutable_schema_settings()->set_first_revision_id(
      first_revision_id);
  request_topic->mutable_schema_settings()->set_last_revision_id(
      last_revision_id);
  *request.mutable_update_mask()->add_paths() =
      "schema_settings.first_revision_id";
  *request.mutable_update_mask()->add_paths() =
      "schema_settings.last_revision_id";
  auto topic = client.UpdateTopic(request);

  if (!topic) throw std::move(topic).status();

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

Go

import (
	"context"
	"fmt"
	"io"

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

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

	// This updates the first / last revision ID for the topic's schema.
	// To clear the schema entirely, use a zero valued (empty) SchemaSettings.
	tc := pubsub.TopicConfigToUpdate{
		SchemaSettings: &pubsub.SchemaSettings{
			FirstRevisionID: firstRevisionID,
			LastRevisionID:  lastRevisionID,
		},
	}

	gotTopicCfg, err := t.Update(ctx, tc)
	if err != nil {
		fmt.Fprintf(w, "topic.Update err: %v\n", gotTopicCfg)
		return err
	}
	fmt.Fprintf(w, "Updated topic with schema: %#v\n", gotTopicCfg)
	return nil
}

Java


import com.google.cloud.pubsub.v1.TopicAdminClient;
import com.google.protobuf.FieldMask;
import com.google.pubsub.v1.SchemaSettings;
import com.google.pubsub.v1.Topic;
import com.google.pubsub.v1.TopicName;
import com.google.pubsub.v1.UpdateTopicRequest;
import java.io.IOException;

public class UpdateTopicSchemaExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    // This is an existing topic that has schema settings attached to it.
    String topicId = "your-topic-id";
    // Set the minimum and maximum revsion ID
    String firstRevisionId = "your-revision-id";
    String lastRevisionId = "your-revision-id";

    UpdateTopicSchemaExample.updateTopicSchemaExample(
        projectId, topicId, firstRevisionId, lastRevisionId);
  }

  public static void updateTopicSchemaExample(
      String projectId, String topicId, String firstRevisionid, String lastRevisionId)
      throws IOException {
    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {

      TopicName topicName = TopicName.of(projectId, topicId);

      // Construct the schema settings with the changes you want to make.
      SchemaSettings schemaSettings =
          SchemaSettings.newBuilder()
              .setFirstRevisionId(firstRevisionid)
              .setLastRevisionId(lastRevisionId)
              .build();

      // Construct the topic with the schema settings you want to change.
      Topic topic =
          Topic.newBuilder()
              .setName(topicName.toString())
              .setSchemaSettings(schemaSettings)
              .build();

      // Construct a field mask to indicate which field to update in the topic.
      FieldMask updateMask =
          FieldMask.newBuilder()
              .addPaths("schema_settings.first_revision_id")
              .addPaths("schema_settings.last_revision_id")
              .build();

      UpdateTopicRequest request =
          UpdateTopicRequest.newBuilder().setTopic(topic).setUpdateMask(updateMask).build();

      Topic response = topicAdminClient.updateTopic(request);

      System.out.println("Updated topic with schema: " + topic.getName());
    }
  }
}

Python

from google.api_core.exceptions import InvalidArgument, NotFound
from google.cloud.pubsub import PublisherClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# first_revision_id = "your-revision-id"
# last_revision_id = "your-revision-id"

publisher_client = PublisherClient()
topic_path = publisher_client.topic_path(project_id, topic_id)

try:
    response = publisher_client.update_topic(
        request={
            "topic": {
                "name": topic_path,
                "schema_settings": {
                    "first_revision_id": first_revision_id,
                    "last_revision_id": last_revision_id,
                },
            },
            "update_mask": "schemaSettings.firstRevisionId,schemaSettings.lastRevisionId",
        }
    )
    print(f"Updated a topic schema:\n{response}")

except NotFound:
    print(f"{topic_id} not found.")
except InvalidArgument:
    print("Schema settings are not valid.")

Associar um esquema a um tópico

Antes de começar

Papéis e permissões necessárias

Permissões necessárias

Diretrizes para associar um esquema a um tópico

Lógica de validação para um esquema de mensagem

Criar e associar um esquema ao criar um tópico

Console

gcloud

REST

C++

C#

Go

Java

Node.js

Node.js

PHP

Python

Ruby

Editar um esquema associado a um tópico

Console

gcloud

REST

C++

Go

Java

Python

A seguir