Criar assinaturas do BigQuery

Tabela

1. No Trusted Cloud console, acesse o BigQuery Studio.

   Acessar o BigQuery Studio

2. Na caixa de pesquisa do painel "Explorador" chamada Filtrar por nome e rótulos, digite o nome da tabela e pressione Enter.

3. Clique na tabela em que você quer conceder permissão.

4. Na tabela, selecione more_vert Mais ações > Compartilhar > Permissões.

   Ou clique na tabela e, na página principal, clique em Compartilhamento > Permissões.

   A janela Permissões de compartilhamento é aberta.

5. Clique em Adicionar principal.

6. Em Adicionar principais, insira o nome do agente de serviço do Pub/Sub para o projeto que contém a assinatura. O formato do agente de serviço é service-project-number@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com. Por exemplo, para um projeto com project-number=112233445566, o agente de serviço tem o formato service-112233445566@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

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

8. Clique em Salvar.

Projeto

1. No console Trusted Cloud , acesse a página IAM.

   Acessar IAM

2. Clique em Conceder acesso.

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

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

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

6. Clique em Salvar.

Conta de serviço

1. No console Trusted 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 do agente de serviço do Pub/Sub para o projeto que contém a assinatura. O formato do agente de serviço é service-project-number@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com. Por exemplo, para um projeto com project-number=112233445566, o agente de serviço tem o formato service-112233445566@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

7. No menu suspenso Selecionar um papel, insira Service Account e selecione o papel Criador de token de conta de serviço.

8. Clique em Salvar.

Projeto

1. No console Trusted Cloud , acesse 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 personalizada.

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

5. No menu suspenso Selecionar um papel, insira Service Account e selecione o papel Criador de token de conta de serviço.

6. Clique em Salvar.

Console

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

   Acessar "Assinaturas"

2. Clique em Criar assinatura.

3. No campo ID da assinatura, insira um nome. Para informações sobre como nomear uma assinatura, 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 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. Para informações sobre como criar uma tabela, consulte Criar tabelas.

9. Recomendamos ativar o envio para fila de mensagens inativas para lidar com 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 Trusted Cloud , acesse a página Tópicos.

   Acesse Tópicos

2. Clique em more_vert ao lado do tópico em que 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. Para informações sobre como criar um conjunto de dados, consulte Como criar tabelas.

8. Recomendamos ativar o envio para fila de mensagens inativas para lidar com falhas de mensagens. Para mais informações, consulte Tópico de mensagens inativas.

9. Clique em Criar.

gcloud

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

   Activate Cloud Shell

   1. 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
      

      Se você quiser usar uma conta de serviço personalizada, forneça-a como um argumento adicional:

      gcloud pubsub subscriptions create SUBSCRIPTION_ID \
          --topic=TOPIC_ID \
          --bigquery-table=PROJECT_ID.DATASET_ID.TABLE_ID 
          --bigquery-service-account-email=SERVICE_ACCOUNT_NAME
      

      Substitua:

      • SUBSCRIPTION_ID: especifica o ID da assinatura.
      • TOPIC_ID: especifica o ID do tema. O tópico exige um esquema.
      • PROJECT_ID: especifica o ID do projeto.
      • DATASET_ID: especifica o ID de um conjunto de dados existente. Para criar um conjunto de dados, consulte Criar conjuntos de dados.
      • TABLE_ID: especifica o ID de uma tabela atual. 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.
      • SERVICE_ACCOUNT_NAME: especifica o nome da conta de serviço a ser usada para gravar no BigQuery.

   C++

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

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

   
   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

   O exemplo a seguir usa a versão principal da biblioteca de cliente do Go Pub/Sub (v2). Se você ainda estiver usando a biblioteca v1, consulte o guia de migração para a v2. Para conferir uma lista de exemplos de código da v1, consulte os exemplos de código descontinuados.

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

   import (
   	"context"
   	"fmt"
   	"io"
   
   	"cloud.google.com/go/pubsub/v2"
   	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
   )
   
   // createBigQuerySubscription creates a Pub/Sub subscription that exports messages to BigQuery.
   func createBigQuerySubscription(w io.Writer, projectID, topic, subscription, table string) error {
   	// projectID := "my-project"
   	// topic := "projects/my-project-id/topics/my-topic"
   	// subscription := "projects/my-project/subscriptions/my-sub"
   	// 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.SubscriptionAdminClient.CreateSubscription(ctx, &pubsubpb.Subscription{
   		Name:  subscription,
   		Topic: topic,
   		BigqueryConfig: &pubsubpb.BigQueryConfig{
   			Table:         table,
   			WriteMetadata: true,
   		},
   	})
   	if err != nil {
   		return fmt.Errorf("failed to create subscription: %w", err)
   	}
   	fmt.Fprintf(w, "Created BigQuery subscription: %v\n", sub)
   
   	return nil
   }
   

   Java

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

   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

   Antes de tentar essa amostra, siga as instruções de configuração do Node.js em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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.ts

   Antes de tentar essa amostra, siga as instruções de configuração do Node.js em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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 tentar esse exemplo, siga as instruções de configuração do PHP em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub PHP.

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

   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

   O exemplo a seguir usa a biblioteca de cliente do Ruby Pub/Sub v3. Se você ainda estiver usando a biblioteca v2, consulte o guia de migração para a v3. Para conferir uma lista de exemplos de código do Ruby v2, consulte os exemplos de código descontinuados.

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

   # project_id = "your-project-id"
   # topic_id = "your-topic-id"
   # subscription_id = "your-subscription-id"
   # bigquery_table_id = "my-project:dataset-id.table-id"
   
   pubsub = Google::Cloud::PubSub.new project_id: project_id
   subscription_admin = pubsub.subscription_admin
   
   subscription = subscription_admin.create_subscription \
     name: pubsub.subscription_path(subscription_id),
     topic: pubsub.topic_path(topic_id),
     bigquery_config: {
       table: bigquery_table_id,
       write_metadata: true
     }
   
   puts "BigQuery subscription created: #{subscription_id}."
   puts "Table for subscription is: #{bigquery_table_id}"