Crea 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 acquisire familiarità con 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 una 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 ulteriori informazioni, consulta la sezione Compatibilità degli schemi.

Autorizzazioni e ruoli richiesti

Di seguito è riportato un elenco di linee guida relative ai ruoli e alle autorizzazioni:

  • Per creare una sottoscrizione, devi configurare il controllo dell'accesso a livello di progetto.

  • Devi disporre delle autorizzazioni a livello di risorsa anche se gli abbonamenti e gli argomenti si trovano in progetti diversi, come illustrato più avanti in questa sezione.

  • Per creare una sottoscrizione BigQuery, l'account di servizio Pub/Sub deve disporre dell'autorizzazione per scrivere nella tabella BigQuery specifica. Per ulteriori informazioni su come concedere queste autorizzazioni, consulta la sezione successiva di questo documento.

  • Puoi configurare una sottoscrizione BigQuery in un progetto per scrivere in una tabella BigQuery di un altro progetto.

Per ottenere le autorizzazioni necessarie per creare sottoscrizioni BigQuery, chiedi all'amministratore di concederti il ruolo IAM Editor Pub/Sub (roles/pubsub.editor) per il progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare sottoscrizioni BigQuery. Per visualizzare le autorizzazioni esatte necessarie, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per creare sottoscrizioni BigQuery sono necessarie le seguenti autorizzazioni:

  • Esegui il pull da una sottoscrizione: pubsub.subscriptions.consume
  • Crea una sottoscrizione: pubsub.subscriptions.create
  • Elimina una sottoscrizione: pubsub.subscriptions.delete
  • Acquista un abbonamento: pubsub.subscriptions.get
  • Elenca un abbonamento: pubsub.subscriptions.list
  • Aggiorna un abbonamento: pubsub.subscriptions.update
  • Allega una sottoscrizione a un argomento: pubsub.topics.attachSubscription
  • Ottieni il criterio IAM per una sottoscrizione: pubsub.subscriptions.getIamPolicy
  • Configura il criterio IAM per un abbonamento: pubsub.subscriptions.setIamPolicy

Potresti anche essere in grado di ottenere queste autorizzazioni con i ruoli personalizzati o altri ruoli predefiniti.

Se devi creare sottoscrizioni BigQuery in un progetto associati a un argomento in un altro progetto, chiedi all'amministratore dell'argomento di concederti anche il ruolo IAM Editor Pub/Sub (roles/pubsub.editor) per l'argomento.

Assegna i ruoli BigQuery all'account di servizio Pub/Sub

Alcuni servizi Google Cloud dispongono di account di servizio gestiti da Google Cloud che consentono ai servizi di accedere alle tue risorse. Questi account di servizio sono noti come agenti di servizio. Pub/Sub crea e gestisce un account di servizio per ogni progetto nel formato service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Per creare una sottoscrizione BigQuery, l'account di servizio Pub/Sub deve disporre dell'autorizzazione per scrivere nella tabella BigQuery specifica e leggere i metadati della tabella.

Concedi il ruolo di Editor dati BigQuery (roles/bigquery.dataEditor) all'account di servizio Pub/Sub.

  1. Nella console Google 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 Pub/Sub. Il formato dell'account di servizio è service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com. Ad esempio, per un progetto con project-number=112233445566, l'account di servizio è nel formato service-112233445566@gcp-sa-pubsub.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.

Per ulteriori informazioni su BigQuery IAM, consulta Ruoli e autorizzazioni di BigQuery.

Proprietà della sottoscrizione BigQuery

Quando configuri una sottoscrizione BigQuery, puoi specificare le seguenti proprietà.

Proprietà comuni

Scopri di più sulle proprietà di abbonamento comuni che puoi impostare per tutte le sottoscrizioni.

Utilizza schema argomento

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

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

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

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

  • Non è necessario che i campi obbligatori nello schema dell'argomento siano obbligatori nello schema di BigQuery.

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

  • Se lo schema dell'argomento include 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à 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.

Potresti non notare che le modifiche allo schema degli argomenti Pub/Sub o allo schema della tabella BigQuery diventeranno effettive immediatamente con i messaggi scritti nella tabella BigQuery. Ad esempio, se l'opzione Elimina campi sconosciuti è abilitata e nello schema Pub/Sub è presente un campo, ma non lo schema BigQuery, i messaggi scritti nella tabella BigQuery potrebbero comunque non contenere il campo dopo averlo aggiunto allo schema BigQuery. Alla fine, gli schemi verranno sincronizzati e i messaggi successivi includeranno il campo.

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

Per scoprire di più su questa funzionalità, consulta Streaming di aggiornamenti delle tabelle con Change Data Capture (CDC).

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

Usa 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 messaggi pubblicati devono essere in formato JSON.

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

  • Se ci sono 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 di BigQuery e questi campi possono essere eliminati, seleziona l'opzione Elimina campi sconosciuti.

  • Nel messaggio JSON, i valori DATE, DATETIME, TIME e TIMESTAMP devono essere numeri interi che rispettano le rappresentazioni supportate.

  • Nel messaggio JSON, i valori NUMERIC e BIGNUMERIC devono essere byte codificati utilizzando BigDecimalByteStringEncoder.

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

Potresti non notare che le modifiche allo schema della tabella BigQuery vengono applicate immediatamente con i 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 viene sincronizzato e i messaggi successivi includono il campo.

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

Per scoprire di più su questa funzionalità, consulta Streaming di aggiornamenti delle tabelle con Change Data Capture (CDC).

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

Rilascia campi sconosciuti

Questa opzione viene utilizzata con l'opzione Utilizza schema argomento o Utilizza schema tabella. Questa opzione consente a Pub/Sub di ignorare qualsiasi campo presente nello schema o nel messaggio dell'argomento, ma non nello schema di BigQuery. Se Elimina campi sconosciuti non viene impostato, i messaggi con campi aggiuntivi non vengono scritti in BigQuery e rimangono nel backlog della sottoscrizione. L'abbonamento risulta stato di errore.

Scrivi metadati

Questa opzione consente a Pub/Sub di scrivere i metadati di ciascun 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 seguente tabella.

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 cammello di questi parametri relativi alle custodie serpenti.

Parametri
subscription_name

STRING

Il 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 in formato JSON valido.
attributes

STRING o JSON

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

Creare una sottoscrizione BigQuery

I seguenti esempi mostrano come creare una sottoscrizione con la consegna di BigQuery.

Console

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

    Vai ad Abbonamenti

  2. Fai clic su Crea sottoscrizione.
  3. Inserisci un nome nel campo ID abbonamento.

    Per informazioni su come assegnare un nome a una sottoscrizione, consulta le linee guida per assegnare un nome a un argomento o a una sottoscrizione.

  4. Scegli o crea un argomento dal menu a discesa. La sottoscrizione riceve messaggi dall'argomento.
  5. Seleziona Tipo di consegna come Scrivi in 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, consulta la sezione Creazione delle tabelle.

  9. Ti consigliamo vivamente di abilitare Non recapitabili per gestire gli errori relativi ai messaggi.

    Per ulteriori informazioni, consulta l'argomento messaggi non recapitabili.

  10. Fai clic su Crea.

Puoi creare un abbonamento anche dalla pagina Argomenti. Questa scorciatoia è utile per associare gli argomenti agli abbonamenti.

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

    Vai ad Argomenti

  2. Fai clic su accanto all'argomento per cui vuoi creare una sottoscrizione.
  3. Dal menu contestuale, seleziona Crea abbonamento.
  4. Seleziona Tipo di consegna come Scrivi in 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, consulta la sezione Creazione di tabelle.

  8. Ti consigliamo vivamente di abilitare Non recapitabili per gestire gli errori relativi ai messaggi.

    Per ulteriori informazioni, consulta l'argomento messaggi non recapitabili.

  9. 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 che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

  2. Per creare un abbonamento 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

    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 Creare 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 Creare una tabella vuota con una definizione di schema.

C++

Prima di provare questo esempio, segui le istruzioni di configurazione di C++ nella guida rapida di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API C++ di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 

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 di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API C# di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
)

// createBigQuerySubscription creates a Pub/Sub subscription that exports messages to BigQuery.
func createBigQuerySubscription(w io.Writer, projectID, subID string, topic *pubsub.Topic, table string) error {
	// projectID := "my-project-id"
	// subID := "my-sub"
	// topic of type https://godoc.org/cloud.google.com/go/pubsub#Topic
	// 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.CreateSubscription(ctx, subID, pubsub.SubscriptionConfig{
		Topic: topic,
		BigQueryConfig: pubsub.BigQueryConfig{
			Table:         table,
			WriteMetadata: true,
		},
	})
	if err != nil {
		return fmt.Errorf("client.CreateSubscription: %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 di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 

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

/**
 * 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.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 di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API PHP di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 

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 di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida di Pub/Sub sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Ruby di Pub/Sub.

Per eseguire l'autenticazione in Pub/Sub, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client. 

require "google/cloud/pubsub"

##
# Shows how to create a BigQuery subscription where messages published
# to a topic populates a BigQuery table.
#
# @param project_id [String]
# Your Google Cloud project (e.g. "my-project")
# @param topic_id [String]
# Your topic name (e.g. "my-secret")
# @param subscription_id [String]
# ID for new subscription to be created (e.g. "my-subscription")
# @param bigquery_table_id [String]
# ID of bigquery table (e.g "my-project:dataset-id.table-id")
#
def pubsub_create_bigquery_subscription project_id:, topic_id:, subscription_id:, bigquery_table_id:
  pubsub = Google::Cloud::Pubsub.new project_id: project_id
  topic = pubsub.topic topic_id
  subscription = topic.subscribe subscription_id,
                                 bigquery_config: {
                                   table: bigquery_table_id,
                                   write_metadata: true
                                 }
  puts "BigQuery subscription created: #{subscription_id}."
  puts "Table for subscription is: #{bigquery_table_id}"
end

Passaggi successivi