Membuat konektor Sumber MirrorMaker 2.0

Konektor Sumber MirrorMaker 2.0 memungkinkan Anda mereplikasi topik dan data dari satu cluster Kafka (sumber) ke cluster Kafka lain (target).

Kasus penggunaan umum untuk konektor ini meliputi:

  • Migrasi data. Pindahkan workload Kafka Anda ke cluster Managed Service untuk Apache Kafka yang baru.

  • Disaster recovery. Buat cluster cadangan untuk memastikan kelangsungan bisnis jika terjadi kegagalan.

  • Agregasi data. Gabungkan data dari beberapa cluster Kafka ke dalam cluster Managed Service untuk Apache Kafka pusat guna melakukan analisis.

Konektor ini melakukan replikasi data dasar antara cluster Kafka. Untuk membantu memastikan disaster recovery yang lebih andal, gunakan konektor berikut bersama dengan konektor MirrorMaker 2.0 Source:

  • Konektor MirrorMaker 2.0 Checkpoint. Mereplikasi offset konsumen, sehingga konsumen dapat melakukan failover ke cluster target tanpa kehilangan data.

  • Konektor MirrorMaker 2.0 Heartbeat. Membuat pesan heartbeat berkala, yang memungkinkan Anda memantau konektivitas dan jeda replikasi.

Memahami peran cluster di MirrorMaker 2.0

Konektor MirrorMaker 2.0 membaca dari cluster Kafka sumber dan menulis ke cluster Kafka target. Di Managed Service untuk Apache Kafka, cluster utama cluster Connect harus menjadi cluster target. Konfigurasi ini meminimalkan latensi untuk operasi tulis. Cluster sumber dapat berupa cluster Managed Service untuk Apache Kafka lain atau cluster Kafka eksternal atau yang dikelola sendiri.

Jika Anda ingin mereplikasi data dari cluster Managed Service untuk Apache Kafka ke cluster eksternal atau yang dikelola sendiri, sebaiknya jalankan Kafka Connect di lokasi atau region yang sama dengan cluster lainnya, dan gunakan MirrorMaker 2.0 untuk menyerap data dari Managed Service untuk Apache Kafka.

Anda harus mengonfigurasi semua properti untuk konektor dengan benar. Hal ini juga mencakup properti autentikasi produsen yang diarahkan ke cluster sekunder. Untuk mengetahui detail tentang potensi masalah, lihat Meningkatkan konfigurasi klien MirrorMaker 2.0.

Peran dan izin yang diperlukan

Untuk mendapatkan izin yang diperlukan untuk membuat konektor, minta administrator untuk memberi Anda peran IAM Managed Kafka Connector Editor (roles/managedkafka.connectorEditor) di project Anda. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran bawaan ini berisi izin yang diperlukan untuk membuat konektor. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk membuat konektor:

  • Buat konektor: managedkafka.connectors.create

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Mengonfigurasi jaringan

Bagian ini menjelaskan persyaratan jaringan agar MirrorMaker 2.0 dapat terhubung ke cluster Kafka sekunder. Berikut persyaratan umumnya:

  • Konektivitas. Worker cluster Connect harus dapat terhubung ke cluster Kafka sekunder.

  • Resolusi DNS. Anda harus menambahkan domain DNS cluster sekunder ke domain DNS yang dapat di-resolve cluster Connect. Selain itu, domain DNS harus dapat di-resolve dari subnet cluster Connect, misalnya dengan membuat zona Cloud DNS.

  • Aturan firewall. Aturan firewall harus mengizinkan worker cluster Connect untuk menjangkau cluster Kafka sumber dan target.

Banyak detail bergantung pada cara dan tempat cluster Kafka sekunder dihosting, apakah itu cluster Managed Service untuk Apache Kafka, cluster yang dikelola mandiri di Google Cloud, atau cluster eksternal.

  • Cluster Managed Service untuk Apache Kafka

    • Jika cluster sekunder berada di jaringan VPC yang berbeda, tambahkan subnet dari jaringan VPC cluster Connect ke subnet yang terhubung ke cluster sekunder. Untuk mengetahui informasi selengkapnya, lihat Konfigurasi jaringan.
  • Cluster Kafka yang dikelola sendiri di Google Cloud

  • Cluster Kafka eksternal

    • Opsi untuk terhubung ke cluster eksternal meliputi:

      • Cloud VPN: Solusi hemat biaya yang cocok untuk bandwidth yang lebih rendah. Layanan ini membuat tunnel terenkripsi melalui internet publik.

      • Cloud Interconnect: Menyediakan koneksi khusus dengan bandwidth tinggi antara jaringan lokal Anda dan Google Cloud. Anda dapat memilih antara Dedicated Interconnect untuk koneksi fisik langsung atau Partner Interconnect untuk terhubung melalui penyedia layanan.

    • Konfigurasikan Cloud NAT agar worker Connect dapat mengakses internet.

    • Buat zona penerusan Cloud DNS di jaringan VPC cluster Connect untuk me-resolve kueri DNS untuk alamat bootstrap dan endpoint broker cluster eksternal Anda.

Mengonfigurasi autentikasi

Jika cluster Kafka sumber atau target adalah cluster Managed Service untuk Apache Kafka, konektor akan otomatis dikonfigurasi untuk menggunakan autentikasi OAuthBearer. Anda tidak perlu menetapkan konfigurasi tambahan.

Untuk cluster Kafka eksternal atau yang dikelola sendiri, Anda harus mengonfigurasi autentikasi dan enkripsi TLS. Konfigurasi bergantung pada mekanisme autentikasi yang didukung cluster Kafka. Untuk mengetahui informasi selengkapnya, lihat Konfigurasi Umum MirrorMaker dalam dokumentasi Apache Kafka.

Jika cluster mendukung autentikasi OAuthBearer, gunakan setelan berikut:

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;

Simpan kredensial yang diperlukan di Secret Manager, seperti yang dijelaskan di bagian berikutnya.

Menggunakan Secret Manager untuk kredensial

Saat terhubung ke cluster Kafka eksternal atau yang dikelola sendiri, gunakan Secret Manager untuk menyimpan nilai konfigurasi sensitif yang diperlukan untuk autentikasi. Informasi ini mungkin mencakup sandi, file key store, dan file trust store, bergantung pada cara autentikasi dikonfigurasi di cluster.

Untuk mengetahui informasi selengkapnya tentang cara mengaitkan secret Secret Manager dengan cluster Connect, lihat resource Secret Manager.

Dalam konfigurasi konektor, referensikan secret sebagai berikut:

  • Untuk jalur file, gunakan format /var/secrets/PROJECT_NAME-SECRET_NAME-SECRET_VERSION. Contoh: ssl.truststore.location=/var/secrets/project1-truststore-1.

  • Untuk sandi, gunakan format ${directory:/var/secrets:PROJECT_NAME-SECRET_NAME-SECRET_VERSION}. Contoh: password=${directory:/var/secrets:project1-database_password-3}.

Ganti kode berikut:

  • PROJECT_NAME: Nama project Google Cloud .
  • SECRET_NAME: Nama secret.
  • SECRET_VERSION: Versi secret.

Cara kerja konektor MirrorMaker Source

Konektor MirrorMaker Source mengambil data dari satu atau beberapa topik Kafka di cluster sumber dan mereplikasi data tersebut, beserta ACL, ke topik di cluster target.

Berikut adalah perincian mendetail tentang cara konektor MirrorMaker Source mereplikasi data:

  • Konektor menggunakan pesan dari topik Kafka yang ditentukan dalam cluster sumber. Tentukan topik yang akan direplikasi menggunakan properti konfigurasi topics, yang menerima nama topik yang dipisahkan koma atau ekspresi reguler bergaya Java tunggal. Contohnya, topic-a,topic-b atau my-prefix-.*.

  • Konektor juga dapat melewati replikasi topik tertentu yang Anda tentukan dengan menggunakan properti topics.exclude; pengecualian menggantikan penyertaan.

  • Konektor menulis pesan yang digunakan ke cluster target.

  • Konektor memerlukan detail koneksi cluster sumber dan target seperti source.cluster.bootstrap.servers dan target.cluster.bootstrap.servers.

  • Konektor juga memerlukan alias untuk cluster sumber dan target seperti yang ditentukan oleh source.cluster.alias dan target.cluster.alias. Secara default, topik yang direplikasi akan otomatis diganti namanya menggunakan alias sumber. Misalnya, topik bernama orders dari sumber dengan alias primary menjadi primary.orders di target. Agar nama topik asli tetap ada di cluster target tanpa awalan, tetapkan replication.policy.class ke org.apache.kafka.connect.mirror.IdentityReplicationPolicy.

  • ACL yang terkait dengan topik yang direplikasi juga disinkronkan dari sumber ke cluster target. Hal ini dapat dinonaktifkan menggunakan properti sync.topic.acls.enabled.

  • Detail autentikasi untuk terhubung ke cluster sumber dan target harus diberikan dalam konfigurasi jika diperlukan oleh cluster. Anda harus mengonfigurasi properti seperti security.protocol, sasl.mechanism, dan sasl.jaas.config, dengan awalan source.cluster. untuk sumber dan target.cluster. untuk target.

  • Konektor mengandalkan topik internal. Anda mungkin perlu mengonfigurasi properti yang terkait dengan hal ini, seperti offset-syncs.topic.replication.factor.

  • Konektor ini menggunakan konverter data Kafka key.converter, value.converter, dan header.converter. Untuk replikasi langsung, setelan ini sering kali ditetapkan secara default ke org.apache.kafka.connect.converters.ByteArrayConverter, yang tidak melakukan konversi (pass-through).

  • Properti tasks.max mengontrol tingkat paralelisme untuk konektor. Meningkatkan tasks.max berpotensi meningkatkan throughput, tetapi paralelisme yang efektif sering kali dibatasi oleh jumlah partisi dalam topik Kafka sumber yang direplikasi.

Properti konektor MirrorMaker 2.0

Saat Anda membuat atau mengupdate konektor MirrorMaker 2.0, tentukan properti berikut:

Nama konektor

Nama atau ID konektor. Untuk panduan tentang cara memberi nama resource, lihat Panduan untuk memberi nama resource Managed Service untuk Apache Kafka. Nama tidak dapat diubah.

Jenis konektor

Jenis konektor harus berupa salah satu dari berikut ini:

Cluster sumber

Cluster Kafka sumber yang dibaca oleh konektor MirrorMaker 2.0.

  • Managed Service untuk Apache Kafka cluster: Pilih cluster dari menu drop-down.

  • Cluster Kafka eksternal atau yang dikelola sendiri: Masukkan alamat bootstrap dalam format hostname:port_number. Misalnya: kafka-test:9092

Nama topik atau ekspresi reguler

Topik yang akan direplikasi. Tentukan nama individual (topic1, topic2) atau gunakan ekspresi reguler (topic.*). Properti ini diperlukan untuk konektor Sumber MirrorMaker 2.0. Nilai defaultnya adalah .*

Nama grup konsumen atau ekspresi reguler

Grup konsumen yang akan direplikasi. Tentukan nama individual (group1, group2) atau gunakan ekspresi reguler (group.*). Properti ini diperlukan untuk konektor Checkpoint MirrorMaker 2.0. Nilai defaultnya adalah .*

Konfigurasi

Bagian ini memungkinkan Anda menentukan properti konfigurasi tambahan khusus konektor untuk konektor MirrorMaker 2.0.

Karena data dalam topik Kafka dapat dalam berbagai format seperti Avro, JSON, atau byte mentah, bagian penting dari konfigurasi melibatkan penentuan konverter. Konverter menerjemahkan data dari format yang digunakan dalam topik Kafka Anda ke format internal Kafka Connect yang terstandardisasi.

Untuk mengetahui informasi umum selengkapnya tentang peran konverter di Kafka Connect, jenis konverter yang didukung, dan opsi konfigurasi umum, lihat Konverter.

Beberapa konfigurasi umum untuk semua konektor MirrorMaker 2.0 meliputi:

  • source.cluster.alias: Alias untuk cluster sumber.

  • target.cluster.alias: Alias untuk cluster target.

  • replication.policy.class: Class kebijakan untuk cara penamaan topik yang direplikasi di cluster target. Nilai defaultnya adalah org.apache.kafka.connect.mirror.DefaultReplicationPolicy, yang memberi awalan nama topik yang direplikasi dengan alias cluster sumber. Jika alias cluster sumber adalah primary, topik bernama orders akan direplikasi ke primary.orders di cluster target. Untuk mempertahankan nama topik asli tanpa awalan, tetapkan properti ini ke org.apache.kafka.connect.mirror.IdentityReplicationPolicy.

Konfigurasi yang digunakan untuk mengecualikan resource tertentu saat mereplikasi data:

  • topics.exclude: Topik yang dikecualikan. Mendukung nama topik dan ekspresi reguler yang dipisahkan koma. Pengecualian lebih diutamakan daripada penyertaan. Digunakan untuk konektor Sumber MirrorMaker 2.0. Nilai defaultnya adalah mm2.*.internal,.*.replica,__.*

  • groups.exclude: Mengecualikan grup. Mendukung ID grup dan ekspresi reguler yang dipisahkan koma. Pengecualian lebih diutamakan daripada penyertaan. Digunakan untuk konektor Checkpoint MirrorMaker 2.0. Nilai defaultnya adalah console-consumer-.*,connect-.*,__.*

Properti konfigurasi yang tersedia bergantung pada konektor tertentu. Periksa versi konektor MirrorMaker 2.0 yang didukung untuk melihat contoh konfigurasi yang didukung. Lihat dokumen berikut:

Konversi data Kafka

Kafka Connect menggunakan org.apache.kafka.connect.converters.ByteArrayConverter sebagai pengonversi default untuk kunci dan nilai, yang menyediakan opsi pass-through yang tidak melakukan konversi.

Anda dapat mengonfigurasi header.converter, key.converter, dan value.converter untuk menggunakan pengonversi lain.

Jumlah tugas

Nilai tasks.max mengonfigurasi tugas maksimum yang digunakan Kafka Connect untuk menjalankan konektor MirrorMaker. Class ini mengontrol tingkat paralelisme untuk konektor. Meningkatkan jumlah tugas dapat meningkatkan throughput, tetapi dibatasi oleh faktor-faktor seperti jumlah partisi topik Kafka.

Membuat konektor Sumber MirrorMaker 2.0

Untuk membuat konektor MirrorMaker 2.0 Source, ikuti langkah-langkah berikut:

Konsol

  1. Di konsol Google Cloud , buka halaman Connect Clusters.

    Buka Connect Clusters

  2. Klik cluster Connect tempat Anda ingin membuat konektor.

  3. Klik Create connector.

  4. Di kolom Connector name, masukkan nama untuk konektor.

  5. Dalam daftar Connector plugin, pilih MirrorMaker 2.0 Source.

  6. Di bagian Source Cluster, tentukan cluster sumber. Pilih salah satu opsi berikut:

    • Cluster Managed Service untuk Apache Kafka. Dalam daftar Kafka cluster, pilih cluster Managed Service untuk Apache Kafka.

    • Cluster Kafka eksternal atau yang dikelola sendiri. Di kolom Cluster bootstrap server, masukkan alamat bootstrap cluster Kafka, dalam format HOSTNAME:PORT_NUMBER`.

  7. Di kolom Topic names or topic regex, masukkan daftar topik yang dipisahkan koma untuk direplikasi. Daftar dapat menyertakan ekspresi reguler.

  8. Opsional: Di kolom Configurations, tambahkan properti konfigurasi atau edit properti default. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi konektor.

  9. Opsional: Di bagian Task restart policy, pilih kebijakan mulai ulang tugas konektor. Untuk mengetahui informasi selengkapnya, lihat Kebijakan memulai ulang tugas.

  10. Klik Create.

gcloud

Jalankan perintah gcloud managed-kafka connectors create:

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

Ganti kode berikut:

  • CONNECTOR_ID: ID atau nama konektor.
  • CONNECT_CLUSTER_ID: ID cluster Connect tempat konektor dibuat.
  • LOCATION: Lokasi cluster Connect.
  • CONFIG_FILE: Jalur ke file konfigurasi YAML atau JSON lokal.

Berikut adalah contoh file konfigurasi untuk konektor Sumber 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"

Ganti kode berikut:

  • TOPIC_LIST: Daftar topik Kafka yang dipisahkan koma untuk direplikasi. Daftar dapat menyertakan ekspresi reguler.

  • SOURCE_CLUSTER_BOOTSTRAP_ADDRESS: Alamat bootstrap cluster Kafka sumber.

  • TARGET_CLUSTER_BOOTSTRAP_ADDRESS: Alamat bootstrap cluster Kafka target.

Jika cluster sumber adalah cluster Kafka yang dikelola sendiri, Anda mungkin perlu menyertakan properti tambahan untuk mengonfigurasi autentikasi. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi autentikasi.

Terraform

Anda dapat menggunakan resource Terraform untuk membuat konektor.

# 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
}

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

Go

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Go di Menginstal library klien. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Go Managed Service untuk Apache Kafka.

Untuk melakukan autentikasi ke Managed Service untuk Apache Kafka, siapkan Kredensial Default Aplikasi (ADC). Untuk mengetahui informasi selengkapnya, lihat Menyiapkan ADC untuk lingkungan pengembangan lokal.

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

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di Menginstal library klien. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Java Managed Service untuk Apache Kafka.

Untuk melakukan autentikasi ke Managed Service untuk Apache Kafka, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan ADC untuk lingkungan pengembangan lokal.


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

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Python di Menginstal library klien. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi Python API Managed Service untuk Apache Kafka.

Untuk melakukan autentikasi ke Managed Service untuk Apache Kafka, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan ADC untuk lingkungan pengembangan lokal.

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

Apa langkah selanjutnya?

Apache Kafka® adalah merek dagang terdaftar dari Apache Software Foundation atau afiliasinya di Amerika Serikat dan/atau negara lainnya.