MirrorMaker 2.0 ソースコネクタを作成する

MirrorMaker 2.0 ソースコネクタを使用すると、Kafka クラスタ(ソース)から別の Kafka クラスタ(ターゲット)にトピックとデータを複製できます。

このコネクタの一般的なユースケースは次のとおりです。

  • データの移行。Kafka ワークロードを新しい Managed Service for Apache Kafka クラスタに移行します。

  • 障害復旧。障害が発生した場合にビジネスの継続性を確保するために、バックアップ クラスタを作成します。

  • データ集計。複数の Kafka クラスタのデータを一元化された Managed Service for Apache Kafka クラスタに統合して、分析を実行する。

このコネクタは、Kafka クラスタ間で基本的なデータ レプリケーションを実行します。より堅牢な障害復旧を実現するには、MirrorMaker 2.0 Source コネクタと組み合わせて次のコネクタを使用します。

  • MirrorMaker 2.0 Checkpoint コネクタ。コンシューマー オフセットを複製して、コンシューマーがデータを失うことなくターゲット クラスタにフェイルオーバーできるようにします。

  • MirrorMaker 2.0 Heartbeat コネクタ。定期的なハートビート メッセージを生成します。これにより、接続性とレプリケーション ラグをモニタリングできます。

MirrorMaker 2.0 のクラスタロールについて

MirrorMaker 2.0 コネクタは、ソース Kafka クラスタから読み取り、ターゲット Kafka クラスタに書き込みます。Managed Service for Apache Kafka では、Connect クラスタのプライマリ クラスタをターゲット クラスタにする必要があります。この構成により、書き込みオペレーションのレイテンシが最小限に抑えられます。ソースクラスタは、別の Managed Service for Apache Kafka クラスタ、または外部またはセルフマネージドの Kafka クラスタにできます。

Managed Service for Apache Kafka クラスタから外部クラスタまたはセルフマネージド クラスタにデータを複製する場合は、他のクラスタと同じロケーションまたはリージョンで Kafka Connect を実行し、MirrorMaker 2.0 を使用して Managed Service for Apache Kafka からデータを取り込むことをおすすめします。

コネクタのすべてのプロパティを正しく構成する必要があります。これには、セカンダリ クラスタを対象とするプロデューサー認証プロパティも含まれます。潜在的な問題の詳細については、MirrorMaker 2.0 クライアント構成を改善するをご覧ください。

必要なロールと権限

コネクタの作成に必要な権限を取得するには、プロジェクトに対するマネージド Kafka コネクタ編集者(roles/managedkafka.connectorEditor)IAM ロールを付与するよう管理者に依頼してください。ロールの付与については、プロジェクト、フォルダ、組織に対するアクセス権の管理をご覧ください。

この事前定義ロールには、コネクタの作成に必要な権限が含まれています。必要とされる正確な権限については、「必要な権限」セクションを開いてご確認ください。

必要な権限

コネクタを作成するには、次の権限が必要です。

  • コネクタを作成します。 managedkafka.connectors.create

カスタムロールや他の事前定義ロールを使用して、これらの権限を取得することもできます。

ネットワークを構成する

このセクションでは、MirrorMaker 2.0 がセカンダリ Kafka クラスタに接続するためのネットワーク要件について説明します。一般的な要件は次のとおりです。

  • 接続。Connect クラスタ ワーカーは、セカンダリ Kafka クラスタに接続できる必要があります。

  • DNS の解決。セカンダリ クラスタの DNS ドメインを Connect クラスタの解決可能な DNS ドメインに追加する必要があります。また、DNS ドメインは、Connect クラスタのサブネットから解決可能である必要があります。たとえば、Cloud DNS ゾーンを作成します。

  • ファイアウォール ルール。ファイアウォール ルールでは、Connect クラスタ ワーカーがソース Kafka クラスタとターゲット Kafka クラスタの両方にアクセスできるようにする必要があります。

詳細の多くは、セカンダリ Kafka クラスタがホストされる方法と場所(Managed Service for Apache Kafka クラスタ、 Google Cloudのセルフマネージド クラスタ、外部クラスタ)によって異なります。

  • Managed Service for Apache Kafka クラスタ

    • セカンダリ クラスタが別の VPC ネットワークにある場合は、Connect クラスタの VPC ネットワークのサブネットをセカンダリ クラスタの接続済みサブネットに追加します。詳細については、ネットワーク構成をご覧ください。
  • Google Cloudのセルフマネージド Kafka クラスタ

  • 外部 Kafka クラスタ

    • 外部クラスタに接続するオプションは次のとおりです。

      • Cloud VPN: 帯域幅が狭い場合に適した費用対効果の高いソリューション。公共のインターネット上に暗号化されたトンネルを構築します。

      • Cloud Interconnect: オンプレミス ネットワークと Google Cloudの間に専用の高帯域幅接続を提供します。物理的な直接接続には Dedicated Interconnect、サービス提供者を介した接続には Partner Interconnect を選択できます。

    • Connect ワーカーがインターネットにアクセスできるように Cloud NAT を構成します。

    • Connect クラスタの VPC ネットワークに Cloud DNS 転送ゾーンを作成して、外部クラスタのブートストラップ アドレスとブローカー エンドポイントの DNS クエリを解決します。

認証を構成する

ソースまたはターゲットの Kafka クラスタが Managed Service for Apache Kafka クラスタの場合、コネクタは OAuthBearer 認証を使用するように自動的に構成されます。追加の構成を設定する必要はありません。

セルフマネージドまたは外部の Kafka クラスタの場合は、認証と TLS 暗号化を構成する必要があります。構成は、Kafka クラスタがサポートする認証メカニズムによって異なります。詳細については、Apache Kafka ドキュメントの MirrorMaker の共通構成をご覧ください。

クラスタが OAuthBearer 認証をサポートしている場合は、次の設定を使用します。

source.cluster.security.protocol=SASL_SSL
source.cluster.sasl.mechanism=OAUTHBEARER
source.cluster.sasl.login.callback.handler.class=com.google.cloud.hosted.kafka.auth.GcpLoginCallbackHandler
source.cluster.sasl.jaas.config=org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule required;

次のセクションで説明するように、必要な認証情報を Secret Manager に保存します。

認証情報に Secret Manager を使用する

セルフマネージドまたは外部の Kafka クラスタに接続する場合は、Secret Manager を使用して、認証に必要な機密性の高い構成値を保存します。この情報には、クラスタでの認証の構成方法に応じて、パスワード、キーストア ファイル、トラストストア ファイルが含まれる場合があります。

Secret Manager のシークレットを Connect クラスタに関連付ける方法については、Secret Manager のリソースをご覧ください。

コネクタ構成で、次のようにシークレットを参照します。

  • ファイルパスには /var/secrets/PROJECT_NAME-SECRET_NAME-SECRET_VERSION の形式を使用します。例: ssl.truststore.location=/var/secrets/project1-truststore-1

  • パスワードには ${directory:/var/secrets:PROJECT_NAME-SECRET_NAME-SECRET_VERSION} の形式を使用します。password=${directory:/var/secrets:project1-database_password-3}

次のように置き換えます。

  • PROJECT_NAME: Google Cloud プロジェクトの名前。
  • SECRET_NAME: Secret の名前。
  • SECRET_VERSION: シークレットのバージョン。

MirrorMaker ソースコネクタの仕組み

MirrorMaker ソースコネクタは、ソースクラスタ内の 1 つ以上の Kafka トピックからデータを pull し、そのデータと ACL をターゲット クラスタ内のトピックに複製します。

MirrorMaker Source コネクタがデータを複製する方法の詳細は次のとおりです。

  • コネクタは、ソースクラスタ内の指定された Kafka トピックからメッセージを消費します。topics 構成プロパティを使用して、複製するトピックを指定します。このプロパティには、カンマ区切りのトピック名または単一の Java スタイルの正規表現を指定できます。たとえば、topic-a,topic-b や my-prefix-.* です。

  • コネクタは、topics.exclude プロパティを使用して指定した特定のトピックの複製をスキップすることもできます。除外は包含をオーバーライドします。

  • コネクタは、消費されたメッセージをターゲット クラスタに書き込みます。

  • コネクタには、source.cluster.bootstrap.servers や target.cluster.bootstrap.servers などのソースクラスタとターゲット クラスタの接続の詳細が必要です。

  • コネクタには、source.cluster.alias と target.cluster.alias で指定されたソースクラスタとターゲット クラスタのエイリアスも必要です。デフォルトでは、複製されたトピックの名前は、ソース エイリアスを使用して自動的に変更されます。たとえば、エイリアス primary を持つソースの orders という名前のトピックは、ターゲットで primary.orders になります。ターゲット クラスタで元のトピック名を接頭辞なしで保持するには、replication.policy.class を org.apache.kafka.connect.mirror.IdentityReplicationPolicy に設定します。

  • レプリケートされたトピックに関連付けられた ACL も、ソースクラスタからターゲット クラスタに同期されます。これは、sync.topic.acls.enabled プロパティを使用して無効にできます。

  • クラスタで必要な場合は、移行元クラスタと移行先クラスタの両方に接続するための認証の詳細を構成に指定する必要があります。security.protocol、sasl.mechanism、sasl.jaas.config などのプロパティを構成する必要があります。ソースには source.cluster.、ターゲットには target.cluster. の接頭辞を付けます。

  • コネクタは内部トピックに依存しています。offset-syncs.topic.replication.factor など、これらに関連するプロパティの構成が必要になる場合があります。

  • コネクタは、Kafka レコード コンバータ key.converter、value.converter、header.converter を使用します。直接レプリケーションの場合、通常はデフォルトで org.apache.kafka.connect.converters.ByteArrayConverter に設定され、変換は行われません(パススルー)。

  • tasks.max プロパティは、コネクタの並列処理のレベルを制御します。tasks.max を増やすとスループットが向上する可能性がありますが、効果的な並列処理は、複製されるソース Kafka トピックのパーティション数によって制限されることがよくあります。

MirrorMaker 2.0 コネクタのプロパティ

MirrorMaker 2.0 コネクタを作成または更新するときに、次のプロパティを指定します。

コネクタ名

コネクタの名前または ID。リソースの命名方法のガイドラインについては、Managed Service for Apache Kafka リソースの命名ガイドラインをご覧ください。名前は変更できません。

コネクタの種類

コネクタタイプは次のいずれかである必要があります。

ソースクラスタ

MirrorMaker 2.0 コネクタが読み取るソース Kafka クラスタ。

  • Managed Service for Apache Kafka クラスタ: プルダウン メニューからクラスタを選択します。

  • セルフマネージドまたは外部の Kafka クラスタ: ブートストラップ アドレスを hostname:port_number の形式で入力します。例: kafka-test:9092。

トピック名または正規表現

複製するトピック。個々の名前(topic1、topic2)を指定するか、正規表現(topic.*)を使用します。このプロパティは、MirrorMaker 2.0 Source コネクタに必要です。デフォルト値は .* です。

コンシューマー グループ名または正規表現

複製するコンシューマー グループ。個々の名前(group1、group2)を指定するか、正規表現(group.*)を使用します。このプロパティは、MirrorMaker 2.0 Checkpoint コネクタに必要です。デフォルト値は .* です。

構成

このセクションでは、MirrorMaker 2.0 コネクタの追加のコネクタ固有の構成プロパティを指定できます。

Kafka トピックのデータは、Avro、JSON、未加工バイトなど、さまざまな形式にできるため、構成の重要な部分にはコンバータの指定が含まれます。コンバータは、Kafka トピックで使用されている形式から Kafka Connect の標準化された内部形式にデータを変換します。

Kafka Connect でのコンバータの役割、サポートされているコンバータの種類、一般的な構成オプションの詳細については、コンバータをご覧ください。

すべての MirrorMaker 2.0 コネクタに共通する構成には、次のようなものがあります。

  • source.cluster.alias: ソースクラスタのエイリアス。

  • target.cluster.alias: ターゲット クラスタのエイリアス。

  • replication.policy.class: ターゲット クラスタで複製されたトピックに名前を付ける方法のポリシークラス。デフォルト値は org.apache.kafka.connect.mirror.DefaultReplicationPolicy です。これにより、複製されたトピック名の先頭にソースクラスタのエイリアスが追加されます。ソースクラスタのエイリアスが primary の場合、orders という名前のトピックがターゲット クラスタの primary.orders に複製されます。接頭辞のない元のトピック名を保持するには、このプロパティを org.apache.kafka.connect.mirror.IdentityReplicationPolicy に設定します。

データを複製するときに特定のリソースを除外するために使用される構成:

  • topics.exclude: 除外トピック。カンマ区切りのトピック名と正規表現をサポートします。除外は包含よりも優先されます。MirrorMaker 2.0 Source コネクタに使用されます。デフォルト値は mm2.*.internal,.*.replica,__.* です。

  • groups.exclude: グループを除外します。カンマ区切りのグループ ID と正規表現をサポートします。除外は包含よりも優先されます。MirrorMaker 2.0 Checkpoint コネクタに使用されます。デフォルト値は console-consumer-.*,connect-.*,__.* です。

使用可能な構成プロパティは、特定のコネクタによって異なります。サポートされている MirrorMaker 2.0 コネクタのバージョンを確認して、サポートされている構成例を確認します。次のドキュメントを参照してください。

Kafka レコードの変換

Kafka Connect は、キーと値のデフォルトのコンバータとして org.apache.kafka.connect.converters.ByteArrayConverter を使用します。これにより、変換を行わないパススルー オプションが提供されます。

header.converter、key.converter、value.converter を構成して、他のコンバータを使用できます。

タスク数

tasks.max 値は、Kafka Connect が MirrorMaker コネクタの実行に使用する最大タスク数を構成します。コネクタの並列処理のレベルを制御します。タスク数を増やすとスループットが向上する可能性がありますが、Kafka トピック パーティションの数などの要因によって制限されます。

MirrorMaker 2.0 Source コネクタを作成する

MirrorMaker 2.0 ソースコネクタを作成する手順は次のとおりです。

コンソール

  1. Google Cloud コンソールで、[Connect クラスタ] ページに移動します。

    [Connect クラスタ] に移動

  2. コネクタを作成する Connect クラスタをクリックします。

  3. [コネクタを作成] をクリックします。

  4. [コネクタ名] フィールドに、コネクタの名前を入力します。

  5. [コネクタ プラグイン] リストで、[MirrorMaker 2.0 Source] を選択します。

  6. [ソースクラスタ] セクションで、ソースクラスタを指定します。次のオプションのいずれかを選択します。

    • Managed Service for Apache Kafka クラスタ。[Kafka クラスタ] リストで、Managed Service for Apache Kafka クラスタを選択します。

    • セルフマネージドまたは外部の Kafka クラスタ。[クラスタ ブートストラップ サーバー] フィールドに、Kafka クラスタのブートストラップ アドレスを HOSTNAME:PORT_NUMBER の形式で入力します。

  7. [トピック名またはトピックの正規表現] フィールドに、複製するトピックのカンマ区切りのリストを入力します。リストには正規表現を含めることができます。

  8. 省略可: [構成フィールド] で、構成プロパティを追加するか、デフォルトのプロパティを編集します。詳細については、コネクタを構成するをご覧ください。

  9. 省略可: [タスクの再起動ポリシー] で、コネクタのタスクの再起動ポリシーを選択します。詳細については、タスクの再起動ポリシーをご覧ください。

  10. [作成] をクリックします。

gcloud

gcloud managed-kafka connectors create コマンドを実行します。

gcloud managed-kafka connectors create CONNECTOR_ID \
    --connect-cluster=CONNECT_CLUSTER_ID \
    --location=LOCATION \
    --config-file=CONFIG_FILE

次のように置き換えます。

  • CONNECTOR_ID: コネクタの ID または名前。
  • CONNECT_CLUSTER_ID: コネクタが作成される Connect クラスタの ID。
  • LOCATION: Connect クラスタのロケーション。
  • CONFIG_FILE: ローカルの YAML または JSON 構成ファイルのパス。

MirrorMaker 2.0 ソースコネクタの構成ファイルの例を次に示します。

connector.class: "org.apache.kafka.connect.mirror.MirrorSourceConnector"
source.cluster.alias: "source"
target.cluster.alias: "target"
topics: "TOPIC_LIST"
source.cluster.bootstrap.servers: "SOURCE_CLUSTER_BOOTSTRAP_ADDRESS"
target.cluster.bootstrap.servers: "TARGET_CLUSTER_BOOTSTRAP_ADDRESS"

次のように置き換えます。

  • TOPIC_LIST: 複製する Kafka トピックのカンマ区切りのリスト。リストには正規表現を含めることができます。

  • SOURCE_CLUSTER_BOOTSTRAP_ADDRESS: ソース Kafka クラスタのブートストラップ アドレス。

  • TARGET_CLUSTER_BOOTSTRAP_ADDRESS: ターゲット Kafka クラスタのブートストラップ アドレス。

ソースクラスタがセルフマネージド Kafka クラスタの場合は、認証を構成するために追加のプロパティを含める必要があります。詳細については、認証を構成するをご覧ください。

Terraform

コネクタの作成には Terraform リソースを使用します。

# A single MirrorMaker 2 Source Connector to replicate from one source to one target.
resource "google_managed_kafka_connector" "default" {
  project         = data.google_project.default.project_id
  connector_id    = "mm2-source-to-target-connector-id"
  connect_cluster = google_managed_kafka_connect_cluster.default.connect_cluster_id
  location        = "us-central1"

  configs = {
    "connector.class"      = "org.apache.kafka.connect.mirror.MirrorSourceConnector"
    "name"                 = "mm2-source-to-target-connector-id"
    "tasks.max"            = "3"
    "source.cluster.alias" = "source"
    "target.cluster.alias" = "target"
    "topics"               = ".*" # Replicate all topics from the source
    # The value for bootstrap.servers is a comma-separated list of hostname:port pairs
    # for one or more Kafka brokers in the source/target cluster.
    "source.cluster.bootstrap.servers" = "source_cluster_dns"
    "target.cluster.bootstrap.servers" = "target_cluster_dns"
    # You can define an exclusion policy for topics as follows:
    # To exclude internal MirrorMaker 2 topics, internal topics and replicated topics,.
    "topics.exclude" = "mm2.*\\.internal,.*\\.replica,__.*"
  }

  provider = google-beta
}

Terraform 構成を適用または削除する方法については、基本的な Terraform コマンドをご覧ください。

Go

このサンプルを試す前に、クライアント ライブラリをインストールするの Go の設定手順を実施してください。詳細については、Managed Service for Apache Kafka Go API リファレンス ドキュメントをご覧ください。

Managed Service for Apache Kafka に対する認証を行うには、アプリケーションのデフォルト認証情報(ADC)を設定します。詳細については、ローカル開発環境の ADC の設定をご覧ください。

import (
	"context"
	"fmt"
	"io"

	managedkafka "cloud.google.com/go/managedkafka/apiv1"
	"cloud.google.com/go/managedkafka/apiv1/managedkafkapb"
	"google.golang.org/api/option"
)

// createMirrorMaker2SourceConnector creates a MirrorMaker 2.0 Source connector.
func createMirrorMaker2SourceConnector(w io.Writer, projectID, region, connectClusterID, connectorID, sourceBootstrapServers, targetBootstrapServers, tasksMax, sourceClusterAlias, targetClusterAlias, topics, topicsExclude string, opts ...option.ClientOption) error {
	// TODO(developer): Update with your config values. Here is a sample configuration:
	// projectID := "my-project-id"
	// region := "us-central1"
	// connectClusterID := "my-connect-cluster"
	// connectorID := "mm2-source-to-target-connector-id"
	// sourceBootstrapServers := "source_cluster_dns"
	// targetBootstrapServers := "target_cluster_dns"
	// tasksMax := "3"
	// sourceClusterAlias := "source"
	// targetClusterAlias := "target"
	// topics := ".*"
	// topicsExclude := "mm2.*.internal,.*.replica,__.*"
	ctx := context.Background()
	client, err := managedkafka.NewManagedKafkaConnectClient(ctx, opts...)
	if err != nil {
		return fmt.Errorf("managedkafka.NewManagedKafkaConnectClient got err: %w", err)
	}
	defer client.Close()

	parent := fmt.Sprintf("projects/%s/locations/%s/connectClusters/%s", projectID, region, connectClusterID)

	config := map[string]string{
		"connector.class":      "org.apache.kafka.connect.mirror.MirrorSourceConnector",
		"name":                 connectorID,
		"tasks.max":            tasksMax,
		"source.cluster.alias": sourceClusterAlias,
		"target.cluster.alias": targetClusterAlias, // This is usually the primary cluster.
		// Replicate all topics from the source
		"topics": topics,
		// The value for bootstrap.servers is a hostname:port pair for the Kafka broker in
		// the source/target cluster.
		// For example: "kafka-broker:9092"
		"source.cluster.bootstrap.servers": sourceBootstrapServers,
		"target.cluster.bootstrap.servers": targetBootstrapServers,
		// You can define an exclusion policy for topics as follows:
		// To exclude internal MirrorMaker 2 topics, internal topics and replicated topics.
		// topicsExclude := "mm2.*.internal,.*.replica,__.*"
		"topics.exclude": topicsExclude,
	}

	connector := &managedkafkapb.Connector{
		Name:    fmt.Sprintf("%s/connectors/%s", parent, connectorID),
		Configs: config,
	}

	req := &managedkafkapb.CreateConnectorRequest{
		Parent:      parent,
		ConnectorId: connectorID,
		Connector:   connector,
	}

	resp, err := client.CreateConnector(ctx, req)
	if err != nil {
		return fmt.Errorf("client.CreateConnector got err: %w", err)
	}
	fmt.Fprintf(w, "Created MirrorMaker 2.0 Source connector: %s\n", resp.Name)
	return nil
}

Java

このサンプルを試す前に、クライアント ライブラリをインストールするの Java の設定手順を行ってください。詳細については、Managed Service for Apache Kafka Java API リファレンス ドキュメントをご覧ください。

Managed Service for Apache Kafka に対する認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の ADC の設定をご覧ください。


import com.google.api.gax.rpc.ApiException;
import com.google.cloud.managedkafka.v1.ConnectClusterName;
import com.google.cloud.managedkafka.v1.Connector;
import com.google.cloud.managedkafka.v1.ConnectorName;
import com.google.cloud.managedkafka.v1.CreateConnectorRequest;
import com.google.cloud.managedkafka.v1.ManagedKafkaConnectClient;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class CreateMirrorMaker2SourceConnector {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the example.
    String projectId = "my-project-id";
    String region = "my-region"; // e.g. us-east1
    String maxTasks = "3";
    String connectClusterId = "my-connect-cluster";
    String connectorId = "my-mirrormaker2-connector";
    String sourceClusterBootstrapServers = "my-source-cluster:9092";
    String targetClusterBootstrapServers = "my-target-cluster:9092";
    String sourceClusterAlias = "source";
    String targetClusterAlias = "target"; // This is usually the primary cluster.
    String connectorClass = "org.apache.kafka.connect.mirror.MirrorSourceConnector";
    String topics = ".*";
    // You can define an exclusion policy for topics as follows:
    // To exclude internal MirrorMaker 2 topics, internal topics and replicated topics.
    String topicsExclude = "mm2.*.internal,.*.replica,__.*";
    createMirrorMaker2SourceConnector(
        projectId,
        region,
        maxTasks,
        connectClusterId,
        connectorId,
        sourceClusterBootstrapServers,
        targetClusterBootstrapServers,
        sourceClusterAlias,
        targetClusterAlias,
        connectorClass,
        topics,
        topicsExclude);
  }

  public static void createMirrorMaker2SourceConnector(
      String projectId,
      String region,
      String maxTasks,
      String connectClusterId,
      String connectorId,
      String sourceClusterBootstrapServers,
      String targetClusterBootstrapServers,
      String sourceClusterAlias,
      String targetClusterAlias,
      String connectorClass,
      String topics,
      String topicsExclude)
      throws Exception {

    // Build the connector configuration
    Map<String, String> configMap = new HashMap<>();
    configMap.put("tasks.max", maxTasks);
    configMap.put("connector.class", connectorClass);
    configMap.put("name", connectorId);
    configMap.put("source.cluster.alias", sourceClusterAlias);
    configMap.put("target.cluster.alias", targetClusterAlias);
    configMap.put("topics", topics);
    configMap.put("topics.exclude", topicsExclude);
    configMap.put("source.cluster.bootstrap.servers", sourceClusterBootstrapServers);
    configMap.put("target.cluster.bootstrap.servers", targetClusterBootstrapServers);

    Connector connector = Connector.newBuilder()
        .setName(
            ConnectorName.of(projectId, region, connectClusterId, connectorId).toString())
        .putAllConfigs(configMap)
        .build();

    try (ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.create()) {
      CreateConnectorRequest request = CreateConnectorRequest.newBuilder()
          .setParent(ConnectClusterName.of(projectId, region, connectClusterId).toString())
          .setConnectorId(connectorId)
          .setConnector(connector)
          .build();

      // This operation is being handled synchronously.
      Connector response = managedKafkaConnectClient.createConnector(request);
      System.out.printf("Created MirrorMaker2 Source connector: %s\n", response.getName());
    } catch (IOException | ApiException e) {
      System.err.printf("managedKafkaConnectClient.createConnector got err: %s\n", e.getMessage());
    }
  }
}

Python

このサンプルを試す前に、クライアント ライブラリをインストールするの Python の設定手順を実施してください。詳細については、Managed Service for Apache Kafka Python API リファレンス ドキュメントをご覧ください。

Managed Service for Apache Kafka に対する認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の ADC の設定をご覧ください。

from google.api_core.exceptions import GoogleAPICallError
from google.cloud.managedkafka_v1.services.managed_kafka_connect import (
    ManagedKafkaConnectClient,
)
from google.cloud.managedkafka_v1.types import Connector, CreateConnectorRequest

connect_client = ManagedKafkaConnectClient()
parent = connect_client.connect_cluster_path(project_id, region, connect_cluster_id)

configs = {
    "connector.class": "org.apache.kafka.connect.mirror.MirrorSourceConnector",
    "name": connector_id,
    "tasks.max": tasks_max,
    "source.cluster.alias": source_cluster_alias,
    "target.cluster.alias": target_cluster_alias,  # This is usually the primary cluster.
    # Replicate all topics from the source
    "topics": topics,
    # The value for bootstrap.servers is a hostname:port pair for the Kafka broker in
    # the source/target cluster.
    # For example: "kafka-broker:9092"
    "source.cluster.bootstrap.servers": source_bootstrap_servers,
    "target.cluster.bootstrap.servers": target_bootstrap_servers,
    # You can define an exclusion policy for topics as follows:
    # To exclude internal MirrorMaker 2 topics, internal topics and replicated topics.
    "topics.exclude": topics_exclude,
}

connector = Connector()
# The name of the connector.
connector.name = connector_id
connector.configs = configs

request = CreateConnectorRequest(
    parent=parent,
    connector_id=connector_id,
    connector=connector,
)

try:
    operation = connect_client.create_connector(request=request)
    print(f"Waiting for operation {operation.operation.name} to complete...")
    response = operation.result()
    print("Created Connector:", response)
except GoogleAPICallError as e:
    print(f"The operation failed with error: {e}")

次のステップ

Apache Kafka® は、Apache Software Foundation または米国その他の諸国における関連会社の商標です。