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 tópicos:

• 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 funções 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 as assinaturas e os 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 do bucket. 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) nos dois projetos. Isso fornece as permissões necessárias para criar a nova assinatura 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 de um projeto diferente ao tópico.

Atribuir papéis a contas de serviço

Alguns Google Cloud serviços têm contas serviço gerenciado por 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 escolher entre permitir que o agente de serviço do Pub/Sub ou uma permissão de 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 precisa ter permissão para gravar no bucket específico do Cloud Storage e ler os metadados do bucket.

Conceda os papéis de Criador de objetos do Storage (roles/storage.objectCreator) e Leitor do bucket legado 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 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 de Criador de objetos do Storage (roles/storage.objectCreator) e Leitor de bucket 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. Para fazer 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 apropriado 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 a outra pessoa na conta de serviço:

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 Pessoas 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. Na lista suspensa Selecionar um papel, digite Service Account e selecione o papel Usuário da conta de serviço.

8. Clique em Salvar.

Propriedades de assinatura do Cloud Storage

Ao configurar uma assinatura do Cloud Storage, é necessário especificar as propriedades comuns a todos os tipos de assinatura e algumas outras propriedades 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 de você criar 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 o recurso Pagamento do solicitante desativado.

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

Prefixo, sufixo e data e hora do nome do 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 os campos que podem ser personalizados:

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

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

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

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

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

  • Por exemplo, se o valor do prefixo do nome do arquivo for prod_ e o valor do sufixo do nome do arquivo for _archive, um exemplo de nome de objeto 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 terá o 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 os objetos do Cloud Storage.

• É possível mudar como a data e a hora aparecem no nome do arquivo:

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

  • Combinadores 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 exemplo 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 é um correspondente, 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 exemplo será prod_2023-09-25T04_10_00-uNiQuE_archive.

Lote de arquivos

As assinaturas do Cloud Storage permitem que você decida quando 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. Confira a seguir as condições de lote 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, um valor padrão de 5 minutos será aplicado. Confira a seguir 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 de 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. Confira a seguir os valores aplicáveis para bytes máximos:

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

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

  • Valor mínimo = 1.000

Por exemplo, é possível configurar a duração máxima como 6 minutos e os bytes máximos 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 arquivo.

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 seis minutos, talvez observe vários arquivos do Cloud Storage sendo criados a cada seis minutos.

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

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 as seguintes propriedades:

  • Gravar metadados: essa opção permite armazenar os metadados da mensagem com a mensagem. 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 de mensagem, exceto dados (por exemplo, uma chave de ordenação, se presente) são adicionadas como entradas no mapa attributes.

    Se a opção write metadata estiver desativada, apenas o payload da mensagem será gravado no objeto Avro de saída. Confira o esquema do Avro para as mensagens de saída com metadados de gravação desativados:

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

    Confira o esquema do Avro para as mensagens de saída com 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 o esquema do tópico: essa opção permite que o Pub/Sub use o esquema do tópico do Pub/Sub ao qual 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 a opção 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 somente os 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 capacidade de criar assinaturas no projeto crie uma assinatura que grava 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"
)

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

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 de monitoramento do Pub/Sub.

Também é possível monitorar 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.