Cómo asegurar y monitorear Kafka

Introducción

Apache Kafka admite varios protocolos de seguridad y flujos de autenticación para garantizar que solo personal y aplicaciones autorizadas puedan conectarse al clúster. En su configuración predeterminada, Kafka permite acceso a todos pero no activa ninguna comprobación de seguridad. Aunque esto es útil para explorar y desarrollar, las implementaciones en producción deben asegurarse adecuadamente antes de exponerse al mundo exterior. Además, estos entornos deben monitorearse para garantizar un funcionamiento fluido y prevenir posibles fallos.

En este tutorial, hardeará su instalación de Kafka configurando cifrado de tráfico TLS y autenticación SASL para proporcionar un flujo de inicio de sesión estándar con nombre de usuario y contraseña. Verá cómo configurar los scripts del productor y el consumidor proporcionados para conectarse a un clúster protegido. A continuación, aprenderá cómo exportar las métricas de Kafka y visualizarlas en Grafana. También aprenderá cómo acceder a los nodos y temas de su clúster a través de una interfaz web fácil de usar proporcionada por AKHQ.

Prerequisitos

Para completar este tutorial, necesitará:

• Una Droplet con al menos 4GB de RAM y 2 procesadores. En el caso de un servidor Ubuntu, siga los Ajustes Iniciales del Servidor para las instrucciones de configuración.
• Apache Kafka está instalado y configurado en su droplet. Para las instrucciones de configuración, siga el tutorial Introducción a Kafka. Solo debe completar Paso 1 y Paso 2.
• Un entendimiento de cómo Java maneja claves y certificados. Para obtener más información, visitar el tutorial Java Keytool Essentials: Working with Java Keystores.
• Grafana instalado en su servidor o máquina local. Por favor, visitar el tutorial Cómo Instalar y Asegurar Grafana en Ubuntu para las instrucciones. Solo necesita completar los primeros cuatro pasos.
• Un nombre de dominio completamente registrado que se apunte a su droplet. Este tutorial usará your_domain a lo largo y se referirá al mismo nombre de dominio que el requisito previo de Grafana. Puede comprar un nombre de dominio en Namecheap, obtener uno gratuito en Freenom, o usar el registrador de dominios de su elección.

Paso 1 – Configuración de los Protocolos de Seguridad de Kafka

En su configuración estándar, Kafka permite que cualquiera se conecte a él sin verificar el origen de la solicitud. Esto significa que, por defecto, tu clúster es accesible para todos. Aunque esto es aceptable para pruebas, ya que reduce la carga de mantenimiento en máquinas locales e instalaciones privadas, las instalaciones de Kafka de producción y de cara al público deben tener habilitadas características de seguridad para evitar accesos no autorizados.

En este paso, configurarás tu broker de Kafka para que utilice el cifrado TLS para el tráfico entre el broker y los consumidores. También configurarás SASL como el marco de autenticación para verificar las credenciales al conectarse al clúster.

Generación de Certificados y Almacenes TLS

Para generar los certificados y claves necesarios para configurar TLS, utilizarás el script del repositorio Herramientas de Seguridad de la Plataforma Confluent. Primero, clónalo en tu directorio de inicio ejecutando el siguiente comando:

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

Navega a él:

cd ~/kafka-ssl

El script que utilizarás se llama kafka-generate-ssl-automatic.sh, y requiere que proporciones tu país, estado, organización y ciudad como variables de entorno. Estos parámetros se utilizan para crear los certificados, pero el contenido de ellos no es importante. También necesitarás proporcionar una contraseña, que se utiliza para proteger la tienda de claves y confianza de Java que se generará.

Ejecuta los siguientes comandos para configurar las variables de entorno necesarias, reemplazando your_tls_password por el valor deseado:

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

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

Da permisos ejecutables al script ejecutando:

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

Luego, ejecútalo para generar los archivos requeridos:

./kafka-generate-ssl-automatic.sh

Habrá mucha salida. Cuando termine, lista los archivos en el directorio:

ls -l

La salida debería ser similar a esta:

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

Verás que el certificado, la confianza y la tienda de claves se han creado con éxito.

Configurando Kafka para TLS y SASL

Ahora que tienes los archivos necesarios para habilitar el cifrado TLS, configurarás Kafka para utilizarlos y autenticar a los usuarios utilizando SASL.

Vas a modificar el archivo server.properties ubicado en config/kraft dentro de la carpeta de instalación. Lo instalaste en kafka en tu directorio personal como parte de los prerequisitos. Vaya a él ejecutando:

cd ~/kafka

Abre el archivo de configuración principal para edición:

nano config/kraft/server.properties

Busca las siguientes líneas:

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

# Nombre del listener utilizado para la comunicación entre brokers.
inter.broker.listener.name=PLAINTEXT

# Nombre del listener, hostname y puerto que el broker anunciará a los clientes.
# Si no se establece, utiliza el valor para "listeners".
advertised.listeners=PLAINTEXT://localhost:9092

Modifícalas para que sean como estas, reemplazando PLAINTEXT con BROKER:

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

# Nombre del listener utilizado para la comunicación entre brokers.
inter.broker.listener.name=BROKER

# Nombre del listener, hostname y puerto que el broker anunciará a los clientes.
# Si no se establece, utiliza el valor para "listeners".
advertised.listeners=BROKER://localhost:9092

A continuación, busca la línea listener.security.protocol.map:

# Mapea los nombres de listener a protocolos de seguridad, por defecto son los mismos. Vea la documentación de la configuración para más detalles
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Mapear BROKER a SASL_SSL añadiendo la definición al valor:

# Mapea los nombres de listener a protocolos de seguridad, por defecto son los mismos. Vea la documentación de la configuración para más detalles
listener.security.protocol.map=BROKER:SASL_SSL,CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

Aquí, has añadido la definición para el alias BROKER que has utilizado en los listeners y lo has mapeado a SASL_SSL, lo que significa que se deben utilizar tanto SSL (un nombre anterior para TLS) como SASL.

A continuación, navega hasta el final del archivo y añade 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 defines las ubicaciones y contraseñas para los almacenes de confianza y claves generados. Estableces el parámetro ssl.client.auth a required, instruyendo a Kafka para que no permita ninguna conexión que no presente un certificado TLS válido. Luego, estableces el mecanismo SASL en PLAIN, lo que lo habilita. PLAIN es diferente de PLAINTEXT en que requiere el uso de una conexión cifrada, y ambos dependen de una combinación de credenciales de nombre de usuario y contraseña.

Finalmente, estableces StandardAuthorizer como la clase autorizadora, que verifica las credenciales contra un archivo de configuración que crearás pronto. Luego, estableces el parámetro allow.everyone.if.no.acl.found en false, restringiendo el acceso para conexiones con credenciales inapropiadas. También designas al usuario admin como superusuario, ya que debe haber al menos uno para realizar tareas administrativas en el clúster.

Recuerda reemplazar your_tls_password con la contraseña que has pasado al script en la sección anterior, luego guarda y cierra el archivo.

Ahora que ha configurado Kafka, necesitará crear un archivo que define las credenciales permitidas para la conexión. Kafka admite el Servicio de Autenticación y Autorización de Java (JAAS), un marco para la implementación de flujos de autenticación, y acepta definiciones de credenciales en el formato JAAS.

Va a almacenarlos en un archivo llamado kafka-server-jaas.conf en config/kraft. Cree y abra el archivo para edición ejecutando:

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

Agregue las siguientes líneas:

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

Las username y password definen las credenciales principales que se utilizan para la comunicación entre broker en el clúster cuando hay múltiples nodos. La línea user_admin define un usuario cuyo nombre de usuario es admin con contraseña admin, que puede conectarse al broker desde fuera. Guarde y cierre el archivo cuando haya terminado.

Kafka necesita estar al tanto del archivo kafka-server-jaas.conf porque complementa la configuración principal. tendrá que modificar la configuración del servicio kafka systemd y pasar una referencia a él. Ejecute el siguiente comando para abrir el servicio para edición:

sudo systemctl edit --full kafka

Al pasar --full, obtiene acceso a los contenidos completos 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'
...

Agregue la siguiente línea encima de él, de modo que se parezca a esto:

...
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 esto, configuras el parámetro java.security.auth.login.config en la configuración al path del archivo de configuración JAAS, desacoplandolo de la configuración principal de Kafka. Una vez que hayas terminado, guarda y cierra el archivo. Recarga la definición del servicio ejecutando:

sudo systemctl daemon-reload

Luego, reinicia Kafka:

sudo systemctl restart kafka

Has configurado ahora tanto el cifrado TLS como la autenticación SASL para tu instalación de Kafka, y ahora aprenderás cómo conectarte a él con los scripts de consola proporcionados.

Paso 2 – Conectándose a un Cluster Seguro

En este paso, aprenderás cómo conectarte a un cluster de Kafka seguro utilizando archivos de configuración JAAS con los scripts de consola proporcionados.

Los scripts proporcionados para manipular temas, producir y consumir mensajes también utilizan Java internamente, y por lo tanto aceptan una configuración JAAS que detalla las ubicaciones de los almacenes de claves y de confianza, así como las credenciales SASL.

Almacenarás esa configuración en un archivo llamado client-jaas.conf en tu directorio de inicio. Crea y ábrelo para editar:

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=

Asimismo, estableces el protocolo en SASL_SSL y proporciones los paths y las contraseñas para los almacenes de claves y de confianza que has creado. A continuación, estableces el mecanismo SASL en PLAIN y proporcionas las credenciales para el usuario admin. Expresamente borras el parámetro ssl.endpoint.identification.algorithm para evitar problemas de conexión, ya que los scripts iniciales establecen el nombre de host de la máquina en la que se ejecuta como el punto final del certificado, lo cual puede no ser correcto.

Reemplaza your_tls_password con el valor correcto, luego guarda y cierra el archivo.

Para pasar este archivo a los scripts, puedes usar el parámetro --command-config. Prueba a crear 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, ejecuta el siguiente comando para listar todos los temas en el clúster:

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

La salida mostrará que new_topic está presente:

Output
__consumer_offsets
new_topic
...

En esta sección, has configurado tu instalación de Kafka para usar cifrado TLS para el tráfico y SASL para la autenticación con combinaciones de un nombre de usuario y una contraseña. Ahora aprenderás cómo exportar diversas métricas de Kafka a través de JMX usando Prometheus.

Paso 3 – Monitorear Métricas JMX de Kafka Usando Prometheus

En esta sección, utilizarás Prometheus para recopilar métricas de Kafka y hacerlas consultables en Grafana. Esto implica configurar el exportador JMX para Kafka y conectarlo a Prometheus.

[Las Extensiones de Gestión de Java (JMX) son un marco para aplicaciones Java que permite a los desarrolladores recopilar métricas generales y personalizadas sobre el funcionamiento de la aplicación en tiempo de ejecución en un formato estandarizado. Dado que Kafka está escrito en Java, admite el protocolo JMX y expone sus métricas personalizadas a través de él, como el estado de los tópicos y brokers.

Configuración de Kafka y Prometheus

Antes de proceder, necesitarás instalar Prometheus. En las máquinas de Ubuntu, puedes usar apt. Actualiza sus repositorios ejecutando:

sudo apt update

Luego, instala Prometheus:

sudo apt install prometheus -y

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

Una vez instalado, necesitará agregar la biblioteca exporter JMX para Prometheus a su instalación de Kafka. Navegue hasta la página de versiones y seleccione la versión más reciente con javaagent en el nombre. En el momento de escribir, la versión más reciente disponible era 0.20.0. Use el siguiente comando para descargarlo 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

La biblioteca exporter JMX ahora será recogida por Kafka.

Antes de activar el exporter, necesita definir qué métricas informará a Prometheus, y guardará esa configuración en un archivo llamado jmx-exporter.yml en config/ de la instalación de Kafka. El proyecto exporter JMX proporciona una configuración predeterminada adecuada, así que ejecute el siguiente comando para almacenarlo como jmx-exporter.yml en 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

Después, para activar el exporter, necesitará modificar el servicio systemd de Kafka. Necesitará modificar la variable de entorno KAFKA_OPTS para incluir el exporter, así como su configuración. Ejecute el siguiente comando para editar el servicio:

sudo systemctl edit --full kafka

Modifique la línea Environment de este modo:

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 iniciar el exporter JMX con su configuración.

Guarde y cierre el archivo cuando haya terminado, y luego reinicie Kafka ejecutando:

sudo systemctl restart kafka

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

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

Esta línea muestra que el puerto 7075 está en uso por un proceso de Java iniciado por el servicio Kafka, que se refiere al exportador JMX.

Ahora configurarás Prometheus para supervisar las métricas JMX exportadas. Su archivo de configuración principal se encuentra en /etc/prometheus/prometheus.yml, por lo que ábrello para editar:

sudo nano /etc/prometheus/prometheus.yml

Busca las siguientes líneas:

...

# Una configuración de scraping que contiene exactamente un endpoint para extraer:


# Aquí es Prometheus mismo.

scrape_configs:
  
# El nombre del trabajo se agrega como una etiqueta `job=<job_name>` a cualquier serie de tiempo extraída de esta configuración.

  - job_name: 'prometheus'

    
# Anula la configuración predeterminada global y extrae los objetivos de este trabajo cada 5 segundos.

    scrape_interval: 5s
    scrape_timeout: 5s

    
# metrics_path por defecto es '/metrics'

    
# scheme por defecto es 'http'.


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

  - job_name: node
    
# Si prometheus-node-exporter está instalado, obtén estadísticas sobre la máquina

    
# local por defecto.

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

Bajo scrape_configs, que especifica los endpoints que Prometheus debe vigilar, agrega una nueva sección para extraer métricas de Kafka:

# Una configuración de raspado que contiene exactamente un endpoint para raspar:
# Aquí es Prometheus mismo.
scrape_configs:
  # El nombre del trabajo se agrega como una etiqueta `job=<job_name>` a cualquier serie de tiempo raspada de esta configuración.
  - job_name: 'prometheus'

    # Anula el valor predeterminado global y raspa los objetivos de este trabajo cada 5 segundos.
    scrape_interval: 5s
    scrape_timeout: 5s

    # metrics_path por defecto es '/metrics'
    # scheme por defecto es 'http'.

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

  - job_name: node
    # Si prometheus-node-exporter está instalado, obtén estadísticas sobre la máquina local
    # por defecto.
    static_configs:
      - targets: ['localhost:9100']

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

El trabajo kafka tiene un objetivo, que apunta al endpoint del exportador JMX.

Recuerda reemplazar tu_dominio con tu nombre de dominio, luego guarda y cierra el archivo. A continuación, reinicia Prometheus ejecutando:

sudo systemctl restart prometheus

En tu navegador, navega al puerto 9090 en tu dominio. Accederás a la interfaz de usuario de Prometheus. Bajo Estado, presiona en Objetivos para listar los trabajos:

Observa que Prometheus ha aceptado el trabajo kafka y ha comenzado a raspar sus métricas. Ahora aprenderás cómo acceder a ellas en Grafana.

Consultar las métricas en Grafana

Como parte de los requisitos previos, ha instalado Grafana en su Droplet y lo ha expuesto en your_domain. Vaya a él en su navegador web, y en la barra lateral, en Conexiones, haga clic en Agregar nueva conexión, luego escriba Prometheus en el campo de búsqueda.

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

Ingrese http://your_domain_name:9090, reemplazando con el nombre de su dominio real, luego desplácese hacia abajo y haga clic en Guardar y probar. Debería recibir un mensaje de éxito:

Se ha agregado la conexión de Prometheus a Grafana. Haga clic en Explorar en la barra lateral, y se le pedirá que seleccione una métrica. Puede escribir kafka_ para listar todas las métricas relacionadas con el cluster, como se muestra:

Por ejemplo, seleccione la métrica kafka_log_log_size, que muestra cuán grande es el registro interno en disco por partición, luego haga clic en Ejecutar consulta en la esquina superior derecha. Verá las cantidades resultantes en el tiempo para cada uno de los temas disponibles:

En este paso, ha configurado la exportación de métricas JMX que proporciona Kafka y ha configurado Prometheus para extraerlas. Después, ha conectado con él desde Grafana y ha ejecutado una consulta sobre las métricas de Kafka. Ahora aprenderá cómo administrar un clúster de Kafka usando una interfaz web.

Paso 4 – Administrar clústeres de Kafka con AKHQ

En este paso, aprenderá cómo configurar y usar AKHQ, una aplicación web para administrar clústeres de Kafka. Permite listar y manipular tópicos, particiones, grupos de consumidores y parámetros de configuración, así como producir y consumir mensajes de tópicos en un solo lugar.

Guardará el ejecutable y su configuración en un directorio llamado akhq. Cree en su directorio personal ejecutando:

mkdir ~/akhq

Vaya a él:

cd ~/akhq

En su navegador, visitar la página de versiones oficiales y copiar el enlace al archivo JAR de la última versión. En el momento de escribir, la versión más reciente era 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

Ahora ha descargado AKHQ y está listo para definir su configuración para conectarse a su clúster. Guardará eso en un archivo llamado akhq-config.yml. Cree y abra para edición ejecutando:

nano ~/akhq/akhq-config.yml

Agregue 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, especificando un clúster en localhost:9092 con los parámetros de SASL y TLS correspondientes especificados. Se admiten múltiples clústeres simultáneamente, ya que puedes definir tantas conexiones como desees. Esto hace que AKHQ sea versátil para la gestión de Kafka. Cuando hayas terminado, guarda y cierra el archivo.

A continuación, necesitarás definir un servicio de systemd para ejecutar AKHQ en segundo plano. Los servicios de systemd pueden iniciarse, detenerse y reiniciarse de manera consistente.

Almacenarás la configuración del servicio en un archivo llamado code-server.service, en el directorio /lib/systemd/system, donde systemd almacena sus servicios. Créalo usando tu 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 especificas la descripción del servicio. Luego, en la sección [Service], defines el tipo de servicio (en simple significa que el comando simplemente debe ejecutarse) y proporcionas el comando que se ejecutará. También especificas que el usuario bajo el que se ejecuta es kafka y que el servicio debe reiniciarse automáticamente si finaliza.

En la sección [Install] le ordenas a systemd que inicie este servicio cuando inicies sesión en tu servidor. Guarda y cierra el archivo cuando hayas terminado.

Carga la configuración del servicio ejecutando:

sudo systemctl daemon-reload

Inicia el servicio AKHQ ejecutando el siguiente comando:

sudo systemctl start akhq

Luego, verifica que se inició correctamente observando 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 ahora se está ejecutando en segundo plano. Por defecto, está expuesto en el puerto 8080. En tu navegador, navega a tu dominio con ese puerto para acceder a él. Verás la vista predeterminada, mostrando la lista de temas:

Puedes hacer doble clic en la fila correspondiente del tema en la tabla para acceder a él y obtener una vista detallada:

AKHQ te permite ver los mensajes en el tema, así como particiones, grupos de consumidores y su configuración. También puedes vaciar o copiar el tema usando los botones en la parte inferior derecha.

Dado que el tema new_topic está vacío, presiona el botón Produce to topic, que abrirá la interfaz para seleccionar los parámetros del nuevo mensaje:

AKHQ llenará automáticamente el nombre del tema para ti. En el campo Value, introduce Hello World!, luego presiona Produce. El mensaje se enviará a Kafka, y podrás verlo en la pestaña Data:

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

En la barra lateral izquierda, también puedes listar los brokers en el clúster presionando en Nodes. En este momento, el clúster consta de solo un nodo:

Haciendo doble clic en un nodo abrirá su configuración, permitiéndote cambiar cualquier ajuste de forma remota:

Una vez que hayas realizado los cambios, puedes aplicarlos presionando el botón Actualizar configuraciones en la parte inferior derecha. Del mismo modo, puedes ver y modificar la configuración de cualquiera de los temas accediendo a ellos y cambiando a la pestaña Configuraciones.

En esta sección, has configurado AKHQ, una aplicación web que proporciona una interfaz de usuario fácil de usar para gestionar y observar nodos y temas de Kafka de forma remota. Permite producir y consumir mensajes en temas y actualizar los parámetros de configuración de temas y nodos sobre la marcha.

Conclusión

En este tutorial, has asegurado tu instalación de Kafka configurando TLS para el cifrado y SASL para la autenticación de usuarios. También has configurado la exportación de métricas utilizando Prometheus y las has visualizado en Grafana. A continuación, aprendiste a usar AKHQ, una aplicación web para gestionar clústers de Kafka.

El autor ha seleccionado a la Fundación Apache Software para recibir una donación como parte del programa Escribir para Donaciones.