Crear un tema de importación de Azure Event Hubs

Un tema de importación de Azure Event Hubs te permite ingerir datos de forma continua desde Azure Event Hubs como fuente externa y en Pub/Sub. Después, puedes transmitir los datos a cualquiera de los destinos que admite Pub/Sub.

En este documento se explica cómo crear y gestionar temas de importación de Azure Event Hubs. Para crear un tema estándar, consulta Crear un tema estándar.

Para obtener más información sobre los temas de importación, consulta el artículo Acerca de los temas de importación.

Antes de empezar

Roles y permisos necesarios

Para obtener los permisos que necesitas para crear y gestionar temas de importación de Azure Event Hubs, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Editor de Pub/Sub (roles/pubsub.editor) en tu tema o proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear y gestionar temas de importación de Azure Event Hubs. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Se necesitan los siguientes permisos para crear y gestionar temas de importación de Azure Event Hubs:

  • Crea un tema de importación: pubsub.topics.create
  • Eliminar un tema importado: pubsub.topics.delete
  • Obtener un tema de importación: pubsub.topics.get
  • Para enumerar un tema de importación, sigue estos pasos: pubsub.topics.list
  • Publicar en un tema de importación: pubsub.topics.publish and pubsub.serviceAgent
  • Actualizar un tema de importación: pubsub.topics.update
  • Obtiene la política de gestión de identidades y accesos de un tema de importación: pubsub.topics.getIamPolicy
  • Configura la política de gestión de identidades y accesos de un tema de importación: pubsub.topics.setIamPolicy

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

Puedes configurar el control de acceso a nivel de proyecto y de recurso individual.

Configurar la identidad federada para acceder a Azure Event Hubs

La federación de identidades de cargas de trabajo permite que los servicios accedan a cargas de trabajo que se ejecutan fuera de Google Cloud. Google Cloud Con la federación de identidades, no es necesario mantener ni transferir credenciales a Google Cloud para acceder a tus recursos en otras nubes. En su lugar, puedes usar las identidades de las cargas de trabajo para autenticarte en Google Cloud y acceder a los recursos.

Crear una cuenta de servicio en Google Cloud

Este paso es opcional. Si ya tienes una cuenta de servicio, puedes usarla en este procedimiento en lugar de crear una nueva. Si usas una cuenta de servicio, ve a Registrar el ID único de la cuenta de servicio para el siguiente paso.

En el caso de los temas de importación de Azure Event Hubs, Pub/Sub usa la cuenta de servicio como identidad para acceder a los recursos de Azure.

Para obtener más información sobre cómo crear una cuenta de servicio, incluidos los requisitos previos, los roles y permisos necesarios, y las directrices para asignar nombres, consulta el artículo Crear cuentas de servicio. Después de crear una cuenta de servicio, es posible que tengas que esperar 60 segundos o más antes de usarla. Este comportamiento se produce porque las operaciones de lectura son coherentes con el tiempo. La nueva cuenta de servicio puede tardar en aparecer.

Registrar el ID único de la cuenta de servicio

Necesitas un ID único de cuenta de servicio para configurar el registro de aplicaciones en Azure.

  1. En la Google Cloud consola, ve a la página de detalles de la cuenta de servicio.

    Ir a la cuenta de servicio

  2. Haz clic en la cuenta de servicio que acabas de crear o en la que tienes previsto usar.

  3. En la página Detalles de la cuenta de servicio, anota el número de ID único.

    Necesitas el ID como parte del flujo de trabajo para configurar el registro de aplicaciones en Azure.

Añadir el rol de creador de tokens de cuenta de servicio a la cuenta de servicio de Pub/Sub

El rol Creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator) permite a las entidades principales crear credenciales de duración reducida para una cuenta de servicio. Estos tokens o credenciales se usan para suplantar la identidad de la cuenta de servicio.

Para obtener más información sobre la suplantación de identidad en cuentas de servicio, consulta el artículo Suplantación de identidad en cuentas de servicio.

También puedes añadir el rol de editor de Pub/Sub (roles/pubsub.publisher) durante este procedimiento. Para obtener más información sobre el rol y por qué lo añade, consulte Añadir el rol de editor de Pub/Sub a la cuenta de servicio de Pub/Sub.

  1. En la consola, ve a la página Gestión de identidades y accesos. Google Cloud

    Ir a IAM

  2. Marca la casilla Incluir concesiones de roles proporcionadas por Google.

  3. Busca la cuenta de servicio que tenga el formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. En esta cuenta de servicio, haz clic en el botón Editar principal.

  5. Si es necesario, haz clic en Añadir otro rol.

  6. Busca y haz clic en el rol Creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator).

  7. Haz clic en Guardar.

Crear un registro de aplicación con la federación de identidades

Para ingerir datos de Azure Event Hubs, registra una aplicación en la plataforma de identidad de Microsoft y habilita la federación de identidades en tu cuenta de servicio. De esta forma, tu cuenta de servicio puede autenticarse en Azure.

Para obtener más información sobre cómo registrar una aplicación en la plataforma de identidad de Microsoft, consulta la guía de inicio rápido sobre el registro de aplicaciones de Azure.

  1. Inicia sesión en el portal de Azure y abre la página Microsoft Entra ID.

  2. En el panel de navegación, haz clic en Gestionar > Registros de aplicaciones.

  3. Haz clic en Nuevo registro.

  4. Ponle un nombre a la aplicación y, en Tipos de cuenta admitidos, selecciona cualquier opción que no sea Solo cuentas personales de Microsoft.

  5. Para registrar la aplicación, haz clic en Registrar.

  6. Abre la aplicación y haz clic en Gestionar > Certificados y secretos.

  7. Haz clic en Añadir credencial.

  8. Para configurar una credencial federada, haz clic en Otro emisor.

  9. En el campo Emisor, introduce https://accounts.google.com.

  10. En el campo Valor, introduce el ID único de tu cuenta de servicio de Pub/Sub.

    Puedes encontrar este ID en Anota el ID único de la cuenta de servicio.

  11. Ponle un nombre a la identidad federada y haz clic en Añadir.

Asignar roles a la aplicación registrada

Para permitir que Pub/Sub lea de tu centro de eventos de Azure, concede los roles necesarios a tu aplicación registrada.

  1. Inicia sesión en el portal de Azure y abre tu espacio de nombres de Event Hubs.

    Para abrir un espacio de nombres, escriba Event Hubs en la búsqueda y, a continuación, haga clic en uno de los espacios de nombres.

  2. En la barra lateral, haz clic en Control de acceso (IAM).

  3. Haz clic en Añadir > Añadir asignación de rol.

  4. Selecciona el rol Receptor de datos de Azure Event Hubs y, a continuación, haz clic en Siguiente.

    De esta forma, la cuenta de servicio de Pub/Sub tendrá acceso de lectura a tu centro de eventos de Azure.

  5. Haz clic en + Seleccionar miembros y busca la aplicación registrada.

  6. Escribe el nombre de la aplicación registrada en el campo de búsqueda.

  7. Haz clic en el nombre de tu aplicación y, a continuación, en Seleccionar.

  8. Haz clic en Revisar y asignar.

  9. Repite los pasos del 3 al 6 y añade el rol Remitente de datos de Azure Event Hubs.

    Este rol concede permiso a la cuenta de servicio de Google Cloud para obtener metadatos de tu centro de eventos de Azure.

Para obtener más información sobre cómo asignar roles de Azure, consulta la página Asignar roles de Azure.

Añadir el rol de editor de Pub/Sub a la cuenta principal de Pub/Sub

Para habilitar la publicación, debes asignar un rol de editor a la cuenta de servicio de Pub/Sub para que Pub/Sub pueda publicar en el tema de importación de Azure Event Hubs.

Añadir el rol de agente de servicio de Pub/Sub a la cuenta de servicio de Pub/Sub

Para permitir que Pub/Sub use la cuota de publicación del proyecto del tema de importación, el agente de servicio de Pub/Sub necesita el permiso serviceusage.services.use en el proyecto del tema de importación.

Para conceder este permiso, te recomendamos que añadas el rol de agente de servicio de Pub/Sub a la cuenta de servicio de Pub/Sub.

Si la cuenta de servicio de Pub/Sub no tiene el rol de agente de servicio de Pub/Sub, se le puede asignar de la siguiente manera:

  1. En la consola, ve a la página Gestión de identidades y accesos. Google Cloud

    Ir a IAM

  2. Marca la casilla Incluir concesiones de roles proporcionadas por Google.

  3. Busca la cuenta de servicio que tenga el formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. En esta cuenta de servicio, haz clic en el botón Editar principal.

  5. Si es necesario, haz clic en Añadir otro rol.

  6. Busca y haz clic en el rol Agente de servicio de Pub/Sub (roles/pubsub.serviceAgent).

  7. Haz clic en Guardar.

Habilitar la publicación de todos los temas

Usa este método si no has creado ningún tema de importación de Azure Event Hubs.

  1. En la consola, ve a la página Gestión de identidades y accesos. Google Cloud

    Ir a IAM

  2. Marca la casilla Incluir concesiones de roles proporcionadas por Google.

  3. Busca la cuenta de servicio que tenga el formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com.

  4. En esta cuenta de servicio, haz clic en el botón Editar principal.

  5. Si es necesario, haz clic en Añadir otro rol.

  6. Busca y haz clic en el rol Editor de Pub/Sub (roles/pubsub.publisher).

  7. Haz clic en Guardar.

Habilitar la publicación desde un solo tema

Utiliza este método solo si ya existe el tema de importación de Azure Event Hubs.

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Ejecuta el comando gcloud pubsub topics add-iam-policy-binding:

    gcloud pubsub topics add-iam-policy-binding TOPIC_ID \
   --member="serviceAccount:service-PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com" \
   --role="roles/pubsub.publisher"

    Haz los cambios siguientes:

    • TOPIC_ID: el ID del tema de importación de Azure Event Hubs.

    • PROJECT_NUMBER: el número de proyecto. Para ver el número de proyecto, consulta el artículo Identificar proyectos.

    3. Añadir el rol de usuario de cuenta de servicio a la cuenta de servicio

    El rol Usuario de cuenta de servicio (roles/iam.serviceAccountUser) incluye el permiso iam.serviceAccounts.actAs, que permite que un principal adjunte una cuenta de servicio a los ajustes de ingestión del tema de importación de Azure Event Hubs y use esa cuenta de servicio para la identidad federada.

    1. En la consola, ve a la página Gestión de identidades y accesos. Google Cloud

      Ir a IAM

    2. En el principal que emite las llamadas para crear o actualizar temas, haz clic en el botón Editar principal.

    3. Si es necesario, haz clic en Añadir otro rol.

    4. Busca y haz clic en el rol Usuario de cuenta de servicio (roles/iam.serviceAccountUser).

    5. Haz clic en Guardar.

    Usar temas de importación de Azure Event Hubs

    Puede crear un tema de importación o editar uno que ya tenga.

    Cuestiones importantes

    • Si creas el tema y la suscripción por separado, aunque lo hagas de forma rápida, se pueden perder datos. Hay un breve periodo en el que el tema está disponible sin suscripción. Si se envían datos al tema durante este periodo, se perderán. Si creas el tema primero, luego la suscripción y, por último, conviertes el tema en un tema de importación, te aseguras de que no se pierda ningún mensaje durante el proceso de importación.

    • Si necesitas volver a crear el centro de eventos de Azure de un tema de importación con el mismo nombre, no puedes simplemente eliminarlo y volver a crearlo. Esta acción puede invalidar la gestión de desfases de Pub/Sub, lo que puede provocar la pérdida de datos. Para mitigar este problema, sigue estos pasos:

      • Eliminar el tema de importación de Pub/Sub
      • Eliminar el centro de eventos de Azure
      • Crear el centro de eventos de Azure
      • Crear el tema de importación de Pub/Sub

    • Los datos de un centro de eventos de Azure siempre se leen desde el desplazamiento más antiguo.

    Crear temas de importación de Azure Event Hubs

    Para obtener más información sobre las propiedades asociadas a un tema, consulta Propiedades de un tema.

    Asegúrate de que has completado los siguientes procedimientos:

    Para crear un tema de importación de Azure Event Hubs, siga estos pasos:

    Consola

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

      Ir a Temas

    2. Haz clic en Crear tema.

    3. En el campo ID de tema, introduce un ID para el tema de importación de Azure Event Hubs. Para obtener más información sobre cómo asignar nombres a los temas, consulta las directrices de nomenclatura.

    4. Selecciona Añadir una suscripción predeterminada.

    5. Selecciona Habilitar la ingesta.

    6. En Fuente de ingestión, seleccione Azure Event Hubs.

    7. Introduce los siguientes datos:

      • Grupo de recursos: el nombre del grupo de recursos de Azure que contiene el espacio de nombres de Azure Event Hubs que quieres insertar en Pub/Sub.
      • Espacio de nombres de Event Hub: el nombre del espacio de nombres de Azure Event Hubs que contiene el Event Hub de Azure que quieres insertar en Pub/Sub.
      • Event Hub: el nombre del centro de eventos de Azure que quieres ingerir en Pub/Sub.
      • ID de cliente: el ID de la aplicación (cliente) registrada en Azure que contiene la identidad federada de la cuenta de servicio de Google Cloud. Este valor debe ser un UUID. Para obtener más información, visita la página de registro de aplicaciones de Azure.
      • ID de cliente: el ID de directorio (cliente) del cliente propietario del centro de eventos de Azure que quieres insertar en Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de cliente, visita la página de Azure para obtener los IDs de suscripción y de cliente.
      • ID de suscripción: el ID de suscripción de la suscripción propietaria del grupo de recursos de Azure Event Hubs. Este valor debe ser un UUID. Para encontrar tu ID de suscripción, ve a la página de Azure para obtener los IDs de suscripción y de cliente.
      • Cuenta de servicio: la cuenta de servicio que has creado en Crear una cuenta de servicio Google Cloud.

    8. Deja los campos restantes con los valores predeterminados.

    9. Haz clic en Crear tema.

    gcloud

    1. In the Google Cloud console, activate Cloud Shell.

      Activate Cloud Shell

      At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    2. Ejecuta el comando gcloud pubsub topics create:

        gcloud pubsub topics create TOPIC_ID \
      --azure-event-hubs-ingestion-resource-group RESOURCE_GROUP \
      --azure-event-hubs-ingestion-namespace NAMESPACE \
      --azure-event-hubs-ingestion-event-hub EVENT_HUB \
      --azure-event-hubs-ingestion-client-id CLIENT_ID \
      --azure-event-hubs-ingestion-tenant-id TENANT_ID \
      --azure-event-hubs-ingestion-subscription-id SUBSCRIPTION_ID \
      --azure-event-hubs-ingestion-service-account SERVICE_ACCOUNT

      Haz los cambios siguientes:

      • TOPIC_ID: el nombre o el ID de tu tema de Pub/Sub.
      • RESOURCE_GROUP: el nombre del grupo de recursos de Azure Event Hubs que contiene el espacio de nombres de Azure Event Hubs en el que quieres insertar datos en Pub/Sub.
      • NAMESPACE: el nombre del espacio de nombres de Azure Event Hubs que contiene el centro de eventos de Azure que quiere insertar en Pub/Sub.
      • EVENT_HUB: el nombre del centro de eventos de Azure que quieres insertar en Pub/Sub.
      • CLIENT_ID: el ID (de cliente) de la aplicación registrada en Azure que contiene la identidad federada de la cuenta de servicioGoogle Cloud . Este valor debe ser un UUID. Para obtener más información, visita la página de registro de aplicaciones de Azure.
      • TENANT_ID: el ID de directorio (inquilino) del inquilino propietario del centro de eventos de Azure que tiene previsto ingerir en Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de cliente, visita la página Obtener los IDs de suscripción y de cliente de Azure.
      • SUBSCRIPTION_ID: el ID de suscripción de la suscripción que posee el centro de eventos de Azure que quieres ingerir en Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de suscripción, ve a la página de Azure para obtener los IDs de suscripción y de cliente.
      • SERVICE_ACCOUNT: la cuenta de servicio que has creado en Crear una cuenta de servicio en Google Cloud

      3. C++

      Antes de probar este ejemplo, sigue las instrucciones de configuración de C++ que se indican en la guía de inicio rápido sobre cómo usar bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de C++ de Pub/Sub. 

      namespace pubsub = ::google::cloud::pubsub;
namespace pubsub_admin = ::google::cloud::pubsub_admin;
[](pubsub_admin::TopicAdminClient client, std::string project_id,
   std::string topic_id, std::string const& resource_group,
   std::string const& event_hubs_namespace, std::string const& event_hub,
   std::string const& client_id, std::string const& tenant_id,
   std::string const& subscription_id,
   std::string const& gcp_service_account) {
  google::pubsub::v1::Topic request;
  request.set_name(
      pubsub::Topic(std::move(project_id), std::move(topic_id)).FullName());
  auto* azure_event_hubs = request.mutable_ingestion_data_source_settings()
                               ->mutable_azure_event_hubs();
  azure_event_hubs->set_resource_group(resource_group);
  azure_event_hubs->set_namespace_(event_hubs_namespace);
  azure_event_hubs->set_event_hub(event_hub);
  azure_event_hubs->set_client_id(client_id);
  azure_event_hubs->set_tenant_id(tenant_id);
  azure_event_hubs->set_subscription_id(subscription_id);
  azure_event_hubs->set_gcp_service_account(gcp_service_account);

  auto topic = client.CreateTopic(request);
  // Note that kAlreadyExists is a possible error when the library retries.
  if (topic.status().code() == google::cloud::StatusCode::kAlreadyExists) {
    std::cout << "The topic already exists\n";
    return;
  }
  if (!topic) throw std::move(topic).status();

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

      Go

      En el siguiente ejemplo se usa la versión principal de la biblioteca de cliente de Pub/Sub de Go (v2). Si sigues usando la biblioteca v1, consulta la guía de migración a la versión 2. Para ver una lista de ejemplos de código de la versión 1, consulta los ejemplos de código obsoletos.

      Antes de probar este ejemplo, sigue las instrucciones de configuración de Go que se indican en la guía de inicio rápido sobre cómo usar bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Pub/Sub.

      import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/pubsub"
)

func createTopicWithAzureEventHubsIngestion(w io.Writer, projectID, topicID, resourceGroup, namespace, eventHub, clientID, tenantID, subID, gcpSA string) error {
	// projectID := "my-project-id"
	// topicID := "my-topic"

	// // Azure Event Hubs ingestion settings.
	// resourceGroup := "resource-group"
	// namespace := "namespace"
	// eventHub := "event-hub"
	// clientID := "client-id"
	// tenantID := "tenant-id"
	// subID := "subscription-id"
	// gcpSA := "gcp-service-account"

	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	cfg := &pubsub.TopicConfig{
		IngestionDataSourceSettings: &pubsub.IngestionDataSourceSettings{
			Source: &pubsub.IngestionDataSourceAzureEventHubs{
				ResourceGroup:     resourceGroup,
				Namespace:         namespace,
				EventHub:          eventHub,
				ClientID:          clientID,
				TenantID:          tenantID,
				SubscriptionID:    subID,
				GCPServiceAccount: gcpSA,
			},
		},
	}
	t, err := client.CreateTopicWithConfig(ctx, topicID, cfg)
	if err != nil {
		return fmt.Errorf("CreateTopic: %w", err)
	}
	fmt.Fprintf(w, "Created topic with azure event hubs ingestion: %v\n", t)
	return nil
}

      Java

      Antes de probar este ejemplo, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido sobre cómo usar bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de Pub/Sub. 

      
import com.google.cloud.pubsub.v1.TopicAdminClient;
import com.google.pubsub.v1.IngestionDataSourceSettings;
import com.google.pubsub.v1.Topic;
import com.google.pubsub.v1.TopicName;
import java.io.IOException;

public class CreateTopicWithAzureEventHubsIngestionExample {
  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";
    // Azure Event Hubs ingestion settings.
    String resourceGroup = "resource-group";
    String namespace = "namespace";
    String eventHub = "event-hub";
    String clientId = "client-id";
    String tenantId = "tenant-id";
    String subscriptionId = "subscription-id";
    String gcpServiceAccount = "gcp-service-account";

    createTopicWithAzureEventHubsIngestionExample(
        projectId,
        topicId,
        resourceGroup,
        namespace,
        eventHub,
        clientId,
        tenantId,
        subscriptionId,
        gcpServiceAccount);
  }

  public static void createTopicWithAzureEventHubsIngestionExample(
      String projectId,
      String topicId,
      String resourceGroup,
      String namespace,
      String eventHub,
      String clientId,
      String tenantId,
      String subscriptionId,
      String gcpServiceAccount)
      throws IOException {
    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      TopicName topicName = TopicName.of(projectId, topicId);

      IngestionDataSourceSettings.AzureEventHubs azureEventHubs =
          IngestionDataSourceSettings.AzureEventHubs.newBuilder()
              .setResourceGroup(resourceGroup)
              .setNamespace(namespace)
              .setEventHub(eventHub)
              .setClientId(clientId)
              .setTenantId(tenantId)
              .setSubscriptionId(subscriptionId)
              .setGcpServiceAccount(gcpServiceAccount)
              .build();
      IngestionDataSourceSettings ingestionDataSourceSettings =
          IngestionDataSourceSettings.newBuilder().setAzureEventHubs(azureEventHubs).build();

      Topic topic =
          topicAdminClient.createTopic(
              Topic.newBuilder()
                  .setName(topicName.toString())
                  .setIngestionDataSourceSettings(ingestionDataSourceSettings)
                  .build());

      System.out.println(
          "Created topic with Azure Event Hubs ingestion settings: " + topic.getAllFields());
    }
  }
}

      Node.js

      Antes de probar este ejemplo, sigue las instrucciones de configuración de Node.js que se indican en la guía de inicio rápido sobre cómo usar bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Node.js de Pub/Sub. 

      /**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const resourceGroup = 'YOUR_RESOURCE_GROUP';
// const namespace = 'YOUR_NAMESPACE';
// const eventHub = 'YOUR_EVENT_HUB';
// const clientId = 'YOUR_CLIENT_ID';
// const tenantId = 'YOUR_TENANT_ID';
// const subscriptionId = 'YOUR_SUBSCRIPTION_ID';
// const gcpServiceAccount = 'ingestion-account@...';

// 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 createTopicWithAzureEventHubsIngestion(
  topicNameOrId,
  resourceGroup,
  namespace,
  eventHub,
  clientId,
  tenantId,
  subscriptionId,
  gcpServiceAccount,
) {
  // Creates a new topic with Azure Event Hubs ingestion.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    ingestionDataSourceSettings: {
      azureEventHubs: {
        resourceGroup,
        namespace,
        eventHub,
        clientId,
        tenantId,
        subscriptionId,
        gcpServiceAccount,
      },
    },
  });
  console.log(
    `Topic ${topicNameOrId} created with Azure Event Hubs ingestion.`,
  );
}

      Node.ts

      Antes de probar este ejemplo, sigue las instrucciones de configuración de Node.js que se indican en la guía de inicio rápido sobre cómo usar bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Node.js de Pub/Sub. 

      /**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const resourceGroup = 'YOUR_RESOURCE_GROUP';
// const namespace = 'YOUR_NAMESPACE';
// const eventHub = 'YOUR_EVENT_HUB';
// const clientId = 'YOUR_CLIENT_ID';
// const tenantId = 'YOUR_TENANT_ID';
// const subscriptionId = 'YOUR_SUBSCRIPTION_ID';
// const gcpServiceAccount = 'ingestion-account@...';

// Imports the Google Cloud client library
import {PubSub} from '@google-cloud/pubsub';

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

async function createTopicWithAzureEventHubsIngestion(
  topicNameOrId: string,
  resourceGroup: string,
  namespace: string,
  eventHub: string,
  clientId: string,
  tenantId: string,
  subscriptionId: string,
  gcpServiceAccount: string,
) {
  // Creates a new topic with Azure Event Hubs ingestion.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    ingestionDataSourceSettings: {
      azureEventHubs: {
        resourceGroup,
        namespace,
        eventHub,
        clientId,
        tenantId,
        subscriptionId,
        gcpServiceAccount,
      },
    },
  });
  console.log(
    `Topic ${topicNameOrId} created with Azure Event Hubs ingestion.`,
  );
}

      Python

      Antes de probar este ejemplo, sigue las instrucciones de configuración de Python que se indican en la guía de inicio rápido sobre cómo usar bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API de Python de Pub/Sub. 

      from google.cloud import pubsub_v1
from google.pubsub_v1.types import Topic
from google.pubsub_v1.types import IngestionDataSourceSettings

# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# resource_group = "your-resource-group"
# namespace = "your-namespace"
# event_hub = "your-event-hub"
# client_id = "your-client-id"
# tenant_id = "your-tenant-id"
# subscription_id = "your-subscription-id"
# gcp_service_account = "your-gcp-service-account"

publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)

request = Topic(
    name=topic_path,
    ingestion_data_source_settings=IngestionDataSourceSettings(
        azure_event_hubs=IngestionDataSourceSettings.AzureEventHubs(
            resource_group=resource_group,
            namespace=namespace,
            event_hub=event_hub,
            client_id=client_id,
            tenant_id=tenant_id,
            subscription_id=subscription_id,
            gcp_service_account=gcp_service_account,
        )
    ),
)

topic = publisher.create_topic(request=request)

print(f"Created topic: {topic.name} with Azure Event Hubs Ingestion Settings")

    Si tienes problemas, consulta Solucionar problemas al importar un tema de Azure Event Hubs.

    Editar temas de importación de Azure Event Hubs

    Para editar la configuración de la fuente de datos de ingestión de un tema de importación de Azure Event Hubs, siga estos pasos:

    Consola

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

      Ir a Temas

    2. Haga clic en el tema de importación de Azure Event Hubs.

    3. En la página de detalles del tema, haz clic en Editar.

    4. Actualiza los campos que quieras cambiar.

    5. Haz clic en Actualizar.

    gcloud

    1. In the Google Cloud console, activate Cloud Shell.

      Activate Cloud Shell

      At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    2. Ejecuta el comando gcloud pubsub topics update con todas las marcas que se mencionan en el siguiente ejemplo:

      gcloud pubsub topics update TOPIC_ID \
    --azure-event-hubs-ingestion-resource-group RESOURCE_GROUP \
    --azure-event-hubs-ingestion-namespace NAMESPACE \
    --azure-event-hubs-ingestion-event-hub EVENT_HUB \
    --azure-event-hubs-ingestion-client-id CLIENT_ID \
    --azure-event-hubs-ingestion-tenant-id TENANT_ID \
    --azure-event-hubs-ingestion-subscription-id SUBSCRIPTION_ID \
    --azure-event-hubs-ingestion-service-account SERVICE_ACCOUNT

      Haz los cambios siguientes:

      • TOPIC_ID: el nombre o el ID de tu tema de Pub/Sub.
      • RESOURCE_GROUP: el nombre del grupo de recursos de Azure Event Hubs que contiene el espacio de nombres de Azure Event Hubs en el que está insertando datos en Pub/Sub.
      • NAMESPACE: el nombre del espacio de nombres de Azure Event Hubs que contiene el centro de eventos de Azure que estás ingiriendo en Pub/Sub.
      • EVENT_HUB: el nombre del centro de eventos de Azure que está ingiriendo en Pub/Sub.
      • CLIENT_ID: el ID (de cliente) de la aplicación registrada en Azure que contiene la identidad federada de la cuenta de servicioGoogle Cloud . Este valor debe ser un UUID. Para obtener más información, consulta la página de registro de aplicaciones de Azure.
      • TENANT_ID: el ID de directorio (propietario) del propietario de los centros de eventos de Azure que está ingiriendo en Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de cliente, visita la página de Azure para obtener los IDs de suscripción y de cliente.
      • SUBSCRIPTION_ID: el ID de suscripción de la suscripción que posee el centro de eventos de Azure en el que estás insertando datos en Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de suscripción, consulta Obtener los IDs de suscripción y de cliente de Azure.
      • SERVICE_ACCOUNT: la cuenta de servicio que has creado en Crear una cuenta de servicio en Google Cloud

    Cuotas y límites

    El rendimiento de publicación de los temas de importación está limitado por la cuota de publicación del tema. Para obtener más información, consulta las cuotas y los límites de Pub/Sub.

    Siguientes pasos