Crea suscripciones a BigQuery

En este documento, se describe cómo crear una suscripción a BigQuery. Puedes usar la consola de Google Cloud, Google Cloud CLI, la biblioteca cliente o la API de Pub/Sub para crear una suscripción a BigQuery.

Antes de comenzar

Antes de leer este documento, asegúrate de estar familiarizado con lo siguiente:

• Cómo funcionan las suscripciones

• El flujo de trabajo de las suscripciones de BigQuery

• Cómo configurar un tema de mensajes no entregados para controlar las fallas de los mensajes

Además de conocer Pub/Sub y BigQuery, asegúrate de cumplir con los siguientes requisitos previos antes de crear una suscripción a BigQuery:

• Que exista una tabla de BigQuery Como alternativa, puedes crear uno cuando crees la suscripción a BigQuery, como se describe en las secciones posteriores de este documento.

• La compatibilidad entre el esquema del tema de Pub/Sub y la tabla de BigQuery. Si agregas una tabla de BigQuery que no es compatible, recibirás un mensaje de error relacionado con la compatibilidad. Para obtener más información, consulta Compatibilidad de esquemas.

Roles y permisos requeridos

A continuación, se muestra una lista de lineamientos relacionados con los roles y los permisos:

• Para crear una suscripción, debes configurar el control de acceso a nivel del proyecto.

• También necesitas permisos a nivel del recurso si tus suscripciones y temas están en diferentes proyectos, como se explica más adelante en esta sección.

• Para crear una suscripción a BigQuery, la cuenta de servicio de Pub/Sub debe tener permiso para escribir en la tabla de BigQuery específica. Para obtener más información sobre cómo otorgar estos permisos, consulta la siguiente sección de este documento.

• Puedes configurar una suscripción a BigQuery en un proyecto para escribir en una tabla de BigQuery en otro proyecto.

Para obtener los permisos que necesitas para crear suscripciones de BigQuery, pídele a tu administrador que te otorgue el rol de IAM de Editor de Pub/Sub (roles/pubsub.editor) en el proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear suscripciones de BigQuery. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Si necesitas crear suscripciones a BigQuery en un proyecto que estén asociadas con un tema en otro proyecto, pídele al administrador del tema que también te otorgue el rol de IAM (roles/pubsub.editor) Editor de Pub/Sub en el tema.

Asigna roles de BigQuery a la cuenta de servicio de Pub/Sub

Algunos servicios de Google Cloud tienen cuentas de servicio administradas por Google Cloud que permiten que los servicios accedan a tus recursos. Estas cuentas de servicio se conocen como agentes de servicio. Pub/Sub crea y mantiene una cuenta de servicio para cada proyecto en el formato service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com.

Para crear una suscripción a BigQuery, la cuenta de servicio de Pub/Sub debe tener permiso para escribir en la tabla de BigQuery específica y leer los metadatos de la tabla.

Otorga el rol de editor de datos de BigQuery (roles/bigquery.dataEditor) a la cuenta de servicio de Pub/Sub.

1. En la consola de Google Cloud, ve a la página IAM.

   Ir a IAM

2. Haz clic en Otorgar acceso.

3. En la sección Agregar principales, ingresa el nombre de tu cuenta de servicio de Pub/Sub. El formato de la cuenta de servicio es service-project-number@gcp-sa-pubsub.iam.gserviceaccount.com. Por ejemplo, para un proyecto con project-number=112233445566, la cuenta de servicio tiene el formato service-112233445566@gcp-sa-pubsub.iam.gserviceaccount.com.

4. En la sección Asignar roles, haz clic en Agregar otra función.

5. En el menú desplegable Selecciona un rol, ingresa BigQuery y selecciona el rol de Editor de datos de BigQuery.

6. Haz clic en Guardar.

Para obtener más información sobre IAM de BigQuery, consulta Roles y permisos de BigQuery.

Propiedades de suscripción a BigQuery

Cuando configuras una suscripción a BigQuery, puedes especificar las siguientes propiedades.

Propiedades comunes

Obtén información sobre las propiedades de suscripción comunes que puedes configurar en todas las suscripciones.

Usar el esquema de tema

Esta opción permite que Pub/Sub use el esquema del tema de Pub/Sub al que está adjunta la suscripción. Además, Pub/Sub escribe los campos de los mensajes en las columnas correspondientes de la tabla de BigQuery.

Cuando uses esta opción, recuerda verificar los siguientes requisitos adicionales:

• Los campos del esquema del tema y del esquema de BigQuery deben tener los mismos nombres, y sus tipos deben ser compatibles entre sí.

• Cualquier campo opcional en el esquema de tema también debe ser opcional en el esquema de BigQuery.

• Los campos obligatorios en el esquema del tema no es necesario que sean obligatorios en el esquema de BigQuery.

• Si hay campos de BigQuery que no están presentes en el esquema del tema, estos campos de BigQuery deben estar en el modo NULLABLE.

• Si el esquema de tema tiene campos adicionales que no están presentes en el esquema de BigQuery y estos campos se pueden descartar, selecciona la opción Descartar campos desconocidos.

• Puedes seleccionar solo una de las propiedades de suscripción, Usar esquema de tema o Usar esquema de tabla.

Si no seleccionas la opción Usar el esquema de tema o Usar el esquema de tabla, asegúrate de que la tabla de BigQuery tenga una columna llamada data de tipo BYTES, STRING o JSON. Pub/Sub escribe el mensaje en esta columna de BigQuery.

Es posible que no veas que los cambios en el esquema de temas de Pub/Sub o el esquema de tablas de BigQuery se apliquen de inmediato con los mensajes que se escriben en la tabla de BigQuery. Por ejemplo, si la opción Descartar campos desconocidos está habilitada y hay un campo presente en el esquema de Pub/Sub, pero no en el esquema de BigQuery, es posible que los mensajes escritos en la tabla de BigQuery aún no contengan el campo después de agregarlo al esquema de BigQuery. Con el tiempo, los esquemas se sincronizan y los mensajes posteriores incluyen el campo.

Cuando usas la opción Usar esquema de tema para tu suscripción a BigQuery, también puedes aprovechar la captura de datos modificados (CDC) de BigQuery. La CDC actualiza las tablas de BigQuery mediante el procesamiento y la aplicación de cambios a las filas existentes.

Para obtener más información sobre esta función, consulta Transmite actualizaciones de tablas con captura de datos modificados.

Para obtener información sobre cómo usar esta función con suscripciones a BigQuery, consulta Captura de datos modificados de BigQuery.

Usar el esquema de tabla

Esta opción permite que Pub/Sub use el esquema de la tabla de BigQuery para escribir los campos de un mensaje en JSON en las columnas correspondientes. Cuando uses esta opción, recuerda verificar los siguientes requisitos adicionales:

• Los mensajes publicados deben estar en formato JSON.

• Se admiten las siguientes conversiones de JSON:

  Tipo de JSON	Tipo de datos de BigQuery
  string	NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME o TIMESTAMP
  number	NUMERIC, BIGNUMERIC, DATE, TIME, DATETIME o TIMESTAMP

  • Cuando se usan conversiones de number a DATE, DATETIME, TIME o TIMESTAMP, el número debe cumplir con las representaciones admitidas.
  • Cuando se usa la conversión de number a NUMERIC o BIGNUMERIC, la precisión y el rango de valores se limitan a los que acepta el estándar IEEE 754 para aritmética de punto flotante. Si necesitas una precisión alta o un rango más amplio de valores, usa las conversiones de string a NUMERIC o BIGNUMERIC.
  • Cuando se usan conversiones de string a NUMERIC o BIGNUMERIC, Pub/Sub supone que la cadena es un número legible por humanos (p.ej., "123.124"). Si el procesamiento de la cadena como un número legible por humanos falla, Pub/Sub la trata como bytes codificados con BigDecimalByteStringEncoder.

• Si el tema de la suscripción tiene un esquema asociado, la propiedad de codificación de mensajes debe establecerse en JSON.

• Si hay campos de BigQuery que no están presentes en los mensajes, estos campos de BigQuery deben estar en el modo NULLABLE.

• Si los mensajes tienen campos adicionales que no están presentes en el esquema de BigQuery y estos campos se pueden descartar, selecciona la opción Descartar campos desconocidos.

• Puedes seleccionar solo una de las propiedades de suscripción, Usar esquema de tema o Usar esquema de tabla.

Si no seleccionas la opción Usar el esquema de tema o Usar el esquema de tabla, asegúrate de que la tabla de BigQuery tenga una columna llamada data de tipo BYTES, STRING o JSON. Pub/Sub escribe el mensaje en esta columna de BigQuery.

Es posible que no veas que los cambios en el esquema de la tabla de BigQuery se implementen de inmediato con los mensajes escritos en la tabla de BigQuery. Por ejemplo, si la opción Descartar campos desconocidos está habilitada y un campo está presente en los mensajes, pero no en el esquema de BigQuery, es posible que los mensajes escritos en la tabla de BigQuery aún no contengan el campo después de agregarlo al esquema de BigQuery. Con el tiempo, se sincroniza el esquema y los mensajes posteriores incluyen el campo.

Cuando usas la opción Usar esquema de tabla para tu suscripción a BigQuery, también puedes aprovechar la captura de datos modificados (CDC) de BigQuery. La CDC actualiza tus tablas de BigQuery mediante el procesamiento y la aplicación de cambios a las filas existentes.

Para obtener más información sobre esta función, consulta Transmite actualizaciones de tablas con captura de datos modificados.

Para obtener información sobre cómo usar esta función con suscripciones a BigQuery, consulta Captura de datos modificados de BigQuery.

Quitar campos desconocidos

Esta opción se usa con las opciones Usar el esquema de tema o Usar el esquema de tabla. Esta opción permite que Pub/Sub descarte cualquier campo que esté presente en el esquema del tema o el mensaje, pero no en el esquema de BigQuery. Si no se configura Descartar campos desconocidos, los mensajes con campos adicionales no se escriben en BigQuery y permanecen en las tareas pendientes de la suscripción. La suscripción termina en un estado de error.

Escribir metadatos

Esta opción permite que Pub/Sub escriba los metadatos de cada mensaje en columnas adicionales de la tabla de BigQuery. De lo contrario, los metadatos no se escriben en la tabla de BigQuery.

Si seleccionas la opción Escribir metadatos, asegúrate de que la tabla de BigQuery tenga los campos que se describen en la siguiente tabla.

Si no seleccionas la opción Escribir metadatos, la tabla de BigQuery de destino solo requiere el campo data, a menos que use_topic_schema sea verdadero. Si seleccionas las opciones Escribir metadatos y Usar esquema del tema, el esquema del tema no debe contener ningún campo con nombres que coincidan con los de los parámetros de metadatos. Esta limitación incluye las versiones en mayúsculas y minúsculas de estos parámetros en formato de barra invertida.

Crea una suscripción a BigQuery

En los siguientes ejemplos, se muestra cómo crear una suscripción con entrega de BigQuery.

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

Supervisa una suscripción a BigQuery

Cloud Monitoring proporciona varias métricas para supervisar las suscripciones.

Para obtener una lista de todas las métricas disponibles relacionadas con Pub/Sub y sus descripciones, consulta la documentación de supervisión de Pub/Sub.

También puedes supervisar las suscripciones desde dentro de Pub/Sub.

¿Qué sigue?

• Crea o modifica una suscripción con los comandos gcloud.
• Crea o modifica una suscripción con las APIs de REST.
• Soluciona problemas relacionados con una suscripción a BigQuery.