Comment sécuriser et surveiller Kafka

Introduction

Apache Kafka prend en charge divers protocoles de sécurité et flux de travail d’authentification pour garantir que seuls le personnel et les applications autorisés peuvent se connecter au cluster. Dans sa configuration par défaut, Kafka permet l’accès à tous mais n’a pas de contrôles de sécurité activés. Bien que cela soit utile pour explorer et développer, les déploiements de production doivent être correctement sécurisés avant d’être exposés au monde extérieur. De plus, de tels environnements doivent être surveillés pour assurer un fonctionnement sans encombre et prévenir les éventuelles pannes.

Dans ce tutoriel, vous renforcerez votre installation Kafka en configurant le cryptage du trafic TLS et l’authentification SASL pour fournir un flux de connexion standard avec nom d’utilisateur et mot de passe. Vous découvrirez comment configurer les scripts producteur et consommateur fournis pour se connecter à un cluster sécurisé. Ensuite, vous apprendrez comment exporter les métriques Kafka et les visualiser dans Grafana. Vous apprendrez également comment accéder aux nœuds et aux sujets de votre cluster via une interface web facile à utiliser fournie par AKHQ.

Prérequis

Pour compléter ce tutoriel, vous aurez besoin :

• Une goutte avec au moins 4Go de RAM et 2 CPU. Dans le cas d’un serveur Ubuntu, suivez la procédure Initial Server Setup pour les instructions de configuration.
• Apache Kafka est installé et configuré sur votre goutte. Pour les instructions de configuration, suivez le tutoriel Introduction to Kafka. Vous devez seulement compléter Étape 1 et Étape 2.
• Une compréhension de la manière dont Java gère les clés et les certificats. Pour plus d’informations, visitez le tutoriel Java Keytool Essentials : Working with Java Keystores.
• Grafana installé sur votre serveur ou machine locale. Veuillez consulter le tutoriel How To Install and Secure Grafana on Ubuntu pour les instructions. Vous avez seulement besoin de compléter les quatre premières étapes.
• Un nom de domaine entièrement enregistré est pointé vers votre goutte. Ce tutoriel utilisera your_domain tout au long et se référera au même nom de domaine que le prérequis Grafana. Vous pouvez acheter un nom de domaine sur Namecheap, en obtenir un gratuitement sur Freenom, ou utiliser le registraire de domaine de votre choix.

Étape 1 – Configurer les protocoles de sécurité de Kafka

Dans sa configuration standard, Kafka permet à tous de se connecter à lui sans vérifier l’origine de la requête. Cela signifie que votre cluster est accessible à tous par défaut. Si c’est acceptable pour le test, car il réduit la charge de maintenance sur les machines locales et les installations privées, les installations de production et celles exposées au public doivent avoir des fonctionnalités de sécurité activées pour empêcher l’accès non autorisé.

Dans cette étape, vous configurerez votre broker Kafka pour utiliser l’encryptage TLS pour le trafic entre le broker et les consommateurs. Vous configurerez également SASL en tant que cadre d’authentification pour vérifier les informations d’identification lors de la connexion au cluster.

Génération de certificats TLS et de magasins

Pour générer les certificats et clés requises pour configurer TLS, vous utiliserez le script du référentiel Outils de sécurité de la plateforme Confluent. Premièrement, clonez-le dans votre répertoire personnel en exécutant la commande suivante :

git clone https://github.com/confluentinc/confluent-platform-security-tools.git ~/kafka-ssl

Naviguez dessus :

cd ~/kafka-ssl

Le script que vous utiliserez s’appelle kafka-generate-ssl-automatic.sh, et il vous faut fournir votre pays, état, organisation et ville en tant que variables d’environnement. Ces paramètres sont utilisés pour créer les certificats, mais leur contenu n’a pas d’importance. Vous devrez également fournir un mot de passe, utilisé pour sécuriser le dépôt de clés et la base de confiance Java qui seront générés.

Exécutez les commandes suivantes pour configurer les variables d’environnement nécessaires, en remplaçant your_tls_password par la valeur souhaitée :

export COUNTRY=US
export STATE=NY
export ORGANIZATION_UNIT=SE
export CITY=New York
export PASSWORD=your_tls_password

Notez que le PASSWORD doit comporter au moins six caractères.

Donnez au script les permissions d’exécution en exécutant :

chmod +x kafka-generate-ssl-automatic.sh

Ensuite, exécutez-le pour générer les fichiers requis :

./kafka-generate-ssl-automatic.sh

Il y aura beaucoup de sortie. Une fois terminé, liste les fichiers dans le répertoire :

ls -l

La sortie devrait ressembler à ceci :

Output
rw-rw-r-- 1 kafka kafka    964 May 13 09:33 README.md
-rw-rw-r-- 1 kafka kafka   1063 May 13 09:34 cert-file
-rw-rw-r-- 1 kafka kafka   1159 May 13 09:34 cert-signed
-rwxrw-r-- 1 kafka kafka   6016 May 13 09:33 kafka-generate-ssl-automatic.sh
-rwxrwxr-x 1 kafka kafka   7382 May 13 09:33 kafka-generate-ssl.sh
drwxrwxr-x 2 kafka kafka   4096 May 13 09:34 keystore
-rw-rw-r-- 1 kafka kafka 184929 May 13 09:33 single-trust-store-diagram.pages
-rw-rw-r-- 1 kafka kafka  36980 May 13 09:33 single-trust-store-diagram.pdf
drwxrwxr-x 2 kafka kafka   4096 May 13 09:34 truststore

Vous verrez que le certificat, le dépôt de confiance et le dépôt de clés ont été créés avec succès.

Configuration de Kafka pour TLS et SASL

Maintenant que vous avez les fichiers nécessaires pour activer le cryptage TLS, vous configurerez Kafka pour les utiliser et authentifier les utilisateurs avec SASL.

Vous modifierez le fichier server.properties situé sous config/kraft dans le répertoire d’installation. Vous l’avez installé sous kafka dans votre répertoire personnel dans le cadre des prérequis. Naviguez jusqu’à lui en exécutant :

cd ~/kafka

Ouvrez le fichier de configuration principal pour l’éditer :

nano config/kraft/server.properties

Trouvez les lignes suivantes :

...
listeners=PLAINTEXT://:9092,CONTROLLER://:9093

# Nom de l'écouteur utilisé pour la communication entre les courtiers.
inter.broker.listener.name=PLAINTEXT

# Nom de l'écouteur, nom d'hôte et port que le courtier annoncera aux clients.
# Si non défini, il utilise la valeur pour "listeners".
advertised.listeners=PLAINTEXT://localhost:9092

Modifiez-les pour qu’elles ressemblent à ceci, en remplaçant PLAINTEXT par BROKER :

...
listeners=BROKER://:9092,CONTROLLER://:9093

# Nom de l'écouteur utilisé pour la communication entre les courtiers.
inter.broker.listener.name=BROKER

# Nom de l'écouteur, nom d'hôte et port que le courtier annoncera aux clients.
# Si non défini, il utilise la valeur pour "listeners".
advertised.listeners=BROKER://localhost:9092

Puis, trouvez la ligne listener.security.protocol.map :

# Maps listener names to security protocols, the default is for them to be the same. See the config documentation for more details
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Mappez BROKER à SASL_SSL en préfixant la définition à la valeur :

# Maps listener names to security protocols, the default is for them to be the same. See the config documentation for more details
listener.security.protocol.map=BROKER:SASL_SSL,CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Voici la traduction demandée :

Ici, vous avez ajouté la définition pour l’alias BROKER que vous avez utilisé dans les listeners et l’avez mappé à SASL_SSL, ce qui signifie que tanto le SSL (un ancien nom pour TLS) que SASL doivent être utilisés.

Puis, naviguez jusqu’à la fin du fichier et ajoutez les lignes suivantes :

ssl.truststore.location=/home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password=your_tls_password
ssl.keystore.location=/home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password=your_tls_password
ssl.key.password=your_tls_password
ssl.client.auth=required

sasl.enabled.mechanisms=PLAIN
sasl.mechanism.controller.protocol=PLAIN
sasl.mechanism.inter.broker.protocol=PLAIN

authorizer.class.name=org.apache.kafka.metadata.authorizer.StandardAuthorizer
allow.everyone.if.no.acl.found=false
super.users=User:admin

Vous définissez d’abord les emplacements et les mots de passe pour les magasins de confiance et de clés générés. Vous réglez le paramètre ssl.client.auth sur required, indiquant à Kafka de refuser toute connexion qui ne présente pas un certificat TLS valide. Ensuite, vous configurez le mécanisme SASL sur PLAIN, ce qui l’active. PLAIN est différent de PLAINTEXT car il nécessite l’utilisation d’une connexion chiffrée, et les deux utilisent une combinaison d’identifiant et de mot de passe.

Finalement, vous définissez StandardAuthorizer comme classe d’autorisation, qui vérifie les informations d’identification par rapport à un fichier de configuration que vous allez créer bientôt. Ensuite, vous réglez le paramètre allow.everyone.if.no.acl.found sur false, restreignant l’accès aux connexions avec des informations d’identification inappropriées. Vous définissez également l’utilisateur admin comme superutilisateur, car il doit y en avoir au moins un pour effectuer des tâches administratives dans le cluster.

N’oubliez pas de remplacer votre_mot_de_passe_tls par le mot de passe que vous avez passé au script dans la section précédente, puis enregistrez et fermez le fichier.

Maintenant que vous avez configuré Kafka, vous devrez créer un fichier qui définit les identifiants autorisés pour la connexion. Kafka supporte le Java Authentication and Authorization Service (JAAS), un framework pour implémenter des flux d’authentification, et accepte les définitions d’identifiants dans le format JAAS.

Vous le stockerez dans un fichier nommé kafka-server-jaas.conf sous config/kraft. Créez-le et ouvrez-le pour l’édition en exécutant :

nano config/kraft/kafka-server-jaas.conf

Ajoutez les lignes suivantes :

KafkaServer {
 org.apache.kafka.common.security.plain.PlainLoginModule required
 username="admin"
 password="admin"
 user_admin="admin";
};

Les username et password définissent les identifiants principaux utilisés pour la communication inter-broker dans le cluster lorsque plusieurs nœuds sont présents. La ligne user_admin définit un utilisateur dont le nom d’utilisateur est admin et le mot de passe admin, qui peut se connecter au broker depuis l’extérieur. Enregistrez et fermez le fichier lorsque vous êtes terminé.

Kafka doit connaître le fichier kafka-server-jaas.conf car il complète la configuration principale. Vous devrez modifier la configuration du service kafka systemd et passer une référence à ce fichier. Exécutez la commande suivante pour ouvrir le service pour l’édition :

sudo systemctl edit --full kafka

En passant en --full, vous avez accès au contenu complet du service. Recherchez la ligne ExecStart :

...
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'
...

Ajoutez la ligne suivante au-dessus, de sorte qu’elle ressemble à ceci :

...
User=kafka
Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/home/kafka/kafka/config/kraft/kafka-server-jaas.conf"
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'
...

Avec cela, vous définissez le paramètre java.security.auth.login.config dans le fichier de configuration sur le chemin vers le fichier de configuration JAAS, le déconnectant de la configuration principale de Kafka. Une fois terminé, enregistrez et fermez le fichier. Rechargez la définition du service en exécutant :

sudo systemctl daemon-reload

Ensuite, redémarrez Kafka :

sudo systemctl restart kafka

Vous avez maintenant configuré à la fois le chiffrement TLS et l’authentification SASL pour votre installation de Kafka, et vous allez apprendre comment vous connecter à elle en utilisant les scripts de console fournis.

Étape 2 – Connexion à un Cluster sécurisé

Dans cette étape, vous apprendrez comment vous connecter à un cluster Kafka sécurisé en utilisant des fichiers de configuration JAAS avec les scripts de console fournis.

Les scripts fournis pour manipuler les topics, produisant et consommant des messages, utilisent également Java internement, et acceptent ainsi une configuration JAAS détaillant les emplacements des magasins de certificats de confiance et de clés, ainsi que les informations d’authentification SASL.

Vous stockeriez cette configuration dans un fichier nommé client-jaas.conf dans votre répertoire personnel. Créez-le et ouvrez-le pour l’édition :

nano ~/client-jaas.conf

Ajoutez les lignes suivantes :

security.protocol=SASL_SSL
ssl.truststore.location=/home/kafka/kafka-ssl/truststore/kafka.truststore.jks
ssl.truststore.password=your_tls_password
ssl.keystore.location=/home/kafka/kafka-ssl/keystore/kafka.keystore.jks
ssl.keystore.password=your_tls_password

sasl.mechanism=PLAIN
sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="admin";
ssl.endpoint.identification.algorithm=

Vous configurez le protocole à SASL_SSL et fournissez les chemins et le mot de passe pour les magasins de clés et de confiance que vous avez créés. Ensuite, vous définissez le mécanisme SASL à PLAIN et fournissez les informations d’identification pour l’utilisateur admin. Vous effacez explicitement le paramètre ssl.endpoint.identification.algorithm pour empêcher les problèmes de connexion, car les scripts initiaux définissent le nom d’hôte de la machine sur laquelle ils sont exécutés comme le point de terminaison du certificat, ce qui peut ne pas être correct.

Remplacez your_tls_password par la valeur appropriée, puis enregistrez et fermez le fichier.

Pour passer ce fichier aux scripts, vous pouvez utiliser le paramètre --command-config. Essayez de créer un nouveau sujet dans le cluster avec la commande suivante :

bin/kafka-topics.sh --bootstrap-server localhost:9092 --create --topic new_topic --command-config ~/client-jaas.conf

La commande devrait s’exécuter avec succès :

Output
...
Created topic new_topic.

Pour vérifier qu’il a été créé, listez tous les sujets dans le cluster en exécutant :

bin/kafka-topics.sh --bootstrap-server localhost:9092 --list --command-config ~/client-jaas.conf

La sortie montrera que new_topic est présent :

Output
__consumer_offsets
new_topic
...

Dans cette section, vous avez configuré votre installation Kafka pour utiliser le cryptage TLS pour le trafic et SASL pour l’authentification avec des combinaisons d’un nom d’utilisateur et d’un mot de passe. Vous apprendrez maintenant comment exporter divers métriques Kafka via JMX en utilisant Prometheus.

Étape 3 – Surveillance des métriques JMX Kafka à l’aide de Prometheus

Dans cette section, vous utiliserez Prometheus pour collecter des métriques Kafka et les rendre exploitable dans Grafana. Cela implique de configurer l’exporteur JMX pour Kafka et de le connecter à Prometheus.

[Les Java Management Extensions (JMX) sont une plateforme pour les applications Java qui permet aux développeurs de collecter des métriques générales et personnalisées sur l’operation de l’application en temps réel dans un format standardisé. Comme Kafka est écrit en Java, il supporte le protocole JMX et expose ses métriques personnalisées à travers celui-ci, telles que l’état des topics et des brokers.

Configurer Kafka et Prometheus

Avant de continuer, vous devez installer Prometheus. Sur les machines Ubuntu, vous pouvez utiliser apt. Mettez à jour ses dépôts en exécutant :

sudo apt update

Ensuite, installez Prometheus :

sudo apt install prometheus -y

Pour d’autres plateformes, veuillez suivre les instructions d’installation sur le site officiel.

Une fois installé, vous devrez ajouter la bibliothèque JMX exporter pour Prometheus à votre installation Kafka. Naviguez vers la page des versions et sélectionnez la dernière version avec javaagent dans le nom. Au moment de l’écriture, la dernière version disponible était 0.20.0. Utilisez la commande suivante pour la télécharger dans le répertoire libs/ où Kafka est installé :

curl https://repo.maven.apache.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/0.20.0/jmx_prometheus_javaagent-0.20.0.jar -o ~/kafka/libs/jmx_prometheus_javaagent.jar

La bibliothèque JMX exporter sera maintenant détectée par Kafka.

Avant d’activer l’exporter, vous devez définir les métriques qu’il rapportera à Prometheus, et vous stockerez cette configuration dans un fichier nommé jmx-exporter.yml sous config/ de votre installation Kafka. Le projet JMX exporter fournit une configuration par défaut adéquate, donc exécutez la commande suivante pour la stocker sous le nom jmx-exporter.yml dans config/ de votre installation Kafka :

curl https://raw.githubusercontent.com/prometheus/jmx_exporter/main/example_configs/kafka-2_0_0.yml -o ~/kafka/config/jmx-exporter.yml

Ensuite, pour activer l’exporter, vous devrez modifier le service systemd de Kafka. Vous devrez modifier la variable d’environnement KAFKA_OPTS pour inclure l’exporter, ainsi que sa configuration. Exécutez la commande suivante pour modifier le service :

sudo systemctl edit --full kafka

Modifiez la ligne Environment pour qu’elle ressemble à ceci :

Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/home/kafka/kafka/config/kraft/kafka-server-jaas.conf -javaagent:/home/kafka/kafka/libs/jmx_prometheus_javaagent.jar=7075:/home/kafka/kafka/config/jmx-exporter.yml"

Ici, vous utilisez l’argument -javaagent pour initialiser JMX exporter avec sa configuration.

Enregistrez et fermez le fichier lorsque vous avez terminé, puis redémarrez Kafka en exécutant :

sudo systemctl restart kafka

Après un minute, vérifiez que JMX exporter fonctionne en demandant si le port 7075 est utilisé :

sudo ss -tunelp | grep 7075

Voici la traduction demandée :

Output
tcp   LISTEN 0      3                  *:7075             *:*    users:(("java",pid=6311,fd=137)) uid:1000 ino:48151 sk:8 cgroup:/system.slice/kafka.service v6only:0 <->

Cette ligne montre que le port 7075 est utilisé par un processus Java lancé par le service Kafka, ce qui fait référence à l’exportateur JMX.

Vous allez maintenant configurer Prometheus pour surveiller les métriques JMX exportées. Son fichier de configuration principal est situé à /etc/prometheus/prometheus.yml, ouvrez-le pour l’éditer :

sudo nano /etc/prometheus/prometheus.yml

Trouvez les lignes suivantes :

...
# Une configuration d'interrogation contenant exactement un point de terminaison à interroger :
# Ici, c'est Prometheus lui-même.
scrape_configs:
  # Le nom de l'emploi est ajouté en tant qu'étiquette `job=<nom_emploi>` à toutes les séries temporelles interrogées à partir de cette configuration.
  - job_name: 'prometheus'

    # Remplacez la valeur par défaut globale et interrogez les cibles de cet emploi toutes les 5 secondes.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path est par défaut '/metrics'
    # scheme est par défaut 'http'.

    static_configs:
      - targets: ['localhost:9090']

  - job_name: node
    # Si prometheus-node-exporter est installé, récupérez les statistiques sur la machine locale
    # par défaut.
    static_configs:
      - targets: ['localhost:9100']

Sous scrape_configs, qui spécifie les points de terminaison que Prometheus doit surveiller, ajoutez une nouvelle section pour extraire les métriques Kafka :

# Une configuration de balayage contenant exactement un point de terminaison à balayer :
# Ici, c'est Prometheus lui-même.
scrape_configs:
  # Le nom du job est ajouté en tant qu'étiquette `job=<nom_job>` à toutes les séries temporelles balayées à partir de cette configuration.
  - job_name: 'prometheus'

    # Remplacez la valeur par défaut globale et balayez les cibles de ce job toutes les 5 secondes.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path est par défaut '/metrics'
    # scheme est par défaut 'http'.

    static_configs:
      - targets: ['localhost:9090']

  - job_name: node
    # Si prometheus-node-exporter est installé, récupérez les statistiques sur la machine locale
    # par défaut.
    static_configs:
      - targets: ['localhost:9100']

  - job_name: 'kafka'
    static_configs:
    - targets: ['your_domain:7075']

Le job kafka a un seul cible, qui pointe vers le point de terminaison de l’exportateur JMX.

N’oubliez pas de remplacer votre_domaine par votre nom de domaine, puis enregistrez et fermez le fichier. Ensuite, redémarrez Prometheus en exécutant :

sudo systemctl restart prometheus

Dans votre navigateur, naviguez vers le port 9090 de votre domaine. Vous accéderez à l’interface utilisateur de Prometheus. Sous État, appuyez sur Cibles pour lister les jobs :

Remarquez que Prometheus a accepté le job kafka et a commencé à balayer ses métriques. Vous apprendrez maintenant comment y accéder dans Grafana.

Interroger les métriques dans Grafana

Comme partie des prérequis, vous avez installé Grafana sur votre Droplet et l’avez exposé à your_domain. Naviguez jusqu’à celui-ci dans votre navigateur, et dans la barre latérale, sous Connections, cliquez sur Ajouter une nouvelle connexion, puis tapez Prometheus dans le champ de recherche.

Cliquez sur Prometheus, ensuite cliquez sur le bouton Ajouter une nouvelle source de données en haut à droite. Vous serez invité à entrer l’adresse d’une instance de Prometheus :

Entrez http://your_domain_name:9090, remplacez-y votre nom de domaine réel, puis défiler vers le bas et cliquez sur Enregistrer & tester. Vous devriez recevoir un message de succès :

La connexion Prometheus a été ajoutée à Grafana. Cliquez sur Explorer dans la barre latérale, et vous serez invité à sélectionner une métrique. Vous pouvez entrer kafka_ pour lister toutes les métriques liées au cluster, comme illustré :

Par exemple, sélectionnez la métrique kafka_log_log_size, qui montre la taille de la log interne sur disque par partition, ensuite cliquez sur Exécuter la requête en haut à droite. Vous verrez les tailles résultantes au fil du temps pour chacun des topics disponibles :

Dans cette étape, vous avez configuré l’exportation des métriques JMX que Kafka fournit et configurez Prometheus pour les scraper. Ensuite, vous vous êtes connecté à Grafana et avez exécuté une requête sur les métriques de Kafka. Vous allez maintenant apprendre comment gérer un cluster Kafka à l’aide d’une interface Web.

Étape 4 – Gestion de clusters Kafka avec AKHQ

Dans cette étape, vous apprendrez comment installer et utiliser AKHQ, une application Web pour gérer les clusters Kafka. Elle vous permet de lister et de manipuler les topics, les partitions, les groupes de consommateurs et les paramètres de configuration, ainsi que de produire et de consommer des messages à partir de topics en un seul endroit.

Vous stockerez l’exécutable et sa configuration dans un répertoire nommé akhq. Créez-le dans votre répertoire personnel en exécutant :

mkdir ~/akhq

Allez-y :

cd ~/akhq

Dans votre navigateur, visitez la page des versions officielles et copiez le lien vers le fichier JAR de la dernière version. Au moment de l’écriture, la dernière version était la 0.24.0. Exécutez la commande suivante pour le télécharger vers votre répertoire personnel :

curl -L https://github.com/tchiotludo/akhq/releases/download/0.24.0/akhq-0.24.0-all.jar -o ~/akhq/akhq.jar

Vous avez maintenant téléchargé AKHQ et êtes prêt à définir sa configuration pour vous connecter à votre cluster. Vous allez stocker cela dans un fichier nommé akhq-config.yml. Créez-le et ouvrez-le en édition en exécutant :

nano ~/akhq/akhq-config.yml

Ajoutez les lignes suivantes :

akhq:
  connections:
    localhost-sasl:
      properties:
        bootstrap.servers: "localhost:9092"
        security.protocol: SASL_SSL
        sasl.mechanism: PLAIN
        sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="admin";
        ssl.truststore.location: /home/kafka/kafka-ssl/truststore/kafka.truststore.jks
        ssl.truststore.password: secret
        ssl.keystore.location: /home/kafka/kafka-ssl/keystore/kafka.keystore.jks
        ssl.keystore.password: secret
        ssl.key.password: secret
        ssl.endpoint.identification.algorithm: ""

Ceci est une configuration de base d’AKHQ, spécifiant un cluster à localhost:9092 avec les paramètres SASL et TLS correspondants spécifiés. Plusieurs clusters simultanés sont également pris en charge car vous pouvez définir autant de connexions que vous le souhaitez. Cela rend AKHQ polyvalent pour gérer Kafka. Quand vous aurez terminé, enregistrez et fermez le fichier.

Ensuite, vous devrez définir un service systemd pour exécuter AKHQ en arrière-plan. Les services systemd peuvent être démarrés, arrêtés et redémarrés de manière cohérente.

Vous stockerarez 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 en utilisant votre éditeur de texte :

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

Ajoutez les lignes suivantes :

[Unit]
Description=akhq

[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c 'java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar'
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Vous définissez 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 le service s’exécute en tant que utilisateur kafka et que le service doit être redémarré automatiquement s’il se termine.

La section [Install] ordonne à systemd de démarrer ce service lorsque vous pouvez vous connecter à votre serveur. Enregistrez et fermez le fichier lorsque vous aurez terminé.

Chargez la configuration du service en exécutant :

sudo systemctl daemon-reload

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

sudo systemctl start akhq

Ensuite, vérifiez qu’il est démarré correctement en observant son état :

sudo systemctl status akhq

La sortie devrait ressembler à cela :

Output
● akhq.service - akhq
     Loaded: loaded (/etc/systemd/system/akhq.service; disabled; vendor preset: enabled)
     Active: active (running) since Wed 2024-05-15 07:37:10 UTC; 3s ago
   Main PID: 3241 (sh)
      Tasks: 21 (limit: 4647)
     Memory: 123.3M
        CPU: 4.474s
     CGroup: /system.slice/akhq.service
             ├─3241 /bin/sh -c "java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar"
             └─3242 java -Dmicronaut.config.files=/home/kafka/akhq/akhq-config.yml -jar /home/kafka/akhq/akhq.jar

AKHQ fonctionne désormais en arrière-plan. Par défaut, il est exposé au port 8080. Dans votre navigateur, naviguez vers votre domaine avec ce port pour y accéder. Vous verrez la vue par défaut, affichant la liste des sujets :

Vous pouvez double-cliquer sur la ligne correspondante du sujet dans le tableau pour y accéder et obtenir une vue détaillée :

AKHQ vous permet de voir les messages du sujet, ainsi que les partitions, les groupes de consommateurs et leur configuration. Vous pouvez également vider ou copier le sujet à l’aide des boutons en bas à droite.

Puisque le sujet new_topic est vide, appuyez sur le bouton Produire pour le sujet, ce qui ouvrira l’interface pour sélectionner les paramètres du nouveau message :

AKHQ remplira automatiquement le nom du sujet pour vous. Dans le champ Valeur, entrez Hello World !, puis appuyez sur Produire. Le message sera envoyé à Kafka et vous le verrez dans l’onglet Données :

Comme le contenu d’un message peut être très volumineux, AKHQ n’affiche que la première ligne. Pour voir le message complet, appuyez sur la zone sombre après la ligne pour le révéler.

Dans la barre latérale de gauche, vous pouvez également lister les courtiers du cluster en appuyant sur Noeuds. Actuellement, le cluster ne consiste qu’en un seul nœud :

En double-cliquant sur un nœud, vous ouvrirez sa configuration, ce qui vous permet de modifier tous les paramètres à distance :

Une fois les modifications effectuées, vous pouvez les appliquer en appuyant sur le bouton Mettre à jour les configurations situé en bas à droite. De même, vous pouvez afficher et modifier la configuration de n’importe lequel des sujets en y accédant et en passant à l’onglet Configurations.

Dans cette section, vous avez configuré AKHQ, une application Web offrant une interface utilisateur facile à utiliser pour gérer et observer les nœuds et les sujets Kafka à distance. Il vous permet de produire et consommer des messages dans les sujets et de mettre à jour les paramètres de configuration des sujets et des nœuds en direct.

Conclusion

Dans ce tutoriel, vous avez sécurisé votre installation Kafka en configurant TLS pour l’encryption et SASL pour l’authentification des utilisateurs. Vous avez également configuré l’exportation de métriques à l’aide de Prometheus et les visualisées dans Grafana. Ensuite, vous avez appris à utiliser AKHQ, une application Web pour gérer les clusters Kafka.

L’auteur a choisi la Fondation Apache pour recevoir une donation dans le cadre du programme Write for DOnations..