Schemaversion für ein Thema löschen

In diesem Dokument erfahren Sie, wie Sie Schemaversionen für Pub/Sub-Themen löschen. Beim Löschen eines Schemas werden auch alle mit dem Schema verknüpften Versionen gelöscht.

Achtung: Der Löschvorgang ist endgültig. Eine gelöschte Schemaversion kann nicht wiederhergestellt werden. Nachrichten, die zum Zeitpunkt der Veröffentlichung anhand der gelöschten Schemaversion validiert wurden, können nicht in BigQuery geschrieben werden, wenn ein BigQuery-Abo mit aktivierter Option „Schema des Themas verwenden“ verwendet wird. Anstatt eine Version zu löschen, sollten Sie ein Rollback für ein Schema in Betracht ziehen.

Hinweis

• Informationen zur Funktionsweise von Pub/Sub-Schemas
• Schema erstellen.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub-Bearbeiter (roles/pubsub.editor) für Ihr Projekt zu erteilen, um die Berechtigungen zu erhalten, die Sie zum Löschen und Verwalten von Schemaversionen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Löschen und Verwalten von Schemaversionen erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen , um die notwendigen Berechtigungen anzuzeigen, die erforderlich sind:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Schemaversionen zu löschen und zu verwalten:

• Schema erstellen: pubsub.schemas.create
• Schema an Thema anhängen: pubsub.schemas.attach
• Schemaversion festschreiben: pubsub.schemas.commit
• Schema oder Schemaversion löschen: pubsub.schemas.delete
• Schema oder Schemaversionen abrufen: pubsub.schemas.get
• Schemas auflisten: pubsub.schemas.list
• Schemaversionen auflisten: pubsub.schemas.listRevisions
• Rollback für ein Schema ausführen: pubsub.schemas.rollback
• Nachricht validieren: pubsub.schemas.validate
• IAM-Richtlinie für ein Schema abrufen: 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 Rollen und Berechtigungen Prinzipalen wie Nutzern, Gruppen, Domains oder Dienstkonten gewähren. Sie können ein Schema in einem Projekt erstellen und es 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.

Schemaversion löschen

Wichtig: Wenn alle Versionen im Versionsbereich der Schemaeinstellungen für ein Thema gelöscht werden, schlagen alle Versuche fehl, Nachrichten in diesem Thema zu veröffentlichen.

Im Folgenden finden Sie einige wichtige Richtlinien zum Löschen einer Schemaversion:

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

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

• Beim Löschen eines Schemas werden auch alle mit dem Schema verknüpften Versionen gelöscht.

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

• Wenn Sie eine Schemaversion löschen und sie als erste Version für ein Thema angegeben ist, wird stattdessen die nächste Version zur Validierung verwendet.

  Wenn die gelöschte Schemaversion als letzte Version für ein Thema angegeben ist, wird stattdessen die vorherige Schemaversion zur Validierung verwendet.

  Wenn die gelöschte Schemaversion in den angegebenen Versionsbereich für ein Thema zur Validierung fällt, wird die Version übersprungen.

Sie können eine Schemaversion über die Google Cloud Console, die gcloud CLI, die Pub/Sub API, oder die Cloud-Clientbibliotheken löschen.

Console

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

   Zu „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 Version aus, die Sie löschen möchten. Sie können auch mehrere Versionen auswählen.

4. Klicken Sie auf Version löschen.

5. Bestätigen Sie den Löschvorgang.

gcloud

gcloud pubsub schemas delete-revision SCHEMA_NAME@REVISION_ID

Wobei:

• REVISION_ID ist die Version, auf die Sie ein Rollback ausführen möchten.

REST

Senden Sie eine DELETE-Anfrage wie diese, um eine Schemaversion 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.

C++

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

namespace pubsub = ::google::cloud::pubsub;
[](pubsub::SchemaServiceClient client, std::string const& project_id,
   std::string const& schema_id, std::string const& revision_id) {
  std::string const schema_id_with_revision = schema_id + "@" + revision_id;

  google::pubsub::v1::DeleteSchemaRevisionRequest request;
  request.set_name(
      pubsub::Schema(project_id, schema_id_with_revision).FullName());
  auto schema = client.DeleteSchemaRevision(request);
  if (!schema) throw std::move(schema).status();

  std::cout << "Deleted schema. Its metadata is:"
            << "\n"
            << schema->DebugString() << "\n";
}

Go

Im folgenden Beispiel wird die Hauptversion der Go Pub/Sub-Clientbibliothek (Version 2) verwendet. Wenn Sie noch die Version 1 verwenden, lesen Sie den Migrationsleitfaden zu Version 2. Eine Liste der Codebeispiele für Version 1 finden Sie unter Veraltete Codebeispiele.

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

import (
	"context"
	"fmt"
	"io"

	pubsub "cloud.google.com/go/pubsub/v2/apiv1"
	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
)

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)
	if err != nil {
		return fmt.Errorf("pubsub.NewSchemaClient: %w", err)
	}
	defer client.Close()

	req := &pubsubpb.DeleteSchemaRevisionRequest{
		Name: fmt.Sprintf("projects/%s/schemas/%s@%s", projectID, schemaID, revisionID),
	}
	if _, err := client.DeleteSchemaRevision(ctx, req); err != nil {
		return fmt.Errorf("client.DeleteSchemaRevision: %w", 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.

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.

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

Node.js

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

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

  // Use the gapic client to delete the schema revision.
  const schemaClient = await pubSubClient.getSchemaClient();
  await schemaClient.deleteSchemaRevision({
    name: `${name}@${revisionId}`,
  });

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

Node.js

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

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const 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 deleteSchemaRevision(
  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 delete the schema revision.
  const schemaClient = await pubSubClient.getSchemaClient();
  await schemaClient.deleteSchemaRevision({
    name: `${name}@${revisionId}`,
  });

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

Nächste Schritte

• Schema löschen
• Schemas auflisten
• Versionen eines Schemas auflisten
• Thema mit einem Schema abonnieren