Hoe u Kafka veilig en monitort

Inleiding

Apache Kafka ondersteunt verschillende beveiligingsprotocollen en authenticatieworkflows om ervoor te zorgen dat alleen geautoriseerd personeel en toepassingen verbinding kunnen maken met de cluster. In de standaardconfiguratie staat Kafka iedereen toegang toe, maar zijn er geen beveiligingscontroles ingeschakeld. Hoewel dit nuttig is voor het verkennen en ontwikkelen, moeten productiedeployments correct beveiligd worden voordat ze worden blootgesteld aan de buitenwereld. Bovendien moeten dergelijke omgevingen worden gemonitord om een soepele werking te waarborgen en mogelijke storingen te voorkomen.

In deze handleiding zul je je Kafka-installatie versterken door TLS-verkeersversleuteling en SASL-authenticatie te configureren om een standaard gebruikersnaam en wachtwoord login flow te bieden. Je ziet hoe je de verstrekte producer- en consumer-scripts kunt configureren om verbinding te maken met een beveiligde cluster. Vervolgens leer je hoe je Kafka-metriek kunt exporteren en deze kunt visualiseren in Grafana. Je leert ook hoe je toegang kunt krijgen tot de knooppunten en onderwerpen van je cluster via een eenvoudig te gebruiken, webgebaseerde interface die wordt aangeboden door AKHQ.

Voorvereisten

Om deze handleiding te voltooien heb je nodig:

• Een Droplet met ten minste 4GB RAM en 2 CPUs. Bij een Ubuntu-server volgt u de Initial Server Setup voor installatieinstructies.
• Apache Kafka is geïnstalleerd en geconfigureerd op uw droplet. Volg voor installatieinstructies de Introduction to Kafka-handleiding. U hoeft alleen Stap 1 en Stap 2 uit te voeren.
• Een begrip van hoe Java sleutels en certificaten afhandelt. Bezoek voor meer informatie de Java Keytool Essentials: Working with Java Keystores-handleiding.
• Grafana geïnstalleerd op uw server of lokale machine. Bezoek de How To Install and Secure Grafana on Ubuntu-handleiding voor instructies. U hoeft alleen de eerste vier stappen uit te voeren.
• Een volledig geregistreerde domeinnaam is gekoppeld aan uw droplet. Deze handleiding gebruikt your_domain doorlopend en verwijst naar dezelfde domeinnaam als de voorwaarde voor Grafana. U kunt een domeinnaam aankopen op Namecheap, krijgt u een gratis domeinnaam op Freenom, of gebruikt u de domeinregistratieur van uw keuze.

Stap 1 – Configuratie van Kafka-beveiligingsprotocollen

In de standaardconfiguratie laat Kafka iedereen verbinding maken zonder de herkomst van het verzoek te controleren. Dit betekent dat uw cluster standaard toegankelijk is voor iedereen. Hoewel dit goed genoeg is voor testdoeleinden, omdat het de onderhoudsbelasting op lokale machines en private installaties vermindert, moeten productie- en publiekstoegankelijke Kafka-installaties beveiligingsfuncties hebben ingeschakeld om ongeautoriseerd toegang te voorkomen.

In deze stap configureert u uw Kafka-broker om TLS-versleuteling te gebruiken voor het verkeer tussen de broker en consumenten. U stelt ook SASL in als het authenticatieframework voor het verifiëren van inloggegevens bij het verbinden met de cluster.

Genereren van TLS-certificaten en opslaglocaties

Om de benodigde certificaten en sleutels voor het instellen van TLS te genereren, gebruikt u het script uit de Confluent Platform Security Tools-repository. Kloon het eerst naar uw persoonlijke map door het volgende commando uit te voeren:

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

Navigeer erheen:

cd ~/kafka-ssl

Het script dat u gaat gebruiken heet kafka-generate-ssl-automatic.sh, en het vereist dat u uw land, deelstaat, organisatie en stad opgeeft als omgevingsvariabelen. Deze parameters worden gebruikt om certificaten te maken, maar hun inhoud is onbelangrijk. U moet ook een wachtwoord opgeven, dat wordt gebruikt om de Java-vertrouwen en sleutelopslag die wordt gegenereerd, te beveiligen.

U kunt de volgende opdrachten uitvoeren om de vereiste omgevingsvariabelen in te stellen, door your_tls_password te vervangen door uw gewenste waarde:

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

Merk op dat PASSWORD minimaal zes tekens lang moet zijn.

Geef het script uitvoerbare rechten door de opdracht uit te voeren:

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

Voer het dan uit om de vereiste bestanden te genereren:

./kafka-generate-ssl-automatic.sh

Er zal veel uitvoer zijn. Wanneer het klaar is, maak een lijst van de bestanden in het directory:

ls -l

De uitvoer zou er ongeveer uitzien:

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

U zult zien dat het certificaat, vertrouwen en sleutelopslag succesvol zijn aangemaakt.

Kafka configureren voor TLS en SASL

Nu u de vereiste bestanden heeft om TLS-versleuteling in te schakelen, zal u Kafka configureren om ze te gebruiken en gebruikers te authenticateren met behulp van SASL.

U zult het bestand server.properties onder config/kraft in de installatiemappe wijzigen. U heeft het geïnstalleerd onder kafka in uw home directory als onderdeel van de voorvereisten. Ga naar deze map door te voerden:

cd ~/kafka

Open het hoofdconfiguratiebestand voor het bewerken:

nano config/kraft/server.properties

Zoek de volgende regels:

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

# Naam van de luisterder die wordt gebruikt voor communicatie tussen de knoopstenen.
inter.broker.listener.name=PLAINTEXT

# Luisterdernaam, hostnaam en poort die de knoopsteen aan klanten zal aanbieden.
# Indien niet ingesteld, gebruikt het het waarden voor "listeners".
advertised.listeners=PLAINTEXT://localhost:9092

Wijzig ze zodat ze er als volgt uitzien, vervang PLAINTEXT door BROKER:

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

# Naam van de luisterder die wordt gebruikt voor communicatie tussen de knoopstenen.
inter.broker.listener.name=BROKER

# Luisterdernaam, hostnaam en poort die de knoopsteen aan klanten zal aanbieden.
# Indien niet ingesteld, gebruikt het de waarden voor "listeners".
advertised.listeners=BROKER://localhost:9092

Vervolgens zoek de regel listener.security.protocol.map:

# Toont luisterdernamen aan beveiligingsprotocollen toe, de standaard is dat ze hetzelfde zijn. Zie de configuratie documentatie voor meer details
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Map BROKER toe aan SASL_SSL door de definitie voor de waarde te vooraf te zetten:

# Toont luisterdernamen aan beveiligingsprotocollen toe, de standaard is dat ze hetzelfde zijn. Zie de configuratie documentatie voor meer details
listener.security.protocol.map=BROKER:SASL_SSL,CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Hier heeft u de definitie voor de alias BROKER toegevoegd die u in de listeners heeft gebruikt en die u heeft toegewezen aan SASL_SSL, wat aangeeft dat zowel SSL (een eerdere naam voor TLS) als SASL moeten worden gebruikt.

Volgende, ga naar het einde van het bestand en voeg de volgende regels toe:

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

U begint door de locaties en wachtwoorden voor de gegenereerde vertrouwde en sleutelopslag te definiëren. U stelt het parameter ssl.client.auth in op required, die Kafka instructeert geen verbindingen te toestaan die geen geldig TLS-certificaat aanbieden. Vervolgens stelt u het SASL-mechanisme in op PLAIN, wat het activeert. PLAIN verschilt van PLAINTEXT in dat het gebruik van een versleutelde verbinding vereist, en beide zijn afhankelijk van een combinatie van een gebruikersnaam en wachtwoord.

Ten slotte stelt u StandardAuthorizer in als de authorizer klasse, die de referenties controleert tegen een configuratiebestand dat u binnenkort zal aanmaken. Vervolgens stelt u het parameter allow.everyone.if.no.acl.found in op false, wat toegang beperkt voor verbindingen met ongeldige referenties. U duid ook de gebruiker admin aan als superuser, want er moet minimaal een zijn om taken uit te voeren in het cluster.

Vergeet niet om your_tls_password te vervangen door het wachtwoord dat u in de vorige sectie aan het script heeft doorgegeven, en sla het bestand dan af en sluit het af.

Nu u Kafka heeft geconfigureerd, moet u een bestand aanmaken dat de toegestane inloggegevens voor de verbinding definieert. Kafka ondersteunt de Java Authentication and Authorization Service (JAAS), een framework voor het implementeren van authenticatiewerken, en accepteert inloggegevensdefinities in het JAAS-formaat.

U zal deze opslaan in een bestand genaamd kafka-server-jaas.conf onder config/kraft. Maak het bestand aan en open het voor bewerking door te draaien:

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

Voeg de volgende regels toe:

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

De username en password definiëren de hoofdinloggegevens die worden gebruikt voor de communicatie tussen de kaders van het cluster bij meerdere knooppunten. De regel user_admin definieert een gebruiker met de naam admin met wachtwoord admin, die van buitenaf met de kader kan verbinden. Sla het bestand op en sluit het af als u klaar bent.

Kafka moet de bestand kafka-server-jaas.conf kennen omdat het de hoofdconfiguratie complementeert. U moet de kafka systemd-dienstconfiguratie aanpassen en een verwijzing naar het toegevoegd zijn. Voer de volgende commando uit om het dienstbestand te openen:

sudo systemctl edit --full kafka

Door --full mee te geven, krijgt u toegang tot de volledige inhoud van de dienst. Zoek de regel 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'
...

Voeg boven deze regel de volgende regel toe, zodat het er als volgt uitziet:

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

Met dit stel je de parameter java.security.auth.login.config in de configuratie in de configuratie op de pad van het JAAS-configbestand, onafhankelijk van de hoofd Kafka-configuratie. Wanneer je klaar bent, sla de bestand op en sluit het af. Laad de service-definitie opnieuw door te draaien:

sudo systemctl daemon-reload

Start dan Kafka opnieuw:

sudo systemctl restart kafka

U hebt nu zowel TLS-versleuteling als SASL-authenticatie voor uw Kafka-installatie geconfigureerd, en leert hoe u met de geleverde console-scripts erop moet verbinden.

Stap 2 – Verbinden met een beveiligd cluster

In deze stap leert u hoe u verbinding kunt maken met een beveiligd Kafka-cluster met behulp van JAAS-configbestanden en de geleverde console-scripts.

De geleverde scripts voor het beheren van topics, het produceren en consumeren van berichten, gebruiken ook intern Java, en accepteren daarom een JAAS-configuratie die de locaties van het vertrouwen en sleutelbestanden, evenals SASL-gegevens, beschrijft.

U zal deze configuratie in een bestand opslaan met de naam client-jaas.conf in uw home-directory. Maak het bestand aan en open het voor bewerking:

nano ~/client-jaas.conf

Voeg de volgende regels toe:

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=

Net zoals eerder, stel je het protocol in op SASL_SSL en geef je de paden en wachtwoorden voor de sleutel- en vertrouwenswarenhuizen die u heeft aangemaakt. Daarna stel je het SASL-mechanisme in op PLAIN en geef je de referenties voor de gebruiker admin. U specificeert expliciet het parameter ssl.endpoint.identification.algorithm op niet ingesteld om connectieproblemen te vermijden, aangezien de initiale scripts het hostnaam van de machine bepalen waarop ze worden uitgevoerd als certificaat-eindpunt, wat misschien niet correct is.

Vervang your_tls_password door de juiste waarde, sla dan het bestand gesloten op.

Om dit bestand door de scripts te geven, kun je het --command-config-parameter gebruiken. Probeer een nieuw topic in het cluster aan te maken met het volgende commando:

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

Het commando moet succesvol worden uitgevoerd:

Output
...
Created topic new_topic.

Om te controleren of het is aangemaakt, roep alle topics in het cluster aan door te voer:

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

Het resultaat zal tonen dat new_topic aanwezig is:

Output
__consumer_offsets
new_topic
...

In deze sectie heeft u uw Kafka-installatie ingesteld om TLS-versleuteling voor verkeer en SASL voor authenticatie te gebruiken met combinaties van een gebruikersnaam en wachtwoord. Nu zult u leren hoe u verschillende Kafka-metrics via JMX met Prometheus exporteert.

Stap 3 – Monitoren van Kafka JMX-metrics met behulp van Prometheus

In deze sectie zult u Prometheus gebruiken om Kafka-metrics te verzamelen en ze in Grafana op te vragen. Dit betekent dat u het JMX-exporteur voor Kafka moet instellen en hem moet verbinden met Prometheus.

[Java Management Extensions (JMX) is een framework voor Java-toepassingen dat ontwikkelaars toestaat om algemene en aangepaste metrics over de runtime van de app te verzamelen in een standaard formaat. Aangezien Kafka in Java geschreven is, ondersteunt het het JMX-protocol en laat het zijn aangepaste metrics vrij via dit protocol, zoals de status van topics en brokers.

Kafka en Prometheus configureren

Voordat u doorgaat, moet u Prometheus installeren. Op Ubuntu-machines kunt u apt gebruiken. Update zijn repositories door de uitvoering van:

sudo apt update

Vervolgens installeer u Prometheus:

sudo apt install prometheus -y

Voor andere platforms, volg de installatie-instructies op de officiële website.

Zodra het is geïnstalleerd, moet je de JMX-exporter-bibliotheek voor Prometheus toevoegen aan je Kafka-installatie. Ga naar de releases pagina en selecteer de nieuwste release met javaagent in de naam. Op het moment van schrijven was de nieuwste beschikbare versie 0.20.0. Gebruik de volgende opdracht om deze te downloaden naar de libs/-map waar Kafka is geïnstalleerd:

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

De JMX-exporter-bibliotheek zal nu worden opgepikt door Kafka.

Voordat je de exporter activeert, moet je definiëren welke metriek deze zal rapporteren aan Prometheus, en je zal deze configuratie opslaan in een bestand genaamd jmx-exporter.yml onder config/ van je Kafka-installatie. Het JMX-exporter-project biedt een geschikte standaardconfiguratie, dus voer de volgende opdracht uit om deze op te slaan als jmx-exporter.yml onder config/ van je Kafka-installatie:

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

Hierna, om de exporter te activeren, moet je de Kafka systemd-service wijzigen. Je moet de omgevingsvariabele KAFKA_OPTS wijzigen om de exporter en zijn configuratie op te nemen. Voer de volgende opdracht uit om de service te bewerken:

sudo systemctl edit --full kafka

Wijzig de Environment-regel zodat deze er als volgt uitziet:

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"

Hier gebruik je het argument -javaagent om de JMX-exporter met zijn configuratie te initialiseren.

Sla en sluit het bestand op wanneer je klaar bent, en herstart Kafka door de volgende opdracht uit te voeren:

sudo systemctl restart kafka

Na een minuut, verifieer of de JMX-exporter draait door te controleren of de poort 7075 in gebruik is:

sudo ss -tunelp | grep 7075

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

Deze regel laat zien dat poort 7075 in gebruik is door een Java-proces dat wordt gestart door de Kafka-dienst, wat verwijst naar de JMX-exporteur.

U configureert nu Prometheus om toezicht te houden op de geëxporteerde JMX-metrieken. Het hoofdconfiguratiebestand ligt op /etc/prometheus/prometheus.yml, dus open dit bestand voor het aanpassen:

sudo nano /etc/prometheus/prometheus.yml

Zoek de volgende regels:

...
# Een scrape configuratie die exact één endpoint bevat om te scrape:
# Hier is dat Prometheus zelf.
scrape_configs:
  # De jobnaam wordt toegevoegd als label `job=` aan elke timeseries die van deze config gehaald wordt.
  - job_name: 'prometheus'

    # Override de algemene standaard en haal doelen van deze job elke 5 seconden.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path standaard op '/metrics'.
    # schema standaard op 'http'.

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

  - job_name: node
    # Als prometheus-node-exporter is geïnstalleerd, haal statistieken over de lokale
    # machine standaard op.
    static_configs:
      - targets: ['localhost:9100']

onder scrape_configs, die specificeert welke endpoints Prometheus moet observeren, voeg een nieuwe sectie toe voor het scrapen van Kafka-metrieken:

# Een scrape-configuratie die precies één eindpunt bevat om te scrapen:
# Hier is het Prometheus zelf.
scrape_configs:
  # De jobnaam wordt toegevoegd als een label `job=<job_name>` aan elke timeserie die vanuit deze configuratie is gescraped.
  - job_name: 'prometheus'

    # Ondermijnt de globale standaard en scrape doelen van deze job elke 5 seconden.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path staat standaard op '/metrics'
    # scheme staat standaard op 'http'.

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

  - job_name: node
    # Als prometheus-node-exporter is geïnstalleerd, haal dan standaard statistieken op over de lokale
    # machine.
    static_configs:
      - targets: ['localhost:9100']

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

De kafka job heeft één doel, wat verwijst naar het JMX exporter-eindpunt.

Vergeet niet om your_domain te vervangen door je domeinnaam, sla vervolgens op en sluit het bestand. Start Prometheus vervolgens opnieuw door het volgende uit te voeren:

sudo systemctl restart prometheus

In je browser, navigeer naar het poort 9090 op je domein. Je krijgt toegang tot de Prometheus UI. Onder Status, klik op Doelen om de jobs te lijsten:

Merk op dat Prometheus de kafka job heeft geaccepteerd en begonnen is met het scrapen van zijn metrics. Je zal nu leren hoe je er toegang toe krijgt in Grafana.

Metrieken aanvragen in Grafana

Als onderdeel van de voorvereisten hebben u Grafana op uw Droplet geinstalleerd en via your_domain ge exposeerd. Ga naar het in uw browser, en onder Verbindings in de zijbalk, klik op Nieuwe verbinding toevoegen, en typ vervolgens Prometheus in het zoekveld in.

Klik op Prometheus, en klik vervolgens op de knop Nieuwe gegevensbron toevoegen in de rechterbovenhoek. U zal gevraagd worden om de adres van een Prometheus-instantie in te vullen:

Voer http://your_domain_name:9090 in, vervangen door uw actuele domeinnaam, en scrol dan naar beneden en klik op Opslaan & testen. U zou een succesmelding moeten ontvangen:

De Prometheus-verbinding is toegevoegd aan Grafana. Klik op Verken in de zijbalk, en u zult gevraagd worden een meetraam te selecteren. U kunt kafka_ typen om alle meetraammen die gerelateerd zijn aan het cluster weer te geven, zoals getoond:

Bijvoorbeeld, selecteer de meetraam kafka_log_log_size, die laat zien hoe groot de interne log op de schijf is per partitie, en klik vervolgens op Query uitvoeren in de rechterbovenhoek. U zult de afgeleide groottes voor elke beschikbare onderwerp zien:

In deze stap heb je de JMX-metrieken geexporteerd die Kafka biedt en heb je Prometheus ingesteld om ze te halen. Daarna heb je er vanaf binnen Grafana mee verbinding gemaakt en een query uitgevoerd op de Kafka-metrieken. Nu zult u leren hoe u een Kafka-cluster kunt beheren via een webinterface.

Stap 4 – Kafka-clusters Beheren Met AKHQ

In deze stap leert u hoe u AKHQ kunt instellen en gebruiken, een webapplicatie voor het beheren van Kafka-clusters. Het stelt u in staat lijsten en objecten te bewerken, zoals topics, partities, consumentengroepen en configuratieparameters, evenals berichten te produceren en te consumeren vanuit topics van een enkele plek.

U zal de uitvoerbare bestanden en hun configuratie opslaan in een map genaamd akhq. Maak deze aan in uw home directory door de volgende opdracht uit te voeren:

mkdir ~/akhq

Navigeer erheen:

cd ~/akhq

In uw browser bezoek de officiële uitgaves pagina en kopieer de link naar het JAR-bestand van de nieuwste uitgave. Bij het schrijven van dit artikel was de nieuwste versie 0.24.0. Voer de volgende opdracht uit om het naar uw home directory te downloaden:

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

U hebt nu AKHQ gedownload en bent klaar om zijn configuratie voor het verbinden met uw cluster te definiëren. U zal dat opslaan in een bestand genaamd akhq-config.yml. Maak het bestand aan en open het voor het bewerken door de volgende opdracht uit te voeren:

nano ~/akhq/akhq-config.yml

Voeg de volgende regels toe:

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: ""

should be translated to:

Dit is een basisconfiguratie van AKHQ, waarbij één cluster is gespecificeerd op localhost:9092 met de bijbehorende SASL en TLS-parameters. Tegelijkertijd ondersteunen we ook meerdere clusters, omdat je zoveel verbindingen kunt definiëren als je wilt. Dit maakt AKHQ veelzijdig voor het beheren van Kafka. Zodra je klaar bent, bewaar en sluit het bestand.

Hierna moet je een systemd-service definiëren voor het uitvoeren van AKHQ op de achtergrond. systemd-services kunnen consistent worden gestart, gestopt en opnieuw gestart.

Je bewaart de serviceconfiguratie in een bestand genaamd code-server.service, in de map /lib/systemd/system, waar systemd zijn services opslaat. Maak het aan met behulp van je teksteditor:

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

Voeg de volgende regels toe:

[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

Je specificeert eerst de beschrijving van de service. Vervolgens, in de sectie [Service], definieer je het type service (simple betekent dat het commando simpelweg moet worden uitgevoerd) en geef je het commando dat wordt uitgevoerd. Je specificeert ook dat de gebruiker waaronder het wordt uitgevoerd kafka is en dat de service automatisch opnieuw moet worden gestart als deze wordt beëindigd.

De sectie [Install] instrueert systemd om deze service te starten wanneer je inlogt op je server. Bewaar en sluit het bestand wanneer je klaar bent.

Laad de serviceconfiguratie door het volgende uit te voeren:

sudo systemctl daemon-reload

Start de AKHQ-service door het volgende commando uit te voeren:

sudo systemctl start akhq

Controleer vervolgens of deze correct is gestart door zijn status te bekijken:

sudo systemctl status akhq

De uitvoer zou er als volgt moeten uitzien:

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 draait nu in de achtergrond. Standaard wordt het op poort 8080暴露. In uw browser navigeer naar uw domein met die poort om toegang tot het te krijgen. U zult de standaardweergave zien, die de lijst met onderwerpen toont:

U kunt dubbelklikken op de bijbehorende rij van het onderwerp in de tabel om er toe te gaan en een gedetailleerde weergave te krijgen:

AKHQ laat u de berichten in het onderwerp zien, evenals partities, consumentengroepen en hun configuratie. U kunt ook het onderwerp leegmaken of kopiëren met de knoppen in de rechterbovenhoek.

Omdat het new_topic-onderwerp leeg is, klik op de knop Produce to topic, die de interface opent om de parameters van het nieuwe bericht te selecteren:

AKHQ zal automatisch het onderwerpnaam voor u invullen. In het veld Value voer Hello World! in, klik dan op Produce. Het bericht zal naar Kafka gestuurd worden en u zult het in het tabblad Data zien:

Omdat de inhoud van een bericht erg groot kan zijn, toont AKHQ alleen de eerste regel. Om het volledige bericht te bekijken, klik op de donkere gebieden na de rij om het te tonen.

In de linker sidebar kunt u ook de brokers in het cluster vermelden door op Nodes te klikken. momenteel bestaat het cluster uit slechts één knooppunt:

Dubbelklikken op een knooppunt opent zijn configuratie, die u toestemming geeft om elke instelling op afstand te wijzigen:

Zodra je wijzigingen hebt aangebracht, kun je deze toepassen door op de knop Update configs in de rechterbenedenhoek te drukken. Op dezelfde manier kun je de configuratie van elk van de onderwerpen bekijken en wijzigen door deze te openen en over te schakelen naar het tabblad Configs.

In dit gedeelte hebt je AKHQ ingesteld, een webapplicatie die een eenvoudig te gebruiken UI biedt voor het beheren en observeren van Kafka-nodes en onderwerpen op afstand. Het stelt je in staat om berichten in onderwerpen te produceren en te consumeren en de configuratieparameters van zowel onderwerpen als nodes direct bij te werken.

Conclusie

In deze handleiding hebt je je Kafka-installatie beveiligd door TLS voor encryptie en SASL voor gebruikersauthenticatie te configureren. Je hebt ook het exporteren van metrische gegevens met behulp van Prometheus ingesteld en deze weergegeven in Grafana. Vervolgens heb je geleerd hoe je AKHQ, een webapplicatie voor het beheren van Kafka-cluster, kunt gebruiken.

De auteur heeft de Apache Software Foundation gekozen om een donatie te ontvangen als onderdeel van het Write for DOnations-programma.