Azure Event Hubs-Importthema erstellen

Mit einem Azure Event Hubs-Importthema können Sie Daten kontinuierlich aus Azure Event Hubs als externe Quelle in Pub/Sub aufnehmen. Anschließend können Sie die Daten in eines der Ziele streamen, die von Pub/Sub unterstützt werden.

In diesem Dokument wird beschrieben, wie Sie Importthemen für Azure Event Hubs erstellen und verwalten. Informationen zum Erstellen eines Standardthemas finden Sie unter Standardthema erstellen.

Weitere Informationen zu Importthemen finden Sie unter Importthemen.

Hinweise

• Weitere Informationen zum Pub/Sub-Veröffentlichungsprozess

• Konfigurieren Sie die erforderlichen Rollen und Berechtigungen zum Verwalten von Azure Event Hubs-Importthemen, einschließlich der folgenden:

  • Dem Pub/Sub-Dienstkonto die Rolle „Pub/Sub-Publisher“ hinzufügen

  • Fügen Sie dem Pub/Sub-Dienstkonto die Rolle des Pub/Sub-Dienst-Agents hinzu, falls sie noch nicht zugewiesen ist.

  • Dem Dienstkonto die Rolle „Dienstkontonutzer“ hinzufügen

• Richten Sie die Workload Identity-Föderation ein, damitTrusted Cloud auf den externen Streamingdienst zugreifen kann.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub Editor (roles/pubsub.editor) für Ihr Thema oder Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von Azure Event Hubs-Importthemen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Erstellen und Verwalten von Azure Event Hubs-Importthemen erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Azure Event Hubs-Importthemen zu erstellen und zu verwalten:

• Importthema erstellen: pubsub.topics.create
• Importthema löschen: pubsub.topics.delete
• Importthema abrufen: pubsub.topics.get
• Importthema auflisten: pubsub.topics.list
• In einem Importthema veröffentlichen: pubsub.topics.publish and pubsub.serviceAgent
• Importthema aktualisieren: pubsub.topics.update
• IAM-Richtlinie für ein Importthema abrufen: pubsub.topics.getIamPolicy
• Konfigurieren Sie die IAM-Richtlinie für ein Importthema: pubsub.topics.setIamPolicy

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Sie können die Zugriffssteuerung auf Projekt- und auf der Ebene einzelner Ressourcen konfigurieren.

Föderierte Identität für den Zugriff auf Azure Event Hubs einrichten

Mit der Workload Identity-Föderation können Trusted Cloud Dienste auf Arbeitslasten zugreifen, die außerhalb von Trusted Cloudausgeführt werden. Bei der Identitätsföderation müssen Sie keine Anmeldedaten für Trusted Cloud verwalten oder übergeben, um auf Ihre Ressourcen in anderen Clouds zuzugreifen. Stattdessen können Sie die Identitäten der Arbeitslasten selbst verwenden, um sich bei Trusted Cloud zu authentifizieren und auf Ressourcen zuzugreifen.

Dienstkonto in Trusted Clouderstellen

Dieser Schritt ist optional. Wenn Sie bereits ein Dienstkonto haben, können Sie es in diesem Verfahren verwenden, anstatt ein neues Dienstkonto zu erstellen. Wenn Sie ein vorhandenes Dienstkonto verwenden, fahren Sie mit dem nächsten Schritt fort: Eindeutige ID des Dienstkontos notieren.

Bei Importthemen für Azure Event Hubs verwendet Pub/Sub das Dienstkonto als Identität für den Zugriff auf Ressourcen aus Azure.

Weitere Informationen zum Erstellen eines Dienstkontos, einschließlich Voraussetzungen, erforderlicher Rollen und Berechtigungen sowie Namensrichtlinien, finden Sie unter Dienstkonten erstellen. Nachdem Sie ein Dienstkonto erstellt haben, müssen Sie möglicherweise 60 Sekunden oder länger warten, bis Sie das Dienstkonto verwenden können. Dieses Verhalten tritt auf, weil Lesevorgänge Eventual Consistency haben. Es kann einige Zeit dauern, bis das neue Dienstkonto sichtbar ist.

Eindeutige ID des Dienstkontos notieren

Sie benötigen eine eindeutige Dienstkonto-ID, um die App-Registrierung in Azure einzurichten.

1. Rufen Sie in der Trusted Cloud Console die Detailseite Dienstkonto auf.

   Zum Dienstkonto

2. Klicken Sie auf das Dienstkonto, das Sie gerade erstellt haben oder das Sie verwenden möchten.

3. Notieren Sie sich auf der Seite Dienstkontodetails die eindeutige ID-Nummer.

   Sie benötigen die ID als Teil des Workflows, um die App-Registrierung in Azure einzurichten.

Rolle „Ersteller von Dienstkonto-Tokens“ dem Pub/Sub-Dienstkonto hinzufügen

Mit der Rolle „Ersteller von Dienstkonto-Tokens“ (roles/iam.serviceAccountTokenCreator) können Hauptkonten kurzlebige Anmeldedaten für ein Dienstkonto erstellen. Diese Tokens oder Anmeldedaten werden verwendet, um die Identität des Dienstkontos zu übernehmen.

Weitere Informationen zu Identitätswechsel für Dienstkonten.

Sie können auch die Rolle „Pub/Sub-Publisher“ (roles/pubsub.publisher) hinzufügen. Weitere Informationen zur Rolle und dazu, warum Sie sie hinzufügen, finden Sie unter Pub/Sub-Publisher-Rolle dem Pub/Sub-Dienstkonto hinzufügen.

1. Rufen Sie in der Trusted Cloud Console die Seite IAM auf.

   IAM aufrufen

2. Klicken Sie auf das Kästchen Von S3NSbereitgestellte Rollenzuweisungen einschließen.

3. Suchen Sie nach dem Dienstkonto im Format service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

4. Klicken Sie für dieses Dienstkonto auf die Schaltfläche Hauptkonto bearbeiten.

5. Klicken Sie bei Bedarf auf Weitere Rolle hinzufügen.

6. Suchen Sie nach der Rolle „Ersteller von Dienstkonto-Tokens“ (roles/iam.serviceAccountTokenCreator) und klicken Sie darauf.

7. Klicken Sie auf Speichern.

App-Registrierung mit Identitätsföderation erstellen

Wenn Sie Daten aus Azure Event Hubs aufnehmen möchten, registrieren Sie eine Anwendung bei der Microsoft Identity-Plattform und aktivieren Sie die Identitätsföderation für Ihr Dienstkonto. So kann sich Ihr Dienstkonto bei Azure authentifizieren.

Weitere Informationen zum Registrieren einer Anwendung bei der Microsoft Identity-Plattform finden Sie im Azure-App-Registrierungs-Schnellstart.

1. Melden Sie sich im Azure-Portal an und öffnen Sie die Seite Microsoft Entra ID.

2. Klicken Sie im Navigationsbereich auf Verwalten > App-Registrierungen.

3. Klicken Sie auf Neue Registrierung.

4. Geben Sie einen Namen für die Anwendung ein und legen Sie Unterstützte Kontotypen auf einen anderen Wert als Nur private Microsoft-Konten fest.

5. Klicken Sie auf Registrieren, um die Anwendung zu registrieren.

6. Öffnen Sie die Anwendung und klicken Sie auf Verwalten > Zertifikate und Schlüssel.

7. Klicken Sie auf Anmeldedaten hinzufügen.

8. Wenn Sie föderierte Anmeldedaten konfigurieren möchten, klicken Sie auf Anderer Aussteller.

9. Geben Sie im Feld Aussteller https://accounts.google.com ein.

10. Geben Sie im Feld Wert die eindeutige ID Ihres Pub/Sub-Dienstkontos ein.

    Sie finden diese ID unter Eindeutige ID des Dienstkontos aufzeichnen.

11. Geben Sie einen Namen für die föderierte Identität ein und klicken Sie auf Hinzufügen.

Der registrierten App Rollenzuweisungen erteilen

Damit Pub/Sub Daten aus Ihrem Azure-Event Hub lesen kann, müssen Sie Ihrer registrierten App die erforderlichen Rollen zuweisen.

1. Melden Sie sich im Azure-Portal an und öffnen Sie Ihren Event Hubs-Namespace.

   Wenn Sie einen Namespace öffnen möchten, geben Sie Event Hubs in die Suche ein und klicken Sie dann auf einen der Namespaces.

2. Klicken Sie in der Seitenleiste auf Zugriffssteuerung (IAM).

3. Klicken Sie auf Hinzufügen > Rollenzuweisung hinzufügen.

4. Wählen Sie die Rolle Azure Event Hubs Data Receiver aus und klicken Sie auf Weiter.

   Dadurch erhält das Pub/Sub-Dienstkonto Lesezugriff auf Ihren Azure-Event Hub.

5. Klicken Sie auf + Mitglieder auswählen und suchen Sie nach Ihrer registrierten App.

6. Geben Sie den registrierten Namen der App in das Suchfeld ein.

7. Klicken Sie auf den Namen Ihrer App und dann auf Auswählen.

8. Klicken Sie auf Überprüfen und zuweisen.

9. Wiederholen Sie die Schritte 3 bis 6 und fügen Sie die Rolle Azure Event Hubs Data Sender hinzu.

   Mit dieser Rolle wird dem Google Cloud-Dienstkonto die Berechtigung erteilt, Metadaten aus Ihrem Azure-Event Hub abzurufen.

Weitere Informationen zum Zuweisen von Azure-Rollen finden Sie auf der Seite Azure-Rollen zuweisen.

Pub/Sub-Publisher-Rolle dem Pub/Sub-Principal hinzufügen

Damit die Veröffentlichung möglich ist, müssen Sie dem Pub/Sub-Dienstkonto eine Publisher-Rolle zuweisen, damit Pub/Sub im Azure Event Hubs-Importthema veröffentlichen kann.

Pub/Sub-Dienst-Agent-Rolle dem Pub/Sub-Dienstkonto hinzufügen

Damit Pub/Sub das Veröffentlichungskontingent des Projekts Ihres Importthemas verwenden kann, benötigt der Pub/Sub-Dienst-Agent die Berechtigung serviceusage.services.use für das Projekt Ihres Importthemas.

Um diese Berechtigung zu erteilen, empfehlen wir, dem Pub/Sub-Dienstkonto die Rolle „Pub/Sub-Dienst-Agent“ hinzuzufügen.

Wenn das Pub/Sub-Dienstkonto nicht über die Rolle „Pub/Sub-Dienst-Agent“ verfügt, kann sie so zugewiesen werden:

1. Rufen Sie in der Trusted Cloud Console die Seite IAM auf.

   IAM aufrufen

2. Klicken Sie auf das Kästchen Von S3NSbereitgestellte Rollenzuweisungen einschließen.

3. Suchen Sie nach dem Dienstkonto im Format service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

4. Klicken Sie für dieses Dienstkonto auf die Schaltfläche Hauptkonto bearbeiten.

5. Klicken Sie bei Bedarf auf Weitere Rolle hinzufügen.

6. Suchen Sie nach der Rolle „Pub/Sub-Dienst-Agent“ (roles/pubsub.serviceAgent) und klicken Sie darauf.

7. Klicken Sie auf Speichern.

Veröffentlichung von allen Themen aus aktivieren

Verwenden Sie diese Methode, wenn Sie noch keine Importthemen für Azure Event Hubs erstellt haben.

1. Rufen Sie in der Trusted Cloud Console die Seite IAM auf.

   IAM aufrufen

2. Klicken Sie auf das Kästchen Von S3NSbereitgestellte Rollenzuweisungen einschließen.

3. Suchen Sie nach dem Dienstkonto im Format service-{PROJECT_NUMBER}@gcp-sa-pubsub.s3ns-system.iam.gserviceaccount.com.

4. Klicken Sie für dieses Dienstkonto auf die Schaltfläche Hauptkonto bearbeiten.

5. Klicken Sie bei Bedarf auf Weitere Rolle hinzufügen.

6. Suchen Sie nach der Rolle „Pub/Sub-Publisher“ (roles/pubsub.publisher) und klicken Sie darauf.

7. Klicken Sie auf Speichern.

Veröffentlichung aus einem einzelnen Thema aktivieren

Verwenden Sie diese Methode nur, wenn das Azure Event Hubs-Importthema bereits vorhanden ist.

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. Führen Sie den Befehl gcloud pubsub topics add-iam-policy-binding aus:

   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"

   Ersetzen Sie Folgendes:

   • TOPIC_ID: die Themen-ID des Azure Event Hubs-Importthemas.

   • PROJECT_NUMBER: die Projektnummer Informationen zum Aufrufen der Projektnummer finden Sie unter Projekte identifizieren.

Rolle „Dienstkontonutzer“ dem Dienstkonto hinzufügen

Die Rolle „Dienstkontonutzer“ (roles/iam.serviceAccountUser) enthält die Berechtigung iam.serviceAccounts.actAs, mit der ein Hauptkonto ein Dienstkonto an die Aufnahmeeinstellungen des Azure Event Hubs-Importthemas anhängen und dieses Dienstkonto für die föderierte Identität verwenden kann.

1. Rufen Sie in der Trusted Cloud Console die Seite IAM auf.

   IAM aufrufen

2. Klicken Sie für das Hauptkonto, das die Aufrufe zum Erstellen oder Aktualisieren von Themen ausgibt, auf die Schaltfläche Hauptkonto bearbeiten.

3. Klicken Sie bei Bedarf auf Weitere Rolle hinzufügen.

4. Suchen Sie nach der Rolle „Dienstkontonutzer“ (roles/iam.serviceAccountUser) und klicken Sie darauf.

5. Klicken Sie auf Speichern.

Azure Event Hubs-Importthemen verwenden

Sie können ein neues Importthema erstellen oder ein vorhandenes Thema bearbeiten.

Hinweise

• Wenn Sie das Thema und das Abo separat erstellen, kann es zu Datenverlusten kommen, auch wenn Sie die Schritte schnell nacheinander ausführen. Es gibt ein kurzes Zeitfenster, in dem das Thema ohne Abo verfügbar ist. Wenn während dieser Zeit Daten an das Thema gesendet werden, gehen sie verloren. Wenn Sie zuerst das Thema und dann das Abo erstellen und das Thema anschließend in ein Importthema umwandeln, stellen Sie sicher, dass während des Importvorgangs keine Nachrichten verloren gehen.

• Wenn Sie den Azure-Event Hub eines vorhandenen Importthemas mit demselben Namen neu erstellen müssen, können Sie den Azure-Event Hub nicht einfach löschen und neu erstellen. Diese Aktion kann die Offsetverwaltung von Pub/Sub ungültig machen, was zu Datenverlust führen kann. So können Sie das Problem beheben:

  • Pub/Sub-Importthema löschen
  • Azure Event Hub löschen
  • Azure Event Hub erstellen
  • Pub/Sub-Importthema erstellen

• Daten aus einem Azure-Ereignishub werden immer ab dem frühesten Offset gelesen.

Azure Event Hubs-Importthemen erstellen

Weitere Informationen zu den Attributen eines Themas

Achten Sie darauf, dass Sie die folgenden Schritte ausgeführt haben:

• Föderierte Identität für den Zugriff auf Azure Event Hubs einrichten

• Dem Pub/Sub-Dienstkonto die Rolle „Pub/Sub-Publisher“ hinzufügen

• IAM-Rolle „Dienstkontonutzer“ dem IAM-Principal hinzufügen

So erstellen Sie ein Azure Event Hubs-Importthema:

Console

1. Rufen Sie in der Trusted Cloud Console die Seite Themen auf.

   Themen aufrufen

2. Klicken Sie auf Thema erstellen.

3. Geben Sie im Feld Themen-ID eine ID für das Importthema für Azure Event Hubs ein. Weitere Informationen zur Benennung von Themen finden Sie in den Benennungsrichtlinien.

4. Wählen Sie Standardabo hinzufügen aus.

5. Wählen Sie Aufnahme aktivieren aus.

6. Wählen Sie als Erfassungsquelle Azure Event Hubs aus.

7. Geben Sie die folgenden Informationen ein:

   • Ressourcengruppe: Der Name der Azure-Ressourcengruppe, die den Azure Event Hubs-Namespace enthält, in den Sie Daten in Pub/Sub aufnehmen möchten.
   • Event Hub-Namespace: Der Name des Azure Event Hubs-Namespace, der den Azure Event Hub enthält, den Sie in Pub/Sub aufnehmen möchten.
   • Event Hub: Der Name des Azure Event Hubs, den Sie in Pub/Sub aufnehmen möchten.
   • Client-ID: Die Anwendungs- oder Client-ID der registrierten App in Azure, die die föderierte Identität des Google Cloud-Dienstkontos enthält. Dieser Wert sollte eine UUID sein. Weitere Informationen finden Sie auf der Seite zur Azure-App-Registrierung.
   • Mandanten-ID: Die Verzeichnis-ID (Mandanten-ID) des Mandanten, zu dem der Azure-Event Hub gehört, den Sie in Pub/Sub aufnehmen möchten. Dieser Wert sollte eine UUID sein. Ihre Mandanten-ID finden Sie auf der Seite Azure-Abo- und Mandanten-IDs abrufen.
   • Abo-ID: Die Abo-ID des Abos, zu dem die Azure Event Hubs-Ressourcengruppe gehört. Dieser Wert sollte eine UUID sein. Ihre Abo-ID finden Sie auf der Seite Azure-Abo- und Mandanten-IDs abrufen.
   • Dienstkonto:Das Dienstkonto, das Sie in Dienstkonto in Trusted Clouderstellen erstellt haben.

8. Behalten Sie für die übrigen Felder die Standardwerte bei.

9. Klicken Sie auf Thema erstellen.

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. Führen Sie den Befehl gcloud pubsub topics create aus:

     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
   

   Ersetzen Sie Folgendes:

   • TOPIC_ID: der Name oder die ID Ihres Pub/Sub-Themas.
   • RESOURCE_GROUP: Der Name der Azure Event Hubs-Ressourcengruppe, die den Azure Event Hubs-Namespace enthält, in den Sie Daten in Pub/Sub aufnehmen möchten.
   • NAMESPACE: der Name des Azure Event Hubs-Namespace, der den Azure Event Hub enthält, den Sie in Pub/Sub aufnehmen möchten.
   • EVENT_HUB: Der Name des Azure Event Hub, den Sie in Pub/Sub aufnehmen möchten.
   • CLIENT_ID: die Anwendungs-ID (Client) der registrierten App in Azure, die die föderierte Identität desTrusted Cloud Dienstkontos enthält. Dieser Wert sollte eine UUID sein. Weitere Informationen finden Sie auf der Seite zur Azure-App-Registrierung.
   • TENANT_ID: die Verzeichnis-ID (Mandanten-ID) des Mandanten, zu dem der Azure-Ereignishub gehört, den Sie in Pub/Sub aufnehmen möchten. Dieser Wert sollte eine UUID sein. Ihre Mandanten-ID finden Sie auf der Seite Azure-Abo- und Mandanten-IDs abrufen.
   • SUBSCRIPTION_ID: die Abo-ID des Abos, zu dem der Azure-Event Hub gehört, den Sie in Pub/Sub aufnehmen möchten. Dieser Wert sollte eine UUID sein. Ihre Abo-ID finden Sie auf der Seite Azure-Abo- und Mandanten-IDs abrufen.
   • SERVICE_ACCOUNT: Das Dienstkonto, das Sie in Dienstkonto in Trusted Clouderstellen erstellt haben.

C++

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für C++ in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C++ API.

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

Im folgenden Beispiel wird die Hauptversion der Go Pub/Sub-Clientbibliothek (v2) verwendet. Wenn Sie noch die v1-Bibliothek verwenden, finden Sie hier den Migrationsleitfaden für v2. Eine Liste der Codebeispiele für Version 1 finden Sie unter Eingestellte Codebeispiele.

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Go in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Pub/Sub Go API.

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Pub/Sub Java API.

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für PHP in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Pub/Sub Node.js API.

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für PHP in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Pub/Sub Node.js API.

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

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Python in der Schnellstart-Anleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Pub/Sub Python API.

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")

Falls Probleme auftreten, lesen Sie den Abschnitt Fehlerbehebung beim Importieren von Themen aus Azure Event Hubs.

Azure Event Hubs-Importthemen bearbeiten

So bearbeiten Sie die Einstellungen der Erfassungsdatenquelle eines Azure Event Hubs-Importthemas:

Console

1. Rufen Sie in der Trusted Cloud Console die Seite Themen auf.

   Themen aufrufen

2. Klicken Sie auf das Thema zum Importieren von Azure Event Hubs.

3. Klicken Sie auf der Seite mit den Themendetails auf Bearbeiten.

4. Aktualisieren Sie die Felder, die Sie ändern möchten.

5. Klicken Sie auf Aktualisieren.

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. Führen Sie den Befehl gcloud pubsub topics update mit allen im folgenden Beispiel genannten Flags aus:

   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
   

   Ersetzen Sie Folgendes:

   • TOPIC_ID: der Name oder die ID Ihres Pub/Sub-Themas.
   • RESOURCE_GROUP: der Name der Azure Event Hubs-Ressourcengruppe, die den Azure Event Hubs-Namespace enthält, in den Sie Daten in Pub/Sub aufnehmen.
   • NAMESPACE: Der Name des Azure Event Hubs-Namespace, der den Azure Event Hub enthält, den Sie in Pub/Sub aufnehmen.
   • EVENT_HUB: der Name des Azure Event Hub, in den Sie Daten in Pub/Sub aufnehmen.
   • CLIENT_ID: die Anwendungs-ID (Client) der registrierten App in Azure, die die föderierte Identität desTrusted Cloud Dienstkontos enthält. Dieser Wert sollte eine UUID sein. Weitere Informationen finden Sie auf der Seite zur Azure-App-Registrierung.
   • TENANT_ID: die Verzeichnis-ID (Mandanten-ID) des Mandanten, zu dem die Azure Event Hubs gehören, die Sie in Pub/Sub aufnehmen. Dieser Wert sollte eine UUID sein. Weitere Informationen zum Abrufen Ihrer Mandanten-ID
   • SUBSCRIPTION_ID: die Abo-ID des Abos, zu dem der Azure-Event Hub gehört, aus dem Sie Daten in Pub/Sub aufnehmen. Dieser Wert sollte eine UUID sein. Informationen zum Suchen Ihrer Abo-ID finden Sie unter Azure-Abo- und Mandanten-IDs abrufen.
   • SERVICE_ACCOUNT: Das Dienstkonto, das Sie in Dienstkonto in Trusted Clouderstellen erstellt haben.

Kontingente und Limits

Der Publisher-Durchsatz für Importthemen ist an das Veröffentlichungskontingent des Themas gebunden. Weitere Informationen finden Sie unter Pub/Sub-Kontingente und ‑Limits.

Nächste Schritte

• Importthema überwachen

• Wählen Sie den Abotyp für Ihr Thema aus.

• Informationen zum Veröffentlichen einer Nachricht in einem Thema

• Erstellen oder ändern Sie ein Thema mit der gcloud CLI, den REST APIs oder den Clientbibliotheken.

• Fehlerbehebung bei einem Azure Event Hubs-Importthema