Creare sottoscrizioni BigQuery

Tabella

1. Nella console Trusted Cloud , vai a BigQuery Studio.

   Vai a BigQuery Studio

2. Nella casella di ricerca del riquadro Explorer con l'etichetta Filtra per nome ed etichette, digita il nome della tabella e premi Invio.

3. Fai clic sulla tabella a cui vuoi concedere l'autorizzazione.

4. Per la tabella, seleziona more_vert Altre azioni > Condividi > Autorizzazioni.

   In alternativa, fai clic sulla tabella e nella pagina principale fai clic su Condivisione > Autorizzazioni.

   Si apre la finestra Autorizzazioni di condivisione.

5. Fai clic su Aggiungi entità.

6. In Aggiungi entità, inserisci il nome dell'agente di servizio Pub/Sub per il progetto contenente l'abbonamento. Il formato dell'agente di servizio è service-project-number@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com. Ad esempio, per un progetto con project-number=112233445566, l'agente di servizio ha il formato service-112233445566@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

7. Nel menu a discesa Seleziona un ruolo, inserisci BigQuery e seleziona il ruolo Editor dati BigQuery.

8. Fai clic su Salva.

Progetto

1. Nella console Trusted Cloud , vai alla pagina IAM.

   Vai a IAM

2. Fai clic su Concedi accesso.

3. Nella sezione Aggiungi entità, inserisci il nome dell'agente di servizio Pub/Sub. Il formato dell'agente di servizio è service-project-number@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com. Ad esempio, per un progetto con project-number=112233445566, l'agente di servizio ha il formato service-112233445566@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

4. Nella sezione Assegna ruoli, fai clic su Aggiungi un altro ruolo.

5. Nel menu a discesa Seleziona un ruolo, inserisci BigQuery e seleziona il ruolo Editor dati BigQuery.

6. Fai clic su Salva.

Service account

1. Nella Trusted Cloud console, vai alla pagina Service account.

   Vai ad Account di servizio

2. Inserisci il nome del account di servizio personalizzato nel Filtro.

3. Seleziona l'account di servizio dall'elenco.

4. Fai clic su Entità con accesso.

5. Fai clic su Concedi accesso.

6. Nella sezione Aggiungi entità, inserisci il nome dell'agente di servizio Pub/Sub per il progetto contenente l'abbonamento. Il formato dell'agente di servizio è service-project-number@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com. Ad esempio, per un progetto con project-number=112233445566, l'agente di servizio ha il formato service-112233445566@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

7. Nel menu a discesa Seleziona un ruolo, inserisci Service Account e seleziona il ruolo Creatore token account di servizio.

8. Fai clic su Salva.

Progetto

1. Nella console Trusted Cloud , vai alla pagina IAM.

   Vai a IAM

2. Fai clic su Concedi accesso.

3. Nella sezione Aggiungi entità, inserisci il nome del tuo account di servizio personalizzato.

4. Nella sezione Assegna ruoli, fai clic su Aggiungi un altro ruolo.

5. Nel menu a discesa Seleziona un ruolo, inserisci Service Account e seleziona il ruolo Creatore token account di servizio.

6. Fai clic su Salva.

Console

1. Nella console Trusted Cloud , vai alla pagina Abbonamenti.

   Vai agli abbonamenti

2. Fai clic su Crea sottoscrizione.

3. Per il campo ID sottoscrizione, inserisci un nome. Per informazioni su come denominare un abbonamento, consulta le linee guida per assegnare un nome a un argomento o a un abbonamento.

4. Scegli o crea un argomento dal menu a discesa. La sottoscrizione riceve i messaggi dall'argomento.

5. Seleziona Tipo di pubblicazione come Scrivi su BigQuery.

6. Seleziona il progetto per la tabella BigQuery.

7. Seleziona un set di dati esistente o creane uno nuovo. Per informazioni su come creare un set di dati, consulta Creazione di set di dati.

8. Seleziona una tabella esistente o creane una nuova. Per informazioni su come creare una tabella, vedi Creare tabelle.

9. Ti consigliamo vivamente di attivare la coda di messaggi non recapitabili per gestire gli errori dei messaggi. Per saperne di più, consulta Argomento di messaggi non recapitabili.

10. Fai clic su Crea.

Puoi anche creare una sottoscrizione dalla pagina Argomenti. Questa scorciatoia è utile per associare argomenti alle sottoscrizioni.

1. Nella console Trusted Cloud , vai alla pagina Argomenti.

   Vai ad Argomenti

2. Fai clic su more_vert accanto all'argomento per cui vuoi creare un abbonamento.

3. Dal menu contestuale, seleziona Crea abbonamento.

4. Seleziona Tipo di pubblicazione come Scrivi su BigQuery.

5. Seleziona il progetto per la tabella BigQuery.

6. Seleziona un set di dati esistente o creane uno nuovo. Per informazioni su come creare un set di dati, consulta Creazione di set di dati.

7. Seleziona una tabella esistente o creane una nuova. Per informazioni su come creare un set di dati, vedi Creare tabelle.

8. Ti consigliamo vivamente di attivare la coda di messaggi non recapitabili per gestire gli errori dei messaggi. Per saperne di più, consulta Argomento di messaggi non recapitabili.

9. Fai clic su Crea.

gcloud

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

   Activate Cloud Shell

   1. Per creare una sottoscrizione Pub/Sub, utilizza il comando gcloud pubsub subscriptions create:

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

      Se vuoi utilizzare un account di servizio personalizzato, forniscilo come argomento aggiuntivo:

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

      Sostituisci quanto segue:

      • SUBSCRIPTION_ID: specifica l'ID dell'abbonamento.
      • TOPIC_ID: specifica l'ID dell'argomento. L'argomento richiede uno schema.
      • PROJECT_ID: specifica l'ID del progetto.
      • DATASET_ID: specifica l'ID di un set di dati esistente. Per creare un set di dati, vedi Creare set di dati.
      • TABLE_ID: specifica l'ID di una tabella esistente. Se l'argomento non ha uno schema, la tabella richiede un campo data. Per creare una tabella, vedi Creare una tabella vuota con una definizione dello schema.
      • SERVICE_ACCOUNT_NAME: specifica il nome dell'account di servizio da utilizzare per scrivere in BigQuery.

   C++

   Prima di provare questo esempio, segui le istruzioni di configurazione di C++ nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'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#

   Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'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;
       }
   }

   Vai

   L'esempio seguente utilizza la versione principale della libreria client Go Pub/Sub (v2). Se utilizzi ancora la libreria v1, consulta la guida alla migrazione alla v2. Per visualizzare un elenco di esempi di codice della versione 1, consulta gli esempi di codice ritirati.

   Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

   Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Java di 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

   Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella Guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

   Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella Guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

   Prima di provare questo esempio, segui le istruzioni di configurazione di PHP nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

   Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

   Il seguente esempio utilizza la libreria client Ruby Pub/Sub v3. Se utilizzi ancora la libreria v2, consulta la guida alla migrazione alla v3. Per visualizzare un elenco di esempi di codice Ruby v2, consulta gli esempi di codice ritirati.

   Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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}"