Cómo proteger y supervisar Kafka

Introducción

Apache Kafka admite diversos protocolos de seguridad y flujos de trabajo de autenticación para garantizar que solo el personal y las aplicaciones autorizados puedan conectarse al clúster. En la configuración predeterminada, Kafka permite el acceso a todos, pero no se habilitan comprobaciones de seguridad. Si bien son útiles para la exploración y el desarrollo, las implementaciones de producción deben protegerse adecuadamente antes de exponerse al exterior. Además, estos entornos deben supervisarse para garantizar un funcionamiento fluido y prevenir posibles fallos.

En este tutorial, reforzará su instalación de Kafka configurando el cifrado de tráfico TLS y la autenticación SASL para proporcionar un flujo de inicio de sesión estándar con nombre de usuario y contraseña. Aprenderá a configurar los scripts de productor y consumidor proporcionados para conectarse a un clúster seguro. Después, aprenderá a exportar métricas de Kafka y visualizarlas en Grafana. También aprenderá a acceder a los nodos y temas de su clúster a través de una interfaz web intuitiva proporcionada por AKHQ.

Requisitos previos

• Una gota con al menos 4 GB de RAM y 2 procesadores. Para Ubuntu Server, siga las instrucciones de configuración del servidor inicial.
• Apache Kafka está instalado y configurado en tu Droplet. Para obtener instrucciones de configuración, sigue el tutorial "Introducción a Kafka". Solo necesitas completar los pasos 1 y 2.
• Comprenda cómo Java administra claves y certificados. Para más información, consulte el tutorial "Fundamentos de Java Keytool: Trabajar con almacenes de claves de Java".
• Grafana está instalado en su servidor o equipo local. Consulte el tutorial sobre cómo instalar y proteger Grafana en Ubuntu para obtener instrucciones. Solo necesita completar los primeros cuatro pasos.
• Un nombre de dominio completamente registrado apunta a tu droplet. Este tutorial usa "your_domain" en todo momento y apunta al mismo nombre de dominio que requiere Grafana. Puedes comprar un nombre de dominio en Namecheap, obtener uno gratis en Freenom o usar el registrador de dominios que prefieras.

Paso 1: Configurar los protocolos de seguridad de Kafka

En su configuración predeterminada, Kafka permite que cualquiera se conecte sin verificar el origen de la solicitud. Esto significa que su clúster es accesible para todos por defecto. Si bien esto es útil para las pruebas, ya que reduce la carga de mantenimiento en equipos locales e instalaciones privadas, las instalaciones de Kafka de producción y públicas deben tener habilitadas las funciones de seguridad para evitar el acceso no autorizado.

En este paso, configurará su bróker de Kafka para usar el cifrado TLS para el tráfico entre el bróker y los consumidores. También configurará SASL como marco de autenticación para la conexión al clúster.

Generación y almacenamiento de certificados TLS

Para generar los certificados y las claves necesarios para configurar TLS, utilice el script disponible en el repositorio de herramientas de seguridad de la plataforma Confluent. Primero, clónelo en su directorio personal ejecutando el siguiente comando:

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

Ir a ello:

cd ~/kafka-ssl

El script que utiliza se llama kafka-generate-ssl-automatic.sh y le solicita que proporcione su país, estado, organización y ciudad como variables de entorno. Estos parámetros se utilizan para generar los certificados, pero su contenido no es importante. También debe proporcionar una contraseña, que se utiliza para proteger la confianza de Java y el almacén de claves creado.

Para configurar las variables de entorno requeridas, ejecute los siguientes comandos, reemplazando your_tls_password con el valor deseado:

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

Tenga en cuenta que la CONTRASEÑA debe tener al menos seis caracteres.

Otorgue permisos de ejecución al script ejecutando lo siguiente:

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

Luego ejecútelo para generar los archivos necesarios:

./kafka-generate-ssl-automatic.sh

Habrá muchos resultados. Una vez completado, enumere los archivos en el directorio:

ls -l

La salida debería verse así:

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

Verá que el certificado, la confianza y el almacén de claves se han creado correctamente.

Configuración de Kafka para TLS y SASL

Ahora que tiene los archivos necesarios para habilitar el cifrado TLS, configurará Kafka para usarlos y autenticar usuarios mediante SASL.

Modificará el archivo server.properties en la sección config/kraft del directorio de instalación. Lo instaló en Kafka, en su directorio personal, como parte de los prerrequisitos. Acceda a él ejecutando:

cd ~/kafka

Abra el archivo de configuración principal para editarlo:

nano config/kraft/server.properties

Encuentra las siguientes líneas:

...
listeners=PLAINTEXT://:9092,CONTROLLER://:9093
# Name of listener used for communication between brokers.
inter.broker.listener.name=PLAINTEXT
# Listener name, hostname and port the broker will advertise to clients.
# If not set, it uses the value for "listeners".
advertised.listeners=PLAINTEXT://localhost:9092

Cámbielos por lo siguiente, reemplazando PLAINTEXT con BROKER:

...
listeners=BROKER://:9092,CONTROLLER://:9093
# Name of listener used for communication between brokers.
inter.broker.listener.name=BROKER
# Listener name, hostname and port the broker will advertise to clients.
# If not set, it uses the value for "listeners".
advertised.listeners=BROKER://localhost:9092

Luego busque la línea 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

Asigne BROKER a SASL_SSL incorporando la definición con el valor:

# 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

Aquí, agregó la definición de alias BROKER que utilizó en los oyentes y la asignó a SASL_SSL, lo que indica que se deben usar tanto SSL (el nombre anterior de TLS) como SASL.

Luego vaya al final del archivo y agregue las siguientes líneas:

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

Primero, define las ubicaciones y contraseñas para los almacenes de confianza y claves que creaste. Configura el parámetro ssl.client.auth como obligatorio, lo que indica a Kafka que deniegue cualquier conexión que no presente un certificado TLS válido. Luego, configura el mecanismo SASL como PLAIN, lo cual lo habilita. PLAIN se diferencia de PLAINTEXT en que requiere una conexión cifrada, y ambos se basan en una combinación de nombre de usuario y contraseña.

Finalmente, configure StandardAuthorizer como la clase de autorización, que compara las credenciales con el archivo de configuración que creará próximamente. A continuación, configure el parámetro allow.everyone.if.no.acl.found como falso, lo que restringe el acceso a las conexiones con credenciales inapropiadas. También seleccione el usuario administrador como superusuario, ya que debe haber al menos uno para realizar tareas administrativas en el clúster.

No olvide reemplazar your_tls_password con la contraseña que ingresó en el script en la sección anterior, luego guarde y cierre el archivo.

Ahora que ha configurado Kafka, debe crear un archivo que defina las credenciales permitidas para la conexión. Kafka es compatible con el Servicio de Autenticación y Autorización de Java (JAAS), un marco para implementar flujos de trabajo de autenticación, y acepta definiciones de credenciales en formato JAAS.

Los almacenará en un archivo llamado kafka-server-jaas.conf en config/kraft. Créelo y ábralo para editarlo ejecutando lo siguiente:

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

Añade las siguientes líneas:

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

El nombre de usuario y la contraseña especifican las credenciales principales que se usarán para la comunicación entre los brokers del clúster cuando haya varios nodos. La línea user_admin define un usuario con nombre de usuario admin y contraseña admin que puede conectarse al broker desde el exterior. Al finalizar, guarde y cierre el archivo.

Kafka necesita conocer el archivo kafka-server-jaas.conf, ya que completa la configuración principal. Debe modificar la configuración del servicio systemd de Kafka y pasarle una referencia. Ejecute el siguiente comando para abrir el servicio y editarlo:

sudo systemctl edit --full kafka

Al pasar –full, accederá al contenido completo del servicio. Busque la línea 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'
...

Añade la siguiente línea encima para que se vea así:

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

Esto establecerá el parámetro java.security.auth.login.config en la configuración en la ruta del archivo de configuración de JAAS, separándolo de la configuración principal de Kafka. Al terminar, guarde y cierre el archivo. Recargue la definición del servicio ejecutando:

sudo systemctl daemon-reload

Luego, reinicie Kafka:

sudo systemctl restart kafka

Ahora ha configurado el cifrado TLS y la autenticación SASL para su instalación de Kafka, y ahora aprenderá cómo conectarse a ella con los scripts de consola proporcionados.

Paso 2: Conéctese a un clúster seguro

En este paso, aprenderá cómo conectarse a un clúster de Kafka seguro utilizando archivos de configuración JAAS con los scripts de consola proporcionados.

Los scripts proporcionados para manipular los temas de producción y consumo de mensajes también usan Java internamente y, por lo tanto, aceptan la configuración JAAS que describe las ubicaciones del almacén de confianza y de claves, así como la autenticación SASL.

Guardará esta configuración en un archivo llamado client-jaas.conf en su directorio personal. Créelo y ábralo para editarlo:

nano ~/client-jaas.conf

Añade las siguientes líneas:

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=

Como antes, configure el protocolo SASL_SSL y proporcione las rutas y la contraseña para los almacenes de claves y de confianza que creó. Luego, configure el mecanismo SASL como PLAIN y proporcione las credenciales para el usuario admin. Borre explícitamente el parámetro ssl.endpoint.identification.algorithm para evitar problemas de conexión, ya que los scripts iniciales configuran el nombre de host del equipo en el que se ejecutan como punto final del certificado, lo cual podría ser incorrecto.

Reemplace your_tls_password con el valor apropiado, luego guarde y cierre el archivo.

Para pasar este archivo a los scripts, puede usar el parámetro --command-config. Cree un nuevo tema en el clúster con el siguiente comando:

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

El comando debería ejecutarse correctamente:

Output...
Created topic new_topic.

Para verificar que se ha creado, enumere todos los subprocesos del clúster ejecutando:

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

La salida mostrará que new_topic existe:

Output__consumer_offsets
new_topic
...

En esta sección, ha configurado su instalación de Kafka para usar cifrado TLS para el tráfico y SASL para la autenticación con una combinación de nombre de usuario y contraseña. Ahora aprenderá a exportar diversas métricas de Kafka mediante JMX con Prometheus.

Paso 3: Supervisar las métricas JMX de Kafka con Prometheus

En esta sección, usará Prometheus para recopilar métricas de Kafka y consultarlas en Grafana. Para ello, deberá configurar un exportador JMX para Kafka y conectarlo a Prometheus.

Configuración de Kafka y Prometheus

Antes de continuar, debe instalar Prometheus. En equipos Ubuntu, puede usar apt. Sus repositorios ejecutando:

sudo apt update

Luego, instala Prometheus:

sudo apt install prometheus -y

Para otras plataformas, siga las instrucciones de instalación en el sitio web oficial.

Una vez instalada, debe agregar la biblioteca de exportación JMX para Prometheus a su instalación de Kafka. Vaya a la página de versiones y seleccione la última versión con "javaagent" en el nombre. Al momento de escribir este artículo, la última versión disponible era la 0.20.0. Use el siguiente comando para descargarla al directorio libs/ donde está instalado 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

Kafka ahora seleccionará la biblioteca de exportación JMX.

Antes de habilitar el exportador, debe especificar las métricas que reportará a Prometheus y guardar esta configuración en un archivo llamado jmx-exporter.yml en el archivo config/ de su instalación de Kafka. El proyecto del exportador JMX proporciona una configuración predeterminada adecuada; ejecute el siguiente comando para guardarlo como jmx-exporter.yml en el archivo config/ de su instalación de Kafka:

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

A continuación, debe modificar el servicio systemd de Kafka para habilitar el exportador. Debe modificar la variable de entorno KAFKA_OPTS para incluir el exportador y su configuración. Ejecute el siguiente comando para editar el servicio:

sudo systemctl edit --full kafka

Cambie la línea de Entorno a lo siguiente:

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"

Aquí, utiliza el argumento -javaagent para inicializar el exportador JMX con su configuración.

Cuando haya terminado, guarde y cierre el archivo, luego inicie Kafka ejecutando:

sudo systemctl restart kafka

Después de un minuto, verifique que el exportador JMX se esté ejecutando consultando si el puerto 7075 está en uso:

sudo ss -tunelp | grep 7075

La salida debería verse así:

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

Esta línea indica que el puerto 7075 es utilizado por un proceso Java iniciado por el servicio Kafka que apunta al exportador JMX.

Ahora configurará Prometheus para monitorizar las métricas JMX exportadas. Su archivo de configuración principal se encuentra en /etc/prometheus/prometheus.yml, así que ábralo para editarlo:

sudo nano /etc/prometheus/prometheus.yml

Encuentra las siguientes líneas:

...
# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
# The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
- job_name: 'prometheus'
# Override the global default and scrape targets from this job every 5 seconds.
scrape_interval: 5s
scrape_timeout: 5s
# metrics_path defaults to '/metrics'
# scheme defaults to 'http'.
static_configs:
- targets: ['localhost:9090']
- job_name: node
# If prometheus-node-exporter is installed, grab stats about the local
# machine by default.
static_configs:
- targets: ['localhost:9100']

En la sección scrape_configs que especifica qué puntos finales debe vigilar Prometheus, agregue una nueva sección para extraer métricas de Kafka:

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
# The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
- job_name: 'prometheus'
# Override the global default and scrape targets from this job every 5 seconds.
scrape_interval: 5s
scrape_timeout: 5s
# metrics_path defaults to '/metrics'
# scheme defaults to 'http'.
static_configs:
- targets: ['localhost:9090']
- job_name: node
# If prometheus-node-exporter is installed, grab stats about the local
# machine by default.
static_configs:
- targets: ['localhost:9100']
- job_name: 'kafka'
static_configs:
- targets: ['your_domain:7075']

Un trabajo de Kafka tiene un destino que apunta a un punto final de exportación JMX.

Recuerda reemplazar "your_domain" por tu nombre de dominio, luego guarda y cierra el archivo. Luego, inicia Prometheus ejecutando:

sudo systemctl restart prometheus

En su navegador, diríjase al puerto 9090 de su dominio. Accederá a la interfaz de Prometheus. En la sección Estado, haga clic en Objetivos para ver los trabajos:

Tenga en cuenta que Prometheus ha asumido el trabajo de Kafka y ha comenzado a extraer sus métricas. Ahora aprenderá a acceder a ellas en Grafana.

Consulta de métricas en Grafana

Como requisito previo, has instalado Grafana en tu Droplet y lo has ubicado en tu_dominio. Accede a él en tu navegador y, en la sección "Conexiones" de la barra lateral, haz clic en "Agregar nueva conexión" y escribe Prometheus en el campo de búsqueda.

Haga clic en Prometheus y luego en el botón "Agregar nueva fuente de datos" en la esquina superior derecha. Se le solicitará que complete la dirección de la instancia de Prometheus:

Introduce http://your_domain_name:9090, reemplazando tu nombre de dominio actual. Desplázate hacia abajo y pulsa Guardar y probar. Deberías ver un mensaje de confirmación:

Se ha añadido la conexión Prometheus a Grafana. Pulse "Explorar" en la barra lateral y se le pedirá que seleccione una métrica. Puede escribir "kafka_" para ver todas las métricas relacionadas con el clúster, como se muestra a continuación:

Por ejemplo, seleccione la métrica kafka_log_log_size, que muestra el tamaño del registro del disco interno en cada partición, y luego pulse "Ejecutar consulta" en la esquina superior derecha. Verá los tamaños resultantes a lo largo del tiempo para cada uno de los temas disponibles:

En este punto, ha configurado las métricas del exportador JMX que proporciona Kafka y Prometheus para extraerlas. Luego, se conectó a él desde Grafana y realizó una consulta sobre las métricas de Kafka. Ahora aprenderá a administrar un clúster de Kafka mediante una interfaz web.

Paso 4: Gestión de clústeres de Kafka con AKHQ

En este paso, aprenderá a configurar y usar AKHQ, una aplicación web para administrar clústeres de Kafka. Le permite listar y manipular temas, particiones, grupos de consumidores y parámetros de configuración, así como generar y consumir mensajes de temas desde una única ubicación.

Guardará el ejecutable y su archivo de configuración en un directorio llamado akhq. Créelo en su directorio personal ejecutando lo siguiente:

mkdir ~/akhq

Ir a ello:

cd ~/akhq

En su navegador, visite la página oficial de versiones y copie el enlace al archivo JAR más reciente. Al momento de escribir esto, la última versión era la 0.24.0. Ejecute el siguiente comando para descargarlo a su directorio personal:

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

Ya ha descargado AKHQ y está listo para definir su configuración para conectarse a su clúster. Lo guardará en un archivo llamado akhq-config.yml. Créelo y ábralo para editarlo ejecutando lo siguiente:

nano ~/akhq/akhq-config.yml

Añade las siguientes líneas:

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

Esta es una configuración básica de AKHQ que especifica un clúster en localhost:9092 con los parámetros SASL y TLS especificados. También se admiten varios clústeres simultáneamente, ya que puede definir tantas conexiones como desee. Esto hace que AKHQ sea versátil para la gestión de Kafka. Al terminar, guarde y cierre el archivo.

A continuación, debe definir un servicio systemd para ejecutar AKHQ en segundo plano. Los servicios systemd pueden iniciarse, detenerse y reiniciarse continuamente.

La configuración del servicio se almacena en un archivo llamado code-server.service en el directorio /lib/systemd/system, donde systemd almacena sus servicios. Créelo con su editor de texto:

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

Añade las siguientes líneas:

[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

Primero, especifique la descripción del servicio. Luego, en el campo [Servicio], defina el tipo de servicio (simple significa que el comando debe ejecutarse de forma sencilla) y proporcione el comando que se ejecutará. También especifique que el usuario lo ejecutará como si fuera Kafka y que se reiniciará automáticamente si el servicio finaliza.

La sección [Instalar] indica al sistema que inicie este servicio cuando pueda iniciar sesión en su servidor. Al finalizar, guarde y cierre el archivo.

Cargue la configuración del servicio ejecutando:

sudo systemctl daemon-reload

Inicie el servicio AKHQ ejecutando el siguiente comando:

sudo systemctl start akhq

Luego, comprueba que se inició correctamente visualizando su estado:

sudo systemctl status akhq

La salida debería verse así:

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 se ejecuta ahora en segundo plano. De forma predeterminada, se muestra en el puerto 8080. En su navegador, navegue a su dominio con ese puerto para acceder. Verá la vista predeterminada, que muestra una lista de temas:

Puede hacer doble clic en la fila con el tema en la tabla para acceder a él y obtener una vista detallada:

AKHQ le permite ver los mensajes del tema, así como las particiones, los grupos de consumidores y su configuración. También puede vaciar o copiar el tema usando los botones de la esquina inferior derecha.

Como el tema new_topic está vacío, presione el botón Producir a tema, que abre la interfaz para seleccionar los parámetros del nuevo mensaje:

AKHQ completará automáticamente el nombre del tema. En el campo Valor, escriba "¡Hola mundo!" y luego pulse "Producir". El mensaje se enviará a Kafka y lo verá en la pestaña Datos.

Dado que el contenido de un mensaje puede ser muy extenso, AKHQ solo muestra la primera línea. Para ver el mensaje completo, haga clic en el área oscura después de la fila para revelarlo.

En la barra lateral izquierda, puede ver los brokers del clúster haciendo clic en Nodos. Actualmente, el clúster consta de un solo nodo:

Al hacer doble clic en un nodo se abre su configuración, lo que le permite cambiar cualquiera de las configuraciones de forma remota:

Una vez realizados los cambios, puedes aplicarlos pulsando el botón "Actualizar configuración" en la esquina inferior derecha. Asimismo, puedes ver y cambiar la configuración de cada tema accediendo a ellos y yendo a la pestaña "Configuración".

En esta sección, ha configurado AKHQ, una aplicación web que proporciona una interfaz intuitiva para gestionar y visualizar nodos y temas de Kafka de forma remota. Permite generar y consumir mensajes en temas, así como actualizar los parámetros de configuración de ambos, sobre la marcha.

Resultado

En este tutorial, protegiste tu instalación de Kafka configurando TLS para el cifrado y SASL para la autenticación de usuarios. También configuraste exportaciones de métricas con Prometheus y las visualizaste en Grafana. A continuación, aprendiste a usar AKHQ, una aplicación web para gestionar clústeres de Kafka.