Créer des abonnements BigQuery

Ce document explique comment créer un abonnement BigQuery. Vous pouvez utiliser la console Google Cloud , 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 connaître les éléments suivants :

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

En plus de votre connaissance de Pub/Sub et de 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 celui de la table BigQuery. Si vous ajoutez une table BigQuery non compatible, un message d'erreur s'affiche. Pour en savoir plus, consultez Compatibilité des schémas.

Rôles et autorisations nécessaires

Pour obtenir les autorisations nécessaires pour créer un abonnement BigQuery, demandez à votre administrateur de vous accorder le rôle IAM Éditeur Pub/Sub (roles/pubsub.editor) sur le projet. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

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

Autorisations requises

Les autorisations suivantes sont requises pour créer un abonnement BigQuery :

pubsub.subscriptions.create sur le projet
pubsub.topics.attachSubscription sur le sujet

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

Abonnements multiprojets

Si vous créez un abonnement dans un projet pour un sujet dans un autre projet, vous devez disposer de l'autorisation pubsub.subscriptions.create sur le projet dans lequel vous créez l'abonnement et de l'autorisation pubsub.topics.attachSubscription sur le sujet.

Attribuer des rôles IAM au compte de service

Pub/Sub utilise un compte de service Identity and Access Management (IAM) pour accéder aux ressources Google Cloud . Par défaut, il utilise l'agent de service Pub/Sub (service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com).

Pour permettre à Pub/Sub d'écrire dans une table BigQuery, le compte de service doit disposer du rôle Éditeur de données BigQuery (roles/bigquery.dataEditor). Vous pouvez accorder des autorisations au compte de service pour le projet ou la table, comme suit :

Projet

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

Accéder à IAM
Sélectionnez Inclure les attributions de rôles fournies par Google.
Recherchez la ligne du compte de service Cloud Pub/Sub, puis cliquez sur Modifier le compte principal.
Cliquez sur Ajouter un autre rôle, puis sélectionnez le rôle Éditeur de données BigQuery.

Pour en savoir plus, consultez Attribuer un rôle IAM à l'aide de la console.

Table

Dans la console Google Cloud , accédez à BigQuery Studio.

Accéder à BigQuery Studio
Dans le champ de recherche du volet "Explorateur" intitulé Filtrer par nom et libellés, saisissez le nom de la table, puis appuyez sur Entrée.
Dans les résultats de recherche, cliquez sur le nom de la table à laquelle vous souhaitez accorder l'autorisation.
Dans l'onglet Détails, cliquez sur Partager > Gérer les autorisations.
Cliquez sur Ajouter un compte principal, puis saisissez l'identifiant du compte de service au format suivant :

service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com.
Dans la liste Attribuer des rôles, sélectionnez Éditeur de données BigQuery.
Cliquez sur Enregistrer. Le rôle est attribué au compte principal sur la ressource.

Utiliser un compte de service personnalisé

En attribuant le rôle Éditeur de données BigQuery au compte de service Cloud Pub/Sub, tout utilisateur autorisé à créer un abonnement dans votre projet peut écrire dans la table BigQuery. Si vous souhaitez accorder des autorisations plus précises, configurez plutôt un compte de service géré par l'utilisateur.

Les autorisations suivantes sont requises pour configurer un compte de service géré par l'utilisateur afin d'écrire dans BigQuery :

Le compte de service géré par l'utilisateur doit disposer du rôle Éditeur de données BigQuery.
Le compte de service Cloud Pub/Sub doit disposer de l'autorisation iam.serviceAccounts.getAccessToken sur le compte de service géré par l'utilisateur.
L'utilisateur qui crée l'abonnement doit disposer de l'autorisation iam.serviceAccounts.actAs sur le compte de service géré par l'utilisateur.

Lorsque vous créez l'abonnement, spécifiez le compte de service géré par l'utilisateur comme compte de service de l'abonnement.

Propriétés des abonnements BigQuery

Les abonnements BigQuery sont compatibles avec toutes les propriétés d'abonnement courantes. Les sections suivantes décrivent les propriétés spécifiques aux abonnements BigQuery.

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é. De plus, 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 exigences 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.
Tout champ facultatif du schéma du sujet doit également être facultatif dans le schéma BigQuery.
Les champs obligatoires dans le schéma du sujet ne doivent pas nécessairement 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 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 de thème ou Utiliser un schéma de table.

Si vous ne sélectionnez pas l'option Utiliser un schéma de sujet ou Utiliser un schéma de table, assurez-vous que la table BigQuery comporte une colonne 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 thèmes 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 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, les messages écrits dans la table BigQuery peuvent toujours ne pas contenir le champ après l'avoir ajouté au schéma BigQuery. Les schémas finissent par se synchroniser et les messages suivants incluent le champ.

Lorsque vous utilisez l'option Utiliser le schéma du sujet pour votre abonnement BigQuery, vous pouvez également profiter 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 des tables avec la capture des données modifiées.

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

Utiliser un schéma de 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 noms de chaque colonne de la table BigQuery ne doivent contenir que des lettres (a-z, A-Z), des chiffres (0-9) ou des traits de soulignement (_).
Les messages publiés doivent être au format JSON.

Si une colonne de table BigQuery est de type de données JSON, le champ correspondant de votre message Pub/Sub doit être un code JSON valide dans une chaîne échappée. Par exemple, pour une colonne nommée myData, le champ de message doit être "myData": "{\"key\":\"value\"}". BigQuery rejette les messages qui ne contiennent pas de code JSON valide.

Les conversions JSON suivantes sont acceptées :

Type JSON	Type de données BigQuery
`string`	`NUMERIC`, `BIGNUMERIC`, `DATE`, `TIME`, `DATETIME` ou `TIMESTAMP`
`number`	`NUMERIC`, `BIGNUMERIC`, `DATE`, `TIME`, `DATETIME` ou `TIMESTAMP`

Lorsque vous utilisez number pour les conversions DATE, DATETIME, TIME ou TIMESTAMP, le nombre doit respecter les représentations acceptées.
Lorsque vous utilisez number pour la conversion en NUMERIC ou BIGNUMERIC, la précision et la plage de valeurs sont limitées à celles acceptées par la norme IEEE 754 pour l'arithmétique à virgule flottante. Si vous avez besoin d'une grande précision ou d'une plage de valeurs plus large, utilisez plutôt les conversions string vers NUMERIC ou BIGNUMERIC.
Lorsque vous utilisez string pour les conversions NUMERIC ou BIGNUMERIC, Pub/Sub suppose que la chaîne est un nombre lisible par l'utilisateur (par exemple, "123.124"). Si le traitement de la chaîne en tant que nombre lisible par l'utilisateur échoue, Pub/Sub traite la chaîne comme des octets encodés avec BigDecimalByteStringEncoder.

Si le sujet de l'abonnement est associé à un schéma, la propriété d'encodage du message 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 que ces champs 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 de thème ou Utiliser un schéma de table.

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 Supprimer 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 le champ après l'avoir ajouté au schéma BigQuery. Le schéma finit par se synchroniser et les messages suivants incluent le champ.

Lorsque vous utilisez l'option Utiliser le schéma de table pour votre abonnement BigQuery, vous pouvez également profiter 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 des tables avec la capture des données modifiées.

Pour savoir 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 les options Utiliser un schéma avec sujet ou Utiliser un schéma de table. Lorsque cette option est activée, Pub/Sub peut supprimer tout champ présent dans le schéma ou le message du sujet, mais pas dans le schéma BigQuery. Les champs qui ne font pas partie du schéma BigQuery sont supprimés lors de l'écriture du message dans la table BigQuery.

Si l'option Supprimer 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, sauf si vous configurez un sujet de lettres mortes.

Le paramètre Supprimer les champs inconnus n'a aucune incidence sur les champs qui ne sont définis ni dans le schéma du sujet Pub/Sub, ni dans le schéma de la table BigQuery. Dans ce cas, un message Pub/Sub valide est remis à l'abonnement. Toutefois, comme BigQuery ne définit pas de colonnes pour ces champs supplémentaires, ils sont supprimés lors du processus d'écriture BigQuery. Pour éviter ce comportement, assurez-vous que tous les champs contenus dans le message Pub/Sub sont également contenus dans le schéma de table BigQuery.

Le comportement concernant les champs supplémentaires peut également dépendre du type de schéma spécifique (Avro, tampon de protocole) et de l'encodage (JSON, binaire) utilisés. Pour en savoir plus sur l'impact de ces facteurs sur le traitement des champs supplémentaires, consultez la documentation concernant votre type de schéma et votre encodage spécifiques.

É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 nécessite que le champ data, sauf si use_topic_schema est défini sur "true". Si vous sélectionnez 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 le nom correspond à celui 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 avec 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 code 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.

Compte de service

Vous disposez des options suivantes pour écrire des messages dans une table BigQuery :

Configurez un compte de service personnalisé afin que seuls les utilisateurs disposant de l'autorisation iam.serviceAccounts.actAs sur le compte de service puissent créer un abonnement qui écrit dans la table. Le rôle Utilisateur du compte de service (roles/iam.serviceAccountUser) est un exemple de rôle qui inclut l'autorisation iam.serviceAccounts.actAs.
Utilisez l'agent de service Pub/Sub par défaut qui permet à tout utilisateur ayant la possibilité de créer des abonnements dans le projet de créer un abonnement qui écrit dans la table. L'agent de service Pub/Sub est le paramètre par défaut lorsque vous ne spécifiez pas de compte de service personnalisé.

Créer un abonnement BigQuery

Pour créer un abonnement avec distribution BigQuery, procédez comme suit.

Console

Dans la console Google Cloud , accédez à la page Créer un abonnement.

Accéder à "Abonnements"
Dans le champ ID d'abonnement, saisissez un nom. Pour savoir comment nommer un abonnement, consultez Consignes de dénomination d'un sujet ou d'un abonnement.
Dans la zone Sélectionner un sujet Cloud Pub/Sub, saisissez ou sélectionnez le sujet à partir duquel recevoir les messages.
Pour Type de livraison, sélectionnez Écrire dans BigQuery.
Sélectionnez la table BigQuery :
1. Pour Projet, sélectionnez le projet Google Cloud qui contient la table BigQuery.
2. Pour Ensemble de données, sélectionnez un ensemble de données existant ou cliquez sur Créer un ensemble de données pour en créer un. Pour savoir comment créer un ensemble de données, consultez Créer des ensembles de données.
3. Dans le champ Table, saisissez le nom de la table. Pour créer une table, cliquez sur le lien qui vous redirige vers la page Créer une table de BigQuery. La page s'ouvre dans un autre onglet. Pour en savoir plus sur la création d'une table, consultez Créer et utiliser des tables.
Pour Configuration du schéma, sélectionnez l'une des options suivantes :
- Ne pas utiliser de schéma. Pub/Sub écrit les octets du message dans une colonne nommée data.
- Utilisez un schéma avec sujet. Pub/Sub utilise le schéma associé au sujet. Pour en savoir plus, consultez Utiliser le schéma de thème.
- Utilisez un schéma de table. Pub/Sub utilise le schéma de la table BigQuery. Pour en savoir plus, consultez Utiliser un schéma de table.
Facultatif. Pour écrire les métadonnées du message dans la table BigQuery, sélectionnez Écrire les métadonnées. Pour en savoir plus, consultez Écrire des métadonnées.
Facultatif. Pour supprimer les champs qui ne sont pas présents dans le schéma de la table BigQuery, sélectionnez Supprimer les champs inconnus. Pour en savoir plus, consultez Supprimer les champs inconnus.
Configurez les propriétés d'abonnement communes selon vos besoins. Nous vous recommandons vivement d'activer la mise en file d'attente des messages non distribués pour gérer les échecs de messages. Pour en savoir plus, consultez Sujet de lettres mortes.
Cliquez sur Créer.

gcloud

Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

En bas 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 commande gcloud pubsub subscriptions create :
```
gcloud pubsub subscriptions create SUBSCRIPTION_ID \
    --topic=TOPIC_ID \
    --bigquery-table=PROJECT_ID.DATASET_ID.TABLE_ID
```
Si vous souhaitez utiliser un compte de service personnalisé, fournissez-le en tant qu'argument supplémentaire :
```
gcloud pubsub subscriptions create SUBSCRIPTION_ID \
    --topic=TOPIC_ID \
    --bigquery-table=PROJECT_ID.DATASET_ID.TABLE_ID \
    --bigquery-service-account-email=SERVICE_ACCOUNT_NAME
```
Remplacez les éléments suivants :
- SUBSCRIPTION_ID : spécifie l'ID de l'abonnement.
- TOPIC_ID : spécifie l'ID du thème. Le 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 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 Créer une table vide avec une définition de schéma.
- SERVICE_ACCOUNT_NAME : spécifie le nom du compte de service à utiliser pour écrire dans BigQuery.

C++

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage C++ qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour C++.

namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::SubscriptionAdminClient client,
   std::string const& project_id, std::string const& topic_id,
   std::string const& subscription_id, std::string const& table_id) {
  google::pubsub::v1::Subscription request;
  request.set_name(
      pubsub::Subscription(project_id, subscription_id).FullName());
  request.set_topic(pubsub::Topic(project_id, topic_id).FullName());
  request.mutable_bigquery_config()->set_table(table_id);
  auto sub = client.CreateSubscription(request);
  if (!sub) {
    if (sub.status().code() == google::cloud::StatusCode::kAlreadyExists) {
      std::cout << "The subscription already exists\n";
      return;
    }
    throw std::move(sub).status();
  }

  std::cout << "The subscription was successfully created: "
            << sub->DebugString() << "\n";
}

C#

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage C# qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour C#.


using Google.Cloud.PubSub.V1;

public class CreateBigQuerySubscriptionSample
{
    public Subscription CreateBigQuerySubscription(string projectId, string topicId, string subscriptionId, string bigqueryTableId)
    {
        SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
        TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
        SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);

        var subscriptionRequest = new Subscription
        {
            SubscriptionName = subscriptionName,
            TopicAsTopicName = topicName,
            BigqueryConfig = new BigQueryConfig
            {
                Table = bigqueryTableId
            }
        };
        var subscription = subscriber.CreateSubscription(subscriptionRequest);
        return subscription;
    }
}

Go

L'exemple suivant utilise la version majeure de la bibliothèque cliente Go Pub/Sub (v2). Si vous utilisez toujours la bibliothèque v1, consultez le guide de migration vers la v2. Pour consulter la liste des exemples de code de la version 1, consultez les exemples de code obsolètes.

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour Go.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub/v2"
	"cloud.google.com/go/pubsub/v2/apiv1/pubsubpb"
)

// createBigQuerySubscription creates a Pub/Sub subscription that exports messages to BigQuery.
func createBigQuerySubscription(w io.Writer, projectID, topic, subscription, table string) error {
	// projectID := "my-project"
	// topic := "projects/my-project-id/topics/my-topic"
	// subscription := "projects/my-project/subscriptions/my-sub"
	// table := "my-project-id.dataset_id.table_id"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	sub, err := client.SubscriptionAdminClient.CreateSubscription(ctx, &pubsubpb.Subscription{
		Name:  subscription,
		Topic: topic,
		BigqueryConfig: &pubsubpb.BigQueryConfig{
			Table:         table,
			WriteMetadata: true,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to create subscription: %w", err)
	}
	fmt.Fprintf(w, "Created BigQuery subscription: %v\n", sub)

	return nil
}

Java

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Java qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour Java.

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

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Node.js qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour Node.js.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const subscriptionNameOrId = 'YOUR_SUBSCRIPTION_NAME_OR_ID';
// const bigqueryTableId = 'YOUR_TABLE_ID';

// Imports the Google Cloud client library
const {PubSub} = require('@google-cloud/pubsub');

// Creates a client; cache this for further use
const pubSubClient = new PubSub();

async function createBigQuerySubscription(
  topicNameOrId,
  subscriptionNameOrId,
  bigqueryTableId,
) {
  const options = {
    bigqueryConfig: {
      table: bigqueryTableId,
      writeMetadata: true,
    },
  };

  await pubSubClient
    .topic(topicNameOrId)
    .createSubscription(subscriptionNameOrId, options);

  console.log(`Subscription ${subscriptionNameOrId} created.`);
}

Node.ts

/**
 * 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 d'installation dans le langage PHP qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour PHP.

use Google\Cloud\PubSub\PubSubClient;
use Google\Cloud\PubSub\V1\BigQueryConfig;

/**
 * Creates a Pub/Sub BigQuery subscription.
 *
 * @param string $projectId  The Google project ID.
 * @param string $topicName  The Pub/Sub topic name.
 * @param string $subscriptionName  The Pub/Sub subscription name.
 * @param string $table      The BigQuery table to which to write.
 */
function create_bigquery_subscription($projectId, $topicName, $subscriptionName, $table)
{
    $pubsub = new PubSubClient([
        'projectId' => $projectId,
    ]);
    $topic = $pubsub->topic($topicName);
    $subscription = $topic->subscription($subscriptionName);
    $config = new BigQueryConfig(['table' => $table]);
    $subscription->create([
        'bigqueryConfig' => $config
    ]);

    printf('Subscription created: %s' . PHP_EOL, $subscription->name());
}

Python

Avant d'essayer cet exemple, suivez les instructions d'installation dans le langage Python qui se trouvent sur la page Démarrage rapide : utiliser des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour Python.

from google.cloud import pubsub_v1

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# bigquery_table_id = "your-project.your-dataset.your-table"

publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)

bigquery_config = pubsub_v1.types.BigQueryConfig(
    table=bigquery_table_id, write_metadata=True
)

# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
    subscription = subscriber.create_subscription(
        request={
            "name": subscription_path,
            "topic": topic_path,
            "bigquery_config": bigquery_config,
        }
    )

print(f"BigQuery subscription created: {subscription}.")
print(f"Table for subscription is: {bigquery_table_id}")

Ruby

L'exemple suivant utilise la bibliothèque cliente Ruby Pub/Sub v3. Si vous utilisez encore la bibliothèque v2, consultez le guide de migration vers la v3. Pour obtenir la liste des exemples de code Ruby v2, consultez les exemples de code obsolètes.

Avant d'essayer cet exemple, suivez les instructions de configuration pour Ruby du guide de démarrage rapide : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API Pub/Sub pour Ruby.

# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# bigquery_table_id = "my-project:dataset-id.table-id"

pubsub = Google::Cloud::PubSub.new project_id: project_id
subscription_admin = pubsub.subscription_admin

subscription = subscription_admin.create_subscription \
  name: pubsub.subscription_path(subscription_id),
  topic: pubsub.topic_path(topic_id),
  bigquery_config: {
    table: bigquery_table_id,
    write_metadata: true
  }

puts "BigQuery subscription created: #{subscription_id}."
puts "Table for subscription is: #{bigquery_table_id}"

Surveiller un abonnement BigQuery

Cloud Monitoring fournit un certain nombre de métriques pour surveiller les abonnements.

Pour obtenir la liste de toutes les métriques disponibles liées à Pub/Sub et leurs descriptions, consultez la documentation sur la surveillance de Pub/Sub.

Vous pouvez également surveiller les abonnements dans Pub/Sub.

Étapes suivantes

Créez ou modifiez un abonnement à l'aide des commandes gcloud.
Créez ou modifiez un abonnement avec les API REST.
Résolvez les problèmes liés à un abonnement BigQuery.