Crie subscrições do BigQuery

Tabela

1. Na Trusted Cloud consola, aceda ao BigQuery Studio.

   Aceda ao BigQuery Studio

2. Na caixa de pesquisa do painel Explorador com a etiqueta Filtrar por nome e etiquetas, introduza o nome da tabela e prima Enter.

3. Clique na tabela à qual quer conceder autorização.

4. Para a tabela, selecione more_vert Mais ações > Partilhar > Autorizações.

   Em alternativa, clique na tabela e, na página principal, clique em Partilha > Autorizações.

   É apresentada a janela Autorizações de partilha.

5. Clique em Adicionar principal.

6. Em Adicionar responsáveis, introduza o nome do agente do serviço do Pub/Sub para o projeto que contém a subscrição. O formato do agente do serviço é service-project-number@gcp-sa-pubsub.s3ns.iam.gserviceaccount.com. Por exemplo, para um projeto com project-number=112233445566, o agente do serviço tem o formato service-112233445566@gcp-sa-pubsub.s3ns.iam.gserviceaccount.com.

7. No menu pendente Selecionar uma função, introduza BigQuery, e selecione a função Editor de dados do BigQuery.

8. Clique em Guardar.

Projeto

1. Na Trusted Cloud consola, aceda à página IAM.

   Aceda ao IAM

2. Clique em Conceder acesso.

3. Na secção Adicionar responsáveis, introduza o nome do agente do serviço Pub/Sub. O formato do agente do serviço é service-project-number@gcp-sa-pubsub.s3ns.iam.gserviceaccount.com. Por exemplo, para um projeto com project-number=112233445566, o agente do serviço tem o formato service-112233445566@gcp-sa-pubsub.s3ns.iam.gserviceaccount.com.

4. Na secção Atribuir funções, clique em Adicionar outra função.

5. No menu pendente Selecionar uma função, introduza BigQuery, e selecione a função Editor de dados do BigQuery.

6. Clique em Guardar.

Conta de serviço

1. Na Trusted Cloud consola, aceda à página Contas de serviço.

   Aceda a Contas de serviço

2. Introduza 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 secção Adicionar responsáveis, introduza o nome do agente do serviço Pub/Sub para o projeto que contém a subscrição. O formato do agente de serviço é service-project-number@gcp-sa-pubsub.s3ns.iam.gserviceaccount.com. Por exemplo, para um projeto com project-number=112233445566, o agente do serviço tem o formato service-112233445566@gcp-sa-pubsub.s3ns.iam.gserviceaccount.com.

7. No menu pendente Selecionar uma função, introduza Service Account, e selecione a função Criador de tokens de contas de serviços.

8. Clique em Guardar.

Projeto

1. Na Trusted Cloud consola, aceda à página IAM.

   Aceda ao IAM

2. Clique em Conceder acesso.

3. Na secção Adicionar membros, introduza o nome da sua conta de serviço personalizada.

4. Na secção Atribuir funções, clique em Adicionar outra função.

5. No menu pendente Selecionar uma função, introduza Service Account, e selecione a função Criador de tokens de contas de serviços.

6. Clique em Guardar.

Consola

1. Na Trusted Cloud consola, aceda à página Subscrições.

   Aceder a Subscrições

2. Clique em Criar subscrição.

3. No campo ID da subscrição, introduza um nome. Para obter informações sobre como atribuir um nome a uma subscrição, consulte as diretrizes para atribuir um nome a um tópico ou a uma subscrição.

4. Escolha ou crie um tópico no menu pendente. A subscrição recebe mensagens do tópico.

5. Selecione Tipo de fornecimento como Escrever no BigQuery.

6. Selecione o projeto da tabela do BigQuery.

7. Selecione um conjunto de dados existente ou crie um novo. Para obter informações sobre como criar um conjunto de dados, consulte o artigo Criar conjuntos de dados.

8. Selecione uma tabela existente ou crie uma nova. Para obter informações sobre como criar uma tabela, consulte o artigo Criar tabelas.

9. Recomendamos vivamente que ative a Dead lettering para processar falhas de mensagens. Para mais informações, consulte o artigo Tópico de mensagens não entregues.

10. Clique em Criar.

Também pode criar uma subscrição na página Tópicos. Este atalho é útil para associar tópicos a subscrições.

1. Na Trusted Cloud consola, aceda à página Tópicos.

   Aceda a Tópicos

2. Clique em more_vert junto ao tópico para o qual quer criar uma subscrição.

3. No menu de contexto, selecione Criar subscrição.

4. Selecione Tipo de fornecimento como Escrever no BigQuery.

5. Selecione o projeto da tabela do BigQuery.

6. Selecione um conjunto de dados existente ou crie um novo. Para obter informações sobre como criar um conjunto de dados, consulte o artigo Criar conjuntos de dados.

7. Selecione uma tabela existente ou crie uma nova. Para ver informações sobre como criar um conjunto de dados, consulte o artigo Criar tabelas.

8. Recomendamos vivamente que ative a Dead lettering para processar falhas de mensagens. Para mais informações, consulte o artigo Tópico de mensagens não entregues.

9. Clique em Criar.

gcloud

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

   Activate Cloud Shell

   1. Para criar uma subscrição 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 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 o seguinte:

      • SUBSCRIPTION_ID: especifica o ID da subscrição.
      • TOPIC_ID: especifica o ID do tópico. O tópico requer 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 o artigo Crie conjuntos de dados.
      • TABLE_ID: especifica o ID de uma tabela existente. A tabela requer um campo data se o seu tópico não tiver um esquema. Para criar uma tabela, consulte o artigo Crie uma tabela vazia com uma definição de esquema.
      • SERVICE_ACCOUNT_NAME: especifica o nome da conta de serviço a usar para escrever no BigQuery.

   C++

   Antes de experimentar este exemplo, siga as instruções de configuração do C++ no artigo Início rápido: usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API C++ do Pub/Sub.

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

   
   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;
       }
   }

   Ir

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

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

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

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

   /**
    * 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 experimentar este exemplo, siga as instruções de configuração do Node.js em Início rápido: usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js do Pub/Sub.

   /**
    * 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 experimentar este exemplo, siga as instruções de configuração do PHP no artigo Início rápido: usar bibliotecas cliente. Para mais informações, consulte a documentação de referência da API PHP Pub/Sub.

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

   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 seguinte usa a biblioteca cliente Ruby Pub/Sub v3. Se ainda estiver a usar a biblioteca v2, consulte o guia de migração para a v3. Para ver uma lista de exemplos de código do Ruby v2, consulte os exemplos de código descontinuados.

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

   # 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}"