Cette page a été traduite par l'API Cloud Translation.

Associer un schéma à un sujet

Ce document vous explique comment associer des schémas aux sujets Pub/Sub.

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 associer et gérer des schémas, 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 associer et gérer des schémas. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour associer et gérer des schémas:

Créer un schéma : pubsub.schemas.create
Associer le schéma au sujet : pubsub.schemas.attach
Valider une révision de schéma : pubsub.schemas.commit
Supprimez un schéma ou une révision de schéma : pubsub.schemas.delete
Obtenir un schéma ou des révisions de schéma : pubsub.schemas.get
Répertorier les schémas: 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 d'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 et l'associer à un sujet situé dans un autre projet. Assurez-vous de disposer des autorisations requises pour chaque projet.

Consignes pour associer un schéma à un sujet

Vous pouvez associer un schéma à un sujet lorsque vous le créez ou le modifiez. Voici les consignes à suivre pour associer un schéma à un sujet :

Vous pouvez associer un schéma à un ou plusieurs sujets.

Une fois qu'un schéma est associé à un sujet, chaque message que le sujet reçoit des éditeurs doit suivre ce schéma.
Lorsque vous associez un schéma à un sujet, vous devez également spécifier l'encodage des messages à publier en tant que BINARY ou JSON. Si vous utilisez du JSON avec un schéma Avro, veillez à respecter les règles d'encodage pour les unions.
Si un schéma associé à un sujet comporte des révisions, les messages doivent correspondre à l'encodage et être validés par rapport à une révision de la plage disponible. Si elles ne le font pas, la publication du message échoue.

Les révisions sont essayées dans l'ordre chronologique inverse, en fonction de l'heure de création. Pour créer une révision de schéma, consultez Validez une révision de schéma.

Logique de validation pour un schéma de message

Lorsque vous associez un schéma à un sujet et que le schéma comporte des révisions, vous pouvez spécifier un sous-ensemble de révisions à utiliser. Si vous ne spécifiez pas de plage, l'ensemble de la plage est utilisé pour la validation.

Si vous ne définissez pas de révision sur Première révision autorisée, alors la révision la plus ancienne du schéma est utilisée pour la validation. Si vous ne définissez pas de révision comme Dernière révision autorisée, alors la révision existante la plus récente pour le schéma est utilisée.

Prenons l'exemple du schéma S associé au sujet T.

Les ID de révision A, B, C et D du schéma S sont créés dans l'ordre. où A correspond à la première ou à la plus ancienne révision. Aucun des schémas n'est identique aux autres ni n'est un rollback d'un schéma existant.

Si vous définissez uniquement le champ Première révision autorisée sur B, les messages conformes uniquement au schéma A sont rejetés, tandis que les messages conformes aux schémas B, C et D sont acceptés.
Si vous ne définissez que le champ Dernière révision autorisée sur C, les messages conformes aux schémas A, B et C sont acceptés, et les messages conformes uniquement au schéma D sont rejetés.
Si vous définissez les deux champs Première révision autorisée sur B et Dernière révision autorisée sur C, les messages conformes aux schémas B et C sont acceptés.
Vous pouvez également définir la première et la dernière révision sur le même ID de révision. Dans ce cas, seuls les messages conformes à cette révision sont acceptés.

Créer et associer un schéma lorsque vous créez un sujet

Vous pouvez créer un sujet avec un schéma à l'aide de la console Google Cloud, de la CLI gcloud, de l'API Pub/Sub ou des bibliothèques clientes Cloud.

Console

Dans la console Google Cloud, accédez à la page Sujets Pub/Sub.

Accéder aux sujets
Cliquez sur Create topic (Créer un sujet).
Dans le champ ID du sujet, saisissez un ID pour votre sujet.

Pour nommer un sujet, consultez les consignes.
Cochez la case Utiliser un schéma.

Conservez les paramètres par défaut pour les autres champs.

Vous pouvez créer un schéma ou utiliser un schéma existant.
Si vous créez un schéma, procédez comme suit : `
1. Dans le champ Sélectionner un schéma Pub/Sub, sélectionnez Créer un schéma.
La page Créer un schéma s'affiche dans un onglet secondaire.

Suivez la procédure décrite dans Créer un schéma.
1. Revenez à l'onglet Créer un sujet et cliquez sur Actualiser.
2. Recherchez votre schéma dans le champ Sélectionner un schéma Pub/Sub.
3. Sélectionnez l'encodage du message en tant que JSON ou Binary (Binaire).
Le schéma que vous venez de créer possède un ID de révision. Vous pouvez créer d'autres révisions de schéma, comme indiqué dans la section Valider une révision de schéma.
Si vous associez un schéma déjà créé, procédez comme suit :
1. Dans le champ Sélectionner un schéma Pub/Sub, sélectionnez un schéma existant.
2. Sélectionnez l'encodage du message en tant que JSON ou Binary (Binaire).
Facultatif : Si le schéma sélectionné comporte des révisions, pour Plage de révisions, utilisez les menus déroulants Première révision autorisée et Dernière révision autorisée.

Vous pouvez spécifier les deux champs, n'en spécifier qu'un seul ou conserver les paramètres par défaut en fonction de vos exigences.

Conservez les paramètres par défaut pour les autres champs.
Cliquez sur Créer pour enregistrer le sujet et l'attribuer au schéma sélectionné.

gcloud

Pour créer un sujet associé à un schéma créé précédemment, exécutez la commande 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 \

Où :

TOPIC_ID correspond à l'ID du sujet que vous créez.
ENCODING_TYPE correspond à l'encodage des messages validés vis-à-vis de la du schéma. Cette valeur doit être définie sur JSON ou BINARY.
SCHEMA_ID correspond à l'ID d'un schéma existant.
FIRST_REVISION_ID correspond à l'ID de la plus ancienne révision à valider.
LAST_REVISION_ID correspond à l'ID de la dernière révision à valider.

--first-revision-id et --last-revision-id sont facultatifs.

Vous pouvez également attribuer un schéma à partir d'un autre projet Google Cloud:

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

Où :

SCHEMA_PROJECT est l'ID du projet Google Cloud pour le schéma.
TOPIC_PROJECT est l'ID du projet Google Cloud associé au sujet.

REST

Pour créer un sujet, utilisez la méthode projects.topics.create. méthode:

Requête :

La demande doit être authentifiée à l'aide d'un jeton d'accès dans l'en-tête Authorization. Pour obtenir un jeton d'accès pour les identifiants par défaut actuels de l'application, exécutez la commande suivante : gcloud auth application-default print-access-token.

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

Corps de la requête :

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

Où :

PROJECT_ID est l'ID de votre projet.
TOPIC_ID est l'ID de votre sujet.
SCHEMA_NAME est le nom du schéma par rapport auquel les messages publiés doivent être validés. Le format est le suivant: projects/PROJECT_ID/schemas/SCHEMA_ID
ENCODING_TYPE est l'encodage des messages validés par rapport au schéma. Il doit être défini sur JSON ou BINARY.
FIRST_REVISION_ID correspond à l'ID de la plus ancienne révision à valider.
LAST_REVISION_ID correspond à l'ID de la dernière révision à valider.

firstRevisionId et lastRevisionId sont facultatifs.

Réponse :

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

Les champs firstRevisionId et lastRevisionId sont omis s'ils ne sont pas fournis dans la demande.

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;
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#

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#.


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

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 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

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.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

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 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage PHP 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 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

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 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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Ruby 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 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."

Modifier un schéma associé à un sujet

Vous pouvez modifier un sujet pour joindre un schéma, en supprimer un ou mettre à jour la plage de révisions utilisée pour valider les messages. En général, si vous avez prévu des modifications pour le schéma utilisé, vous pouvez commettre une nouvelle révision et mettre à jour la plage de révisions utilisée pour le sujet.

Vous pouvez modifier un schéma associé à un sujet à l'aide de la console Google Cloud, de la CLI gcloud, de l'API Pub/Sub ou des bibliothèques clientes Cloud.

Console

Dans la console Google Cloud, accédez à la page Sujets Pub/Sub.

Accéder aux sujets
Cliquez sur l'ID de sujet d'un sujet.
Sur la page d'informations du thème, cliquez sur Modifier.
Vous pouvez apporter les modifications suivantes au schéma.

L'application des modifications peut prendre quelques minutes.
- Si vous souhaitez supprimer le schéma du sujet, Sur la page Modifier le sujet, décochez la case Utiliser un schéma.
- Si vous souhaitez modifier le schéma, sélectionnez le nom d'un schéma dans la section Schéma.
Mettez à jour les autres champs si nécessaire.
- Si vous souhaitez mettre à jour la plage de révisions, pour Plage de révisions, utilisez les menus déroulants pour Première révision autorisée et Dernière révision autorisée.
Vous pouvez spécifier les deux champs, n'en spécifier qu'un seul ou conserver les paramètres par défaut en fonction de vos exigences.
Cliquez sur Mettre à jour pour enregistrer les modifications.

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 \

Où :

TOPIC_ID correspond à l'ID du sujet que vous créez.
ENCODING_TYPE correspond à l'encodage des messages validés par rapport au schéma. Cette valeur doit être définie sur JSON ou BINARY.
SCHEMA_NAME correspond au nom d'un schéma existant.
FIRST_REVISION_ID est l'ID de la révision la plus ancienne à utiliser pour la validation.
LAST_REVISION_ID correspond à l'ID de la dernière révision à valider.

--first-revision-id et --last-revision-id sont facultatifs.

REST

Pour mettre à jour un thème, utilisez la méthode projects.topics.patch méthode:

Requête :

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

Corps de la requête :

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

Où :

PROJECT_ID est l'ID de votre projet.
TOPIC_ID est l'ID de votre sujet.
SCHEMA_NAME est le nom du schéma par rapport auquel les messages publiés doivent être validés. Le format est le suivant: projects/PROJECT_ID/schemas/SCHEMA_ID
ENCODING_TYPE est l'encodage des messages validés par rapport au schéma. Il doit être défini sur JSON ou BINARY.
FIRST_REVISION_ID correspond à l'ID de la plus ancienne révision à valider.
LAST_REVISION_ID correspond à l'ID de la dernière révision à valider.

firstRevisionId et lastRevisionId sont facultatifs.

Réponse :

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

firstRevisionId et lastRevisionId ne sont pas définis après le mise à jour.

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.")

Associer un schéma à un sujet

Avant de commencer

Rôles et autorisations requis

Autorisations requises

Consignes pour associer un schéma à un sujet

Logique de validation pour un schéma de message

Créer et associer un schéma lorsque vous créez un sujet

Console

gcloud

REST

C++

C#

Go

Java

Node.js

Node.js

PHP

Python

Ruby

Modifier un schéma associé à un sujet

Console

gcloud

REST

C++

Go

Java

Python

Étape suivante