Recherche de site Web

Introduction à Kafka

L'auteur a sélectionné Apache Software Foundation pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

Apache Kafka est une plate-forme distribuée open source de traitement d'événements et de flux écrite en Java, conçue pour traiter des flux de données exigeants en temps réel. Il est intrinsèquement évolutif, avec un débit et une disponibilité élevés. Développé par Apache Software Foundation, Kafka a été largement adopté pour sa fiabilité, sa facilité d'utilisation et sa tolérance aux pannes. Il est utilisé par les plus grandes organisations du monde pour gérer de gros volumes de données de manière distribuée et efficace.

Dans ce didacticiel, vous allez télécharger et configurer Apache Kafka. Vous apprendrez à créer et à supprimer des sujets, ainsi qu'à envoyer et recevoir des événements à l'aide des scripts fournis. Vous découvrirez également des projets similaires ayant le même objectif et comment Kafka se compare.

Conditions préalables

Pour terminer ce tutoriel, vous aurez besoin de :

  • Une machine avec au moins 4 Go de RAM et 2 processeurs. Dans le cas d'un serveur Ubuntu, suivez la configuration initiale du serveur pour les instructions de configuration.
  • Java 8 ou supérieur installé sur votre Droplet ou votre ordinateur local. Pour obtenir des instructions sur l'installation de Java sur Ubuntu, consultez le didacticiel Comment installer Java avec Apt sur Ubuntu.

Étape 1 - Téléchargement et configuration d'Apache Kafka

Dans cette section, vous allez télécharger et extraire Apache Kafka sur votre ordinateur. Vous le configurerez sous son propre compte utilisateur pour plus de sécurité. Ensuite, vous le configurerez et l’exécuterez à l’aide de KRaft.

Tout d’abord, vous allez créer un utilisateur distinct sous lequel Kafka s’exécutera. Créez un utilisateur appelé kafka en exécutant la commande suivante :

sudo adduser kafka

Il vous sera demandé le mot de passe du compte. Entrez un mot de passe fort et évitez de remplir les informations supplémentaires en appuyant sur ENTER pour chaque champ.

Enfin, passez à l'utilisateur spécifique à Kafka :

su kafka

Ensuite, vous téléchargerez le package de version Kafka à partir de la page officielle de téléchargement. Au moment de la rédaction, la dernière version était 3.7.0, conçue pour Scala 2.13. Si vous utilisez macOS ou Linux, vous pouvez télécharger Kafka avec curl.

Utilisez cette commande pour télécharger Kafka et placez-le sous /tmp :

curl -o /tmp/kafka.tgz https://downloads.apache.org/kafka/3.7.0/kafka_2.13-3.7.0.tgz

Vous stockerez la version sous ~/kafka, dans le répertoire personnel. Créez-le en exécutant :

mkdir ~/kafka

Ensuite, extrayez-le dans ~/kafka en exécutant :

tar -xzf /tmp/kafka.tgz -C ~/kafka --strip-components=1

Étant donné que l'archive que vous avez téléchargée contient un dossier racine portant le même nom que la version de Kafka, --strip-components=1 l'ignorera et extraira tout ce qu'il contient.

Au moment de la rédaction de cet article, Kafka 3 était la dernière version majeure, qui prend en charge deux systèmes de gestion des métadonnées : Apache ZooKeeper et Kafka KRaft (abréviation de Kafka Raft). ZooKeeper est un projet open source fournissant un moyen standardisé de coordination de données distribuées pour les applications, également développé par Apache Software Foundation.

Cependant, à partir de Kafka 3.3, la prise en charge de KRaft a été introduite. KRaft est un système spécialement conçu pour coordonner uniquement les instances Kafka, simplifiant le processus d'installation et permettant une bien plus grande évolutivité. Avec KRaft, Kafka assume lui-même l'entière responsabilité des données au lieu de conserver les métadonnées administratives en externe.

Bien qu'il soit toujours disponible, le support de ZooKeeper devrait être supprimé à partir de Kafka 4 et au-delà. Dans ce didacticiel, vous allez configurer Kafka à l'aide de KRaft.

Vous devrez créer un identifiant unique pour votre nouveau cluster Kafka. Pour l’instant, il ne s’agira que d’un seul nœud. Accédez au répertoire où réside désormais Kafka :

cd ~/kafka

Kafka avec KRaft stocke sa configuration sous config/kraft/server.properties, tandis que le fichier de configuration ZooKeeper est config/server.properties.

Avant de l’exécuter pour la première fois, vous devrez remplacer certains paramètres par défaut. Ouvrez le fichier pour le modifier en exécutant :

nano config/kraft/server.properties

Recherchez les lignes suivantes :

...
############################# Log Basics #############################

# A comma separated list of directories under which to store log files
log.dirs=/tmp/kafka-logs
...

Le paramètre log.dirs spécifie où Kafka conservera ses fichiers journaux. Par défaut, il les stockera sous /tmp/kafka-logs, car cela est garanti comme étant accessible en écriture, bien que temporaire. Remplacez la valeur par le chemin en surbrillance :

...
############################# Log Basics #############################

# A comma separated list of directories under which to store log files
log.dirs=/home/kafka/kafka-logs
...

Puisque vous avez créé un utilisateur distinct pour Kafka, vous définissez le chemin du répertoire des journaux sous le répertoire personnel de l'utilisateur. S’il n’existe pas, Kafka le créera. Lorsque vous avez terminé, enregistrez et fermez le fichier.

Maintenant que vous avez configuré Kafka, exécutez la commande suivante pour générer un ID de cluster aléatoire :

KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"

Créez ensuite un espace de stockage pour les fichiers journaux en exécutant la commande suivante et en transmettant l'ID :

bin/kafka-storage.sh format -t $KAFKA_CLUSTER_ID -c config/kraft/server.properties

Le résultat sera :

Formatting /home/kafka/kafka-logs with metadata.version 3.7-IV4.

Enfin, vous pouvez démarrer le serveur Kafka pour la première fois :

bin/kafka-server-start.sh config/kraft/server.properties

La fin du résultat ressemblera à ceci :

...
[2024-02-26 10:38:26,889] INFO Awaiting socket connections on 0.0.0.0:9092. (kafka.network.DataPlaneAcceptor)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Waiting for all of the authorizer futures to be completed (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Finished waiting for all of the authorizer futures to be completed (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Waiting for all of the SocketServer Acceptors to be started (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Finished waiting for all of the SocketServer Acceptors to be started (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Transition from STARTING to STARTED (kafka.server.BrokerServer)
[2024-02-26 10:38:26,891] INFO Kafka version: 3.7.0 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,891] INFO Kafka commitId: 5e3c2b738d253ff5 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,891] INFO Kafka startTimeMs: 1708943906890 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,892] INFO [KafkaRaftServer nodeId=1] Kafka Server started (kafka.server.KafkaRaftServer)

La sortie indique que Kafka s'est initialisé avec succès à l'aide de KRaft et qu'il accepte les connexions à 0.0.0.0:9092.

Une fois que vous appuyez sur CTRL+C, le processus se terminera. Étant donné qu’il n’est pas préférable d’exécuter Kafka en maintenant une session ouverte, vous créerez un service pour exécuter Kafka en arrière-plan à l’étape suivante.

Étape 2 - Création d'un service systemd pour Kafka

Dans cette section, vous allez créer un service systemd pour exécuter Kafka en arrière-plan à tout moment. Les services systemd peuvent être démarrés, arrêtés et redémarrés de manière cohérente.

Vous stockerez la configuration du service dans un fichier nommé code-server.service, dans le répertoire /lib/systemd/system, où systemd stocke ses services. Créez-le à l'aide de votre éditeur de texte :

sudo nano /etc/systemd/system/kafka.service

Ajoutez les lignes suivantes :

[Unit]
Description=kafka-server

[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/kraft/server.properties > /home/kafka/kafka/kafka.log 2>&1'
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Ici, vous spécifiez d'abord la description du service. Ensuite, dans la section [Service], vous définissez le type de service (simple signifie que la commande doit simplement s'exécuter) et fournissez la commande qui sera exécutée. Vous spécifiez également que l'utilisateur sous lequel il s'exécute est kafka et que le service doit être automatiquement redémarré si Kafka se ferme.

La section [Install] ordonne à systemd de démarrer ce service lorsqu'il devient possible de se connecter à votre serveur. Enregistrez et fermez le fichier lorsque vous avez terminé.

Démarrez le service Kafka en exécutant la commande suivante :

sudo systemctl start kafka

Vérifiez qu'il a bien démarré en observant son statut :

sudo systemctl status kafka

Vous verrez un résultat similaire à :

● kafka.service - kafka-server
     Loaded: loaded (/etc/systemd/system/kafka.service; disabled; preset: enabled)
     Active: active (running) since Mon 2024-02-26 11:17:30 UTC; 2min 40s ago
   Main PID: 1061 (sh)
      Tasks: 94 (limit: 4646)
     Memory: 409.2M
        CPU: 10.491s
     CGroup: /system.slice/kafka.service
             ├─1061 /bin/sh -c "/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/kraft/server.properties > /home/kafka/kafka/kafka.log 2>&1"
             └─1062 java -Xmx1G -Xms1G -server -XX:+UseG1GC -XX:MaxGCPauseMillis=20 -XX:InitiatingHeapOccupancyPercent=35 -XX:+ExplicitGCInvokesConcurrent -XX:MaxInlineLevel=15 -Djava.awt.headless=true "-Xlog:gc*:file=/home/kafka/kafka/bin/../logs/kaf>

Feb 26 11:17:30 kafka-test1 systemd[1]: Started kafka.service - kafka-server.

Pour que Kafka démarre automatiquement après un redémarrage du serveur, activez son service en exécutant la commande suivante :

sudo systemctl enable kafka

Au cours de cette étape, vous avez créé un service systemd pour Kafka et l'avez activé, afin qu'il démarre à chaque démarrage du serveur. Vous découvrirez ensuite comment créer et supprimer des sujets dans Kafka, ainsi que comment produire et consommer des messages texte à l'aide des scripts inclus.

Étape 3 - Production et consommation de messages thématiques

Maintenant que vous avez configuré un serveur Kafka, vous découvrirez les sujets et comment les gérer à l'aide des scripts fournis. Vous apprendrez également comment envoyer et diffuser des messages à partir d’un sujet.

Comme expliqué dans l'article Event Streaming, la publication et la réception de messages sont liées à des sujets. Un sujet peut être lié à une catégorie à laquelle appartient un message.

Le script kafka-topics.sh fourni peut être utilisé pour gérer les sujets dans Kafka via la CLI. Exécutez la commande suivante pour créer un sujet appelé first-topic :

bin/kafka-topics.sh --create --topic first-topic --bootstrap-server localhost:9092

Tous les scripts Kafka fournis nécessitent que vous spécifiiez l'adresse du serveur avec --bootstrap-server.

Le résultat sera :

Created topic first-topic.

Pour lister tous les sujets disponibles, transmettez --list au lieu de --create :

bin/kafka-topics.sh --list --bootstrap-server localhost:9092

Vous verrez le sujet que vous venez de créer :

first-topic

Vous pouvez obtenir des informations détaillées et des statistiques sur le sujet en transmettant --describe :

bin/kafka-topics.sh --describe --topic first-topic --bootstrap-server localhost:9092

Le résultat ressemblera à ceci :

Topic: first-topic      TopicId: VtjiMIUtRUulwzxJL5qVjg PartitionCount: 1       ReplicationFactor: 1    Configs: segment.bytes=1073741824
        Topic: first-topic      Partition: 0    Leader: 1       Replicas: 1     Isr: 1

La première ligne spécifie le nom du sujet, l'ID et le facteur de réplication, qui est 1 car le sujet est présent uniquement sur la machine actuelle. La deuxième ligne est volontairement en retrait et affiche des informations sur la première (et unique) partition du sujet. Kafka vous permet de partitionner le sujet, ce qui signifie que différentes fractions d'un sujet peuvent être distribuées sur différents serveurs, améliorant ainsi l'évolutivité. Ici, une seule partition existe.

Maintenant que vous avez créé un sujet, vous allez produire des messages à l'aide du script kafka-console-producer.sh. Exécutez la commande suivante pour démarrer le producteur :

bin/kafka-console-producer.sh --topic first-topic --bootstrap-server localhost:9092

Vous verrez une invite vide :

>

Le producteur attend que vous saisissiez un message texte. Saisissez test et appuyez sur ENTER. L'invite ressemblera à ceci :

>test
>

Le producteur attend désormais le prochain message, ce qui signifie que le précédent a été transmis avec succès à Kafka. Vous pouvez saisir autant de messages que vous le souhaitez pour les tests. Pour quitter le producteur, appuyez sur CTRL+C.

Pour relire les messages du sujet, vous aurez besoin d’un consommateur. Kafka fournit un consommateur simple sous la forme de kafka-console-consumer.sh. Exécutez-le en exécutant :

bin/kafka-console-consumer.sh --topic first-topic --bootstrap-server localhost:9092

Cependant, il n’y aura aucune sortie. La raison en est que le consommateur diffuse des données sur le sujet et que rien n’est actuellement produit et envoyé. Pour consommer les messages que vous avez produits avant de démarrer le consommateur, vous devrez lire le sujet depuis le début en exécutant :

bin/kafka-console-consumer.sh --topic first-topic --from-beginning --bootstrap-server localhost:9092

Le consommateur rejouera tous les événements du sujet et récupérera les messages :

test
...

Comme pour le producteur, appuyez sur CTRL+C pour quitter.

Pour vérifier que le consommateur diffuse effectivement les données, vous l'ouvrirez dans une session de terminal distincte. Ouvrez une session SSH secondaire et exécutez le consommateur dans la configuration par défaut :

bin/kafka-console-consumer.sh --topic first-topic --bootstrap-server localhost:9092

Dans la session principale, exécutez le producteur :

bin/kafka-console-producer.sh --topic first-topic --bootstrap-server localhost:9092

Ensuite, saisissez les messages de votre choix :

>second test
>third test
>

Vous les verrez immédiatement être reçus par le consommateur :

second test
third test

Une fois les tests terminés, mettez fin au producteur et au consommateur.

Pour supprimer first-topic, transmettez --delete à kafka-topics.sh :

bin/kafka-topics.sh --delete --topic first-topic --bootstrap-server localhost:9092

Il n'y aura aucune sortie. Vous pouvez lister les sujets pour vérifier qu'il a bien été supprimé :

bin/kafka-topics.sh --list --bootstrap-server localhost:9092

Le résultat sera :

__consumer_offsets

__consumer_offsets est un sujet interne à Kafka, qui stocke jusqu'où un consommateur a lu un sujet.

Au cours de cette étape, vous avez créé un sujet Kafka et y avez généré des messages. Ensuite, vous avez consommé les messages à l’aide du script fourni et enfin, vous les avez reçus en temps réel. Ensuite, vous découvrirez comment Kafka se compare à d’autres courtiers d’événements et logiciels similaires.

Comparaison avec des architectures similaires

Apache Kafka est considéré comme la solution de facto pour les cas d'utilisation du streaming d'événements. Cependant, Apache Pulsar et RabbitMQ sont également largement utilisés et se distinguent comme des options polyvalentes, bien qu'avec des différences dans leur approche.

La principale différence entre la mise en file d'attente de messages et le streaming d'événements est que la tâche principale de la première est de transmettre les messages aux consommateurs de la manière la plus rapide possible, sans tenir compte de leur commande. De tels systèmes stockent généralement les messages en mémoire jusqu'à ce qu'ils soient reconnus par les consommateurs. Le filtrage et l'acheminement des messages constituent un aspect important, car les consommateurs peuvent exprimer leur intérêt pour des catégories spécifiques de données. RabbitMQ est un bon exemple de système de messagerie traditionnel, dans lequel plusieurs consommateurs peuvent s'abonner au même sujet et recevoir plusieurs copies d'un message.

Le streaming d’événements, quant à lui, se concentre sur la persistance. Les événements doivent être archivés, conservés dans l’ordre et traités une seule fois. Les acheminer vers des consommateurs spécifiques n'est pas important, car l'idée est que tous les consommateurs traitent les événements de la même manière.

Apache Pulsar est un système de messagerie open source, développé par Apache Software Foundation, qui prend en charge le streaming d'événements. Contrairement à Kafka, qui a été conçu dès le départ en pensant à cela, Pulsar a commencé comme une solution traditionnelle de mise en file d'attente de messages et a ensuite acquis des capacités de streaming d'événements. Pulsar est donc utile lorsqu'un mélange des deux approches est nécessaire, sans avoir à déployer des applications distinctes.

Conclusion

Apache Kafka s'exécute désormais en toute sécurité en arrière-plan sur votre serveur, configuré en tant que service systemd. Vous avez également appris à manipuler des sujets à partir de la ligne de commande, ainsi qu'à produire et consommer des messages. Cependant, le principal attrait de Kafka réside dans la grande variété de clients permettant de l'intégrer dans vos applications.

Articles connexes: