Se usó la API de Cloud Translation para traducir esta página.

Migra de Pub/Sub Lite al Servicio administrado de Apache Kafka de Google Cloud

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

Antes de comenzar

Habilita la API de Google Kubernetes Engine.
Identifica un tema de Pub/Sub Lite para migrar. Elige un nombre para el tema de destino en 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, completa las siguientes tareas. Los detalles específicos de estas tareas se muestran más adelante en esta página.

Crea una cuenta de servicio de Google Kubernetes Engine.
Crear un clúster de Google Kubernetes Engine
Personaliza una imagen de Docker con los detalles de configuración de tus temas.
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 tenga los permisos necesarios para ejecutar un clúster de Google Kubernetes Engine.

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.
Otorga los siguientes roles de IAM adicionales a la cuenta de servicio. Estos roles 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 usuario 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 la cuenta de servicio que creaste en el paso anterior.

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

Ir a Google Kubernetes Engine
Haz clic en Crear.

Aparecerá la página Crea un clúster de Autopilot.
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.
De manera opcional, configura otros parámetros según sea necesario.
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.

Clona el repositorio de GitHub de migración de Pub/Sub Lite.
Para la cuenta de servicio de IAM que creaste antes, genera una clave de cuenta JSON.

Usa una herramienta de 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
```

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>

Ejecuta el archivo docker/build-image.sh para compilar la imagen de Docker.
```
./push-image.sh
```
Actualiza la imagen docker/push-image.sh con el nombre de tu proyecto de Google Cloud.
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.

Instala y configura kubectl con el complemento de autenticación.
Genera el archivo kubeconfig para tu clúster de Google Kubernetes Engine.

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

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.
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.

Supervisa un trabajo

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

En la consola de Google Cloud, ve a la página Detalles de la implementación > Carga de trabajo.
Haz clic en tu implementación de Kubernetes.

Se abrirá la página de detalles de la implementación.
En Servicios expuestos, haz clic en Exponer y, luego, agrega el puerto 8083.

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.

Migrar suscriptores Actualiza a tus suscriptores para que consuman temas de Kafka en lugar de temas de Pub/Sub Lite.

Esto se debe hacer de forma 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.
Migrar publicadores. Actualiza tus publicadores para que publiquen directamente en temas de Kafka en lugar de temas de Pub/Sub Lite.

Al igual que con la migración de suscriptores, esto se debe hacer de forma 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, da de baja tus publicadores de Pub/Sub Lite.
Después de migrar todos tus suscriptores y publicadores, quita la herramienta de migración. Para ello, borra la carga de trabajo y el clúster.
Borra el tema original de Pub/Sub Lite.

¿Qué sigue?

Más información sobre el Servicio administrado para Apache Kafka