Esegui il deployment di Apache Kafka su GKE con Strimzi

La guida mostra come utilizzare l'operatore Strimzi per eseguire il deployment di cluster Apache Kafka.

Kafka è un sistema di messaggistica distribuito e open source progettato per gestire flussi di dati a volume elevato, velocità effettiva elevata e flussi di dati in tempo reale. Ti permette di creare pipeline di dati in modalità flusso per un trasferimento affidabile di dati tra diversi sistemi per supportare le attività di elaborazione e analisi.

Gli operatori sono estensioni software che utilizzano risorse personalizzate per gestire le applicazioni e i loro componenti. Per scoprire di più sulla motivazione per l'utilizzo per gli operatori, consulta Pattern operatore nella documentazione open source di Kubernetes. L'operatore Strimzi offre flessibilità nelle opzioni di deployment e consente di utilizzare le incompatibilità per l'esecuzione di Kafka su nodi dedicati.

Questa guida è rivolta ad amministratori della piattaforma, architetti cloud e professionisti delle operazioni interessati a eseguire il deployment di cluster Kafka su GKE.

Questa soluzione è un buon punto di partenza se vuoi imparare a eseguire il deployment di Kafka utilizzando un operatore di terze parti per automatizzare la gestione e ridurre gli errori. Se preferisci un controllo operativo più granulare, consulta Esegui il deployment di cluster Kafka a disponibilità elevata su GKE.

Obiettivi

  • Pianifica ed esegui il deployment dell'infrastruttura GKE per Apache Kafka
  • Esegui il deployment e la configurazione dell'operatore Strimzi
  • configura Apache Kafka utilizzando l'operatore Strimzi

Vantaggi

Strimzi offre i seguenti vantaggi:

  • Gli operatori Strimzi forniscono un approccio semplificato e nativo di Kubernetes a per gestire i cluster Kafka. Strimzi utilizza risorse personalizzate che rappresentano argomenti e utenti Kafka, semplificando notevolmente la gestione del cluster e allineandola alle best practice di Kubernetes.
  • Strimzi dà priorità alla sicurezza per impostazione predefinita generando certificati per e il supporto di metodi di autenticazione sicuri come TLS, SCRAM-SHA e OAuth. Strimzi gestisce anche NetworkPolicies per tutti gli ascoltatori Kafka.
  • Strimzi non si basa su dipendenze esterne. Comprende Kafka e ZooKeeper con esportatori di metriche integrati, evitando così di dover strumenti aggiuntivi. Puoi anche ottimizzare le configurazioni dei broker requisiti specifici.

Architettura di deployment

Un cluster Kafka è costituito da uno o più server, noti come broker, che collaborano per gestire i flussi di dati in entrata e semplificare la messaggistica Pub/Sub per i client Kafka, chiamati consumer.

A ogni partizione di dati all'interno del cluster Kafka è assegnato un broker leader, responsabile della gestione di tutte le operazioni di lettura e scrittura nella partizione. La partizione può anche avere uno o più broker follower che replicano passivamente le azioni del broker leader.

In una configurazione tipica, ZooKeeper coordina i cluster Kafka aiutando a scegliere una leader tra gli broker e garantire un failover fluido in caso di problemi.

Puoi anche eseguire il deployment della configurazione Kafka senza Zookeeper attivando KRaft ma questo metodo non è considerato pronto per la produzione dallo Strimzi community perché non include il supporto per le risorse KafkaTopic, autenticazione delle credenziali e altro ancora.

Disponibilità e ripristino di emergenza

Questo tutorial utilizza pool di nodi e zone distinti per i cluster Kafka e ZooKeeper per garantire l'alta disponibilità e prepararsi al disaster recovery.

L'utilizzo di più nodi e zone è fondamentale per ottenere un'elevata disponibilità Kubernetes in Google Cloud per i seguenti motivi:

  • Tolleranza agli errori: più nodi distribuiscono il carico di lavoro nel cluster, garantendo che, in caso di errore di un nodo, gli altri possano assumere il controllo delle attività, evitando tempi di inattività e interruzioni del servizio.
  • Scalabilità: l'utilizzo di più nodi garantisce che la scalabilità orizzontale possa aggiungere o rimuovere i nodi in base alle esigenze, garantendo un'allocazione ottimale delle risorse e adattandosi all'aumento del traffico o delle richieste di carico di lavoro.
  • Alta disponibilità: l'utilizzo di più zone all'interno di una regione garantisce la ridondanza e riduce al minimo il rischio di un singolo punto di défaillance. Se un'intera zona di disponibilità presenta un'interruzione, il cluster può continuare a funzionare in altre zone, mantenendo la disponibilità del servizio.
  • Ridondanza geografica: abbracciando i nodi tra regioni, e servizi sono distribuiti geograficamente, fornendo resilienza da calamità naturali, interruzioni di corrente o altre interruzioni locali che potrebbero influire su una singola zona.
  • Aggiornamenti e manutenzione incrementali: l'utilizzo di più zone consente di eseguire aggiornamenti e manutenzione incrementali sui singoli nodi senza influire sulla disponibilità complessiva del cluster. Ciò garantisce un accesso continuo consentendo l'applicazione delle patch e degli aggiornamenti necessari senza problemi.
  • Accordi sul livello del servizio (SLA): Google Cloud fornisce gli SLA per di deployment multizona, garantendo un livello minimo di uptime e la disponibilità del servizio.

Diagramma di deployment

Il seguente diagramma mostra un cluster Kafka in esecuzione su più nodi e zone in un cluster GKE:

Nel diagramma, Kafka StrimziPodSet viene eseguito su tre nodi in tre zone diverse. Puoi controllare questa configurazione impostando il parametro pod richiesto affinità e dispersione della topologia nella specifica della risorsa personalizzata StrimziPodSet.

In caso di errore di una zona, utilizzando la configurazione consigliata, ripianifica i pod su nuovi nodi e replica i dati dalle repliche rimanenti, sia per Kafka che per Zookeeper.

Il seguente diagramma mostra un StrimziPodSet di ZooKeeper implementato in tre di nodi in tre zone diverse:

La risorsa personalizzata StrimziPodSet

Questo tutorial utilizza la risorsa personalizzata StrimziPodSet introdotta nella versione 0.29 di Strimzi anziché StatefulSets.

Le risorse StrimziPodSet offrono una scalabilità migliorata per il cluster e consentono di passare le opzioni di configurazione, in modo da apportare modifiche più granulari ai pod. La risorsa StrimziPodSet è abilitata per impostazione predefinita nelle versioni Strimzi 0.35 e versioni successive.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the Compute Engine, IAM, GKE, Backup for GKE, and Resource Manager APIs: 

    gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com gkebackup.googleapis.com cloudresourcemanager.googleapis.com
  7. Install the Google Cloud CLI.

  8. To initialize the gcloud CLI, run the following command: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Make sure that billing is enabled for your Google Cloud project.

  11. Enable the Compute Engine, IAM, GKE, Backup for GKE, and Resource Manager APIs: 

    gcloud services enable compute.googleapis.com iam.googleapis.com container.googleapis.com gkebackup.googleapis.com cloudresourcemanager.googleapis.com

  12. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/storage.objectViewer, roles/logging.logWriter, roles/container.clusterAdmin, roles/container.serviceAgent, roles/iam.serviceAccountAdmin, roles/serviceusage.serviceUsageAdmin, roles/iam.serviceAccountAdmin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.

    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

Prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Il software è preinstallato in Cloud Shell che ti servono per questo tutorial, kubectl, il gcloud CLI, Helm e Terraform.

Per configurare l'ambiente con Cloud Shell:

  1. Avvia una sessione di Cloud Shell dalla console Google Cloud. clic su Icona di attivazione di Cloud Shell Attiva Cloud Shell nella Console Google Cloud: Verrà avviata una sessione nel riquadro inferiore della console Google Cloud.

  2. Imposta le variabili di ambiente:

    export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=kafka
export REGION=us-central1

    Sostituisci PROJECT_ID: il tuo progetto Google Cloud con il tuo ID progetto.

  3. Clona il repository GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples

  4. Passa alla directory di lavoro:

    cd kubernetes-engine-samples/streaming/

Crea l'infrastruttura del cluster

In questa sezione esegui uno script Terraform per creare un cluster GKE regionale privato e ad alta disponibilità. I passaggi che seguono consentono l'accesso pubblico al piano di controllo. Per limitare l'accesso, crea un'istanza cluster privato.

Puoi installare l'operatore utilizzando un'istanza Standard o Autopilot in un cluster Kubernetes.

Standard

Il seguente diagramma mostra un cluster GKE regionale privato standard di cui è stato eseguito il deployment in tre zone diverse:

Per eseguire il deployment di questa infrastruttura, esegui i seguenti comandi da Cloud Shell:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=kafka/terraform/gke-standard init
terraform -chdir=kafka/terraform/gke-standard apply -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Quando richiesto, digita yes. Il completamento di questo comando potrebbe richiedere diversi minuti e il cluster potrebbe mostrare uno stato di disponibilità.

Terraform crea le seguenti risorse:

  • Una rete VPC e una subnet privata per i nodi Kubernetes.
  • Un router per accedere a Internet tramite NAT.
  • Un cluster GKE privato nella regione us-central1.
  • 2 pool di nodi con scalabilità automatica abilitata (1-2 nodi per zona, 1 nodo per zona minimo)
  • Un'ServiceAccount con autorizzazioni di logging e monitoraggio.
  • Backup per GKE per il ripristino di emergenza.
  • Google Cloud Managed Service per Prometheus per il monitoraggio dei cluster.

L'output è simile al seguente:

...
Apply complete! Resources: 14 added, 0 changed, 0 destroyed.

Outputs:

kubectl_connection_command = "gcloud container clusters get-credentials strimzi-cluster --region us-central1"

Autopilot

Il seguente diagramma mostra un Autopilot a livello di regione privato Cluster GKE:

Per eseguire il deployment dell'infrastruttura, esegui questi comandi Cloud Shell:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=kafka/terraform/gke-autopilot init
terraform -chdir=kafka/terraform/gke-autopilot apply -var project_id=${PROJECT_ID} \
  -var region=${REGION} \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Quando richiesto, digita yes. Potrebbero essere necessari diversi minuti prima che questo comando completata e affinché il cluster mostri lo stato Pronto.

Terraform crea le seguenti risorse:

  • Rete VPC e subnet privata per i nodi Kubernetes.
  • Un router per accedere a internet tramite NAT.
  • Un cluster GKE privato nella regione us-central1.
  • Un'ServiceAccount con autorizzazioni di logging e monitoraggio
  • Google Cloud Managed Service per Prometheus per il monitoraggio dei cluster.

L'output è simile al seguente:

...
Apply complete! Resources: 12 added, 0 changed, 0 destroyed.

Outputs:

kubectl_connection_command = "gcloud container clusters get-credentials strimzi-cluster --region us-central1"

Connessione al cluster in corso...

Configura kubectl per comunicare con il cluster:

gcloud container clusters get-credentials ${KUBERNETES_CLUSTER_PREFIX}-cluster --region ${REGION}

Esegui il deployment dell'operatore Strimzi nel cluster

In questa sezione esegui il deployment dell'operatore Strimzi utilizzando un grafico Helm. Esistono anche diversi altri modi per eseguire il deployment di Strimzi.

  1. Aggiungi il repository del grafico Helm Strimzi:

    helm repo add strimzi https://strimzi.io/charts/

  2. Aggiungi uno spazio dei nomi per l'operatore Strimzi e il cluster Kafka:

    kubectl create ns kafka

  3. Esegui il deployment dell'operatore di cluster Strimzi utilizzando Helm:

    helm install strimzi-operator strimzi/strimzi-kafka-operator -n kafka

    Per eseguire il deployment di Strimzi Cluster Operator e dei cluster Kafka in diversi spazi dei nomi, aggiungi il parametro --set watchNamespaces="{kafka-namespace,kafka-namespace-2,...}" al comando helm.

  4. Verifica che il deployment dell'operatore del cluster Strimzi sia stato eseguito correttamente usando Helm:

    helm ls -n kafka

    L'output è simile al seguente:

    NAME            NAMESPACE    REVISION    UPDATED                              STATUS    CHART                        APP VERSION
strimzi-operator    kafka      1       2023-06-27 11:22:15.850545 +0200 CEST    deployed    strimzi-kafka-operator-0.35.0    0.35.0

Esegui il deployment di Kafka

Una volta eseguito il deployment dell'operatore nel cluster, puoi eseguire il deployment di un cluster Kubernetes.

In questa sezione esegui il deployment di Kafka in una configurazione di base, quindi prova vari scenari di configurazione avanzata per soddisfare i requisiti di disponibilità, sicurezza e osservabilità.

Configurazione di base

La configurazione di base per l'istanza Kafka include i seguenti componenti:

  • Tre repliche di broker Kafka, con un minimo di due repliche disponibili obbligatorie per la coerenza del cluster.
  • Tre repliche di nodi ZooKeeper che formano un cluster.
  • Due listener Kafka: uno senza autenticazione e uno che utilizza l'autenticazione TLS con un certificato generato da Strimzi.
  • Java MaxHeapSize e MinHeapSize impostati su 4 GB per Kafka e 2 GB per ZooKeeper.
  • Alloca risorse CPU di 1 richiesta CPU e 2 limiti CPU sia per Kafka sia per ZooKeeper, oltre a richieste e limiti di memoria di 5 GB per Kafka (4 GB per il servizio principale e 0,5 GB per l'esportatore di metriche) e 2,5 GB per ZooKeeper (2 GB per il servizio principale e 0,5 GB per l'esportatore di metriche).
  • Operatore di entità con le seguenti richieste e limiti:
    • tlsSidecar: 100 m/500 m CPU e 128 Mi di memoria.
    • topicOperator: 100 m/500 m CPU e 512 Mi di memoria.
    • userOperator: 500 m CPU e 2 Gi di memoria.
  • 100 GB di spazio di archiviazione allocato a ogni pod mediante premium-rwo storageClass.
  • Tolleranza, nodeAffinities e podAntiAffinities configurati per ogni carico di lavoro, garantendo una distribuzione adeguata tra i nodi, utilizzando i rispettivi pool di nodi e zone diverse.
  • Comunicazione all'interno del cluster protetta da certificati autofirmati: autorità di certificazione (CA) distinte per il cluster e i client (mTLS). Puoi anche configurare l'utilizzo di un'altra autorità di certificazione.

Questa configurazione rappresenta la configurazione minima richiesta per creare un cluster Kafka pronto per la produzione. Le seguenti sezioni illustrano la configurazioni per affrontare aspetti quali la sicurezza del cluster, gli elenchi di controllo dell'accesso (ACL), gestione di argomenti, gestione certificati e altro ancora.

Crea un cluster Kafka di base

  1. Crea un nuovo cluster Kafka utilizzando la configurazione di base:

    kubectl apply -n kafka -f kafka-strimzi/manifests/01-basic-cluster/my-cluster.yaml

    Questo comando crea una risorsa personalizzata Kafka dell'operatore Strimzi che include le richieste e i limiti di CPU e memoria, richieste di archiviazione a blocchi e combinazione di incompatibilità e affinità per distribuire i pod di cui è stato eseguito il provisioning tra i nodi Kubernetes.

  2. Attendi alcuni minuti mentre Kubernetes avvia i carichi di lavoro richiesti:

    kubectl wait kafka/my-cluster --for=condition=Ready --timeout=600s -n kafka

  3. Verifica che i carichi di lavoro Kafka siano stati creati:

    kubectl get pod,service,deploy,pdb -l=strimzi.io/cluster=my-cluster -n kafka

    L'output è simile al seguente:

    NAME                                            READY   STATUS  RESTARTS   AGE
pod/my-cluster-entity-operator-848698874f-j5m7f   3/3   Running   0        44m
pod/my-cluster-kafka-0                          1/1   Running   0        5m
pod/my-cluster-kafka-1                          1/1   Running   0        5m
pod/my-cluster-kafka-2                          1/1   Running   0        5m
pod/my-cluster-zookeeper-0                      1/1   Running   0        6m
pod/my-cluster-zookeeper-1                      1/1   Running   0        6m
pod/my-cluster-zookeeper-2                      1/1   Running   0        6m

NAME                                TYPE      CLUSTER-IP   EXTERNAL-IP   PORT(S)                             AGE
service/my-cluster-kafka-bootstrap  ClusterIP   10.52.8.80   <none>      9091/TCP,9092/TCP,9093/TCP          5m
service/my-cluster-kafka-brokers    ClusterIP   None         <none>      9090/TCP,9091/TCP,9092/TCP,9093/TCP   5m
service/my-cluster-zookeeper-client   ClusterIP   10.52.11.144   <none>      2181/TCP                            6m
service/my-cluster-zookeeper-nodes  ClusterIP   None         <none>      2181/TCP,2888/TCP,3888/TCP          6m

NAME                                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/my-cluster-entity-operator   1/1   1          1         44m

NAME                                            MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
poddisruptionbudget.policy/my-cluster-kafka     2             N/A             1                   5m
poddisruptionbudget.policy/my-cluster-zookeeper   2             N/A             1                   6m

L'operatore crea le seguenti risorse:

  • Due StrimziPodSets per Kafka e ZooKeeper.
  • Tre pod per le repliche dei broker Kafka.
  • Tre pod per le repliche di ZooKeeper.
  • Due PodDisruptionBudgets, garantendo una disponibilità minima di due repliche per garantire la coerenza del cluster.
  • Un servizio denominato my-cluster-kafka-bootstrap, che funge da bootstrap server per i client Kafka che si connettono dall'interno del cluster Kubernetes. Tutti in questo servizio sono disponibili listener Kafka interni.
  • Un servizio headless denominato my-cluster-kafka-brokers che consente la risoluzione DNS degli indirizzi IP dei pod del broker Kafka direttamente. Questo servizio è utilizzato per le comunicazioni tra gli intermediari.
  • Un servizio denominato my-cluster-zookeeper-client che consente ai broker Kafka di connettersi ai nodi ZooKeeper come client.
  • Un servizio headless denominato my-cluster-zookeeper-nodes che consente la risoluzione DNS degli indirizzi IP dei pod ZooKeeper direttamente. Questo servizio è utilizzato per connettersi tra repliche ZooKeeper.
  • Un Deployment denominato my-cluster-entity-operator che contiene operatore-argomento e operatore-utente e facilita la gestione delle risorse personalizzate KafkaTopics e KafkaUsers.

Puoi anche configurare due NetworkPolicies per semplificare la connettività ai listener Kafka da qualsiasi pod e spazio dei nomi. Inoltre, questi criteri limiterebbero le connessioni a ZooKeeper ai broker e attiverebbero la comunicazione tra i pod del cluster e le porte di servizio interne esclusivamente per la comunicazione del cluster.

Autenticazione e gestione degli utenti

Questa sezione mostra come attivare l'autenticazione e l'autorizzazione per proteggere i listener Kafka e condividere le credenziali con i client.

Strimzi fornisce un metodo nativo di Kubernetes per la gestione degli utenti utilizzando un User Operator e la risorsa personalizzata Kubernetes corrispondente, KafkaUser, che definisce la configurazione utente. La configurazione utente include le impostazioni per l'autenticazione e l'autorizzazione e esegue il provisioning dell'utente corrispondente in Kafka.

Strimzi può creare listener e utenti Kafka che supportano diverse meccanismi di autenticazione come l'autenticazione basata su password e nome utente (SCRAM-SHA-512) o TLS. Tu puoi utilizzare anche l'autenticazione OAuth 2.0, che è spesso considerata rispetto all'uso di password o certificati per l'autenticazione, della sicurezza e della gestione delle credenziali esterne.

Esegui il deployment di un cluster Kafka

Questa sezione mostra come eseguire il deployment di un operatore Strimzi che dimostra di Google Cloud, tra cui:

  • Un cluster Kafka con autenticazione basata su password (SCRAM-SHA-512) attivata su uno dei listener.
  • A KafkaTopic con 3 repliche.
  • Un KafkaUser con un ACL che specifica che l'utente dispone delle autorizzazioni di lettura e scrittura per l'argomento.

  1. Configura il tuo cluster Kafka per l'uso di un listener basato su password Autenticazione SCRAM-SHA-512 sulla porta 9094 e semplice autorizzazione:

    kubectl apply -n kafka -f kafka-strimzi/manifests/03-auth/my-cluster.yaml

  2. Crea un Topic, un User e un pod client per eseguire comandi sul cluster Kafka:

    kubectl apply -n kafka -f kafka-strimzi/manifests/03-auth/topic.yaml
kubectl apply -n kafka -f kafka-strimzi/manifests/03-auth/my-user.yaml

    L'elemento Secret my-user con le credenziali utente viene montato sul client come pod Volume.

    Queste credenziali confermano che l'utente dispone delle autorizzazioni per pubblicare messaggi nell'argomento utilizzando l'ascoltatore con l'autenticazione basata su password attivata (SCRAM-SHA-512).

  3. Crea un pod client:

    kubectl apply -n kafka -f kafka-strimzi/manifests/03-auth/kafkacat.yaml

  4. Attendi qualche minuto affinché il pod client diventi Ready, quindi connettiti:

    kubectl wait --for=condition=Ready pod --all -n kafka --timeout=600s
kubectl exec -it kafkacat -n kafka -- /bin/sh

  5. Crea un nuovo messaggio con le credenziali my-user e prova a utilizzarlo:

    echo "Message from my-user" |kcat \
  -b my-cluster-kafka-bootstrap.kafka.svc.cluster.local:9094 \
  -X security.protocol=SASL_SSL \
  -X sasl.mechanisms=SCRAM-SHA-512 \
  -X sasl.username=my-user \
  -X sasl.password=$(cat /my-user/password) \
  -t my-topic -P
kcat -b my-cluster-kafka-bootstrap.kafka.svc.cluster.local:9094 \
  -X security.protocol=SASL_SSL \
  -X sasl.mechanisms=SCRAM-SHA-512 \
  -X sasl.username=my-user \
  -X sasl.password=$(cat /my-user/password) \
  -t my-topic -C

    L'output è simile al seguente:

    Message from my-user
% Reached end of topic my-topic [0] at offset 0
% Reached end of topic my-topic [2] at offset 1
% Reached end of topic my-topic [1] at offset 0

    Digita CTRL+C per interrompere il processo del consumatore.

  6. Esci dalla shell del pod

    exit

Backup e ripristino di emergenza

Sebbene l'operatore Strimzi non offra funzionalità di backup integrate, puoi implementare strategie di backup efficienti seguendo determinati pattern.

Puoi utilizzare Backup per GKE per eseguire il backup di:

  • e i file manifest delle risorse Kubernetes.
  • Risorse personalizzate dell'API Strimzi e relative definizioni estratte dal Server API Kubernetes del cluster in fase di backup.
  • I volumi che corrispondono alle risorse PersistentVolumeClaim presenti e i file manifest.

Per ulteriori informazioni su come eseguire il backup e ripristinare i cluster Kafka utilizzando Backup per GKE, consulta Preparati per il ripristino di emergenza.

Puoi anche eseguire il backup di un cluster Kafka di cui è stato eseguito il deployment utilizzando l'operatore Strimzi. Devi eseguire il backup di:

  • La configurazione Kafka, che include tutte le risorse personalizzate API Strimzi come KafkaTopicse KafkaUsers.
  • I dati, archiviati negli oggetti PersistentVolume dei broker Kafka.

La memorizzazione dei manifest delle risorse Kubernetes, incluse le configurazioni di Strimzi, nei repository Git può eliminare la necessità di un backup separato per la configurazione di Kafka, perché le risorse possono essere riapplicate a un nuovo cluster Kubernetes, se necessario.

Per salvaguardare il recupero dei dati di Kafka negli scenari in cui viene persa un'istanza del server Kafka o un cluster Kubernetes in cui è dipiegato Kafka, ti consigliamo di configurare la classe di archiviazione Kubernetes utilizzata per il provisioning dei volumi per i broker Kafka con l'opzione reclaimPolicy impostata su Retain. Ti consigliamo inoltre che prendi snapshot dei volumi dei broker Kafka.

Il manifest seguente descrive un oggetto StorageClass che utilizza l'oggetto reclaimPolicy opzione Retain:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: premium-rwo-retain
...
reclaimPolicy: Retain
volumeBindingMode: WaitForFirstConsumer

L'esempio seguente mostra StorageClass aggiunto a spec di una risorsa personalizzata del cluster Kafka:

# ...
spec:
  kafka:
    # ...
    storage:
      type: persistent-claim
      size: 100Gi
      class: premium-rwo-retain

Con questa configurazione, il provisioning degli oggetti PersistentVolume viene eseguito non vengono eliminate anche se l'oggetto PersistentVolumeClaim corrispondente eliminati.

Per recuperare l'istanza Kafka su un nuovo cluster Kubernetes utilizzando i dati esistenti della configurazione e dell'istanza del broker:

  1. Applica le risorse personalizzate Kafka di Strimzi esistenti (Kakfa, KafkaTopic, KafkaUser e così via) a un nuovo cluster Kubernetes
  2. Aggiorna i PersistentVolumeClaim con il nome delle nuove istanze del broker Kafka ai vecchi PersistentVolume utilizzando la proprietà spec.volumeName sul PersistentVolumeClaim.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Elimina le singole risorse

Se hai utilizzato un progetto esistente e non vuoi eliminarlo, elimina il alle singole risorse.

  1. Imposta le variabili di ambiente.

    export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=kafka
export REGION=us-central1

  2. Esegui il comando terraform destroy:

    export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=kafka/terraform/FOLDER destroy -var project_id=${PROJECT_ID}   \
  -var region=${REGION}  \
  -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

    Sostituisci FOLDER con gke-autopilot o gke-standard.

    Quando richiesto, digita yes.

  3. Trova tutti i dischi scollegati:

    export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,zone)")

    Questo passaggio è necessario perché, per impostazione predefinita Strimzi utilizza la classe Parametro deleteClaim: false per l'archiviazione. Se elimini il cluster, tutti i dischi rimangono disponibili.

  4. Elimina i dischi:

    for i in $disk_list; do
  disk_name=$(echo $i| cut -d'|' -f1)
  disk_zone=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
  echo "Deleting $disk_name"
  gcloud compute disks delete $disk_name --zone $disk_zone --quiet
done

Passaggi successivi

  • Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.