Les modèles de conception orientés microservices ont rendu nos applications plus évolutives que jamais. Les serveurs API RESTful, le front-end et même les bases de données sont désormais évolutifs horizontalement. La mise à l'échelle horizontale consiste à ajouter de nouveaux nœuds à votre cluster d'applications pour prendre en charge une charge de travail supplémentaire. A l'inverse, il permet également de réduire la consommation de ressources, lorsque la charge de travail diminue, afin de réduire les coûts. Les systèmes évolutifs horizontalement doivent être des systèmes distribués. Ces systèmes qui peuvent survivre à la défaillance de plusieurs machines virtuelles, conteneurs ou liens réseau tout en restant en ligne et en bonne santé pour l'utilisateur final.

Lorsque nous parlons de systèmes distribués comme ci-dessus, nous rencontrons le problème de l'analyse et de la surveillance. Chaque nœud génère de nombreuses informations sur sa propre santé (utilisation du processeur, mémoire, etc.) et sur l'état de l'application ainsi que sur ce que les utilisateurs essaient de faire. Ces données doivent être enregistrées dans :

1. Le même ordre dans lequel ils sont créés,
2. Séparés en termes d'urgence (analyses en temps réel ou lots de données), et surtout,
3. Le mécanisme avec lequel ils sont collectés doit lui-même être distribué et évolutif, sinon nous nous retrouvons avec un seul point de défaillance. Quelque chose que la conception du système distribué était censé éviter.

Pourquoi utiliser Kafka?

Apache Kafka est présenté comme une plate-forme de streaming distribuée. Dans le jargon de Kafka, Producteurs générer en continu des données (ruisseaux) et Consommateurs sont responsables de leur traitement, de leur stockage et de leur analyse. Kafka Courtiers sont responsables de s'assurer que dans un scénario distribué, les données peuvent atteindre des producteurs aux consommateurs sans aucune incohérence. Un ensemble de courtiers Kafka et un autre logiciel appelé gardien de zoo constituent un déploiement Kafka typique.

Le flux de données de nombreux producteurs doit être agrégé, partitionné et envoyé à plusieurs consommateurs, il y a beaucoup de brassage impliqué. Éviter les incohérences n'est pas une tâche facile. C'est pourquoi nous avons besoin de Kafka.

Les scénarios où Kafka peut être utilisé sont assez divers. Tout, des périphériques IOT au cluster de machines virtuelles en passant par vos propres serveurs bare metal sur site. Partout où beaucoup de « choses » veulent simultanément votre attention… .Ce n'est pas très scientifique n'est-ce pas? Eh bien, l'architecture Kafka est un terrier à part entière et mérite un traitement indépendant. Voyons d'abord un déploiement très superficiel du logiciel.

Utiliser Docker Compose

Quelle que soit la manière imaginative que vous décidiez d'utiliser Kafka, une chose est sûre - vous ne l'utiliserez pas comme une seule instance. Il n'est pas destiné à être utilisé de cette façon, et même si votre application distribuée n'a besoin que d'une seule instance (courtier) pour le moment, elle finira par grandir et vous devez vous assurer que Kafka peut suivre le rythme.

Docker-compose est le partenaire idéal pour ce type d'évolutivité. Au lieu d'exécuter des courtiers Kafka sur différentes machines virtuelles, nous les conteneurisons et utilisons Docker Compose pour automatiser le déploiement et la mise à l'échelle. Les conteneurs Docker sont hautement évolutifs sur les deux hôtes Docker uniques ainsi que sur un cluster si nous utilisons Docker Swarm ou Kubernetes. Il est donc logique de l'exploiter pour rendre Kafka évolutif.

Commençons par une seule instance de courtier. Créez un répertoire appelé apache-kafka et à l'intérieur, créez votre docker-compose.yml.

$ mkdir apache-kafka
$ cd apache-kafka
$ vim docker-composer.yml

Le contenu suivant va être mis dans votre docker-compose.fichier yml :

version : '3'
prestations de service:
gardien de zoo :
image: wurstmeister/gardien de zoo
 
kafka :
image: wurstmeister/kafka
ports :
- "9092:9092"
environnement:
KAFKA_ADVERTISED_HOST_NAME : hôte local
KAFKA_ZOOKEPER_CONNECT : gardien de zoo : 2181

Une fois que vous avez enregistré le contenu ci-dessus dans votre fichier de composition, à partir du même répertoire, exécutez :

$ docker-compose up -d

D'accord, alors qu'avons-nous fait ici?

Comprendre le Docker-Compose.yml

Compose démarrera deux services répertoriés dans le fichier yml. Regardons le dossier d'un peu plus près. La première image est zookeeper dont Kafka a besoin pour garder une trace de divers courtiers, de la topologie du réseau ainsi que de la synchronisation d'autres informations. Étant donné que les services zookeeper et kafka feront partie du même réseau de ponts (ceci est créé lorsque nous exécutons docker-compose up ), nous n'avons pas besoin d'exposer de ports. Le courtier Kafka peut parler au gardien de zoo et c'est tout ce dont le gardien de zoo de communication a besoin.

Le deuxième service est kafka lui-même et nous n'en exécutons qu'une seule instance, c'est-à-dire un courtier. Idéalement, vous voudriez utiliser plusieurs courtiers afin de tirer parti de l'architecture distribuée de Kafka. Le service écoute sur le port 9092 qui est mappé sur le même numéro de port sur l'hôte Docker et c'est ainsi que le service communique avec le monde extérieur.

Le deuxième service a également quelques variables d'environnement. Tout d'abord, KAFKA_ADVERTISED_HOST_NAME est-il défini sur localhost. C'est l'adresse à laquelle Kafka fonctionne, et où les producteurs et les consommateurs peuvent le trouver. Encore une fois, cela devrait être défini sur localhost mais plutôt sur l'adresse IP ou le nom d'hôte avec lequel les serveurs peuvent être atteints dans votre réseau. Le deuxième est le nom d'hôte et le numéro de port de votre service de gardien de zoo. Depuis que nous avons nommé le service zookeeper… eh bien, zookeeper c'est ce que sera le nom d'hôte, au sein du réseau Docker Bridge que nous avons mentionné.

Exécution d'un flux de messages simple

Pour que Kafka commence à travailler, nous devons créer un sujet en son sein. Les clients producteurs peuvent alors publier des flux de données (messages) sur ledit sujet et les consommateurs peuvent lire ledit flux de données, s'ils sont abonnés à ce sujet particulier.

Pour ce faire, nous devons démarrer une borne interactive avec le conteneur Kafka. Lister les conteneurs pour récupérer le nom du conteneur kafka. Par exemple, dans ce cas notre conteneur se nomme apache-kafka_kafka_1

$ docker ps

Avec le nom du conteneur kafka, nous pouvons maintenant déposer à l'intérieur de ce conteneur.

$ docker exec -it apache-kafka_kafka_1 bash
bash-4.4#

Ouvrez deux terminaux différents pour en utiliser un en tant que consommateur et un autre en tant que producteur.

Côté producteur

Dans l'une des invites (celle que vous choisissez comme producteur), saisissez les commandes suivantes :

## Pour créer un nouveau sujet nommé test
bash-4.4 # kafka-sujets.sh --create --zookeeper zookeeper:2181 --replication-factor 1
--partitions 1 --topic test
 
## Pour démarrer un producteur qui publie un flux de données depuis l'entrée standard vers kafka
bash-4.4 # kafka-console-producteur.sh --broker-list localhost:9092 --topic test
>

Le producteur est maintenant prêt à prendre la saisie du clavier et à la publier.

Côté consommateur

Passez au deuxième terminal connecté à votre conteneur kafka. La commande suivante démarre un consommateur qui se nourrit de sujet de test :

$ kafka-console-consommateur.sh --bootstrap-server localhost:9092 --topic test

Retour au producteur

Vous pouvez maintenant taper des messages dans la nouvelle invite et chaque fois que vous appuyez sur retour, la nouvelle ligne est imprimée dans l'invite du consommateur. Par example:

> Ceci est un message.

Ce message est transmis au consommateur, via Kafka, et vous pouvez le voir imprimé à l'invite du consommateur.

Configurations du monde réel

Vous avez maintenant une idée approximative du fonctionnement de la configuration de Kafka. Pour votre propre cas d'utilisation, vous devez définir un nom d'hôte qui n'est pas localhost, vous avez besoin de plusieurs de ces courtiers pour faire partie de votre cluster kafka et enfin vous devez configurer des clients consommateurs et producteurs.

Voici quelques liens utiles :

1. Client Python de Confluent
2. Documents officiels
3. Une liste utile de démos

J'espère que vous vous amuserez à explorer Apache Kafka.