Crea un conector de fuente de MirrorMaker 2.0

Un conector de origen de MirrorMaker 2.0 te permite replicar temas y datos de un clúster de Kafka (el origen) a otro clúster de Kafka (el destino).

Entre los casos de uso típicos de este conector, se incluyen los siguientes:

  • Migración de datos. Mueve tu carga de trabajo de Kafka a un nuevo clúster de Managed Service para Apache Kafka.

  • Recuperación ante desastres Crea un clúster de copia de seguridad para garantizar la continuidad empresarial en caso de fallas.

  • Agregación de datos. Consolida datos de varios clústeres de Kafka en un clúster central de Managed Service para Apache Kafka para realizar análisis.

Este conector realiza una replicación de datos básica entre clústeres de Kafka. Para ayudar a garantizar una recuperación ante desastres más sólida, usa los siguientes conectores junto con el conector de origen de MirrorMaker 2.0:

Comprende los roles de clúster en MirrorMaker 2.0

Un conector de MirrorMaker 2.0 lee de un clúster de Kafka de origen y escribe en un clúster de Kafka de destino. En Managed Service para Apache Kafka, el clúster principal del clúster de Connect debe ser el clúster de destino. Esta configuración minimiza la latencia de las operaciones de escritura. El clúster de origen puede ser otro clúster de Managed Service para Apache Kafka o un clúster de Kafka externo o autoadministrado.

Si quieres replicar datos de un clúster de Managed Service para Apache Kafka en un clúster externo o autoadministrado, te recomendamos que ejecutes Kafka Connect en la misma ubicación o región que el otro clúster y que uses MirrorMaker 2.0 para transferir los datos de Managed Service para Apache Kafka.

Debes configurar correctamente todas las propiedades del conector. También incluyen propiedades de autenticación del productor que se dirigen al clúster secundario. Para obtener detalles sobre los posibles problemas, consulta Mejora la configuración del cliente de MirrorMaker 2.0.

Roles y permisos requeridos

Para obtener los permisos que necesitas para crear un conector, pídele a tu administrador que te otorgue el rol de IAM de editor de conectores de Kafka administrados (roles/managedkafka.connectorEditor) en tu proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear un conector. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear un conector:

  • Crea un conector: managedkafka.connectors.create

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Configura las redes

En esta sección, se describen los requisitos de red para que MirrorMaker 2.0 se conecte al clúster de Kafka secundario. Estos son los requisitos generales:

  • Conectividad. Los trabajadores del clúster de Connect deben poder conectarse al clúster secundario de Kafka.

  • Resolución de DNS. Debes agregar el dominio de DNS del clúster secundario a los dominios de DNS que se pueden resolver del clúster de Connect. Además, el dominio de DNS debe poder resolverse desde la subred del clúster de Connect, por ejemplo, creando una zona de Cloud DNS.

  • Reglas de firewall Las reglas de firewall deben permitir que los trabajadores del clúster de Connect lleguen a los clústeres de Kafka de origen y de destino.

Muchos de los detalles dependen de cómo y dónde se aloja el clúster de Kafka secundario, ya sea un clúster de Managed Service para Apache Kafka, un clúster autoadministrado en Google Cloudo un clúster externo.

  • Clúster de Managed Service para Apache Kafka

    • Si el clúster secundario está en una red de VPC diferente, agrega una subred de la red de VPC del clúster de Connect a las subredes conectadas del clúster secundario. Para obtener más información, consulta Configuración de red.
  • Clúster de Kafka autoadministrado en Google Cloud

  • Clúster de Kafka externo

    • Estas son algunas de las opciones para conectarse a un clúster externo:

      • Cloud VPN: Es una solución rentable adecuada para un ancho de banda más bajo. Crea un túnel encriptado a través del Internet público.

      • Cloud Interconnect: Proporciona una conexión dedicada de gran ancho de banda entre tu red local y Google Cloud. Puedes elegir entre la interconexión dedicada para una conexión física directa o la interconexión de socio para conectarte a través de un proveedor de servicios.

    • Configura Cloud NAT para permitir que los trabajadores de Connect accedan a Internet.

    • Crea una zona de reenvío de Cloud DNS en la red de VPC del clúster de Connect para resolver las consultas de DNS de la dirección de arranque y los extremos de agentes de tu clúster externo.

Configura la autenticación

Si el clúster de Kafka de origen o de destino es un clúster de Managed Service para Apache Kafka, el conector se configura automáticamente para usar la autenticación OAuthBearer. No necesitas establecer ningún parámetro de configuración adicional.

Para un clúster de Kafka autoadministrado o externo, debes configurar la autenticación y la encriptación TLS. Los parámetros de configuración dependen del mecanismo de autenticación que admite el clúster de Kafka. Para obtener más información, consulta Configuraciones comunes de MirrorMaker en la documentación de Apache Kafka.

Si el clúster admite la autenticación de OAuthBearer, usa la siguiente configuración:

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;

Almacena las credenciales requeridas en Secret Manager, como se describe en la siguiente sección.

Usa Secret Manager para las credenciales

Cuando te conectes a clústeres de Kafka autoadministrados o externos, usa Secret Manager para almacenar los valores de configuración sensibles necesarios para la autenticación. Esta información puede incluir contraseñas, archivos de almacén de claves y archivos de almacén de confianza, según cómo se configure la autenticación en el clúster.

Para obtener más información sobre cómo asociar secretos de Secret Manager con un clúster de Connect, consulta Recursos de Secret Manager.

En la configuración del conector, haz referencia a los Secrets de la siguiente manera:

  • Para las rutas de acceso de archivos, usa el formato /var/secrets/PROJECT_NAME-SECRET_NAME-SECRET_VERSION. Ejemplo: ssl.truststore.location=/var/secrets/project1-truststore-1.

  • Para las contraseñas, usa el formato ${directory:/var/secrets:PROJECT_NAME-SECRET_NAME-SECRET_VERSION}. Ejemplo: password=${directory:/var/secrets:project1-database_password-3}.

Reemplaza lo siguiente:

  • PROJECT_NAME: Es el nombre del proyecto de Google Cloud .
  • SECRET_NAME: Es el nombre del Secret.
  • SECRET_VERSION: Es la versión del Secret.

Cómo funciona un conector de origen de MirrorMaker

Un conector de origen de MirrorMaker extrae datos de uno o más temas de Kafka en un clúster de origen y replica esos datos, junto con las ACL, en temas de un clúster de destino.

A continuación, se incluye un desglose detallado de cómo el conector de origen de MirrorMaker replica los datos:

  • El conector consume mensajes de temas de Kafka especificados dentro del clúster de origen. Especifica los temas que se replicarán con la propiedad de configuración topics, que acepta nombres de temas separados por comas o una sola expresión regular de estilo Java. Por ejemplo, topic-a,topic-b o my-prefix-.*.

  • El conector también puede omitir la replicación de temas específicos que indiques con la propiedad topics.exclude; las exclusiones anulan las inclusiones.

  • El conector escribe los mensajes consumidos en el clúster de destino.

  • El conector requiere los detalles de conexión del clúster de origen y de destino, como source.cluster.bootstrap.servers y target.cluster.bootstrap.servers.

  • El conector también requiere alias para los clústeres de origen y de destino, como lo especifican source.cluster.alias y target.cluster.alias. De forma predeterminada, se cambia el nombre de los temas replicados automáticamente con el alias de origen. Por ejemplo, un tema llamado orders de una fuente con el alias primary se convierte en primary.orders en el destino. Para mantener los nombres de los temas originales en el clúster de destino sin un prefijo, establece replication.policy.class en org.apache.kafka.connect.mirror.IdentityReplicationPolicy.

  • Las ACL asociadas con los temas replicados también se sincronizan del clúster de origen al de destino. Esto se puede inhabilitar con la propiedad sync.topic.acls.enabled.

  • Los detalles de autenticación para conectarse a los clústeres de origen y de destino se deben proporcionar en la configuración si los clústeres lo requieren. Debes configurar propiedades como security.protocol, sasl.mechanism y sasl.jaas.config, con el prefijo source.cluster. para el origen y target.cluster. para el destino.

  • El conector se basa en temas internos. Es posible que debas configurar propiedades relacionadas con estas, como offset-syncs.topic.replication.factor.

  • El conector usa los convertidores de registros de Kafka key.converter, value.converter y header.converter. Para la replicación directa, estos suelen tener como valor predeterminado org.apache.kafka.connect.converters.ByteArrayConverter, que no realiza ninguna conversión (paso directo).

  • La propiedad tasks.max controla el nivel de paralelismo del conector. Aumentar tasks.max puede mejorar la capacidad de procesamiento, pero el paralelismo efectivo suele estar limitado por la cantidad de particiones en los temas de Kafka de origen que se replican.

Propiedades de un conector de MirrorMaker 2.0

Cuando crees o actualices un conector de MirrorMaker 2.0, especifica estas propiedades:

Nombre del conector

Es el nombre o el ID del conector. Para obtener orientación sobre cómo asignar un nombre al recurso, consulta Lineamientos para asignar un nombre a un recurso de Managed Service para Apache Kafka. El nombre es inmutable.

Tipo de conector

El tipo de conector debe ser uno de los siguientes:

Clúster de origen

Es el clúster de Kafka de origen desde el que lee el conector de MirrorMaker 2.0.

  • Clúster de Managed Service para Apache Kafka: Selecciona un clúster del menú desplegable.

  • Clúster de Kafka autoadministrado o externo: Ingresa la dirección de arranque en el formato hostname:port_number. Por ejemplo: kafka-test:9092.

Nombres de temas o expresiones regulares

Son los temas que se replicarán. Especifica nombres individuales (topic1, topic2) o usa una expresión regular (topic.*). Esta propiedad es obligatoria para el conector de origen de MirrorMaker 2.0. El valor predeterminado es .*.

Nombres de grupos de consumidores o expresiones regulares

Son los grupos de consumidores que se replicarán. Especifica nombres individuales (group1, group2) o usa una expresión regular (group.*). Esta propiedad es obligatoria para el conector de punto de control de MirrorMaker 2.0. El valor predeterminado es .*.

Configuración

En esta sección, puedes especificar propiedades de configuración adicionales y específicas del conector para el conector de MirrorMaker 2.0.

Dado que los datos de los temas de Kafka pueden estar en varios formatos, como Avro, JSON o bytes sin procesar, una parte clave de la configuración implica especificar convertidores. Los convertidores traducen los datos del formato que se usa en tus temas de Kafka al formato interno estandarizado de Kafka Connect.

Para obtener más información general sobre la función de los convertidores en Kafka Connect, los tipos de convertidores admitidos y las opciones de configuración comunes, consulta Convertidores.

Algunos parámetros de configuración comunes para todos los conectores de MirrorMaker 2.0 son los siguientes:

  • source.cluster.alias: Es el alias del clúster de origen.

  • target.cluster.alias: Es el alias del clúster de destino.

  • replication.policy.class: Es la clase de política para la forma en que se nombran los temas replicados en el clúster de destino. El valor predeterminado es org.apache.kafka.connect.mirror.DefaultReplicationPolicy, que agrega un prefijo a los nombres de los temas replicados con el alias del clúster de origen. Si el alias del clúster de origen es primary, un tema llamado orders se replica en primary.orders en el clúster de destino. Para conservar los nombres de los temas originales sin un prefijo, establece esta propiedad en org.apache.kafka.connect.mirror.IdentityReplicationPolicy.

Son los parámetros de configuración que se usan para excluir recursos específicos cuando se replican datos:

  • topics.exclude: Son los temas excluidos. Admite nombres de temas y regex separados por comas. Las exclusiones tienen prioridad sobre las inclusiones. Se usa para el conector de origen de MirrorMaker 2.0. El valor predeterminado es mm2.*.internal,.*.replica,__.*

  • groups.exclude: Excluye grupos. Admite IDs de grupo y expresiones regulares separados por comas. Las exclusiones tienen prioridad sobre las inclusiones. Se usa para el conector de punto de control de MirrorMaker 2.0. El valor predeterminado es console-consumer-.*,connect-.*,__.*

Las propiedades de configuración disponibles dependen del conector específico. Verifica la versión del conector de MirrorMaker 2.0 compatible para ver qué ejemplos de configuración se admiten. Consulta los siguientes documentos:

Conversión de registros de Kafka

Kafka Connect usa org.apache.kafka.connect.converters.ByteArrayConverter como el convertidor predeterminado para la clave y el valor, lo que proporciona una opción de transferencia que no realiza ninguna conversión.

Puedes configurar header.converter, key.converter y value.converter para usar otros convertidores.

Recuento de tareas

El valor tasks.max configura las tareas máximas que usa Kafka Connect para ejecutar los conectores de MirrorMaker. Controla el nivel de paralelismo de un conector. Aumentar el recuento de tareas puede aumentar la capacidad de procesamiento, pero está limitado por factores como la cantidad de particiones de temas de Kafka.

Crea un conector de fuente de MirrorMaker 2.0

Para crear un conector de origen de MirrorMaker 2.0, sigue estos pasos:

Console

  1. En la consola de Google Cloud , ve a la página Conectar clústeres.

    Ir a Conectar clústeres

  2. Haz clic en el clúster de Connect en el que deseas crear el conector.

  3. Haz clic en Crear conector.

  4. En el campo Nombre del conector, ingresa un nombre para el conector.

  5. En la lista Complemento de conector, selecciona MirrorMaker 2.0 Source.

  6. En la sección Clúster de origen, especifica el clúster de origen. Selecciona una de las siguientes opciones:

    • Clúster de Managed Service para Apache Kafka. En la lista Clúster de Kafka, selecciona un clúster de Managed Service para Apache Kafka.

    • Clúster de Kafka autoadministrado o externo. En el campo Servidor de arranque del clúster, ingresa la dirección de arranque del clúster de Kafka, con el formato HOSTNAME:PORT_NUMBER`.

  7. En el campo Nombres de temas o regex de temas, ingresa una lista separada por comas de los temas que se replicarán. La lista puede incluir expresiones regulares.

  8. Opcional: En el campo Configuraciones, agrega propiedades de configuración o edita las propiedades predeterminadas. Para obtener más información, consulta Configura el conector.

  9. Opcional: En Política de reinicio de tareas, selecciona la política de reinicio de tareas del conector. Para obtener más información, consulta Política de reinicio de tareas.

  10. Haz clic en Crear.

gcloud

Ejecuta el comando gcloud managed-kafka connectors create:

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

Reemplaza lo siguiente:

  • CONNECTOR_ID: Es el ID o el nombre del conector.
  • CONNECT_CLUSTER_ID: Es el ID del clúster de Connect en el que se crea el conector.
  • LOCATION: Es la ubicación del clúster de Connect.
  • CONFIG_FILE: Es la ruta de acceso a un archivo de configuración YAML o JSON local.

A continuación, se muestra un ejemplo de un archivo de configuración para el conector de origen de 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"

Reemplaza lo siguiente:

  • TOPIC_LIST: Es una lista separada por comas de los temas de Kafka que se replicarán. La lista puede incluir expresiones regulares.

  • SOURCE_CLUSTER_BOOTSTRAP_ADDRESS: Es la dirección de arranque del clúster de Kafka de origen.

  • TARGET_CLUSTER_BOOTSTRAP_ADDRESS: Es la dirección de arranque del clúster de Kafka de destino.

Si el clúster de origen es un clúster de Kafka autoadministrado, es posible que debas incluir propiedades adicionales para configurar la autenticación. Para obtener más información, consulta Configura la autenticación.

Terraform

Puedes usar un recurso de Terraform para crear un conector.

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

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go en Instala las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Go de Managed Service para Apache Kafka.

Para autenticarte en Managed Service para Apache Kafka, configura las credenciales predeterminadas de la aplicación (ADC). Para obtener más información, consulta Configura ADC para un entorno de desarrollo local.

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

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en Instala las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de Managed Service para Apache Kafka.

Para autenticarte en Managed Service para Apache Kafka, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura ADC para un entorno de desarrollo local.


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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en Instala las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Python de Managed Service para Apache Kafka.

Para autenticarte en Managed Service para Apache Kafka, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura ADC para un entorno de desarrollo local.

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

Próximos pasos

Apache Kafka® es una marca registrada de The Apache Software Foundation o sus afiliados en Estados Unidos y otros países.