Criar assinaturas do BigQuery

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

Antes de começar

Antes de ler este documento, confira se você conhece os seguintes tópicos:

Além de conhecer o Pub/Sub e o BigQuery, verifique se você atende aos pré-requisitos a seguir antes de criar uma assinatura do BigQuery:

  • Uma tabela do BigQuery existe. Você também pode criar uma ao criar a assinatura do BigQuery, conforme descrito nas seções posteriores deste documento.

  • Compatibilidade entre o esquema do tópico do Pub/Sub e a tabela do BigQuery. Se você adicionar uma tabela do BigQuery incompatível, vai receber uma mensagem de erro relacionada à compatibilidade. Para mais informações, consulte Compatibilidade de esquema.

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 suas assinaturas e tópicos estiverem em projetos diferentes, conforme discutido mais adiante nesta seção.

  • Para criar uma assinatura do BigQuery, a conta de serviço do Pub/Sub precisa ter permissão para gravar na tabela específica do BigQuery. Para mais informações sobre como conceder essas permissões, consulte a próxima seção deste documento.

  • É possível configurar uma assinatura do BigQuery em um projeto para gravar em uma tabela do BigQuery em outro projeto.

Para receber as permissões necessárias para criar assinaturas do BigQuery, 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 BigQuery. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar assinaturas do BigQuery:

  • Extrair de uma assinatura: pubsub.subscriptions.consume
  • Criar uma assinatura: pubsub.subscriptions.create
  • Excluir uma assinatura: pubsub.subscriptions.delete
  • Receber uma assinatura: pubsub.subscriptions.get
  • Listar uma assinatura: pubsub.subscriptions.list
  • Atualizar uma assinatura: pubsub.subscriptions.update
  • Anexe uma assinatura a um tópico: pubsub.topics.attachSubscription
  • Acesse a política do IAM para uma assinatura: pubsub.subscriptions.getIamPolicy
  • Configure a política do IAM para uma assinatura: pubsub.subscriptions.setIamPolicy

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

Se você precisar criar assinaturas do BigQuery em um projeto associado a um tópico em outro projeto, peça ao administrador do tópico para conceder a você o papel do IAM (roles/pubsub.editor) do Editor do Pub/Sub no tópico.

Atribuir papéis do BigQuery à conta de serviço do Pub/Sub

Alguns serviços do Google Cloud têm contas de serviço gerenciado pelo Google Cloud que 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 uma conta de serviço para cada projeto no formato service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Para criar uma assinatura do BigQuery, a conta de serviço do Pub/Sub precisa ter permissão para gravar na tabela específica do BigQuery e ler os metadados dela.

Conceda o papel de editor de dados do BigQuery (roles/bigquery.dataEditor) à conta de serviço do Pub/Sub.

  1. No console do Google Cloud, abra a página IAM.

    Acessar IAM

  2. Clique em Conceder acesso.

  3. Na seção Adicionar principais, insira o nome da sua conta de serviço do Pub/Sub. O formato da conta de serviço é service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com. Por exemplo, para um projeto com project-number=112233445566, a conta de serviço tem o formato service-112233445566@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. Na seção Atribuir funções, clique em Adicionar outro papel.

  5. No menu suspenso Selecionar um papel, digite BigQuery e selecione Papel de editor de dados do BigQuery.

  6. Clique em Salvar.

Para mais informações sobre o IAM do BigQuery, consulte Funções e permissões do BigQuery.

Propriedades de assinatura do BigQuery

Ao configurar uma assinatura do BigQuery, é possível especificar as seguintes propriedades:

Propriedades comuns

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

Usar esquema de tópicos

Essa opção permite que o Pub/Sub use o esquema do tópico do Pub/Sub ao qual a assinatura está anexada. Além disso, o Pub/Sub grava os campos em mensagens nas colunas correspondentes da tabela do BigQuery.

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

  • Os campos no esquema do tópico e no BigQuery precisam ter os mesmos nomes, e os tipos precisam ser compatíveis entre si.

  • Qualquer campo opcional no esquema do tópico também precisa ser opcional no esquema do BigQuery.

  • Os campos obrigatórios no esquema do tópico não precisam ser obrigatórios no esquema do BigQuery.

  • Se houver campos do BigQuery que não estão presentes no esquema do tópico, eles precisam estar no modo NULLABLE.

  • Se o esquema do tópico tiver campos adicionais que não estão presentes no esquema do BigQuery e que podem ser descartados, selecione a opção Drop unknown fields.

  • Você pode selecionar apenas uma das propriedades de assinatura, Usar esquema de tópico ou Usar esquema de tabela.

Se você não selecionar a opção Usar esquema de tópicos ou Usar esquema de tabela, verifique se a tabela do BigQuery tem uma coluna chamada data de tipo BYTES, STRING ou JSON. O Pub/Sub grava a mensagem nessa coluna do BigQuery.

Talvez as mudanças no esquema de tópicos do Pub/Sub ou no esquema de tabela do BigQuery não entrem em vigor imediatamente com as mensagens gravadas na tabela do BigQuery. Por exemplo, se a opção Drop unknown fields estiver ativada e um campo estiver presente no esquema do Pub/Sub, mas não no BigQuery, as mensagens gravadas na tabela do BigQuery ainda poderão não conter o campo depois de adicioná-lo ao esquema do BigQuery. Eventualmente, os esquemas são sincronizados e as mensagens subsequentes incluem o campo.

Ao usar a opção Usar esquema de tópico na sua assinatura do BigQuery, você também pode aproveitar a captura de dados de mudança (CDC) do BigQuery. A CDC atualiza as tabelas do BigQuery processando e aplicando as mudanças às linhas atuais.

Para saber mais sobre esse recurso, consulte Fazer streaming de atualizações da tabela com captura de dados alterados.

Para saber como usar esse recurso com as assinaturas do BigQuery, consulte Captura de dados de alterações do BigQuery.

Usar esquema de tabela

Essa opção permite que o Pub/Sub use o esquema da tabela do BigQuery para gravar os campos de uma mensagem JSON nas colunas correspondentes. Ao usar essa opção, verifique os seguintes requisitos adicionais:

  • As mensagens publicadas precisam estar no formato JSON.

  • As seguintes conversões JSON são compatíveis:

    Tipo de JSON Tipo de dados do BigQuery
    string NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME ou TIMESTAMP
    number NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME ou TIMESTAMP
    • Ao usar number para conversões DATE, DATETIME, TIME ou TIMESTAMP, o número precisa obedecer às representações compatíveis.
    • Ao usar a conversão de number para NUMERIC ou BIGNUMERIC, a precisão e o intervalo de valores são limitados aos aceitos pelo padrão IEEE 754 para aritmética de ponto flutuante. Se você precisar de alta precisão ou um intervalo maior de valores, use as conversões de string para NUMERIC ou BIGNUMERIC.
    • Ao usar conversões de string para NUMERIC ou BIGNUMERIC, o Pub/Sub presume que a string é um número legível por humanos (por exemplo, "123.124"). Se o processamento da string como um número legível por humanos falhar, o Pub/Sub vai tratar a string como bytes codificados com o BigDecimalByteStringEncoder.

  • Se o tópico da assinatura tiver um esquema associado, a propriedade de codificação da mensagem precisará ser definida como JSON.

  • Se houver campos do BigQuery que não estão presentes nas mensagens, eles precisam estar no modo NULLABLE.

  • Se as mensagens tiverem campos adicionais que não estão presentes no esquema do BigQuery e esses campos puderem ser descartados, selecione a opção Drop unknown fields.

  • Você pode selecionar apenas uma das propriedades de assinatura, Usar esquema de tópico ou Usar esquema de tabela.

Se você não selecionar a opção Usar esquema de tópicos ou Usar esquema de tabela, verifique se a tabela do BigQuery tem uma coluna chamada data de tipo BYTES, STRING ou JSON. O Pub/Sub grava a mensagem nessa coluna do BigQuery.

Talvez as mudanças no esquema da tabela do BigQuery não entrem em vigor imediatamente com as mensagens gravadas na tabela do BigQuery. Por exemplo, se a opção Drop unknown fields estiver ativada e um campo estiver presente nas mensagens, mas não no esquema do BigQuery, as mensagens gravadas na tabela do BigQuery ainda poderão não conter o campo depois de adicioná-lo ao esquema do BigQuery. Eventualmente, o esquema é sincronizado e as mensagens seguintes incluem o campo.

Ao usar a opção Usar esquema de tabela na sua assinatura do BigQuery, você também pode aproveitar a captura de dados alterados (CDC) do BigQuery. A CDC atualiza as tabelas do BigQuery processando e aplicando mudanças às linhas existentes.

Para saber mais sobre esse recurso, consulte Fazer streaming de atualizações da tabela com captura de dados alterados.

Para saber como usar esse recurso com as assinaturas do BigQuery, consulte Captura de dados de alterações do BigQuery.

Remover campos desconhecidos

Essa opção é usada com a opção Usar esquema de tópicos ou Usar esquema de tabela. Essa opção permite que o Pub/Sub exclua qualquer campo presente no esquema do tópico ou da mensagem, mas não no esquema do BigQuery. Sem a opção Drop unknown fields definida, as mensagens com campos extras não são gravadas no BigQuery e permanecem no backlog de assinatura. A assinatura acaba em um estado de erro.

Gravar metadados

Essa opção permite que o Pub/Sub grave os metadados de cada mensagem em outras colunas na tabela do BigQuery. Caso contrário, os metadados não serão gravados na tabela do BigQuery.

Se você selecionar a opção Gravar metadados, verifique se a tabela do BigQuery tem os campos descritos na tabela a seguir.

Se você não selecionar a opção Gravar metadados, a tabela de destino do BigQuery só vai exigir o campo data, a menos que use_topic_schema seja verdadeiro. Se você selecionar as opções Gravar metadados e Usar esquema de tópicos, o esquema do tópico não poderá conter campos com nomes que correspondam aos dos parâmetros de metadados. Essa limitação inclui versões em CamelCase desses parâmetros de caixa baixa.

Parâmetros
subscription_name

STRING

Nome de uma assinatura.
message_id

STRING

ID de uma mensagem
publish_time

TIMESTAMP

O horário de publicação de uma mensagem.
data

BYTES, STRING ou JSON

O corpo da mensagem.

O campo data é obrigatório para todas as tabelas de destino do BigQuery que não selecionam Usar esquema de tópicos ou Usar esquema de tabela. Se o campo for do tipo JSON, o corpo da mensagem precisa ser um JSON válido.
attributes

STRING ou JSON

Um objeto JSON que contém todos os atributos da mensagem. Ele também contém outros campos que fazem parte da mensagem do Pub/Sub, incluindo a chave de ordenação, se presente.

Criar uma assinatura do BigQuery

Os exemplos a seguir demonstram como criar uma assinatura com entrega do BigQuery.

Console

  1. No console do Google Cloud, acesse a página Assinaturas.

    Acessar "Assinaturas"

  2. Clique em Criar assinatura.
  3. No campo ID da assinatura, insira um nome.

    Para saber como nomear uma assinatura, consulte as Diretrizes para nomear um tópico ou uma assinatura.

  4. Escolha ou crie um tópico no menu suspenso. A assinatura recebe mensagens do tópico.
  5. Selecione Tipo de entrega como Gravar no BigQuery.
  6. Selecione o projeto da tabela do BigQuery.
  7. Selecione um conjunto de dados ou crie um.

    Para saber como criar um conjunto de dados, consulte Como criar conjuntos de dados.

  8. Selecione uma tabela ou crie uma nova.

    Para saber como criar uma tabela, consulte Como criar tabelas.

  9. É altamente recomendável ativar o Dead lettering para processar falhas de mensagens.

    Para mais informações, consulte Tópico de mensagens inativas.

  10. Clique em Criar.

Você também pode criar uma assinatura na página Tópicos. Esse atalho é útil para associar tópicos a assinaturas.

  1. No console do Google Cloud, acesse a página Tópicos.

    Acesse Tópicos

  2. Clique em ao lado do tópico para o qual você quer criar uma assinatura.
  3. No menu de contexto, selecione Criar assinatura.
  4. Selecione Tipo de entrega como Gravar no BigQuery.
  5. Selecione o projeto da tabela do BigQuery.
  6. Selecione um conjunto de dados ou crie um.

    Para saber como criar um conjunto de dados, consulte Como criar conjuntos de dados.

  7. Selecione uma tabela ou crie uma nova.

    Para saber como criar um conjunto de dados, consulte Como criar tabelas.

  8. É altamente recomendável ativar o Dead lettering para processar falhas de mensagens.

    Para mais informações, consulte Tópico de mensagens inativas.

  9. Clique em Criar.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para criar uma assinatura do Pub/Sub, use o comando gcloud pubsub subscriptions create:

    gcloud pubsub subscriptions create SUBSCRIPTION_ID \
    --topic=TOPIC_ID \
    --bigquery-table=PROJECT_ID:DATASET_ID.TABLE_ID

    Substitua:

    • SUBSCRIPTION_ID: especifica o ID da assinatura.
    • TOPIC_ID: especifica o ID do tópico. O tópico exige um esquema.
    • PROJECT_ID: especifica o ID do projeto.
    • DATASET_ID: especifica o ID de um conjunto de dados atual. Para criar um conjunto de dados, consulte Criar conjuntos de dados.
    • TABLE_ID: especifica o ID de uma tabela existente. A tabela precisa de um campo data se o tópico não tiver um esquema. Para criar uma tabela, consulte Criar uma tabela vazia com uma definição de esquema.

C++

Antes de testar esta amostra, siga as instruções de configuração do C++ no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub C++.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

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& table_id) {
  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_bigquery_config()->set_table(table_id);
  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";
}

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub C#.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 


using Google.Cloud.PubSub.V1;

public class CreateBigQuerySubscriptionSample
{
    public Subscription CreateBigQuerySubscription(string projectId, string topicId, string subscriptionId, string bigqueryTableId)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
        SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);

        var subscriptionRequest = new Subscription
        {
            SubscriptionName = subscriptionName,
            TopicAsTopicName = topicName,
            BigqueryConfig = new BigQueryConfig
            {
                Table = bigqueryTableId
            }
        };
        var subscription = subscriber.CreateSubscription(subscriptionRequest);
        return subscription;
    }
}

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Go.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

import (
	"context"
	"fmt"
	"io"

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

// createBigQuerySubscription creates a Pub/Sub subscription that exports messages to BigQuery.
func createBigQuerySubscription(w io.Writer, projectID, subID string, topic *pubsub.Topic, table string) error {
	// projectID := "my-project-id"
	// subID := "my-sub"
	// topic of type https://godoc.org/cloud.google.com/go/pubsub#Topic
	// table := "my-project-id.dataset_id.table_id"
	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,
		BigQueryConfig: pubsub.BigQueryConfig{
			Table:         table,
			WriteMetadata: true,
		},
	})
	if err != nil {
		return fmt.Errorf("client.CreateSubscription: %w", err)
	}
	fmt.Fprintf(w, "Created BigQuery subscription: %v\n", sub)

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Java.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

import com.google.cloud.pubsub.v1.SubscriptionAdminClient;
import com.google.pubsub.v1.BigQueryConfig;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.ProjectTopicName;
import com.google.pubsub.v1.Subscription;
import java.io.IOException;

public class CreateBigQuerySubscriptionExample {
  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 bigqueryTableId = "your-project.your-dataset.your-table";

    createBigQuerySubscription(projectId, topicId, subscriptionId, bigqueryTableId);
  }

  public static void createBigQuerySubscription(
      String projectId, String topicId, String subscriptionId, String bigqueryTableId)
      throws IOException {
    try (SubscriptionAdminClient subscriptionAdminClient = SubscriptionAdminClient.create()) {

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

      BigQueryConfig bigqueryConfig =
          BigQueryConfig.newBuilder().setTable(bigqueryTableId).setWriteMetadata(true).build();

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

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

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';
// const bigqueryTableId = 'YOUR_TABLE_ID';

// Imports the Google Cloud client library
const {PubSub} = require('@google-cloud/pubsub');

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

async function createBigQuerySubscription(
  topicNameOrId,
  subscriptionNameOrId,
  bigqueryTableId
) {
  const options = {
    bigqueryConfig: {
      table: bigqueryTableId,
      writeMetadata: true,
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);

  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';
// const bigqueryTableId = 'YOUR_TABLE_ID';

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

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

async function createBigQuerySubscription(
  topicNameOrId: string,
  subscriptionNameOrId: string,
  bigqueryTableId: string
) {
  const options: CreateSubscriptionOptions = {
    bigqueryConfig: {
      table: bigqueryTableId,
      writeMetadata: true,
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);

  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

PHP

Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub PHP.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

use Google\Cloud\PubSub\PubSubClient;
use Google\Cloud\PubSub\V1\BigQueryConfig;

/**
 * Creates a Pub/Sub BigQuery 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 $table      The BigQuery table to which to write.
 */
function create_bigquery_subscription($projectId, $topicName, $subscriptionName, $table)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);
    $topic = $pubsub->topic($topicName);
    $subscription = $topic->subscription($subscriptionName);
    $config = new BigQueryConfig(['table' => $table]);
    $subscription->create([
        'bigqueryConfig' => $config
    ]);

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

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Python.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

from google.cloud import pubsub_v1

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# bigquery_table_id = "your-project.your-dataset.your-table"

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)

bigquery_config = pubsub_v1.types.BigQueryConfig(
    table=bigquery_table_id, write_metadata=True
)

# 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,
            "bigquery_config": bigquery_config,
        }
    )

print(f"BigQuery subscription created: {subscription}.")
print(f"Table for subscription is: {bigquery_table_id}")

Ruby

Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido do Pub/Sub: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub Ruby.

Para autenticar no Pub/Sub, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

require "google/cloud/pubsub"

##
# Shows how to create a BigQuery subscription where messages published
# to a topic populates a BigQuery table.
#
# @param project_id [String]
# Your Google Cloud project (e.g. "my-project")
# @param topic_id [String]
# Your topic name (e.g. "my-secret")
# @param subscription_id [String]
# ID for new subscription to be created (e.g. "my-subscription")
# @param bigquery_table_id [String]
# ID of bigquery table (e.g "my-project:dataset-id.table-id")
#
def pubsub_create_bigquery_subscription project_id:, topic_id:, subscription_id:, bigquery_table_id:
  pubsub = Google::Cloud::Pubsub.new project_id: project_id
  topic = pubsub.topic topic_id
  subscription = topic.subscribe subscription_id,
                                 bigquery_config: {
                                   table: bigquery_table_id,
                                   write_metadata: true
                                 }
  puts "BigQuery subscription created: #{subscription_id}."
  puts "Table for subscription is: #{bigquery_table_id}"
end

Monitorar uma assinatura do BigQuery

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