Associare uno schema a un argomento

Questo documento mostra come associare gli schemi per gli argomenti Pub/Sub.

Prima di iniziare

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per associare e gestire gli schemi, chiedi all'amministratore di concederti Ruolo IAM dell'editor Pub/Sub (roles/pubsub.editor) per il tuo progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per associare e gestire gli schemi. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per associare e gestire gli schemi sono necessarie le seguenti autorizzazioni:

  • Crea schema: pubsub.schemas.create
  • Associa schema all'argomento: pubsub.schemas.attach
  • Esegui il commit di una revisione dello schema: pubsub.schemas.commit
  • Elimina uno schema o una revisione dello schema: pubsub.schemas.delete
  • Ottieni uno schema o una revisione dello schema: pubsub.schemas.get
  • Elenca schemi: pubsub.schemas.list
  • Elenca le revisioni dello schema: pubsub.schemas.listRevisions
  • Esegui il rollback di uno schema: pubsub.schemas.rollback
  • Convalida un messaggio: pubsub.schemas.validate
  • Ottieni il criterio IAM per uno schema: pubsub.schemas.getIamPolicy
  • Configura il criterio IAM per uno schema: pubsub.schemas.setIamPolicy

Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.

Puoi concedere ruoli e autorizzazioni a entità come utenti, gruppi domini o account di servizio. Puoi creare uno schema in un progetto a un argomento di un altro progetto. Assicurati di disporre delle autorizzazioni necessarie per per ogni progetto.

Linee guida per associare uno schema a un argomento

Puoi associare uno schema a un argomento quando crei o modifichi un argomento. Di seguito sono riportate le linee guida per associare uno schema a un argomento:

  • Puoi associare uno schema a uno o più argomenti.

    Dopo che uno schema è stato associato a un argomento, ogni messaggio che l'argomento riceve dagli editori deve seguire lo schema.

  • Quando associ uno schema a un argomento, devi anche specificare la codifica dei messaggi da pubblicare come BINARY o JSON. Se utilizzi JSON con uno schema Avro, presta particolare attenzione alle regole di codifica per le unioni.

  • Se uno schema associato a un argomento contiene revisioni, i messaggi devono corrispondere alla codifica e essere convalidati in base a una revisione all'interno dell'intervallo disponibile. Se non vengono convalidate, la pubblicazione del messaggio non riesce.

    Le revisioni vengono provate in ordine cronologico inverso in base alla data di creazione. Per creare una revisione dello schema, consulta Eseguire il commit di una revisione dello schema.

Logica di convalida per uno schema di messaggi

Quando associ uno schema a un argomento e se quest'ultimo ha revisioni, puoi specificare un sottoinsieme di revisioni da utilizzare. Se non specifichi un intervallo, viene utilizzato l'intero intervallo per la convalida.

Se non specifichi una revisione come Prima revisione consentita, per la convalida viene utilizzata la revisione esistente meno recente dello schema. Se non specifichi una revisione come Ultima revisione consentita, viene usata la revisione esistente più recente dello schema.

Prendiamo l'esempio dello schema S associato all'argomento T.

Per lo schema S sono stati creati in ordine gli ID revisione A,B, C e D, dove A è la prima o la revisione meno recente. Nessuno degli schemi è identico o rollback di uno schema esistente.

  • Se imposti solo il campo Prima revisione consentita su B, i messaggi conformi solo allo schema A vengono rifiutati. mentre vengono accettati i messaggi conformi agli schemi B, C e D.

  • Se imposti il campo Ultima revisione consentita solo su C, i messaggi conformi agli schemi A, B e C vengono accettati, mentre i messaggi conformi solo allo schema D vengono rifiutati.

  • Se imposti entrambi i campi Prima revisione consentita su B e Ultima revisione consentita su C, i messaggi conformi ai schemi B e C sono accettati.

  • Puoi anche impostare la prima e l'ultima revisione sullo stesso ID revisione. In questo caso, vengono accettati solo i messaggi conformi a quella revisione.

Crea e associa uno schema quando crei un argomento

Puoi creare un argomento con uno schema utilizzando la console Google Cloud, l'interfaccia a riga di comando gcloud, l'API Pub/Sub o le librerie client di Cloud.

Console

  1. Nella console Google Cloud, vai alla pagina Argomenti Pub/Sub.

    Vai ad Argomenti

  2. Fai clic su Crea argomento.

  3. Inserisci un ID per l'argomento nel campo ID argomento.

    Per assegnare un nome a un argomento, consulta le linee guida.

  4. Seleziona la casella Utilizza uno schema.

    Mantieni le impostazioni predefinite per i restanti campi.

    Puoi creare uno schema o utilizzarne uno esistente.

  5. Se stai creando uno schema, segui questi passaggi: `

    1. Per Seleziona uno schema Pub/Sub, seleziona Crea un nuovo schema.

    La pagina Crea schema viene visualizzata in una scheda secondaria.

    Segui i passaggi descritti in Creare uno schema.

    1. Torna alla scheda Crea argomento e fai clic su Aggiorna.

    2. Cerca il tuo schema nel campo Seleziona uno schema Pub/Sub.

    3. Seleziona la codifica del messaggio come JSON o Binario.

    Lo schema appena creato ha un ID revisione. Puoi creare altri revisioni dello schema come discusso in Eseguire il commit di una revisione dello schema.

  6. Se associ uno schema già creato, segui questi passaggi:

    1. In Seleziona uno schema Pub/Sub, seleziona uno schema esistente.

    2. Seleziona la codifica dei messaggi come JSON o Binario.

  7. (Facoltativo) Se lo schema selezionato ha revisioni, per l'opzione Intervallo di revisioni: Utilizza i menu a discesa per Prima revisione consentita e Ultima revisione consentita.

Puoi specificare entrambi i campi, specificarne uno solo o mantenere il valore predefinito le impostazioni in base ai tuoi requisiti.

  1. Conserva le impostazioni predefinite per i restanti campi.

  2. Fai clic su Crea per salvare l'argomento e assegnarlo allo schema selezionato.

gcloud

Per creare un argomento assegnato con uno schema creato in precedenza, esegui il comando 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 \

Dove:

  • TOPIC_ID è l'ID dell'argomento che stai creando.
  • ENCODING_TYPE è la codifica dei messaggi convalidati in base al . Questo valore deve essere impostato su JSON o BINARY.
  • SCHEMA_ID è l'ID di uno schema esistente.
  • FIRST_REVISION_ID è l'ID della revisione precedente rispetto alla quale eseguire la convalida.
  • LAST_REVISION_ID è l'ID dell'ultima revisione in base a cui eseguire la convalida.

Sia --first-revision-id che --last-revision-id sono facoltativi.

Puoi anche assegnare uno schema da un altro progetto Google Cloud:

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

Dove:

  • SCHEMA_PROJECT è l'ID del progetto Google Cloud per lo schema.
  • TOPIC_PROJECT è l'ID del progetto Google Cloud per l'argomento.

REST

Per creare un argomento, utilizza la projects.topics.create :

Richiesta:

La richiesta deve essere autenticata con un token di accesso nell'intestazioneAuthorization. Per ottenere un token di accesso per l'istanza Credenziali predefinite dell'applicazione: gcloud auth application-default print-access-token.

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

Corpo della richiesta: 

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

Dove:

  • PROJECT_ID è l'ID progetto.
  • TOPIC_ID è l'ID argomento.
  • SCHEMA_NAME è il nome dello schema in base al quale devono essere convalidati i messaggi pubblicati. Il formato è: projects/PROJECT_ID/schemas/SCHEMA_ID.
  • ENCODING_TYPE è la codifica dei messaggi convalidati in base allo schema. Deve essere impostato su JSON o BINARY.
  • FIRST_REVISION_ID è l'ID della revisione precedente rispetto alla quale eseguire la convalida.
  • LAST_REVISION_ID è l'ID della revisione più recente in base alla quale eseguire la convalida.

Sia firstRevisionId che lastRevisionId sono facoltativi.

Risposta:

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

Sia firstRevisionId che lastRevisionId vengono omessi se non forniti nella richiesta.

C++

Prima di provare questo esempio, segui le istruzioni di configurazione C++ riportate nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub 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#

Prima di provare questo esempio, segui le istruzioni di configurazione C# in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API C# Pub/Sub. 


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

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione di Go in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Pub/Sub. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js Pub/Sub. 

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API PHP Pub/Sub. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub per 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Ruby Pub/Sub. 

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

Modificare uno schema associato a un argomento

Puoi modificare un argomento per collegare uno schema, rimuoverlo o aggiornare l'intervallo di revisioni utilizzato per convalidare i messaggi. In generale, se hai pianificato modifiche allo schema in uso, puoi eseguire il commit di una nuova revisione aggiornare l'intervallo di revisioni utilizzate per l'argomento.

Puoi modificare uno schema associato a un argomento utilizzando il metodo console Google Cloud, gcloud CLI, l'API Pub/Sub, o le librerie client di Cloud.

Console

  1. Nella console Google Cloud, vai alla pagina Argomenti Pub/Sub.

    Vai ad Argomenti

  2. Fai clic sull'ID argomento di un argomento.

  3. Nella pagina dei dettagli dell'argomento, fai clic su Modifica.

  4. Puoi apportare le seguenti modifiche allo schema.

    Potrebbero essere necessari alcuni minuti prima che le modifiche vengano applicate.

    • Se vuoi rimuovere lo schema dall'argomento, nella pagina Modifica argomento, deseleziona la casella di controllo Utilizza uno schema.

    • Se vuoi modificare lo schema, seleziona il nome di uno schema nella sezione Schema.

    Aggiorna gli altri campi come richiesto.

    • Se vuoi aggiornare l'intervallo di revisioni, in Intervallo di revisioni: Utilizza i menu a discesa per Prima revisione consentita e Ultima revisione consentita.

    Puoi specificare entrambi i campi, uno solo o mantenere le impostazioni predefinite in base ai tuoi requisiti.

  5. Fai clic su Aggiorna per salvare le modifiche.

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 \

Dove:

  • TOPIC_ID è l'ID dell'argomento che stai creando.
  • ENCODING_TYPE è la codifica dei messaggi convalidati in base allo schema. Questo valore deve essere impostato su JSON o BINARY.
  • SCHEMA_NAME è il nome di uno schema esistente.
  • FIRST_REVISION_ID è l'ID della revisione precedente rispetto alla quale eseguire la convalida.
  • LAST_REVISION_ID è l'ID dell'ultima revisione in base a cui eseguire la convalida.

Sia --first-revision-id che --last-revision-id sono facoltativi.

REST

Per aggiornare un argomento, utilizza projects.topics.patch :

Richiesta:

La richiesta deve essere autenticata con un token di accesso nel Intestazione Authorization. Per ottenere un token di accesso per le Credenziali predefinite dell'applicazione correnti: gcloud auth application-default print-access-token.

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

Corpo della richiesta: 

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

Dove:

  • PROJECT_ID è l'ID progetto.
  • TOPIC_ID è l'ID argomento.
  • SCHEMA_NAME è il nome dello schema in base al quale devono essere convalidati i messaggi pubblicati. Il formato è: projects/PROJECT_ID/schemas/SCHEMA_ID.
  • ENCODING_TYPE è la codifica dei messaggi convalidati in base allo schema. Deve essere impostato su JSON o BINARY.
  • FIRST_REVISION_ID è l'ID della revisione precedente rispetto alla quale eseguire la convalida.
  • LAST_REVISION_ID è l'ID della revisione più recente in base alla quale eseguire la convalida.

Sia firstRevisionId che lastRevisionId sono facoltativi.

Risposta:

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

Sia firstRevisionId che lastRevisionId non sono impostati dopo il tag aggiornamento.

C++

Prima di provare questo esempio, segui le istruzioni per la configurazione di C++ in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub 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";
}

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Pub/Sub. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python in Guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub per 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.")
0

Passaggi successivi