Come proteggere e monitorare Kafka

Introduzione

Apache Kafka supporta vari protocolli di sicurezza e flussi di autenticazione per garantire che solo personale e applicazioni autorizzati possano connettersi al cluster. Nella sua configurazione predefinita, Kafka permette l’accesso a tutti ma non ha attivate verifiche di sicurezza. Sebbene questo sia utile per esplorare e sviluppare, le distribuzioni di produzione devono essere adeguatamente protette prima di essere esposte al mondo esterno. Inoltre, tali ambienti devono essere monitorati per garantire un funzionamento senza problemi e prevenire possibili guasti.

In questo tutorial,加固inerai la tua installazione di Kafka configurando la crittografia del traffico TLS e l’autenticazione SASL per fornire un flusso di login standard con nome utente e password. Vedrai come configurare gli script di produttore e consumatore forniti per connettersi a un cluster sicuro. Poi, imparerai come esportare le metriche di Kafka e visualizzarle in Grafana. Inoltre, scoprirai come accedere ai nodi e ai topic del tuo cluster tramite un’interfaccia web facile da usare fornita da AKHQ.

Prerequisiti

Per completare questo tutorial, avrai bisogno di:

• Una Droplet con almeno 4GB di RAM e 2 CPU. Nel caso di un server Ubuntu, segui la guida Initial Server Setup per le istruzioni di setup.
• Apache Kafka è installato e configurato sulla tua droplet. Per le istruzioni di setup, segui il tutorial Introduction to Kafka. Devi completare solo il Passo 1 e il Passo 2.
• Una comprensione di come Java gestisce chiavi e certificati. Per ulteriori informazioni, visita il tutorial Java Keytool Essentials: Working with Java Keystores.
• Grafana installato sul tuo server o macchina locale. Per favore, visita il tutorial How To Install and Secure Grafana on Ubuntu per le istruzioni. Devi completare solo i primi quattro passaggi.
• Un dominio completamente registrato è puntato alla tua droplet. Questo tutorial utilizzerà your_domain throughout e si riferirà allo stesso nome di dominio richiesto da Grafana. Puoi acquistare un nome di dominio su Namecheap, ottenerne uno gratuitamente su Freenom, o utilizzare il registratore di domini del tuo choix.

Passo 1 – Configurazione dei Protocolli di Sicurezza di Kafka

Nella sua configurazione predefinita, Kafka permette a chiunque di connettersi senza verificare l’origine della richiesta. Questo significa che il tuo cluster è accessibile a tutti per impostazione predefinita. Sebbene questo sia adatto per i test, poiché riduce il carico di manutenzione su macchine locali e installazioni private, le installazioni di Kafka in produzione e rivolte al pubblico devono avere le funzionalità di sicurezza abilitate per prevenire l’accesso non autorizzato.

In questo passo, configurerai il tuo broker Kafka per utilizzare la crittografia TLS per il traffico tra il broker e i consumatori. Inoltre, configurerai SASL come framework di autenticazione per verificare le credenziali durante la connessione al cluster.

Generazione di Certificati TLS e Magazzini

Per generare i certificati e le chiavi necessari per l’impostazione di TLS, utilizzerai lo script dal repository Strumenti di Sicurezza della Piattaforma Confluent. Prima,克隆lo nella tua directory home eseguendo il seguente comando:

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

Naviga al suo interno:

cd ~/kafka-ssl

Lo script che utilizzerai si chiama kafka-generate-ssl-automatic.sh, e richiede di fornire il paese, lo stato, l’organizzazione e la città come variabili d’ambiente. Questi parametri vengono utilizzati per creare i certificati, ma il loro contenuto non è rilevante. Dovrai anche fornire una password, che viene utilizzata per proteggere il trust store e il key store Java che verranno generati.

Esegui i seguenti comandi per impostare le variabili d’ambiente richieste, sostituendo your_tls_password con il valore desiderato:

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

Nota che la PASSWORD deve essere almeno di sei caratteri.

Dai al script i permessi di esecuzione eseguendo:

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

Poi, eseguilo per generare i file richiesti:

./kafka-generate-ssl-automatic.sh

Ci sarà molto output. Una volta completato, elenca i file nella directory:

ls -l

L’output dovrebbe apparire simile a questo:

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

Vedrai che il certificato, il trust store e il key store sono stati creati con successo.

Configurazione di Kafka per TLS e SASL

Ora che hai i file necessari per abilitare la crittografia TLS, configurerai Kafka per utilizzarli e autenticare gli utenti utilizzando SASL.

the Italian language:

Modificherai il file server.properties situato in config/kraft nella directory di installazione. L’hai installato in kafka nella tua directory home come parte dei prerequisiti. Vai a esso eseguendo:

cd ~/kafka

Apri il file di configurazione principale per la modifica:

nano config/kraft/server.properties

Trova le seguenti righe:

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

# Nome del listener utilizzato per la comunicazione tra broker.
inter.broker.listener.name=PLAINTEXT

# Nome del listener, nome host e porta che il broker announcerà ai clienti.
# Se non impostato, utilizza il valore per "listeners".
advertised.listeners=PLAINTEXT://localhost:9092

Modificali in questo modo, sostituendo PLAINTEXT con BROKER:

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

# Nome del listener utilizzato per la comunicazione tra broker.
inter.broker.listener.name=BROKER

# Nome del listener, nome host e porta che il broker announcerà ai clienti.
# Se non impostato, utilizza il valore per "listeners".
advertised.listeners=BROKER://localhost:9092

Poi, trova la riga listener.security.protocol.map:

# Mappa i nomi dei listener ai protocolli di sicurezza, il valore predefinito è che siano uguali. Vedi la documentazione di configurazione per ulteriori dettagli
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Mappa BROKER a SASL_SSL aggiungendo la definizione al valore:

# Mappa i nomi dei listener ai protocolli di sicurezza, il valore predefinito è che siano uguali. Vedi la documentazione di configurazione per ulteriori dettagli
listener.security.protocol.map=BROKER:SASL_SSL,CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Qui, hai aggiunto la definizione dell’alias BROKER che hai utilizzato nei listener e l’hai mappato a SASL_SSL, che indica che saranno utilizzati sia SSL (un nome precedente di TLS) che SASL.

Successivamente, naviga fino alla fine del file e aggiungi le seguenti righe:

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

Prima di tutto, definisci le posizioni e le password per i trust store e key store generati. Imposti il parametro ssl.client.auth a required, istruendo Kafka a negare qualsiasi connessione che non presenti un certificato TLS valido. Poi imposti il meccanismo SASL a PLAIN, che lo abilita. PLAIN differisce da PLAINTEXT in quanto richiede l’uso di una connessione criptata e entrambi si basano su una combinazione di nome utente e password.

Infine, imposti la classe StandardAuthorizer come classe autorizzatrice, che verifica le credenziali contro un file di configurazione che creerai tra poco. Poi imposti il parametro allow.everyone.if.no.acl.found a false, limitando l’accesso per connessioni con credenziali inappropriate. Anche l’utente admin viene denotato come superutente, poiché deve essere almeno uno per svolgere attività amministrative nel cluster.

ricorda di sostituire your_tls_password con la password fornita al script nel capitolo precedente, quindi salva e chiudi il file.

Ora che hai configurato Kafka, dovrai creare un file che definisce le credenziali consentite per la connessione. Kafka supporta il Java Authentication and Authorization Service (JAAS), un framework per implementare flussi di autenticazione, e accetta definizioni di credenziali nel formato JAAS.

Le memorizzerai in un file chiamato kafka-server-jaas.conf nella cartella config/kraft. Crealo e aprilo per la modifica eseguendo:

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

Aggiungi le seguenti righe:

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

La username e password definiscono le credenziali principali utilizzate per la comunicazione tra broker nel cluster quando ci sono più nodi presenti. La riga user_admin definisce un utente il cui nome utente è admin con password admin, che può connettersi al broker dall’esterno. Salva e chiudi il file quando hai finito.

Kafka deve essere consapevole del file kafka-server-jaas.conf poiché complementa la configurazione principale. Dovrai modificare la configurazione del servizio systemd di kafka e passare un riferimento ad esso. Esegui il seguente comando per aprire il servizio per la modifica:

sudo systemctl edit --full kafka

Passando --full, ottieni accesso ai contenuti completi del servizio. Trova la riga 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'
...

Aggiungi la seguente riga sopra di essa, in modo che sia così:

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

Con questo imposti il parametro java.security.auth.login.config nella configurazione sul percorso del file di configurazione JAAS, decoupleandolo dalla configurazione principale di Kafka. Quando sei pronto, salva e chiudi il file. Ricarica la definizione del servizio eseguendo:

sudo systemctl daemon-reload

Poi, riavvia Kafka:

sudo systemctl restart kafka

Ora hai configurato sia l’encrusione TLS che l’autenticazione SASL per la tua installazione di Kafka, e imparerai come connetterti a questa usando i script di console forniti.

Step 2 – Connessione a un Cluster Protetto

In questo passaggio, imparerai come connetterti a un cluster di Kafka protetto usando i file di configurazione JAAS con i script di console forniti.

I script forniti per la gestione dei topic, la produzione e la consumazione di messaggi usano Java internamente, quindi accettano una configurazione JAAS che descrive le posizioni del trust store e del key store, nonché le credenziali SASL.

Salverai quella configurazione in un file chiamato client-jaas.conf nella tua directory home. Crea e apriti il file per la modifica:

nano ~/client-jaas.conf

Aggiungi le seguenti righe:

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=

Come prima, imposti il protocollo come SASL_SSL e fornisci i percorsi e le password per i key store e trust store che hai creato. Poi, imposti il meccanismo SASL come PLAIN e fornisci le credenziali per l’utente admin. In maniera esplicita, svuotate il parametro ssl.endpoint.identification.algorithm per prevenire problemi di connessione, poiché gli script iniziali impostano il nome host della macchina su cui viene eseguito come endpoint del certificato, che potrebbe non essere corretto.

Sostituisci your_tls_password con il valore corretto, quindi salva e chiudi il file.

Per inviare questo file agli script, puoi utilizzare il parametro --command-config. Prova a creare un nuovo topic nel cluster usando il seguente comando:

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

Il comando dovrebbe essere eseguito con successo:

Output
...
Created topic new_topic.

Per verificare che sia stato creato, elenca tutti i topic nel cluster eseguendo:

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

L’output mostrerà che new_topic è presente:

Output
__consumer_offsets
new_topic
...

In questa sezione, hai configurato la tua installazione di Kafka per usare l’encrisione TLS per il traffico e SASL per l’autenticazione con combinazioni di nome utente e password. Ora imparerai come esportare varie metriche di Kafka attraverso JMX usando Prometheus.

Step 3 – Monitoraggio delle metriche JMX di Kafka usando Prometheus

In questa sezione, utilizzerai Prometheus per raccogliere le metriche di Kafka e renderle consultabili in Grafana. Questo implica configurare l’esportatore JMX per Kafka e collegarlo a Prometheus.

[Java Management Extensions (JMX) è un framework per le applicazioni Java che consente agli sviluppatori di raccogliere metriche generali e personalizzate riguardanti il funzionamento dell’applicazione in runtime in un formato standardizzato. Dato che Kafka è scritto in Java, supporta il protocollo JMX e espone le sue metriche personalizzate attraverso di esso, come lo stato dei topic e dei broker.

Configurazione di Kafka e Prometheus

Prima di procedere, dovrai installare Prometheus. Sulle macchine Ubuntu, puoi utilizzare apt. Aggiorna i suoi repository eseguendo:

sudo apt update

Poi, installa Prometheus:

sudo apt install prometheus -y

Per altre piattaforme, segui le istruzioni di installazione sul sito ufficiale.

Una volta installato, dovrai aggiungere la libreria JMX exporter per Prometheus alla tua installazione di Kafka. Navigare alla pagina releases e selezionare l’ultima versione in uscita con javaagent nel nome. Al momento della scrittura, l’ultima versione disponibile era 0.20.0. Usare il comando seguente per scaricarla nella directory libs/ dove è installato Kafka:

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 libreria JMX exporter sarà ora caricata da Kafka.

Prima di attivare l’esportatore, devi definire quali metriche saranno segnalate a Prometheus, e il configuration file dovrai salvarlo con il nome jmx-exporter.yml nella directory config/ dell’installazione di Kafka. Il progetto JMX exporter fornisce una configurazione predefinita appropriata, quindi eseguire il seguente comando per salvarla come jmx-exporter.yml nella directory config/ dell’installazione di Kafka:

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

Successivamente, per attivare l’esportatore, dovrai modificare il servizio systemd di Kafka. Dovrai modificare la variabile d’ambiente KAFKA_OPTS per includere l’esportatore e la sua configurazione. Eseguire il seguente comando per modificare il servizio:

sudo systemctl edit --full kafka

Modificare la riga Environment così:

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"

Qui, utilizzi l’argomento -javaagent per inizializzare l’esportatore JMX con la sua configurazione.

Salva e chiudi il file quando sei pronto, poi riavvia Kafka eseguendo:

sudo systemctl restart kafka

Dopo un minuto, verifica che l’esportatore JMX sia in esecuzione facendo una richiesta sulla porta 7075:

sudo ss -tunelp | grep 7075

La riga successiva apparirà come questa:

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

Questa riga mostra che il porto 7075 è in uso da un processo Java avviato dal servizio Kafka, riferito all’esportatore JMX.

Ora configurerai Prometheus per supervisionare le metriche JMX esportate. Il suo file di configurazione principale si trova in /etc/prometheus/prometheus.yml, quindi lo apri per le modifiche:

sudo nano /etc/prometheus/prometheus.yml

Cerca le seguenti righe:

...
# Una configurazione di scarica contenente esattamente un endpoint da scaricare:
# qui è Prometheus stesso.
scrape_configs:
  # Il nome del job viene aggiunto come etichetta `job=` a qualsiasi serie di tempo estratta da questa configurazione.
  - job_name: 'prometheus'

    # Sovrascrivi il default globale e scarica i target da questo job ogni 5 secondi.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path predefinito è '/metrics'
    # scheme predefinito è 'http'.

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

  - job_name: node
    # Se prometheus-node-exporter è installato, preleva statistiche sulla macchina locale
    # di default.
    static_configs:
      - targets: ['localhost:9100']

Inserisci sotto scrape_configs, che specifica quali endpoint Prometheus dovrebbe monitorare, una nuova sezione per l’estrazione delle metriche di Kafka:

# Una configurazione di scrape contenente esattamente un endpoint da scrape:
# Qui è Prometheus stesso.
scrape_configs:
  # Il nome del job viene aggiunto come etichetta `job=<job_name>` a qualsiasi timeseries raccolta da questa configurazione.
  - job_name: 'prometheus'

    # Sostituisce il valore predefinito globale e raccoglie target da questo job ogni 5 secondi.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path è predefinito a '/metrics'
    # scheme è predefinito a 'http'.

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

  - job_name: node
    # Se prometheus-node-exporter è installato, raccoglie statistiche sulla macchina locale
    # per impostazione predefinita.
    static_configs:
      - targets: ['localhost:9100']

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

Il job kafka ha un target, che punta all’endpoint del JMX exporter.

Ricorda di sostituire your_domain con il tuo nome di dominio, poi salva e chiudi il file. Quindi, riavvia Prometheus eseguendo:

sudo systemctl restart prometheus

Nel tuo browser, naviga alla porta 9090 del tuo dominio. Accederai all’interfaccia utente di Prometheus. Sotto Stato, premi su Target per elencare i job:

Noti che Prometheus ha accettato il job kafka e ha iniziato a raccogliere le sue metriche. Ora vedrai come accedere a queste in Grafana.

Query di metriche in Grafana

Come parte dei prerequisiti, hai installato Grafana sul tuo Droplet e l’hai reso accessibile a your_domain. Naviga a questo indirizzo nel tuo browser, e sotto Connettioni nella barra laterale, clicca su Aggiungi nuova connessione, quindi immetti Prometheus nel campo di ricerca.

Clicca su Prometheus, quindi clicca sul pulsante Aggiungi nuova sorgente dati in alto a destra. Ti verrà chiesto di immettere l’indirizzo di una istanza di Prometheus:

Inserisci http://your_domain_name:9090, sostituendo il tuo dominio reale, quindi scorri giù e clicca su Salva & testa. Dovresti ricevere un messaggio di successo:

La connessione Prometheus è stata aggiunta a Grafana. Clicca su Esplora nella barra laterale, e verrai chiesto di selezionare una metrica. Puoi inserire kafka_ per elencare tutte le metriche relative al cluster, come mostrato:

Per esempio, seleziona la metrica kafka_log_log_size, che mostra la dimensione del log interno su disco per ogni partizione, quindi clicca sul pulsante Esegui query in alto a destra. Vedrai le dimensioni risultanti nel tempo per ciascuna delle topic disponibili:

In questo step, hai impostato l’esportazione delle metriche JMX fornite da Kafka e configurato Prometheus per scaricarle. Poi, tu sei connesso a questo da Grafana e hai eseguito una query sulle metriche di Kafka. Ora, imparerai come gestire un cluster Kafka utilizzando una interfaccia web.

Step 4 – Gestione dei cluster Kafka con AKHQ

In questo step, imparerai come installare e utilizzare AKHQ, una web app per la gestione dei cluster Kafka. Permette di elencare e manipolare i topic, le partizioni, i gruppi di consumer e i parametri di configurazione, nonché di produrre e consumare messaggi da topic in un unico posto.

Salverai l’eseguibile e la sua configurazione in una directory chiamata akhq. Crea questa directory nel tuo directory home eseguendo:

mkdir ~/akhq

Vai a questa directory:

cd ~/akhq

In tuo browser, visita la pagina ufficiali release e copia il link del file JAR dell’ultima release. Al momento della scrittura, l’ultima versione era 0.24.0. Esegui il comando seguente per scaricarlo nella tua directory home:

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

Ora hai scaricato AKHQ e sei pronto a definire la sua configurazione per connetterti al tuo cluster. Salverai questa configurazione in un file chiamato akhq-config.yml. Crea e apri questo file per la modifica eseguendo:

nano ~/akhq/akhq-config.yml

Aggiungi le seguenti righe:

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

Questa è una configurazione di base di AKHQ, che specifica un cluster a localhost:9092 con i relativi parametri SASL e TLS. E’ anche supportato il funzionamento simultaneo di molti cluster poiché puoi definire quante connessioni desideri. Questo rende AKHQ versatile per la gestione di Kafka. Una volta fatto, salva e chiudi il file.

Successivamente, dovrai definire un servizio systemd per lanciare AKHQ in background. I servizi systemd possono essere avviati, arrestati e riavviati in modo coerente.

Verrà memorizzato il configurazione del servizio in un file chiamato code-server.service, nella directory /lib/systemd/system, dove systemd memorizza i suoi servizi. Crea il file usando il tuo editor di testo:

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

Aggiungi le seguenti righe:

[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

Inizialmente specifici la descrizione del servizio. Poi, nella sezione [Service], definisci il tipo di servizio (simple significa che il comando dovrebbe essere eseguito semplicemente) e fornisci il comando che verrà eseguito. Specifici anche che l’utente in cui sarà eseguito è kafka e che il servizio dovrebbe essere riavviato automaticamente se esce.

Nella sezione [Install] ordini a systemd di avviare questo servizio quando puoi accedere al tuo server. Salva e chiudi il file quando sei pronto.

Carica la configurazione del servizio eseguendo:

sudo systemctl daemon-reload

Avvia il servizio AKHQ eseguendo il seguente comando:

sudo systemctl start akhq

Poi, verifica che sia stato avviato correttamente osservando il suo stato:

sudo systemctl status akhq

L’output dovrebbe assomigliare a questo:

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 è ora in esecuzione in background. Per impostazione predefinita, è accessibile sulla porta 8080. Nel tuo browser, naviga al tuo dominio con quella porta per accedervi. Vedrai la vista predefinita, che mostra l’elenco degli argomenti:

Puoi fare doppio clic sulla riga corrispondente dell’argomento nella tabella per accedervi e ottenere una vista dettagliata:

AKHQ ti permette di vedere i messaggi nell’argomento, nonché le partizioni, i gruppi di consumatori e la loro configurazione. Puoi anche svuotare o copiare l’argomento utilizzando i pulsanti in basso a destra.

Dato che l’argomento new_topic è vuoto, premi il pulsante Produce to topic, che aprirà l’interfaccia per selezionare i parametri del nuovo messaggio:

AKHQ riempirà automaticamente il nome dell’argomento per te. Nel campo Value, inserisci Hello World!, poi premi Produce. Il messaggio sarà inviato a Kafka, e lo vedrai nella scheda Data:

Dato che il contenuto di un messaggio può essere molto grande, AKHQ mostra solo la prima riga. Per vedere il messaggio completo, premi sull’area oscurata dopo la riga per rivelarlo.

Nella barra laterale sinistra, puoi anche elencare i broker nel cluster premendo su Nodes. Al momento, il cluster consiste in un solo nodo:

Facendo doppio clic su un nodo aprirà la sua configurazione, permettendoti di cambiare qualsiasi impostazione in remoto:

Dopo aver effettuato le modifiche, puoi applicarle premendo il pulsante Aggiorna configurazioni in basso a destra. Allo stesso modo, puoi visualizzare e modificare la configurazione di qualsiasi argomento accedendovi e passando alla scheda Configurazioni.

In questa sezione, hai configurato AKHQ, un’applicazione web che fornisce un’interfaccia utente semplice da usare per gestire e osservare nodi e argomenti Kafka in remoto. ti consente di produrre e consumare messaggi negli argomenti e aggiornare i parametri di configurazione sia degli argomenti che dei nodi al volo.

Conclusione

In questo tutorial, hai reso sicura la tua installazione Kafka configurando TLS per la crittografia e SASL per l’autenticazione degli utenti. Hai anche configurato l’export delle metriche utilizzando Prometheus e le hai visualizzate in Grafana. Successivamente, hai imparato come utilizzare AKHQ, un’applicazione web per la gestione dei cluster Kafka.

L’autore ha scelto di destinare una donazione alla Apache Software Foundation come parte del programma Write for DOnations.