Rollback einer Schemaversion durchführen

In diesem Dokument erfahren Sie, wie Sie ein Rollback eines Schemas für ein Pub/Sub .

Mit dem Rollback-Vorgang können Sie eine weitere Schemaversion mit genau dieser Schemadefinition der angegebenen vorherigen Version.

Hinweise

• Funktionsweise von Pub/Sub-Schemas
• Schema erstellen

Erforderliche Rollen und Berechtigungen

Um die Berechtigungen zu erhalten, die Sie für das Rollback von Schemas und deren Verwaltung benötigen, bitten Sie Ihren Administrator, Ihnen IAM-Rolle Pub/Sub-Bearbeiter (roles/pubsub.editor) für Ihr Projekt Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.

Diese vordefinierte Rolle enthält Berechtigungen, die für das Rollback von Schemas und deren Verwaltung erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um ein Rollback von Schemas durchzuführen und diese zu verwalten:

• Schema erstellen: pubsub.schemas.create
• Schema an Thema anhängen: pubsub.schemas.attach
• Führen Sie einen Commit für eine Schemaversion durch: pubsub.schemas.commit
• So löschen Sie ein Schema oder eine Schemaversion: pubsub.schemas.delete
• Rufen Sie ein Schema oder eine Schemaversion ab: pubsub.schemas.get
• Schemas auflisten: pubsub.schemas.list
• Schemaversionen auflisten: pubsub.schemas.listRevisions
• Rollback eines Schemas durchführen: pubsub.schemas.rollback
• Validieren Sie eine Nachricht: 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. Sie können ein Schema in einem Projekt erstellen und an ein Thema in einem anderen Projekt anhängen. Achten Sie darauf, dass Sie die erforderlichen Berechtigungen für für jedes Projekt.

Rollback einer Schemaversion durchführen

Sie können für ein Schema mit der Methode Google Cloud Console, gcloud CLI, Pub/Sub API Cloud-Clientbibliotheken. Gehen Sie so vor:

Console

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

   Zu „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 des Schemas wird geöffnet.

4. Wählen Sie die Version aus, auf die Sie das Rollback des Schemas durchführen möchten.

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

   Eine neue Version wird mit dem Schema erstellt, das im Rollback-Vorgang.

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

7. Klicken Sie auf Unterschied ansehen.

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

   Sie können die soeben erstellte Schemaversion als letzte Version verwenden zur Validierung eines Themas. Aktualisieren Sie dazu das Feld Letzte zulässige Überarbeitung.

gcloud

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

Wobei:

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

REST

Um ein Schema rückgängig zu machen, senden Sie eine POST-Anfrage wie die folgende:

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 Version, auf die ein Rollback durchgeführt werden soll.

Der Antworttext sollte eine JSON-Darstellung einer Schemaressource enthalten.

C++

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

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

  std::cout << "Rolledback schema. Created a new schema and its metadata is:"
            << "\n"
            << schema->DebugString() << "\n";
}

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 zu Pub/Sub Go API.

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: %w", err)
	}
	defer client.Close()

	s, err := client.RollbackSchema(ctx, schemaID, revisionID)
	if err != nil {
		return fmt.Errorf("RollbackSchema: %w", 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 zu Pub/Sub Java API.

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 zu Pub/Sub Python API.

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

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 zu Pub/Sub Node.js API.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';
// const revisionId = 'YOUR_REVISION_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 rollbackSchema(schemaNameOrId, revisionId) {
  // Get the fully qualified schema name.
  const schema = pubSubClient.schema(schemaNameOrId);
  const name = await schema.getName();

  // Use the gapic client to roll back the schema revision.
  const schemaClient = await pubSubClient.getSchemaClient();
  await schemaClient.rollbackSchema({
    name,
    revisionId,
  });

  console.log(`Schema ${name} revision ${revisionId} rolled back.`);
}

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 zu Pub/Sub Node.js API.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const schemaNameOrId = 'YOUR_SCHEMA_NAME_OR_ID';
// const revisionId = 'YOUR_REVISION_ID';

// Imports the Google Cloud client library
import {PubSub} from '@google-cloud/pubsub';

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

async function rollbackSchema(schemaNameOrId: string, revisionId: string) {
  // Get the fully qualified schema name.
  const schema = pubSubClient.schema(schemaNameOrId);
  const name = await schema.getName();

  // Use the gapic client to roll back the schema revision.
  const schemaClient = await pubSubClient.getSchemaClient();
  await schemaClient.rollbackSchema({
    name,
    revisionId,
  });

  console.log(`Schema ${name} revision ${revisionId} rolled back.`);
}

Nächste Schritte

• Schemaversion löschen
• Schema löschen
• Schemas auflisten
• Schemaversionen auflisten
• Thema mit einem Schema abonnieren