Creare sottoscrizioni BigQuery

Questo documento descrive come creare una sottoscrizione 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 avere familiarità con quanto segue:

Oltre ad avere 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 la sottoscrizione 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, riceverai un messaggio di errore relativo alla compatibilità. Per saperne di più, consulta 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 una sottoscrizione BigQuery. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare una sottoscrizione 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.

Sottoscrizioni tra progetti

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

Concedi i 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 l'agente di servizio Pub/Sub (service-PROJECT_NUMBER@gcp-sa-pubsub.).

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 per la tabella, come segue:

Progetto

  1. Nella console Google Cloud vai alla pagina IAM.

    Vai a IAM

  2. Seleziona Includi concessioni di ruoli fornite da Google.

  3. Individua 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 BigQuery Data Editor.

Per ulteriori 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 per cui vuoi concedere l'autorizzazione.

  4. Nel riquadro dei 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..

  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 BigQuery Data Editor al account di servizio Cloud Pub/Sub, qualsiasi utente autorizzato a creare una sottoscrizione nel tuo progetto può scrivere nella tabella BigQuery. Se vuoi fornire autorizzazioni più granulari, configura invece un service account gestito dall'utente.

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

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

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

  • L'utente che crea la sottoscrizione 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 della sottoscrizione.

Proprietà delle sottoscrizioni BigQuery

Le sottoscrizioni BigQuery supportano tutte le proprietà delle sottoscrizioni comuni. Le sezioni seguenti descrivono le proprietà specifiche delle sottoscrizioni 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 dei messaggi nelle colonne corrispondenti della tabella BigQuery.

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

  • I campi nello schema dell'argomento e nello schema BigQuery devono avere gli stessi nomi e i relativi 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 contiene campi aggiuntivi che non sono presenti nello schema BigQuery e questi campi possono essere ignorati, seleziona l'opzione Ignora campi sconosciuti.

  • Puoi selezionare solo una delle proprietà della sottoscrizione, Utilizza schema argomento o Utilizza 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.

Le modifiche allo schema degli argomenti Pub/Sub o allo schema della tabella BigQuery potrebbero non essere applicate immediatamente ai messaggi scritti nella tabella BigQuery. Ad esempio, se l'opzione Ignora 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 schema argomento per la tua sottoscrizione BigQuery, puoi anche usufruire di Change Data Capture (CDC) di BigQuery. CDC aggiorna le tabelle BigQuery elaborando e applicando le modifiche alle righe esistenti.

Per scoprire di più su questa funzionalità, consulta Esegui lo streaming degli aggiornamenti delle tabelle con Change Data Capture.

Per scoprire come utilizzare questa funzionalità con le sottoscrizioni BigQuery, consulta Change Data Capture 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, ricorda di controllare i seguenti requisiti aggiuntivi:

  • I nomi di ogni colonna della 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 di una tabella BigQuery ha il tipo di dati JSON, il campo corrispondente nel messaggio Pub/Sub deve essere un JSON valido in una stringa con 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 da number a 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 un intervallo di valori più ampio, utilizza invece le conversioni da string a 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 tratta la stringa come byte codificati con BigDecimalByteStringEncoder.

  • Se l'argomento della sottoscrizione ha uno schema associato, la proprietà di codifica del messaggio deve essere impostata su JSON.

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

  • Se i messaggi contengono campi aggiuntivi che non sono presenti nello schema BigQuery e questi campi possono essere ignorati, seleziona l'opzione Ignora campi sconosciuti.

  • Puoi selezionare solo una delle proprietà della sottoscrizione, Utilizza schema argomento o Utilizza 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.

Le modifiche allo schema della tabella BigQuery potrebbero non essere applicate immediatamente ai messaggi scritti nella tabella BigQuery. Ad esempio, se l'opzione Elimina 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 si sincronizza e i messaggi successivi includono il campo.

Quando utilizzi l'opzione Utilizza lo schema della tabella per la tua sottoscrizione BigQuery, puoi anche usufruire di Change Data Capture (CDC) di BigQuery. CDC aggiorna le tabelle BigQuery elaborando e applicando le modifiche alle righe esistenti.

Per scoprire di più su questa funzionalità, consulta Esegui lo streaming degli aggiornamenti delle tabelle con Change Data Capture.

Per scoprire come utilizzare questa funzionalità con le sottoscrizioni BigQuery, consulta Change Data Capture di BigQuery.

Rilascia campi sconosciuti

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

Se non imposti Elimina campi sconosciuti, i messaggi con campi aggiuntivi non vengono scritti in BigQuery e rimangono nel backlog della sottoscrizione, a meno che non configuri un argomento 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, alla sottoscrizione viene recapitato un messaggio Pub/Sub valido. Tuttavia, poiché BigQuery non ha colonne definite per questi campi aggiuntivi, questi campi vengono eliminati durante il processo di scrittura di BigQuery. Per evitare questo comportamento, assicurati che tutti i campi contenuti nel messaggio Pub/Sub siano contenuti anche nello schema della tabella BigQuery.

Il comportamento relativo ai campi aggiuntivi può dipendere anche dal tipo di schema specifico (Avro, buffer di protocollo) e dalla codifica (JSON, binario) 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 entrambe 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 camelCase di questi parametri snake_case.

Parametri
subscription_name

STRING

Nome di una sottoscrizione.
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 per cui non è selezionata l'opzione 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

Per scrivere messaggi in una tabella BigQuery, hai a disposizione le seguenti opzioni:

  • Configura un service account personalizzato in modo che solo gli utenti con l'autorizzazione iam.serviceAccounts.actAs sul account di servizio possano creare una sottoscrizione che scrive nella tabella. Un esempio di ruolo che include l'autorizzazione iam.serviceAccounts.actAs è il ruolo Service Account User (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. L'agente di servizio Pub/Sub è l'impostazione predefinita quando non specifichi un account di servizio personalizzato.

Creare una sottoscrizione BigQuery

Per creare una sottoscrizione con distribuzione BigQuery, segui questi passaggi.

Console

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

    Vai ad Abbonamenti

  2. Nel campo ID sottoscrizione, inserisci un nome. Per informazioni su come assegnare un nome a una sottoscrizione, consulta Linee guida per assegnare un nome a un argomento o a una sottoscrizione.

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

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

  5. Seleziona la tabella BigQuery:

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

    2. In 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, consulta Crea set di dati.

    3. Nel campo Table (Tabella), inserisci il nome della tabella. Per creare una nuova tabella, fai clic sul link che ti indirizza alla pagina Crea nuova tabella di BigQuery. La pagina si apre in una scheda separata. Per informazioni sulla creazione di una tabella, consulta Crea e utilizza le 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 Utilizza lo schema degli argomenti.

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

  7. Facoltativo. Per scrivere i metadati dei messaggi nella tabella BigQuery, seleziona Scrivi metadati. Per saperne di più, consulta Scrivi i metadati.

  8. Facoltativo. Per eliminare i campi non presenti nello schema della tabella BigQuery, seleziona Elimina campi sconosciuti. Per saperne di più, consulta Elimina campi sconosciuti.

  9. Configura le proprietà comuni degli abbonamenti in base alle tue esigenze. Ti consigliamo vivamente di attivare la funzionalità Messaggi non recapitabili per gestire gli errori dei messaggi. Per saperne di più, consulta 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 della sottoscrizione.
    • 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, consulta Crea set di dati.
    • TABLE_ID: specifica l'ID di una tabella esistente. La tabella richiede un campo data se l'argomento non ha uno schema. Per creare una tabella, consulta Crea una tabella vuota con una definizione di schema.
    • SERVICE_ACCOUNT_NAME: specifica il nome del 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;
    }
}

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 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 in Guida rapida: 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: 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: 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: 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: 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}"

Monitora una sottoscrizione BigQuery

Cloud Monitoring fornisce una serie di metriche per monitorare le sottoscrizioni.

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

Puoi anche monitorare le sottoscrizioni all'interno di Pub/Sub.

Passaggi successivi