Criar assinaturas do Cloud Storage

Este documento descreve como criar uma assinatura do Cloud Storage. É possível usar o console Google Cloud , a Google Cloud CLI, a biblioteca de cliente ou a API Pub/Sub para criar uma assinatura do Cloud Storage.

Antes de começar

Antes de ler este documento, confira se você conhece os seguintes conceitos:

• Como funciona uma assinatura do Cloud Storage.
• Como o Cloud Storage funciona e como criar e gerenciar buckets do Cloud Storage.
• Como configurar um tópico de mensagens inativas para lidar com falhas de mensagens.

Papéis e permissões necessárias

Confira a seguir uma lista de diretrizes sobre papéis e permissões:

• Para criar uma assinatura, é necessário configurar o controle de acesso no nível do projeto.

• Você também precisa de permissões no nível do recurso se suas assinaturas e tópicos estiverem em projetos diferentes, conforme discutido mais adiante nesta seção.

• Para criar uma assinatura do Cloud Storage, o agente de serviço do Pub/Sub ou uma conta de serviço personalizada precisa ter permissão para gravar no bucket específico do Cloud Storage e ler os metadados dele. Para mais informações sobre como conceder essas permissões, consulte a próxima seção deste documento.

Para receber as permissões necessárias para criar assinaturas do Cloud Storage, peça ao administrador para conceder a você o papel do IAM de Editor do Pub/Sub (roles/pubsub.editor) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para criar assinaturas do Cloud Storage. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Para permitir que um principal em um projeto crie uma assinatura do Cloud Storage em outro projeto, conceda a esse principal o papel de Editor do Pub/Sub (roles/pubsub.editor) em ambos os projetos. Isso fornece as permissões necessárias para criar a nova assinatura do Google Cloud e anexá-la ao tópico original. O papel de editor do Pub/Sub (roles/pubsub.editor) no tópico também ajuda a anexar assinaturas Google Cloud em um projeto diferente ao tópico.

Atribuir papéis a contas de serviço

Alguns serviços do Google Cloud têm contas de serviço gerenciado pelo Google Cloudque permitem que os serviços acessem seus recursos. Essas contas de serviço são conhecidas como agentes de serviço. O Pub/Sub cria e mantém um agente de serviço para cada projeto no formato service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Você pode permitir que o agente de serviço do Pub/Sub ou uma conta de serviço personalizada grave no bucket do Cloud Storage.

Conceder permissão ao agente de serviço do Pub/Sub significa que qualquer usuário com permissão para criar uma assinatura no seu projeto pode gravar no bucket do Cloud Storage. Se você quiser fornecer uma permissão mais granular para gravar no bucket do Cloud Storage, configure uma conta de serviço personalizada.

Para mais informações sobre o IAM do Cloud Storage, consulte Identity and Access Management do Cloud Storage.

Atribuir papéis do Cloud Storage ao agente de serviço do Pub/Sub

Se você quiser criar uma assinatura do Cloud Storage usando o agente de serviço do Pub/Sub, ele precisará ter permissão para gravar no bucket específico do Cloud Storage e para ler os metadados do bucket.

Conceda os papéis Criador de objetos do Storage (roles/storage.objectCreator) e Leitor de buckets legados do Storage (roles/storage.legacyBucketReader) ao agente de serviço do Pub/Sub. É possível conceder a permissão em um bucket individual ou no projeto como um todo.

Atribuir papéis do Cloud Storage a uma conta de serviço personalizada

Se você quiser usar uma conta de serviço personalizada para gravar em um bucket do Cloud Storage, defina as seguintes permissões:

• A conta de serviço personalizada precisa ter permissão para gravar no bucket específico do Cloud Storage e ler os metadados dele.
• O agente de serviço do Pub/Sub precisa ter a permissão iam.serviceAccounts.getAccessToken na conta de serviço personalizada.
• O usuário que cria a assinatura precisa ter a permissão iam.serviceAccounts.actAs na conta de serviço personalizada.

Crie a conta de serviço e conceda permissões seguindo estas etapas:

1. Crie a conta de serviço personalizada. A conta de serviço precisa estar no mesmo projeto que a assinatura.

2. Conceda os papéis Criador de objetos do Storage (roles/storage.objectCreator) e Leitor de buckets legados do Storage (roles/storage.legacyBucketReader) à conta de serviço personalizada.

   É possível conceder a permissão da conta de serviço em uma única tabela no projeto ou em todas as tabelas do projeto. Para isso, consulte a seção apropriada em Atribuir papéis Google Cloud ao agente de serviço do Pub/Sub. No procedimento, substitua o endereço de e-mail do agente de serviço do Pub/Sub pelo endereço de e-mail personalizado da conta de serviço.

3. Conceda ao agente de serviço do Pub/Sub a permissão iam.serviceAccounts.getAccessToken na conta de serviço personalizada ou em todas as contas de serviço do projeto. Para conceder essa permissão, atribua o papel roles/iam.serviceAccountTokenCreator ao agente de serviço do Pub/Sub.

   Escolha o método adequado com base nos seus requisitos.

Se você criou a conta de serviço personalizada, já tem a permissão iam.serviceAccounts.actAs necessária. Se você precisar conceder a permissão na conta de serviço a outra pessoa:

1. No console Google Cloud , acesse a página Contas de serviço.

   Acesse as Contas de serviço

2. Insira o nome da conta de serviço personalizada no Filtro.

3. Selecione a conta de serviço na lista.

4. Clique em Principais com acesso.

5. Clique em Conceder acesso.

6. Na seção Adicionar principais, insira o nome da conta a que você quer conceder acesso.

7. No menu suspenso Selecionar um papel, insira Service Account e selecione o papel Usuário da conta de serviço.

8. Clique em Salvar.

Propriedades da assinatura do Cloud Storage

Ao configurar uma assinatura do Cloud Storage, você precisa especificar as propriedades comuns a todos os tipos de assinatura e algumas propriedades adicionais específicas da assinatura do Cloud Storage.

Propriedades comuns de assinatura

Saiba mais sobre as propriedades comuns de assinatura que podem ser definidas em todas as assinaturas.

Nome do bucket

Um bucket do Cloud Storage precisa existir antes da criação de uma assinatura do Cloud Storage.

As mensagens são enviadas em lotes e armazenadas no bucket do Cloud Storage. Um único lote ou arquivo é armazenado como um objeto no bucket.

O bucket do Cloud Storage precisa ter a opção Pagamentos do solicitante desativada.

Para criar um bucket do Cloud Storage, consulte Criar buckets.

Prefixo, sufixo e data/hora do nome de arquivo

Os arquivos de saída do Cloud Storage gerados pela assinatura do Cloud Storage são armazenados como objetos no bucket do Cloud Storage. O nome do objeto armazenado no bucket do Cloud Storage tem o seguinte formato: <file-prefix><UTC-date-time>_<uuid><file-suffix>.

A lista a seguir inclui detalhes do formato de arquivo e dos campos que você pode personalizar:

• <file-prefix> é o prefixo do nome de arquivo personalizado. Esse campo é opcional.

• <UTC-date-time> é uma string personalizável gerada automaticamente com base no momento em que o objeto é criado.

• <uuid> é uma string aleatória gerada automaticamente para o objeto.

• <file-suffix> é o sufixo personalizado do nome do arquivo. Esse campo é opcional. O sufixo do nome do arquivo não pode terminar com "/".

• É possível mudar o prefixo e o sufixo do nome do arquivo:

  • Por exemplo, se o valor do prefixo do nome de arquivo for prod_ e o valor do sufixo for _archive, um nome de objeto de exemplo será prod_2023-09-25T04:10:00+00:00_uN1QuE_archive.

  • Se você não especificar o prefixo e o sufixo do nome do arquivo, o nome do objeto armazenado no bucket do Cloud Storage será do formato: <UTC-date-time>_<uuid>.

  • Os requisitos de nomenclatura de objetos do Cloud Storage também se aplicam ao prefixo e ao sufixo do nome do arquivo. Para mais informações, consulte Sobre objetos do Cloud Storage.

• Você pode mudar como a data e a hora são mostradas no nome do arquivo:

  • Correspondedores de data e hora obrigatórios que podem ser usados apenas uma vez: ano (YYYY ou YY), mês (MM), dia (DD), hora (hh), minuto (mm), segundo (ss). Por exemplo, YY-YYYY ou MMM é inválido.

  • Correspondedores opcionais que podem ser usados apenas uma vez: separador de data e hora (T) e deslocamento de fuso horário (Z ou +00:00).

  • Elementos opcionais que podem ser usados várias vezes: hífen (-), sublinhado (_), dois-pontos (:) e barra (/).

  • Por exemplo, se o valor do formato de data e hora do nome do arquivo for YYYY-MM-DD/hh_mm_ssZ, um nome de objeto de amostra será prod_2023-09-25/04_10_00Z_uNiQuE_archive.

  • Se o formato de data e hora do nome do arquivo terminar com um caractere que não seja um comparador, esse caractere vai substituir o separador entre <UTC-date-time> e <uuid>. Por exemplo, se o valor do formato de data e hora do nome do arquivo for YYYY-MM-DDThh_mm_ss-, um nome de objeto de amostra será prod_2023-09-25T04_10_00-uNiQuE_archive.

Lote de arquivos

Com as assinaturas do Cloud Storage, você decide quando quer criar um novo arquivo de saída armazenado como um objeto no bucket do Cloud Storage. O Pub/Sub grava um arquivo de saída quando uma das condições de lote especificadas é atendida. Estas são as condições de loteamento do Cloud Storage:

• Duração máxima do lote de armazenamento. Essa é uma configuração obrigatória. A assinatura do Cloud Storage grava um novo arquivo de saída se o valor especificado de duração máxima for excedido. Se você não especificar o valor, o padrão de 5 minutos será aplicado. Confira os valores aplicáveis para a duração máxima:

  • Valor mínimo = 1 minuto
  • Valor padrão = 5 minutos
  • Valor máximo = 10 minutos

• Máximo de bytes do lote de armazenamento. Essa configuração é opcional. A assinatura do Cloud Storage grava um novo arquivo de saída se o valor especificado de bytes máximos for excedido. Estes são os valores aplicáveis para bytes máximos:

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

• Número máximo de mensagens do lote de armazenamento. Essa configuração é opcional. A assinatura do Cloud Storage grava um novo arquivo de saída se o número máximo de mensagens especificado for excedido. Confira abaixo os valores aplicáveis para o número máximo de mensagens:

  • Valor mínimo = 1000

Por exemplo, é possível configurar a duração máxima como 6 minutos e o número máximo de bytes como 2 GB. Se, no quarto minuto, o arquivo de saída atingir um tamanho de 2 GB, o Pub/Sub vai finalizar o arquivo anterior e começar a gravar em um novo.

Uma assinatura do Cloud Storage pode gravar em vários arquivos em um bucket do Cloud Storage simultaneamente. Se você configurou sua assinatura para criar um novo arquivo a cada 6 minutos, é possível observar vários arquivos do Cloud Storage sendo criados a cada 6 minutos.

Em algumas situações, o Pub/Sub pode começar a gravar em um novo arquivo antes do horário configurado pelas condições de agrupamento em lote. Um arquivo também pode exceder o valor de "Max bytes" se a assinatura receber mensagens maiores que esse valor.

Formato do arquivo

Ao criar uma assinatura do Cloud Storage, é possível especificar o formato dos arquivos de saída que serão armazenados em um bucket do Cloud Storage como Texto ou Avro.

• Texto: as mensagens são armazenadas como texto simples. Um caractere de nova linha separa uma mensagem da anterior no arquivo. Somente os payloads de mensagens são armazenados, não atributos ou outros metadados.

• Avro: as mensagens são armazenadas no formato binário do Apache Avro. Ao selecionar Avro, você pode ativar estas propriedades adicionais:

  • Gravar metadados: com essa opção, é possível armazenar os metadados da mensagem junto com ela. Metadados como os campos subscription_name, message_id, publish_time e attributes são gravados em campos de nível superior no objeto Avro de saída, enquanto todas as outras propriedades da mensagem, além dos dados (por exemplo, uma ordering_key, se presente), são adicionadas como entradas no mapa attributes.

    Se a opção gravar metadados estiver desativada, apenas a carga útil da mensagem será gravada no objeto Avro de saída. Confira abaixo o esquema Avro para as mensagens de saída com os metadados de gravação desativados:

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

    Confira o esquema Avro para as mensagens de saída com os metadados de gravação ativados:

    {
      "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 esquema de tópico: essa opção permite que o Pub/Sub use o esquema do tópico do Pub/Sub a que a assinatura está anexada ao gravar arquivos Avro.

    Ao usar essa opção, verifique os seguintes requisitos adicionais:

    • O esquema do tópico precisa estar no formato Apache Avro.

    • Se as opções usar esquema de tópico e gravar metadados estiverem ativadas, o esquema de tópico precisará ter um objeto Record na raiz. O Pub/Sub vai expandir a lista de campos do registro para incluir os campos de metadados. Como resultado, o registro não pode conter campos com o mesmo nome dos campos de metadados (subscription_name, message_id, publish_time ou attributes).

Conta de serviço

Você tem as seguintes opções para gravar mensagens em uma tabela do BigQuery ou em um bucket do Cloud Storage:

• Configure uma conta de serviço personalizada para que apenas usuários com a permissão iam.serviceAccounts.actAs na conta de serviço possam criar uma assinatura que grava na tabela ou no bucket. Um exemplo de papel que inclui a permissão iam.serviceAccounts.actAs é o papel de Usuário da conta de serviço (roles/iam.serviceAccountUser).

• Use o agente de serviço padrão do Pub/Sub, que permite que qualquer usuário com a capacidade de criar assinaturas no projeto crie uma assinatura que grave na tabela ou no bucket. O agente de serviço do Pub/Sub é a configuração padrão quando você não especifica uma conta de serviço personalizada.

Criar uma assinatura do 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/v2"
	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
	"google.golang.org/protobuf/types/known/durationpb"
)

// createCloudStorageSubscription creates a Pub/Sub subscription that exports messages to Cloud Storage.
func createCloudStorageSubscription(w io.Writer, projectID, topic, subscription, bucket string) error {
	// projectID := "my-project-id"
	// topic := "projects/my-project-id/topics/my-topic"
	// subscription := "projects/my-project/subscriptions/my-sub"
	// bucket := "my-bucket" // bucket must not have the gs:// prefix
	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.SubscriptionAdminClient.CreateSubscription(ctx, &pubsubpb.Subscription{
		Name:  subscription,
		Topic: topic,
		CloudStorageConfig: &pubsubpb.CloudStorageConfig{
			Bucket:         bucket,
			FilenamePrefix: "log_events_",
			FilenameSuffix: ".avro",
			OutputFormat: &pubsubpb.CloudStorageConfig_AvroConfig_{
				AvroConfig: &pubsubpb.CloudStorageConfig_AvroConfig{
					WriteMetadata: true,
				},
			},
			MaxDuration: durationpb.New(1 * time.Minute),
			MaxBytes:    1e8,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to create cloud storage sub: %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}")

Monitorar uma assinatura do Cloud Storage

O Cloud Monitoring oferece várias métricas para monitorar assinaturas.

Para conferir uma lista de todas as métricas disponíveis relacionadas ao Pub/Sub e as descrições delas, consulte a documentação do Monitoring para o Pub/Sub.

Você também pode monitorar as assinaturas no Pub/Sub.

A seguir

• Resolver problemas com uma assinatura do Cloud Storage.

• Leia sobre o Cloud Storage.

• Confira os preços do Pub/Sub, incluindo a assinatura do Cloud Storage.