Cette page a été traduite par l'API Cloud Translation.

Migrer de Pub/Sub Lite vers Google Cloud Managed Service pour Apache Kafka

Ce document explique comment migrer des données d'un sujet Pub/Sub Lite vers un sujet Managed Service pour Apache Kafka.

Avant de commencer

Activez l'API Google Kubernetes Engine.
Identifiez un sujet Pub/Sub Lite à migrer. Choisissez un nom pour le sujet cible dans Google Cloud Managed Service pour Apache Kafka. Déterminez également vers quel cluster Managed Service pour Apache Kafka vous effectuez la migration.

Workflow de migration

Pour migrer vos données, procédez comme suit : Les détails spécifiques de ces tâches sont indiqués plus loin sur cette page.

Créez un compte de service Google Kubernetes Engine.
Créez un cluster Google Kubernetes Engine.
Personnalisez une image Docker avec les détails de configuration de vos sujets.
Déployez l'image Docker sur un cluster Google Kubernetes Engine.

Dans l'image, Kafka Connect et le plug-in Pub/Sub Lite pour Kafka Connect sont utilisés pour s'abonner à un nouvel abonnement Pub/Sub Lite et publier des données dans Managed Service pour Apache Kafka.

Créer un compte de service Google Kubernetes Engine

Cette section explique comment créer un compte de service IAM disposant des autorisations requises pour exécuter un cluster Google Kubernetes Engine.

Dans la console Google Cloud, créez un compte de service IAM avec les autorisations minimales requises pour utiliser Google Kubernetes Engine.
Attribuez les rôles IAM supplémentaires suivants au compte de service. Ces rôles facilitent le processus de migration.
- Rôle de client Managed Kafka (roles/managedkafka.client)
- Rôle d'abonné Pub/Sub Lite (roles/pubsublite.subscriber)
- Rôle de lecteur Pub/Sub Lite (roles/pubsublite.Viewer)
- Rôle Lecteur Artifact Registry (roles/artifactregistry.reader)

Créer un cluster GKE

Cette section explique comment créer un cluster GKE qui utilise le compte de service que vous avez créé à l'étape précédente.

Accédez à la page Google Kubernetes Engine dans Google Cloud Console.

Accéder à Google Kubernetes Engine
Cliquez sur Créer.

La page Créer un cluster Autopilot s'affiche.
Dans l'onglet Paramètres avancés, remplacez le compte de service par le compte de service IAM que vous avez créé à l'étape précédente.
Vous pouvez également configurer d'autres paramètres si nécessaire.
Pour créer le cluster, cliquez sur Créer.

Créer une image Docker Kafka Connect

Cette section explique comment créer et personnaliser une image Docker Kafka Connect pour votre sujet.

Clonez le dépôt GitHub de migration Pub/Sub Lite.
Pour le compte de service IAM que vous avez créé précédemment, générez une clé de compte JSON.

Utilisez un outil base64 pour encoder la clé JSON. Par exemple,

Linux
```
base64 -w 0 < my_service_account.json > password.txt
```
Mac
```
base64 < account_key_json > password.txt
```

Dans les fichiers secrets du dépôt GitHub, mettez à jour les fichiers suivants avec les informations appropriées pour associer le dépôt à votre projet Google Cloud, Pub/Sub Lite et 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>

Créez l'image Docker en exécutant le fichier docker/build-image.sh.
```
./push-image.sh
```
Remplacez l'image docker/push-image.sh par le nom de votre projet Google Cloud.
Transférez l'image vers Artifact Registry en exécutant le fichier docker/push-image.sh.
```
./push-image.sh
```

Déployer une charge de travail Kafka Connect

Cette section explique comment déployer l'image Docker Kafka Connect sur un cluster Google Kubernetes Engine.

Installez et configurez kubectl avec le plug-in d'authentification.
Générez le kubeconfig pour votre cluster Google Kubernetes Engine.

Créez un compte de service Google Kubernetes Engine et accordez-lui les autorisations appropriées pour usurper l'identité de votre compte 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

Ouvrez le fichier K8s.yaml dans un éditeur de texte et mettez à jour les valeurs suivantes.
1. Remplacez <workflow_name> par le nom de votre workflow Kafka Connect.
2. Remplacez <gke_service_account> par le nom du compte de service Google Kubernetes Engine.
Exécutez le fichier K8s.yaml.
```
kubectl create -f k8s.yaml
```
Cela crée une charge de travail Kafka Connect exécutée dans votre cluster Google Kubernetes Engine et lance le connecteur Pub/Sub Lite pour transférer les données de votre sujet Pub/Sub Lite vers Google Cloud Managed Service pour Apache Kafka.

Surveiller une tâche

Une fois qu'une tâche est en cours d'exécution, vous pouvez l'inspecter en vous connectant au point de terminaison REST Kafka Connect.

Dans la console Google Cloud, accédez à la page Détails du déploiement > Charge de travail.
Cliquez sur votre déploiement Kubernetes.

La page des détails du déploiement s'affiche.
Sous Exposer des services, cliquez sur Exposer, puis ajoutez le port 8083.

Activez le transfert de port.

Le lien par défaut obtenu en configurant le transfert de port renvoie un résultat semblable à celui-ci:

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

Si vous ajoutez /connectors au lien, le connecteur en cours d'exécution est listé. Par exemple:

["PubSubLiteSourceConnector"]

Par exemple, cliquer sur ce lien url:8083/connectors/PubSubLiteSourceConnector/status affiche une liste de tâches et leur état.

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

Migration en plusieurs phases

Une fois votre sujet Pub/Sub Lite migré vers Kafka, vous pouvez migrer vos abonnés et éditeurs. Pour ce faire, procédez comme suit.

Migrer les abonnés Mettez à jour vos abonnés pour qu'ils consomment des sujets Kafka au lieu de sujets Pub/Sub Lite.

Cette opération doit être effectuée progressivement dans un environnement de développement contrôlé.

Idéalement, vous devez gérer deux ensembles d'abonnés pour vérifier que des messages identiques sont reçus à la fois de Kafka et de Pub/Sub Lite. Une fois le comportement correct vérifié, vous pouvez mettre hors service vos abonnés Pub/Sub Lite.
Migrer les éditeurs Mettez à jour vos éditeurs pour qu'ils publient directement dans des sujets Kafka au lieu de sujets Pub/Sub Lite.

Comme pour la migration des abonnés, cette opération doit être effectuée progressivement dans un environnement de développement contrôlé. Si les données en double ne vous posent pas de problème, vous pouvez gérer deux ensembles d'éditeurs pour vérifier le comportement. Après avoir vérifié le comportement, mettez hors service vos éditeurs Pub/Sub Lite.
Une fois tous vos abonnés et éditeurs migrés, mettez hors service l'outil de migration en supprimant la charge de travail et le cluster.
Supprimez le sujet Pub/Sub Lite d'origine.

Étape suivante

En savoir plus sur le service géré pour Apache Kafka