Los patrones de diseño orientados a microservicios han hecho que nuestras aplicaciones sean más escalables que nunca. Los servidores de API RESTful, el front-end e incluso las bases de datos ahora son escalables horizontalmente. El escalado horizontal es el acto de agregar nuevos nodos a su clúster de aplicaciones para admitir una carga de trabajo adicional. Por el contrario, también permite reducir el consumo de recursos, cuando la carga de trabajo disminuye, con el fin de ahorrar costos. Los sistemas escalables horizontalmente deben ser un sistema distribuido. Estos sistemas pueden sobrevivir a fallas de múltiples VM, contenedores o enlaces de red y aún permanecer en línea y en buen estado para el usuario final.

Cuando hablamos de sistemas distribuidos como el anterior, nos encontramos con el problema de la analítica y la monitorización. Cada nodo genera mucha información sobre su propio estado (uso de CPU, memoria, etc.) y sobre el estado de la aplicación junto con lo que los usuarios están tratando de hacer. Estos detalles deben registrarse en:

1. El mismo orden en que se crean,
2. Separado en términos de urgencia (análisis en tiempo real o lotes de datos), y lo más importante,
3. El mecanismo con el que se recogen debe ser en sí mismo distribuido y escalable, de lo contrario nos quedamos con un único punto de falla. Algo que se suponía que debía evitar el diseño del sistema distribuido.

Por qué utilizar Kafka?

Apache Kafka se presenta como una plataforma de transmisión distribuida. En la jerga de Kafka, Productores generar datos continuamente (arroyos) y Consumidores son los encargados de procesarlo, almacenarlo y analizarlo. Kafka Corredores son responsables de asegurar que en un escenario distribuido los datos puedan llegar de Productores a Consumidores sin ninguna inconsistencia. Un conjunto de corredores de Kafka y otra pieza de software llamada cuidador del zoológico constituyen un despliegue típico de Kafka.

El flujo de datos de muchos productores debe agregarse, dividirse y enviarse a múltiples consumidores, hay mucha mezcla involucrada. Evitar la inconsistencia no es tarea fácil. Por eso necesitamos a Kafka.

Los escenarios en los que se puede utilizar Kafka son bastante diversos. Cualquier cosa, desde dispositivos IOT hasta clústeres de máquinas virtuales y sus propios servidores nativos en las instalaciones. En cualquier lugar donde muchas 'cosas' requieran su atención simultáneamente .. .Eso no es muy científico, ¿verdad?? Bueno, la arquitectura de Kafka es un agujero de conejo en sí misma y merece un tratamiento independiente. Primero veamos una implementación a nivel muy superficial del software.

Uso de Docker Compose

De cualquier forma imaginativa que decida usar Kafka, una cosa es segura: no lo usará como una sola instancia. No está destinado a ser utilizado de esa manera, e incluso si su aplicación distribuida necesita solo una instancia (agente) por ahora, eventualmente crecerá y debe asegurarse de que Kafka pueda mantenerse al día.

Docker-compose es el socio perfecto para este tipo de escalabilidad. En lugar de ejecutar agentes de Kafka en diferentes máquinas virtuales, lo colocamos en contenedores y aprovechamos Docker Compose para automatizar la implementación y el escalado. Los contenedores Docker son altamente escalables tanto en hosts Docker únicos como en un clúster si usamos Docker Swarm o Kubernetes. Por lo tanto, tiene sentido aprovecharlo para hacer que Kafka sea escalable.

Comencemos con una única instancia de corredor. Cree un directorio llamado apache-kafka y dentro de él cree su docker-compose.yml.

$ mkdir apache-kafka
$ cd apache-kafka
$ vim docker-compose.yml

Los siguientes contenidos se colocarán en su docker-compose.archivo yml:

versión: '3'
servicios:
cuidador del zoológico:
imagen: wurstmeister / zookeeper
 
kafka:
imagen: wurstmeister / kafka
puertos:
- "9092: 9092"
ambiente:
KAFKA_ADVERTISED_HOST_NAME: localhost
KAFKA_ZOOKEEPER_CONNECT: guardián del zoológico: 2181

Una vez que haya guardado el contenido anterior en su archivo de redacción, desde el mismo directorio ejecute:

$ docker-compose up -d

Está bien, entonces, ¿qué hicimos aquí??

Comprensión de Docker-Compose.yml

Compose iniciará dos servicios como se enumeran en el archivo yml. Veamos el archivo un poco más de cerca. La primera imagen es el guardián del zoológico que Kafka requiere para realizar un seguimiento de varios corredores, la topología de la red y sincronizar otra información. Dado que los servicios de zookeeper y kafka van a ser parte de la misma red de puente (esto se crea cuando ejecutamos docker-compose up) no necesitamos exponer ningún puerto. El agente de Kafka puede hablar con el cuidador del zoológico y esa es toda la comunicación que necesita el cuidador del zoológico.

El segundo servicio es kafka en sí mismo y solo estamos ejecutando una instancia única de él, es decir, un corredor. Idealmente, querrá utilizar varios corredores para aprovechar la arquitectura distribuida de Kafka. El servicio escucha en el puerto 9092 que está asignado al mismo número de puerto en el host de Docker y así es como el servicio se comunica con el mundo exterior.

El segundo servicio también tiene un par de variables de entorno. Primero, ¿KAFKA_ADVERTISED_HOST_NAME se establece en localhost?. Esta es la dirección en la que se ejecuta Kafka y donde los productores y consumidores pueden encontrarla. Una vez más, este debería ser el establecido en localhost, sino más bien en la dirección IP o el nombre de host, con esto se puede acceder a los servidores en su red. El segundo es el nombre de host y el número de puerto de su servicio de cuidador del zoológico. Desde que nombramos el servicio de cuidador del zoológico ... bueno, cuidador del zoológico, ese será el nombre de host, dentro de la red de puente acoplable, mencionamos.

Ejecutando un flujo de mensajes simple

Para que Kafka comience a trabajar, necesitamos crear un tema dentro de él. Los clientes productores pueden publicar flujos de datos (mensajes) a dicho tema y los consumidores pueden leer dicho flujo de datos, si están suscritos a ese tema en particular.

Para hacer esto, necesitamos iniciar una terminal interactiva con el contenedor Kafka. Enumere los contenedores para recuperar el nombre del contenedor kafka. Por ejemplo, en este caso nuestro contenedor se llama apache-kafka_kafka_1

$ docker ps

Con el nombre del contenedor kafka, ahora podemos colocarlo dentro de este contenedor.

$ docker exec -it apache-kafka_kafka_1 bash
bash-4.4 #

Abra dos terminales tan diferentes para usar una como consumidor y otra como productor.

Lado del productor

En una de las indicaciones (la que elijas para ser productor), ingresa los siguientes comandos:

## Para crear un nuevo tema llamado prueba
bash-4.4 # temas-kafka.sh --crear - guardián del zoológico guardián del zoológico: 2181 - factor de replicación 1
--particiones 1 - prueba de tema
 
## Para iniciar un productor que publique el flujo de datos desde la entrada estándar a kafka
bash-4.4 # kafka-consola-productor.sh --broker-list localhost: 9092 --prueba de tema
>

El productor ahora está listo para tomar la entrada del teclado y publicarla.

Lado del consumidor

Pase a la segunda terminal conectada a su contenedor kafka. El siguiente comando inicia un consumidor que se alimenta del tema de prueba:

$ kafka-console-consumer.sh --bootstrap-server localhost: 9092 --prueba de tema

Volver al productor

Ahora puede escribir mensajes en el nuevo mensaje y cada vez que presione devolver, la nueva línea se imprimirá en el mensaje del consumidor. Por ejemplo:

> Este es un mensaje.

Este mensaje se transmite al consumidor, a través de Kafka, y puede verlo impreso en el indicador del consumidor.

Configuraciones del mundo real

Ahora tiene una idea aproximada de cómo funciona la configuración de Kafka. Para su propio caso de uso, debe establecer un nombre de host que no sea localhost, necesita que varios de estos agentes formen parte de su clúster de kafka y, finalmente, debe configurar clientes consumidores y productores.

Aquí hay algunos enlaces útiles:

1. Cliente Python de Confluent
2. Documentación oficial
3. Una lista útil de demostraciones

Espero que te diviertas explorando Apache Kafka.