Criar um tópico de importação dos Event Hubs

Com um tópico de importação dos Hubs de Eventos do Azure, é possível ingerir dados continuamente dos Hubs de Eventos do Azure como uma fonte externa e no Pub/Sub. Em seguida, é possível fazer streaming dos dados para qualquer um dos destinos compatíveis com o Pub/Sub.

Neste documento, mostramos como criar e gerenciar tópicos de importação do Azure Event Hubs. Para criar um tópico padrão, consulte Criar um tópico padrão.

Para mais informações sobre tópicos de importação, consulte Sobre tópicos de importação.

Antes de começar

Papéis e permissões necessárias

Para receber as permissões necessárias para criar e gerenciar tópicos de importação do Azure Event Hubs, peça ao administrador para conceder a você o papel do IAM de Editor do Pub/Sub (roles/pubsub.editor) no seu tópico ou projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para criar e gerenciar tópicos de importação do Azure Event Hubs. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar e gerenciar tópicos de importação dos Hubs de Eventos do Azure:

  • Crie um tópico de importação: pubsub.topics.create
  • Excluir um tema de importação: pubsub.topics.delete
  • Receber um tópico de importação: pubsub.topics.get
  • Liste um tema de importação: pubsub.topics.list
  • Publicar em um tópico de importação: pubsub.topics.publish and pubsub.serviceAgent
  • Atualizar um tema de importação: pubsub.topics.update
  • Receba a política do IAM para um tópico de importação: pubsub.topics.getIamPolicy
  • Configure a política do IAM para um tópico de importação: pubsub.topics.setIamPolicy

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

É possível configurar o controle de acesso no nível do projeto e no nível do recurso individual.

Configurar a identidade federada para acessar os Hubs de Eventos do Azure

A federação de identidade da carga de trabalho permite que os serviços do Trusted Cloud acessem cargas de trabalho executadas fora do Trusted Cloud. Com a federação de identidade, não é necessário manter ou transmitir credenciais para Trusted Cloud acessar seus recursos em outras nuvens. Em vez disso, é possível usar as identidades das próprias cargas de trabalho para autenticar no Trusted Cloud e acessar recursos.

Criar uma conta de serviço em Trusted Cloud

Essa é uma etapa opcional. Se você já tiver uma conta de serviço, use-a neste procedimento em vez de criar uma nova. Se você estiver usando uma conta de serviço, acesse Registrar o ID exclusivo da conta de serviço para a próxima etapa.

Para tópicos de importação do Azure Event Hubs, o Pub/Sub usa a conta de serviço como a identidade para acessar recursos do Azure.

Para mais informações sobre como criar uma conta de serviço, incluindo pré-requisitos, papéis e permissões obrigatórios e diretrizes de nomenclatura, consulte Criar contas de serviço. Depois de criar uma conta de serviço, talvez seja necessário aguardar 60 segundos ou mais para usá-la. Esse comportamento ocorre porque as operações de leitura têm consistência eventual e pode levar algum tempo para a nova conta de serviço ficar visível.

Registre o ID exclusivo da conta de serviço

Você precisa de um ID exclusivo da conta de serviço para configurar o registro de app no Azure.

  1. No console Trusted Cloud , acesse a página de detalhes da conta de serviço.

    Acessar contas de serviço

  2. Clique na conta de serviço que você acabou de criar ou na que você planeja usar.

  3. Na página Detalhes da conta de serviço, anote o número do ID exclusivo.

    Você precisa do ID como parte do fluxo de trabalho para configurar o registro de app no Azure.

Adicionar o papel de criador de token da conta de serviço à conta de serviço do Pub/Sub

O papel de criador de token da conta de serviço (roles/iam.serviceAccountTokenCreator) permite que os principais criem credenciais de curta duração para uma conta de serviço. Esses tokens ou credenciais são usados para representar a conta de serviço.

Para mais informações sobre representação da conta de serviço, consulte Representação da conta de serviço.

Você também pode adicionar o papel de editor do Pub/Sub (roles/pubsub.publisher) durante esse procedimento. Para mais informações sobre a função e por que você está adicionando ela, consulte Adicionar a função de editor do Pub/Sub à conta de serviço do Pub/Sub.

  1. No console Trusted Cloud , acesse a página IAM.

    Acessar IAM

  2. Clique na caixa de seleção Incluir concessões de papel fornecidas pelo S3NS.

  3. Procure a conta de serviço que tem o formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

  4. Na conta de serviço, clique no botão Editar principal.

  5. Se necessário, clique em Adicionar outro papel.

  6. Pesquise e clique no papel Criador de token da conta de serviço (roles/iam.serviceAccountTokenCreator).

  7. Clique em Salvar.

Criar um registro de app com federação de identidade

Para ingerir dados dos Hubs de Eventos do Azure, registre um aplicativo na plataforma de identidade da Microsoft e ative a federação de identidade para sua conta de serviço. Isso permite que sua conta de serviço se autentique no Azure.

Para mais informações sobre como registrar um aplicativo com a plataforma de identidade da Microsoft, consulte o Início rápido de registro de aplicativos do Azure.

  1. Faça login no portal do Azure e abra a página Microsoft Entra ID.

  2. No painel de navegação, clique em Gerenciar > Registros de apps.

  3. Clique em New registration.

  4. Nomeie o aplicativo e defina Tipos de conta aceitos como qualquer coisa diferente de Somente contas pessoais da Microsoft.

  5. Para registrar o aplicativo, clique em Registrar.

  6. Abra o aplicativo e clique em Gerenciar > Certificados e chaves secretas.

  7. Clique em Adicionar credencial.

  8. Para configurar uma credencial federada, clique em Outro emissor.

  9. No campo Emissor, insira https://accounts.google.com.

  10. No campo Valor, insira o ID exclusivo da conta de serviço do Pub/Sub.

    Você pode encontrar esse ID em Registrar o ID exclusivo da conta de serviço.

  11. Nomeie a identidade federada e clique em Adicionar.

Conceder atribuições de função ao app registrado

Para permitir que o Pub/Sub leia do seu hub de eventos do Azure, conceda os papéis necessários ao app registrado.

  1. Faça login no portal do Azure e abra o namespace dos Hubs de Eventos.

    Para abrir um namespace, insira Hubs de Eventos na pesquisa e clique em um dos namespaces.

  2. Na barra lateral, clique em Controle de acesso (IAM).

  3. Clique em Adicionar > Adicionar atribuição de função.

  4. Selecione a função Receptor de dados do Azure Event Hubs e clique em Próxima.

    Isso concede à conta de serviço do Pub/Sub acesso de leitura ao hub de eventos do Azure.

  5. Clique em +Selecionar membros e pesquise o app registrado.

  6. Digite o nome do app registrado no campo de pesquisa.

  7. Clique no nome do app e em Selecionar.

  8. Clique em Revisar + atribuir.

  9. Repita as etapas de 3 a 6 e adicione a função Remetente de dados dos Hubs de Eventos do Azure.

    Essa função concede à conta de serviço do Google Cloud permissão para buscar metadados do seu hub de eventos do Azure.

Para mais informações sobre como atribuir papéis do Azure, acesse a página Atribuir papéis do Azure.

Adicione o papel de editor do Pub/Sub ao principal do Pub/Sub.

Para ativar a publicação, atribua um papel de editor à conta de serviço do Pub/Sub para que ele possa publicar no tópico de importação do Azure Event Hubs.

Adicione o papel de agente de serviço do Pub/Sub à conta de serviço do Pub/Sub

Para permitir que o Pub/Sub use a cota de publicação do projeto do tópico de importação, o agente de serviço do Pub/Sub precisa da permissão serviceusage.services.use no projeto do tópico de importação.

Para conceder essa permissão, recomendamos que você adicione o papel de agente de serviço do Pub/Sub à conta de serviço do Pub/Sub.

Se a conta de serviço do Pub/Sub não tiver o papel de agente de serviço do Pub/Sub, ela poderá ser concedida da seguinte maneira:

  1. No console Trusted Cloud , acesse a página IAM.

    Acessar IAM

  2. Clique na caixa de seleção Incluir concessões de papel fornecidas pelo S3NS.

  3. Procure a conta de serviço que tem o formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

  4. Clique no botão Editar principal.

  5. Se necessário, clique em Adicionar outro papel.

  6. Pesquise e clique no papel de agente de serviço do Pub/Sub (roles/pubsub.serviceAgent).

  7. Clique em Salvar.

Ativar a publicação de todos os tópicos

Use esse método se você não tiver criado nenhum tópico de importação dos Hubs de Eventos do Azure.

  1. No console Trusted Cloud , acesse a página IAM.

    Acessar IAM

  2. Clique na caixa de seleção Incluir concessões de papel fornecidas pelo S3NS.

  3. Procure a conta de serviço que tem o formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

  4. Clique no botão Editar principal.

  5. Se necessário, clique em Adicionar outro papel.

  6. Pesquise e clique no papel de editor do Pub/Sub (roles/pubsub.publisher).

  7. Clique em Salvar.

Ativar a publicação de um único tópico

Use esse método apenas se o tópico de importação dos Hubs de Eventos do Azure já existir.

  1. 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.

  2. Execute o 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"

    Substitua:

    • TOPIC_ID: o ID do tópico de importação do Azure Event Hubs.

    • PROJECT_NUMBER: o número do projeto. Para conferir o número do projeto, consulte Identificar projetos.

    3. Adicione o função do usuário da conta de serviço à conta de serviço

    O papel de usuário da conta de serviço (roles/iam.serviceAccountUser) inclui a permissão iam.serviceAccounts.actAs, que permite que um principal anexe uma conta de serviço às configurações de ingestão do tópico de importação do Azure Event Hubs e use essa conta de serviço para identidade federada.

    1. No console Trusted Cloud , acesse a página IAM.

      Acessar IAM

    2. Para o principal que está emitindo as chamadas de criação ou atualização de tópico, clique no botão Editar principal.

    3. Se necessário, clique em Adicionar outro papel.

    4. Pesquise e clique no papel de usuário da conta de serviço (roles/iam.serviceAccountUser).

    5. Clique em Salvar.

    Usar tópicos de importação dos Hubs de Eventos do Azure

    Você pode criar ou editar um tópico de importação.

    Considerações

    • Criar o tópico e a assinatura separadamente, mesmo que em rápida sucessão, pode levar à perda de dados. Há um período curto em que o tema existe sem uma assinatura. Se algum dado for enviado ao tópico durante esse período, ele será perdido. Ao criar primeiro o tópico, depois a assinatura e, por fim, converter o tópico em um tópico de importação, você garante que nenhuma mensagem seja perdida durante o processo de importação.

    • Se você precisar recriar o hub de eventos do Azure de um tópico de importação com o mesmo nome, não será possível apenas excluir e recriar o hub de eventos do Azure. Essa ação pode invalidar o gerenciamento de deslocamento do Pub/Sub, o que pode levar à perda de dados. Para evitar isso, siga estas etapas:

      • Excluir o tópico de importação do Pub/Sub
      • Excluir o hub de eventos do Azure
      • Criar o hub de eventos do Azure
      • Criar o tópico de importação do Pub/Sub

    • Os dados de um hub de eventos do Azure são sempre lidos do menor deslocamento.

    Criar tópicos de importação do Azure Event Hubs

    Para saber mais sobre as propriedades associadas a um tópico, consulte Propriedades de um tópico.

    Verifique se você concluiu os seguintes procedimentos:

    Para criar um tópico de importação do Azure Event Hubs, siga estas etapas:

    Console

    1. No console Trusted Cloud , acesse a página Tópicos.

      Acesse Tópicos

    2. Selecione Criar tópico.

    3. No campo ID do tópico, insira um ID para o tópico de importação do Azure Event Hubs. Para mais informações sobre como nomear tópicos, consulte as diretrizes de nomenclatura.

    4. Selecione Adicionar uma assinatura padrão.

    5. Selecione Ativar ingestão.

    6. Em "Origem da ingestão", selecione Azure Event Hubs.

    7. Digite os seguintes detalhes:

      • Grupo de recursos: o nome do grupo de recursos do Azure que contém o namespace dos Hubs de Eventos do Azure que você planeja ingerir no Pub/Sub.
      • Namespace do Hub de Eventos: o nome do namespace do Azure Event Hubs que contém o hub de eventos do Azure que você planeja ingerir no Pub/Sub.
      • Hub de eventos: o nome do hub de eventos do Azure que você planeja ingerir no Pub/Sub.
      • ID do cliente: o ID do aplicativo (cliente) do app registrado no Azure que contém a identidade federada da conta de serviço do Google Cloud. Esse valor precisa ser um UUID. Para mais informações, acesse a página de registro de apps do Azure.
      • ID do locatário: o ID do diretório (locatário) do locatário proprietário do hub de eventos do Azure que você planeja ingerir no Pub/Sub. Esse valor precisa ser um UUID. Para encontrar seu ID do locatário, acesse a página do Azure para receber IDs de assinatura e locatário.
      • ID da assinatura: o ID da assinatura proprietária do grupo de recursos dos Hubs de Eventos do Azure. Esse valor precisa ser um UUID. Para encontrar seu ID de assinatura, acesse a página "Receber IDs de assinatura e locatário do Azure".
      • Conta de serviço:a conta de serviço que você criou em Criar uma conta de serviço em Trusted Cloud.

    8. Mantenha os valores padrão nos campos restantes.

    9. Selecione Criar tópico.

    gcloud

    1. 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.

    2. Execute o 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

      Substitua:

      • TOPIC_ID: o nome ou ID do seu tópico do Pub/Sub.
      • RESOURCE_GROUP: o nome do grupo de recursos dos Hubs de Eventos do Azure que contém o namespace dos Hubs de Eventos do Azure que você planeja ingerir no Pub/Sub.
      • NAMESPACE: o nome do namespace do Azure Event Hubs que contém o hub de eventos do Azure que você planeja ingerir no Pub/Sub.
      • EVENT_HUB: o nome do hub de eventos do Azure que você planeja ingerir no Pub/Sub.
      • CLIENT_ID: o ID do aplicativo (cliente) do app registrado no Azure que contém a identidade federada da conta de serviçoTrusted Cloud . Esse valor precisa ser um UUID. Para mais informações, acesse a página de registro de apps do Azure.
      • TENANT_ID: o ID do diretório (locatário) do locatário proprietário do hub de eventos do Azure que você planeja ingerir no Pub/Sub. Esse valor precisa ser um UUID. Para encontrar seu ID de locatário, acesse a página Como conseguir IDs de assinatura e locatário do Azure.
      • SUBSCRIPTION_ID: o ID da assinatura que possui o hub de eventos do Azure que você planeja ingerir no Pub/Sub. Esse valor precisa ser um UUID. Para encontrar o ID da sua assinatura, acesse a página Obter IDs de assinatura e locatário do Azure.
      • SERVICE_ACCOUNT: a conta de serviço que você criou em Criar uma conta de serviço em Trusted Cloud

      3. C++

      Antes de tentar esse exemplo, siga as instruções de configuração do C++ em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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

      O exemplo a seguir usa a versão principal da biblioteca de cliente do Go Pub/Sub (v2). Se você ainda estiver usando a biblioteca v1, consulte o guia de migração para a v2. Para conferir uma lista de exemplos de código da v1, consulte os exemplos de código descontinuados.

      Antes de tentar esse exemplo, siga as instruções de configuração do Go em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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 tentar essa amostra, siga as instruções de configuração do Java em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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 tentar essa amostra, siga as instruções de configuração do Node.js em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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

      Antes de tentar essa amostra, siga as instruções de configuração do Node.js em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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
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 tentar esse exemplo, siga as instruções de configuração do Python em Guia de início rápido: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Pub/Sub 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")

    Se você tiver problemas, consulte Solução de problemas de um tópico de importação do Azure Event Hubs.

    Editar tópicos de importação do Azure Event Hubs

    Para editar as configurações da fonte de dados de ingestão de um tópico de importação do Azure Event Hubs, siga estas etapas:

    Console

    1. No console Trusted Cloud , acesse a página Tópicos.

      Acesse Tópicos

    2. Clique no tópico de importação do Azure Event Hubs.

    3. Na página de detalhes do tópico, clique em Editar.

    4. Atualize os campos que você quer mudar.

    5. Clique em Atualizar.

    gcloud

    1. 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.

    2. Execute o comando gcloud pubsub topics update com todas as flags mencionadas no exemplo a seguir:

      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

      Substitua:

      • TOPIC_ID: o nome ou ID do seu tópico do Pub/Sub.
      • RESOURCE_GROUP: o nome do grupo de recursos dos Hubs de Eventos do Azure que contém o namespace dos Hubs de Eventos do Azure em que você está ingerindo o Pub/Sub.
      • NAMESPACE: o nome do namespace dos Hubs de Eventos do Azure que contém o hub de eventos do Azure que você está ingerindo no Pub/Sub.
      • EVENT_HUB: o nome do hub de eventos do Azure que você está ingerindo no Pub/Sub.
      • CLIENT_ID: o ID do aplicativo (cliente) do app registrado no Azure que contém a identidade federada da conta de serviçoTrusted Cloud . Esse valor precisa ser um UUID. Para mais informações, consulte a página de registro de apps do Azure.
      • TENANT_ID: o ID do diretório (locatário) do locatário proprietário dos Hubs de Eventos do Azure que você está ingerindo no Pub/Sub. Esse valor precisa ser um UUID. Para encontrar seu ID de locatário, acesse a página "Receber IDs de assinatura e locatário do Azure".
      • SUBSCRIPTION_ID: o ID da assinatura que possui o hub de eventos do Azure que você está inserindo no Pub/Sub. Esse valor precisa ser um UUID. Para encontrar seu ID de assinatura, consulte Obter IDs de assinatura e locatário do Azure.
      • SERVICE_ACCOUNT: a conta de serviço que você criou em Criar uma conta de serviço em Trusted Cloud

    Cotas e limites

    A taxa de transferência do editor para tópicos de importação é limitada pela cota de publicação do tópico. Para mais informações, consulte Cotas e limites do Pub/Sub.

    A seguir