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 in 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

• Weitere Informationen zum Pub/Sub-Veröffentlichungsprozess

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

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

  • Dem Dienstkonto die Rolle „Dienstkontonutzer“ hinzufügen

• Richten Sie die Workload Identity-Föderation ein, damitGoogle 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 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:

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.

Federated Identity 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. Bei der Identitätsföderation müssen Sie keine Anmeldedaten für Google 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 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 dem nächsten Schritt fort: Eindeutige ID des Dienstkontos notieren.

Bei Confluent Cloud-Importthemen verwendet Pub/Sub das Dienstkonto als Identität für den Zugriff auf Ressourcen aus Confluent Cloud.

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 den Identitätsanbieter und den Pool in der Confluent Cloud Console einzurichten.

1. Rufen Sie in der Google 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 den Identitätsanbieter und den Pool in der Confluent Cloud Console 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 Google Cloud Console die Seite IAM auf.

   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 Add an OAuth/OIDC Identity Provider.

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 Other OIDC Provider (Anderer OIDC-Anbieter) und dann auf Next (Weiter).

7. Geben Sie einen Namen und eine Beschreibung des Zwecks 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 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 zuweisen

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

Achten Sie darauf, dass Ihr Cluster in Confluent Cloud erstellt wird, bevor Sie mit dem Erstellen eines Identitätspools fortfahren.

Weitere Informationen zum Erstellen eines Identitätspools finden Sie auf der Seite Identitätspools 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 Identitätsanspruch auf 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 notieren 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 Operator und dann auf Hinzufügen.

    Diese Rolle gewährt Pub/Sub. Dienstkonto-Zugriff auf den Cluster, der das Confluent Kafka-Thema enthält, 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. Beispiele: 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.

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 Confluent Cloud-Importthema veröffentlichen kann.

Veröffentlichung von allen Themen aus aktivieren

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

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

   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öffentlichung 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 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 Confluent Cloud-Importthemas anhängen und dieses Dienstkonto für die föderierte Identität verwenden kann.

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

Confluent Cloud-Themen importieren

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 das Kafka-Thema eines vorhandenen Importthemas mit demselben Namen neu erstellen müssen, können Sie das Kafka-Thema 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:

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

• Daten aus einem Confluent Cloud Kafka-Thema werden immer ab dem frühesten Offset gelesen.

Confluent Cloud-Importthema erstellen

Weitere Informationen zu den Attributen eines Themas

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

• Federated Identity für den Zugriff auf Confluent Cloud einrichten

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

• Dem Dienstkonto die Rolle „Dienstkontonutzer“ hinzufügen

So erstellen Sie ein Confluent Cloud-Importthema:

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
}

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());
    }
  }
}

/**
 * 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.`);
}

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

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";
}

/**
 * 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 Abschnitt Fehlerbehebung bei einem Confluent Cloud-Importthema.

Confluent Cloud Hubs-Importthema bearbeiten

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

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.

• Probleme beim Importieren von Themen in Confluent Cloud beheben