Es posible que parte o toda la información de esta página no se aplique a Trusted Cloud de S3NS.

Se usó la API de Cloud Translation para traducir esta página.

Crea un tema de importación de Azure Event Hubs

Un tema de importación de Azure Event Hubs te permite transferir datos de forma continua desde Azure Event Hubs como fuente externa a Pub/Sub. Luego, puedes transmitir los datos a cualquiera de los destinos que admite Pub/Sub.

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

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

Antes de comenzar

Obtén más información sobre el proceso de publicación de Pub/Sub.
Configura los roles y permisos necesarios para administrar los temas de importación de Azure Event Hubs, incluidos los siguientes:
Configura la federación de identidades para cargas de trabajo de modo queTrusted Cloud pueda acceder al servicio de transmisión externo.

Roles y permisos requeridos

Para obtener los permisos que necesitas para crear y administrar temas de importación de Azure Event Hubs, pídele a tu administrador que te otorgue el rol de IAM Editor de Pub/Sub (roles/pubsub.editor) en tu tema o 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 y administrar temas de importación de Azure Event Hubs. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

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

Crea un tema de importación: pubsub.topics.create
Borra un tema de importación: pubsub.topics.delete
Obtén un tema de importación: pubsub.topics.get
Enumera un tema de importación: pubsub.topics.list
Publica en un tema de importación: pubsub.topics.publish and pubsub.serviceAgent
Actualiza un tema de importación: pubsub.topics.update
Obtén la política de IAM para un tema de importación: pubsub.topics.getIamPolicy
Configura la política de IAM para un tema de importación: pubsub.topics.setIamPolicy

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

Puedes configurar el control de acceso a nivel del proyecto y de los recursos individuales.

Configura la identidad federada para acceder a Azure Event Hubs

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

Crea una cuenta de servicio en Trusted 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 existente, ve a Registra 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 los lineamientos de nomenclatura, consulta Crea cuentas de servicio. Después de crear una cuenta de servicio, es posible que debas esperar 60 segundos o más antes de usarla. Este comportamiento sucede porque las operaciones de lectura tienen coherencia eventual. Es posible que la nueva cuenta de servicio tarde un poco más en ser visible.

Registra el ID único de la cuenta de servicio

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

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

Ir a la cuenta de servicio
Haz clic en la cuenta de servicio que acabas de crear o en la que planeas usar.
En la página Detalles de la cuenta de servicio, registra el número de ID único.

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

Agrega el rol de creador de tokens de cuenta de servicio a la cuenta de servicio de Pub/Sub

El rol de creador de tokens de cuentas de servicio (roles/iam.serviceAccountTokenCreator) permite que las principales creen credenciales de corta duración 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 el uso de la identidad de cuentas de servicio, consulta Uso de la identidad de cuentas de servicio.

También puedes agregar el rol de publicador de Pub/Sub (roles/pubsub.publisher) durante este procedimiento. Para obtener más información sobre el rol y por qué lo agregas, consulta Cómo agregar el rol de publicador de Pub/Sub a la cuenta de servicio de Pub/Sub.

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

Ir a IAM
Haz clic en la casilla de verificación Incluir asignaciones de roles proporcionadas por S3NS.
Busca la cuenta de servicio que tiene el formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.
En esta cuenta de servicio, haz clic en el botón Editar principal.
Si es necesario, haz clic en Agregar otro rol.
Busca y haz clic en el rol de creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator).
Haz clic en Guardar.

Crea un registro de la app con la federación de identidades

Para transferir datos desde Azure Event Hubs, registra una aplicación en la plataforma de identidad de Microsoft y habilita la federación de identidades para tu cuenta de servicio. Esto permite que tu cuenta de servicio se autentique en Azure.

Para obtener más información sobre el registro de una aplicación con la plataforma de identidad de Microsoft, consulta el inicio rápido del registro de aplicaciones de Azure.

Accede al portal de Azure y abre la página Microsoft Entra ID.
En el panel de navegación, haz clic en Administrar > Registros de aplicaciones.
Haz clic en Registro nuevo.
Asigna un nombre a la aplicación y establece Supported account types en cualquier opción que no sea Personal Microsoft accounts only.
Para registrar la aplicación, haz clic en Registrar.
Abre la aplicación y haz clic en Administrar > Certificados y secretos.
Haz clic en Agregar credencial.
Para configurar una credencial federada, haz clic en Otro emisor.
En el campo Emisor, ingresa https://accounts.google.com.
En el campo Value, ingresa el ID único de tu cuenta de servicio de Pub/Sub.

Puedes encontrar este ID en Registra el ID único de la cuenta de servicio.
Asigna un nombre a la identidad federada y, luego, haz clic en Agregar.

Otorga asignaciones de roles a la app registrada

Para permitir que Pub/Sub lea desde tu centro de eventos de Azure, otorga los roles necesarios a tu app registrada.

Accede al portal de Azure y abre tu espacio de nombres de Event Hubs.

Para abrir un espacio de nombres, ingresa Event Hubs en la búsqueda y, luego, haz clic en uno de los espacios de nombres.
En la barra lateral, haz clic en Control de acceso (IAM).
Haz clic en Agregar > Agregar asignación de rol.
Selecciona el rol Azure Event Hubs Data Receiver y, luego, haz clic en Siguiente.

Esto otorga a la cuenta de servicio de Pub/Sub acceso de lectura a tu centro de eventos de Azure.
Haz clic en + Seleccionar miembros y, luego, busca la app que registraste.
Escribe el nombre de la app registrada en el campo de búsqueda.
Haz clic en el nombre de tu app y, luego, en Seleccionar.
Haz clic en Revisar y asignar.
Repite los pasos del 3 al 6 y agrega el rol Azure Event Hubs Data Sender.

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

Para obtener más información sobre la asignación de roles de Azure, visita la página Asigna roles de Azure.

Agrega el rol de publicador de Pub/Sub a la principal de Pub/Sub

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

Agrega 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 requiere el permiso serviceusage.services.use en el proyecto del tema de importación.

Para otorgar este permiso, te recomendamos que agregues 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 puede otorgar de la siguiente manera:

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

Ir a IAM
Haz clic en la casilla de verificación Incluir asignaciones de roles proporcionadas por S3NS.
Busca la cuenta de servicio que tiene el formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.
En esta cuenta de servicio, haz clic en el botón Editar principal.
Si es necesario, haz clic en Agregar otro rol.
Busca y haz clic en el rol de agente de servicio de Pub/Sub (roles/pubsub.serviceAgent).
Haz clic en Guardar.

Habilita la publicación desde todos los temas

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

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

Ir a IAM
Haz clic en la casilla de verificación Incluir asignaciones de roles proporcionadas por S3NS.
Busca la cuenta de servicio que tiene el formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.
En esta cuenta de servicio, haz clic en el botón Editar principal.
Si es necesario, haz clic en Agregar otro rol.
Busca y haz clic en el rol de publicador de Pub/Sub (roles/pubsub.publisher).
Haz clic en Guardar.

Habilita la publicación desde un solo tema

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

In the Trusted Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Trusted 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.
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.s3ns-system.iam.gserviceaccount.com" \
   --role="roles/pubsub.publisher"
```
Reemplaza lo siguiente:
- TOPIC_ID: Es el ID del tema de importación de Azure Event Hubs.
- PROJECT_NUMBER: Número del proyecto Para ver el número de proyecto, consulta Identifica proyectos.

Agrega el rol de usuario de cuenta de servicio a la cuenta de servicio

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

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

Ir a IAM
En el principal que emite las llamadas para crear o actualizar temas, haz clic en el botón Editar principal.
Si es necesario, haz clic en Agregar otro rol.
Busca y haz clic en el rol de usuario de cuenta de servicio (roles/iam.serviceAccountUser).
Haz clic en Guardar.

Usa temas de importación de Azure Event Hubs

Puedes crear un tema de importación nuevo o editar uno existente.

Consideraciones

Crear el tema y la suscripción por separado, incluso si se hace de forma rápida y sucesiva, puede provocar la pérdida de datos. Hay un período breve en el que el tema existe sin una suscripción. Si se envían datos al tema durante este período, se perderán. Si primero creas el tema, luego la suscripción y, por último, conviertes el tema en un tema de importación, garantizas 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 existente con el mismo nombre, no puedes simplemente borrar el centro de eventos de Azure y volver a crearlo. Esta acción puede invalidar la administración de desplazamiento de Pub/Sub, lo que puede provocar la pérdida de datos. Para mitigar este problema, sigue estos pasos:
- Borra el tema de importación de Pub/Sub
- Borra el centro de eventos de Azure
- Crea el centro de eventos de Azure
- Crea 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.

Crea 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 haber completado los siguientes procedimientos:

Configura la identidad federada para acceder a Azure Event Hubs
Agrega el rol de publicador de Pub/Sub a la cuenta de servicio de Pub/Sub
Agrega el rol de usuario de la cuenta de servicio a la principal de IAM

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

Console

En la consola de Trusted Cloud , ve a la página Temas.

Ir a temas
Haz clic en Crear un tema.
En el campo ID del tema, ingresa un ID para el tema de importación de Azure Event Hubs. Para obtener más información sobre cómo nombrar temas, consulta los lineamientos para asignar nombres.
Selecciona Agregar una suscripción predeterminada.
Selecciona Habilitar transferencia.
En la fuente de transferencia, selecciona Azure Event Hubs.
Ingresa los siguientes detalles:
- Grupo de recursos: Es el nombre del grupo de recursos de Azure que contiene el espacio de nombres de Azure Event Hubs que planeas transferir a Pub/Sub.
- Espacio de nombres de Event Hub: Es el nombre del espacio de nombres de Azure Event Hubs que contiene el centro de eventos de Azure que planeas transferir a Pub/Sub.
- Event Hub: Es el nombre del centro de eventos de Azure que planeas transferir a Pub/Sub.
- ID de cliente: Es el ID de la aplicación (cliente) de la app 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 usuario: Es el ID del directorio (usuario) del usuario que posee el centro de eventos de Azure que planeas transferir a Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de usuario, visita la página de Azure para obtener IDs de suscripción y de usuario.
- ID de suscripción: Es el ID de la suscripción que posee el grupo de recursos de Azure Event Hubs. Este valor debe ser un UUID. Para encontrar tu ID de suscripción, visita la página de Azure para obtener IDs de suscripción y de inquilino.
- Cuenta de servicio: La cuenta de servicio que creaste en Crea una cuenta de servicio en Trusted Cloud
Deja los campos restantes con los valores predeterminados.
Haz clic en Crear un tema.

gcloud

In the Trusted Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Trusted 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.
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
```
Reemplaza lo siguiente:
- TOPIC_ID: Es el nombre o ID de tu tema de Pub/Sub.
- RESOURCE_GROUP: Es el nombre del grupo de recursos de Azure Event Hubs que contiene el espacio de nombres de Azure Event Hubs que planeas transferir a Pub/Sub.
- NAMESPACE: Es el nombre del espacio de nombres de Azure Event Hubs que contiene el centro de eventos de Azure que planeas transferir a Pub/Sub.
- EVENT_HUB: Es el nombre del centro de eventos de Azure que planeas transferir a Pub/Sub.
- CLIENT_ID: ID de la aplicación (cliente) de la aplicación registrada en Azure que contiene la identidad federada de laTrusted Cloud cuenta de servicio. Este valor debe ser un UUID. Para obtener más información, visita la página de registro de aplicaciones de Azure.
- TENANT_ID: Es el ID del directorio (inquilino) del inquilino propietario del centro de eventos de Azure que planeas transferir a Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de inquilino, visita la página de Azure para obtener IDs de suscripción y de inquilino.
- SUBSCRIPTION_ID: Es el ID de la suscripción que posee el centro de eventos de Azure que planeas transferir a Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de suscripción, visita la página de Azure para obtener IDs de suscripción y de inquilino.
- SERVICE_ACCOUNT: La cuenta de servicio que creaste en Crea una cuenta de servicio en Trusted Cloud

C++

Antes de probar esta muestra, sigue las instrucciones de configuración de C++ en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para C++.

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 cliente de Pub/Sub de Go (v2). Si aún usas la biblioteca de la versión 1, consulta la guía de migración a la versión 2. Para ver una lista de muestras de código de la versión 1, consulta las muestras de código obsoletas.

Antes de probar esta muestra, sigue las instrucciones de configuración de Go en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Go.

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 esta muestra, sigue las instrucciones de configuración de Java en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Java.


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 esta muestra, sigue las instrucciones de configuración de Node.js en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Node.js.

/**
 * 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

/**
 * 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 esta muestra, sigue las instrucciones de configuración de Python en la guía de inicio rápido sobre el uso de bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Pub/Sub para Python.

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 Soluciona problemas relacionados con la importación de un tema de Azure Event Hubs.

Edita los temas de importación de Azure Event Hubs

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

Console

En la consola de Trusted Cloud , ve a la página Temas.

Ir a temas
Haz clic en el tema de importación de Azure Event Hubs.
En la página de detalles del tema, haz clic en Editar.
Actualiza los campos que deseas cambiar.
Haz clic en Actualizar.

gcloud

In the Trusted Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Trusted 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.
Ejecuta el comando gcloud pubsub topics update con todas las marcas mencionadas 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
```
Reemplaza lo siguiente:
- TOPIC_ID: Es el nombre o ID de tu tema de Pub/Sub.
- RESOURCE_GROUP: Es el nombre del grupo de recursos de Azure Event Hubs que contiene el espacio de nombres de Azure Event Hubs en el que se realiza la transferencia a Pub/Sub.
- NAMESPACE: Es el nombre del espacio de nombres de Azure Event Hubs que contiene el centro de eventos de Azure que se está transfiriendo a Pub/Sub.
- EVENT_HUB: Es el nombre del centro de eventos de Azure que se transfiere a Pub/Sub.
- CLIENT_ID: ID de la aplicación (cliente) de la aplicación registrada en Azure que contiene la identidad federada de laTrusted Cloud cuenta de servicio. Este valor debe ser un UUID. Para obtener más información, consulta la página de registro de aplicaciones de Azure.
- TENANT_ID: Es el ID del directorio (inquilino) del inquilino propietario de los centros de eventos de Azure que se transfieren a Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de usuario, visita la página de Azure para obtener IDs de suscripción y de usuario.
- SUBSCRIPTION_ID: Es el ID de la suscripción que posee el centro de eventos de Azure que se está transfiriendo a Pub/Sub. Este valor debe ser un UUID. Para encontrar tu ID de suscripción, consulta Obtén los IDs de suscripción y de inquilino de Azure.
- SERVICE_ACCOUNT: La cuenta de servicio que creaste en Crea una cuenta de servicio en Trusted Cloud

Cuotas y límites

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

¿Qué sigue?

Supervisa un tema de importación.
Elige el tipo de suscripción para tu tema.
Obtén información para publicar un mensaje en un tema.
Crea o modifica un tema con gcloud CLI, APIs de REST o bibliotecas cliente.
Soluciona problemas relacionados con un tema de importación de Azure Event Hubs.