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

Vous devez disposer des autorisations suivantes 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
Committer 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
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 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 des 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 la section Valider une révision de schéma.

Logique de validation d'un schéma de message

Lorsque vous associez un schéma à un sujet et si le schéma comporte des révisions, vous pouvez spécifier une plage 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 spécifiez pas de révision comme Première révision autorisée, la révision la plus ancienne du schéma est utilisée pour la validation. Si vous ne spécifiez pas de révision comme Dernière révision autorisée, la dernière révision existante du schéma est utilisée.

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

Le schéma S comporte les ID de révision A, B, C et D créés dans l'ordre, où A est 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 ne définissez que le champ Première révision autorisée sur B, les messages conformes uniquement au schéma A sont refusé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 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 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 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, puis cliquez sur Actualiser.
2. Recherchez votre schéma dans le champ Sélectionner un schéma Pub/Sub.
3. Sélectionnez l'encodage des messages sur JSON ou Binaire.
Le schéma que vous venez de créer comporte un ID de révision. Vous pouvez créer des révisions de schéma supplémentaires, comme indiqué dans 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 des messages sur JSON ou 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 par rapport au 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 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 sur lequel les messages publiés doivent être validés. Il a le format suivant : projects/PROJECT_ID/schemas/SCHEMA_ID.
ENCODING_TYPE correspond à l'encodage des messages validés par rapport au schéma. Cette valeur doit être définie 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 sont tous deux ignorés 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 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 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 de sujet d'un sujet.
Sur la page des détails de l'article, cliquez sur Modifier.
Vous pouvez apporter les modifications suivantes au schéma.

La prise en compte 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 modifier 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 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 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.

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 sur lequel les messages publiés doivent être validés. Il a le format suivant : projects/PROJECT_ID/schemas/SCHEMA_ID.
ENCODING_TYPE correspond à l'encodage des messages validés par rapport au schéma. Cette valeur doit être définie 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 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 d'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