Aller au contenu principal

deploiement-kafak-kube

Comment déployer Kafka sur Docker et DigitalOcean Kubernetes​

Introduction Apache Kafka est une plateforme open-source de traitement d'événements et de flux distribués, écrite en Java, conçue pour traiter des flux de données exigeants en temps réel.

Elle est conçue pour être tolérante aux pannes et prendre en charge des centaines de nœuds par cluster. L'exécution efficace d'un plus grand nombre de nœuds nécessite des processus de conteneurisation et d'orchestration pour une utilisation optimale des ressources, tels que Kubernetes.

Prérequis

  • Docker installé sur votre machine. Ubuntu
  • Docker Compose installé sur votre machine. Pour Ubuntu.
  • Un cluster DigitalOcean Kubernetes v1.23+ avec votre connexion configurée comme kubectl par défaut. Les instructions relatives à la configuration de kubectl figurent à l'étape Connexion à votre cluster lors de la création de votre cluster. Pour créer un cluster Kubernetes sur DigitalOcean, lisez le Quickstart Kubernetes.
  • Le gestionnaire de paquets Helm 3 installé sur votre machine locale.
  • Une compréhension de Kafka, y compris les sujets, les producteurs et les consommateurs.

Étape 1 – Exécution de Kafka à l'aide de Docker Compose​

Dans cette section, vous apprendrez à exécuter Kafka en utilisant Docker Compose en mode KRaft. L'utilisation de KRaft rationalise la configuration globale et l'utilisation des ressources car aucune instance ZooKeeper n'est nécessaire.

Tout d'abord, vous définirez une image Docker qui contient une version Kafka décompressée. Vous l'utiliserez pour tester la connexion au conteneur Kafka en utilisant les scripts inclus.

Vous allez stocker les commandes nécessaires dans un Dockerfile. Créez-le et ouvrez-le pour le modifier :

sudo nano Dockerfile
FROM ubuntu:latest AS build
RUN apt-get update
RUN apt-get install curl default-jre -y
WORKDIR /kafka-test
RUN curl -o kafka.tgz https://dlcdn.apache.org/kafka/3.7.0/kafka_2.13-3.7.0.tgz
RUN tar -xzf kafka.tgz --strip-components=1

Le conteneur est basé sur la dernière version d'Ubuntu. Après avoir mis à jour le cache des paquets et installé curl et Java, vous téléchargez un paquet Kafka. Au moment de la rédaction de ce document, la dernière version de Kafka était la 3.7.0. Vous pouvez consulter la dernière version sur la page officielle de téléchargement et remplacer la valeur surlignée si nécessaire.

Ensuite, vous définissez le WORKDIR (répertoire de travail) à /kafka-test, dans lequel vous téléchargez et extrayez la version de Kafka. Le paramètre --strip-components=1 est passé à tar pour sauter le premier répertoire de l'archive, qui porte le nom de l'archive elle-même.

Ensuite, vous allez définir la configuration de Docker Compose dans un fichier nommé kafka-compose.yaml. Créez-le et ouvrez-le pour le modifier en exécutant :

sudo nano kafka-compose.yaml

kafka-compose.yaml

version: '3'

services:
  kafka:
    image: 'bitnami/kafka:latest'
    environment:
      - KAFKA_CFG_NODE_ID=0
      - KAFKA_CFG_PROCESS_ROLES=controller,broker
      - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092,CONTROLLER://:9093
      - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=0@kafka:9093
      - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
  kafka-test:
    build:
      dockerfile: Dockerfile
      context: .
    tty: true

Ici, vous définissez deux services, kafka et kafka-test. Le service kafka est basé sur la dernière image Bitnami Kafka. Dans la section environnement, vous passez les variables d'environnement nécessaires et leurs valeurs, qui configurent le nœud Kafka pour être autonome avec un ID de 0. Pour kafka-test, vous passez le fichier Docker que vous venez de créer comme base pour la construction de l'image du conteneur. En mettant tty à true, vous laissez une session ouverte avec le conteneur. C'est nécessaire pour le maintenir en vie, car sinon il quitterait le conteneur immédiatement après le démarrage, sans aucune autre commande.

RUN kafka-compose.yaml file:

docker-compose -f kafka-compose.yaml up -d
docker ps -a
  • Ouvrez un shell dans le conteneur kafka-test en exécutant :
docker exec -it docker_kafka-test_1 bash

Le shell sera déjà positionné dans le répertoire /kafka-test :

root@2a0cd13859e3:/kafka-test#
  • Ensuite, essayez de créer un sujet en utilisant kafka-topics.sh :
bin/kafka-topics.sh --create --topic first-topic --bootstrap-server kafka:9092

[Notez]

que vous faites référence à Kafka par son nom dans la configuration de Docker Compose (kafka).

Vous vous êtes connecté avec succès au déploiement Kafka depuis le service Docker Compose. Saisissez exit et appuyez sur Entrée pour fermer le shell.

Pour arrêter le déploiement de Docker Compose, exécutez la commande suivante :

docker-compose -f kafka-compose.yaml down

Dans cette étape, vous avez déployé Kafka à l'aide de Docker Compose. Vous avez également testé que Kafka est disponible à partir d'autres conteneurs en déployant une image personnalisée qui contient des scripts shell pour s'y connecter. Dans la suite du tutoriel, vous apprendrez à déployer Kafka sur DigitalOcean Kubernetes.

Étape 2 – Installation de Strimzi sur Kubernetes​

Dans cette section, vous allez installer Strimzi sur votre cluster Kubernetes. Cela implique d'ajouter son référentiel à Helm et de créer une version Helm.

Vous devez d’abord ajouter le référentiel Strimzi Helm à Helm, qui contient le graphique Strimzi :

helm repo add strimzi https://strimzi.io/charts
Output"strimzi" has been added to your repositories

Ensuite, actualisez le cache de Helm pour télécharger son contenu :

helm repo update
Output...Successfully got an update from the "strimzi" chart repository
Update Complete. ⎈Happy Helming!⎈

Enfin, installez Strimzi sur votre cluster en exécutant :

helm install strimzi strimzi/strimzi-kafka-operator
OutputNAME: strimzi
LAST DEPLOYED: ...
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Thank you for installing strimzi-kafka-operator-0.40.0

To create a Kafka cluster refer to the following documentation.

https://strimzi.io/docs/operators/latest/deploying.html#deploying-cluster-operator-helm-chart-str

Strimzi est désormais installé sur votre cluster Kubernetes. Dans la section suivante, vous l'utiliserez pour déployer Kafka sur votre cluster.

Étape 3 – Déploiement d’un cluster Kafka sur Kubernetes​

Dans cette section, vous allez déployer un cluster Kafka à un nœud avec ZooKeeper dans votre cluster Kubernetes. Au moment de la rédaction, la prise en charge du déploiement de Kafka à l'aide de KRaft n'était pas généralement disponible dans Strimzi.

Vous stockerez le manifeste Kubernetes pour le déploiement dans un fichier nommé kafka.yaml. Créez-le et ouvrez-le pour l'éditer :

nano kafka.yaml
apiVersion: kafka.strimzi.io/v1beta2
kind: Kafka
metadata:
  name: my-cluster
spec:
  kafka:
    version: 3.7.0
    replicas: 1
    listeners:
      - name: plain
        port: 9092
        type: internal
        tls: false
      - name: tls
        port: 9093
        type: internal
        tls: true
    config:
      offsets.topic.replication.factor: 1
      transaction.state.log.replication.factor: 1
      transaction.state.log.min.isr: 1
      default.replication.factor: 1
      min.insync.replicas: 1
      inter.broker.protocol.version: "3.7"
    storage:
      type: jbod
      volumes:
      - id: 0
        type: persistent-claim
        size: 100Gi
        deleteClaim: false
  zookeeper:
    replicas: 1
    storage:
      type: persistent-claim
      size: 100Gi
      deleteClaim: false
  entityOperator:
    topicOperator: {}
    userOperator: {}

Le premier bloc de la spécification(spec) concerne Kafka lui-même. Vous définissez la version, ainsi que le nombre de répliques. Ensuite, vous définissez deux listeners, qui sont des ports que le déploiement Kafka utilisera pour communiquer. Le deuxième écouteur est crypté parce que vous avez mis tls à true. Puisque les auditeurs ne peuvent pas entrer en collision, vous attribuez 9093 comme numéro de port pour le second.

Étant donné que vous ne déployez qu'un seul nœud Kafka dans la section de configuration (config), vous définissez divers facteurs de réplication (pour les sujets, les événements et les répliques) à 1. Pour le stockage, vous définissez le type à jbod (qui signifie "juste un tas de disques"), ce qui vous permet de spécifier plusieurs volumes. Ici, vous définissez un volume de type persistent-claim avec une taille de 100GB. Cela créera un volume DigitalOcean et l'assignera à Kafka. Vous définissez également deleteClaim à false pour vous assurer que les données ne sont pas supprimées lorsque le cluster Kafka est détruit.

Pour configurer le déploiement de zookeeper, vous définissez son nombre de répliques à 1 et lui fournissez une seule revendication persistante de 100 Go, car seul Kafka prend en charge le type de stockage jbod. Les deux définitions sous entityOperator indiquent à Strimzi de créer des opérateurs à l'échelle du cluster pour gérer les sujets et les utilisateurs Kafka.

kubectl apply -f kafka.yaml
Outputkafka.kafka.strimzi.io/my-cluster created
kubectl get strimzipodset -w

Après quelques minutes, les pods Kafka et Zookeeper seront disponibles et prêts :

OutputNAME                   PODS   READY PODS   CURRENT PODS   AGE
...
my-cluster-kafka       1      1            1              28s
my-cluster-zookeeper   1      1            1              61s

Pour répertorier les déploiements Kafka, exécutez la commande suivante :

kubectl get kafka
OutputNAME         DESIRED KAFKA REPLICAS   DESIRED ZK REPLICAS   READY   METADATA STATE   WARNINGS
my-cluster   1                        1

Maintenant que Kafka est en cours d'exécution, vous allez créer un sujet dans celui-ci. Ouvrez un fichier appelé kafka-topic.yaml pour le modifier :

nano kafka-topic.yaml
apiVersion: kafka.strimzi.io/v1beta2
kind: KafkaTopic
metadata:
  name: my-topic
  labels:
    strimzi.io/cluster: "my-cluster"
spec:
  partitions: 1
  replicas: 1

Ce KafkaTopic définit un sujet appelé my-topic dans le cluster que vous venez de déployer (my-cluster).

kubectl apply -f kafka-topic.yaml
Outputkafkatopic.kafka.strimzi.io/my-topic created

Ensuite, répertoriez toutes les rubriques Kafka dans le cluster :

kubectl get kafkatopic

kubectl affichera la sortie suivante :

OutputNAME       CLUSTER      PARTITIONS   REPLICATION FACTOR   READY
my-topic   my-cluster   1            1                    True

Au cours de cette étape, vous avez déployé Kafka sur votre cluster Kubernetes à l’aide de Strimzi, qui s’occupe des ressources réelles et des instances ZooKeeper. Vous avez également créé une rubrique, que vous utiliserez à l’étape suivante lors de la connexion à Kafka.

Étape 4 – Connexion à Kafka dans Kubernetes​

Dans cette section, vous apprendrez à vous connecter à un cluster Kafka déployé sur Kubernetes depuis le cluster.

Grâce à Strimzi, votre déploiement Kafka est déjà disponible pour les pods du cluster. Toute application de l'intérieur peut se connecter au point de terminaison my-cluster-kafka-bootstrap, qui sera automatiquement résolu en cluster my-cluster.

Vous allez maintenant déployer un pod temporaire sur Kubernetes en vous basant sur une image Docker fournie par Strimzi. L'image contient une installation Kafka avec des scripts shell pour produire et consommer des messages textuels (kafka-console-producer.sh et kafka-console-consumer.sh).

kubectl run kafka-producer -ti \
--image=quay.io/strimzi/kafka:0.40.0-kafka-3.7.0 --rm=true --restart=Never \
-- bin/kafka-console-producer.sh --bootstrap-server my-cluster-kafka-bootstrap:9092 --topic my-topic

Le pod temporaire s'appellera kafka-producer et utilisera l'image du projet Strimzi. Il sera supprimé à la fin de l'exécution des commandes (--rm=true) et ne sera jamais redémarré, car il s'agit d'un travail unique. Ensuite, vous passez la commande pour exécuter le script kafka-console-producer.sh. Comme indiqué précédemment, vous indiquez le désignateur my-cluster-kafka-bootstrap pour le serveur et my-topic comme nom de sujet.

OutputIf you don't see a command prompt, try pressing enter.
>

Vous pouvez saisir n'importe quel message texte et appuyer sur Entrée pour l'envoyer au sujet :

OutputIf you don't see a command prompt, try pressing enter.
>Hello World!
>

Pour quitter, appuyez sur CTRL+C et confirmez avec Entrée. Ensuite, exécutez la commande suivante pour exécuter le script consommateur dans le cluster :

Vous devrez peut-être appuyer sur Entrée pour que la commande soit exécutée. Le résultat sera similaire à celui-ci :

OutputHello World!
...

Vous avez appris à vous connecter à votre déploiement Kafka depuis le cluster. Vous allez maintenant exposer Kafka au monde extérieur.

Étape 5 – Exposer Kafka en dehors de Kubernetes​

Dans cette étape, vous exposerez votre déploiement Kafka en externe à l'aide d'un équilibreur de charge. Strimzi dispose d'un moyen intégré de créer et de configurer un équilibreur de charge pour Kafka. Ouvrez kafka.yaml pour le modifier en exécutant :

sudo nano kafka.yaml

Ajoutez les lignes suivantes à la section des auditeurs (listeners) :

...
    listeners:
      - name: plain
        port: 9092
        type: internal
        tls: false
      - name: tls
        port: 9093
        type: internal
        tls: true
      - name: external
        port: 9094
        type: loadbalancer
        tls: false
...

La partie en surbrillance définit un nouvel écouteur avec le type loadbalancer qui acceptera les connexions au port 9094 sans cryptage TLS.

Enregistrez et fermez le fichier, puis appliquez le nouveau manifeste en exécutant :

kubectl apply -f kafka.yaml
Outputkafka.kafka.strimzi.io/my-cluster configured

Exécutez la commande suivante pour la voir devenir disponible :

kubectl get service my-cluster-kafka-external-bootstrap -w -o=jsonpath='{.status.loadBalancer.ingress[0].ip}{"\n"}'

Lorsque l'équilibreur de charge qui gère le trafic pour Kafka devient disponible, la sortie sera son adresse IP.

Dans le cadre des prérequis, vous avez téléchargé et extrait la dernière version de Kafka sur votre machine. Accédez à ce répertoire et exécutez le consommateur de la console, en remplaçant votre_lb_ip par le Adresse IP issue de la sortie de la commande précédente :

bin/kafka-console-consumer.sh --bootstrap-server your_lb_ip:9094 --topic my-topic --from-beginning

Vous verrez bientôt les messages lus à partir du sujet, ce qui signifie que vous avez été connecté avec succès :

OutputHello World!
...

Pour supprimer toutes les ressources liées à Strimzi de votre cluster (telles que les déploiements et les rubriques Kafka), exécutez la commande suivante :

kubectl delete $(kubectl get strimzi -o name)

Conclusion​

Dans cet article, vous avez déployé Kafka à l’aide de Docker Compose et vérifié que vous pouvez vous y connecter. Vous avez également appris à installer Strimzi sur votre cluster Kubernetes DigitalOcean et à déployer un cluster Kafka à l’aide des manifestes fournis.

running-kafka-using-docker-compose