Migra de Pub/Sub Lite a Google Cloud Managed Service para Apache Kafka

En este documento, se detalla cómo migrar datos de un tema de Pub/Sub Lite a un tema Servicio administrado para Apache Kafka.

Antes de comenzar

  1. Habilita la API de Google Kubernetes Engine.
  2. Identifica un tema de Pub/Sub Lite para migrar. Decide un nombre para en el tema de destino de Google Cloud Managed Service para Apache Kafka. También determina a qué clúster de Servicio administrado para Apache Kafka migrarás.

Flujo de trabajo de migración

Para migrar tus datos, debes completar las siguientes tareas. Los detalles específicos de estas tareas se muestran más adelante en esta página.

  1. Crea una cuenta de servicio de Google Kubernetes Engine.
  2. Crear un clúster de Google Kubernetes Engine
  3. Personaliza una imagen de Docker con la configuración. los detalles de tus temas.

  4. Implementa la imagen de Docker en un clúster de Google Kubernetes Engine.

    Dentro de la imagen, se usan Kafka Connect y el complemento de Pub/Sub Lite para Kafka Connect para suscribirse a una nueva suscripción a Pub/Sub Lite y publicar en el servicio administrado para Apache Kafka.

Crea una cuenta de servicio de Google Kubernetes Engine

En esta sección, se describe cómo crear una cuenta de servicio de IAM que los permisos necesarios para ejecutar un clúster de Google Kubernetes Engine.

  1. En la consola de Google Cloud, crea una nueva cuenta de servicio de IAM con los permisos mínimos necesarios para operar Google Kubernetes Engine.

  2. Otorga los siguientes roles de IAM adicionales a la cuenta de servicio. Estos los roles de IAM facilitan el proceso de migración.

    • Rol de cliente de Kafka administrado (roles/managedkafka.client)
    • Rol de suscriptor de Pub/Sub Lite (roles/pubsublite.subscriber)
    • Rol de visualizador de Pub/Sub Lite (roles/pubsublite.Viewer)
    • Rol de lector de Artifact Registry (roles/artifactregistry.reader)

Cree un clúster de GKE

En esta sección, se describe cómo crear un clúster de GKE que use el servicio cuenta que creaste en el paso anterior.

  1. Ve a la página de Google Kubernetes Engine en la consola de Google Cloud.

    Ir a Google Kubernetes Engine

  2. Haz clic en Crear.

    Aparecerá la página Crea un clúster de Autopilot.

  3. En la pestaña Configuración avanzada, cambia la cuenta de servicio a IAM. de servicio que creaste en el paso anterior.

  4. Opcionalmente, establece otros parámetros de configuración según sea necesario.

  5. Para crear el clúster, haz clic en Crear.

Crea una imagen de Docker de Kafka Connect

En esta sección, se describe cómo crear y personalizar una imagen de Docker de Kafka Connect para tu tema.

  1. Clona el repositorio de GitHub de migración de Pub/Sub Lite.

  2. Para la cuenta de servicio de IAM que creaste antes, genera una clave de cuenta JSON.

    Usa una herramienta Base64 para codificar la clave JSON. Por ejemplo:

    Linux

    base64 -w 0 < my_service_account.json > password.txt

    Mac

    base64 < account_key_json > password.txt

  3. En los archivos de secretos, repositorio de GitHub, actualiza los siguientes archivos con las para vincular el repositorio a tu proyecto de Google Cloud Pub/Sub Lite y Kafka.

    .gcp/gmk_sasl_service_account → sensitive
<service-account-name>@<gcp-project>.iam.gserviceaccount.com

.gcp/gmk_sasl_service_account_key → sensitive
<base64 encoded sasl service account key>

.gcp/kafka_ssl_truststore_location → sensitive
<full path of the ssl truststore jks file location>

.gcp/kafka_ssl_truststore_password → sensitive
<password for the ssl truststore jks>

.gcp/gmk_bootstrap_servers → environment specific
bootstrap.<google-managed-kafka-cluster-name>.<google-managed-kafka-cluster-region name>.managedkafka.<google-managed-cluster-host-project-name>.cloud.goog:9092

.gcp/kafka_connect_group_id → environment specific
<Kafka Connect group id (unique per worker group) for the Kafka connect workers in distributed mode>

.gcp/kafka_config_storage_topic → environment specific
<Kafka topic name used by Kafka Connect for tracking the config>

.gcp/kafka_offset_storage_topic → environment specific
<Kafka topic name used by Kafka Connect for tracking the offsets>

.gcp/kafka_status_storage_topic → environment specific
<Kafka topic name used by Kafka Connect for tracking the status>

.gcp/kafka_sink_topic → environment specific
<target sink Kafka topic name used by Kafka Connect for migrating the data from the Pub/Sub Lite topic>

.gcp/pubsub_lite_gcp_project → environment specific
<Google Cloud project that hosts the Pub/Sub Lite source subscription to be used for migrating the Pub/Sub Lite topic to sink the Kafka topic>

.gcp/pubsub_lite_gcp_location → environment specific
<Google Cloud location for the Pub/Sub Lite source subscription tor migrate the Pub/Sub Lite topic to sink Kafka topic>

.gcp/pubsub_lite_subscription → environment specific
<Pub/Sub Lite source subscription name to be used for migrating the pubsub lite topic to Kafka topic>

  4. Compila la imagen de Docker ejecutando el archivo docker/build-image.sh.

    ./push-image.sh

  5. Actualiza la imagen docker/push-image.sh con el nombre de tu proyecto de Google Cloud.

  6. Ejecuta el archivo docker/push-image.sh para enviar la imagen a Artifact Registry.

    ./push-image.sh

Implementa una carga de trabajo de Kafka Connect

En esta sección, se describe cómo implementar la imagen de Docker de Kafka Connect en un clúster de Google Kubernetes Engine.

  1. Instalación y configuración kubectl con el complemento de autenticación.
  2. Genera el kubeconfig para tu clúster de Google Kubernetes Engine.

  3. Crea una cuenta de servicio de Google Kubernetes Engine y bríndale los permisos correctos para que actúe en nombre de tu cuenta de IAM.

    $KSA_NAME = KUBERNETES_SERVICE_ACCOUNT_NAME
$PROJECT_ID = GOOGLE_CLOUD_PROJECT_ID
$IAM_SA_NAME = IAM_SERVICE_ACCOUNT_NAME

kubectl create serviceaccount $KSA_NAME \
    --namespace=default

gcloud iam service-accounts add-iam-policy-binding \
$IAM_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$PROJECT_ID.svc.id.goog[default/$KSA_NAME]"

kubectl annotate serviceaccount $KSA_NAME \
    --namespace default \
iam.gke.io/gcp-service-account=$IAM_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com

  4. Abre el archivo K8s.yaml en un editor de texto y actualiza los siguientes valores.

    1. Reemplaza <workflow_name> por el nombre de tu flujo de trabajo de Kafka Connect.
    2. Reemplaza <gke_service_account> por el nombre de la cuenta de servicio de Google Kubernetes Engine.

  5. Ejecuta el archivo K8s.yaml.

    kubectl create -f k8s.yaml

    Esto crea una carga de trabajo de Kafka Connect que se ejecuta en tu clúster de Google Kubernetes Engine y, luego, inicia el conector de Pub/Sub Lite para transferir datos de tu tema de Pub/Sub Lite al servicio administrado de Google Cloud para Apache Kafka.

Supervisar un trabajo

Una vez que se esté ejecutando un trabajo, puedes inspeccionarlo si te conectas al extremo REST de Kafka Connect.

  1. En la consola de Google Cloud, ve a la página Detalles de la implementación > Carga de trabajo.

  2. Haz clic en tu implementación de Kubernetes.

    Se abrirá la página de detalles de la implementación.

  3. En Servicios expuestos, haz clic en Exponer y, luego, agrega el puerto 8083.

  4. Habilita la redirección de puertos.

    El vínculo predeterminado que obtienes cuando configuras la redirección de puertos muestra un resultado similar al siguiente:

    {"version":"3.4.0","commit":"2e1947d240607d53","kafka_cluster_id":"6H6qWA0dQnuK31hBPqYUDg"}

    Si agregas /connectors al vínculo, se muestra el conector en ejecución. Por ejemplo:

    ["PubSubLiteSourceConnector"]

    Por ejemplo, si verificas este vínculo url:8083/connectors/PubSubLiteSourceConnector/status, se muestra una lista de tareas y su estado.

    {"name":"PubSubLiteSourceConnector","connector":{"state":"RUNNING","worker_id":"10.53.0.157:8083"},"tasks":[{"id":0,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":1,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":2,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":3,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":4,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":5,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":6,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":7,"state":"RUNNING","worker_id":"10.53.0.157:8083"},{"id":8,"state":"RUNNING","worker_id":"10.53.0.139:8083"},{"id":9,"state":"RUNNING","worker_id":"10.53.0.157:8083"}],"type":"source"}

Migración por fases

Después de migrar tu tema de Pub/Sub Lite a Kafka, puedes migrar tus suscriptores y publicadores. Para ello, sigue estos pasos.

  1. Migra los suscriptores. Actualiza a tus suscriptores para que consuman Temas de Kafka en lugar de temas de Pub/Sub Lite.

    Esto debe hacerse de manera gradual en un entorno de desarrollo controlado.

    Lo ideal es que mantengas dos conjuntos de suscriptores para verificar que se reciban mensajes idénticos de Kafka y Pub/Sub Lite. Una vez que se verifique el comportamiento correcto, podrás dar de baja a tus suscriptores de Pub/Sub Lite.

  2. Migra publicadores. Actualiza los publicadores para que publiquen directamente en Temas de Kafka en lugar de temas de Pub/Sub Lite.

    Al igual que la migración de suscriptores, esto debe hacerse de manera gradual en un de entorno de desarrollo controlado. Si no te preocupa la duplicación de datos, puedes mantener dos conjuntos de publicadores para verificar el comportamiento. Después de verificar el comportamiento, da de baja tus publicadores de Pub/Sub Lite.

  3. Una vez que se hayan migrado todos los suscriptores y publicadores, retira el servicio de migración, borrando la carga de trabajo y el clúster.

  4. Borra el tema original de Pub/Sub Lite.

¿Qué sigue?