Confluent Cloud-Importthema erstellen

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

In diesem Dokument erfahren Sie, wie Sie Confluent Cloud-Importthemen erstellen und verwalten. Informationen zum Erstellen eines Standardthemas finden Sie unter Standardthema erstellen.

Weitere Informationen zu Importthemen finden Sie unter Importthemen.

Hinweise

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Pub/Sub Editor (roles/pubsub.editor) für Ihr Thema oder Projekt zu erteilen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von Confluent Cloud-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 Confluent Cloud-Importthemen erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Confluent Cloud-Importthemen zu erstellen und zu verwalten:

  • So erstellen Sie ein Importthema: pubsub.topics.create
  • Importthema löschen: pubsub.topics.delete
  • Importthema abrufen: pubsub.topics.get
  • Importthema angeben: pubsub.topics.list
  • In einem importierten Thema veröffentlichen: pubsub.topics.publish
  • 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 Projektebene und auf der Ebene einzelner Ressourcen konfigurieren.

Föderierte Identität für den Zugriff auf Confluent Cloud einrichten

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

Dienstkonto in Google 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 Eindeutige ID des Dienstkontos erfassen fort.

Bei Confluent Cloud-Importthemen verwendet Pub/Sub das Dienstkonto als Identität, um auf Ressourcen von Confluent Cloud zuzugreifen.

Weitere Informationen zum Erstellen eines Dienstkontos, einschließlich Voraussetzungen, erforderlicher Rollen und Berechtigungen sowie Richtlinien für die Benennung, 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.

Notieren Sie sich die eindeutige ID des Dienstkontos.

Sie benötigen eine eindeutige ID für das Dienstkonto, um den Identitätsanbieter und den Pool in der Confluent Cloud Console einzurichten.

  1. Rufen Sie in der Google Cloud Console die Seite Dienstkonto auf.

    Weiter zu 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.

    Sie benötigen die ID im Rahmen des Workflows, um den Identitätsanbieter und den Pool in der Confluent Cloud Console einzurichten.

Dem Pub/Sub-Dienstkonto die Rolle „Ersteller von Dienstkonto-Tokens“ 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 das Dienstkonto zu imitieren.

Weitere Informationen zu Identitätswechsel für Dienstkonten.

Sie können während dieses Vorgangs auch die Rolle „Pub/Sub-Publisher“ (roles/pubsub.publisher) hinzufügen. Weitere Informationen zu dieser Rolle und warum Sie sie hinzufügen, finden Sie unter Dem Pub/Sub-Dienstkonto die Rolle „Pub/Sub-Publisher“ hinzufügen.

  1. Öffnen Sie in der Google Cloud Console die Seite IAM.

    IAM aufrufen

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

  3. Suchen Sie nach dem Dienstkonto im Format service-{PROJECT_NUMBER}@gcp-sa-pubsub.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.

Identitätsanbieter in Confluent Cloud erstellen

Für die Authentifizierung bei Confluent Cloud benötigt das Google Cloud-Dienstkonto einen Identitätspool. Sie müssen zuerst einen Identitätsanbieter in Confluent Cloud erstellen.

Weitere Informationen zum Erstellen eines Identitätsanbieters in Confluent Cloud finden Sie auf der Seite OAuth/OIDC-Identitätsanbieter hinzufügen.

  1. Melden Sie sich in der Confluent Cloud Console an.

  2. Klicken Sie im Menü auf Konten und Zugriff.

  3. Klicken Sie auf Workload Identitys.

  4. Klicken Sie auf Anbieter hinzufügen.

  5. Klicken Sie auf OAuth/OIDC und dann auf Weiter.

  6. Klicken Sie auf Anderer OIDC-Anbieter und dann auf Weiter.

  7. Geben Sie einen Namen und eine Beschreibung für den Zweck des Identitätsanbieters an.

  8. Klicken Sie auf Erweiterte Konfiguration anzeigen.

  9. Geben Sie im Feld Aussteller-URI den Wert https://accounts.google.com ein.

  10. Geben Sie im Feld JWKS-URI den Wert https://www.googleapis.com/oauth2/v3/certs ein.

  11. Klicken Sie auf Validieren und speichern.

Identitätspool erstellen und die entsprechenden Rollen in Confluent Cloud gewähren

Sie müssen einen Identitätspool unter Ihrem Identitätsprofil erstellen und die erforderlichen Rollen erteilen, damit sich das Pub/Sub-Dienstkonto authentifizieren und Daten aus Confluent Cloud-Kafka-Themen lesen kann.

Ihr Cluster muss in Confluent Cloud erstellt werden, bevor Sie mit dem Erstellen eines Identitätspools fortfahren können.

Weitere Informationen zum Erstellen eines Identitätspools finden Sie auf der Seite Identity Pools mit Ihrem OAuth-/OIDC-Identitätsanbieter verwenden.

  1. Melden Sie sich in der Confluent Cloud Console an.

  2. Klicken Sie im Menü auf Konten und Zugriff.

  3. Klicken Sie auf Workload Identitys.

  4. Klicken Sie auf den Identitätsanbieter, den Sie unter Identitätsanbieter in Confluent Cloud erstellen erstellt haben.

  5. Klicken Sie auf Pool hinzufügen.

  6. Geben Sie einen Namen und eine Beschreibung für den Identitätspool ein.

  7. Legen Sie für Identity Claim die Option claims fest.

  8. Klicken Sie unter Filter festlegen auf den Tab Erweitert. Geben Sie den folgenden Code ein:

    claims.iss=='https://accounts.google.com' && claims.sub=='<SERVICE_ACCOUNT_UNIQUE_ID>'

    Ersetzen Sie <SERVICE_ACCOUNT_UNIQUE_ID> durch die eindeutige ID Ihres Dienstkontos, die Sie unter Eindeutige ID des Dienstkontos erfassen finden.

  9. Klicken Sie auf Weiter.

  10. Klicken Sie auf Neue Berechtigung hinzufügen. Klicken Sie dann auf Weiter.

  11. Klicken Sie im entsprechenden Cluster auf Rollenzuweisung hinzufügen.

  12. Klicken Sie auf die Rolle Bediener und dann auf Hinzufügen.

    Diese Rolle gewährt Pub/Sub. Dienstkontozugriff auf den Cluster mit dem Confluent Kafka-Thema, das Sie in Pub/Sub aufnehmen möchten.

  13. Klicken Sie unter dem Cluster auf Themen. Klicken Sie dann auf Rollenzuweisung hinzufügen.

  14. Wählen Sie die Rolle DeveloperRead aus.

  15. Klicken Sie auf die entsprechende Option und geben Sie das Thema oder Präfix an. Beispiel: Bestimmtes Thema, Präfixregel oder Alle Themen.

  16. Klicken Sie auf Hinzufügen.

  17. Klicken Sie auf Weiter.

  18. Klicken Sie auf Validieren und speichern.

Dem Pub/Sub-Principal die Pub/Sub-Publisher-Rolle hinzufügen

Um das Veröffentlichen zu aktivieren, müssen Sie dem Pub/Sub-Dienstkonto die Rolle „Publisher“ zuweisen, damit Pub/Sub im Confluent Cloud-Importthema veröffentlichen kann.

Veröffentlichung aus allen Themenbereichen aktivieren

Verwenden Sie diese Methode, wenn Sie noch keine Confluent Cloud-Importthemen erstellt haben.

  1. Öffnen Sie in der Google Cloud Console die Seite IAM.

    IAM aufrufen

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

  3. Suchen Sie nach dem Dienstkonto im Format service-{PROJECT_NUMBER}@gcp-sa-pubsub.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öffentlichungen aus einem einzelnen Thema aktivieren

Verwenden Sie diese Methode nur, wenn das Confluent Cloud-Importthema bereits vorhanden ist.

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

    Activate Cloud Shell

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

  2. 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.iam.gserviceaccount.com" \
   --role="roles/pubsub.publisher"

    Ersetzen Sie Folgendes:

    • TOPIC_ID: die Themen-ID des Confluent Cloud-Importthemas.

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

Dem Dienstkonto die Rolle „Dienstkontonutzer“ hinzufügen

Die Rolle Dienstkontonutzer (roles/iam.serviceAccountUser) umfasst die Berechtigung iam.serviceAccounts.actAs, mit der ein Hauptkonto ein Dienstkonto an die Aufnahmeeinstellungen des Confluent Cloud-Import-Themas anhängen und dieses Dienstkonto für die föderierte Identität verwenden kann.

  1. Öffnen Sie in der Google Cloud Console die Seite IAM.

    IAM aufrufen

  2. Klicken Sie für das Hauptkonto, das die Aufrufe zum Erstellen oder Aktualisieren von Themen ausführt, 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.

Themen mit Confluent Cloud importieren

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

Hinweise

  • Wenn Sie das Thema und das Abo separat erstellen, kann dies zu Datenverlusten führen, auch wenn Sie dies in schneller Folge tun. Es gibt eine kurze Zeitspanne, in der 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 dann in ein Importthema umwandeln, wird sichergestellt, dass beim Import keine Nachrichten übersehen werden.

  • Wenn Sie das Kafka-Thema eines vorhandenen Importthemas mit demselben Namen neu erstellen möchten, können Sie das Kafka-Thema nicht einfach löschen und neu erstellen. Dadurch kann die Offset-Verwaltung von Pub/Sub ungültig werden, was zu Datenverlusten führen kann. So können Sie das Risiko minimieren:

    • Löschen Sie das Pub/Sub-Importthema.
    • Löschen Sie das Kafka-Thema.
    • Erstellen Sie das Kafka-Thema.
    • Erstellen Sie das Pub/Sub-Importthema.

  • Daten aus einem Confluent Cloud-Kafka-Thema werden immer vom ältesten Offset gelesen.

Confluent Cloud-Importthema erstellen

Weitere Informationen zu den Properties, die mit einem Thema verknüpft sind, finden Sie unter Properties eines Themas.

Führen Sie die folgenden Schritte aus:

So erstellen Sie ein Confluent Cloud-Importthema:

Console

  1. Rufen Sie in der Google 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 ein.

    Weitere Informationen zur Benennung von Themen finden Sie in den Richtlinien für die Benennung von Themen.

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

  5. Wählen Sie Aufnahme aktivieren aus.

  6. Wählen Sie als Datenaufnahmequelle Confluent Cloud aus.

  7. Geben Sie die folgenden Informationen ein:

    1. Bootstrap-Server: Der Bootstrap-Server Ihres Clusters, der das Kafka-Thema enthält, das Sie in Pub/Sub aufnehmen. Das Format ist hostname:port.

    2. Cluster-ID: Die ID Ihres Clusters, der das Kafka-Thema enthält, das Sie in Pub/Sub aufnehmen.

    3. Topic: Der Name des Kafka-Themas, das Sie in Pub/Sub aufnehmen.

    4. Identity Pool-ID: Die Pool-ID des Identitätspools, die für die Authentifizierung bei Confluent Cloud verwendet wird.

    5. Dienstkonto:Das Dienstkonto, das Sie unter Dienstkonto in Google Cloud erstellen erstellt haben.

  8. Klicken Sie auf Thema erstellen.

gcloud

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

    Activate Cloud Shell

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

  2. Zum Abrufen der aktuellen Richtlinie führen Sie den Befehl gcloud pubsub topics create aus:

    gcloud pubsub topics create TOPIC_ID \
    --confluent-cloud-ingestion-bootstrap-server CONFLUENT_BOOTSTRAP_SERVER \
    --confluent-cloud-ingestion-cluster-id CONFLUENT_CLUSTER_ID \
    --confluent-cloud-ingestion-topic CONFLUENT_TOPIC \
    --confluent-cloud-ingestion-identity-pool-id CONFLUENT_IDENTITY_POOL_ID \
    --confluent-cloud-ingestion-service-account PUBSUB_SERVICE_ACCOUNT

    Ersetzen Sie Folgendes:

    • TOPIC_ID: der Name oder die ID Ihres Pub/Sub-Themas.
    • CONFLUENT_BOOTSTRAP_SERVER: Der Bootstrap-Server Ihres Clusters, der das Kafka-Thema enthält, das Sie in Pub/Sub aufnehmen. Das Format ist hostname:port.
    • CONFLUENT_CLUSTER_ID: die ID Ihres Clusters, der das Kafka-Thema enthält, das Sie in Pub/Sub aufnehmen.
    • CONFLUENT_TOPIC: der Name des Kafka-Themas, das Sie in Pub/Sub aufnehmen.
    • CONFLUENT_IDENTITY_POOL_ID: die Pool-ID des Identitätspools, der für die Authentifizierung bei Confluent Cloud verwendet wird.
    • PUBSUB_SERVICE_ACCOUNT: Das Dienstkonto, das Sie unter Dienstkonto in Google Cloud erstellen erstellt haben.

Go

Folgen Sie der Einrichtungsanleitung für Go in der Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

import (
	"context"
	"fmt"
	"io"

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

func createTopicWithConfluentCloudIngestion(w io.Writer, projectID, topicID, bootstrapServer, clusterID, confluentTopic, poolID, gcpSA string) error {
	// projectID := "my-project-id"
	// topicID := "my-topic"

	// // Confluent Cloud ingestion settings.
	// bootstrapServer := "bootstrap-server"
	// clusterID := "cluster-id"
	// confluentTopic := "confluent-topic"
	// poolID := "identity-pool-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.IngestionDataSourceConfluentCloud{
				BootstrapServer:   bootstrapServer,
				ClusterID:         clusterID,
				Topic:             confluentTopic,
				IdentityPoolID:    poolID,
				GCPServiceAccount: gcpSA,
			},
		},
	}
	t, err := client.CreateTopicWithConfig(ctx, topicID, cfg)
	if err != nil {
		return fmt.Errorf("CreateTopic: %w", err)
	}
	fmt.Fprintf(w, "Created topic with Confluent Cloud ingestion: %v\n", t)
	return nil
}

Java

Folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


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 CreateTopicWithConfluentCloudIngestionExample {
  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";
    // Confluent Cloud ingestion settings.
    String bootstrapServer = "bootstrap-server";
    String clusterId = "cluster-id";
    String confluentTopic = "confluent-topic";
    String identityPoolId = "identity-pool-id";
    String gcpServiceAccount = "gcp-service-account";

    createTopicWithConfluentCloudIngestionExample(
        projectId,
        topicId,
        bootstrapServer,
        clusterId,
        confluentTopic,
        identityPoolId,
        gcpServiceAccount);
  }

  public static void createTopicWithConfluentCloudIngestionExample(
      String projectId,
      String topicId,
      String bootstrapServer,
      String clusterId,
      String confluentTopic,
      String identityPoolId,
      String gcpServiceAccount)
      throws IOException {
    try (TopicAdminClient topicAdminClient = TopicAdminClient.create()) {
      TopicName topicName = TopicName.of(projectId, topicId);

      IngestionDataSourceSettings.ConfluentCloud confluentCloud =
          IngestionDataSourceSettings.ConfluentCloud.newBuilder()
              .setBootstrapServer(bootstrapServer)
              .setClusterId(clusterId)
              .setTopic(confluentTopic)
              .setIdentityPoolId(identityPoolId)
              .setGcpServiceAccount(gcpServiceAccount)
              .build();
      IngestionDataSourceSettings ingestionDataSourceSettings =
          IngestionDataSourceSettings.newBuilder().setConfluentCloud(confluentCloud).build();

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

      System.out.println(
          "Created topic with Confluent Cloud ingestion settings: " + topic.getAllFields());
    }
  }
}

Node.js

Folgen Sie der Einrichtungsanleitung für Node.js in der Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Node.js API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const bootstrapServer = 'url:port';
// const clusterId = 'YOUR_CLUSTER_ID';
// const confluentTopic = 'YOUR_CONFLUENT_TOPIC';
// const identityPoolId = 'pool-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 createTopicWithConfluentCloudIngestion(
  topicNameOrId,
  bootstrapServer,
  clusterId,
  confluentTopic,
  identityPoolId,
  gcpServiceAccount
) {
  // Creates a new topic with Confluent Cloud ingestion.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    ingestionDataSourceSettings: {
      confluentCloud: {
        bootstrapServer,
        clusterId,
        topic: confluentTopic,
        identityPoolId,
        gcpServiceAccount,
      },
    },
  });
  console.log(`Topic ${topicNameOrId} created with Confluent Cloud ingestion.`);
}

Python

Folgen Sie der Einrichtungsanleitung für Python in der Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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"
# bootstrap_server = "your-bootstrap-server"
# cluster_id = "your-cluster-id"
# confluent_topic = "your-confluent-topic"
# identity_pool_id = "your-identity-pool-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(
        confluent_cloud=IngestionDataSourceSettings.ConfluentCloud(
            bootstrap_server=bootstrap_server,
            cluster_id=cluster_id,
            topic=confluent_topic,
            identity_pool_id=identity_pool_id,
            gcp_service_account=gcp_service_account,
        )
    ),
)

topic = publisher.create_topic(request=request)

print(f"Created topic: {topic.name} with Confluent Cloud Ingestion Settings")

C++

Folgen Sie der Einrichtungsanleitung für C++ in der Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub C++ API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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& bootstrap_server,
   std::string const& cluster_id, std::string const& confluent_topic,
   std::string const& identity_pool_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* confluent_cloud = request.mutable_ingestion_data_source_settings()
                              ->mutable_confluent_cloud();
  confluent_cloud->set_bootstrap_server(bootstrap_server);
  confluent_cloud->set_cluster_id(cluster_id);
  confluent_cloud->set_topic(confluent_topic);
  confluent_cloud->set_identity_pool_id(identity_pool_id);
  confluent_cloud->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";
}

Node.js (TypeScript)

Lesen Sie unter Pub/Sub-Schnellstart-Anleitung: Clientbibliotheken verwenden die Anleitung für die Einrichtung von Node.js, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Pub/Sub Node.js API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Pub/Sub zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const topicNameOrId = 'YOUR_TOPIC_NAME_OR_ID';
// const bootstrapServer = 'url:port';
// const clusterId = 'YOUR_CLUSTER_ID';
// const confluentTopic = 'YOUR_CONFLUENT_TOPIC';
// const identityPoolId = 'pool-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 createTopicWithConfluentCloudIngestion(
  topicNameOrId: string,
  bootstrapServer: string,
  clusterId: string,
  confluentTopic: string,
  identityPoolId: string,
  gcpServiceAccount: string
) {
  // Creates a new topic with Confluent Cloud ingestion.
  await pubSubClient.createTopic({
    name: topicNameOrId,
    ingestionDataSourceSettings: {
      confluentCloud: {
        bootstrapServer,
        clusterId,
        topic: confluentTopic,
        identityPoolId,
        gcpServiceAccount,
      },
    },
  });
  console.log(`Topic ${topicNameOrId} created with Confluent Cloud ingestion.`);
}

Falls Probleme auftreten, lesen Sie den Hilfeartikel Probleme beim Importieren von Topics aus Confluent Cloud beheben.

Importthema für Confluent Cloud Hubs bearbeiten

So bearbeiten Sie die Einstellungen der Datenaufnahmequelle eines Confluent Cloud-Importthemas:

Console

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

    Themen aufrufen

  2. Klicken Sie auf das Importthema für Confluent Cloud.

  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 Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

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

    Damit die Einstellungen für das importierte Thema nicht verloren gehen, sollten Sie sie jedes Mal angeben, wenn Sie das Thema aktualisieren. Wenn du etwas auslässt, wird die Einstellung von Pub/Sub auf den ursprünglichen Standardwert zurückgesetzt.

  2. Führen Sie den Befehl gcloud pubsub topics update mit allen im folgenden Beispiel genannten Flags aus:

    gcloud pubsub topics update TOPIC_ID \
   --confluent-cloud-ingestion-bootstrap-server CONFLUENT_BOOTSTRAP_SERVER \
   --confluent-cloud-ingestion-cluster-id CONFLUENT_CLUSTER_ID \
   --confluent-cloud-ingestion-topic CONFLUENT_TOPIC \
   --confluent-cloud-ingestion-identity-pool-id CONFLUENT_IDENTITY_POOL_ID \
   --confluent-cloud-ingestion-service-account PUBSUB_SERVICE_ACCOUNT

    Ersetzen Sie Folgendes:

    • TOPIC_ID: der Name oder die ID Ihres Pub/Sub-Themas.
    • CONFLUENT_BOOTSTRAP_SERVER: Der Bootstrap-Server Ihres Clusters, der das Kafka-Thema enthält, das Sie in Pub/Sub aufnehmen. Das Format ist hostname:port.
    • CONFLUENT_CLUSTER_ID: Die ID Ihres Clusters, der das Kafka-Thema enthält, das Sie in Pub/Sub aufnehmen
    • CONFLUENT_TOPIC: Der Name des Kafka-Themas, das Sie in Pub/Sub aufnehmen.
    • CONFLUENT_IDENTITY_POOL_ID: Die Pool-ID des Identitätspools, der für die Authentifizierung bei Confluent Cloud verwendet wird.
    • CONFLUENT_IDENTITY_POOL_ID: Das Dienstkonto, das Sie unter Dienstkonto in Google Cloud erstellen erstellt haben.

Kontingente und Limits

Der Publisher-Durchsatz für importierte Themen ist durch das Publish-Kontingent des Themas begrenzt. Weitere Informationen finden Sie unter Pub/Sub-Kontingente und Limits.

Nächste Schritte

Apache Kafka® ist eine eingetragene Marke der Apache Software Foundation oder deren Tochtergesellschaften in den USA und/oder anderen Ländern.