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

Questo documento descrive in dettaglio come eseguire la migrazione dei dati da un argomento Pub/Sub Lite in 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 questi vengono mostrate più avanti in questa pagina.

  1. Crea un account di servizio Google Kubernetes Engine.
  2. Crea un cluster Google Kubernetes Engine.
  3. Personalizzare un'immagine Docker con la configurazione i dettagli 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 La connessione viene utilizzata per sottoscrivere una nuova sottoscrizione Pub/Sub Lite e pubblicare su Apache Kafka per BigQuery.

Creare 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 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 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, cambia l'account di servizio in IAM. l'account di servizio che hai creato nel passaggio precedente.

  4. Facoltativamente, configura altre impostazioni. dell'oggetto o eliminare definitivamente una versione archiviata, in base alle necessità.

  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 segreti della GitHub di ASL, aggiorna i file seguenti con le per collegare il repository al progetto Google Cloud, in 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 Connect di Kafka in un in un cluster Google Kubernetes Engine.

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

  3. Crea e concedi 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 l'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 in Google Kubernetes Engine cluster e avvia il connettore Pub/Sub Lite per spostare i dati da Pub/Sub Lite ad Apache Kafka per BigQuery.

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 queste istruzioni: passaggi.

  1. Eseguire la migrazione degli abbonati. Aggiorna i tuoi abbonati per usufruire Argomenti Kafka invece che 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 con la migrazione degli abbonati, questa operazione va 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 la verifica il comportamento dei publisher Pub/Sub Lite.

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

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

Passaggi successivi