Les modèles de conception axés sur les 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 horizontalement évolutives. La mise à l'échelle horizontale est l'acte d'ajouter de nouveaux nœuds à votre cluster d'applications pour prendre en charge la charge de travail supplémentaire. Inversement, il permet également de réduire la consommation de ressources, lorsque la charge de travail diminue, afin d'économiser les coûts. Les systèmes évolutifs horizontalement doivent être distribués. Ces systèmes qui peuvent survivre à l'échec de plusieurs machines virtuelles, conteneurs ou liens réseau tout en respectant 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 beaucoup d'informations sur sa propre santé (utilisation du processeur, mémoire, etc.) et sur l'état de l'application ainsi que ce que les utilisateurs essaient de faire. Ces détails doivent être enregistrés dans:

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

Pourquoi utiliser Kafka?

Apache Kafka est présentée comme une plate-forme de streaming distribuée. Dans Kafka Lingo, Producteurs générer en continu des données (ruisseaux) et Consommateurs sont responsables du traitement, du stockage et de l'analyse. Kafka Courtiers sont chargés de garantir 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 constituer un déploiement typique de Kafka.

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

Les scénarios où Kafka peut être utilisé est assez diversifié. Tout, des appareils IoT à l'amas de machines virtuelles, à vos propres serveurs sur place en métal nu. 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 trou de lapin et mérite un traitement indépendant. Voyons d'abord un déploiement très surface du logiciel.

Utilisation de Docker Compose

Quelle que soit l'imagination dont vous décidez 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 qu'une seule instance (courtier) pour l'instant, il finira par grandir et vous devez vous assurer que Kafka peut suivre.

Docker-Compose est le partenaire parfait pour ce type d'évolutivité. Au lieu de cela pour exécuter des courtiers kafka sur différentes machines virtuelles, nous le compainise et nous nous levons Docker Composer pour automatiser le déploiement et la mise à l'échelle. Les conteneurs Docker sont très évolutifs sur les deux hôtes Docker unique ainsi que sur un cluster si nous utilisons Docker Swarm ou Kubernetes. Il est donc logique de le tirer parti pour rendre Kafka évolutif.

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

$ mkdir apache-kafka
$ cd apache-kafka
$ vim docker-compose.YML

Le contenu suivant va être placé dans votre compose docker.Fichier YML:

Version: '3'
prestations de service:
Zookeeper:
Image: Wurstmeister / Zookeeper
Kafka:
Image: Wurstmeister / Kafka
PORTS:
- "9092: 9092"
environnement:
Kafka_advertised_host_name: localhost
Kafka_zookeeper_connect: zookeeper: 2181

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

$ docker-compose up -d

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

Comprendre le docker-compose.YML

Compose commencera deux services indiqués dans le fichier yml. Regardons le fichier un peu de près. La première image est Zookeeper dont Kafka a besoin pour garder une trace de divers courtiers, la topologie du réseau ainsi que 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), nous n'avons pas besoin d'exposer de ports. Kafka Broker peut parler à Zookeeper et c'est tout ce dont Zookeeper a besoin de communication.

Le deuxième service est Kafka lui-même et nous en exécutons 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 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 défini sur localhost. Ceci est l'adresse à laquelle Kafka est en cours d'exécution et où les producteurs et les consommateurs peuvent le trouver. Encore une fois, cela devrait être l'ensemble de localhost mais plutôt sur l'adresse IP ou le nom d'hôte avec cela, 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. Puisque nous avons nommé le service ZooKeeper… eh bien, Zookeeper c'est ce que sera le nom d'hôte, dans Docker Bridge Network que nous avons mentionné.

Exécuter un simple flux de messages

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

Pour ce faire, nous devons démarrer un terminal interactif avec le conteneur Kafka. Énumérez les conteneurs pour récupérer le nom du conteneur Kafka. Par exemple, dans ce cas, notre conteneur est nommé apache-kafka_kafka_1

$ docker ps

Avec le nom du conteneur de Kafka, nous pouvons maintenant tomber à l'intérieur de ce conteneur.

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

Ouvrez deux terminaux de ces différents pour en utiliser un comme consommateur et un autre producteur.

Côté producteur

Dans l'une des invites (celle que vous choisissez d'être producteur), entrez les commandes suivantes:

## Pour créer un nouveau sujet nommé Test
bash-4.4 # kafka-topics.sh --create --zookeeper zookeeper: 2181 - Réplication-facteur 1
--Partitions 1 - Test topic
## Pour démarrer un producteur qui publie un datasteream à partir de l'entrée standard à Kafka
bash-4.4 # kafka-console producteur.SH - Broker-list localhost: 9092 - Test topic
>

Le producteur est maintenant prêt à prendre les commentaires du clavier et à le publier.

Côté consommateur

Déplacez-vous sur le deuxième terminal connecté à votre conteneur kafka. La commande suivante démarre un consommateur qui se nourrit du sujet du test:

$ kafka-consoleur.sh --bootstrap-server localhost: 9092 - Test topic

Retour au producteur

Vous pouvez désormais taper des messages dans la nouvelle invite et chaque fois que vous appuyez sur le retour, la nouvelle ligne est imprimée dans l'invite de consommation. Par exemple:

> C'est un message.

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

Configuration du monde réel

Vous avez maintenant une image approximative de la fonction de 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 courtiers de ces.

Voici quelques liens utiles:

1. Client Python de Confluent
2. Documentation officielle
3. Une liste utile de démos

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