Esegui la migrazione da Pub/Sub Lite ad Apache Kafka per BigQuery

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

Prima di iniziare

  1. Abilita 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 Apache Kafka per BigQuery. Determina anche a quale cluster Apache Kafka per BigQuery stai eseguendo la migrazione.

Flusso di lavoro della migrazione

Per eseguire la migrazione dei tuoi dati, devi completare le attività riportate di seguito. I dettagli specifici di queste attività sono mostrati 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 degli 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 in Apache Kafka per BigQuery.

Creare un account di servizio Google Kubernetes Engine

Questa sezione descrive come creare un account di servizio IAM che disponga delle 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 ruoli facilitano il processo di migrazione.

    • Ruolo client Kafka gestito (roles/managedkafka.client)
    • Ruolo sottoscrittore Pub/Sub Lite (roles/pubsublite.subscriber)
    • Ruolo Visualizzatore Pub/Sub Lite (roles/pubsublite.Viewer)
    • Ruolo Lettore Artifact Registry (roles/artifactregistry.reader)

crea un cluster GKE

Questa sezione descrive come creare un cluster GKE che utilizza l'account di 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, cambia l'account di servizio nell'account di servizio IAM creato nel passaggio precedente.

  4. Facoltativamente, configura altre impostazioni in base alle esigenze.

  5. Per creare il cluster, fai clic su Crea.

Crea un'immagine Docker Kafka Connect

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

  1. Clona il repository GitHub di migrazione 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 di secret del repository GitHub, aggiorna i file seguenti con le informazioni appropriate per collegare il repository al tuo progetto Google Cloud, a 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 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 Kafka Connect in un cluster Google Kubernetes Engine.

  1. Installare e configurare kubectl con il plug-in di autenticazione.
  2. Generare kubeconfig per il tuo cluster Google Kubernetes Engine.

  3. Creare e concedere un account di servizio Google Kubernetes Engine con le autorizzazioni corrette per impersonare il 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 valori seguenti.

    1. Sostituisci <workflow_name> con il nome del tuo flusso di lavoro Kafka Connect.
    2. Sostituisci <gke_service_account> con il nome dell'account di servizio Google Kubernetes Engine.

  5. 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 avviato il connettore Pub/Sub Lite per spostare i dati dall'argomento Pub/Sub Lite ad Apache Kafka per BigQuery.

Monitora un job

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

  1. Nella console Google Cloud, vai alla pagina Dettagli deployment > 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 ottenuto impostando il port forwarding restituisce un output simile al seguente:

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

    Se aggiungi /connectors al link, verrà elencato il connettore in esecuzione, ad esempio:

    ["PubSubLiteSourceConnector"]

    Ad esempio, se selezioni questo link url:8083/connectors/PubSubLiteSourceConnector/status, viene visualizzato un elenco di attività con 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 dei sottoscrittori e dei publisher. Per farlo, segui questi passaggi.

  1. Eseguire la migrazione degli abbonati. Aggiorna i tuoi sottoscrittori per utilizzare argomenti Kafka anziché argomenti Pub/Sub Lite.

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

    Idealmente, dovresti mantenere due insiemi di sottoscrittori per verificare che messaggi identici vengano ricevuti sia da Kafka che da Pub/Sub Lite. Una volta verificato il comportamento corretto, puoi ritirare i sottoscrittori Pub/Sub Lite.

  2. Eseguire la migrazione dei publisher. Aggiorna i publisher in modo che pubblichino direttamente in argomenti Kafka anziché in argomenti Pub/Sub Lite.

    Come per la migrazione degli abbonati, questa operazione va eseguita gradualmente in un ambiente di sviluppo controllato. Se la presenza di dati duplicati non è un problema, puoi gestire due insiemi di publisher per verificare il comportamento. Dopo aver verificato il comportamento, dismetti i publisher Pub/Sub Lite.

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

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

Passaggi successivi