Cloud Storage-Abos erstellen

In diesem Dokument wird beschrieben, wie Sie ein Cloud Storage-Abo erstellen. Sie können ein Cloud Storage-Abo mit der Google Cloud Console, der Google Cloud CLI, der Clientbibliothek oder der Pub/Sub API erstellen.

Hinweise

Bevor Sie dieses Dokument lesen, sollten Sie mit Folgendem vertraut sein:

• Funktionsweise eines Cloud Storage-Abos
• Wie Cloud Storage funktioniert und wie Sie Cloud Storage-Buckets erstellen und verwalten.
• Informationen zum Konfigurieren eines Themas für unzustellbare Nachrichten, um Nachrichtenfehler zu behandeln.

Erforderliche Rollen und Berechtigungen

Im Folgenden finden Sie eine Liste von Richtlinien zu Rollen und Berechtigungen:

• Wenn Sie ein Abo erstellen möchten, müssen Sie die Zugriffssteuerung auf Projektebene konfigurieren.

• Sie benötigen auch Berechtigungen auf Ressourcenebene, wenn sich Ihre Abos und Themen in verschiedenen Projekten befinden, wie weiter unten in diesem Abschnitt erläutert.

• Damit ein Cloud Storage-Abo erstellt werden kann, muss entweder der Pub/Sub-Dienst-Agent oder ein benutzerdefiniertes Dienstkonto die Berechtigung zum Schreiben in den jeweiligen Cloud Storage-Bucket und zum Lesen der Bucket-Metadaten haben. Weitere Informationen zum Gewähren dieser Berechtigungen finden Sie im nächsten Abschnitt dieses Dokuments.

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub Editor (roles/pubsub.editor) für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen von Cloud Storage-Abos 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 Erstellen von Cloud Storage-Abos erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

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

Wenn ein Nutzer in einem Projekt ein Cloud Storage-Abo in einem anderen Projekt erstellen soll, müssen Sie ihm in beiden Projekten die Rolle „Pub/Sub-Bearbeiter“ (roles/pubsub.editor) zuweisen. Dadurch erhalten Sie die erforderlichen Berechtigungen, um das neue Google Cloud -Abo zu erstellen und an das ursprüngliche Thema anzuhängen. Mit der Rolle „Pub/Sub-Bearbeiter“ (roles/pubsub.editor) für das Thema können Sie dem Thema auch Google Cloud Abos in einem anderen Projekt zuweisen.

Dienstkonten Rollen zuweisen

Einige Dienste haben Google Cloud verwaltete Dienstkonten Google Cloud, mit denen die Dienste auf Ihre Ressourcen zugreifen können. Diese Dienstkonten werden als Dienst-Agents bezeichnet. Pub/Sub erstellt und verwaltet für jedes Projekt einen Dienst-Agenten im Format service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Sie können dem Pub/Sub-Dienstagenten oder einem benutzerdefinierten Dienstkonto die Berechtigung zum Schreiben in den Cloud Storage-Bucket erteilen.

Wenn Sie dem Pub/Sub-Dienst-Agent eine Berechtigung gewähren, kann jeder Nutzer, der berechtigt ist, ein Abo in Ihrem Projekt zu erstellen, in den Cloud Storage-Bucket schreiben. Wenn Sie detailliertere Berechtigungen zum Schreiben in den Cloud Storage-Bucket gewähren möchten, konfigurieren Sie stattdessen ein benutzerdefiniertes Dienstkonto.

Weitere Informationen zu Cloud Storage IAM finden Sie unter Identity and Access Management für Cloud Storage.

Dem Pub/Sub-Dienst-Agent Cloud Storage-Rollen zuweisen

Wenn Sie ein Cloud Storage-Abo mit dem Pub/Sub-Dienst-Agent erstellen möchten, muss er zum Schreiben in den entsprechenden Cloud Storage-Bucket und zum Lesen der Bucket-Metadaten berechtigt sein.

Weisen Sie dem Pub/Sub-Dienst-Agent die Rollen „Storage-Objekt-Ersteller“ (roles/storage.objectCreator) und „Leser alter Storage-Objekte“ (roles/storage.legacyBucketReader) zu. Sie können die Berechtigung für einen einzelnen Bucket oder für das gesamte Projekt gewähren.

Cloud Storage-Rollen einem benutzerdefinierten Dienstkonto zuweisen

Wenn Sie ein benutzerdefiniertes Dienstkonto zum Schreiben in einen Cloud Storage-Bucket verwenden möchten, müssen Sie die folgenden Berechtigungen festlegen:

• Das benutzerdefinierte Dienstkonto muss die Berechtigung zum Schreiben in den entsprechenden Cloud Storage-Bucket und zum Lesen der Bucket-Metadaten haben.
• Der Pub/Sub-Dienst-Agent muss die Berechtigung iam.serviceAccounts.getAccessToken für das benutzerdefinierte Dienstkonto haben.
• Der Nutzer, der das Abo erstellt, muss die Berechtigung iam.serviceAccounts.actAs für das benutzerdefinierte Dienstkonto haben.

So erstellen Sie das Dienstkonto und gewähren Berechtigungen:

1. Erstellen Sie das benutzerdefinierte Dienstkonto. Das Dienstkonto muss sich im selben Projekt wie das Abo befinden.

2. Weisen Sie dem benutzerdefinierten Dienstkonto die Rollen „Storage Object Creator“ (roles/storage.objectCreator) und „Storage Legacy Bucket Reader“ (roles/storage.legacyBucketReader) zu.

   Sie können die Berechtigung für das Dienstkonto für eine einzelne Tabelle im Projekt oder für alle Tabellen im Projekt gewähren. Weitere Informationen finden Sie im entsprechenden Abschnitt unter Dem Pub/Sub-Dienst-Agent Rollen zuweisen Google Cloud . Ersetzen Sie in der Anleitung die E-Mail-Adresse des Pub/Sub-Dienst-Agents durch die E-Mail-Adresse des benutzerdefinierten Dienstkontos.

3. Weisen Sie dem Pub/Sub-Dienstmitarbeiter die Berechtigung iam.serviceAccounts.getAccessToken für das benutzerdefinierte Dienstkonto oder für alle Dienstkonten im Projekt zu. Sie können diese Berechtigung erteilen, indem Sie dem Pub/Sub-Dienst-Agent die Rolle roles/iam.serviceAccountTokenCreator zuweisen.

   Wählen Sie je nach Ihren Anforderungen die geeignete Methode aus.

Wenn Sie das benutzerdefinierte Dienstkonto erstellt haben, sollten Sie bereits die erforderliche iam.serviceAccounts.actAs-Berechtigung haben. Wenn Sie einer anderen Person die Berechtigung für das Dienstkonto erteilen möchten, gehen Sie so vor:

1. Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf.

   Zur Seite „Dienstkonten“

2. Geben Sie den Namen des benutzerdefinierten Dienstkontos in das Feld Filter ein.

3. Wählen Sie das Dienstkonto aus der Liste aus.

4. Klicken Sie auf Hauptkonten mit Zugriff.

5. Klicken Sie auf Zugriff erlauben.

6. Geben Sie im Bereich Hauptkonten hinzufügen den Namen des Kontos ein, dem Sie Zugriff gewähren möchten.

7. Geben Sie im Drop-down-Menü Rolle auswählen die Zahl Service Account ein und wählen Sie die Rolle Dienstkontonutzer aus.

8. Klicken Sie auf Speichern.

Eigenschaften von Cloud Storage-Abos

Wenn Sie ein Cloud Storage-Abo konfigurieren, müssen Sie die Eigenschaften angeben, die für alle Abotypen gemeinsam sind, sowie einige zusätzliche Cloud Storage-spezifische Aboeigenschaften.

Allgemeine Aboeigenschaften

Weitere Informationen zu den allgemeinen Aboeigenschaften, die Sie für alle Abos festlegen können

Bucket-Name

Ein Cloud Storage-Bucket muss bereits vorhanden sein, bevor Sie ein Cloud Storage-Abo erstellen.

Die Nachrichten werden als Batches gesendet und im Cloud Storage-Bucket gespeichert. Ein einzelner Batch oder eine einzelne Datei wird als Objekt im Bucket gespeichert.

Für den Cloud Storage-Bucket muss Anfragender bezahlt deaktiviert sein.

Informationen zum Erstellen eines Cloud Storage-Bucket finden Sie unter Buckets erstellen.

Präfix, Suffix und Datum/Uhrzeit für Dateinamen

Die vom Cloud Storage-Abo generierten Cloud Storage-Ausgabedateien werden als Objekte im Cloud Storage-Bucket gespeichert. Der Name des im Cloud Storage-Bucket gespeicherten Objekts hat das folgende Format: <file-prefix><UTC-date-time>_<uuid><file-suffix>.

Die folgende Liste enthält Details zum Dateiformat und zu den Feldern, die Sie anpassen können:

• <file-prefix> ist das benutzerdefinierte Dateinamenspräfix. Dieses Feld ist optional.

• <UTC-date-time> ist ein anpassbarer, automatisch generierter String, der auf dem Zeitpunkt basiert, zu dem das Objekt erstellt wurde.

• <uuid> ist ein automatisch generierter Zufallsstring für das Objekt.

• <file-suffix> ist das benutzerdefinierte Dateinamensuffix. Dieses Feld ist optional. Das Dateiendung darf nicht auf „/“ enden.

• Sie können das Präfix und Suffix des Dateinamens ändern:

  • Wenn der Wert des Dateinamenspräfixes beispielsweise prod_ und der Wert des Dateinamenssuffixes _archive ist, lautet ein Beispielobjektname prod_2023-09-25T04:10:00+00:00_uN1QuE_archive.

  • Wenn Sie kein Dateinamenpräfix und ‑suffix angeben, hat der im Cloud Storage-Bucket gespeicherte Objektname das Format: <UTC-date-time>_<uuid>.

  • Die Anforderungen für die Benennung von Cloud Storage-Objekten gelten auch für das Präfix und Suffix des Dateinamens. Weitere Informationen finden Sie unter Cloud Storage-Objekte.

• Sie können festlegen, wie Datum und Uhrzeit im Dateinamen angezeigt werden:

  • Erforderliche Datum/Uhrzeit-Abgleiche, die nur einmal verwendet werden können: Jahr (YYYY oder YY), Monat (MM), Tag (DD), Stunde (hh), Minute (mm), Sekunde (ss). YY-YYYY oder MMM sind beispielsweise ungültig.

  • Optionale Übereinstimmungen, die nur einmal verwendet werden können: Datums-/Uhrzeit-Trennzeichen (T) und Zeitzonendifferenz (Z oder +00:00).

  • Optionale Elemente, die Sie mehrmals verwenden können: Bindestrich (-), Unterstrich (_), Doppelpunkt (:) und Schrägstrich (/).

  • Wenn der Wert des Dateinamens im Datums-/Uhrzeitformat beispielsweise YYYY-MM-DD/hh_mm_ssZ ist, ist ein Beispielobjektname prod_2023-09-25/04_10_00Z_uNiQuE_archive.

  • Wenn das Datums-/Uhrzeitformat des Dateinamens auf ein Zeichen endet, das kein Übereinstimmungszeichen ist, wird dieses Zeichen durch das Trennzeichen zwischen <UTC-date-time> und <uuid> ersetzt. Wenn der Wert des Dateinamens im Datums-/Uhrzeitformat beispielsweise YYYY-MM-DDThh_mm_ss- ist, ist ein Beispielobjektname prod_2023-09-25T04_10_00-uNiQuE_archive.

Batchverarbeitung von Dateien

Mit Cloud Storage-Abos können Sie festlegen, wann eine neue Ausgabedatei erstellt werden soll, die als Objekt im Cloud Storage-Bucket gespeichert wird. Pub/Sub schreibt eine Ausgabedatei, wenn eine der angegebenen Batch-Bedingungen erfüllt ist. Die folgenden Bedingungen gelten für die Batchverarbeitung in Cloud Storage:

• Maximale Storage-Batchdauer Diese Einstellung ist erforderlich. Das Cloud Storage-Abo schreibt eine neue Ausgabedatei, wenn der angegebene Wert für die maximale Dauer überschritten wird. Wenn Sie keinen Wert angeben, wird der Standardwert „5 Minuten“ verwendet. Folgende Werte sind für die maximale Dauer zulässig:

  • Mindestwert = 1 Minute
  • Standardwert: 5 Minuten
  • Maximalwert: 10 Minuten

• Maximale Storage-Batch-Bytes Diese Einstellung ist optional. Das Cloud Storage-Abo schreibt eine neue Ausgabedatei, wenn der angegebene Wert für die maximale Anzahl von Byte überschritten wird. Folgende Werte sind für „max. Bytes“ zulässig:

  • Mindestwert = 1 KB
  • Maximalwert = 10 GiB

• Storage-Batch-Nachrichten Diese Einstellung ist optional. Das Cloud Storage-Abo schreibt eine neue Ausgabedatei, wenn die angegebene maximale Anzahl von Nachrichten überschritten wird. Folgende Werte sind für „max. Nachrichten“ zulässig:

  • Mindestwert = 1.000

Sie können beispielsweise „max_duration“ auf 6 Minuten und „max_bytes“ auf 2 GB konfigurieren. Wenn die Ausgabedatei in der 4. Minute eine Dateigröße von 2 GB erreicht, schließt Pub/Sub die vorherige Datei ab und beginnt, in eine neue Datei zu schreiben.

Ein Cloud Storage-Abo kann gleichzeitig in mehrere Dateien in einem Cloud Storage-Bucket schreiben. Wenn Sie Ihr Abo so konfiguriert haben, dass alle sechs Minuten eine neue Datei erstellt wird, werden möglicherweise alle sechs Minuten mehrere Cloud Storage-Dateien erstellt.

In einigen Fällen beginnt Pub/Sub möglicherweise früher mit dem Schreiben in eine neue Datei, als in den Bedingungen für die Dateigruppierung konfiguriert. Eine Datei kann auch den Wert „Max. Bytes“ überschreiten, wenn das Abo Nachrichten empfängt, die größer als der Wert „Max. Bytes“ sind.

Dateiformat

Wenn Sie ein Cloud Storage-Abo erstellen, können Sie das Format der Ausgabedateien, die in einem Cloud Storage-Bucket gespeichert werden sollen, als Text oder Avro angeben.

• Text: Die Nachrichten werden als Nur-Text gespeichert. Ein Zeilenumbruch trennt eine Nachricht von der vorherigen Nachricht in der Datei. Es werden nur Nachrichtennutzlasten gespeichert, keine Attribute oder anderen Metadaten.

• Avro: Die Nachrichten werden im binären Apache Avro-Format gespeichert. Wenn Sie Avro auswählen, können Sie die folgenden zusätzlichen Properties aktivieren:

  • Metadaten schreiben: Mit dieser Option können Sie die Nachrichtenmetadaten zusammen mit der Nachricht speichern. Metadaten wie subscription_name-, message_id-, publish_time- und attributes-Felder werden in die obersten Felder im Ausgabe-Avro-Objekt geschrieben. Alle anderen Nachrichteneigenschaften außer Daten (z. B. ein vorhandener „ordering_key“) werden als Einträge in die attributes-Map eingefügt.

    Wenn Metadaten schreiben deaktiviert ist, wird nur die Nachrichtenn-Nutzlast in das Ausgabe-Avro-Objekt geschrieben. Hier ist das Avro-Schema für die Ausgabenachrichten, bei dem Metadaten schreiben deaktiviert ist:

    {
      "type": "record",
      "namespace": "com.google.pubsub",
      "name": "PubsubMessage",
      "fields": [
        { "name": "data", "type": "bytes" }
      ]
    }
    

    Hier ist das Avro-Schema für die Ausgabenachrichten mit aktivierter Option Metadaten schreiben:

    {
      "type": "record",
      "namespace": "com.google.pubsub",
      "name": "PubsubMessageWithMetadata",
      "fields": [
        { "name": "subscription_name", "type": "string" },
        { "name": "message_id", "type": "string"  },
        { "name": "publish_time", "type": {
            "type": "long",
            "logicalType": "timestamp-micros"
          }
        },
        { "name": "attributes", "type": { "type": "map", "values": "string" } },
        { "name": "data", "type": "bytes" }
      ]
    }
    

  • Schema des Themas verwenden: Mit dieser Option kann Pub/Sub beim Schreiben von Avro-Dateien das Schema des Pub/Sub-Themas verwenden, an das das Abo angehängt ist.

    Beachten Sie bei Verwendung dieser Option die folgenden zusätzlichen Anforderungen:

    • Das Themenschema muss im Apache Avro-Format vorliegen.

    • Wenn sowohl Topic-Schema verwenden als auch Metadaten schreiben aktiviert sind, muss das Topic-Schema ein Record-Objekt als Stamm haben. Pub/Sub erweitert die Liste der Felder des Datensatzes um die Metadatenfelder. Daher darf der Datensatz keine Felder mit demselben Namen wie die Metadatenfelder (subscription_name, message_id, publish_time oder attributes) enthalten.

Dienstkonto

Sie haben folgende Möglichkeiten, Nachrichten in eine BigQuery-Tabelle oder einen Cloud Storage-Bucket zu schreiben:

• Konfigurieren Sie ein benutzerdefiniertes Dienstkonto so, dass nur Nutzer, die die Berechtigung iam.serviceAccounts.actAs für das Dienstkonto haben, ein Abo erstellen können, das in die Tabelle oder den Bucket schreibt. Ein Beispiel für eine Rolle mit der Berechtigung iam.serviceAccounts.actAs ist die Rolle Dienstkontonutzer (roles/iam.serviceAccountUser).

• Verwenden Sie den standardmäßigen Pub/Sub-Dienst-Agent, mit dem jeder Nutzer, der Abos im Projekt erstellen kann, ein Abo erstellen kann, das in die Tabelle oder den Bucket schreibt. Der Pub/Sub-Dienst-Agent ist die Standardeinstellung, wenn Sie kein benutzerdefiniertes Dienstkonto angeben.

Cloud Storage-Abo erstellen

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::SubscriptionAdminClient client,
   std::string const& project_id, std::string const& topic_id,
   std::string const& subscription_id, std::string const& bucket) {
  google::pubsub::v1::Subscription request;
  request.set_name(
      pubsub::Subscription(project_id, subscription_id).FullName());
  request.set_topic(pubsub::Topic(project_id, topic_id).FullName());
  request.mutable_cloud_storage_config()->set_bucket(bucket);
  auto sub = client.CreateSubscription(request);
  if (!sub) {
    if (sub.status().code() == google::cloud::StatusCode::kAlreadyExists) {
      std::cout << "The subscription already exists\n";
      return;
    }
    throw std::move(sub).status();
  }

  std::cout << "The subscription was successfully created: "
            << sub->DebugString() << "\n";
}

using Google.Cloud.PubSub.V1;
using Google.Protobuf.WellKnownTypes;
using System;

public class CreateCloudStorageSubscriptionSample
{
    public Subscription CreateCloudStorageSubscription(string projectId, string topicId, string subscriptionId,
        string bucket, string filenamePrefix, string filenameSuffix, TimeSpan maxDuration)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
        SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);

        var subscriptionRequest = new Subscription
        {
            SubscriptionName = subscriptionName,
            TopicAsTopicName = topicName,
            CloudStorageConfig = new CloudStorageConfig
            {
                Bucket = bucket,
                FilenamePrefix = filenamePrefix,
                FilenameSuffix = filenameSuffix,
                MaxDuration = Duration.FromTimeSpan(maxDuration)
            }
        };
        var subscription = subscriber.CreateSubscription(subscriptionRequest);
        return subscription;
    }
}

import (
	"context"
	"fmt"
	"io"
	"time"

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

// createCloudStorageSubscription creates a Pub/Sub subscription that exports messages to Cloud Storage.
func createCloudStorageSubscription(w io.Writer, projectID, subID string, topic *pubsub.Topic, bucket string) error {
	// projectID := "my-project-id"
	// subID := "my-sub"
	// topic of type https://godoc.org/cloud.google.com/go/pubsub#Topic
	// note bucket should not have the gs:// prefix
	// bucket := "my-bucket"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	sub, err := client.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
		Topic: topic,
		CloudStorageConfig: pubsub.CloudStorageConfig{
			Bucket:         bucket,
			FilenamePrefix: "log_events_",
			FilenameSuffix: ".avro",
			OutputFormat:   &pubsub.CloudStorageOutputFormatAvroConfig{WriteMetadata: true},
			MaxDuration:    1 * time.Minute,
			MaxBytes:       1e8,
		},
	})
	if err != nil {
		return fmt.Errorf("client.CreateSubscription: %w", err)
	}
	fmt.Fprintf(w, "Created Cloud Storage subscription: %v\n", sub)

	return nil
}

import com.google.cloud.pubsub.v1.SubscriptionAdminClient;
import com.google.protobuf.Duration;
import com.google.pubsub.v1.CloudStorageConfig;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.ProjectTopicName;
import com.google.pubsub.v1.Subscription;
import java.io.IOException;

public class CreateCloudStorageSubscriptionExample {
  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";
    String subscriptionId = "your-subscription-id";
    String bucket = "your-bucket";
    String filenamePrefix = "log_events_";
    String filenameSuffix = ".text";
    Duration maxDuration = Duration.newBuilder().setSeconds(300).build();

    createCloudStorageSubscription(
        projectId, topicId, subscriptionId, bucket, filenamePrefix, filenameSuffix, maxDuration);
  }

  public static void createCloudStorageSubscription(
      String projectId,
      String topicId,
      String subscriptionId,
      String bucket,
      String filenamePrefix,
      String filenameSuffix,
      Duration maxDuration)
      throws IOException {
    try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {

      ProjectTopicName topicName = ProjectTopicName.of(projectId, topicId);
      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);

      CloudStorageConfig cloudStorageConfig =
          CloudStorageConfig.newBuilder()
              .setBucket(bucket)
              .setFilenamePrefix(filenamePrefix)
              .setFilenameSuffix(filenameSuffix)
              .setMaxDuration(maxDuration)
              .build();

      Subscription subscription =
          subscriptionAdminClient.createSubscription(
              Subscription.newBuilder()
                  .setName(subscriptionName.toString())
                  .setTopic(topicName.toString())
                  .setCloudStorageConfig(cloudStorageConfig)
                  .build());

      System.out.println("Created a CloudStorage subscription: " + subscription.getAllFields());
    }
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicName = 'YOUR_TOPIC_NAME';
// const subscriptionName = 'YOUR_SUBSCRIPTION_NAME';
// const bucket = 'YOUR_BUCKET_ID';
// const filenamePrefix = 'YOUR_FILENAME_PREFIX';
// const filenameSuffix = 'YOUR_FILENAME_SUFFIX';
// const maxDuration = 60;

// 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 createCloudStorageSubscription(
  topicName,
  subscriptionName,
  bucket,
  filenamePrefix,
  filenameSuffix,
  maxDuration,
) {
  const options = {
    cloudStorageConfig: {
      bucket,
      filenamePrefix,
      filenameSuffix,
      maxDuration: {
        seconds: maxDuration,
      },
    },
  };

  await pubSubClient
    .topic(topicName)
    .createSubscription(subscriptionName, options);

  console.log(
    `Created subscription ${subscriptionName} with a cloud storage configuration.`,
  );
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicName = 'YOUR_TOPIC_NAME';
// const subscriptionName = 'YOUR_SUBSCRIPTION_NAME';
// const bucket = 'YOUR_BUCKET_ID';
// const filenamePrefix = 'YOUR_FILENAME_PREFIX';
// const filenameSuffix = 'YOUR_FILENAME_SUFFIX';
// const maxDuration = 60;

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

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

async function createCloudStorageSubscription(
  topicName: string,
  subscriptionName: string,
  bucket: string,
  filenamePrefix: string,
  filenameSuffix: string,
  maxDuration: number,
) {
  const options: CreateSubscriptionOptions = {
    cloudStorageConfig: {
      bucket,
      filenamePrefix,
      filenameSuffix,
      maxDuration: {
        seconds: maxDuration,
      },
    },
  };

  await pubSubClient
    .topic(topicName)
    .createSubscription(subscriptionName, options);

  console.log(
    `Created subscription ${subscriptionName} with a cloud storage configuration.`,
  );
}

use Google\Cloud\PubSub\PubSubClient;

/**
 * Creates a Pub/Sub GCS subscription.
 *
 * @param string $projectId  The Google project ID.
 * @param string $topicName  The Pub/Sub topic name.
 * @param string $subscriptionName  The Pub/Sub subscription name.
 * @param string $bucket The Cloud Storage bucket name without any prefix like "gs://".
 */
function create_cloud_storage_subscription($projectId, $topicName, $subscriptionName, $bucket)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);
    $topic = $pubsub->topic($topicName);
    $subscription = $topic->subscription($subscriptionName);
    $config = ['bucket' => $bucket];
    $subscription->create([
        'cloudStorageConfig' => $config
    ]);

    printf('Subscription created: %s' . PHP_EOL, $subscription->name());
}

from google.cloud import pubsub_v1
from google.protobuf import duration_pb2

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# bucket = "my-bucket"

filename_prefix = "log_events_"
filename_suffix = ".avro"
# Either CloudStorageConfig.AvroConfig or CloudStorageConfig.TextConfig
# defaults to TextConfig
avro_config = pubsub_v1.types.CloudStorageConfig.AvroConfig(write_metadata=True)

publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
max_duration = duration_pb2.Duration()
max_duration.FromSeconds(300)

cloudstorage_config = pubsub_v1.types.CloudStorageConfig(
    bucket=bucket,
    filename_prefix=filename_prefix,
    filename_suffix=filename_suffix,
    avro_config=avro_config,
    # Min 1 minutes, max 10 minutes
    max_duration=max_duration,
    # Min 1 KB, max 10 GiB
    max_bytes=10000000,
)

# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
    subscription = subscriber.create_subscription(
        request={
            "name": subscription_path,
            "topic": topic_path,
            "cloud_storage_config": cloudstorage_config,
        }
    )

print(f"CloudStorage subscription created: {subscription}.")
print(f"Bucket for subscription is: {bucket}")
print(f"Prefix is: {filename_prefix}")
print(f"Suffix is: {filename_suffix}")

Cloud Storage-Abo überwachen

Cloud Monitoring bietet eine Reihe von Messwerten, mit denen Sie Abos überwachen können.

Eine Liste aller verfügbaren Pub/Sub-Messwerte und ihre Beschreibungen finden Sie in der Monitoring-Dokumentation für Pub/Sub.

Sie können Abos auch in Pub/Sub überwachen.

Nächste Schritte

• Fehlerbehebung bei einem Cloud Storage-Abo

• Weitere Informationen zu Cloud Storage

• Preise für Pub/Sub prüfen, einschließlich Cloud Storage-Abos