Cette page a été traduite par l'API Cloud Translation.

Créer des abonnements BigQuery

Ce document explique comment créer un abonnement BigQuery. Vous pouvez utiliser la console Google Cloud, la Google Cloud CLI, la bibliothèque cliente ou l'API Pub/Sub pour créer un abonnement BigQuery.

Avant de commencer

Avant de lire ce document, assurez-vous de maîtriser les points suivants:

Fonctionnement des abonnements
Workflow des abonnements BigQuery.
Comment configurer un lettres mortes pour gérer les échecs de messages.

En plus de vos connaissances sur Pub/Sub et BigQuery, assurez-vous de remplir les conditions préalables suivantes avant de créer un abonnement BigQuery:

Une table BigQuery existe. Vous pouvez également en créer un lorsque vous créez l'abonnement BigQuery, comme décrit dans les sections suivantes de ce document.
Compatibilité entre le schéma du sujet Pub/Sub et la table BigQuery. Si vous ajoutez un bloc d'annonces non compatible une table BigQuery, vous obtenez une erreur liée à la compatibilité . Pour en savoir plus, consultez Compatibilité du schéma

Rôles et autorisations requis

Voici une liste de consignes concernant les rôles et les autorisations:

Pour créer un abonnement, vous devez configurer le contrôle des accès au niveau du projet à l'échelle du projet.
Vous avez également besoin d'autorisations au niveau des ressources les abonnements et les sujets appartiennent à des projets différents, comme nous le verrons ultérieurement. dans cette section.
Pour créer un abonnement BigQuery, Le compte de service Pub/Sub doit être autorisé à écrire dans le une table BigQuery spécifique. Pour savoir comment ces autorisations, consultez la section suivante de ce document.
Vous pouvez configurer un abonnement BigQuery dans un projet pour écrire dans une table BigQuery d'un autre projet.

Pour obtenir les autorisations dont vous avez besoin pour créer des abonnements BigQuery, demandez à votre administrateur de vous accorder le Éditeur Pub/Sub (roles/pubsub.editor) sur le projet. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient les autorisations requises pour créer des abonnements BigQuery. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer des abonnements BigQuery:

Extraire d'un abonnement: pubsub.subscriptions.consume
Créez un abonnement: pubsub.subscriptions.create
Supprimer un abonnement: pubsub.subscriptions.delete
Obtenir un abonnement: pubsub.subscriptions.get
Pour lister un abonnement: pubsub.subscriptions.list
Pour mettre à jour un abonnement: pubsub.subscriptions.update
Associer un abonnement à un sujet: pubsub.topics.attachSubscription
Obtenez la stratégie IAM d'un abonnement: pubsub.subscriptions.getIamPolicy
Configurez la stratégie IAM pour un abonnement: pubsub.subscriptions.setIamPolicy

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Si vous devez créer BigQuery abonnements d'un projet qui sont associés à un sujet dans un autre demandez à l'administrateur du sujet de vous accorder également le rôle d'éditeur Pub/Sub (roles/pubsub.editor) sur le sujet.

Attribuer des rôles BigQuery au compte de service Pub/Sub

Certains services Google Cloud disposent de comptes de service gérés par Google Cloud qui permettent d'accès à vos ressources. Ces comptes de service appelés "agents de service". Pub/Sub crée et gère compte de service pour chaque projet au format service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com

Pour créer un abonnement BigQuery, compte de service doit être autorisé à écrire à la table BigQuery spécifique et lire les métadonnées de la table.

Accorder l'accès à l'éditeur de données BigQuery (roles/bigquery.dataEditor) au compte de service Pub/Sub.

Dans la console Google Cloud, accédez à la page IAM.

Accéder à IAM
Cliquez sur Accorder l'accès.
Dans la section Ajouter des comptes principaux, saisissez le nom de votre de service géré. Le format du compte de service est service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com. Par exemple, pour un projet avec project-number=112233445566, le compte de service est au format service-112233445566@gcp-sa-pubsub.iam.gserviceaccount.com.
Dans la section Attribuer des rôles, cliquez sur Ajouter un autre rôle.
Dans la liste déroulante Sélectionner un rôle, saisissez BigQuery. et sélectionnez le rôle Éditeur de données BigQuery.
Cliquez sur Enregistrer.

Pour en savoir plus sur les rôles IAM BigQuery, consultez la page Rôles et autorisations BigQuery.

Propriétés d'abonnement BigQuery

Lorsque vous configurez un abonnement BigQuery, vous pouvez spécifier les éléments suivants : propriétés.

Propriétés communes

En savoir plus sur les propriétés d'abonnement courantes que vous pouvez définir pour tous les abonnements.

Utiliser un schéma avec sujet

Cette option permet à Pub/Sub d'utiliser le schéma du sujet Pub/Sub auquel le est associé à un abonnement. De plus, Pub/Sub écrit les champs des messages dans l'espace de noms dans la table BigQuery.

Lorsque vous utilisez cette option, n'oubliez pas de vérifier les conditions supplémentaires suivantes:

Champs du schéma du sujet et du schéma BigQuery doivent avoir les mêmes noms et leurs types doivent être compatibles entre eux.
Tout champ facultatif du schéma du sujet doit également être est facultative dans le schéma BigQuery.
Il n'est pas nécessaire que les champs obligatoires du schéma requises dans le schéma BigQuery.
Si des champs BigQuery ne sont pas présents dans le schéma du sujet, ces champs BigQuery doit être en mode NULLABLE.
Si le schéma du sujet comporte des champs supplémentaires ne sont pas présentes dans le schéma BigQuery et peuvent être supprimés, sélectionnez l'option Supprimer les champs inconnus.
Vous ne pouvez sélectionner qu'une seule des propriétés d'abonnement : Utiliser un schéma avec sujet. ou Utiliser un schéma de table.

Si vous ne sélectionnez pas l'option Utiliser un schéma avec sujet ou Utiliser un schéma de table, vérifiez que la table BigQuery comporte une colonne appelée data saisissez BYTES, STRING ou JSON. Pub/Sub écrit le message cette colonne BigQuery.

Il est possible que vous ne voyiez pas les modifications apportées au schéma des sujets Pub/Sub ou Le schéma de la table BigQuery prend effet immédiatement avec les messages dans la table BigQuery. Par exemple, si le bouton Drop champs inconnus est activée et qu'un champ est présent dans le schéma Pub/Sub, mais pas le schéma BigQuery, que les messages écrits dans la table BigQuery ne contiennent toujours pas après l'avoir ajouté au schéma BigQuery. Finalement, les schémas synchronisés et les messages suivants incluent ce champ.

Lorsque vous utilisez l'option Utiliser un schéma de sujet pour votre projet BigQuery vous pouvez aussi profiter des modifications apportées à BigQuery de capture de données (CDC). La CDC met à jour vos tables BigQuery de le traitement et l'application des modifications aux lignes existantes.

Pour en savoir plus sur cette fonctionnalité, consultez Diffuser des mises à jour de tables avec capture des données modifiées.

Pour découvrir comment utiliser cette fonctionnalité avec les abonnements BigQuery, consultez la page Capture de données modifiées dans BigQuery.

Utiliser un schéma de table

Cette option permet à Pub/Sub d'utiliser le schéma du Table BigQuery pour écrire les champs d'un fichier JSON dans les colonnes correspondantes. Lorsque vous utilisez cette option, n'oubliez pas vérifiez les exigences supplémentaires suivantes:

Les messages publiés doivent être au format JSON.
Si le sujet de l'abonnement est associé à un schéma, la propriété d'encodage des messages doit être définie sur JSON.
Si des champs BigQuery ne sont pas présents dans les messages, ces champs BigQuery doivent être en mode NULLABLE.
Si les messages comportent des champs supplémentaires qui ne figurent pas dans la section schéma BigQuery et que ces champs peuvent être supprimés, sélectionnez le l'option Supprimer les champs inconnus.
Dans le message JSON, les valeurs DATE, DATETIME, TIME et TIMESTAMP doivent être des entiers conformes aux représentations acceptées.
Dans le message JSON, les valeurs NUMERIC et BIGNUMERIC doivent être des octets encodés à l'aide de la méthode BigDecimalByteStringEncoder.
Vous ne pouvez sélectionner qu'une seule des propriétés d'abonnement : Utiliser un schéma avec sujet. ou Utiliser un schéma de table.

Il est possible que les modifications apportées au schéma de la table BigQuery ne soient pas prises en compte immédiatement avec les messages écrits dans la table BigQuery. Par exemple, si l'option Supprimer les champs inconnus est activée et qu'un champ est dans les messages, mais pas dans le schéma BigQuery, que les messages écrits dans la table BigQuery ne contiennent toujours pas après l'avoir ajouté au schéma BigQuery. Finalement, le schéma est synchronisé et les messages ultérieurs incluent ce champ.

Lorsque vous utilisez l'option Utiliser un schéma de table avec votre abonnement BigQuery, vous peuvent également exploiter la capture de données modifiées (CDC, Change Data Capture) de BigQuery. La CDC met à jour vos tables BigQuery en traitant et en appliquant les modifications lignes.

Pour en savoir plus sur cette fonctionnalité, consultez Diffuser des mises à jour de tables avec capture des données modifiées.

Pour découvrir comment utiliser cette fonctionnalité avec des abonnements BigQuery, consultez Capture de données modifiées dans BigQuery.

Supprimer les champs inconnus

Cette option est utilisée avec les options Utiliser un schéma avec sujet ou Utiliser un schéma de table. . Cette option permet à Pub/Sub de supprimer tous les champs présents dans le sujet. schéma ou un message, mais pas dans le schéma BigQuery. Sans Défaillance inconnue champs définis, les messages comportant des champs supplémentaires ne sont pas écrits dans dans BigQuery et demeurer dans les tâches d'abonnement en attente. La l'abonnement se retrouve à l'état d'erreur.

Écrire des métadonnées

Cette option permet à Pub/Sub écrire les métadonnées de chaque message dans des colonnes supplémentaires table BigQuery. Sinon, les métadonnées n'est pas écrite dans la table BigQuery.

Si vous sélectionnez l'option Écrire les métadonnées, assurez-vous que La table BigQuery comporte les champs décrits dans le tableau suivant.

Si vous ne sélectionnez pas l'option Écrire les métadonnées, la table BigQuery de destination ne nécessite que le champ data, sauf si use_topic_schema est vrai. Si vous sélectionnez à la fois Écrire les métadonnées et Utiliser un schéma de sujet, le schéma du sujet doit ne contenir aucun champ dont le nom correspond à ceux des paramètres de métadonnées. Cette limitation inclut les versions camelcase de ces paramètres snake case.

Paramètres
`subscription_name`	STRING Nom d'un abonnement.
`message_id`	STRING ID d'un message
`publish_time`	TIMESTAMP Heure de publication d'un message.
`data`	BYTES, STRING ou JSON Corps du message. Le champ `data` est obligatoire pour toutes les destinations les tables BigQuery sans l'option Utiliser schéma de sujet ou Utiliser un schéma de table. Si le est de type JSON, le corps du message doit être JSON valide.
`attributes`	STRING ou JSON Objet JSON contenant tous les attributs du message. Il y a aussi contient des champs supplémentaires un message Pub/Sub incluant la clé de tri, le cas échéant.

Créer un abonnement BigQuery

Les exemples suivants montrent comment créer un abonnement avec la diffusion BigQuery.

Console

Dans la console Google Cloud, accédez à Abonnements.
Accéder à Abonnements
Cliquez sur Créer un abonnement.
Dans le champ ID d'abonnement, saisissez un nom.
Pour sur le nom d'un abonnement, consultez les Consignes pour nommer un abonnement un sujet ou un abonnement.
Choisissez ou créez un sujet dans le menu déroulant. L'abonnement reçoit les messages du sujet.
Dans le champ Type de diffusion, sélectionnez Écrire dans dans BigQuery.
Sélectionnez le projet pour la table BigQuery.
Sélectionnez un ensemble de données existant ou créez-en un.
Pour plus d'informations Pour savoir comment créer un ensemble de données, consultez la page Créer des ensembles de données.
Sélectionnez une table existante ou créez-en une.
Pour plus d'informations sur comment créer une table, consultez la section Créer des tables.
Nous vous recommandons vivement d'activer les lettering pour gérer les échecs de messages.
Pour en savoir plus, consultez la section des lettres.
Cliquez sur Créer.

Vous pouvez également créer un abonnement à partir de la page Sujets. Ce raccourci est utile pour associer des sujets à des abonnements.

Dans la console Google Cloud, accédez à la page Sujets. .
Accéder à Thèmes
Cliquez sur à côté du thème pour lequel vous souhaitez pour créer un abonnement.
Dans le menu contextuel, sélectionnez Créer un abonnement.
Dans le champ Type de diffusion, sélectionnez Écrire dans dans BigQuery.
Sélectionnez le projet pour la table BigQuery.
Sélectionnez un ensemble de données existant ou créez-en un.
Pour plus d'informations Pour savoir comment créer un ensemble de données, consultez la page Créer des ensembles de données.
Sélectionnez une table existante ou créez-en une.
Pour plus d'informations sur comment créer un ensemble de données, consultez la page Créer des tables.
Nous vous recommandons vivement d'activer les lettering pour gérer les échecs de messages.
Pour en savoir plus, consultez la section des lettres.
Cliquez sur Créer.

gcloud

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Pour créer un abonnement Pub/Sub, utilisez la méthode gcloud pubsub subscriptions create commande:
```
gcloud pubsub subscriptions create SUBSCRIPTION_ID \
    --topic=TOPIC_ID \
    --bigquery-table=PROJECT_ID:DATASET_ID.TABLE_ID
```
Remplacez les éléments suivants :
- SUBSCRIPTION_ID: spécifie l'ID du abonnement.
- TOPIC_ID: spécifie l'ID du sujet. La nécessite un schéma.
- PROJECT_ID: spécifie l'ID du projet.
- DATASET_ID: spécifie l'ID d'un objet existant ensemble de données. Pour créer un ensemble de données, consultez la section Créer des ensembles de données.
- TABLE_ID: spécifie l'ID d'une table existante. Le tableau nécessite un champ data si votre sujet n'a pas de schéma. Pour créer une table, consultez la section Créer une table vide avec une définition de schéma.

C++

Avant d'essayer cet exemple, suivez les instructions de configuration de C++ dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API C++ Pub/Sub documentation de référence.

Pour vous authentifier auprès de Pub/Sub, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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#

Avant d'essayer cet exemple, suivez les instructions de configuration de C# dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API C# Pub/Sub documentation de référence.


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

Avant d'essayer cet exemple, suivez les instructions de configuration de Go dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API Go Pub/Sub documentation de référence.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Java dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API Java Pub/Sub documentation de référence.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de PHP dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API PHP Pub/Sub documentation de référence.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Python dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API Python Pub/Sub documentation de référence.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Ruby dans le Guide de démarrage rapide de Pub/Sub bibliothèques clientes. Pour en savoir plus, consultez les API Ruby Pub/Sub documentation de référence.

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

Étape suivante

Créer ou modifier un abonnement à l'aide de commandes gcloud
créer ou modifier un abonnement à l'aide des API REST ;
Résoudre un problème d'abonnement BigQuery