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, certifique-se de que você esteja familiarizado com o seguinte:

Além da sua familiaridade com o Pub/Sub e BigQuery, verifique se você atende aos seguintes pré-requisitos antes de criar uma assinatura do BigQuery:

  • Existe uma tabela do BigQuery. Como alternativa, crie um ao criar a assinatura do BigQuery, conforme descrito em nas próximas seções deste documento.

  • a compatibilidade entre o esquema do tópico do Pub/Sub e na tabela do BigQuery. Se você adicionar um bloco de anúncios Tabela do BigQuery, você recebe um erro relacionado à compatibilidade mensagem. Para mais informações, consulte Compatibilidade do esquema.

Papéis e permissões necessárias

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

  • Para criar uma assinatura, você precisa configurar o controle de acesso no projeto nível

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

  • Para criar uma assinatura do BigQuery, A conta de serviço do Pub/Sub precisa ter permissão para gravar no uma 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 gravar em uma tabela do BigQuery em um projeto diferente.

Para ter as permissões necessárias para criar assinaturas do BigQuery, peça ao administrador para conceder a você Papel do IAM Editor do Pub/Sub (roles/pubsub.editor) no projeto. Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

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
  • Crie uma assinatura: pubsub.subscriptions.create
  • Para excluir uma assinatura: pubsub.subscriptions.delete
  • Assinar uma assinatura: pubsub.subscriptions.get
  • Para listar uma assinatura: pubsub.subscriptions.list
  • Atualizar uma assinatura: pubsub.subscriptions.update
  • Anexe uma assinatura a um tópico: pubsub.topics.attachSubscription
  • Para receber a política do IAM de 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 modelos do BigQuery assinaturas de um projeto que estão associadas a um tópico em outro projeto, peça ao administrador do tópico para conceder a você o papel Editor do Pub/Sub (roles/pubsub.editor) no tópico.

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

Alguns serviços do Google Cloud têm contas serviço gerenciado pelo Google Cloud, o que permite e serviços acessem seus recursos. Essas contas de serviço são conhecidos como agentes de serviço. O Pub/Sub cria e mantém 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 precisa ter permissão para gravar à tabela específica do BigQuery e ler os metadados dela.

Conceder ao 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 do seu Pub/Sub conta de serviço. O formato da conta de serviço é service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com. Por exemplo, a conta de serviço tem o formato service-112233445566@gcp-sa-pubsub.iam.gserviceaccount.com para um projeto com project-number=112233445566.

  4. Na seção Atribuir papéis, clique em Adicionar outro papel.

  5. No menu suspenso Selecionar papel, insira BigQuery. e selecione o papel Editor de dados do BigQuery.

  6. Clique em Salvar.

Para mais informações sobre o IAM do BigQuery, consulte Permissões e papéis do BigQuery.

Propriedades da assinatura do BigQuery

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

Propriedades comuns

Saiba mais sobre as propriedades comuns de assinaturas que você pode definir 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 a que o em anexo. Além disso, o Pub/Sub grava os campos nas mensagens para a colunas na tabela do BigQuery.

Ao usar essa opção, lembre-se de verificar os seguintes requisitos adicionais:

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

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

  • Os campos obrigatórios no esquema de tópicos não precisam ser necessários no esquema do BigQuery.

  • Se houver campos do BigQuery que não estão presentes no esquema de tópicos, esses campos do BigQuery precisa estar no modo NULLABLE.

  • Se o esquema de tópicos tiver campos adicionais que não estão presentes no esquema do BigQuery, campos podem ser descartados, selecione a opção Descartar campos desconhecidos.

  • É possível selecionar apenas uma das propriedades de assinatura: Usar esquema de tópicos 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 digite BYTES, STRING ou JSON. O Pub/Sub grava a mensagem essa coluna do BigQuery.

Talvez você não veja alterações no esquema de tópicos do Pub/Sub ou O esquema da tabela do BigQuery entra em vigor imediatamente com mensagens gravados na tabela do BigQuery. Por exemplo, se Drop a opção de campos desconhecidos está ativada e há um campo presente na o esquema do Pub/Sub, mas não o do BigQuery, mensagens gravadas na tabela do BigQuery podem não conter depois de adicioná-lo ao esquema do BigQuery. Em algum momento, os esquemas serão sincronizados, e as mensagens subsequentes incluirão o campo.

Quando você usa a opção Usar esquema de tópicos no BigQuery, você também pode aproveitar as vantagens do BigQuery de captura de dados (CDC). O CDC atualiza suas tabelas do BigQuery processar e aplicar alterações às linhas existentes.

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

Para aprender a usar esse recurso com assinaturas do BigQuery, consulte Captura de dados alterados do BigQuery.

Usar esquema de tabela

Essa opção permite que o Pub/Sub use o esquema do tabela do BigQuery para gravar os campos de uma às colunas correspondentes. Ao usar essa opção, lembre-se de verifique os seguintes requisitos adicionais:

  • As mensagens publicadas precisam estar no formato JSON.

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

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

  • Se as mensagens tiverem campos adicionais que não estejam presentes no esquema do BigQuery e esses campos possam ser descartados, selecione o opção Descartar campos desconhecidos.

  • Na mensagem JSON, os valores DATE, DATETIME, TIME e TIMESTAMP precisam ser números inteiros que estejam de acordo com as representações compatíveis.

  • Na mensagem JSON, os valores NUMERIC e BIGNUMERIC precisam ser bytes codificados usando o BigDecimalByteStringEncoder.

  • É possível selecionar apenas uma das propriedades de assinatura: Usar esquema de tópicos 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 digite BYTES, STRING ou JSON. O Pub/Sub grava a mensagem essa coluna do BigQuery.

Talvez você não note que as alterações no esquema da tabela do BigQuery imediatamente com mensagens gravadas na tabela do BigQuery. Por exemplo, se a opção Descartar campos desconhecidos estiver ativada e um campo for presentes nas mensagens, mas não no esquema do BigQuery, mensagens gravadas na tabela do BigQuery podem não conter depois de adicioná-lo ao esquema do BigQuery. Em algum momento, o esquema será sincronizado, e as mensagens subsequentes incluirão o campo.

Ao usar a opção Usar esquema de tabela para sua assinatura do BigQuery, você também pode aproveitar a captura de dados alterados (CDC) do BigQuery. O CDC atualiza as tabelas do BigQuery processando e aplicando alterações a tabelas linhas

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

Para saber como usar esse recurso com assinaturas do BigQuery, consulte Captura de dados alterados do BigQuery.

Remover campos desconhecidos

Essa opção é utilizada com as opções Usar esquema de tópicos ou Usar esquema de tabela. é a melhor opção. Essa opção permite que o Pub/Sub remova qualquer campo presente no tópico ou mensagem, mas não no esquema do BigQuery. Sem Drop desconhecido campos definidos, as mensagens com campos extras não são gravadas ao BigQuery e permanecer no backlog das assinaturas. O assinatura acaba em estado de erro.

Gravar metadados

Essa opção permite que o Pub/Sub gravar os metadados de cada mensagem em colunas adicionais na Tabela do BigQuery. Caso contrário, os metadados não é gravado na tabela do BigQuery.

Se você selecionar a opção Gravar metadados, verifique se o 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 exigirá apenas o campo data, a menos que o campo seja data. use_topic_schema é verdadeiro. Se você selecionar os campos Metadados de gravação e Use as opções de esquema de tópicos, o esquema do tópico deverá não conter campos com nomes que correspondam aos dos parâmetros de metadados. Essa limitação inclui versões camelcase desses parâmetros de snake case.

Parâmetros
subscription_name

STRING

Nome de uma assinatura.
message_id

STRING

ID de uma mensagem
publish_time

TIMESTAMP

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

BYTES, STRING ou JSON

O corpo da mensagem.

O campo data é obrigatório para todos os destinos Tabelas do BigQuery que não selecionam Usar esquema de tópicos ou Usar esquema de tabela. Se o campo é do tipo JSON, o corpo da mensagem deve ser JSON válido.
attributes

STRING ou JSON

Um objeto JSON que contém todos os atributos de mensagem. Ela também contém campos adicionais que fazem parte Mensagem do Pub/Sub, incluindo a chave de ordem, se estiver presente.

Criar uma assinatura do BigQuery

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

Console

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

    Ir para Assinaturas

  2. Clique em Criar assinatura.
  3. Insira um nome no campo ID da assinatura.

    Para informações sobre como nomear uma inscrição, consulte 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 o Tipo de entrega como Gravar em no BigQuery.
  6. Selecione o projeto para a tabela do BigQuery.
  7. Selecione um conjunto de dados ou crie um novo.

    Para informações sobre como criar um conjunto de dados, consulte Como criar conjuntos de dados.

  8. Selecione uma tabela ou crie uma nova.

    Para informações sobre como criar uma tabela, consulte Como criar tabelas.

  9. Recomendamos que você ative a opção morta o uso de letras para lidar com falhas de mensagens.

    Para mais informações, consulte Inativos tópico de letras.

  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 Topics página.

    Ir para Tópicos

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

    Para informações sobre como criar um conjunto de dados, consulte Como criar conjuntos de dados.

  7. Selecione uma tabela ou crie uma nova.

    Para informações sobre como criar um conjunto de dados, consulte Como criar tabelas.

  8. Recomendamos que você ative a opção morta o uso de letras para lidar com falhas de mensagens.

    Para mais informações, consulte Inativos tópico de letras.

  9. Clique em Criar.

gcloud

  1. No Console do Google Cloud, ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

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

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

    Substitua:

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

C++

Antes de testar este exemplo, siga as instruções de configuração do C++ na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API C++ do Pub/Sub documentação de referência.

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 este exemplo, siga as instruções de configuração do C# na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API C# do Pub/Sub documentação de referência.

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 este exemplo, siga as instruções de configuração do Go na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API Go do Pub/Sub documentação de referência.

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 este exemplo, siga as instruções de configuração do Java na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API Java do Pub/Sub documentação de referência.

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 este exemplo, siga as instruções de configuração do PHP na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API PHP do Pub/Sub documentação de referência.

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 este exemplo, siga as instruções de configuração do Python na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API Python do Pub/Sub documentação de referência.

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 este exemplo, siga as instruções de configuração do Ruby na Guia de início rápido do Pub/Sub usando bibliotecas de cliente. Para mais informações, consulte a API Ruby do Pub/Sub documentação de referência.

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

A seguir