Alcune o tutte le informazioni in questa pagina potrebbero non essere applicabili a Trusted Cloud by S3NS.

Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un argomento di importazione di Azure Event Hubs

Un argomento di importazione di Azure Event Hubs ti consente di importare continuamente dati da Azure Event Hubs come origine esterna e in Pub/Sub. Poi puoi trasmettere i dati in streaming a una qualsiasi delle destinazioni supportate da Pub/Sub.

Questo documento mostra come creare e gestire gli argomenti di importazione di Azure Event Hubs. Per creare un argomento standard, vedi Creare un argomento standard.

Per saperne di più sugli argomenti di importazione, consulta Informazioni sugli argomenti di importazione.

Prima di iniziare

Scopri di più sulla procedura di pubblicazione Pub/Sub.
Configura i ruoli e le autorizzazioni richiesti per gestire gli argomenti di importazione di Azure Event Hubs, tra cui:
Configura la federazione delle identità per i workload in modo che Trusted Cloud possa accedere al servizio di streaming esterno.

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per creare e gestire argomenti di importazione di Azure Event Hubs, chiedi all'amministratore di concederti il ruolo IAM Pub/Sub Editor (roles/pubsub.editor) nell'argomento o nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare e gestire gli argomenti di importazione di Azure Event Hubs. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare e gestire gli argomenti di importazione di Azure Event Hubs sono necessarie le seguenti autorizzazioni:

Crea un argomento di importazione: pubsub.topics.create
Elimina un argomento di importazione: pubsub.topics.delete
Recuperare un argomento di importazione: pubsub.topics.get
Elenca un argomento di importazione: pubsub.topics.list
Pubblica in un argomento di importazione: pubsub.topics.publish and pubsub.serviceAgent
Aggiorna un argomento di importazione: pubsub.topics.update
Recupera il criterio IAM per un argomento di importazione: pubsub.topics.getIamPolicy
Configura il criterio IAM per un argomento di importazione: pubsub.topics.setIamPolicy

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Puoi configurare il controllo dell'accesso a livello di progetto e a livello di singola risorsa.

Configurare l'identità federata per accedere ad Azure Event Hubs

La federazione delle identità per i workload consente ai servizi di accedere ai workload in esecuzione al di fuori di Trusted Cloud. Trusted Cloud Con la federazione delle identità, non devi mantenere o trasmettere le credenziali a Trusted Cloud per accedere alle tue risorse in altri cloud. Puoi invece utilizzare le identità dei carichi di lavoro stessi per autenticarti su Trusted Cloud e accedere alle risorse.

Crea un account di servizio in Trusted Cloud

Questo passaggio è facoltativo. Se hai già un account di servizio, puoi utilizzarlo in questa procedura anziché crearne uno nuovo. Se utilizzi un account di servizio esistente, vai a Registra l'ID univoco del service account per il passaggio successivo.

Per gli argomenti di importazione di Azure Event Hubs, Pub/Sub utilizza l'account di servizio come identità per accedere alle risorse da Azure.

Per ulteriori informazioni sulla creazione di un account di servizio, inclusi prerequisiti, ruoli e autorizzazioni richiesti e linee guida per la denominazione, consulta Creare service account. Dopo aver creato un account di servizio, potresti dover attendere 60 secondi o più prima di account di servizio utilizzare. Questo comportamento si verifica perché le operazioni di lettura sono alla fine coerenti; potrebbe essere necessario del tempo prima che il nuovoaccount di serviziot diventi visibile.

Registra l'ID univoco del account di servizio

Per configurare la registrazione dell'app in Azure, è necessario un ID univoco dell'account di servizio.

Nella Trusted Cloud console, vai alla pagina dei dettagli del service account.

Vai all'account di servizio
Fai clic sul account di servizio che hai appena creato o su quello che intendi utilizzare.
Nella pagina Dettagli del service account, annota il numero dell'ID univoco.

Hai bisogno dell'ID come parte del flusso di lavoro per configurare la registrazione dell'app in Azure.

Aggiungi il ruolo di creatore token account di servizio al account di servizio Pub/Sub

Il ruolo Creatore token service account (roles/iam.serviceAccountTokenCreator) consente alle entità di creare credenziali di breve durata per un account di servizio. Questi token o credenziali vengono utilizzati per rappresentare ilaccount di serviziot.

Per ulteriori informazioni sull'impersonificazione del account di servizio, consulta Impersonificazione del service account.

Puoi anche aggiungere il ruolo Publisher Pub/Sub (roles/pubsub.publisher) durante questa procedura. Per saperne di più sul ruolo e sul motivo per cui lo stai aggiungendo, consulta Aggiungere il ruolo Publisher Pub/Sub all'account di servizio Pub/Sub.

Nella console Trusted Cloud , vai alla pagina IAM.

Vai a IAM
Fai clic sulla casella di controllo Includi concessioni di ruoli fornite da S3NS.
Cerca il account di servizio con il formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.
Per questo account di servizio, fai clic sul pulsante Modifica entità.
Se necessario, fai clic su Aggiungi un altro ruolo.
Cerca e fai clic sul ruolo Creatore token service account (roles/iam.serviceAccountTokenCreator).
Fai clic su Salva.

Crea una registrazione dell'app con la federazione delle identità

Per importare i dati da Azure Event Hubs, registra un'applicazione con la piattaforma Microsoft Identity e attiva la federazione delle identità per il tuaccount di serviziont. In questo modo, il account di servizio può autenticarsi su Azure.

Per ulteriori informazioni sulla registrazione di un'applicazione con Microsoft Identity Platform, consulta la guida rapida alla registrazione dell'app Azure.

Accedi al portale Azure e apri la pagina Microsoft Entra ID.
Nel riquadro di navigazione, fai clic su Gestisci > Registrazioni app.
Fai clic su Nuova registrazione.
Assegna un nome all'applicazione e imposta Tipi di account supportati su un valore diverso da Solo account Microsoft personali.
Per registrare l'applicazione, fai clic su Registra.
Apri l'applicazione e fai clic su Gestisci > Certificati e segreti.
Fai clic su Aggiungi credenziale.
Per configurare una credenziale federata, fai clic su Altro emittente.
Nel campo Emittente, inserisci https://accounts.google.com.
Per il campo Valore, inserisci l'ID univoco del tuo account di servizio Pub/Sub.

Puoi trovare questo ID in Registra l'ID univoco dell'account di servizio.
Assegna un nome all'identità federata e fai clic su Aggiungi.

Concedere assegnazioni di ruoli all'app registrata

Per consentire a Pub/Sub di leggere dall'hub eventi Azure, concedi i ruoli necessari all'app registrata.

Accedi al portale Azure e apri lo spazio dei nomi degli hub di evento.

Per aprire uno spazio dei nomi, inserisci Hub eventi nella ricerca e poi fai clic su uno degli spazi dei nomi.
Nella barra laterale, fai clic su Controllo accesso (IAM).
Fai clic su Aggiungi > Aggiungi assegnazione ruolo.
Seleziona il ruolo Azure Event Hubs Data Receiver e poi fai clic su Avanti.

In questo modo, l'account di servizio Pub/Sub ha accesso in lettura all'hub eventi Azure.
Fai clic su + Seleziona membri, quindi cerca l'app registrata.
Digita il nome dell'app registrata nel campo di ricerca.
Fai clic sul nome della tua app, quindi su Seleziona.
Fai clic su Rivedi e assegna.
Ripeti i passaggi 3-6 e aggiungi il ruolo Azure Event Hubs Data Sender.

Questo ruolo concede all'account di servizio Google Cloud l'autorizzazione per recuperare i metadati dall'hub eventi Azure.

Per ulteriori informazioni sull'assegnazione dei ruoli Azure, visita la pagina Assegnare ruoli Azure.

Aggiungi il ruolo Publisher Pub/Sub all'entità Pub/Sub

Per attivare la pubblicazione, devi assegnare un ruolo di publisher all'account di servizio Pub/Sub in modo che Pub/Sub possa pubblicare nell'argomento di importazione di Azure Event Hubs.

Aggiungi il ruolo di agente di servizio Pub/Sub all'account di servizio Pub/Sub

Per consentire a Pub/Sub di utilizzare la quota di pubblicazione del progetto dell'argomento di importazione, l'agente di servizio Pub/Sub richiede l'autorizzazione serviceusage.services.use per il progetto dell'argomento di importazione.

Per fornire questa autorizzazione, ti consigliamo di aggiungere il ruolo di agente di servizio Pub/Sub all'account di servizio Pub/Sub.

Se l'account di servizio Pub/Sub non dispone del ruolo Agente di servizio Pub/Sub, può essere concesso nel seguente modo:

Nella console Trusted Cloud , vai alla pagina IAM.

Vai a IAM
Fai clic sulla casella di controllo Includi concessioni di ruoli fornite da S3NS.
Cerca il account di servizio con il formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.
Per questo account di servizio, fai clic sul pulsante Modifica entità.
Se necessario, fai clic su Aggiungi un altro ruolo.
Cerca e fai clic sul ruolo Agente di servizio Pub/Sub (roles/pubsub.serviceAgent).
Fai clic su Salva.

Attivare la pubblicazione da tutti gli argomenti

Utilizza questo metodo se non hai creato argomenti di importazione di Azure Event Hubs.

Nella console Trusted Cloud , vai alla pagina IAM.

Vai a IAM
Fai clic sulla casella di controllo Includi concessioni di ruoli fornite da S3NS.
Cerca il account di servizio con il formato service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.
Per questo account di servizio, fai clic sul pulsante Modifica entità.
Se necessario, fai clic su Aggiungi un altro ruolo.
Cerca e fai clic sul ruolo Publisher Pub/Sub (roles/pubsub.publisher).
Fai clic su Salva.

Abilitare la pubblicazione da un singolo argomento

Utilizza questo metodo solo se l'argomento di importazione di Azure Event Hubs esiste già.

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.
Esegui il 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"
```
Sostituisci quanto segue:
- TOPIC_ID: l'ID argomento dell'argomento di importazione di Azure Event Hubs.
- PROJECT_NUMBER: il numero di progetto. Per visualizzare il numero del progetto, consulta Identificazione dei progetti.

Aggiungi il ruolo Utente account di servizio al account di servizio

Il ruolo Utente service account (roles/iam.serviceAccountUser) include l'autorizzazione iam.serviceAccounts.actAs che consente a un'entità di collegare un service account alle impostazioni di importazione dell'argomento di importazione di Azure Event Hubs e di utilizzare questo account di servizio per l'identità federata.

Nella console Trusted Cloud , vai alla pagina IAM.

Vai a IAM
Per l'entità che effettua le chiamate di creazione o aggiornamento dell'argomento, fai clic sul pulsante Modifica entità.
Se necessario, fai clic su Aggiungi un altro ruolo.
Cerca e fai clic sul ruolo Utente service account (roles/iam.serviceAccountUser).
Fai clic su Salva.

Utilizzare gli argomenti di importazione di Azure Event Hubs

Puoi creare un nuovo argomento di importazione o modificarne uno esistente.

Considerazioni

La creazione separata dell'argomento e della sottoscrizione, anche se eseguita in rapida successione, può comportare la perdita di dati. Esiste un breve periodo di tempo in cui l'argomento esiste senza un abbonamento. Se vengono inviati dati all'argomento durante questo periodo, vanno persi. Se crei prima l'argomento, poi la sottoscrizione e infine converti l'argomento in un argomento di importazione, ti assicuri che nessun messaggio venga perso durante il processo di importazione.
Se devi ricreare l'hub eventi Azure di un argomento di importazione esistente con lo stesso nome, non puoi semplicemente eliminare l'hub eventi Azure e ricrearlo. Questa azione può invalidare la gestione degli offset di Pub/Sub, il che può comportare la perdita di dati. Per risolvere il problema, segui questi passaggi:
- Elimina l'argomento di importazione Pub/Sub
- Elimina l'hub eventi Azure
- Crea l'hub eventi Azure
- Crea l'argomento di importazione Pub/Sub
I dati di un hub eventi Azure vengono sempre letti dall'offset più recente.

Crea argomenti di importazione di Azure Event Hubs

Per saperne di più sulle proprietà associate a un argomento, consulta Proprietà di un argomento.

Assicurati di aver completato le seguenti procedure:

Configurare l'identità federata per accedere ad Azure Event Hubs
Aggiungi il ruolo Publisher Pub/Sub all'account di servizio Pub/Sub
Aggiungi il ruolo Utente account di servizio all'entità IAM

Per creare un argomento di importazione di Hub eventi di Azure:

Console

Nella console Trusted Cloud , vai alla pagina Argomenti.

Vai ad Argomenti
Fai clic su Crea argomento.
Nel campo ID argomento, inserisci un ID per l'argomento di importazione di Azure Event Hubs. Per ulteriori informazioni sulla denominazione degli argomenti, consulta le linee guida per la denominazione.
Seleziona Aggiungi una sottoscrizione predefinita.
Seleziona Abilita importazione.
Per l'origine dell'importazione, seleziona Azure Event Hubs.
Inserisci i seguenti dettagli:
- Gruppo di risorse: il nome del gruppo di risorse Azure che contiene lo spazio dei nomi di Azure Event Hubs che prevedi di importare in Pub/Sub.
- Spazio dei nomi dell'hub di evento: il nome dello spazio dei nomi di Azure Event Hubs che contiene l'hub di evento Azure che prevedi di importare in Pub/Sub.
- Event Hub: il nome dell'hub eventi Azure che prevedi di importare in Pub/Sub.
- ID client: l'ID applicazione (client) dell'app registrata in Azure che contiene l'identità federata dell'account di servizio Google Cloud. Questo valore deve essere un UUID. Per ulteriori informazioni, visita la pagina di registrazione dell'app Azure.
- ID tenant: l'ID directory (tenant) del tenant proprietario dell'hub eventi Azure che prevedi di importare in Pub/Sub. Questo valore deve essere un UUID. Per trovare l'ID tenant, visita la pagina Azure Get subscription and tenant IDs.
- ID abbonamento: l'ID abbonamento dell'abbonamento proprietario del gruppo di risorse Azure Event Hubs. Questo valore deve essere un UUID. Per trovare l'ID abbonamento, visita la pagina Azure Get subscription and tenant IDs.
- Account di servizio: l'account di servizio che hai creato in Creare un service account in Trusted Cloud.
Lascia invariati i valori predefiniti dei restanti campi.
Fai clic su Crea argomento.

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.
Esegui il 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
```
Sostituisci quanto segue:
- TOPIC_ID: il nome o l'ID dell'argomento Pub/Sub.
- RESOURCE_GROUP: il nome del gruppo di risorse Azure Event Hubs che contiene lo spazio dei nomi Azure Event Hubs che prevedi di importare in Pub/Sub.
- NAMESPACE: il nome dello spazio dei nomi di Azure Event Hubs che contiene l'hub eventi Azure che prevedi di importare in Pub/Sub.
- EVENT_HUB: il nome dell'hub eventi di Azure che prevedi di importare in Pub/Sub.
- CLIENT_ID: l'ID applicazione (client) dell'app registrata in Azure che contiene l'identità federata del service accountTrusted Cloud . Questo valore deve essere un UUID. Per ulteriori informazioni, visita la pagina di registrazione dell'app Azure.
- TENANT_ID: l'ID directory (tenant) del tenant proprietario dell'hub eventi Azure che prevedi di importare in Pub/Sub. Questo valore deve essere un UUID. Per trovare l'ID tenant, visita la pagina Azure Get subscription and tenant IDs.
- SUBSCRIPTION_ID: l'ID abbonamento dell'abbonamento proprietario dell'hub eventi Azure che prevedi di importare in Pub/Sub. Questo valore deve essere un UUID. Per trovare l'ID abbonamento, visita la pagina Azure Get subscription and tenant IDs.
- SERVICE_ACCOUNT: il account di servizio che hai creato in Creare un account di servizio in Trusted Cloud

C++

Prima di provare questo esempio, segui le istruzioni di configurazione di C++ nella guida rapida all'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'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";
}

Vai

L'esempio seguente utilizza la versione principale della libreria client Go Pub/Sub (v2). Se utilizzi ancora la libreria v1, consulta la guida alla migrazione alla v2. Per visualizzare un elenco di esempi di codice della versione 1, consulta gli esempi di codice ritirati.

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Java di 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella Guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'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 riscontri problemi, consulta Risoluzione dei problemi relativi a un argomento di importazione di Azure Event Hubs.

Modifica gli argomenti di importazione di Azure Event Hubs

Per modificare le impostazioni dell'origine dati di importazione di un argomento di importazione di Azure Event Hubs:

Console

Nella console Trusted Cloud , vai alla pagina Argomenti.

Vai ad Argomenti
Fai clic sull'argomento di importazione di Azure Event Hubs.
Nella pagina dei dettagli dell'argomento, fai clic su Modifica.
Aggiorna i campi che vuoi modificare.
Fai clic su Aggiorna.

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.
Esegui il comando gcloud pubsub topics update con tutti i flag menzionati nell'esempio seguente:
```
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
```
Sostituisci quanto segue:
- TOPIC_ID: il nome o l'ID dell'argomento Pub/Sub.
- RESOURCE_GROUP: il nome del gruppo di risorse Azure Event Hubs che contiene lo spazio dei nomi Azure Event Hubs che stai importando in Pub/Sub.
- NAMESPACE: il nome dello spazio dei nomi di Azure Event Hubs che contiene l'hub di eventi di Azure che stai importando in Pub/Sub.
- EVENT_HUB: il nome dell'hub eventi Azure che stai importando in Pub/Sub.
- CLIENT_ID: l'ID applicazione (client) dell'app registrata in Azure che contiene l'identità federata del service accountTrusted Cloud . Questo valore deve essere un UUID. Per ulteriori informazioni, consulta la pagina di registrazione dell'app Azure.
- TENANT_ID: l'ID directory (tenant) del tenant proprietario degli hub eventi Azure che stai importando in Pub/Sub. Questo valore deve essere un UUID. Per trovare l'ID tenant, visita la pagina di Azure per ottenere l'ID abbonamento e tenant.
- SUBSCRIPTION_ID: l'ID abbonamento dell'abbonamento proprietario dell'hub eventi Azure che stai importando in Pub/Sub. Questo valore deve essere un UUID. Per trovare l'ID abbonamento, consulta Azure Get subscription and tenant IDs.
- SERVICE_ACCOUNT: il account di servizio che hai creato in Creare un account di servizio in Trusted Cloud

Quote e limiti

Il throughput del publisher per gli argomenti di importazione è vincolato alla quota di pubblicazione dell'argomento. Per maggiori informazioni, consulta Quote e limiti di Pub/Sub.

Passaggi successivi

Monitorare un argomento di importazione.
Scegli il tipo di abbonamento per l'argomento.
Scopri come pubblicare un messaggio in un argomento.
Crea o modifica un argomento con gcloud CLI, API REST o librerie client.
Risolvi i problemi relativi a un argomento di importazione di Azure Event Hubs.