BigQuery-Abos erstellen

In diesem Dokument wird beschrieben, wie Sie ein BigQuery-Abo erstellen. Sie können ein BigQuery-Abo über die Google Cloud Console, die Google Cloud CLI, die Clientbibliothek oder die Pub/Sub API erstellen.

Hinweise

Bevor Sie dieses Dokument lesen, sollten Sie mit Folgendem vertraut sein:

• Funktionsweise von Abos

• Der Workflow für BigQuery-Abos

• Informationen zum Konfigurieren eines Themas für unzustellbare Nachrichten, um Nachrichtenfehler zu behandeln.

Sie sollten mit Pub/Sub und BigQuery vertraut sein und die folgenden Voraussetzungen erfüllen, bevor Sie ein BigQuery-Abo erstellen:

• Es gibt eine BigQuery-Tabelle. Alternativ können Sie eine ID erstellen, wenn Sie das BigQuery-Abo erstellen, wie in den folgenden Abschnitten dieses Dokuments beschrieben.

• Kompatibilität zwischen dem Schema des Pub/Sub-Themas und der BigQuery-Tabelle Wenn Sie eine nicht kompatible BigQuery-Tabelle hinzufügen, erhalten Sie eine entsprechende Fehlermeldung. Weitere Informationen finden Sie unter Schemakompatibilität.

Erforderliche Rollen und Berechtigungen

Im Folgenden finden Sie eine Liste von Richtlinien zu Rollen und Berechtigungen:

• Wenn Sie ein Abo erstellen möchten, müssen Sie die Zugriffssteuerung auf Projektebene konfigurieren.

• Sie benötigen auch Berechtigungen auf Ressourcenebene, wenn sich Ihre Abos und Themen in verschiedenen Projekten befinden, wie weiter unten in diesem Abschnitt erläutert.

• Um ein BigQuery-Abo zu erstellen, muss entweder der Pub/Sub-Dienstagent oder ein benutzerdefiniertes Dienstkonto die Berechtigung zum Schreiben in die entsprechende BigQuery-Tabelle haben. Weitere Informationen zum Gewähren dieser Berechtigungen finden Sie im nächsten Abschnitt dieses Dokuments.

• Sie können ein BigQuery-Abo in einem Projekt so konfigurieren, dass es in eine BigQuery-Tabelle in einem anderen Projekt schreibt.

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub-Editor (roles/pubsub.editor) für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen von BigQuery-Abos benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Erstellen von BigQuery-Abos erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Damit ein Nutzer in einem Projekt ein BigQuery-Abo in einem anderen Projekt erstellen kann, müssen Sie ihm in beiden Projekten die Rolle „Pub/Sub-Bearbeiter“ (roles/pubsub.editor) gewähren. Dadurch erhalten Sie die erforderlichen Berechtigungen, um das neue BigQuery-Abo zu erstellen und an das ursprüngliche Thema anzuhängen. Mit der Rolle „Pub/Sub-Bearbeiter“ (roles/pubsub.editor) für das Thema können Sie dem Thema auch BigQuery-Abos in einem anderen Projekt zuordnen.

Dienstkonten Rollen zuweisen

Einige Dienste haben Google Cloud verwaltete Dienstkonten Google Cloud, mit denen die Dienste auf Ihre Ressourcen zugreifen können. Diese Dienstkonten werden als Dienst-Agents bezeichnet. Pub/Sub erstellt und verwaltet für jedes Projekt einen Dienst-Agenten im Format service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Sie können dem Pub/Sub-Dienstagenten oder einem benutzerdefinierten Dienstkonto die Berechtigung zum Schreiben in die BigQuery-Tabelle erteilen.

Wenn Sie dem Pub/Sub-Dienst-Agent die Berechtigung erteilen, kann jeder Nutzer, der berechtigt ist, ein Abo in Ihrem Projekt zu erstellen, in die BigQuery-Tabelle schreiben. Wenn Sie detailliertere Berechtigungen zum Schreiben in die BigQuery-Tabelle gewähren möchten, konfigurieren Sie stattdessen ein benutzerdefiniertes Dienstkonto.

Weitere Informationen zu IAM in BigQuery finden Sie unter BigQuery-Rollen und ‑Berechtigungen.

Dem Pub/Sub-Dienst-Agent BigQuery-Rollen zuweisen

Wenn Sie ein BigQuery-Abo mit dem Pub/Sub-Dienstagenten erstellen möchten, muss er zum Schreiben in die entsprechende BigQuery-Tabelle und zum Lesen der Tabellenmetadaten berechtigt sein.

Weisen Sie dem Pub/Sub-Dienst-Agent die Rolle „BigQuery-Datenbearbeiter“ (roles/bigquery.dataEditor) zu. Sie können die Berechtigung für eine einzelne Tabelle oder für das gesamte Projekt gewähren.

BigQuery-Rollen einem benutzerdefinierten Dienstkonto zuweisen

Wenn Sie ein benutzerdefiniertes Dienstkonto zum Schreiben in eine BigQuery-Tabelle verwenden möchten, müssen Sie die folgenden Berechtigungen festlegen:

• Das benutzerdefinierte Dienstkonto muss die Berechtigung zum Schreiben in die jeweilige BigQuery-Tabelle und zum Lesen der Tabellenmetadaten haben.
• Der Pub/Sub-Dienst-Agent muss die Berechtigung iam.serviceAccounts.getAccessToken für das benutzerdefinierte Dienstkonto haben.
• Der Nutzer, der das Abo erstellt, muss die Berechtigung iam.serviceAccounts.actAs für das benutzerdefinierte Dienstkonto haben.

So erstellen Sie das Dienstkonto und gewähren Berechtigungen:

1. Erstellen Sie das benutzerdefinierte Dienstkonto. Das Dienstkonto muss sich im selben Projekt wie das Abo befinden.

2. Weisen Sie dem benutzerdefinierten Dienstkonto die Rolle „BigQuery-Datenbearbeiter“ (roles/bigquery.dataEditor) zu.

   Sie können die Berechtigung für das Dienstkonto für eine einzelne Tabelle im Projekt oder für alle Tabellen im Projekt gewähren. Weitere Informationen finden Sie im entsprechenden Abschnitt des Artikels BigQuery-Rollen dem Pub/Sub-Dienst-Agent zuweisen. Ersetzen Sie in der Anleitung die E-Mail-Adresse des Pub/Sub-Dienst-Agents durch die E-Mail-Adresse des benutzerdefinierten Dienstkontos.

3. Weisen Sie dem Pub/Sub-Dienstmitarbeiter die Berechtigung iam.serviceAccounts.getAccessToken für das benutzerdefinierte Dienstkonto oder für alle Dienstkonten im Projekt zu. Sie können diese Berechtigung erteilen, indem Sie dem Pub/Sub-Dienst-Agent die Rolle roles/iam.serviceAccountTokenCreator zuweisen.

   Wählen Sie je nach Ihren Anforderungen die geeignete Methode aus.

Wenn Sie das benutzerdefinierte Dienstkonto erstellt haben, sollten Sie bereits die erforderliche iam.serviceAccounts.actAs-Berechtigung haben. Wenn Sie einer anderen Person die Berechtigung für das Dienstkonto erteilen möchten, gehen Sie so vor:

1. Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf.

   Zur Seite „Dienstkonten“

2. Geben Sie den Namen des benutzerdefinierten Dienstkontos in das Feld Filter ein.

3. Wählen Sie das Dienstkonto aus der Liste aus.

4. Klicken Sie auf Hauptkonten mit Zugriff.

5. Klicken Sie auf Zugriff erlauben.

6. Geben Sie im Bereich Hauptkonten hinzufügen den Namen des Kontos ein, dem Sie Zugriff gewähren möchten.

7. Geben Sie im Drop-down-Menü Rolle auswählen die Zahl Service Account ein und wählen Sie die Rolle Dienstkontonutzer aus.

8. Wenn es sich bei Ihrer BigQuery-Tabelle um eine Apache Iceberg-Tabelle handelt, gewähren Sie dem Pub/Sub-Dienstkonto außerdem die Rolle Storage-Administrator (roles/storage.admin), um auf den Cloud Storage-Bucket zuzugreifen.

9. Klicken Sie auf Speichern.

Eigenschaften von BigQuery-Abos

Wenn Sie ein BigQuery-Abo konfigurieren, können Sie die folgenden Eigenschaften angeben.

Allgemeine Eigenschaften

Weitere Informationen zu den allgemeinen Aboeigenschaften, die Sie für alle Abos festlegen können

Schema des Themas verwenden

Mit dieser Option kann Pub/Sub das Schema des Pub/Sub-Themas verwenden, an das das Abo angehängt ist. Außerdem schreibt Pub/Sub die Felder in Nachrichten in die entsprechenden Spalten der BigQuery-Tabelle.

Beachten Sie bei Verwendung dieser Option die folgenden zusätzlichen Anforderungen:

• Die Felder im Themaschema und im BigQuery-Schema müssen dieselben Namen haben und ihre Typen müssen miteinander kompatibel sein.

• Alle optionalen Felder im Schema des Themas müssen auch im BigQuery-Schema optional sein.

• Erforderliche Felder im Themaschema müssen nicht im BigQuery-Schema erforderlich sein.

• Wenn es BigQuery-Felder gibt, die nicht im Themaschema vorhanden sind, müssen diese BigQuery-Felder im Modus NULLABLE sein.

• Wenn das Themaschema zusätzliche Felder enthält, die nicht im BigQuery-Schema vorhanden sind und gelöscht werden können, wählen Sie die Option Unbekannte Felder löschen aus.

• Sie können nur eine der Aboeigenschaften auswählen: Themaschema verwenden oder Tabellenschema verwenden.

Wenn Sie die Option Schema des Themas verwenden oder Tabellenschema verwenden nicht auswählen, muss die BigQuery-Tabelle eine Spalte namens data vom Typ BYTES, STRING oder JSON haben. Pub/Sub schreibt die Nachricht in diese BigQuery-Spalte.

Änderungen am Pub/Sub-Themenschema oder am BigQuery-Tabellenschema werden möglicherweise nicht sofort wirksam, wenn Nachrichten in die BigQuery-Tabelle geschrieben werden. Wenn beispielsweise die Option Unbekannte Felder löschen aktiviert ist und ein Feld im Pub/Sub-Schema, aber nicht im BigQuery-Schema vorhanden ist, enthalten Nachrichten, die in die BigQuery-Tabelle geschrieben werden, das Feld möglicherweise auch dann nicht, wenn es dem BigQuery-Schema hinzugefügt wurde. Irgendwann werden die Schemas synchronisiert und nachfolgende Nachrichten enthalten das Feld.

Wenn Sie die Option Themenschema verwenden für Ihr BigQuery-Abo verwenden, können Sie auch BigQuery Change Data Capture (CDC) nutzen. CDC aktualisiert Ihre BigQuery-Tabellen durch Verarbeitung und Anwendung von Änderungen auf vorhandene Zeilen.

Weitere Informationen zu dieser Funktion finden Sie unter Tabellenaktualisierungen mit Change Data Capture streamen.

Informationen zur Verwendung dieser Funktion mit BigQuery-Abos finden Sie unter BigQuery-Change Data Capture.

Schema der Tabelle verwenden

Mit dieser Option kann Pub/Sub das Schema der BigQuery-Tabelle verwenden, um die Felder einer JSON-Nachricht in die entsprechenden Spalten zu schreiben. Beachten Sie bei Verwendung dieser Option die folgenden zusätzlichen Anforderungen:

• Die Namen der einzelnen Spalten in der BigQuery-Tabelle dürfen nur Buchstaben (a–z, A–Z), Ziffern (0–9) oder Unterstriche (_) enthalten.

• Veröffentlichte Nachrichten müssen im JSON-Format vorliegen.

• Die folgenden JSON-Konvertierungen werden unterstützt:

  JSON-Typ	BigQuery-Datentyp
  string	NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME oder TIMESTAMP
  number	NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME oder TIMESTAMP

  • Wenn Sie number bis DATE, DATETIME, TIME oder TIMESTAMP-Conversions verwenden, muss die Zahl den unterstützten Darstellungen entsprechen.
  • Bei der Umwandlung von number in NUMERIC oder BIGNUMERIC sind Genauigkeit und Wertebereich auf die Werte beschränkt, die vom IEEE 754-Standard für Gleitkommaarithmetik akzeptiert werden. Wenn Sie eine hohe Genauigkeit oder einen größeren Wertebereich benötigen, verwenden Sie stattdessen string bis NUMERIC oder BIGNUMERIC-Conversions.
  • Bei der Verwendung von string- bis NUMERIC- oder BIGNUMERIC-Konvertierungen geht Pub/Sub davon aus, dass der String eine für Menschen lesbare Zahl ist (z.B. "123.124"). Wenn die Verarbeitung des Strings als für Menschen lesbare Zahl fehlschlägt, behandelt Pub/Sub den String als mit dem BigDecimalByteStringEncoder codierte Bytes.

• Wenn dem Thema des Abos ein Schema zugewiesen ist, muss die Eigenschaft „Nachrichtencodierung“ auf JSON festgelegt sein.

• Wenn BigQuery-Felder vorhanden sind, die nicht in den Nachrichten enthalten sind, müssen diese BigQuery-Felder sich im Modus NULLABLE befinden.

• Wenn die Nachrichten zusätzliche Felder enthalten, die nicht im BigQuery-Schema vorhanden sind und gelöscht werden können, wählen Sie die Option Unbekannte Felder löschen aus.

• Sie können nur eine der Aboeigenschaften auswählen: Themaschema verwenden oder Tabellenschema verwenden.

Wenn Sie die Option Schema des Themas verwenden oder Tabellenschema verwenden nicht auswählen, muss die BigQuery-Tabelle eine Spalte namens data vom Typ BYTES, STRING oder JSON haben. Pub/Sub schreibt die Nachricht in diese BigQuery-Spalte.

Änderungen am BigQuery-Tabellenschema werden möglicherweise nicht sofort für Nachrichten übernommen, die in die BigQuery-Tabelle geschrieben werden. Wenn beispielsweise die Option Unbekannte Felder löschen aktiviert ist und ein Feld in den Nachrichten, aber nicht im BigQuery-Schema vorhanden ist, enthalten Nachrichten, die in die BigQuery-Tabelle geschrieben werden, das Feld möglicherweise auch dann nicht, wenn es dem BigQuery-Schema hinzugefügt wurde. Nach einiger Zeit wird das Schema synchronisiert und nachfolgende Nachrichten enthalten das Feld.

Wenn Sie für Ihr BigQuery-Abo die Option Tabellenschema verwenden verwenden, können Sie auch BigQuery Change Data Capture (CDC) nutzen. CDC aktualisiert Ihre BigQuery-Tabellen durch Verarbeitung und Anwendung von Änderungen auf vorhandene Zeilen.

Weitere Informationen zu dieser Funktion finden Sie unter Tabellenaktualisierungen mit Change Data Capture streamen.

Informationen zur Verwendung dieser Funktion mit BigQuery-Abos finden Sie unter BigQuery-Change Data Capture.

Unbekannte Felder löschen

Diese Option wird mit der Option Schema des Themas verwenden oder Schema der Tabelle verwenden verwendet. Wenn diese Option aktiviert ist, kann Pub/Sub alle Felder löschen, die im Schema des Themas oder in der Nachricht, aber nicht im BigQuery-Schema vorhanden sind. Felder, die nicht Teil des BigQuery-Schemas sind, werden beim Schreiben der Nachricht in die BigQuery-Tabelle gelöscht.

Wenn Unbekannte Felder löschen nicht festgelegt ist, werden Nachrichten mit zusätzlichen Feldern nicht in BigQuery geschrieben und verbleiben im Rückstand des Abos, es sei denn, Sie konfigurieren ein Thema für unzustellbare Nachrichten.

Die Einstellung Unbekannte Felder löschen hat keine Auswirkungen auf Felder, die weder im Pub/Sub-Thema-Schema noch im BigQuery-Tabellenschema definiert sind. In diesem Fall wird eine gültige Pub/Sub-Nachricht an das Abo gesendet. Da in BigQuery jedoch keine Spalten für diese zusätzlichen Felder definiert sind, werden sie beim Schreiben in BigQuery gelöscht. Um dieses Verhalten zu vermeiden, müssen alle Felder in der Pub/Sub-Nachricht auch im BigQuery-Tabellenschema enthalten sein.

Das Verhalten bei zusätzlichen Feldern kann auch vom verwendeten Schematyp (Avro, Protocol Buffer) und der Codierung (JSON, Binär) abhängen. Informationen dazu, wie sich diese Faktoren auf die Verarbeitung zusätzlicher Felder auswirken, finden Sie in der Dokumentation für Ihren spezifischen Schematyp und Ihre spezifische Codierung.

Metadaten schreiben

Mit dieser Option kann Pub/Sub die Metadaten jeder Nachricht in zusätzliche Spalten in der BigQuery-Tabelle schreiben. Andernfalls werden die Metadaten nicht in die BigQuery-Tabelle geschrieben.

Wenn Sie die Option Metadaten schreiben auswählen, muss die BigQuery-Tabelle die in der folgenden Tabelle beschriebenen Felder enthalten.

Wenn Sie die Option Metadaten schreiben nicht auswählen, ist für die BigQuery-Tabelle nur das Feld data erforderlich, es sei denn, use_topic_schema ist wahr. Wenn Sie sowohl die Option Metadaten schreiben als auch Schema des Themas verwenden auswählen, darf das Schema des Themas keine Felder mit Namen enthalten, die mit denen der Metadatenparameter übereinstimmen. Diese Einschränkung gilt auch für CamelCase-Versionen dieser Parameter.

BigQuery-Abo erstellen

Die folgenden Beispiele zeigen, wie Sie ein Abo mit BigQuery-Zustellung erstellen.

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";
}

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;
    }
}

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
}

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());
    }
  }
}

/**
 * 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.`);
}

/**
 * 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.`);
}

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());
}

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}")

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

BigQuery-Abo überwachen

Cloud Monitoring bietet eine Reihe von Messwerten, mit denen Sie Abos überwachen können.

Eine Liste aller verfügbaren Pub/Sub-Messwerte und ihre Beschreibungen finden Sie in der Monitoring-Dokumentation für Pub/Sub.

Sie können Abos auch in Pub/Sub überwachen.

Nächste Schritte

• Erstellen oder ändern Sie ein Abo mit gcloud-Befehlen.
• Mit REST APIs ein Abo erstellen oder ändern
• Fehlerbehebung bei einem BigQuery-Abo