Schema mit einem Thema verknüpfen

In diesem Dokument erfahren Sie, wie Sie Schemas für Pub/Sub-Themen verknüpfen.

Hinweise

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub Editor (roles/pubsub.editor) für Ihr Projekt zu gewähren, damit Sie die Berechtigungen erhalten, die Sie zum Verknüpfen und Verwalten von Schemas benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Verknüpfen und Verwalten von Schemas erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Verknüpfen und Verwalten von Schemas erforderlich:

  • Schema erstellen: pubsub.schemas.create
  • Schema an Thema anhängen: pubsub.schemas.attach
  • Commit für eine Schemaversion durchführen: pubsub.schemas.commit
  • Schema oder Schemaversion löschen: pubsub.schemas.delete
  • Schema- oder Schemaversionen abrufen: pubsub.schemas.get
  • Schemas auflisten: pubsub.schemas.list
  • Schemaversionen auflisten: pubsub.schemas.listRevisions
  • Rollback für Schema durchführen: pubsub.schemas.rollback
  • Nachricht validieren: pubsub.schemas.validate
  • Rufen Sie die IAM-Richtlinie für ein Schema ab: pubsub.schemas.getIamPolicy
  • Konfigurieren Sie die IAM-Richtlinie für ein Schema: pubsub.schemas.setIamPolicy

Möglicherweise können Sie diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Sie können Hauptkonten wie Nutzern, Gruppen, Domains oder Dienstkonten Rollen und Berechtigungen gewähren. Sie können ein Schema in einem Projekt erstellen und an ein Thema in einem anderen Projekt anhängen. Prüfen Sie, ob Sie die erforderlichen Berechtigungen für jedes Projekt haben.

Richtlinien zum Verknüpfen eines Schemas mit einem Thema

Sie können ein Schema mit einem Thema verknüpfen, wenn Sie ein Thema erstellen oder bearbeiten. Hier finden Sie die Richtlinien zum Verknüpfen eines Schemas mit einem Thema:

  • Sie können ein Schema mit einem oder mehreren Themen verknüpfen.

    Nachdem ein Schema mit einem Thema verknüpft wurde, muss jede Nachricht, die das Thema von den Publishern erhält, diesem Schema folgen.

  • Beim Verknüpfen eines Schemas mit einem Thema müssen Sie auch die Codierung der zu veröffentlichenden Nachrichten als BINARY oder JSON angeben. Wenn Sie JSON mit einem Avro-Schema verwenden, achten Sie genau auf die Codierungsregeln für Unions.

  • Wenn ein mit einem Thema verknüpftes Schema Versionen hat, müssen Nachrichten mit der Codierung übereinstimmen und anhand einer Version innerhalb des verfügbaren Bereichs validiert werden. Andernfalls kann die Nachricht nicht veröffentlicht werden.

    Überarbeitungen werden in umgekehrter chronologischer Reihenfolge basierend auf der Erstellungszeit versucht. Informationen zum Erstellen einer Schemaversion finden Sie unter Commit für Schemaversion durchführen.

Validierungslogik für ein Nachrichtenschema

Wenn Sie ein Schema mit einem Thema verknüpfen und es Versionen enthält, können Sie eine Teilmenge der zu verwendenden Überarbeitungen angeben. Wenn Sie keinen Bereich angeben, wird der gesamte Bereich zur Validierung verwendet.

Wenn Sie keine Version als Erste Überarbeitung zugelassen angeben, wird die älteste vorhandene Version des Schemas zur Validierung verwendet. Wenn Sie keine Version als Letzte zulässige Version angeben, wird die neueste vorhandene Version des Schemas verwendet.

Nehmen wir als Beispiel das Schema S, das an das Thema T angehängt ist.

Das Schema S hat die Überarbeitungs-IDs A,B, C und D, die in der richtigen Reihenfolge erstellt werden, wobei A die erste oder älteste Version ist. Keines der Schemas ist identisch und es gibt keine Rollbacks eines vorhandenen Schemas.

  • Wenn Sie nur das Feld Erste Überarbeitung zugelassen auf B festlegen, werden Nachrichten, die nur dem Schema A entsprechen, abgelehnt. Nachrichten, die den Schemas B, C und D entsprechen, werden dagegen akzeptiert.

  • Wenn Sie das Feld Letzte Überarbeitung zulässig nur auf C setzen, werden Nachrichten akzeptiert, die den Schemas A, B und C entsprechen, und Nachrichten, die nur dem Schema D entsprechen, werden abgelehnt.

  • Wenn Sie für beide Felder Erste Überarbeitung zugelassen den Wert B und Letzte Überarbeitung zulässig auf C festlegen, werden Nachrichten akzeptiert, die den Schemas B und C entsprechen.

  • Sie können auch für die erste und die letzte Version dieselbe Versions-ID festlegen. In diesem Fall werden nur Nachrichten akzeptiert, die dieser Überarbeitung entsprechen.

Schema beim Erstellen eines Themas erstellen und verknüpfen

Sie können ein Thema mit einem Schema mit der Google Cloud Console, der gcloud CLI, der Pub/Sub API oder den Cloud-Clientbibliotheken erstellen.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Pub/Sub-Themen auf.

    Themen aufrufen

  2. Klicken Sie auf Thema erstellen.

  3. Geben Sie im Feld Themen-ID eine ID für das Thema ein.

    Informationen dazu, wie Sie Themen benennen, finden Sie in den Richtlinien.

  4. Klicken Sie das Kästchen Schema verwenden an.

    Behalten Sie die Standardeinstellungen für die übrigen Felder bei.

    Sie können ein Schema erstellen oder ein vorhandenes Schema verwenden.

  5. Wenn Sie ein Schema erstellen, gehen Sie so vor: `

    1. Wählen Sie unter Pub/Sub-Schema auswählen die Option Neues Schema erstellen aus.

    Die Seite Schema erstellen wird in einem sekundären Tab angezeigt.

    Folgen Sie der Anleitung unter Schema erstellen.

    1. Kehren Sie zum Tab Thema erstellen zurück und klicken Sie auf Aktualisieren.

    2. Suchen Sie im Feld Pub/Sub-Schema auswählen nach Ihrem Schema.

    3. Wählen Sie als Nachrichtencodierung JSON oder Binär aus.

    Das soeben erstellte Schema hat eine Versions-ID. Sie können weitere Schemaüberarbeitungen erstellen, wie unter Schemaüberarbeitung per Commit beschrieben.

  6. Wenn Sie ein bereits erstelltes Schema verknüpfen, gehen Sie so vor:

    1. Wählen Sie unter Pub/Sub-Schema auswählen ein vorhandenes Schema aus.

    2. Wählen Sie als Nachrichtencodierung JSON oder Binär aus.

  7. Optional: Wenn das ausgewählte Schema Versionen enthält, verwenden Sie für Überarbeitungsbereich die Drop-down-Menüs für Erste Überarbeitung zugelassen und Letzte zulässige Überarbeitung.

Sie können beide Felder angeben, nur eines angeben oder die Standardeinstellungen entsprechend Ihren Anforderungen beibehalten.

  1. Behalten Sie die Standardeinstellungen für die übrigen Felder bei.

  2. Klicken Sie auf Erstellen, um das Thema zu speichern und dem ausgewählten Schema zuzuweisen.

gcloud

Führen Sie den Befehl gcloud pubsub topics create aus, um ein Thema zu erstellen, das einem zuvor erstellten Schema zugewiesen ist:

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 \

Wobei:

  • TOPIC_ID ist die ID für das Thema, das Sie erstellen.
  • ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wird. Dieser Wert muss auf JSON oder BINARY festgelegt werden.
  • SCHEMA_ID ist die ID eines vorhandenen Schemas.
  • FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die geprüft werden soll.
  • LAST_REVISION_ID ist die ID der neuesten Version, die validiert werden soll.

--first-revision-id und --last-revision-id sind optional.

Sie können auch ein Schema aus einem anderen Google Cloud-Projekt zuweisen:

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

Wobei:

  • SCHEMA_PROJECT ist die Projekt-ID des Google Cloud-Projekts für das Schema.
  • TOPIC_PROJECT ist die Projekt-ID des Google Cloud-Projekts für das Thema.

REST

Verwenden Sie zum Erstellen eines Themas die Methode projects.topics.create:

Anfrage

Die Anfrage muss mit einem Zugriffstoken im Header Authorization authentifiziert werden. So rufen Sie ein Zugriffstoken für die aktuellen Standardanmeldedaten für Anwendungen ab: gcloud auth application-default print-access-token.

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

Anfragetext: 

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

Wobei:

  • PROJECT_ID ist die Projekt-ID.
  • TOPIC_ID ist Ihre Themen-ID.
  • SCHEMA_NAME ist der Name des Schemas, anhand dessen veröffentlichte Nachrichten validiert werden sollen. Das Format ist: projects/PROJECT_ID/schemas/SCHEMA_ID.
  • ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wird. Dies muss entweder auf JSON oder BINARY festgelegt werden.
  • FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die geprüft werden soll.
  • LAST_REVISION_ID ist die ID der neuesten Version, die validiert werden soll.

firstRevisionId und lastRevisionId sind optional.

Lösung:

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

Sowohl firstRevisionId als auch lastRevisionId werden weggelassen, wenn sie nicht in der Anfrage angegeben sind.

C++

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für C++ in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C++ API. 

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#

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für C# in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C# API. 


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

Einfach loslegen (Go)

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Go in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Go API. 

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Java API. 


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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für PHP in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Node.js API. 

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für PHP in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Node.js API. 

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

Folgen Sie der Einrichtungsanleitung für PHP unter Schnellstart: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub PHP API. 

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Python in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Python API. 

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Ruby in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Ruby API. 

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

Mit einem Thema verknüpftes Schema bearbeiten

Sie können ein Thema bearbeiten, um ein Schema anzuhängen, ein Schema zu entfernen oder den Versionsbereich zu aktualisieren, der zum Validieren von Nachrichten verwendet wird. Wenn Sie Änderungen für das verwendete Schema geplant haben, können Sie im Allgemeinen einen Commit für eine neue Version durchführen und den Bereich der für das Thema verwendeten Versionen aktualisieren.

Sie können ein mit einem Thema verknüpftes Schema mit der Google Cloud Console, der gcloud CLI, Pub/Sub API oder den Cloud-Clientbibliotheken bearbeiten.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Pub/Sub-Themen auf.

    Themen aufrufen

  2. Klicken Sie auf die Themen-ID eines Themas.

  3. Klicken Sie auf der Seite mit den Themendetails auf Bearbeiten.

  4. Sie können folgende Änderungen am Schema vornehmen.

    Es kann einige Minuten dauern, bis die Änderungen wirksam werden.

    • Wenn Sie das Schema aus dem Thema entfernen möchten, entfernen Sie auf der Seite Thema bearbeiten das Häkchen aus dem Kästchen Schema verwenden.

    • Wenn Sie das Schema ändern möchten, wählen Sie im Abschnitt Schema den Namen eines Schemas aus.

    Aktualisieren Sie die anderen Felder nach Bedarf.

    • Wenn Sie den Überarbeitungsbereich aktualisieren möchten, verwenden Sie für Überarbeitungsbereich die Drop-down-Menüs für Erste Überarbeitung und Letzte zulässige Überarbeitung.

    Sie können beide Felder angeben, nur eines angeben oder die Standardeinstellungen entsprechend Ihren Anforderungen beibehalten.

  5. Klicken Sie auf Aktualisieren, um die Änderungen zu speichern.

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 \

Wobei:

  • TOPIC_ID ist die ID für das Thema, das Sie erstellen.
  • ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wird. Dieser Wert muss auf JSON oder BINARY festgelegt werden.
  • SCHEMA_NAME ist der Name eines vorhandenen Schemas.
  • FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die geprüft werden soll.
  • LAST_REVISION_ID ist die ID der neuesten Version, die validiert werden soll.

--first-revision-id und --last-revision-id sind optional.

REST

Verwenden Sie zum Aktualisieren eines Themas die Methode projects.topics.patch:

Anfrage

Die Anfrage muss mit einem Zugriffstoken im Header Authorization authentifiziert werden. So rufen Sie ein Zugriffstoken für die aktuellen Standardanmeldedaten für Anwendungen ab: gcloud auth application-default print-access-token.

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

Anfragetext: 

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

Wobei:

  • PROJECT_ID ist die Projekt-ID.
  • TOPIC_ID ist Ihre Themen-ID.
  • SCHEMA_NAME ist der Name des Schemas, anhand dessen veröffentlichte Nachrichten validiert werden sollen. Das Format ist: projects/PROJECT_ID/schemas/SCHEMA_ID.
  • ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wird. Dies muss entweder auf JSON oder BINARY festgelegt werden.
  • FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die geprüft werden soll.
  • LAST_REVISION_ID ist die ID der neuesten Version, die validiert werden soll.

firstRevisionId und lastRevisionId sind optional.

Lösung:

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

Sowohl firstRevisionId als auch lastRevisionId werden nach der Aktualisierung nicht festgelegt.

C++

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für C++ in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C++ API. 

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

Einfach loslegen (Go)

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Go in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Go API. 

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Java API. 


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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Python in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Python API. 

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

Nächste Schritte