Creare sottoscrizioni BigQuery

Questo documento descrive come creare un abbonamento BigQuery. Puoi utilizzare la console Google Cloud , Google Cloud CLI, la libreria client o l'API Pub/Sub per creare una sottoscrizione BigQuery.

Prima di iniziare

Prima di leggere questo documento, assicurati di conoscere quanto segue:

Oltre alla tua familiarità con Pub/Sub e BigQuery, assicurati di soddisfare i seguenti prerequisiti prima di creare una sottoscrizione BigQuery:

  • Esiste una tabella BigQuery. In alternativa, puoi crearne uno quando crei l'abbonamento BigQuery, come descritto nelle sezioni successive di questo documento.

  • Compatibilità tra lo schema dell'argomento Pub/Sub e la tabella BigQuery. Se aggiungi una tabella BigQuery non compatibile, viene visualizzato un messaggio di errore relativo alla compatibilità. Per ulteriori informazioni, consulta la sezione Compatibilità dello schema.

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per creare una sottoscrizione BigQuery, chiedi all'amministratore di concederti il ruolo IAM Pub/Sub Editor (roles/pubsub.editor) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare un abbonamento BigQuery. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare un abbonamento BigQuery sono necessarie le seguenti autorizzazioni:

  • pubsub.subscriptions.create sul progetto
  • pubsub.topics.attachSubscription sull'argomento

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Abbonamenti tra progetti

Se crei una sottoscrizione in un progetto per un argomento in un altro progetto, devi disporre dell'autorizzazione pubsub.subscriptions.create sul progetto in cui stai creando la sottoscrizione e dell'autorizzazione pubsub.topics.attachSubscription sull'argomento.

Concedi ruoli IAM al account di servizio

Pub/Sub utilizza un account di servizio Identity and Access Management (IAM) per accedere alle risorse Google Cloud . Per impostazione predefinita, utilizza il service agent Pub/Sub (service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com).

Per consentire a Pub/Sub di scrivere in una tabella BigQuery, il account di servizio richiede il ruolo Editor dati BigQuery (roles/bigquery.dataEditor). Puoi concedere le autorizzazioni al account di servizio per il progetto o la tabella, nel seguente modo:

Progetto

  1. Nella console Google Cloud vai alla pagina IAM.

    Vai a IAM

  2. Seleziona Includi concessioni di ruoli fornite da Google.

  3. Trova la riga del account di servizio Cloud Pub/Sub e fai clic su Modifica entità.

  4. Fai clic su Aggiungi un altro ruolo e seleziona il ruolo Editor dati BigQuery.

Per maggiori informazioni, consulta Concedi un ruolo IAM utilizzando la console.

Tabella

  1. Nella console Google 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. Nei risultati di ricerca, fai clic sul nome della tabella a cui vuoi concedere l'autorizzazione.

  4. Nella scheda Dettagli, fai clic su Condividi > Gestisci autorizzazioni.

  5. Fai clic su Aggiungi entità, quindi inserisci l'identificatore del account di servizio nel seguente formato:

    service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com.

  6. Nell'elenco Assegna ruoli, seleziona BigQuery Data Editor.

  7. Fai clic su Salva. All'entità viene concesso il ruolo sulla risorsa.

Utilizzo di un account di servizio personalizzato

Se concedi il ruolo Editor dati BigQuery all'account di servizio Cloud Pub/Sub, qualsiasi utente che dispone dell'autorizzazione per creare un abbonamento nel tuo progetto può scrivere nella tabella BigQuery. Se vuoi fornire autorizzazioni più granulari, configura un service account gestito dall'utente.

Per configurare un service account gestito dall'utente per scrivere in BigQuery sono necessarie le seguenti autorizzazioni:

  • Il account di servizio gestito dall'utente deve avere il ruolo Editor dati BigQuery.

  • Il account di servizio Cloud Pub/Sub deve disporre dell'autorizzazione iam.serviceAccounts.getAccessToken sul service account gestito dall'utente.

  • L'utente che crea l'abbonamento deve disporre dell'autorizzazione iam.serviceAccounts.actAs sul account di servizio gestito dall'utente.

Quando crei la sottoscrizione, specifica il account di servizio gestito dall'utente come service account di sottoscrizione.

Proprietà delle sottoscrizioni BigQuery

Le sottoscrizioni BigQuery supportano tutte le proprietà di sottoscrizione comuni. Le sezioni seguenti descrivono le proprietà specifiche degli abbonamenti BigQuery.

Utilizza schema argomento

Questa opzione consente a Pub/Sub di utilizzare lo schema dell'argomento Pub/Sub a cui è collegata la sottoscrizione. Inoltre, Pub/Sub scrive i campi nei messaggi nelle colonne corrispondenti della tabella BigQuery.

Quando utilizzi questa opzione, ricorda di controllare i seguenti requisiti aggiuntivi:

  • I campi nello schema dell'argomento e nello schema BigQuery devono avere gli stessi nomi e i loro tipi devono essere compatibili tra loro.

  • Qualsiasi campo facoltativo nello schema dell'argomento deve essere facoltativo anche nello schema BigQuery.

  • I campi obbligatori nello schema dell'argomento non devono essere obbligatori nello schema BigQuery.

  • Se sono presenti campi BigQuery non presenti nello schema dell'argomento, questi campi BigQuery devono essere in modalità NULLABLE.

  • Se lo schema dell'argomento ha campi aggiuntivi che non sono presenti nello schema BigQuery e questi campi possono essere eliminati, seleziona l'opzione Elimina campi sconosciuti.

  • Puoi selezionare solo una delle proprietà dell'abbonamento, Usa schema argomento o Usa schema tabella.

Se non selezioni l'opzione Utilizza schema argomento o Utilizza schema tabella, assicurati che la tabella BigQuery abbia una colonna denominata data di tipo BYTES, STRING o JSON. Pub/Sub scrive il messaggio in questa colonna BigQuery.

Potresti non vedere immediatamente le modifiche allo schema degli argomenti Pub/Sub o allo schema della tabella BigQuery con i messaggi scritti nella tabella BigQuery. Ad esempio, se l'opzione Elimina campi sconosciuti è abilitata e un campo è presente nello schema Pub/Sub, ma non in quello BigQuery, i messaggi scritti nella tabella BigQuery potrebbero comunque non contenere il campo dopo averlo aggiunto allo schema BigQuery. Alla fine, gli schemi si sincronizzano e i messaggi successivi includono il campo.

Quando utilizzi l'opzione Utilizza lo schema dell'argomento per la sottoscrizione BigQuery, puoi anche usufruire dell'acquisizione dei dati delle modifiche (CDC) di BigQuery. CDC aggiorna le tabelle BigQuery elaborando e applicando le modifiche alle righe esistenti.

Per scoprire di più su questa funzionalità, vedi Aggiornare le tabelle di stream con l'acquisizione delle modifiche ai dati.

Per scoprire come utilizzare questa funzionalità con gli abbonamenti BigQuery, consulta Acquisizione delle modifiche ai dati di BigQuery.

Utilizza schema tabella

Questa opzione consente a Pub/Sub di utilizzare lo schema della tabella BigQuery per scrivere i campi di un messaggio JSON nelle colonne corrispondenti. Quando utilizzi questa opzione, ricordati di controllare i seguenti requisiti aggiuntivi:

  • I nomi di ogni colonna nella tabella BigQuery devono contenere solo lettere (a-z, A-Z), numeri (0-9) o trattini bassi (_).

  • I messaggi pubblicati devono essere in formato JSON.

    Se una colonna della tabella BigQuery ha il tipo di dati JSON, il campo corrispondente nel messaggio Pub/Sub deve essere un JSON valido in una stringa di escape. Ad esempio, per una colonna denominata myData, il campo del messaggio deve essere "myData": "{\"key\":\"value\"}". BigQuery rifiuta i messaggi che non contengono JSON valido.

  • Sono supportate le seguenti conversioni JSON:

    Tipo JSON Tipo di dati BigQuery
    string NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME o TIMESTAMP
    number NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME o TIMESTAMP
    • Quando utilizzi le conversioni number in DATE, DATETIME, TIME o TIMESTAMP, il numero deve rispettare le rappresentazioni supportate.
    • Quando utilizzi la conversione da number a NUMERIC o BIGNUMERIC, la precisione e l'intervallo di valori sono limitati a quelli accettati dallo standard IEEE 754 per l'aritmetica in virgola mobile. Se hai bisogno di un'elevata precisione o di una gamma più ampia di valori, utilizza le conversioni string in NUMERIC o BIGNUMERIC.
    • Quando utilizzi le conversioni da string a NUMERIC o BIGNUMERIC, Pub/Sub presuppone che la stringa sia un numero leggibile (ad es. "123.124"). Se l'elaborazione della stringa come numero leggibile non va a buon fine, Pub/Sub considera la stringa come byte codificati con BigDecimalByteStringEncoder.

  • Se all'argomento della sottoscrizione è associato uno schema, la proprietà di codifica dei messaggi deve essere impostata su JSON.

  • Se nei messaggi sono presenti campi BigQuery non presenti, questi campi BigQuery devono essere in modalità NULLABLE.

  • Se i messaggi hanno campi aggiuntivi non presenti nello schema BigQuery e questi campi possono essere eliminati, seleziona l'opzione Elimina campi sconosciuti.

  • Puoi selezionare solo una delle proprietà dell'abbonamento, Usa schema argomento o Usa schema tabella.

Se non selezioni l'opzione Utilizza schema argomento o Utilizza schema tabella, assicurati che la tabella BigQuery abbia una colonna denominata data di tipo BYTES, STRING o JSON. Pub/Sub scrive il messaggio in questa colonna BigQuery.

Potresti non vedere immediatamente le modifiche allo schema della tabella BigQuery con i messaggi scritti nella tabella BigQuery. Ad esempio, se l'opzione Ignora campi sconosciuti è abilitata e un campo è presente nei messaggi, ma non nello schema BigQuery, i messaggi scritti nella tabella BigQuery potrebbero comunque non contenere il campo dopo averlo aggiunto allo schema BigQuery. Alla fine, lo schema viene sincronizzato e i messaggi successivi includono il campo.

Quando utilizzi l'opzione Usa schema tabella per la sottoscrizione BigQuery, puoi anche sfruttare l'acquisizione di dati di modifica (CDC) di BigQuery. CDC aggiorna le tabelle BigQuery elaborando e applicando le modifiche alle righe esistenti.

Per scoprire di più su questa funzionalità, vedi Aggiornare le tabelle di stream con l'acquisizione delle modifiche ai dati.

Per scoprire come utilizzare questa funzionalità con gli abbonamenti BigQuery, consulta Acquisizione delle modifiche ai dati di BigQuery.

Rilascia campi sconosciuti

Questa opzione viene utilizzata con l'opzione Utilizza schema argomento o Utilizza schema tabella. Se questa opzione è abilitata, Pub/Sub ignora qualsiasi campo presente nello schema dell'argomento o nel messaggio, ma non nello schema BigQuery. I campi che non fanno parte dello schema BigQuery vengono eliminati durante la scrittura del messaggio nella tabella BigQuery.

Se l'opzione Elimina campi sconosciuti non è impostata, i messaggi con campi aggiuntivi non vengono scritti in BigQuery e rimangono nel backlog della sottoscrizione, a meno che tu non configuri un argomento dei messaggi non recapitabili.

L'impostazione Ignora campi sconosciuti non influisce sui campi non definiti nello schema dell'argomento Pub/Sub o nello schema della tabella BigQuery. In questo caso, il messaggio Pub/Sub valido viene recapitato alla sottoscrizione. Tuttavia, poiché BigQuery non ha colonne definite per questi campi aggiuntivi, questi campi vengono eliminati durante il processo di scrittura BigQuery. Per evitare questo comportamento, assicurati che qualsiasi campo contenuto nel messaggio Pub/Sub sia contenuto anche nello schema della tabella BigQuery.

Il comportamento relativo ai campi aggiuntivi può dipendere anche dal tipo di schema specifico (Avro, buffer del protocollo) e dalla codifica (JSON, binaria) utilizzati. Per informazioni su come questi fattori influiscono sulla gestione dei campi aggiuntivi, consulta la documentazione relativa al tipo di schema e alla codifica specifici.

Scrivi metadati

Questa opzione consente a Pub/Sub di scrivere i metadati di ogni messaggio in colonne aggiuntive della tabella BigQuery. In caso contrario, i metadati non vengono scritti nella tabella BigQuery.

Se selezioni l'opzione Scrivi metadati, assicurati che la tabella BigQuery contenga i campi descritti nella tabella seguente.

Se non selezioni l'opzione Scrivi metadati, la tabella BigQuery di destinazione richiede solo il campo data, a meno che use_topic_schema non sia true. Se selezioni le opzioni Scrivi metadati e Utilizza schema argomento, lo schema dell'argomento non deve contenere campi con nomi corrispondenti a quelli dei parametri dei metadati. Questa limitazione include le versioni camel case di questi parametri snake case.

Parametri
subscription_name

STRING

Nome di un abbonamento.
message_id

STRING

ID di un messaggio
publish_time

TIMESTAMP

L'ora di pubblicazione di un messaggio.
data

BYTES, STRING o JSON

Il corpo del messaggio.

Il campo data è obbligatorio per tutte le tabelle BigQuery di destinazione che non selezionano Utilizza schema argomento o Utilizza schema tabella. Se il campo è di tipo JSON, il corpo del messaggio deve essere un JSON valido.
attributes

STRING o JSON

Un oggetto JSON contenente tutti gli attributi del messaggio. Contiene anche campi aggiuntivi che fanno parte del messaggio Pub/Sub, inclusa la chiave di ordinamento, se presente.

Service account

Hai a disposizione le seguenti opzioni per scrivere messaggi in una tabella BigQuery:

  • Configura un service account personalizzato in modo che solo gli utenti che dispongono dell'autorizzazione iam.serviceAccounts.actAs sul account di servizio possano creare un abbonamento che scrive nella tabella. Un ruolo di esempio che include l'autorizzazione iam.serviceAccounts.actAs è il ruolo Utente service account (roles/iam.serviceAccountUser).

  • Utilizza l'agente di servizio Pub/Sub predefinito che consente a qualsiasi utente con la possibilità di creare sottoscrizioni nel progetto di creare una sottoscrizione che scrive nella tabella. Il service agent Pub/Sub è l'impostazione predefinita quando non specifichi un account di servizio personalizzato.

Creare una sottoscrizione BigQuery

Per creare un abbonamento con la distribuzione BigQuery, segui questi passaggi.

Console

  1. Nella console Google Cloud , vai alla pagina Crea sottoscrizione.

    Vai ad Abbonamenti

  2. Per il campo ID sottoscrizione, inserisci un nome. Per informazioni su come denominare un abbonamento, consulta Linee guida per la denominazione di un argomento o di un abbonamento.

  3. Nella casella Seleziona un argomento Cloud Pub/Sub, digita o seleziona l'argomento da cui ricevere i messaggi.

  4. Per Tipo di pubblicazione, seleziona Scrivi in BigQuery.

  5. Seleziona la tabella BigQuery:

    1. Per Progetto, seleziona il progetto Google Cloud che contiene la tabella BigQuery.

    2. Per Set di dati, seleziona un set di dati esistente o fai clic su Crea nuovo set di dati per crearne uno nuovo. Per informazioni sulla creazione di un set di dati, vedi Creare set di dati.

    3. Nel campo Table (Tabella), inserisci il nome della tabella. Per creare una nuova tabella, fai clic sul link che ti reindirizza alla pagina Crea nuova tabella di BigQuery. La pagina si apre in una scheda separata. Per informazioni sulla creazione di una tabella, vedi Creare e utilizzare tabelle.

  6. In Configurazione schema, seleziona una delle seguenti opzioni:

    • Non utilizzare uno schema. Pub/Sub scrive i byte del messaggio in una colonna denominata data.

    • Utilizza schema argomento. Pub/Sub utilizza lo schema associato all'argomento. Per saperne di più, consulta Utilizzare lo schema dell'argomento.

    • Utilizza schema tabella. Pub/Sub utilizza lo schema della tabella BigQuery. Per saperne di più, vedi Utilizzare lo schema della tabella.

  7. Facoltativo. Per scrivere i metadati del messaggio nella tabella BigQuery, seleziona Scrivi metadati. Per ulteriori informazioni, consulta la sezione Scrivere metadati.

  8. Facoltativo. Per eliminare i campi non presenti nello schema della tabella BigQuery, seleziona Elimina campi sconosciuti. Per maggiori informazioni, vedi Elimina campi sconosciuti.

  9. Configura le proprietà comuni dell'abbonamento in base alle esigenze. Ti consigliamo vivamente di attivare la coda di messaggi non recapitabili per gestire gli errori dei messaggi. Per saperne di più, consulta la sezione Argomento di messaggi non recapitabili.

  10. Fai clic su Crea.

gcloud

  1. Nella console Google Cloud , attiva Cloud Shell.

    Attiva Cloud Shell

    Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

  2. 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 saperne di più, 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 saperne di più, 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;
    }
}

Go

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

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 Python di 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

L'esempio seguente 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 deprecati.

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

Monitorare una sottoscrizione BigQuery

Cloud Monitoring fornisce una serie di metriche per monitorare gli abbonamenti.

Per un elenco di tutte le metriche disponibili relative a Pub/Sub e le relative descrizioni, consulta la documentazione di Monitoring per Pub/Sub.

Puoi anche monitorare gli abbonamenti all'interno di Pub/Sub.

Passaggi successivi