Supprimer une révision de schéma pour un sujet

Ce document explique comment supprimer des révisions de schéma pour Pub/Sub sujets. L'opération de suppression d'un schéma supprime également toutes les révisions associées au schéma.

Attention : La suppression est définitive. Vous ne pouvez pas restaurer une révision de schéma supprimée. Les messages validés par rapport à la version du schéma supprimée au moment de la publication ne peuvent pas être écrits dans BigQuery à l'aide d'un abonnement BigQuery avec l'option Utiliser un schéma avec sujet activée. Au lieu de supprimer une révision, Effectuer le rollback d'un schéma

Avant de commencer

• Découvrez le fonctionnement des schémas Pub/Sub.
• Créez un schéma.

Rôles et autorisations requis

Pour obtenir les autorisations nécessaires pour supprimer et gérer les révisions de schéma, demandez à votre administrateur de vous accorder le rôle IAM Éditeur Pub/Sub (roles/pubsub.editor) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour supprimer et gérer les révisions de schéma. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Vous devez disposer des autorisations suivantes pour supprimer et gérer les révisions de schéma :

• Créer un schéma : pubsub.schemas.create
• Associez le schéma au sujet: pubsub.schemas.attach
• Effectuez un commit d'une révision du schéma: pubsub.schemas.commit
• Supprimez un schéma ou une révision de schéma : pubsub.schemas.delete
• Obtenez un schéma ou des révisions de schéma: pubsub.schemas.get
• Schémas de liste : pubsub.schemas.list
• Liste des révisions de schéma : pubsub.schemas.listRevisions
• Effectuer un rollback d'un schéma : pubsub.schemas.rollback
• Valider un message : pubsub.schemas.validate
• Obtenez la stratégie IAM pour un schéma: pubsub.schemas.getIamPolicy
• Configurez la stratégie IAM pour un schéma : pubsub.schemas.setIamPolicy

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Vous pouvez accorder des rôles et des autorisations à des comptes principaux tels que des utilisateurs, des groupes, des domaines ou des comptes de service. Vous pouvez créer un schéma dans un projet le joindre à un sujet situé dans un autre projet. Assurez-vous de disposer des autorisations requises pour chaque projet.

Supprimer une révision de schéma

Important :Si toutes les révisions comprises dans la plage de révisions des paramètres du schéma d'un sujet sont supprimées, toutes les tentatives de publication de messages sur ce sujet échouent.

Voici quelques consignes importantes pour supprimer une révision de schéma:

• Vous pouvez supprimer une ou plusieurs révisions de schéma.

• Si le schéma ne comporte qu'une seule révision, vous ne pouvez pas la supprimer. Supprimez plutôt le schéma.

• L'opération de suppression d'un schéma supprime également toutes les révisions associées au schéma.

• Si vous supprimez un schéma, la publication de messages dans les sujets associés à ce schéma échoue.

• Si vous supprimez une révision de schéma et qu'elle est spécifiée comme première révision pour un sujet, la révision suivante est utilisée à la place pour la validation.

  Si la révision de schéma supprimée est spécifiée comme dernière révision pour un sujet, la révision de schéma précédente est utilisée à la place pour la validation.

  Si la révision de schéma supprimée se trouve dans la plage de révisions spécifiée pour un sujet à valider, la révision est ignorée.

Vous pouvez supprimer une révision de schéma à l'aide de la la console Google Cloud, la gcloud CLI, l'API Pub/Sub, ou les bibliothèques clientes Cloud.

Console

1. Dans la console Google Cloud, accédez à la page Schémas Pub/Sub.

   Accéder à la page "Schémas"

2. Cliquez sur le nom d'un schéma existant.

   La page Détails du schéma s'ouvre.

3. Sélectionnez la révision que vous souhaitez supprimer. Vous pouvez également sélectionner plusieurs révisions.

4. Cliquez sur Supprimer la révision.

5. Confirmez l'opération de suppression.

gcloud

gcloud pubsub schemas delete-revision SCHEMA_NAME@REVISION_ID

Où :

• REVISION_ID correspond à la révision vers laquelle vous souhaitez effectuer le rollback.

REST

Pour supprimer une révision de schéma, envoyez une requête DELETE semblable à celle-ci:

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

Le corps de la réponse doit contenir une représentation JSON des éléments supprimés ressource de schéma.

C++

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage C++ qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Go qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Java qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Python qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Node.js qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Node.js qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour 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.`);
}

Étape suivante

• Supprimer un schéma
• List schemas
• Répertorier les révisions d'un schéma
• S'abonner à un sujet avec un schéma