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

Associer un schéma à un sujet

Ce document explique comment associer des schémas pour les sujets Pub/Sub.

Avant de commencer

Comprendre le fonctionnement des schémas Pub/Sub
Créez un schéma.

Rôles et autorisations requis

Afin d'obtenir les autorisations nécessaires pour associer et gérer des schémas, demandez à votre administrateur de vous attribuer 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 section Gérer les accès.

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 le schéma : pubsub.schemas.create
Associer le schéma au sujet : pubsub.schemas.attach
Effectuez un commit d'une révision de 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
Répertorier les schémas : pubsub.schemas.list
Répertorier les révisions de schéma : pubsub.schemas.listRevisions
Effectuer le rollback d'un schéma : pubsub.schemas.rollback
Validez 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 attribuer 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 créez ou modifiez un sujet. 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 JSON avec un schéma Avro, soyez particulièrement attentif aux 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 comprise dans la plage disponible. En l'absence de validation, le message ne peut pas être publié.

Les révisions sont testées dans l'ordre chronologique inverse en fonction de la date de création. Pour créer une révision de schéma, consultez la section Valider une révision de schéma.

Logique de validation pour un schéma de message

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

Si vous ne définissez pas l'option Première révision autorisée pour une révision, la révision existante la plus ancienne du schéma est utilisée pour la validation. Si vous ne spécifiez pas l'option Dernière révision autorisée pour une révision, la révision existante la plus récente du 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 ont été créés dans l'ordre, où A est la première ou la plus ancienne révision. Aucun schéma n'est identique l'un à l'autre ou rollbacks d'un schéma existant.

Si vous ne définissez que le champ Première révision autorisée sur B, les messages conformes uniquement au schéma A seront rejetés, tandis que ceux conformes aux schémas B, C et D sont acceptés.
Si vous définissez uniquement 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 qui ne sont conformes qu'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 le même ID de révision pour la première et la dernière 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 gcloud CLI, 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 Use a schema (Utiliser un schéma).

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

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 Select a Pub/Sub schema (Sélectionner un schéma Pub/Sub), cliquez sur Create a new schema (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.
Le schéma que vous venez de créer possède un ID de révision. Vous pouvez créer des révisions de schéma supplémentaires, comme indiqué dans la section Valider une révision du 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.
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 besoins.

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

gcloud

Pour créer un sujet attribué avec 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 est l'ID du sujet que vous créez.
ENCODING_TYPE est l'encodage des messages validés par rapport au schéma. Cette valeur doit être définie sur JSON ou BINARY.
SCHEMA_ID est l'ID 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 est l'ID de la révision la plus récente à utiliser pour la validation.

--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 correspond à l'ID du projet Google Cloud pour le sujet.

REST

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

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 est l'ID de la révision la plus ancienne à utiliser pour la validation.
LAST_REVISION_ID est l'ID de la révision la plus récente à utiliser pour la validation.

firstRevisionId et lastRevisionId sont facultatifs.

Solution :

{
  "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 sont omis s'ils ne sont pas fournis dans la requête.

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 associer 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 en cours d'utilisation, vous pouvez valider 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 gcloud CLI, 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 du thème.
Sur la page d'informations du sujet, 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, décochez la case Utiliser un schéma sur la page Modifier le sujet.
- Si vous souhaitez modifier le schéma, sélectionnez le nom d'un schéma dans la section Schema (Schéma).
Mettez à jour les autres champs selon vos besoins.
- Si vous souhaitez mettre à jour la plage de 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 besoins.
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 est l'ID du sujet que vous créez.
ENCODING_TYPE est 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 est l'ID de la révision la plus récente à utiliser pour la validation.

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

REST

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

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 est l'ID de la révision la plus ancienne à utiliser pour la validation.
LAST_REVISION_ID est l'ID de la révision la plus récente à utiliser pour la validation.

firstRevisionId et lastRevisionId sont facultatifs.

Solution :

{
  "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 la 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

Étapes suivantes