Migra de Pub/Sub Lite a Apache Kafka para BigQuery

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

Antes de comenzar

  1. Habilita la API de Google Kubernetes Engine.
  2. Identifica un tema de Pub/Sub Lite para migrar. Elige un nombre para el tema de destino en Apache Kafka para BigQuery. Además, determina a qué clúster de Apache Kafka para BigQuery 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 los detalles de configuración de tus temas.

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

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

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 tenga 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. Estas funciones 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)

Crea un clúster de GKE

En esta sección, se describe cómo crear un clúster de GKE que use la cuenta de servicio 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 Crear un clúster de Autopilot.

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

  4. De manera opcional, 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 del repositorio de GitHub, actualiza los siguientes archivos con la información adecuada 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. Envía la imagen a Artifact Registry mediante la ejecución del archivo docker/push-image.sh.

    ./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. Instala y configura kubectl con el complemento de autenticación.
  2. Genera el kubeconfig para tu clúster de Google Kubernetes Engine.

  3. Crea y otorga una cuenta de servicio de Google Kubernetes Engine con los permisos correctos para usar la identidad 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 el clúster de Google Kubernetes Engine y, luego, inicia el conector de Pub/Sub Lite para mover los datos del tema de Pub/Sub Lite a Apache Kafka para BigQuery.

Supervisar un trabajo

Una vez que se ejecuta un trabajo, puedes conectarte al extremo de REST de Kafka Connect para inspeccionarlo.

  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. Habilitar 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 el /connectors al vínculo, se muestra el conector en ejecución, por ejemplo:

    ["PubSubLiteSourceConnector"]

    Por ejemplo, si se verifica el vínculo url:8083/connectors/PubSubLiteSourceConnector/status, se obtiene 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 hacerlo, 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 mantener 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, puedes retirar 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 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, retira del servicio de tus publicadores de Pub/Sub Lite.

  3. Una vez que se hayan migrado todos los suscriptores y publicadores, borra la carga de trabajo y el clúster para retirar la herramienta de migración.

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

¿Qué sigue?