Excluir uma revisão de esquema para um tópico

Neste documento, mostramos como excluir revisões de esquemas para tópicos do Pub/Sub. A operação de exclusão de um esquema também exclui todas as revisões associadas a ele.

Cuidado: a exclusão é permanente. Não é possível restaurar uma revisão de esquema excluída. Todas as mensagens validadas em relação à revisão de esquema excluída no o horário da publicação não pode ser gravado no BigQuery usando Assinatura do BigQuery com usar esquema de temas ativado. Em vez de excluir uma revisão, considere revertendo um esquema.

Antes de começar

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

Papéis e permissões necessárias

Para receber as permissões necessárias para excluir e gerenciar revisões de esquema, peça ao administrador para conceder a você o Papel do IAM 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 excluir e gerenciar revisões de esquema. 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 excluir e gerenciar revisões de esquema:

• Criar esquema: pubsub.schemas.create
• Anexar esquema ao tópico: pubsub.schemas.attach
• Confirme uma revisão de esquema: pubsub.schemas.commit
• Exclua um esquema ou uma revisão de esquema: pubsub.schemas.delete
• Receber um esquema ou revisões de esquema: pubsub.schemas.get
• Esquemas de lista: pubsub.schemas.list
• Listar revisões de esquema: pubsub.schemas.listRevisions
• Fazer o rollback de 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

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

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

Excluir uma revisão de esquema

Importante: se todas as revisões dentro do intervalo de revisões das configurações do esquema de um tópico forem excluídas, todas as tentativas de publicação de mensagens para esse tópico vão falhar.

Veja a seguir algumas diretrizes importantes para excluir uma revisão de esquema:

• É possível excluir uma ou várias revisões de esquema de um esquema.

• Se o esquema tiver apenas uma revisão, não será possível excluí-la. Em vez disso, exclua o esquema.

• A operação de exclusão de um esquema também exclui todas as revisões associados ao esquema.

• Se você excluir um esquema, a publicação de mensagens em tópicos associados a esse esquema falhar.

• Se você excluir uma revisão de esquema e ela for especificada como a primeira revisão para um tópico, a próxima revisão será usada para validação.

  Se a revisão de esquema excluída for especificada como a última revisão de um a revisão de esquema anterior será usada para validação.

  Se a revisão do esquema excluída estiver dentro do intervalo de revisão especificado para um tópico de validação, a revisão será ignorada.

É possível excluir uma revisão de esquema usando o console do Google Cloud, a CLI gcloud, a API Pub/Sub, ou as bibliotecas de cliente do Cloud.

Console

1. No console do Google Cloud, acesse a página Esquemas do Pub/Sub.

   Acessar Esquemas

2. Clique no nome de um esquema.

   A página Detalhes do esquema é aberta.

3. Selecione a revisão que você quer excluir. Você também pode selecionar várias revisões.

4. Clique em Excluir revisão.

5. Confirme a operação de exclusão.

gcloud

gcloud pubsub schemas delete-revision SCHEMA_NAME@REVISION_ID

Em que:

• REVISION_ID é a revisão para a qual você quer reverter.

REST

Para excluir uma revisão de esquema, envie uma solicitação DELETE como esta:

POST https://pubsub.googleapis.com/v1/projects/PROJECT_ID/schemas/SCHEMA_ID@REVISION_ID:deleteRevision
Authorization: Bearer $(gcloud auth application-default print-access-token)
Content-Type: application/json --data @response-body.json

O corpo da resposta precisa conter uma representação JSON do recurso de esquema excluído.

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;
[](pubsub::SchemaServiceClient client, std::string const& project_id,
   std::string const& schema_id, std::string const& revision_id) {
  std::string const schema_id_with_revision = schema_id + "@" + revision_id;

  google::pubsub::v1::DeleteSchemaRevisionRequest request;
  request.set_name(
      pubsub::Schema(project_id, schema_id_with_revision).FullName());
  auto schema = client.DeleteSchemaRevision(request);
  if (!schema) throw std::move(schema).status();

  std::cout << "Deleted schema. Its metadata is:"
            << "\n"
            << schema->DebugString() << "\n";
}

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 deleteSchemaRevision(w io.Writer, projectID, schemaID, revisionID string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema-id"
	// revisionID := "my-revision-id"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %w", err)
	}
	defer client.Close()

	if _, err := client.DeleteSchemaRevision(ctx, schemaID, revisionID); err != nil {
		return fmt.Errorf("client.DeleteSchema revision: %w", err)
	}
	fmt.Fprintf(w, "Deleted a schema revision: %s@%s", schemaID, revisionID)
	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.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.DeleteSchemaRevisionRequest;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;

public class DeleteSchemaRevisionExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id@your-revision-id";

    deleteSchemaRevisionExample(projectId, schemaId);
  }

  public static void deleteSchemaRevisionExample(String projectId, String schemaId)
      throws IOException {
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      DeleteSchemaRevisionRequest request =
          DeleteSchemaRevisionRequest.newBuilder().setName(schemaName.toString()).build();

      schemaServiceClient.deleteSchemaRevision(request);

      System.out.println("Deleted a schema revision:" + schemaName);

    } catch (NotFoundException e) {
      System.out.println(schemaName + "not found.");
    }
  }
}

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 NotFound
from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# revision_id = "your-revision-id"

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id + "@" + revision_id)

try:
    schema_client.delete_schema_revision(request={"name": schema_path})
    print(f"Deleted a schema revision:\n{schema_path}")
except NotFound:
    print(f"{schema_id} not found.")

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 schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';
// const revisionId = 'YOUR_REVISION_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 deleteSchemaRevision(schemaNameOrId, revisionId) {
  // Get the fully qualified schema name.
  const schema = pubSubClient.schema(schemaNameOrId);
  const name = await schema.getName();

  // Use the gapic client to delete the schema revision.
  const schemaClient = await pubSubClient.getSchemaClient();
  await schemaClient.deleteSchemaRevision({
    name: `${name}@${revisionId}`,
  });

  console.log(`Schema ${name} revision ${revisionId} deleted.`);
}

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 schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';
// const revisionId = 'YOUR_REVISION_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 deleteSchemaRevision(
  schemaNameOrId: string,
  revisionId: string
) {
  // Get the fully qualified schema name.
  const schema = pubSubClient.schema(schemaNameOrId);
  const name = await schema.getName();

  // Use the gapic client to delete the schema revision.
  const schemaClient = await pubSubClient.getSchemaClient();
  await schemaClient.deleteSchemaRevision({
    name: `${name}@${revisionId}`,
  });

  console.log(`Schema ${name} revision ${revisionId} deleted.`);
}

A seguir

• Excluir um esquema
• Esquemas de listas
• Listar revisões de um esquema
• Assinar um tópico com um esquema