Crea suscripciones a Cloud Storage

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

En este documento, se describe cómo crear una suscripción a Cloud Storage. Puedes usar la consola de Google Cloud , Google Cloud CLI, la biblioteca cliente o la API de Pub/Sub para crear una suscripción a Cloud Storage.

Antes de comenzar

Antes de leer este documento, asegúrate de estar familiarizado con lo siguiente:

• Cómo funciona una suscripción a Cloud Storage
• Cómo funciona Cloud Storage y cómo crear y administrar buckets de Cloud Storage
• Cómo configurar un tema de mensajes no entregados para controlar las fallas de los mensajes

Roles y permisos requeridos

A continuación, se muestra una lista de lineamientos relacionados con los roles y los permisos:

• Para crear una suscripción, debes configurar el control de acceso a nivel del proyecto.

• También necesitas permisos a nivel del recurso si tus suscripciones y temas están en proyectos diferentes, como se explica más adelante en esta sección.

• Para crear una suscripción a Cloud Storage, el agente de servicio de Pub/Sub o una cuenta de servicio personalizada deben tener permiso para escribir en el bucket específico de Cloud Storage y leer los metadatos del bucket. Para obtener más información sobre cómo otorgar estos permisos, consulta la siguiente sección de este documento.

Para obtener los permisos que necesitas para crear suscripciones de Cloud Storage, pídele a tu administrador que te otorgue el rol de IAM Editor de Pub/Sub (roles/pubsub.editor) en el proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear suscripciones a Cloud Storage. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Para permitir que una principal de un proyecto cree una suscripción a Cloud Storage en otro proyecto, debes otorgarle el rol de editor de Pub/Sub (roles/pubsub.editor) en ambos proyectos. Esto proporciona los permisos necesarios para crear la nueva suscripción a Google Cloud y adjuntarla al tema original. El rol de editor de Pub/Sub (roles/pubsub.editor) en el tema también te ayuda a adjuntar Google Cloud suscripciones en un proyecto diferente al tema.

Asigna roles a cuentas de servicio

Algunos Google Cloud servicios tienen Google Cloudcuentas de servicio administradas que permiten que los servicios accedan a tus recursos. Estas cuentas de servicio se conocen como agentes de servicio. Pub/Sub crea y mantiene un agente de servicio para cada proyecto en el formato service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Puedes elegir entre permitir que el agente de servicio de Pub/Sub o una cuenta de servicio personalizada escriban en el bucket de Cloud Storage.

Otorgar permiso al agente de servicio de Pub/Sub significa que cualquier usuario que tenga permiso para crear una suscripción en tu proyecto puede escribir en el bucket de Cloud Storage. Si deseas proporcionar un permiso más detallado para escribir en el bucket de Cloud Storage, configura una cuenta de servicio personalizada.

Si deseas obtener más información sobre la IAM de Cloud Storage, consulta Administración de identidades y accesos de Cloud Storage.

Asigna roles de Cloud Storage al agente de servicio de Pub/Sub

Si deseas crear una suscripción a Cloud Storage con el agente de servicio de Pub/Sub, este debe tener permiso para escribir en el bucket específico de Cloud Storage y para leer los metadatos del bucket.

Otorga los roles de creador de objetos de almacenamiento (roles/storage.objectCreator) y lector de buckets heredados de almacenamiento (roles/storage.legacyBucketReader) al agente de servicio de Pub/Sub. Puedes otorgar el permiso en un bucket individual o en todo el proyecto.

Asigna roles de Cloud Storage a una cuenta de servicio personalizada

Si deseas usar una cuenta de servicio personalizada para escribir en un bucket de Cloud Storage, debes establecer los siguientes permisos:

• La cuenta de servicio personalizada debe tener permiso para escribir en el bucket de Cloud Storage específico y para leer los metadatos del bucket.
• El agente de servicio de Pub/Sub debe tener el permiso iam.serviceAccounts.getAccessToken en la cuenta de servicio personalizada.
• El usuario que crea la suscripción debe tener el permiso iam.serviceAccounts.actAs en la cuenta de servicio personalizada.

Crea la cuenta de servicio y otorga permisos con los siguientes pasos:

1. Crea la cuenta de servicio personalizada. La cuenta de servicio debe estar en el mismo proyecto que la suscripción.

2. Otorga los roles de creador de objetos de almacenamiento (roles/storage.objectCreator) y lector de buckets heredados de almacenamiento (roles/storage.legacyBucketReader) a la cuenta de servicio personalizada.

   Puedes otorgar el permiso de cuenta de servicio en una sola tabla del proyecto o en todas las tablas del proyecto. Para ello, consulta la sección correspondiente en Cómo asignar Google Cloud roles al agente de servicio de Pub/Sub. En el procedimiento, reemplaza la dirección de correo electrónico del agente de servicio de Pub/Sub por la dirección de correo electrónico personalizada de la cuenta de servicio.

3. Otórgale al agente de servicio de Pub/Sub el permiso iam.serviceAccounts.getAccessToken en la cuenta de servicio personalizada o en todas las cuentas de servicio del proyecto. Para otorgar este permiso, asigna el rol roles/iam.serviceAccountTokenCreator al agente de servicio de Pub/Sub.

   Elige el método adecuado según tus requisitos.

Si creaste la cuenta de servicio personalizada, ya deberías tener el permiso iam.serviceAccounts.actAs necesario. Si necesitas otorgarle a otra persona el permiso en la cuenta de servicio, haz lo siguiente:

1. En la consola de Google Cloud , ve a la página Cuentas de servicio.

   Ir a Cuentas de servicio

2. Ingresa el nombre de la cuenta de servicio personalizada en Filtro.

3. Selecciona la cuenta de servicio de la lista.

4. Haz clic en Principales con acceso.

5. Haz clic en Otorgar acceso.

6. En la sección Agregar principales, ingresa el nombre de la cuenta a la que deseas otorgar acceso.

7. En el menú desplegable Seleccionar un rol, ingresa Service Account y selecciona el rol Usuario de cuenta de servicio.

8. Haz clic en Guardar.

Propiedades de la suscripción a Cloud Storage

Cuando configuras una suscripción a Cloud Storage, debes especificar las propiedades comunes a todos los tipos de suscripción y algunas propiedades adicionales específicas de la suscripción a Cloud Storage.

Propiedades comunes de suscripción

Obtén información sobre las propiedades de suscripción comunes que puedes configurar en todas las suscripciones.

Nombre del bucket

Ya debe existir un bucket de Cloud Storage antes de crear una suscripción a Cloud Storage.

Los mensajes se envían en lotes y se almacenan en el bucket de Cloud Storage. Un solo lote o archivo se almacena como un objeto en el bucket.

El bucket de Cloud Storage debe tener inhabilitada la opción Pago del solicitante.

Para crear un bucket de Cloud Storage, consulta Crea buckets.

Prefijo, sufijo y fecha y hora del nombre de archivo

Los archivos de Cloud Storage de salida que genera la suscripción a Cloud Storage se almacenan como objetos en el bucket de Cloud Storage. El nombre del objeto almacenado en el bucket de Cloud Storage tiene el siguiente formato: <file-prefix><UTC-date-time>_<uuid><file-suffix>.

En la siguiente lista, se incluyen detalles del formato de archivo y los campos que puedes personalizar:

• <file-prefix> es el prefijo del nombre de archivo personalizado. Este paso es opcional,

• <UTC-date-time> es una cadena personalizable generada automáticamente según el momento en que se crea el objeto.

• <uuid> es una cadena aleatoria generada automáticamente para el objeto.

• <file-suffix> es el sufijo del nombre de archivo personalizado. Este paso es opcional, El sufijo del nombre del archivo no puede terminar en “/”.

• Puedes cambiar el prefijo y el sufijo del nombre de archivo:

  • Por ejemplo, si el valor del prefijo del nombre de archivo es prod_ y el valor del sufijo del nombre de archivo es _archive, un nombre de objeto de muestra es prod_2023-09-25T04:10:00+00:00_uN1QuE_archive.

  • Si no especificas el prefijo ni el sufijo del nombre del archivo, el nombre del objeto almacenado en el bucket de Cloud Storage tiene el formato: <UTC-date-time>_<uuid>.

  • Los requisitos para nombrar objetos de Cloud Storage también se aplican al prefijo y al sufijo del nombre del archivo. Para obtener más información, consulta Acerca de los objetos de Cloud Storage.

• Puedes cambiar cómo se muestran la fecha y la hora en el nombre del archivo:

  • Coincidencias de fecha y hora obligatorias que puedes usar solo una vez: año (YYYY o YY), mes (MM), día (DD), hora (hh), minuto (mm), segundo (ss). Por ejemplo, YY-YYYY o MMM no son válidos.

  • Coincidencias opcionales que puedes usar solo una vez: separador de fecha y hora (T) y compensación de zona horaria (Z o +00:00).

  • Elementos opcionales que puedes usar varias veces: guion (-), guion bajo (_), dos puntos (:) y barra diagonal (/).

  • Por ejemplo, si el valor del formato de fecha y hora del nombre de archivo es YYYY-MM-DD/hh_mm_ssZ, un nombre de objeto de muestra es prod_2023-09-25/04_10_00Z_uNiQuE_archive.

  • Si el formato de fecha y hora del nombre del archivo termina en un carácter que no es un comparador, ese carácter reemplazará el separador entre <UTC-date-time> y <uuid>. Por ejemplo, si el valor del formato de fecha y hora del nombre de archivo es YYYY-MM-DDThh_mm_ss-, un nombre de objeto de muestra es prod_2023-09-25T04_10_00-uNiQuE_archive.

Procesamiento de archivos por lotes

Las suscripciones a Cloud Storage te permiten decidir cuándo quieres crear un nuevo archivo de salida que se almacena como un objeto en el bucket de Cloud Storage. Pub/Sub escribe un archivo de salida cuando se cumple una de las condiciones de procesamiento por lotes especificadas. Las siguientes son las condiciones de procesamiento por lotes de Cloud Storage:

• Duración máxima del lote de almacenamiento. Este es un parámetro de configuración obligatorio. La suscripción a Cloud Storage escribe un nuevo archivo de salida si se supera el valor especificado de duración máxima. Si no especificas el valor, se aplica un valor predeterminado de 5 minutos. Los siguientes son los valores aplicables para la duración máxima:

  • Valor mínimo = 1 minuto
  • Valor predeterminado = 5 minutos
  • Valor máximo = 10 minutos

• Cantidad máxima de bytes por lotes de almacenamiento. Este es un parámetro de configuración opcional. La suscripción a Cloud Storage escribe un nuevo archivo de salida si se supera el valor especificado de bytes máximos. Los siguientes son los valores aplicables para los bytes máximos:

  • Valor mínimo = 1 KB
  • Valor máximo = 10 GiB

• Mensajes por lotes de almacenamiento máximos. Este es un parámetro de configuración opcional. La suscripción a Cloud Storage escribe un nuevo archivo de salida si se supera la cantidad máxima de mensajes especificada. Los siguientes son los valores aplicables para los mensajes máximos:

  • Valor mínimo = 1,000

Por ejemplo, puedes configurar la duración máxima en 6 minutos y los bytes máximos en 2 GB. Si, en el cuarto minuto, el archivo de salida alcanza un tamaño de 2 GB, Pub/Sub finaliza el archivo anterior y comienza a escribir en uno nuevo.

Una suscripción a Cloud Storage puede escribir en varios archivos de un bucket de Cloud Storage de forma simultánea. Si configuraste tu suscripción para crear un archivo nuevo cada 6 minutos, es posible que observes que se crean varios archivos de Cloud Storage cada 6 minutos.

En algunas situaciones, Pub/Sub puede comenzar a escribir en un archivo nuevo antes de la hora configurada por las condiciones de procesamiento por lotes de archivos. Un archivo también puede superar el valor de bytes máximos si la suscripción recibe mensajes más grandes que el valor de bytes máximos.

Formato de archivo

Cuando creas una suscripción a Cloud Storage, puedes especificar el formato de los archivos de salida que se almacenarán en un bucket de Cloud Storage como Texto o Avro.

• Texto: Los mensajes se almacenan como texto sin formato. Un carácter de salto de línea separa un mensaje del mensaje anterior en el archivo. Solo se almacenan las cargas útiles de los mensajes, no los atributos ni otros metadatos.

• Avro: Los mensajes se almacenan en formato binario de Apache Avro. Cuando seleccionas Avro, puedes habilitar las siguientes propiedades adicionales:

  • Escribir metadatos: Esta opción te permite almacenar los metadatos del mensaje junto con el mensaje. Los metadatos, como los campos subscription_name, message_id, publish_time y attributes, se escriben en campos de nivel superior en el objeto Avro de salida, mientras que todas las demás propiedades del mensaje, excepto los datos (por ejemplo, un ordering_key, si está presente), se agregan como entradas en el mapa attributes.

    Si se inhabilitan los metadatos de escritura, solo se escribe la carga útil del mensaje en el objeto Avro de salida. Este es el esquema Avro para los mensajes de salida con los metadatos de escritura inhabilitados:

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

    Este es el esquema de Avro para los mensajes de salida con los metadatos de escritura habilitados:

    {
      "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" }
      ]
    }
    

  • Usar el esquema de tema: Esta opción permite que Pub/Sub use el esquema del tema de Pub/Sub al que se adjunta la suscripción cuando se escriben archivos Avro.

    Cuando uses esta opción, recuerda verificar los siguientes requisitos adicionales:

    • El esquema del tema debe estar en formato Apache Avro.

    • Si están habilitados usar el esquema de tema y escribir metadatos, el esquema de tema debe tener un objeto Record en su raíz. Pub/Sub expandirá la lista de campos del registro para incluir los campos de metadatos. Como resultado, el registro no puede contener ningún campo con el mismo nombre que los campos de metadatos (subscription_name, message_id, publish_time o attributes).

Cuenta de servicio

Tienes las siguientes opciones para escribir mensajes en una tabla de BigQuery o un bucket de Cloud Storage:

• Configura una cuenta de servicio personalizada para que solo los usuarios que tengan el permiso iam.serviceAccounts.actAs en la cuenta de servicio puedan crear una suscripción que escriba en la tabla o el bucket. Un ejemplo de rol que incluye el permiso iam.serviceAccounts.actAs es el rol de usuario de cuenta de servicio (roles/iam.serviceAccountUser).

• Usa el agente de servicio de Pub/Sub predeterminado que permite que cualquier usuario con la capacidad de crear suscripciones en el proyecto cree una suscripción que escriba en la tabla o el bucket. El agente de servicio de Pub/Sub es la configuración predeterminada cuando no especificas una cuenta de servicio personalizada.

Crea una suscripción a Cloud Storage

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

Supervisa una suscripción a Cloud Storage

Cloud Monitoring proporciona varias métricas para supervisar las suscripciones.

Para obtener una lista de todas las métricas disponibles relacionadas con Pub/Sub y sus descripciones, consulta la documentación de supervisión de Pub/Sub.

También puedes supervisar las suscripciones desde dentro de Pub/Sub.

¿Qué sigue?

• Soluciona problemas relacionados con una suscripción a Cloud Storage.

• Obtén información sobre Cloud Storage.

• Revisa los precios de Pub/Sub, incluida la suscripción a Cloud Storage.