Introducción
Apache Kafka es una plataforma distribuida de código abierto para el procesamiento de eventos y flujos, escrita en Java y diseñada para procesar feeds de datos en tiempo real. Es inherentemente escalable, con alto rendimiento y disponibilidad. Desarrollada por la Apache Software Foundation, Kafka ha sido ampliamente adoptada por su fiabilidad, facilidad de uso y tolerancia a fallos. Es utilizada por las organizaciones más grandes del mundo para gestionar grandes volúmenes de datos de forma distribuida y eficiente.
En este tutorial, descargará y configurará Apache Kafka. Aprenderá a crear y eliminar temas, así como a enviar y recibir eventos mediante los scripts proporcionados. También conocerá proyectos similares con el mismo objetivo y comparará Kafka con otros.
Requisitos previos
- Una máquina con al menos 4 GB de RAM y 2 CPU. En el caso de Ubuntu Server
- Java 8 o superior instalado en su Droplet o máquina local.
Paso 1: Descargar y configurar Apache Kafka
En esta sección, descargará y extraerá Apache Kafka en su equipo. Para mayor seguridad, lo configurará con su propia cuenta de usuario. Después, lo configurará y ejecutará con KRaft.
Primero, crea un usuario independiente bajo el cual se ejecutará Kafka. Crea un usuario llamado kafka ejecutando el siguiente comando:
sudo adduser kafkaSe le solicitará la contraseña de su cuenta. Ingrese una contraseña segura y presione ENTER en cada campo para omitir la información adicional.
Por último, cambie al usuario específico de Kafka:
su kafkaA continuación, descargará el paquete de lanzamiento de Kafka desde la página oficial de descargas. Al momento de escribir este artículo, la última versión era la 3.7.0, desarrollada para Scala 2.13. Si usa macOS o Linux, puede descargar Kafka con curl.
Utilice este comando para descargar Kafka y colocarlo en /tmp:
curl -o /tmp/kafka.tgz https://downloads.apache.org/kafka/3.7.0/kafka_2.13-3.7.0.tgzAlmacenarás la versión en ~/kafka, en el directorio principal. Créala ejecutando:
mkdir ~/kafkaLuego extráelo a ~/kafka ejecutando:
tar -xzf /tmp/kafka.tgz -C ~/kafka --strip-components=1Dado que el archivo que descargaste contiene una carpeta raíz con el mismo nombre que la versión de Kafka, –strip-components=1 la omitirá y extraerá todo lo que contenga.
Al momento de escribir este artículo, Kafka 3 era la última versión importante compatible con dos sistemas de gestión de metadatos: Apache ZooKeeper y Kafka KRaft (abreviatura de Kafka Raft). ZooKeeper es un proyecto de código abierto que proporciona un método estándar para coordinar datos distribuidos para aplicaciones, también desarrollado por la Apache Software Foundation.
Sin embargo, a partir de Kafka 3.3, se introdujo la compatibilidad con KRaft. KRaft es un sistema diseñado específicamente para coordinar únicamente instancias de Kafka, lo que simplifica el proceso de instalación y permite una escalabilidad mucho mayor. Con KRaft, Kafka asume la plena responsabilidad de los datos, en lugar de mantener metadatos administrativos externamente.
Aunque aún está disponible, se espera que la compatibilidad con ZooKeeper se elimine de Kafka 4 y versiones posteriores. En este tutorial, configurarás Kafka con KRaft.
Necesita crear un identificador único para su nuevo clúster de Kafka. Actualmente, consta de un solo nodo. Vaya al directorio donde se encuentra Kafka:
cd ~/kafkaKafka con KRaft almacena su configuración en config/kraft/server.properties, mientras que el archivo de configuración de ZooKeeper es config/server.properties.
Antes de ejecutarlo por primera vez, debe anular algunas de las configuraciones predeterminadas. Abra el archivo para editarlo ejecutando:
nano config/kraft/server.propertiesEncuentra las siguientes líneas:
...
############################# Log Basics #############################
# A comma separated list of directories under which to store log files
log.dirs=/tmp/kafka-logs
...La configuración log.dirs especifica dónde guarda Kafka sus archivos de registro. De forma predeterminada, se almacenan en /tmp/kafka-logs, ya que se garantiza su escritura, aunque sea temporalmente. Reemplace el valor con la ruta especificada:
... ############################# Log Basics ############################# # A comma separated list of directories under which to store log files log.dirs=/home/kafka/kafka-logs ...
Dado que creó un usuario independiente para Kafka, coloque la ruta del directorio de registro en el directorio personal del usuario. Si no existe, Kafka la creará. Al terminar, guarde y cierre el archivo.
Ahora que ha configurado Kafka, ejecute el siguiente comando para generar un ID de clúster aleatorio:
KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"Luego, cree espacio de almacenamiento para los archivos de registro ejecutando el siguiente comando e ingresando el ID:
bin/kafka-storage.sh format -t $KAFKA_CLUSTER_ID -c config/kraft/server.propertiesLa salida será:
Output
Formatting /home/kafka/kafka-logs with metadata.version 3.7-IV4.Finalmente, puedes iniciar el servidor Kafka por primera vez:
bin/kafka-server-start.sh config/kraft/server.propertiesEl resultado final será similar a esto:
Output
...
[2024-02-26 10:38:26,889] INFO Awaiting socket connections on 0.0.0.0:9092. (kafka.network.DataPlaneAcceptor)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Waiting for all of the authorizer futures to be completed (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Finished waiting for all of the authorizer futures to be completed (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Waiting for all of the SocketServer Acceptors to be started (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Finished waiting for all of the SocketServer Acceptors to be started (kafka.server.BrokerServer)
[2024-02-26 10:38:26,890] INFO [BrokerServer id=1] Transition from STARTING to STARTED (kafka.server.BrokerServer)
[2024-02-26 10:38:26,891] INFO Kafka version: 3.7.0 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,891] INFO Kafka commitId: 5e3c2b738d253ff5 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,891] INFO Kafka startTimeMs: 1708943906890 (org.apache.kafka.common.utils.AppInfoParser)
[2024-02-26 10:38:26,892] INFO [KafkaRaftServer nodeId=1] Kafka Server started (kafka.server.KafkaRaftServer)La salida muestra que Kafka se ha inicializado correctamente utilizando KRaft y está aceptando conexiones en 0.0.0.0:9092.
El proceso sale cuando presiona CTRL + C. Dado que no es preferible ejecutar Kafka con una sesión abierta, en el siguiente paso creará un servicio para ejecutar Kafka en segundo plano.
Paso 2: Crear un servicio systemd para Kafka
En esta sección, creará un servicio systemd para ejecutar Kafka en segundo plano en todo momento. 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/kafka.serviceAñade las siguientes líneas:
[Unit]
Description=kafka-server
[Service]
Type=simple
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'
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal
[Install]
WantedBy=multi-user.targetAquí primero se especifica la descripción del servicio. Luego, en el campo [Servicio], se define el tipo de servicio (simple significa que el comando debe ejecutarse de forma sencilla) y se proporciona el comando que se ejecutará. También se especifica que el usuario que se ejecutará es Kafka y que el servicio debe reiniciarse automáticamente si Kafka cierra.
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.
Inicie el servicio Kafka ejecutando el siguiente comando:
sudo systemctl start kafkaComprueba que se ha iniciado correctamente visualizando su estado:
sudo systemctl status kafkaVerá un resultado similar al siguiente:
Output
● kafka.service - kafka-server
Loaded: loaded (/etc/systemd/system/kafka.service; disabled; preset: enabled)
Active: active (running) since Mon 2024-02-26 11:17:30 UTC; 2min 40s ago
Main PID: 1061 (sh)
Tasks: 94 (limit: 4646)
Memory: 409.2M
CPU: 10.491s
CGroup: /system.slice/kafka.service
├─1061 /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"
└─1062 java -Xmx1G -Xms1G -server -XX:+UseG1GC -XX:MaxGCPauseMillis=20 -XX:InitiatingHeapOccupancyPercent=35 -XX:+ExplicitGCInvokesConcurrent -XX:MaxInlineLevel=15 -Djava.awt.headless=true "-Xlog:gc*:file=/home/kafka/kafka/bin/../logs/kaf>
Feb 26 11:17:30 kafka-test1 systemd[1]: Started kafka.service - kafka-server.Para iniciar Kafka automáticamente después de reiniciar el servidor, habilite su servicio ejecutando el siguiente comando:
sudo systemctl enable kafkaEn este punto, ha creado y habilitado un servicio systemd para Kafka, de modo que se inicie cada vez que se inicie el servidor. A continuación, aprenderá a crear y eliminar temas en Kafka, así como a generar y recibir mensajes de texto con los scripts disponibles.
Paso 3 – Producción y consumo de mensajes temáticos
Ahora que ha configurado un servidor Kafka, conocerá los temas y cómo administrarlos mediante los scripts proporcionados. También aprenderá a enviar y recibir mensajes desde un tema.
Como se explica en el artículo sobre el flujo de eventos, la publicación y recepción de mensajes están asociadas a temas. Un tema puede estar relacionado con la categoría a la que pertenece un mensaje.
El script kafka-topics.sh se puede usar para administrar temas en Kafka mediante la CLI. Para crear un tema llamado first-topic, ejecute el siguiente comando:
bin/kafka-topics.sh --create --topic first-topic --bootstrap-server localhost:9092Todos los scripts de Kafka proporcionados requieren que especifique la dirección del servidor con --bootstrap-server.
La salida será:
Output
Created topic first-topic.Para enumerar todos los temas existentes, reemplace –create con –list:
bin/kafka-topics.sh --list --bootstrap-server localhost:9092Ves el tema que creaste:
Output
first-topicPuede obtener información detallada y estadísticas sobre el tema pasando --describe:
bin/kafka-topics.sh --describe --topic first-topic --bootstrap-server localhost:9092La salida se verá así:
Output
Topic: first-topic TopicId: VtjiMIUtRUulwzxJL5qVjg PartitionCount: 1 ReplicationFactor: 1 Configs: segment.bytes=1073741824
Topic: first-topic Partition: 0 Leader: 1 Replicas: 1 Isr: 1La primera línea especifica el nombre del tema, su ID y el factor de recurrencia, que es 1 porque el tema solo existe en la máquina actual. La segunda línea tiene sangría intencionada y muestra información sobre la primera (y única) partición del tema. Kafka permite particionar el tema, lo que significa que sus diferentes partes se pueden distribuir entre diferentes servidores, lo que aumenta la escalabilidad. En este caso, solo hay una partición.
Ahora que ha creado un tema, generará mensajes para él mediante el script kafka-console-producer.sh. Ejecute el siguiente comando para iniciar el productor:
bin/kafka-console-producer.sh --topic first-topic --bootstrap-server localhost:9092Verás una notificación en blanco:
>El proveedor espera tu SMS. Accede a la prueba y pulsa ENTER. La notificación se verá así:
>test
>El productor está esperando el siguiente mensaje, lo que significa que el mensaje anterior se envió correctamente a Kafka. Puede introducir cualquier número de mensajes para probar. Para salir del productor, pulse Ctrl+C.
Para recuperar mensajes de tema, necesita un consumidor. Kafka ofrece un consumidor simple llamado kafka-console-consumer.sh. Ejecútelo con:
bin/kafka-console-consumer.sh --topic first-topic --bootstrap-server localhost:9092Sin embargo, no habrá salida. Esto se debe a que el consumidor está transmitiendo datos desde el tema y no se está produciendo ni enviando nada en este momento. Para consumir los mensajes generados antes del inicio del consumidor, debe leer el tema desde el principio ejecutando:
bin/kafka-console-consumer.sh --topic first-topic --from-beginning --bootstrap-server localhost:9092El consumidor reproduce todos los eventos del tema y recupera mensajes:
Outputtest
...Al igual que con el constructor, presione CTRL+C para salir.
Para verificar que el consumidor esté transmitiendo datos, ábralo en una sesión de terminal independiente. Abra una sesión SSH secundaria y ejecute el consumidor con la configuración predeterminada:
bin/kafka-console-consumer.sh --topic first-topic --bootstrap-server localhost:9092En la sesión inicial, ejecute el constructor:
bin/kafka-console-producer.sh --topic first-topic --bootstrap-server localhost:9092A continuación introduzca los mensajes deseados:
>second test
>third test
>Los verás inmediatamente recibidos por el consumidor:
Output
second test
third testUna vez finalizada la prueba, finalice tanto el productor como el consumidor.
Para eliminar el primer tema, pase --delete a kafka-topics.sh:
bin/kafka-topics.sh --delete --topic first-topic --bootstrap-server localhost:9092No habrá salida. Puedes listar los temas para verificar que se eliminaron:
bin/kafka-topics.sh --list --bootstrap-server localhost:9092La salida será:
Output
__consumer_offsets__Consumer_Equivalent es un tema interno de Kafka que almacena la cantidad de tiempo que un consumidor ha leído un tema.
En este punto, ha creado un tema de Kafka y ha generado mensajes en él. Después, ha consumido los mensajes mediante el script proporcionado y finalmente los ha recibido en tiempo real. A continuación, aprenderá cómo se compara Kafka con otros gestores de eventos y software similar.
Comparación con arquitecturas similares
Apache Kafka se considera la solución de facto para casos de uso de streaming de eventos. Sin embargo, Apache Pulsar y RabbitMQ también son ampliamente utilizados y destacan como opciones versátiles, aunque con diferentes enfoques.
La principal diferencia entre una cola de mensajes y un flujo de eventos radica en que la función principal de la primera es entregar los mensajes a los consumidores lo más rápido posible, independientemente del orden. Estos sistemas suelen almacenar los mensajes en memoria hasta que los consumidores los reconocen. El filtrado y el enrutamiento de mensajes son aspectos importantes, ya que los consumidores pueden mostrar interés en categorías específicas de datos. RabbitMQ es un buen ejemplo de un sistema de mensajería tradicional donde varios consumidores pueden suscribirse a un tema y recibir múltiples copias de un mensaje.
Por otro lado, la transmisión de eventos se centra en la persistencia. Los eventos deben archivarse, mantenerse y procesarse una sola vez. Dirigirlos a consumidores específicos no es importante, ya que la idea es que todos los consumidores procesen los eventos de la misma manera.
Apache Pulsar es un sistema de mensajería de código abierto desarrollado por la Apache Software Foundation que admite la transmisión de eventos. A diferencia de Kafka, con el que se creó desde cero, Pulsar comenzó como una solución tradicional de colas de mensajes y posteriormente adquirió capacidades de transmisión de eventos. Por lo tanto, Pulsar resulta útil cuando se necesita una combinación de ambos enfoques, sin necesidad de implementar aplicaciones independientes.
Resultado
Ahora tiene Apache Kafka ejecutándose de forma segura en segundo plano en su servidor, configurado como un servicio del sistema. También ha aprendido a manipular temas desde la línea de comandos, así como a generar y consumir mensajes. Sin embargo, el principal atractivo de Kafka reside en la amplia variedad de clientes que lo integran en sus aplicaciones.
