Eclipse Hono ahora soporta Apache Kafka para mensajería de dispositivos fluida

Eclipse Hono es un proyecto open-source para conectar grandes números de dispositivos heterogéneos a un backend (en la nube). Hono define interfaces de servicio que permiten comunicación uniforme entre dispositivos, que pueden usar protocolos muy diferentes, así como aplicaciones de negocio. El proyecto existe desde hace tiempo y se ha usado con éxito en Bosch IoT Device Management durante varios años. Lo nuevo es que ahora soporta Apache Kafka para mensajería. Los beneficios resultantes y cambios en el uso de Hono se presentan en este artículo.

Los datos provenientes de dispositivos se transforman en Hono a un formato de mensaje uniforme por adaptadores de protocolo (ej. hay algunos para MQTT, HTTP y CoAP) y se pasan a un sistema de mensajería. Las aplicaciones de negocio leen estos mensajes, que son o bien mensajes de telemetría o bien eventos, directamente del sistema de mensajería (también pueden usar Comando y Control para enviar mensajes a dispositivos y recibir respuestas). Para mensajería, que no es parte de Hono sino que debe proveerse externamente, se ha usado el protocolo AMQP 1.0 hasta ahora.

Desde la versión 1.7, Hono soporta Apache Kafka para mensajería como vista previa técnica. Una característica clave de Hono es la definición e implementación de APIs para reenviar mensajes hacia y desde un sistema de mensajería. Dado que las definiciones de API se basan en mensajería y dependen directamente de sus propiedades, soportar un nuevo sistema de mensajería es una innovación fundamental para Hono. Para todas las APIs de mensajería en Hono (telemetría, evento y comando y control), se crearon nuevas especificaciones basadas en Kafka, tanto hacia el adaptador de protocolo como hacia la aplicación de negocio. Se tuvo cuidado de asegurar que se comporten lo más similar posible a las APIs basadas en AMQP.

Beneficios

Apache Kafka es una plataforma de streaming de eventos distribuida diseñada para throughput muy alto mientras proporciona ciertas garantías en el orden de los mensajes. Es una gran opción para los requisitos de Hono respecto a mensajería por varias razones. Beneficios clave son:

• Escalado: Múltiples servidores Kafka operan simultáneamente como un clúster que puede expandirse según necesidad. Kafka está optimizado para permitir que muchos procesos escriban y lean datos simultáneamente. Con AMQP 1.0, múltiples procesos también pueden consumir mensajes de la misma dirección en paralelo. Sin embargo, eso significa que pierden su orden.
• Ordenación de mensajes: Una de las características centrales de Kafka es la partición de datos mediante una clave de partición, que puede usarse para seleccionar datos para los que el orden debe mantenerse y datos que pueden procesarse en paralelo. En Hono, esto nos permite asegurar fácilmente que todos los eventos de un dispositivo se proporcionen a la aplicación de negocio en el orden correcto. Los datos de telemetría del dispositivo pueden procesarse en paralelo, y su orden también está garantizado. Los mensajes de todos los demás dispositivos pueden consumirse en paralelo, completamente independientes, incluso en múltiples instancias de la aplicación de negocio usadas concurrentemente.
• Adopción a gran escala: Kafka es usado por un gran número de empresas y es soportado por muchas otras tecnologías. Varias empresas ofrecen Kafka como servicio que puede reservarse en varias plataformas en la nube. Esto facilita proveer a Hono un sistema de mensajería operado profesionalmente. El vendor lock-in también se evita.

Cambios

AMQP 1.0 es un protocolo de comunicación donde pares se conectan entre sí para intercambiar mensajes. En contraste, un clúster Kafka consiste en brokers que coordinan la escritura (y lectura) de datos en almacenamiento permanente. Esta diferencia tiene dos consecuencias: Primero, un mensaje está disponible para recuperación por un tiempo antes de ser eventualmente eliminado. Para lograr este efecto en Hono con AMQP, típicamente se provee un message broker separado donde los eventos se almacenan para evitar pérdida de mensajes si la aplicación de negocio está temporalmente indisponible. Con Kafka, cada mensaje se almacena. Esto incluye mensajes de telemetría (el tiempo de almacenamiento, sin embargo, depende de la configuración de los topics de telemetría en el clúster Kafka). Segundo, comunicar vía almacenamiento permanente desacopla las operaciones de envío y recepción entre sí: El adaptador de protocolo ya no puede reportar al dispositivo si actualmente no hay consumidor conectado. En su lugar, simplemente almacena los mensajes sin "saber" si o cuándo una aplicación de negocio los leerá.

Probándolo

Al instalar Hono, necesitas desplegar ya sea una red de mensajería AMQP o un clúster Kafka. También existe la posibilidad de configurar Hono para usar ambos sistemas de mensajería. Entonces, cada tenant (un subconjunto de dispositivos y configuración) puede configurarse para usar AMQP o Kafka. El proyecto Hono proporciona un entorno sandbox accesible públicamente en Internet donde puedes experimentar con Hono usando mensajería basada en AMQP o Kafka.

Ejemplo práctico

A continuación, te guiamos a través de un pequeño ejemplo de cómo usar mensajería basada en Apache Kafka en el sandbox de Hono. Enviarás un mensaje de telemetría al adaptador de protocolo HTTP y luego lo leerás del clúster Kafka.

Simulamos un dispositivo habilitado para Internet enviando comandos HTTP desde la línea de comandos. Para esto, usamos la popular herramienta open-source curl. Si no está instalado actualmente en tu computadora, consulta las instrucciones de instalación en la página de inicio de curl. Para simular la aplicación de negocio, usamos el cliente de línea de comandos de Hono, que puede descargarse desde la página de descargas de Hono. Ten en cuenta que Java debe estar instalado en al menos versión 11 para ejecutarlo.

Si alguno de los comandos mostrados a continuación no funciona (lo que siempre puede ocurrir con tales instrucciones), consulta la Guía de Mensajería Kafka donde las explicaciones cubren más detalles.

Registrando un dispositivo

Primero, necesitas crear un nuevo tenant en el sandbox para evitar interferir con otros usuarios. El siguiente comando crea un tenant con ID aleatorio y lo configura para usar Kafka para mensajería.

$ curl -i -H "content-type: application/json" --data-binary '{\n "ext": {\n "messaging-type": "kafka"\n }\n}' https://hono.eclipseprojects.io:28080/v1/tenants

La salida debería contener algo como: {"id":"85f63e23-1b78-4156-8500-debcbd1a8d35"}.

Ahora copia este ID y establécelo como variable de entorno de la siguiente manera:

$ export MY_TENANT=85f63e23-1b78-4156-8500-debcbd1a8d35

Registra un dispositivo para el tenant:

$ curl -i -X POST https://hono.eclipseprojects.io:28080/v1/devices/$MY_TENANT

y una vez más proporciona el ID devuelto como variable de entorno de la siguiente manera:

$ export MY_DEVICE=4412abe2-f219-4099-ae14-b446604ae9c6

Finalmente establece una contraseña para el dispositivo:

$ export MY_PWD=my-pwd
$ curl -i -X PUT -H "content-type: application/json" --data-binary '[{\n "type": "hashed-password",\n "auth-id": "'$MY_DEVICE'",\n "secrets": [{\n "pwd-plain": "'$MY_PWD'"\n }]\n}]' https://hono.eclipseprojects.io:28080/v1/credentials/$MY_TENANT/$MY_DEVICE

Enviando un mensaje

Ahora que has registrado un dispositivo, puedes enviar y recibir mensajes.

Abre una segunda ventana de terminal para recibir los mensajes. Ve al directorio donde descargaste el cliente de línea de comandos de Hono. Ahora inicia el cliente con el siguiente comando, asegurándote de reemplazar my-tenant con el ID del tenant que acabas de crear:

# en directorio donde el archivo hono-cli-*-exec.jar ha sido descargado
$ java -jar hono-cli-*-exec.jar --spring.profiles.active=receiver,sandbox,kafka --tenant.id="my-tenant"

El cliente está listo para recibir mensajes si la salida contiene una línea similar a la siguiente:
10:23:01.807 [vert.x-eventloop-thread-0] INFO org.eclipse.hono.cli.app.Receiver - Receiver [tenant: 85f63e23-1b78-4156-8500-debcbd1a8d35, mode: all] created successfully, hit ctrl-c to exit

Ahora puedes enviar un mensaje desde tu dispositivo simulado a Hono. Para esto, vuelve a la primera ventana de terminal. El siguiente comando envía un mensaje de telemetría al adaptador de protocolo HTTP:

$ curl -i -u $MY_DEVICE@$MY_TENANT:$MY_PWD -H "content-type: application/json" --data-binary '{"temp": 42}' https://hono.eclipseprojects.io:8080/telemetry

El mensaje debería imprimirse ahora en la segunda terminal.

También puedes enviar un evento:

$ curl -i -u $MY_DEVICE@$MY_TENANT:$MY_PWD -H "content-type: application/json" --data-binary '{"hello": "kafka"}' https://hono.eclipseprojects.io:8080/event

Ahora deberías haber, esperemos, tenido éxito enviando mensajes desde un dispositivo a Hono y recibiéndolos del clúster Kafka. Como siguiente paso, podrías echar un vistazo a los ejemplos más detallados en la Guía de Mensajería Kafka de Hono. También te muestra cómo enviar un comando desde la aplicación de negocio al dispositivo y responder a él. Si quieres profundizar, podrías querer echar un vistazo a las especificaciones de las APIs basadas en Kafka, que pueden encontrarse en las Especificaciones de API de Hono.

Conclusión

El sistema de mensajería es la base para la funcionalidad central de Eclipse Hono porque sus interfaces se proporcionan sobre él. Soportar Kafka junto a AMQP 1.0 es un cambio muy profundo para Hono, donde se ha puesto gran énfasis en asegurar que las interfaces puedan mapearse fácilmente entre sí. Los beneficios clave de Kafka son su escalabilidad, sus garantías de ordenación, su adopción a gran escala y la riqueza de ofertas de servicios comerciales. Las principales diferencias con la mensajería con AMQP son que todos los tipos de mensaje son brokered. Esto significa que los mensajes pueden entregarse incluso si el destinatario estuvo desconectado por un momento. La comunicación también está desacoplada en términos de tiempo para que la retroalimentación directa del destinatario al remitente de un mensaje ya no sea posible. En un breve ejemplo práctico, te mostramos cómo enviar mensajes desde un dispositivo simulado al sandbox de Hono y consumirlos del clúster Kafka.