Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui la migrazione da Pub/Sub Lite a Google Cloud Managed Service per Apache Kafka

Questo documento descrive in dettaglio come eseguire la migrazione dei dati da un argomento Pub/Sub Lite a un argomento Managed Service per Apache Kafka.

Prima di iniziare

Attiva l'API Google Kubernetes Engine.
Identifica un argomento Pub/Sub Lite di cui eseguire la migrazione. Scegli un nome per l'argomento di destinazione in Google Cloud Managed Service per Apache Kafka. Determina anche a quale cluster Managed Service per Apache Kafka esegui la migrazione.

Flusso di lavoro di migrazione

Per eseguire la migrazione dei dati, completa le seguenti attività. I dettagli specifici di queste attività sono riportati più avanti in questa pagina.

Crea un account di servizio Google Kubernetes Engine.
Crea un cluster Google Kubernetes Engine.
Personalizza un'immagine Docker con i dettagli di configurazione dei tuoi argomenti.
Esegui il deployment dell'immagine Docker in un cluster Google Kubernetes Engine.

All'interno dell'immagine, Kafka Connect e il plug-in Pub/Sub Lite per Kafka Connect vengono utilizzati per sottoscrivere un nuovo abbonamento Pub/Sub Lite e pubblicare nel servizio gestito per Apache Kafka.

Crea un account di servizio Google Kubernetes Engine

Questa sezione descrive come creare un account di servizio IAM con le autorizzazioni necessarie per eseguire un cluster Google Kubernetes Engine.

Nella console Google Cloud, crea un nuovo account di servizio IAM con le autorizzazioni minime necessarie per utilizzare Google Kubernetes Engine.
Concedi i seguenti ruoli IAM aggiuntivi all'account di servizio. Questi ruoli facilitano il processo di migrazione.
- Ruolo Managed Kafka Client (roles/managedkafka.client)
- Ruolo sottoscrittore Pub/Sub Lite (roles/pubsublite.subscriber)
- Ruolo Pub/Sub Lite Viewer (roles/pubsublite.Viewer)
- Ruolo Artifact Registry Reader (roles/artifactregistry.reader)

Crea un cluster GKE

Questa sezione descrive come creare un cluster GKE che utilizzi l'account di servizio creato nel passaggio precedente.

Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

Vai a Google Kubernetes Engine
Fai clic su Crea.

Viene visualizzata la pagina Crea un cluster Autopilot.
Nella scheda Impostazioni avanzate, imposta l'account di servizio sull'account di servizio IAM che hai creato nel passaggio precedente.
Se vuoi, configura altre impostazioni come necessario.
Per creare il cluster, fai clic su Crea.

Crea un'immagine Docker di Kafka Connect

Questa sezione descrive come creare e personalizzare un'immagine Docker di Kafka Connect per il tuo argomento.

Clona il repository GitHub per la migrazione di Pub/Sub Lite.
Per l'account di servizio IAM creato in precedenza, genera una chiave dell'account JSON.

Utilizza uno strumento base64 per codificare la chiave JSON. Ad esempio,

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

Nei file secrets nel repository GitHub, aggiorna i seguenti file con le informazioni appropriate per collegare il repository al progetto Google Cloud, Pub/Sub Lite e 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>

Crea l'immagine Docker eseguendo il file docker/build-image.sh.
```
./push-image.sh
```
Aggiorna l'immagine docker/push-image.sh con il nome del tuo progetto Google Cloud.
Esegui il push dell'immagine in Artifact Registry eseguendo il file docker/push-image.sh.
```
./push-image.sh
```

Esegui il deployment di un carico di lavoro Kafka Connect

Questa sezione descrive come eseguire il deployment dell'immagine Docker di Kafka Connect in un cluster Google Kubernetes Engine.

Installa e configura kubectl con il plug-in di autenticazione.
Genera il file kubeconfig per il tuo cluster Google Kubernetes Engine.

Crea e concedi un account di servizio Google Kubernetes Engine con le autorizzazioni corrette per simulare l'identità del tuo account 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

Apri il file K8s.yaml in un editor di testo e aggiorna i seguenti valori.
1. Sostituisci <workflow_name> con il nome del flusso di lavoro Kafka Connect.
2. Sostituisci <gke_service_account> con il nome account di servizio Google Kubernetes Engine.
Esegui il file K8s.yaml.
```
kubectl create -f k8s.yaml
```
Viene creato un carico di lavoro Kafka Connect in esecuzione nel cluster Google Kubernetes Engine e viene lanciato il connettore Pub/Sub Lite per spostare i dati dall'argomento Pub/Sub Lite al Managed Service per Apache Kafka di Google Cloud.

Monitorare un job

Una volta eseguito un job, puoi esaminarlo connettendoti all'endpoint REST di Kafka Connect.

Nella console Google Cloud, vai alla pagina Dettagli di deployment > Carico di lavoro.
Fai clic sul deployment Kubernetes.

Viene visualizzata la pagina dei dettagli del deployment.
In Esposizione dei servizi, fai clic su Esponi e poi aggiungi la porta 8083.

Attiva il port forwarding.

Il link predefinito che ottieni dalla configurazione del port forwarding restituisce un output simile al seguente:

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

Se aggiungi /connectors al link, viene elencato il connettore in esecuzione. Ad esempio:

["PubSubLiteSourceConnector"]

Ad esempio, se fai clic su questo linkurl:8083/connectors/PubSubLiteSourceConnector/status viene visualizzato un elenco di attività e il relativo stato.

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

Migrazione graduale

Dopo aver eseguito la migrazione dell'argomento Pub/Sub Lite a Kafka, puoi eseguire la migrazione di sottoscrittori ed editori. Per farlo, segui questi passaggi.

Esegui la migrazione degli iscritti. Aggiorna gli iscritti in modo che consumino gli argomenti Kafka anziché quelli Pub/Sub Lite.

Questa operazione deve essere eseguita gradualmente in un ambiente di sviluppo controllato.

Idealmente, dovresti gestire due insiemi di iscritti per verificare che vengano ricevuti messaggi identici sia da Kafka che da Pub/Sub Lite. Una volta verificato il comportamento corretto, puoi ritirare gli iscritti a Pub/Sub Lite.
Esegui la migrazione dei publisher. Aggiorna i publisher in modo che pubblichino direttamente negli argomenti Kafka anziché negli argomenti Pub/Sub Lite.

Come per la migrazione degli iscritti, questa operazione deve essere eseguita gradualmente in un ambiente di sviluppo controllato. Se i dati duplicati non sono un problema, puoi gestire due set di publisher per verificare il comportamento. Dopo aver verificato il comportamento, ritira i publisher Pub/Sub Lite.
Dopo aver eseguito la migrazione di tutti gli abbonati e i publisher, ritira lo strumento di migrazione eliminando il workload e il cluster.
Elimina l'argomento Pub/Sub Lite originale.

Passaggi successivi

Scopri di più su Managed Service per Apache Kafka