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
- Un dispositivo con al menos 4 GB de RAM y 2 CPU.
- 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. Al ejecutar el siguiente comando, crearás un usuario llamado Kafka Crear:
sudo adduser kafkaSe te pedirá la contraseña de tu cuenta. Introduce una contraseña segura y pulsa Intro. INGRESAR Para cada campo, omita completar 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 es la 3.6.1. Si usa macOS o Linux, puede descargar Kafka con curl.
Utilice este comando para descargar Kafka e instalarlo en /tmp Lugar:
curl -o /tmp/kafka.tgz https://dlcdn.apache.org/kafka/3.6.1/kafka_2.13-3.6.1.tgzTienes la versión debajo ~/kafkaLo guardarás en el directorio principal. Créalo ejecutando:
mkdir ~/kafkaLuego, al ejecutarlo, ~/kafka Extracto:
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. Por ahora, constará de un solo nodo. Vaya al directorio donde se encuentra actualmente Kafka:
cd ~/kafkaKafka con KRaft se configura en config/kraft/server.properties guarda, mientras que el archivo de configuración Configuración de ZooKeeper/server.properties Es.
Antes de ejecutarlo por primera vez, debe anular algunas de las configuraciones predeterminadas. Abra el archivo para editarlo ejecutando:
nano config/kraft/server.properties...
############################# Log Basics #############################
# A comma separated list of directories under which to store log files
log.dirs=/tmp/kafka-logs
...Ajustes directorio de registro Especifica dónde guarda Kafka sus archivos de registro. De forma predeterminada, los almacena en /tmp/registros-de-kafka Los guarda, ya que se garantiza que se pueden escribir, 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.6-IV2.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.6.1 (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)El resultado muestra que Kafka se ha inicializado correctamente usando KRaft y está creando conexiones en 0.0.0.0:9092 Acepta.
Cuando CTRL + C Presione , el proceso finalizará. Dado que no es recomendable 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.
Coloque la configuración del servicio en un archivo llamado servicio de servidor de código En la lista /lib/systemd/sistema Ahorras, donde systemd Almacena tus servicios. Créalo con tu 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 [Servicio] Define el tipo de servicio (simple significa que el comando debe ejecutarse de forma sencilla) y proporciona el comando que se ejecutará. También especifica el usuario que se ejecutará. Kafka es, y el servicio debería reiniciarse automáticamente si Kafka sale.
Sección [instalar] indica al sistema que inicie este servicio cuando sea posible 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, se le presentarán 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 la recepción de mensajes están relacionadas con los temas. Un tema puede estar relacionado con la categoría a la que pertenece un mensaje.
Del script proporcionado temas-kafka.sh Puedes gestionar temas en Kafka a través de CLI Se utiliza para crear un tema llamado primer tema Ejecute el siguiente comando:
bin/kafka-topics.sh --create --topic first-topic --bootstrap-server localhost:9092Todos los scripts de Kafka proporcionados requieren que la dirección del servidor se especifique con --servidor bootstrap Especificar.
La salida será:
Output
Created topic first-topic.Para enumerar todos los temas disponibles, en lugar de --crear En --lista Enviar:
bin/kafka-topics.sh --list --bootstrap-server localhost:9092Ves el tema que creaste:
Output first-topic
Puede encontrar información detallada y estadísticas sobre el tema visitando --describir Conseguir:
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: 1
La 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 productor espera tu SMS. Entra a la prueba y INGRESAR Presiona . La notificación se verá así:
>test
>El productor está esperando el siguiente mensaje, lo que significa que el mensaje anterior se entregó correctamente a Kafka. Puede introducir cualquier número de mensajes para la prueba. Para salir del productor, CTRL+C Prensa .
Para recuperar mensajes de un tema, se necesita un consumidor. Kafka proporciona un consumidor simple en forma de kafka-console-consumer.sh Se ofrece. Ejecútalo ejecutando:
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 el constructor, para salir, CTRL+C Prensa .
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
>Verás inmediatamente que son recibidos por el consumidor:
Output
second test
third test
Una vez finalizada la prueba, finalice tanto el productor como el consumidor.
Para eliminar el primer tema, --borrar a temas-kafka.sh Transferir:
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 el 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. En el siguiente paso, aprenderá cómo se compara Kafka con otros gestores de eventos y software similar.
Comparación con arquitecturas similares
Apache Kafka se considera una solución viable para casos de uso de transmisión de eventos. Sin embargo, Apache Pulsar y RabbitMQ también se utilizan ampliamente y destacan como opciones versátiles, aunque con diferentes enfoques. La principal diferencia entre las colas de mensajes y los flujos de eventos radica en que la función principal de las primeras es entregar los mensajes a los clientes lo más rápido posible, independientemente de su 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. La transmisión de eventos, por otro lado, se centra en la persistencia. Los eventos deben archivarse, mantenerse ordenados y procesarse una sola vez. Su enrutamiento 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 desarrolló desde cero, Pulsar comenzó como una solución tradicional de colas de mensajes y posteriormente incorporó funciones de transmisión de eventos. Por lo tanto, Pulsar resulta útil cuando se necesita una combinación de ambos métodos, 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.
