Crea sottoscrizioni BigQuery

Questo documento descrive come creare una sottoscrizione BigQuery. Puoi utilizzare la console Google Cloud, Google Cloud CLI, la libreria client oppure 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 la sottoscrizione BigQuery come descritto in 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, vedi Compatibilità dello schema.

Ruoli e autorizzazioni richiesti

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

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

  • Sono inoltre necessarie autorizzazioni a livello di risorsa se i tuoi abbonati e gli argomenti si trovano in progetti diversi, come discusso 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 concedi 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) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

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

Autorizzazioni obbligatorie

Per creare sottoscrizioni BigQuery sono necessarie le seguenti autorizzazioni:

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

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

Se devi creare sottoscrizioni BigQuery in un progetto associate 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 hanno account di servizio gestiti da Google Cloud che consentono per accedere alle tue risorse. Questi account di servizio noti come agenti di servizio. Pub/Sub crea e gestisce un account di servizio per ogni progetto nel formatoservice-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 l'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 Pub/Sub l'account di servizio. 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 saperne di più su IAM di BigQuery, consulta Ruoli e autorizzazioni di BigQuery.

Proprietà delle sottoscrizioni BigQuery

Quando configuri un abbonamento BigQuery, puoi specificare le seguenti proprietà.

Proprietà comuni

Scopri le proprietà comuni delle iscrizioni che puoi impostare in tutti gli abbonamenti.

Utilizza schema argomento

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

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

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

  • Anche qualsiasi campo facoltativo nello schema dell'argomento deve essere sono facoltative nello schema BigQuery.

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

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

  • Se lo schema dell'argomento ha campi aggiuntivi che non sono presenti nello schema BigQuery e questi ultimi seleziona l'opzione Rilascia campi sconosciuti.

  • Puoi selezionare una sola delle proprietà di sottoscrizione, Utilizza lo schema dell'argomento o Utilizza lo schema della tabella.

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

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

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

Per scoprire di più su questa funzionalità, consulta Aggiornare le tabelle di streaming con l'acquisizione dei dati sulle modifiche.

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

Utilizza schema tabella

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

  • I messaggi pubblicati devono essere in formato JSON.

  • 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 a virgola mobile. Se hai bisogno di una precisione elevata o di una gamma più ampia di valori, utilizza 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 la tratta 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 sono presenti campi BigQuery non presenti in i messaggi, questi campi di BigQuery devono essere in modalità NULLABLE.

  • Se i messaggi contengono campi aggiuntivi che non sono presenti nella Schema BigQuery e questi campi possono essere eliminati, seleziona il opzione Trascina campi sconosciuti.

  • Puoi selezionare una sola delle proprietà di sottoscrizione, Utilizza lo schema dell'argomento o Utilizza lo schema della 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 le modifiche allo schema della tabella BigQuery ha effetto immediato con i messaggi scritti nella tabella BigQuery. Ad esempio, se l'opzione Elimina campi sconosciuti è attivata e un campo è presente nei messaggi, ma non nello schema di BigQuery, i messaggi scritti nella tabella BigQuery potrebbero non contenere ancora il campo dopo averlo aggiunto allo schema di BigQuery. In seguito, 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 sfruttare il vantaggio di BigQuery Change Data Capture (CDC). CDC aggiorna le tabelle BigQuery elaborando e applicando modifiche alle righe.

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

Per scoprire come utilizzare questa funzionalità con gli abbonamenti BigQuery, consulta Acquisizione dei dati sulle modifiche 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 eliminare qualsiasi campo presente nell'argomento. nello schema o nel messaggio, ma non nello schema BigQuery. Se non è impostato Elimina campi sconosciuti, i messaggi con campi aggiuntivi non vengono scritti in BigQuery e rimangono nel backlog della sottoscrizione. L'abbonamento termina in uno stato di errore.

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 viene scritto 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 sia l'opzione Scrivi metadati sia 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 con lettere maiuscole di questi parametri con lettere minuscole.

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 che non selezionano Utilizza schema argomento o Utilizza schema tabella. Se il campo è di tipo JSON, il corpo del messaggio deve essere JSON valido.
attributes

STRING o JSON

Un 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

Gli esempi riportati di seguito mostrano come creare un abbonamento con invio BigQuery.

Console

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

    Vai a Abbonamenti

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

    Per informazioni su come assegnare un nome a 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. L'abbonamento riceve messaggi dall'argomento.
  5. Seleziona Tipo di importazione come Scrive 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 Creare set di dati.

  8. Seleziona una tabella esistente o creane una nuova.

    Per informazioni su su come creare una tabella, consulta Creazione di tabelle.

  9. Ti consigliamo vivamente di attivare la funzionalità Messaggi non recapitabili per gestire gli errori dei messaggi.

    Per ulteriori informazioni, vedi Dead all'argomento delle lettere.

  10. Fai clic su Crea.

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

  1. Nella console Google Cloud, vai a Topics. .

    Vai a Argomenti

  2. Fai clic su accanto all'argomento per cui vuoi creare un abbonamento.
  3. Dal menu contestuale, seleziona Crea abbonamento.
  4. Seleziona Tipo di importazione come Scrive 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 su come creare un set di dati, consulta Creazione di tabelle.

  8. Ti consigliamo vivamente di attivare Dead per gestire gli errori dei messaggi.

    Per ulteriori informazioni, consulta l'argomento Lettere morte.

  9. Fai clic su Crea.

gcloud

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

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Per creare un abbonamento Pub/Sub, utilizza 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 dell'abbonamento.
    • TOPIC_ID: specifica l'ID dell'argomento. La richiede uno schema.
    • PROJECT_ID: specifica l'ID del progetto.
    • DATASET_ID: specifica l'ID di un elemento esistente del set di dati. 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. una tabella vuota con una definizione di schema.

C++

Prima di provare questo esempio, segui le istruzioni per la configurazione di C++ nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta API Pub/Sub C++ documentazione di riferimento.

Per eseguire l'autenticazione su Pub/Sub, configura le credenziali predefinite dell'applicazione. Per saperne di più, 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 per la configurazione di C# nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub C#.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per saperne di più, 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 riportate nella guida rapida di Pub/Sub che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub Go.

Per eseguire l'autenticazione su Pub/Sub, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 per la configurazione di Java nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub Java.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 riportate nella guida rapida di Pub/Sub che utilizza le librerie client. Per ulteriori informazioni, consulta API Pub/Sub PHP documentazione di riferimento.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per saperne di più, 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 per la configurazione di Python nel Guida rapida di Pub/Sub con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub Python.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 riportate nella guida rapida di Pub/Sub che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Pub/Sub Ruby.

Per autenticarti a Pub/Sub, configura le credenziali predefinite dell'applicazione. Per saperne di più, 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

Monitorare una sottoscrizione BigQuery

Cloud Monitoring fornisce una serie di metriche monitorare gli abbonamenti.

Per un elenco di tutte le metriche disponibili relative a Pub/Sub e le relative descrizioni, vedi Documentazione sul monitoraggio di Pub/Sub.

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

Passaggi successivi