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 in un argomento Managed Service per Apache Kafka.

Prima di iniziare

  1. Attiva l'API Google Kubernetes Engine.
  2. 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.

  1. Crea un account di servizio Google Kubernetes Engine.
  2. Crea un cluster Google Kubernetes Engine.
  3. Personalizza un'immagine Docker con i dettagli di configurazione dei tuoi argomenti.

  4. 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 che le autorizzazioni necessarie per eseguire un cluster Google Kubernetes Engine.

  1. Nella console Google Cloud, crea un nuovo account di servizio IAM con le autorizzazioni minime necessarie per utilizzare Google Kubernetes Engine.

  2. Concedi i seguenti ruoli IAM aggiuntivi all'account di servizio. Questi che 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 utilizza il servizio creato nel passaggio precedente.

  1. Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

    Vai a Google Kubernetes Engine

  2. Fai clic su Crea.

    Viene visualizzata la pagina Crea un cluster Autopilot.

  3. Nella scheda Impostazioni avanzate, imposta l'account di servizio sull'account di servizio IAM che hai creato nel passaggio precedente.

  4. Se vuoi, configura altre impostazioni come necessario.

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

  1. Clona il repository GitHub per la migrazione di Pub/Sub Lite.

  2. Per l'account di servizio IAM che hai creato in precedenza, genera una chiave account JSON.

    Usa 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

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

  4. Crea l'immagine Docker eseguendo il file docker/build-image.sh.

    ./push-image.sh

  5. Aggiorna l'immagine docker/push-image.sh con il nome del tuo progetto Google Cloud.

  6. Esegui il push dell'immagine in Artifact Registry eseguendo il 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.

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

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

  4. 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 l'account di servizio Google Kubernetes Engine nome.

  5. Esegui il file K8s.yaml.

    kubectl create -f k8s.yaml

    Viene creato un carico di lavoro Kafka Connect in esecuzione in Google Kubernetes Engine e avvia il connettore Pub/Sub Lite per spostare i dati un argomento Pub/Sub Lite per il servizio gestito di Google Cloud per Apache Kafka.

Monitora un job

Quando un job è in esecuzione, puoi controllarlo connettendoti a Kafka Connect l'endpoint REST.

  1. Nella console Google Cloud, vai a Dettagli deployment > Pagina Carico di lavoro.

  2. Fai clic sul deployment Kubernetes.

    Si apre la pagina dei dettagli del deployment.

  3. In Servizi di esposizione, fai clic su Esponi, quindi aggiungi la porta 8083.

  4. 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, saranno elencati il connettore in esecuzione, Ad esempio:

    ["PubSubLiteSourceConnector"]

    Ad esempio, selezionando questo link url:8083/connectors/PubSubLiteSourceConnector/status restituisce 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 per fasi

Dopo la migrazione dell'argomento Pub/Sub Lite in Kafka, puoi eseguire la migrazione di abbonati e publisher. Per farlo, segui questi passaggi.

  1. Eseguire la migrazione degli abbonati. 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 sottoscrittori per verificare che i messaggi identici vengono ricevute sia da Kafka che da Pub/Sub Lite. Una volta verificato il comportamento corretto, puoi ritirare Pub/Sub Lite abbonati.

  2. Eseguire la migrazione dei publisher. Aggiornare i publisher per pubblicare direttamente su Argomenti Kafka invece che 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, due gruppi di publisher per verificare il comportamento. Dopo aver verificato il comportamento, ritira i publisher Pub/Sub Lite.

  3. Dopo aver eseguito la migrazione di tutti gli abbonati e i publisher, ritira lo strumento di migrazione eliminando il carico di lavoro e il cluster.

  4. Elimina l'argomento Pub/Sub Lite originale.

Passaggi successivi