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 d'avoir pris connaissance des points suivants:

En plus de connaître 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 lors de la création de 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 une table BigQuery non compatible, un message d'erreur lié à la compatibilité s'affiche. Pour en savoir plus, consultez la section Compatibilité des schémas.

Rôles et autorisations requis

Vous trouverez ci-dessous 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.

  • Vous devez également disposer d'autorisations au niveau des ressources si vos abonnements et vos sujets se trouvent dans des projets différents, comme indiqué plus loin dans cette section.

  • Pour créer un abonnement BigQuery, le compte de service Pub/Sub doit être autorisé à écrire dans la table BigQuery spécifique. Pour savoir comment accorder 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 nécessaires pour créer des abonnements BigQuery, demandez à votre administrateur de vous attribuer le rôle IAM É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:

  • Extrait d'un abonnement : pubsub.subscriptions.consume
  • Créer un abonnement : pubsub.subscriptions.create
  • Supprimer un abonnement : pubsub.subscriptions.delete
  • Souscrire un abonnement : pubsub.subscriptions.get
  • Répertorier un abonnement : pubsub.subscriptions.list
  • 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, dans un projet, vous devez créer des abonnements BigQuery associés à un sujet d'un autre projet, demandez à votre administrateur de sujets de vous accorder également le rôle IAM (roles/pubsub.editor) Éditeur Pub/Sub 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 leur permettent d'accéder à vos ressources. Ces comptes de service sont appelés agents de service. Pub/Sub crée et gère un compte de service pour chaque projet au format service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Pour créer un abonnement BigQuery, le compte de service Pub/Sub doit être autorisé à écrire dans la table BigQuery spécifique et à lire ses métadonnées.

Attribuez le rôle Éditeur de données BigQuery (roles/bigquery.dataEditor) au compte de service Pub/Sub.

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

    Accéder à IAM

  2. Cliquez sur Accorder l'accès.

  3. Dans la section Ajouter des comptes principaux, saisissez le nom de votre compte de service Pub/Sub. 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.

  4. Dans la section Attribuer des rôles, cliquez sur Ajouter un autre rôle.

  5. Dans la liste déroulante Sélectionner un rôle, saisissez BigQuery, puis sélectionnez le rôle Éditeur de données BigQuery.

  6. 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 propriétés suivantes.

Propriétés communes

Découvrez 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 l'abonnement est associé. En outre, Pub/Sub écrit les champs des messages dans les colonnes correspondantes de la table BigQuery.

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

  • Les champs du schéma du sujet et du schéma BigQuery doivent avoir les mêmes noms, et leurs types doivent être compatibles les uns avec les autres.

  • Tout champ facultatif du schéma du sujet doit également l'être dans le schéma BigQuery.

  • Les champs obligatoires du schéma du sujet n'ont pas besoin de l'être dans le schéma BigQuery.

  • Si des champs BigQuery ne sont pas présents dans le schéma du sujet, ils doivent être en mode NULLABLE.

  • Si le schéma du sujet comporte des champs supplémentaires qui ne sont pas présents dans le schéma BigQuery et que ces champs peuvent être ignorés, sélectionnez l'option Supprimer les champs inconnus.

  • Vous ne pouvez sélectionner qu'une seule propriété d'abonnement : Utiliser un schéma du 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, assurez-vous que la table BigQuery comporte une colonne appelée data de type BYTES, STRING ou JSON. Pub/Sub écrit le message dans cette colonne BigQuery.

Il est possible que les modifications apportées au schéma des sujets Pub/Sub ou au schéma de la table BigQuery ne prennent pas effet immédiatement avec les messages écrits dans la table BigQuery. Par exemple, si l'option Drop unknown rows (Supprimer les champs inconnus) est activée et qu'un champ est présent dans le schéma Pub/Sub, mais pas dans le schéma BigQuery, il est possible que les messages écrits dans la table BigQuery ne contiennent toujours pas ce champ après l'avoir ajouté au schéma BigQuery. À terme, les schémas se synchronisent et les messages suivants incluent le champ.

Lorsque vous utilisez l'option Utiliser un schéma de sujet pour votre abonnement BigQuery, vous pouvez également tirer parti de la capture des données modifiées (CDC, Change Data Capture) de BigQuery. La CDC met à jour vos tables BigQuery en traitant et en appliquant les modifications aux lignes existantes.

Pour en savoir plus sur cette fonctionnalité, consultez Diffuser les mises à jour de table avec la 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 BigQuery.

Utiliser le schéma de la table

Cette option permet à Pub/Sub d'utiliser le schéma de la table BigQuery pour écrire les champs d'un message JSON dans les colonnes correspondantes. Lorsque vous utilisez cette option, n'oubliez pas de vérifier 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, ils doivent être en mode NULLABLE.

  • Si les messages comportent des champs supplémentaires qui ne sont pas présents dans le schéma BigQuery et qu'ils peuvent être supprimés, sélectionnez l'option Drop unknownfields (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 encodées à l'aide de BigDecimalByteStringEncoder.

  • Vous ne pouvez sélectionner qu'une seule propriété d'abonnement : Utiliser un schéma du 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, assurez-vous que la table BigQuery comporte une colonne appelée data de type BYTES, STRING ou JSON. Pub/Sub écrit le message dans cette colonne BigQuery.

Il est possible que les modifications apportées au schéma de la table BigQuery ne prennent pas effet immédiatement avec les messages écrits dans la table BigQuery. Par exemple, si l'option Abandonner les champs inconnus est activée et qu'un champ est présent dans les messages, mais pas dans le schéma BigQuery, il est possible que les messages écrits dans la table BigQuery ne contiennent toujours pas ce champ après l'avoir ajouté au schéma BigQuery. À terme, le schéma se synchronise et les messages suivants incluent le champ.

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

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

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

Supprimer les champs inconnus

Cette option est utilisée avec l'option Utiliser un schéma avec sujet ou Utiliser un schéma de table. Cette option permet à Pub/Sub de supprimer tout champ présent dans le schéma du sujet ou le message, mais pas dans le schéma BigQuery. Si l'option Abandonner les champs inconnus n'est pas définie, les messages comportant des champs supplémentaires ne sont pas écrits dans BigQuery et restent en attente dans les tâches d'abonnement. L'abonnement se termine par un état d'erreur.

Écrire des métadonnées

Cette option permet à Pub/Sub d'écrire les métadonnées de chaque message dans des colonnes supplémentaires de la table BigQuery. Sinon, les métadonnées ne sont pas écrites 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 requiert que le champ data, sauf si use_topic_schema est défini sur "true". Si vous sélectionnez à la fois les options Écrire les métadonnées et Utiliser le schéma du sujet, le schéma du sujet ne doit contenir aucun champ dont les noms correspondent à 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 tables BigQuery de destination pour lesquelles les options Utiliser un schéma du sujet ou Utiliser un schéma de table ne sont pas sélectionnées. Si le champ est de type JSON, le corps du message doit être un fichier JSON valide.
attributes

STRING ou JSON

Objet JSON contenant tous les attributs du message. Il contient également des champs supplémentaires qui font partie du message Pub/Sub, y compris la clé de tri, le cas échéant.

Créer un abonnement BigQuery

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

Console

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

    Accéder aux abonnements

  2. Cliquez sur Créer un abonnement.
  3. Dans le champ ID d'abonnement, saisissez un nom.

    Pour en savoir plus sur l'attribution d'un nom à un abonnement, consultez la section Consignes pour nommer un sujet ou un abonnement.

  4. Choisissez ou créez un sujet dans le menu déroulant. L'abonnement reçoit les messages du sujet.
  5. Sélectionnez Write to BigQuery (Type de diffusion) sur Write to BigQuery (Écrire dans BigQuery).
  6. Sélectionnez le projet pour la table BigQuery.
  7. Sélectionnez un ensemble de données existant ou créez-en un.

    Pour en savoir plus sur la création d'un ensemble de données, consultez la page Créer des ensembles de données.

  8. Sélectionnez une table existante ou créez-en une.

    Pour plus d'informations sur la création d'une table, consultez la section Créer des tables.

  9. Nous vous recommandons vivement d'activer la fonctionnalité Dead lettering pour gérer les échecs de message.

    Pour en savoir plus, consultez la section Sujet des lettres mortes.

  10. Cliquez sur Créer.

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

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

    Accéder à Topics

  2. Cliquez sur à côté du sujet pour lequel vous souhaitez créer un abonnement.
  3. Dans le menu contextuel, sélectionnez Créer un abonnement.
  4. Sélectionnez Write to BigQuery (Type de diffusion) sur Write to BigQuery (Écrire dans BigQuery).
  5. Sélectionnez le projet pour la table BigQuery.
  6. Sélectionnez un ensemble de données existant ou créez-en un.

    Pour en savoir plus sur la création d'un ensemble de données, consultez la page Créer des ensembles de données.

  7. Sélectionnez une table existante ou créez-en une.

    Pour en savoir plus sur la création d'un ensemble de données, consultez la section Créer des tables.

  8. Nous vous recommandons vivement d'activer la fonctionnalité Dead lettering pour gérer les échecs de message.

    Pour en savoir plus, consultez la section Sujet des lettres mortes.

  9. Cliquez sur Créer.

gcloud

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

  2. Pour créer un abonnement Pub/Sub, utilisez la commande gcloud pubsub subscriptions create:

    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 de l'abonnement.
    • TOPIC_ID: spécifie l'ID du sujet. Ce sujet nécessite un schéma.
    • PROJECT_ID: spécifie l'ID du projet.
    • DATASET_ID: spécifie l'ID d'un ensemble de données existant. Pour créer un ensemble de données, consultez la page Créer des ensembles de données.
    • TABLE_ID: spécifie l'ID d'une table existante. La table 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++ décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub C++.

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# décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub C#.

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. 


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 décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub Go.

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. 

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 décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub Java.

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. 

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 décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub PHP.

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. 

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 décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub Python.

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. 

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 décrites dans le guide de démarrage rapide de Pub/Sub à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Pub/Sub Ruby.

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. 

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

Étapes suivantes