Schemas erstellen und verwalten

Auf dieser Seite wird beschrieben, wie Sie Schemas für Pub/Sub-Themen erstellen und verwalten.

Ein Schema ist ein Format, dem das Feld data einer Pub/Sub-Nachricht folgen muss. Ein Schema erstellt einen Vertrag zwischen dem Publisher und dem Abonnenten über das Format der Nachrichten. Pub/Sub erzwingt dieses Format. Schemas vereinfachen den interteamübergreifenden Datenstream in Ihrer Organisation, da eine zentrale Behörde für Nachrichtentypen und -berechtigungen erstellt wird. Ein Pub/Sub-Nachrichtenschema definiert die Namen und Datentypen für die Felder in einer Nachricht.

Wichtiger Hinweis: Sie können ein Schema erstellen und mit einem Thema verknüpfen, um das Schema für veröffentlichte Nachrichten zu erzwingen. Wenn eine bestimmte Nachricht nicht dem Schema entspricht, wird sie nicht veröffentlicht.

Schematypen

Sie können ein Schema in Pub/Sub mit einem der folgenden Frameworks erstellen:

• Apache Avro
• Protocol Buffer

Das folgende Schema definiert beispielsweise das Inventar eines Warehouse, einmal im Avro-Format und dann im Protokollzwischenspeicher-Format.

Hinweis: Avro Version 1.11 wird unterstützt. Für Protokollzwischenspeicher werden proto2 und proto3 unterstützt.

Apache Avro-Format

{
 "type" : "record",
 "name" : "Avro",
 "fields" : [
   {
     "name" : "ProductName",
     "type" : "string",
     "default": ""
   },
   {
     "name" : "SKU",
     "type" : "int",
     "default": 0
   },
   {
     "name" : "InStock",
     "type" : "boolean",
     "default": false
   }
 ]
}

Protokollzwischenspeicher-Format

syntax = "proto3";
message ProtocolBuffer {
  string product_name = 1;
  int32 SKU = 2;
  bool in_stock = 3;
}

Hinweis

Bevor Sie mit der Konfiguration von Schemas beginnen, prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

• Ein Projekt mit aktivierter Pub/Sub API. In dieser Kurzanleitung erfahren Sie, wie Sie die Pub/Sub API aktivieren.

• Ein Pub/Sub-Thema oder die erforderlichen Rollen und Berechtigungen zum Erstellen eines Themas.

• Die erforderlichen Rollen und Berechtigungen zum Erstellen eines Schemas.

Erforderliche Rollen und Berechtigungen zum Verwalten von Schemas

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub-Bearbeiter (roles/pubsub.editor) für Ihr Projekt zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Erstellen 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 Erstellen und Verwalten von Schemas erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

• Schema erstellen: pubsub.schemas.create
• Schema an folgendes Thema anhängen: pubsub.schemas.attach
• Führen Sie einen Commit für die Schemaüberarbeitung durch: pubsub.schemas.commit
• Löschen Sie ein Schema oder eine Schemaüberarbeitung: pubsub.schemas.delete
• Schema oder Schemaüberarbeitungen: pubsub.schemas.get
• Schemas auflisten: pubsub.schemas.list
• Schemaüberarbeitungen: pubsub.schemas.listRevisions
• Rollback für ein 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

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

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

Schema erstellen

Sie können ein Schema mit der Google Cloud Console, der gcloud CLI, der Pub/Sub API oder den Cloud-Clientbibliotheken erstellen. Im Folgenden finden Sie einige Richtlinien zum Erstellen eines Schemas:

• Damit ein Schema mit Pub/Sub funktioniert, darf nur ein Typ der obersten Ebene definiert werden. Importanweisungen, die auf andere Typen verweisen, werden nicht unterstützt.

• Sie können dasselbe Schema mehreren Themen zuweisen.

• Sie können manuell testen, ob eine Nachricht anhand eines Schemas validiert wird.

Console

So erstellen Sie ein Schema:

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

   Zu den Schemas

2. Klicken Sie auf Schema erstellen.

3. Geben Sie im Feld Schema-ID eine ID für Ihr Schema ein.

   Richtlinien zum Benennen eines Schemas finden Sie unter Richtlinien für die Benennung eines Themas, Abos oder Snapshots.

4. Wählen Sie als Schematyp entweder Avro oder den Protokollpuffer aus.

   Schematypen

5. Geben Sie im Feld Schemadefinition die Avro- oder Protokollpufferdefinition für Ihr Schema ein.

   Hier sehen Sie ein Beispielschema in Avro.

   {
     "type": "record",
     "name": "Avro",
     "fields": [
       {
         "name": "ProductName",
         "type": "string",
         "default": ""
       },
       {
         "name": "SKU",
         "type": "int",
         "default": 0
       },
       {
         "name": "InStock",
         "type": "boolean",
         "default": false
       }
     ]
   }
   
   

6. Optional: Klicken Sie auf Definition überprüfen, um zu prüfen, ob die Schemadefinition korrekt ist.

   Die Validierungsprüfung prüft nicht die Kompatibilität des Schemas mit den zu veröffentlichenden Nachrichten. Testen Sie Nachrichten im nächsten Schritt.

7. Optional: Sie können testen, ob Nachrichten mit dem richtigen Schema veröffentlicht werden.

   1. Klicken Sie auf Nachricht testen.

   2. Wählen Sie im Fenster Testnachricht einen Typ für die Nachrichtencodierung aus.

   3. Geben Sie im Feld Nachrichtentext eine Testnachricht ein.

   4. Klicken Sie auf Test.

      Hier sehen Sie eine Beispielnachricht für das Testschema. Wählen Sie in diesem Beispiel als Nachrichtencodierung JSON aus.

      {"ProductName":"GreenOnions", "SKU":34543, "InStock":true}
      

   5. Schließen Sie die Seite mit der Testnachricht.

8. Klicken Sie auf Erstellen, um das Schema zu speichern.

gcloud

gcloud pubsub schemas create SCHEMA_ID \
        --type=SCHEMA_TYPE \
        --definition=SCHEMA_DEFINITION

Wobei:

• SCHEMA_TYPE ist entweder avro oder protocol-buffer.
• SCHEMA_DEFINITION ist ein string, der die Definition des Schemas enthält, die gemäß dem ausgewählten Schematyp formatiert ist.

Sie können die Schemadefinition auch in einer Datei angeben:

gcloud pubsub schemas create SCHEMA_ID \
        --type=SCHEMA_TYPE \
        --definition-file=SCHEMA_DEFINITION_FILE

Wobei:

• SCHEMA_TYPE ist entweder avro oder protocol-buffer.
• SCHEMA_DEFINITION_FILE ist ein string, der den Pfad zur Datei mit der Definition des Schemas enthält, der gemäß dem ausgewählten Schematyp formatiert ist.

REST

Senden Sie zum Erstellen eines Schemas eine POST-Anfrage wie die diese:

POST https://pubsub.googleapis.com/v1/projects/PROJECT_ID/schemas/SCHEMA_ID
Authorization: Bearer $(gcloud auth application-default print-access-token)
Content-Type: application/json --data @response-body.json

Geben Sie im Anfragetext die folgenden Felder an:

{
  "definition": SCHEMA_DEFINITION
  "type": SCHEMA_TYPE
}

Wobei:

• SCHEMA_TYPE ist entweder avro oder protocol-buffer.
• SCHEMA_DEFINITION ist ein String, der die Definition des Schemas enthält, formatiert gemäß dem ausgewählten Schematyp.

Der Antworttext sollte eine JSON-Darstellung einer Schemaressource enthalten. Beispiel:

{
  "name": SCHEMA_NAME,
  "type": SCHEMA_TYPE,
  "definition": SCHEMA_DEFINITION
  "revisionId": REVISION_ID
  "revisionCreateTime": REVISION_CREATE_TIME
}

Wobei:

• REVISION_ID ist die vom Server generierte ID für die Überarbeitung.
• REVISION_CREATE_TIME ist der Zeitstempel gemäß ISO 8601, zu dem die Überarbeitung erstellt wurde.

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.

Avro

Auf GitHub ansehen Feedback

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::SchemaServiceClient client, std::string const& project_id,
   std::string const& schema_id) {
  auto constexpr kDefinition = R"js({
    "type": "record",
    "name": "State",
    "namespace": "utilities",
    "doc": "A list of states in the United States of America.",
    "fields": [
      {
        "name": "name",
        "type": "string",
        "doc": "The common name of the state."
      },
      {
        "name": "post_abbr",
        "type": "string",
        "doc": "The postal code abbreviation of the state."
      }
    ]
  })js";
  google::pubsub::v1::CreateSchemaRequest request;
  request.set_parent(google::cloud::Project(project_id).FullName());
  request.set_schema_id(schema_id);
  request.mutable_schema()->set_type(google::pubsub::v1::Schema::AVRO);
  request.mutable_schema()->set_definition(kDefinition);
  auto schema = client.CreateSchema(request);
  if (schema.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The schema already exists\n";
    return;
  }
  if (!schema) throw std::move(schema).status();

  std::cout << "Schema successfully created: " << schema->DebugString()
            << "\n";
}

Proto

Auf GitHub ansehen Feedback

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::SchemaServiceClient client, std::string const& project_id,
   std::string const& schema_id) {
  auto constexpr kDefinition = R"pfile(
      syntax = "proto3";
      package google.cloud.pubsub.samples;

      message State {
        string name = 1;
        string post_abbr = 2;
      }
      )pfile";
  google::pubsub::v1::CreateSchemaRequest request;
  request.set_parent(google::cloud::Project(project_id).FullName());
  request.set_schema_id(schema_id);
  request.mutable_schema()->set_type(
      google::pubsub::v1::Schema::PROTOCOL_BUFFER);
  request.mutable_schema()->set_definition(kDefinition);
  auto schema = client.CreateSchema(request);
  if (schema.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The schema already exists\n";
    return;
  }
  if (!schema) throw std::move(schema).status();
  std::cout << "Schema successfully created: " << schema->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.

Avro

Auf GitHub ansehen Feedback

using Google.Cloud.PubSub.V1;
using Grpc.Core;
using System;
using System.IO;

public class CreateAvroSchemaSample
{
    public Schema CreateAvroSchema(string projectId, string schemaId, string pathToDefinition)
    {
        SchemaServiceClient schemaService = SchemaServiceClient.Create();
        var schemaName = SchemaName.FromProjectSchema(projectId, schemaId);
        string schemaDefinition = File.ReadAllText(pathToDefinition);
        Schema schema = new Schema
        {
            Name = schemaName.ToString(),
            Type = Schema.Types.Type.Avro,
            Definition = schemaDefinition
        };
        CreateSchemaRequest createSchemaRequest = new CreateSchemaRequest
        {
            Parent = "projects/" + projectId,
            SchemaId = schemaId,
            Schema = schema
        };

        try
        {
            schema = schemaService.CreateSchema(createSchemaRequest);
            Console.WriteLine($"Schema {schema.Name} created.");
        }
        catch (RpcException e) when (e.Status.StatusCode == StatusCode.AlreadyExists)
        {
            Console.WriteLine($"Schema {schemaName} already exists.");
        }
        return schema;
    }
}

Proto

Auf GitHub ansehen Feedback

using Google.Cloud.PubSub.V1;
using Grpc.Core;
using System;
using System.IO;

public class CreateProtoSchemaSample
{
    public Schema CreateProtoSchema(string projectId, string schemaId, string pathToDefinition)
    {
        SchemaServiceClient schemaService = SchemaServiceClient.Create();
        var schemaName = SchemaName.FromProjectSchema(projectId, schemaId);
        string schemaDefinition = File.ReadAllText(pathToDefinition);
        Schema schema = new Schema
        {
            Name = schemaName.ToString(),
            Type = Schema.Types.Type.ProtocolBuffer,
            Definition = schemaDefinition
        };
        CreateSchemaRequest createSchemaRequest = new CreateSchemaRequest
        {
            Parent = "projects/" + projectId,
            SchemaId = schemaId,
            Schema = schema
        };

        try
        {
            schema = schemaService.CreateSchema(createSchemaRequest);
            Console.WriteLine($"Schema {schema.Name} created.");
        }
        catch (RpcException e) when (e.Status.StatusCode == StatusCode.AlreadyExists)
        {
            Console.WriteLine($"Schema {schemaName} already exists.");
        }
        return schema;
    }
}

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.

Avro

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"os"

	"cloud.google.com/go/pubsub"
)

// createAvroSchema creates a schema resource from a JSON-formatted Avro schema file.
func createAvroSchema(w io.Writer, projectID, schemaID, avscFile string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema"
	// avscFile = "path/to/an/avro/schema/file(.avsc)/formatted/in/json"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	avscSource, err := os.ReadFile(avscFile)
	if err != nil {
		return fmt.Errorf("error reading from file: %s", avscFile)
	}

	config := pubsub.SchemaConfig{
		Type:       pubsub.SchemaAvro,
		Definition: string(avscSource),
	}
	s, err := client.CreateSchema(ctx, schemaID, config)
	if err != nil {
		return fmt.Errorf("CreateSchema: %v", err)
	}
	fmt.Fprintf(w, "Schema created: %#v\n", s)
	return nil
}

Proto

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"os"

	"cloud.google.com/go/pubsub"
)

// createProtoSchema creates a schema resource from a schema proto file.
func createProtoSchema(w io.Writer, projectID, schemaID, protoFile string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema"
	// protoFile = "path/to/a/proto/schema/file(.proto)/formatted/in/protocol/buffers"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	protoSource, err := os.ReadFile(protoFile)
	if err != nil {
		return fmt.Errorf("error reading from file: %s", protoFile)
	}

	config := pubsub.SchemaConfig{
		Type:       pubsub.SchemaProtocolBuffer,
		Definition: string(protoSource),
	}
	s, err := client.CreateSchema(ctx, schemaID, config)
	if err != nil {
		return fmt.Errorf("CreateSchema: %v", err)
	}
	fmt.Fprintf(w, "Schema created: %#v\n", s)
	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.

Avro

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.AlreadyExistsException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.ProjectName;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class CreateAvroSchemaExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id";
    String avscFile = "path/to/an/avro/schema/file/(.avsc)/formatted/in/json";

    createAvroSchemaExample(projectId, schemaId, avscFile);
  }

  public static Schema createAvroSchemaExample(String projectId, String schemaId, String avscFile)
      throws IOException {

    ProjectName projectName = ProjectName.of(projectId);
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    // Read an Avro schema file formatted in JSON as a string.
    String avscSource = new String(Files.readAllBytes(Paths.get(avscFile)));

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      Schema schema =
          schemaServiceClient.createSchema(
              projectName,
              Schema.newBuilder()
                  .setName(schemaName.toString())
                  .setType(Schema.Type.AVRO)
                  .setDefinition(avscSource)
                  .build(),
              schemaId);

      System.out.println("Created a schema using an Avro schema:\n" + schema);
      return schema;
    } catch (AlreadyExistsException e) {
      System.out.println(schemaName + "already exists.");
      return null;
    }
  }
}

Proto

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.AlreadyExistsException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.ProjectName;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class CreateProtoSchemaExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id";
    String protoFile = "path/to/a/proto/file/(.proto)/formatted/in/protocol/buffers";

    createProtoSchemaExample(projectId, schemaId, protoFile);
  }

  public static Schema createProtoSchemaExample(String projectId, String schemaId, String protoFile)
      throws IOException {

    ProjectName projectName = ProjectName.of(projectId);
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    // Read a proto file as a string.
    String protoSource = new String(Files.readAllBytes(Paths.get(protoFile)));

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      Schema schema =
          schemaServiceClient.createSchema(
              projectName,
              Schema.newBuilder()
                  .setName(schemaName.toString())
                  .setType(Schema.Type.PROTOCOL_BUFFER)
                  .setDefinition(protoSource)
                  .build(),
              schemaId);

      System.out.println("Created a schema using a protobuf schema:\n" + schema);
      return schema;
    } catch (AlreadyExistsException e) {
      System.out.println(schemaName + "already exists.");
      return null;
    }
  }
}

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.

Avro

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';
// const avscFile = 'path/to/an/avro/schema/file/(.avsc)/formatted/in/json';

// Imports the Google Cloud client library
const {PubSub, SchemaTypes} = require('@google-cloud/pubsub');

const fs = require('fs');

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

async function createAvroSchema(schemaNameOrId, avscFile) {
  const definition = fs.readFileSync(avscFile).toString();
  const schema = await pubSubClient.createSchema(
    schemaNameOrId,
    SchemaTypes.Avro,
    definition
  );

  const name = await schema.getName();
  console.log(`Schema ${name} created.`);
}

Proto

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';
// const protoFile = 'path/to/a/proto/schema/file/(.proto)/formatted/in/protcol/buffers';

// Imports the Google Cloud client library
const {PubSub, SchemaTypes} = require('@google-cloud/pubsub');

const fs = require('fs');

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

async function createProtoSchema(schemaNameOrId, protoFile) {
  const definition = fs.readFileSync(protoFile).toString();
  const schema = await pubSubClient.createSchema(
    schemaNameOrId,
    SchemaTypes.ProtocolBuffer,
    definition
  );

  const fullName = await schema.getName();
  console.log(`Schema ${fullName} created.`);
}

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.

Avro

Auf GitHub ansehen Feedback

use Google\Cloud\PubSub\PubSubClient;
use Google\Cloud\PubSub\V1\Schema\Type;

/**
 * Create a Schema with an AVRO definition.
 *
 * @param string $projectId
 * @param string $schemaId
 * @param string $avscFile
 */
function create_avro_schema($projectId, $schemaId, $avscFile)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);

    $definition = file_get_contents($avscFile);
    $schema = $pubsub->createSchema($schemaId, Type::AVRO, $definition);

    printf('Schema %s created.', $schema->name());
}

Proto

Auf GitHub ansehen Feedback

use Google\Cloud\PubSub\PubSubClient;
use Google\Cloud\PubSub\V1\Schema\Type;

/**
 * Create a Schema with an Protocol Buffer definition.
 *
 * @param string $projectId
 * @param string $schemaId
 * @param string $protoFile
 */
function create_proto_schema($projectId, $schemaId, $protoFile)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);

    $definition = file_get_contents($protoFile);
    $schema = $pubsub->createSchema($schemaId, Type::PROTOCOL_BUFFER, $definition);

    printf('Schema %s created.', $schema->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.

Avro

Auf GitHub ansehen Feedback

from google.api_core.exceptions import AlreadyExists
from google.cloud.pubsub import SchemaServiceClient
from google.pubsub_v1.types import Schema

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# avsc_file = "path/to/an/avro/schema/file/(.avsc)/formatted/in/json"

project_path = f"projects/{project_id}"

# Read a JSON-formatted Avro schema file as a string.
with open(avsc_file, "rb") as f:
    avsc_source = f.read().decode("utf-8")

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)
schema = Schema(name=schema_path, type_=Schema.Type.AVRO, definition=avsc_source)

try:
    result = schema_client.create_schema(
        request={"parent": project_path, "schema": schema, "schema_id": schema_id}
    )
    print(f"Created a schema using an Avro schema file:\n{result}")
    return result
except AlreadyExists:
    print(f"{schema_id} already exists.")

Proto

Auf GitHub ansehen Feedback

from google.api_core.exceptions import AlreadyExists
from google.cloud.pubsub import SchemaServiceClient
from google.pubsub_v1.types import Schema

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# proto_file = "path/to/a/proto/file/(.proto)/formatted/in/protocol/buffers"

project_path = f"projects/{project_id}"

# Read a protobuf schema file as a string.
with open(proto_file, "rb") as f:
    proto_source = f.read().decode("utf-8")

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)
schema = Schema(
    name=schema_path, type_=Schema.Type.PROTOCOL_BUFFER, definition=proto_source
)

try:
    result = schema_client.create_schema(
        request={"parent": project_path, "schema": schema, "schema_id": schema_id}
    )
    print(f"Created a schema using a protobuf schema file:\n{result}")
    return result
except AlreadyExists:
    print(f"{schema_id} already exists.")

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.

Avro

Auf GitHub ansehen Feedback

# schema_id = "your-schema-id"
# avsc_file = "path/to/an/avro/schema/file/(.avsc)/formatted/in/json"
require "google/cloud/pubsub"

pubsub = Google::Cloud::Pubsub.new

definition = File.read avsc_file
schema = pubsub.create_schema schema_id, :avro, definition

puts "Schema #{schema.name} created."

Proto

Auf GitHub ansehen Feedback

# schema_id = "your-schema-id"
# proto_file = "path/to/a/proto/file/(.proto)/formatted/in/protocol/buffers"
require "google/cloud/pubsub"

pubsub = Google::Cloud::Pubsub.new

definition = File.read proto_file
schema = pubsub.create_schema schema_id, :protocol_buffer, definition

puts "Schema #{schema.name} created."

Nachdem ein Schema erstellt wurde, können Sie die Details des Schemas auf der Seite Schemas sehen. Sie können jetzt das Schema mit einem Thema verknüpfen.

Schemaüberarbeitung vornehmen

Sie können ein Schema in Pub/Sub überarbeiten.

Sie können eine Schemaüberarbeitung über die Google Cloud Console, die gcloud CLI, die Pub/Sub API oder die Cloud-Clientbibliotheken durchführen.

Im Folgenden finden Sie einige Richtlinien, um ein Schema zu überarbeiten:

• Sie können ein Schema innerhalb bestimmter Einschränkungen überarbeiten:

  • Bei Protocol Buffer-Schemas können Sie optionale Felder hinzufügen oder entfernen. Sie können keine anderen Felder hinzufügen oder löschen. Sie können auch keine vorhandenen Felder bearbeiten.

  • Informationen zu Avro-Schemas finden Sie in der Avro-Dokumentation.

  • Ein Schema kann maximal 20 Überarbeitungen gleichzeitig haben. Wenn Sie das Limit überschreiten, löschen Sie eine Schemaüberarbeitung, bevor Sie eine weitere erstellen.

• Jeder Überarbeitung ist eine eindeutige Überarbeitungs-ID zugeordnet. Die Überarbeitungs-ID ist eine automatisch generierte achtstellige UUID.

• Wenn Sie den Überarbeitungsbereich oder die Überarbeitung eines Schemas aktualisieren, das für die Themenvalidierung verwendet wird, kann es einige Minuten dauern, bis die Änderungen wirksam werden.

Console

So erstellen Sie eine Schemaüberarbeitung:

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

   Zu den Schemas

2. Klicken Sie auf die Schema-ID eines vorhandenen Schemas.

   Die Seite Schemadetails für das Schema wird geöffnet.

3. Klicken Sie auf Überarbeitung erstellen.

   Die Seite Schemaüberarbeitung erstellen wird geöffnet.

4. Nehmen Sie die erforderlichen Änderungen vor.

   Für das Beispielschema in Avro, das Sie unter Schema erstellen erstellt haben, können Sie beispielsweise das optionale Feld Price so hinzufügen:

    {
      "type": "record",
      "name": "Avro",
      "fields": [
        {
          "name": "ProductName",
          "type": "string",
          "default": ""
        },
        {
          "name": "SKU",
          "type": "int",
          "default": 0
        },
        {
          "name": "InStock",
          "type": "boolean",
          "default": false
        },
        {
          "name": "Price",
          "type": "double",
          "default": "0.0"
        },
      ]
    }
   

5. Klicken Sie auf Definition überprüfen, um zu prüfen, ob die Schemadefinition korrekt ist.

   Hinweis: Bei der Validierungsprüfung wird nicht geprüft, ob die neue Version mit den älteren Überarbeitungen kompatibel ist.

6. Sie können die Nachrichten auch für das Schema validieren.

   1. Klicken Sie auf Testnachricht, um eine Beispielnachricht zu testen.

   2. Wählen Sie im Fenster Testnachricht einen Typ für die Nachrichtencodierung aus.

   3. Geben Sie im Feld Nachrichtentext eine Testnachricht ein.

      Hier sehen Sie eine Beispielnachricht für das Testschema. Wählen Sie in diesem Beispiel als Nachrichtencodierung JSON aus.

      {"ProductName":"GreenOnions", "SKU":34543, "Price":12, "InStock":true}
      

   4. Klicken Sie auf Test.

7. Klicken Sie auf Commit durchführen, um das Schema zu speichern.

gcloud

gcloud pubsub schemas commit SCHEMA_ID \
        --type=SCHEMA_TYPE \
        --definition=SCHEMA_DEFINITION

Wobei:

• SCHEMA_TYPE ist entweder avro oder protocol-buffer.
• SCHEMA_DEFINITION ist ein string, der die Definition des Schemas enthält, die gemäß dem ausgewählten Schematyp formatiert ist.

Sie können auch die Schemadefinition in der Datei angeben:

gcloud pubsub schemas commit SCHEMA_ID \
        --type=SCHEMA_TYPE \
        --definition-file=SCHEMA_DEFINITION_FILE

Wobei:

• SCHEMA_TYPE ist entweder avro oder protocol-buffer.
• SCHEMA_DEFINITION_FILE ist ein string, der den Pfad zur Datei mit der Definition des Schemas enthält, der gemäß dem ausgewählten Schematyp formatiert ist.

REST

Senden Sie eine POST-Anfrage wie die folgende, um ein Schema zu aktualisieren:

POST https://pubsub.googleapis.com/v1/projects/PROJECT_ID/schemas/SCHEMA_ID:commit
Authorization: Bearer $(gcloud auth application-default print-access-token)
Content-Type: application/json --data @response-body.json

Geben Sie im Anfragetext die folgenden Felder an:

{
  "definition": SCHEMA_DEFINITION
  "type": SCHEMA_TYPE
  "name": SCHEMA_NAME
}

Wobei:

• SCHEMA_TYPE ist entweder AVRO oder PROTOCOL_BUFFER.
• SCHEMA_DEFINITION ist ein String, der die Definition des Schemas enthält, formatiert gemäß dem ausgewählten Schematyp.
• SCHEMA_NAME ist der Name eines vorhandenen Schemas.

Der Antworttext sollte eine JSON-Darstellung einer Schemaressource enthalten. Beispiel:

{
  "name": SCHEMA_NAME,
  "type": SCHEMA_TYPE,
  "definition": SCHEMA_DEFINITION
  "revisionId": REVISION_ID
  "revisionCreateTime": REVISION_CREATE_TIME
}

Wobei:

• REVISION_ID ist die vom Server generierte ID für die Überarbeitung.
• REVISION_CREATE_TIME ist der Zeitstempel gemäß ISO 8601, zu dem die Überarbeitung erstellt wurde.

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.

Avro

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"io/ioutil"

	"cloud.google.com/go/pubsub"
)

// commitAvroSchema commits a new avro schema revision to an existing schema.
func commitAvroSchema(w io.Writer, projectID, schemaID, avscFile string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema-id"
	// avscFile = "path/to/an/avro/schema/file(.avsc)/formatted/in/json"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	// Read an Avro schema file formatted in JSON as a byte slice.
	avscSource, err := ioutil.ReadFile(avscFile)
	if err != nil {
		return fmt.Errorf("error reading from file: %s", avscFile)
	}

	config := pubsub.SchemaConfig{
		Name:       fmt.Sprintf("projects/%s/schemas/%s", projectID, schemaID),
		Type:       pubsub.SchemaAvro,
		Definition: string(avscSource),
	}
	s, err := client.CommitSchema(ctx, schemaID, config)
	if err != nil {
		return fmt.Errorf("CommitSchema: %v", err)
	}
	fmt.Fprintf(w, "Committed a schema using an Avro schema: %#v\n", s)
	return nil
}

Proto

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"io/ioutil"

	"cloud.google.com/go/pubsub"
)

// commitProtoSchema commits a new proto schema revision to an existing schema.
func commitProtoSchema(w io.Writer, projectID, schemaID, protoFile string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema"
	// protoFile = "path/to/a/proto/schema/file(.proto)/formatted/in/protocol/buffers"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	// Read a proto file as a byte slice.
	protoSource, err := ioutil.ReadFile(protoFile)
	if err != nil {
		return fmt.Errorf("error reading from file: %s", protoFile)
	}

	config := pubsub.SchemaConfig{
		Name:       fmt.Sprintf("projects/%s/schemas/%s", projectID, schemaID),
		Type:       pubsub.SchemaProtocolBuffer,
		Definition: string(protoSource),
	}
	s, err := client.CommitSchema(ctx, schemaID, config)
	if err != nil {
		return fmt.Errorf("CommitSchema: %v", err)
	}
	fmt.Fprintf(w, "Committed a schema using a protobuf schema: %#v\n", s)
	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.

Avro

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.ProjectName;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class CommitAvroSchemaExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id";
    String avscFile = "path/to/an/avro/schema/file/(.avsc)/formatted/in/json";

    commitAvroSchemaExample(projectId, schemaId, avscFile);
  }

  public static Schema commitAvroSchemaExample(String projectId, String schemaId, String avscFile)
      throws IOException {

    ProjectName projectName = ProjectName.of(projectId);
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    // Read an Avro schema file formatted in JSON as a string.
    String avscSource = new String(Files.readAllBytes(Paths.get(avscFile)));

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      Schema schema =
          schemaServiceClient.commitSchema(
              schemaName.toString(),
              Schema.newBuilder()
                  .setName(schemaName.toString())
                  .setType(Schema.Type.AVRO)
                  .setDefinition(avscSource)
                  .build());

      System.out.println("Committed a schema using an Avro schema:\n" + schema);
      return schema;
    } catch (NotFoundException e) {
      System.out.println(schemaName + "does not exist.");
      return null;
    }
  }
}

Proto

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.ProjectName;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class CommitProtoSchemaExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id";
    String protoFile = "path/to/a/proto/file/(.proto)/formatted/in/protocol/buffers";

    commitProtoSchemaExample(projectId, schemaId, protoFile);
  }

  public static Schema commitProtoSchemaExample(String projectId, String schemaId, String protoFile)
      throws IOException {

    ProjectName projectName = ProjectName.of(projectId);
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    // Read a proto file as a string.
    String protoSource = new String(Files.readAllBytes(Paths.get(protoFile)));

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      Schema schema =
          schemaServiceClient.commitSchema(
              schemaName.toString(),
              Schema.newBuilder()
                  .setName(schemaName.toString())
                  .setType(Schema.Type.PROTOCOL_BUFFER)
                  .setDefinition(protoSource)
                  .build());

      System.out.println("Committed a schema using a protobuf schema:\n" + schema);
      return schema;
    } catch (NotFoundException e) {
      System.out.println(schemaName + "does not exist.");
      return null;
    }
  }
}

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.

Avro

Auf GitHub ansehen Feedback

from google.api_core.exceptions import NotFound
from google.cloud.pubsub import SchemaServiceClient
from google.pubsub_v1.types import Schema

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# avsc_file = "path/to/an/avro/schema/file/(.avsc)/formatted/in/json"

# Read a JSON-formatted Avro schema file as a string.
with open(avsc_file, "rb") as f:
    avsc_source = f.read().decode("utf-8")

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)
schema = Schema(name=schema_path, type_=Schema.Type.AVRO, definition=avsc_source)

try:
    result = schema_client.commit_schema(
        request={"schema": schema, "name": schema_path}
    )
    print(f"Committed a schema revision using an Avro schema file:\n{result}")
    return result
except NotFound:
    print(f"{schema_id} does not exist.")

Proto

Auf GitHub ansehen Feedback

from google.api_core.exceptions import NotFound
from google.cloud.pubsub import SchemaServiceClient
from google.pubsub_v1.types import Schema

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# proto_file = "path/to/a/proto/file/(.proto)/formatted/in/protocol/buffers"

# Read a protobuf schema file as a string.
with open(proto_file, "rb") as f:
    proto_source = f.read().decode("utf-8")

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)
schema = Schema(
    name=schema_path, type_=Schema.Type.PROTOCOL_BUFFER, definition=proto_source
)

try:
    result = schema_client.commit_schema(
        request={"schema": schema, "name": schema_path}
    )
    print(f"Committed a schema revision using a protobuf schema file:\n{result}")
    return result
except NotFound:
    print(f"{schema_id} does not exist.")

Nach dem Commit einer Schemaüberarbeitung können Sie die Details der neuen Überarbeitung auf der Seite Schemas sehen.

Schema mit einem Thema verknüpfen

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 einem Thema zugeordnet wurde, muss jede Nachricht, die das Thema von den Publishern erhält, diesem Schema folgen.

• Wenn Sie ein Schema mit einem Thema verknüpfen, müssen Sie auch die Codierung der zu veröffentlichenden Nachrichten als BINARY oder JSON angeben.

• Wenn einem Schema, das mit einem Thema verknüpft ist, Überarbeitungen vorliegen, müssen die Nachrichten mit der Codierung übereinstimmen und innerhalb des verfügbaren Bereichs auf eine Überarbeitung geprüft werden. Andernfalls wird die Nachricht nicht veröffentlicht.

  Überarbeitungen werden in umgekehrter chronologischer Reihenfolge ausgeführt, die auf dem Erstellungszeitpunkt basiert. Informationen zum Erstellen einer Schemaüberarbeitung finden Sie unter Schemaüberarbeitung durchführen.

Validierungslogik für ein Nachrichtenschema

Wenn Sie ein Schema mit einem Thema verknüpfen und das Schema Überarbeitungen enthält, können Sie einen Teil der zu verwendenden Überarbeitungen angeben. Wenn Sie keinen Bereich angeben, wird der gesamte Bereich für die Validierung verwendet.

Wenn Sie eine Überarbeitung nicht als Erste Überarbeitung erlaubt angeben, wird die älteste vorhandene Überarbeitung für das Schema zur Validierung verwendet. Wenn Sie eine Überarbeitung nicht als Letzte Überarbeitung erlaubt angeben, wird die neueste vorhandene Überarbeitung für das Schema 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 in der angegebenen Reihenfolge, wobei A die erste oder älteste Überarbeitung ist. Keines der Schemas ist identisch oder es gibt ein Rollback eines vorhandenen Schemas.

• Wenn Sie nur das Feld Erste Überarbeitung erlaubt als B festlegen, werden Nachrichten abgelehnt, die nur dem Schema A entsprechen, während Nachrichten, die dem Schema B, C und D entsprechen, akzeptiert werden.

• Wenn Sie nur das Feld Letzte Überarbeitung zulässig als C festlegen, 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 erlaubt den Wert B und Letzte Überarbeitung zugelassen den Wert C festgelegt haben, werden Nachrichten akzeptiert, die den Schemas B und C entsprechen.

• Sie können auch für die erste und die letzte Überarbeitung dieselbe Überarbeitungs-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 über die Google Cloud Console, die gcloud CLI, die Pub/Sub API oder die 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 zum Benennen eines Themas finden Sie in den Richtlinien.

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

   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 auf 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 die Nachrichtencodierung als JSON oder Binär aus.

   Das soeben erstellte Schema hat eine Überarbeitungs-ID. Sie können zusätzliche Schemaüberarbeitungen erstellen, wie unter Schemaüberarbeitung Commit durchführen erläutert.

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 die Nachrichtencodierung als JSON oder Binär aus.

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

Sie können beide Felder angeben oder nur eines festlegen 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 es 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 von Ihnen erstellte Thema.
• ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wurden. Dieser Wert muss entweder JSON oder BINARY sein.
• SCHEMA_ID ist die ID eines vorhandenen Schemas.
• FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die validiert werden soll.
• LAST_REVISION_ID ist die ID der neuesten Überarbeitung, 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 die Methode projects.topics.create, um ein Thema zu erstellen:

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, mit dem Nachrichten veröffentlicht werden sollen. Das Format ist projects/PROJECT_ID/schemas/SCHEMA_ID.
• ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wurden. Dies muss entweder JSON oder BINARY sein.
• FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die validiert werden soll.
• LAST_REVISION_ID ist die ID der neuesten Überarbeitung, 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 ausgelassen, wenn sie in der Anfrage nicht 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.

Auf GitHub ansehen Feedback

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::TopicAdminClient client, std::string project_id,
   std::string topic_id, std::string schema_id, std::string const& encoding) {
  auto const& schema = pubsub::Schema(project_id, std::move(schema_id));
  auto topic = client.CreateTopic(
      pubsub::TopicBuilder(
          pubsub::Topic(std::move(project_id), std::move(topic_id)))
          .set_schema(schema)
          .set_encoding(encoding == "JSON" ? google::pubsub::v1::JSON
                                           : google::pubsub::v1::BINARY));
  // 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.

Auf GitHub ansehen Feedback

using Google.Cloud.PubSub.V1;
using Grpc.Core;
using System;

public class CreateTopicWithSchemaSample
{
    public Topic CreateTopicWithSchema(string projectId, string topicId, string schemaName, Encoding encoding)
    {
        PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
        var topicName = TopicName.FromProjectTopic(projectId, topicId);
        Topic topic = new Topic
        {
            Name = topicName.ToString(),
            SchemaSettings = new SchemaSettings
            {
                Schema = schemaName,
                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.

Auf GitHub ansehen Feedback

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: %v", 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: %v", 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

/**
 * 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}.`);
}

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

# 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
require "google/cloud/pubsub"

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

Achtung: Wenn Sie das Schema oder die Codierung eines Themas ändern oder das Schema aus einem Thema entfernen, kann dies zu Fehlern bei Publishern führen, die aktiv Inhalte veröffentlichen.

Sie können ein Thema bearbeiten, um ein Schema anzuhängen, ein Schema zu entfernen oder den Überarbeitungsbereich zu aktualisieren, der zum Validieren von Nachrichten verwendet wird. Im Allgemeinen können Sie, wenn Sie Änderungen für das verwendete Schema geplant haben, eine neue Überarbeitung übergeben und den für das Thema verwendeten Überarbeitungsbereich aktualisieren.

Sie können ein mit einem Thema verknüpftes Schema über die Google Cloud Console, die gcloud CLI, die Pub/Sub API oder die 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, nutzen Sie für die Überarbeitung die Drop-down-Menüs Erste Überarbeitung erlaubt und Letzte Überarbeitung zulässig.

   Sie können beide Felder angeben oder nur eines festlegen 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 von Ihnen erstellte Thema.
• ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wurden. Dieser Wert muss entweder JSON oder BINARY sein.
• SCHEMA_NAME ist der Name eines vorhandenen Schemas.
• FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die validiert werden soll.
• LAST_REVISION_ID ist die ID der neuesten Überarbeitung, die validiert werden soll.

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

REST

Verwenden Sie die Methode projects.topics.update, um ein Thema zu aktualisieren:

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, mit dem Nachrichten veröffentlicht werden sollen. Das Format ist projects/PROJECT_ID/schemas/SCHEMA_ID.
• ENCODING_TYPE ist die Codierung von Nachrichten, die anhand des Schemas validiert wurden. Dies muss entweder JSON oder BINARY sein.
• FIRST_REVISION_ID ist die ID der ältesten Überarbeitung, die validiert werden soll.
• LAST_REVISION_ID ist die ID der neuesten Überarbeitung, 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 mehr festgelegt.

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.

Auf GitHub ansehen Feedback

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: %v", 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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

Schemaüberarbeitung rückgängig machen

Sie können ein Rollback auf eine bestimmte Schemaüberarbeitung durchführen. Mit dem Rollback-Vorgang können Sie eine weitere Schemaüberarbeitung mit der exakten Schemadefinition wie in der vorherigen Überarbeitung erstellen.

Sie können ein Schema mit der Google Cloud Console, der gcloud CLI, der Pub/Sub API oder den Cloud-Clientbibliotheken zurücksetzen. Gehen Sie so vor:

Console

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

   Zu den Schemas

2. Klicken Sie auf den Namen eines vorhandenen Schemas.

   Die Seite Schemadetails für das Schema wird geöffnet.

3. Klicken Sie auf Rollback.

   Das Dialogfeld Rollback-Schema wird geöffnet.

4. Wählen Sie die Überarbeitung aus, auf die das Rollback eines Schemas angewendet werden soll.

5. Klicken Sie auf Bestätigen, um den Rollback-Vorgang zu speichern.

   Eine neue Überarbeitung wird mit dem Schema erstellt, das im Rollback-Vorgang angegeben wurde.

6. Wählen Sie auf der Seite Schemadetails die neueste Version des Schemas und die Version aus, die Sie als Quelle für den Rollback-Vorgang ausgewählt haben.

7. Klicken Sie auf Differenz ansehen.

   Sie können prüfen, ob die beiden Schemas identisch sind.

   Sie können die soeben erstellte Schemaüberarbeitung als letzte Überarbeitung zum Validieren eines Themas verwenden, indem Sie das Feld Letzte Überarbeitung zulässig aktualisieren.

gcloud

gcloud pubsub schemas rollback SCHEMA_ID \
        --revision-id=REVISION_ID

Wobei:

• REVISION_ID ist die Überarbeitung, für die ein Rollback durchgeführt werden soll.

REST

Senden Sie eine POST-Anfrage wie die folgende, um ein Schema zurückzusetzen:

POST https://pubsub.googleapis.com/v1/projects/PROJECT_ID/schemas/SCHEMA_ID:rollback
Authorization: Bearer $(gcloud auth application-default print-access-token)
Content-Type: application/json --data @response-body.json

Geben Sie im Anfragetext die folgenden Felder an:

{
  "revisionId": REVISION_KD
}

Wobei:

• REVISION_KD ist die ID der Überarbeitung, für die ein Rollback durchgeführt werden soll.

Der Antworttext sollte eine JSON-Darstellung einer Schemaressource enthalten.

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.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
)

// rollbackSchema creates a new schema revision that is a copy of the provided revisionID.
func rollbackSchema(w io.Writer, projectID, schemaID, revisionID string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema"
	// revisionID := "a1b2c3d4"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	s, err := client.RollbackSchema(ctx, schemaID, revisionID)
	if err != nil {
		return fmt.Errorf("RollbackSchema: %v", err)
	}
	fmt.Fprintf(w, "Rolled back a schema: %#v\n", s)
	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.

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;

public class RollbackSchemaExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project";
    String schemaId = "your-schema";
    String revisionId = "your-revision";

    rollbackSchemaExample(projectId, schemaId, revisionId);
  }

  public static void rollbackSchemaExample(String projectId, String schemaId, String revisionId)
      throws IOException {
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      Schema schema = schemaServiceClient.rollbackSchema(schemaName, revisionId);

      System.out.println("Rolled back a schema:" + schema);

    } catch (NotFoundException e) {
      System.out.println(schemaName + "not found.");
    }
  }
}

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.

Auf GitHub ansehen Feedback

from google.api_core.exceptions import NotFound
from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# schema_revision_id = "your-schema-revision-id"

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)

try:
    result = schema_client.rollback_schema(
        request={"name": schema_path, "revision_id": schema_revision_id}
    )
    print(f"Rolled back a schema revision:\n{result}")
except NotFound:
    print(f"{schema_id} not found.")

Schemaüberarbeitung löschen

Wichtig: Wenn alle Überarbeitungen innerhalb des Überarbeitungsbereichs der Schemaeinstellungen für ein Thema gelöscht werden, schlagen alle Versuche, Nachrichten zu diesem Thema zu veröffentlichen, fehl.

Im Folgenden finden Sie einige wichtige Richtlinien zum Löschen einer Schemaüberarbeitung:

• Sie können eine oder mehrere Schemaüberarbeitungen aus einem Schema löschen.

• Wenn das Schema nur eine Überarbeitung hat, können Sie die Überarbeitung nicht löschen. Löschen Sie stattdessen das Schema.

• Beim Löschen eines Schemas werden auch alle damit verknüpften Überarbeitungen gelöscht.

• Wenn Sie ein Schema löschen, schlägt das Veröffentlichen von Nachrichten in Themen fehl, die mit diesem Schema verknüpft sind.

• Wenn Sie eine Schemaüberarbeitung löschen und diese als erste Überarbeitung für ein Thema angegeben ist, wird stattdessen die nächste Überarbeitung verwendet.

  Wenn die gelöschte Schemaüberarbeitung als letzte Überarbeitung für ein Thema angegeben ist, wird die vorherige Schemaüberarbeitung zur Überprüfung verwendet.

  Wenn die gelöschte Schemaüberarbeitung in den angegebenen Überarbeitungsbereich für ein Thema zur Validierung fällt, wird die Überarbeitung übersprungen.

Sie können eine Schemaüberarbeitung mit der Google Cloud Console, der gcloud CLI, der Pub/Sub API oder den Cloud-Clientbibliotheken löschen.

Console

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

   Zu den Schemas

2. Klicken Sie auf den Namen eines vorhandenen Schemas.

   Die Seite Schemadetails für das Schema wird geöffnet.

3. Wählen Sie die Überarbeitung aus, die Sie löschen möchten. Sie können auch mehrere Überarbeitungen auswählen.

4. Klicken Sie auf Überarbeitung löschen.

5. Bestätigen Sie den Löschvorgang.

gcloud

gcloud pubsub schemas delete-revision SCHEMA_NAME@REVISION_ID

Wobei:

• REVISION_ID ist die Überarbeitung, für die ein Rollback durchgeführt werden soll.

REST

Senden Sie eine DELETE-Anfrage wie die folgende, um eine Schemaüberarbeitung zu löschen:

POST https://pubsub.googleapis.com/v1/projects/PROJECT_ID/schemas/SCHEMA_ID@REVISION_ID:deleteRevision
Authorization: Bearer $(gcloud auth application-default print-access-token)
Content-Type: application/json --data @response-body.json

Der Antworttext sollte eine JSON-Darstellung der gelöschten Schemaressource enthalten.

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.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
)

func deleteSchemaRevision(w io.Writer, projectID, schemaID, revisionID string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema-id"
	// revisionID := "my-revision-id"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	if _, err := client.DeleteSchemaRevision(ctx, schemaID, revisionID); err != nil {
		return fmt.Errorf("client.DeleteSchema revision: %v", err)
	}
	fmt.Fprintf(w, "Deleted a schema revision: %s@%s", schemaID, revisionID)
	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.

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.DeleteSchemaRevisionRequest;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;

public class DeleteSchemaRevisionExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id@your-revision-id";

    deleteSchemaRevisionExample(projectId, schemaId);
  }

  public static void deleteSchemaRevisionExample(String projectId, String schemaId)
      throws IOException {
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      DeleteSchemaRevisionRequest request =
          DeleteSchemaRevisionRequest.newBuilder().setName(schemaName.toString()).build();

      schemaServiceClient.deleteSchemaRevision(request);

      System.out.println("Deleted a schema revision:" + schemaName);

    } catch (NotFoundException e) {
      System.out.println(schemaName + "not found.");
    }
  }
}

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.

Auf GitHub ansehen Feedback

from google.api_core.exceptions import NotFound
from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# revision_id = "your-revision-id"

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id + "@" + revision_id)

try:
    schema_client.delete_schema_revision(request={"name": schema_path})
    print(f"Deleted a schema revision:\n{schema_path}")
except NotFound:
    print(f"{schema_id} not found.")

Schema löschen

Wichtig: Wenn ein Schema gelöscht wird, schlagen alle Versuche fehl, Nachrichten in Themen zu veröffentlichen, die mit diesem Schema verknüpft sind.

Bevor Sie ein Schema löschen, müssen Sie seine Verknüpfung mit einem Thema entfernen.

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

Console

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

   Zu den Schemas

2. Wählen Sie ein oder mehrere Schemas aus, die Sie löschen möchten.

3. Klicken Sie auf Löschen.

4. Bestätigen Sie den Löschvorgang.

gcloud

gcloud pubsub schemas delete SCHEMA_NAME

REST

Um ein Schema zu löschen, senden Sie eine DELETE-Anfrage wie diese:

DELETE https://pubsub.googleapis.com/v1/SCHEMA_NAME

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.

Auf GitHub ansehen Feedback

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::SchemaServiceClient client, std::string const& project_id,
   std::string const& schema_id) {
  google::pubsub::v1::DeleteSchemaRequest request;
  request.set_name(pubsub::Schema(project_id, schema_id).FullName());
  auto status = client.DeleteSchema(request);
  // Note that kNotFound is a possible result when the library retries.
  if (status.code() == google::cloud::StatusCode::kNotFound) {
    std::cout << "The schema was not found\n";
    return;
  }
  if (!status.ok()) throw std::runtime_error(status.message());

  std::cout << "Schema successfully deleted\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.

Auf GitHub ansehen Feedback

using Google.Cloud.PubSub.V1;

public class DeleteSchemaSample
{
    public void DeleteSchema(string projectId, string schemaId)
    {
        SchemaServiceClient schemaService = SchemaServiceClient.Create();
        SchemaName schemaName = SchemaName.FromProjectSchema(projectId, schemaId);
        schemaService.DeleteSchema(schemaName);
    }
}

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.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
)

func deleteSchema(w io.Writer, projectID, schemaID string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	if err := client.DeleteSchema(ctx, schemaID); err != nil {
		return fmt.Errorf("client.DeleteSchema: %v", err)
	}
	fmt.Fprintf(w, "Deleted schema: %s", schemaID)
	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.

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;

public class DeleteSchemaExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id";

    deleteSchemaExample(projectId, schemaId);
  }

  public static void deleteSchemaExample(String projectId, String schemaId) throws IOException {
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      schemaServiceClient.deleteSchema(schemaName);

      System.out.println("Deleted a schema:" + schemaName);

    } catch (NotFoundException e) {
      System.out.println(schemaName + "not found.");
    }
  }
}

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.

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment this variable before running the sample.
 */
// const schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';

// 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 deleteSchema(schemaNameOrId) {
  const schema = pubSubClient.schema(schemaNameOrId);
  const name = await schema.getName();
  await schema.delete();
  console.log(`Schema ${name} deleted.`);
}

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.

Auf GitHub ansehen Feedback

use Google\Cloud\PubSub\PubSubClient;

/**
 * Delete a schema.
 *
 * @param string $projectId
 * @param string $schemaId
 */
function delete_schema($projectId, $schemaId)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);

    $schema = $pubsub->schema($schemaId);

    if ($schema->exists()) {
        $schema->delete();

        printf('Schema %s deleted.', $schema->name());
    } else {
        printf('Schema %s does not exist.', $schema->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.

Auf GitHub ansehen Feedback

from google.api_core.exceptions import NotFound
from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)

try:
    schema_client.delete_schema(request={"name": schema_path})
    print(f"Deleted a schema:\n{schema_path}")
except NotFound:
    print(f"{schema_id} not found.")

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.

Auf GitHub ansehen Feedback

# schema_id = "your-schema-id"
require "google/cloud/pubsub"

pubsub = Google::Cloud::Pubsub.new

schema = pubsub.schema schema_id
schema.delete

puts "Schema #{schema_id} deleted."

Schemadetails ansehen

Sie können die Details eines Schemas über die Google Cloud Console, die gcloud CLI, die Pub/Sub API oder die Cloud-Clientbibliotheken abrufen. Die Ergebnisse geben die Details für die neueste Überarbeitungs-ID zurück.

Console

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

   Zu den Schemas

2. Klicken Sie auf den Namen des Schemas, das Sie aufrufen möchten.

   Die Seite Schemadetails für das Schema wird geöffnet.

gcloud

So rufen Sie die neueste Überarbeitung für ein Schema auf:

gcloud pubsub schemas describe SCHEMA_NAME

So rufen Sie eine bestimmte Überarbeitung für ein Schema auf:

gcloud pubsub schemas describe SCHEMA_ID@REVISION_ID

Wobei:

• REVISION_ID ist die Überarbeitung, für die ein Rollback durchgeführt werden soll.

REST

Senden Sie eine GET-Anfrage wie die folgende, um die Details der letzten Überarbeitung eines Schemas abzurufen:

GET https://pubsub.googleapis.com/v1/SCHEMA_NAME

Senden Sie eine GET-Anfrage wie die folgende, um die Details einer bestimmten Überarbeitung eines Schemas abzurufen:

GET https://pubsub.googleapis.com/v1/SCHEMA_NAME@REVISION_ID

Wenn der Vorgang erfolgreich ist, enthält der Antworttext eine Instanz der Schemaklasse.

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.

Auf GitHub ansehen Feedback

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::SchemaServiceClient client, std::string const& project_id,
   std::string const& schema_id) {
  google::pubsub::v1::GetSchemaRequest request;
  request.set_name(pubsub::Schema(project_id, schema_id).FullName());
  request.set_view(google::pubsub::v1::FULL);
  auto schema = client.GetSchema(request);
  if (!schema) throw std::move(schema).status();

  std::cout << "The schema exists and its metadata is: "
            << schema->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.

Auf GitHub ansehen Feedback

using Google.Cloud.PubSub.V1;

public class GetSchemaSample
{
    public Schema GetSchema(string projectId, string schemaId)
    {
        SchemaServiceClient schemaService = SchemaServiceClient.Create();
        SchemaName schemaName = SchemaName.FromProjectSchema(projectId, schemaId);
        GetSchemaRequest request = new GetSchemaRequest
        {
            Name = schemaName.ToString(),
            View = SchemaView.Full
        };

        return schemaService.GetSchema(request);
    }
}

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.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
)

func getSchemaRevision(w io.Writer, projectID, schemaID string) error {
	// projectID := "my-project-id"
	// schemaID := "my-schema[@my-schema-revision]"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	s, err := client.Schema(ctx, schemaID, pubsub.SchemaViewFull)
	if err != nil {
		return fmt.Errorf("client.Schema revision: %v", err)
	}
	fmt.Fprintf(w, "Got schema revision: %#v\n", s)
	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.

Auf GitHub ansehen Feedback

import com.google.api.gax.rpc.NotFoundException;
import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;

public class GetSchemaRevisionExample {

  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id[@your-schema-revision]";
    getSchemaRevisionExample(projectId, schemaId);
  }

  public static void getSchemaRevisionExample(String projectId, String schemaId)
      throws IOException {
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {

      Schema schema = schemaServiceClient.getSchema(schemaName);

      System.out.println("Got a schema:\n" + schema);

    } catch (NotFoundException e) {
      System.out.println(schemaName + "not found.");
    }
  }
}

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.

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment this variable before running the sample.
 */
// const schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';

// 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 getSchema(schemaNameOrId) {
  const schema = pubSubClient.schema(schemaNameOrId);
  const info = await schema.get();
  const fullName = await schema.getName();
  console.log(`Schema ${fullName} info: ${JSON.stringify(info, null, 4)}.`);
}

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.

Auf GitHub ansehen Feedback

use Google\Cloud\PubSub\PubSubClient;

/**
 * Get a schema.
 *
 * @param string $projectId
 * @param string $schemaId
 */
function get_schema($projectId, $schemaId)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);

    $schema = $pubsub->schema($schemaId);
    $schema->info();

    printf('Schema %s retrieved', $schema->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.

Auf GitHub ansehen Feedback

from google.api_core.exceptions import NotFound
from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"
# schema_revision_id = "your-schema-revision-id"

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(
    project_id, schema_id + "@" + schema_revision_id
)

try:
    result = schema_client.get_schema(request={"name": schema_path})
    print(f"Got a schema revision:\n{result}")
except NotFound:
    print(f"{schema_id} not found.")

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.

Auf GitHub ansehen Feedback

# schema_id = "your-schema-id"
require "google/cloud/pubsub"

pubsub = Google::Cloud::Pubsub.new

schema = pubsub.schema schema_id

puts "Schema #{schema.name} retrieved."

Schemas auflisten

Sie können die Schemas in einem Google Cloud-Projekt mithilfe der Google Cloud Console, der gcloud CLI, der Pub/Sub API oder der Cloud-Clientbibliotheken auflisten.

Console

• Rufen Sie in der Google Cloud Console die Seite Pub/Sub-Schemas auf.

  Zu den Schemas

  Die Liste der Schemas wird angezeigt.

gcloud

gcloud pubsub schemas list

Verwenden Sie den Befehl gcloud pubsub schemas list --view=FULL, um die neueste Definition für jedes Schema zu sehen.

REST

Um die Schemas in einem Projekt aufzulisten, senden Sie eine GET-Anfrage wie diese:

GET https://pubsub.googleapis.com/v1/projects/PROJECT_ID/schemas

Wenn der Vorgang erfolgreich ist, enthält der Antworttext ein JSON-Objekt, das die letzte Überarbeitung für alle Schemas im Projekt enthält.

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.

Auf GitHub ansehen Feedback

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::SchemaServiceClient client, std::string const& project_id) {
  auto const parent = google::cloud::Project(project_id).FullName();
  for (auto& s : client.ListSchemas(parent)) {
    if (!s) throw std::move(s).status();
    std::cout << "Schema: " << s->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.

Auf GitHub ansehen Feedback

using Google.Api.Gax.ResourceNames;
using Google.Cloud.PubSub.V1;
using System.Collections.Generic;

public class ListSchemasSample
{
    public IEnumerable<Schema> ListSchemas(string projectId)
    {
        SchemaServiceClient schemaService = SchemaServiceClient.Create();
        ProjectName projectName = ProjectName.FromProject(projectId);
        var schemas = schemaService.ListSchemas(projectName);
        return schemas;
    }
}

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.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
	"google.golang.org/api/iterator"
)

func listSchemas(w io.Writer, projectID string) ([]*pubsub.SchemaConfig, error) {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return nil, fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	var schemas []*pubsub.SchemaConfig

	schemaIter := client.Schemas(ctx, pubsub.SchemaViewFull)
	for {
		sc, err := schemaIter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, fmt.Errorf("schemaIter.Next: %v", err)
		}
		fmt.Fprintf(w, "Got schema: %#v\n", sc)
		schemas = append(schemas, sc)
	}

	fmt.Fprintf(w, "Got %d schemas", len(schemas))
	return schemas, 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.

Auf GitHub ansehen Feedback

import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.ProjectName;
import com.google.pubsub.v1.Schema;
import java.io.IOException;

public class ListSchemasExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";

    listSchemasExample(projectId);
  }

  public static void listSchemasExample(String projectId) throws IOException {
    ProjectName projectName = ProjectName.of(projectId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {
      for (Schema schema : schemaServiceClient.listSchemas(projectName).iterateAll()) {
        System.out.println(schema);
      }
      System.out.println("Listed schemas.");
    }
  }
}

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.

Auf GitHub ansehen Feedback

// 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 listSchemas() {
  for await (const s of pubSubClient.listSchemas()) {
    console.log(s.name);
  }
  console.log('Listed schemas.');
}

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.

Auf GitHub ansehen Feedback

use Google\Cloud\PubSub\PubSubClient;

/**
 * List schemas in the project.
 *
 * @param string $projectId
 */
function list_schemas($projectId)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);

    $schemas = $pubsub->schemas();
    foreach ($schemas as $schema) {
        printf('Schema name: %s' . PHP_EOL, $schema->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.

Auf GitHub ansehen Feedback

from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"

project_path = f"projects/{project_id}"
schema_client = SchemaServiceClient()

for schema in schema_client.list_schemas(request={"parent": project_path}):
    print(schema)

print("Listed schemas.")

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.

Auf GitHub ansehen Feedback

require "google/cloud/pubsub"

pubsub = Google::Cloud::Pubsub.new

schemas = pubsub.schemas

puts "Schemas in project:"
schemas.each do |schema|
  puts schema.name
end

Überarbeitungen eines Schemas auflisten

Sie können die Überarbeitungen eines Schemas in einem Google Cloud-Projekt über die Google Cloud Console, die gcloud CLI, die Pub/Sub API oder die Cloud-Clientbibliotheken auflisten.

Console

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

   Zu den Schemas

   Die Liste der Schemas wird angezeigt.

2. Klicken Sie auf den Namen des Schemas, das Sie aufrufen möchten.

   Die Seite Schemadetails für das Schema wird geöffnet.

   Im Abschnitt Überarbeitungen finden Sie die Liste der verfügbaren Überarbeitungen für das Schema.

gcloud

So rufen Sie die neueste Überarbeitung für ein Schema auf:

gcloud pubsub schemas list-revisions SCHEMA_ID

Verwenden Sie den Befehl gcloud pubsub schemas list-revisions <var>SCHEMA_ID</var> --view=FULL, um die Definitionen für die Schemaüberarbeitungen aufzurufen.

REST

Senden Sie eine GET-Anfrage wie die folgende, um die Schemaüberarbeitungen für ein Schema aufzulisten:

GET https://pubsub.googleapis.com/v1/projects/SCHEMA_NAME:listRevisions

Wenn der Vorgang erfolgreich ist, enthält der Antworttext ein JSON-Objekt, das alle Schemaüberarbeitungen für das Schema enthält.

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.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
	"google.golang.org/api/iterator"
)

func listSchemaRevisions(w io.Writer, projectID, schemaID string) ([]*pubsub.SchemaConfig, error) {
	// projectID := "my-project-id"
	// schemaID := "my-schema-id"
	ctx := context.Background()
	client, err := pubsub.NewSchemaClient(ctx, projectID)
	if err != nil {
		return nil, fmt.Errorf("pubsub.NewSchemaClient: %v", err)
	}
	defer client.Close()

	var schemas []*pubsub.SchemaConfig

	schemaIter := client.ListSchemaRevisions(ctx, schemaID, pubsub.SchemaViewFull)
	for {
		sc, err := schemaIter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, fmt.Errorf("schemaIter.Next: %v", err)
		}
		fmt.Fprintf(w, "Got schema revision: %#v\n", sc)
		schemas = append(schemas, sc)
	}

	fmt.Fprintf(w, "Got %d schema revisions", len(schemas))
	return schemas, 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.

Auf GitHub ansehen Feedback

import com.google.cloud.pubsub.v1.SchemaServiceClient;
import com.google.pubsub.v1.Schema;
import com.google.pubsub.v1.SchemaName;
import java.io.IOException;

public class ListSchemaRevisionsExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String schemaId = "your-schema-id";

    listSchemaRevisionsExample(projectId, schemaId);
  }

  public static void listSchemaRevisionsExample(String projectId, String schemaId)
      throws IOException {
    SchemaName schemaName = SchemaName.of(projectId, schemaId);

    try (SchemaServiceClient schemaServiceClient = SchemaServiceClient.create()) {
      for (Schema schema : schemaServiceClient.listSchemaRevisions(schemaName).iterateAll()) {
        System.out.println(schema);
      }
      System.out.println("Listed schema revisions.");
    }
  }
}

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.

Auf GitHub ansehen Feedback

from google.cloud.pubsub import SchemaServiceClient

# TODO(developer): Replace these variables before running the sample.
# project_id = "your-project-id"
# schema_id = "your-schema-id"

schema_client = SchemaServiceClient()
schema_path = schema_client.schema_path(project_id, schema_id)

for schema in schema_client.list_schema_revisions(request={"name": schema_path}):
    print(schema)

print("Listed schema revisions.")

Schemadefinition validieren

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

Folgen Sie den Schritten unter Schema erstellen oder Schemaüberarbeitung vornehmen.

Die Validierungsprüfung prüft nicht die Kompatibilität der neuen Überarbeitung mit den älteren Überarbeitungen.

Nachricht für ein Schema validieren

Sie können prüfen, ob Nachrichten einem bestimmten Schema entsprechen, bevor oder nachdem Sie eine Schemaressource erstellt haben. Mit diesem Schritt wird sichergestellt, dass die Nachrichten, die Sie über ein mit einem Schema verknüpftes Thema senden möchten, mit dem Schema übereinstimmen, bevor das Schema angewendet wird.

Sie können Nachrichten anhand der Schemas in der Google Cloud Console, der gcloud CLI, der Pub/Sub API oder den Cloud-Clientbibliotheken validieren.

Console

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

   Zu den Schemas

   Die Liste der Schemas wird angezeigt.

2. Klicken Sie auf die Schema-ID eines vorhandenen Schemas.

   Die Seite Schemadetails für das Schema wird geöffnet.

3. Klicken Sie im Abschnitt Überarbeitungen auf die Überarbeitung, für die Sie eine Nachricht validieren möchten.

4. Klicken Sie im Abschnitt Details auf Testnachricht.

5. Wählen Sie im Fenster Testnachricht einen Typ für die Nachrichtencodierung aus.

6. Geben Sie im Text von Nachricht eine Testnachricht ein.

7. Klicken Sie auf Test.

Kontingente und Limits für Schemas

Für Schemas gelten die folgenden Limits:

• Das Feld für die Schemadefinition darf maximal 50 KB groß sein.

• Ein Projekt kann maximal 10.000 Schemas enthalten.

• Ein einzelnes Schema darf nicht mehr als 20 Überarbeitungen haben.

  Informationen zu Schemas und Limits in Bezug auf Pub/Sub finden Sie unter Pub/Sub-Kontingente und -Limits.

Nächste Schritte

• Wählen Sie den Abotyp für Ihr Thema aus oder erstellen Sie ein BigQuery-Abo, um Nachrichten direkt in BigQuery zu schreiben.

• Erstellen Sie ein Abo für Ihr Thema.

• Nachrichten beim Abonnieren von Themen verarbeiten, die mit einem Schema konfiguriert sind