Eclipse Hono ondersteunt nu Apache Kafka voor naadloze device-messaging

Eclipse Hono is een open-source project voor het verbinden van grote aantallen heterogene apparaten met een (cloud) back-end. Hono definieert service-interfaces die uniforme communicatie mogelijk maken tussen apparaten, die wijd uiteenlopende protocollen kunnen gebruiken, alsook bedrijfsapplicaties. Het project bestaat al enige tijd en is met succes gebruikt in Bosch IoT Device Management voor meerdere jaren. Wat nieuw is, is dat het nu Apache Kafka ondersteunt voor messaging. De resulterende voordelen en wijzigingen in het gebruik van Hono worden in dit artikel geïntroduceerd.

Data van apparaten wordt in Hono getransformeerd naar een uniform berichtformaat door protocol-adapters (bijv. er zijn er voor MQTT, HTTP en CoAP) en doorgegeven aan een messaging-systeem. Bedrijfsapplicaties lezen deze berichten, die ofwel telemetrie-berichten ofwel events zijn, direct vanuit het messaging-systeem (ze kunnen ook Command and Control gebruiken om berichten naar apparaten te sturen en antwoorden te ontvangen). Voor messaging, wat niet onderdeel is van Hono maar extern moet worden geleverd, is tot nu toe het AMQP 1.0-protocol gebruikt.

Sinds versie 1.7 ondersteunt Hono Apache Kafka voor messaging als een technical preview. Een sleutelkenmerk van Hono is de definitie en implementatie van API's voor het doorsturen van berichten naar en van een messaging-systeem. Omdat de API-definities gebaseerd zijn op messaging en direct afhangen van zijn eigenschappen, is het ondersteunen van een nieuw messaging-systeem een fundamentele innovatie voor Hono. Voor alle messaging-API's in Hono (telemetrie, event en command and control) werden nieuwe specificaties gebaseerd op Kafka aangemaakt, zowel richting de protocol-adapter als de bedrijfsapplicatie. Er is gezorgd dat ze zich zo vergelijkbaar mogelijk gedragen als de AMQP-gebaseerde API's.

Voordelen

Apache Kafka is een gedistribueerd event-streaming-platform ontworpen voor zeer hoge doorvoer terwijl het bepaalde garanties biedt in de volgorde van berichten. Het is een uitstekende fit voor Hono's vereisten voor messaging om diverse redenen. Belangrijkste voordelen zijn:

• Schalen: Meerdere Kafka-servers worden simultaan als een cluster bediend dat naar behoefte uitgebreid kan worden. Kafka is geoptimaliseerd om veel processen toe te laten om data simultaan te schrijven en te lezen. Met AMQP 1.0 kunnen meerdere processen ook berichten van hetzelfde adres parallel consumeren. Echter, dat betekent dat ze hun volgorde verliezen.
• Berichtvolgorde: Een van Kafka's kernfeatures is het partitioneren van data door middel van een partition key, wat gebruikt kan worden om data te selecteren waarvoor de volgorde behouden moet blijven en data die parallel verwerkt kan worden. In Hono stelt dit ons in staat om gemakkelijk te garanderen dat alle events van een apparaat in de juiste volgorde aan de bedrijfsapplicatie worden geleverd. De telemetriedata van het apparaat kan parallel verwerkt worden, en de volgorde ervan is ook gegarandeerd. Berichten van alle andere apparaten kunnen parallel, volledig onafhankelijk, geconsumeerd worden, zelfs in meerdere instanties van de bedrijfsapplicatie die gelijktijdig gebruikt worden.
• Brede adoptie: Kafka wordt door een groot aantal bedrijven gebruikt en wordt door veel andere technologieën ondersteund. Verschillende bedrijven bieden Kafka als een service aan die op diverse cloud-platformen geboekt kan worden. Dit maakt het gemakkelijk om Hono een professioneel beheerd messaging-systeem te voorzien. Vendor lock-in wordt ook vermeden.

Wijzigingen

AMQP 1.0 is een communicatieprotocol waar peers met elkaar verbinden om berichten uit te wisselen. In tegenstelling bestaat een Kafka-cluster uit brokers die het schrijven (en lezen) van data naar permanente opslag coördineren. Dit verschil heeft twee gevolgen: Ten eerste is een bericht beschikbaar voor ophaling voor een tijdje voordat het uiteindelijk verwijderd wordt. Om dit effect in Hono met AMQP te bereiken, voorziet men typisch een aparte message broker waar events worden opgeslagen om berichtverlies te voorkomen als de bedrijfsapplicatie tijdelijk onbeschikbaar is. Met Kafka wordt elk bericht opgeslagen. Dit omvat telemetrieberichten (de opslagtijd hangt echter af van de configuratie van de telemetrie-topics in de Kafka-cluster). Ten tweede, communiceren via permanente opslag ontkoppelt de zend- en ontvangoperaties van elkaar: De protocol-adapter kan niet meer terugmelden aan het apparaat als er momenteel geen consumer verbonden is. In plaats daarvan slaat het de berichten gewoon op zonder te "weten" of of wanneer een bedrijfsapplicatie ze zal lezen.

Het uitproberen

Bij het installeren van Hono, moet u ofwel een AMQP messaging-netwerk ofwel een Kafka-cluster deployen. Er is ook de mogelijkheid om Hono te configureren om beide messaging-systemen te gebruiken. Dan kan elke tenant (een subset van apparaten en configuratie) geconfigureerd worden om ofwel AMQP ofwel Kafka te gebruiken. Het Hono-project biedt een publiekelijk toegankelijke sandbox-omgeving op het internet waar u kunt experimenteren met Hono met AMQP of Kafka-gebaseerde messaging.

Praktisch voorbeeld

In het volgende lopen we u door een klein voorbeeld van hoe Apache Kafka-gebaseerde messaging in de Hono-sandbox te gebruiken. U stuurt een telemetriebericht naar de HTTP-protocol-adapter en leest het vervolgens van de Kafka-cluster.

We simuleren een internet-ingeschakeld apparaat door HTTP-commando's vanaf de commandoregel te sturen. Hiervoor gebruiken we de populaire open-source tool curl. Als momenteel niet geïnstalleerd op uw computer, raadpleeg de installatie-instructies op de curl-homepage. Om de bedrijfsapplicatie te simuleren, gebruiken we Hono's command-line client, die gedownload kan worden van de Hono-downloadpagina. Let op dat Java minstens versie 11 geïnstalleerd moet zijn om het te draaien.

Als een van de onderstaande commando's niet werkt (wat altijd kan gebeuren met dergelijke instructies), raadpleeg dan de Kafka Messaging Guide waar de uitleg meer details dekt.

Een apparaat registreren

Eerst moet u een nieuwe tenant in de sandbox aanmaken om niet met andere gebruikers te interfereren. Het volgende commando maakt een tenant met een willekeurige ID en configureert het om Kafka voor messaging te gebruiken.

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

De output zou zoiets als het volgende moeten bevatten: {"id":"85f63e23-1b78-4156-8500-debcbd1a8d35"}.

Kopieer nu deze ID en stel het in als een omgevingsvariabele als volgt:

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

Registreer een apparaat voor de tenant:

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

en nogmaals het geretourneerde ID opgeven als omgevingsvariabele als volgt:

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

Ten slotte een wachtwoord instellen voor het apparaat:

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

Een bericht sturen

Nu u een apparaat heeft geregistreerd, kunt u berichten sturen en ontvangen.

Open een tweede terminalvenster om de berichten te ontvangen. Ga naar de map waar u de Hono command-line client heeft gedownload. Start nu de client met het volgende commando, met zorg dat u my-tenant vervangt door de ID van de tenant die u zojuist heeft aangemaakt:

# in directory where the hono-cli-*-exec.jar file has been downloaded to
$ java -jar hono-cli-*-exec.jar --spring.profiles.active=receiver,sandbox,kafka --tenant.id="my-tenant"

De client is klaar om berichten te ontvangen als de output een regel bevat die lijkt op het volgende:
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

Nu kunt u een bericht sturen vanaf uw gesimuleerde apparaat naar Hono. Schakel terug naar het eerste terminalvenster. Het volgende commando stuurt een telemetriebericht naar de HTTP-protocol-adapter:

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

Het bericht zou nu in het tweede terminalvenster moeten worden geprint.

U kunt ook een event sturen:

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

Nu zou u, hopelijk, succesvol berichten hebben gestuurd van een apparaat naar Hono en ze van de Kafka-cluster ontvangen. Als volgende stap kunt u een kijkje nemen in de meer gedetailleerde voorbeelden in Hono's Kafka Messaging Guide. Het toont u ook hoe u een commando van de bedrijfsapplicatie naar het apparaat stuurt en erop reageert. Als u dieper wilt duiken, kunt u wellicht een kijkje nemen in de specificaties van de Kafka-gebaseerde API's, die te vinden zijn in Hono's API Specifications.

Conclusie

Het messaging-systeem is de fundering voor Eclipse Hono's kernfunctionaliteit omdat de interfaces erop worden geboden. Kafka ondersteunen naast AMQP 1.0 is een zeer diepgaande verandering voor Hono, waar grote nadruk is gelegd op het garanderen dat interfaces gemakkelijk op elkaar af te beelden zijn. De sleutelvoordelen van Kafka zijn de schaalbaarheid, de volgorde-garanties, de brede adoptie en de rijkdom aan commerciële service-aanbiedingen. De belangrijkste verschillen met messaging via AMQP zijn dat alle berichttypes gebrokered zijn. Dit betekent dat berichten kunnen worden afgeleverd zelfs als de ontvanger voor een moment was verbroken. De communicatie is ook in termen van tijd ontkoppeld, zodat directe feedback van de ontvanger naar de zender van een bericht niet meer mogelijk is. In een kort praktijkvoorbeeld lieten we u zien hoe berichten van een gesimuleerd apparaat naar de Hono-sandbox te sturen en ze van de Kafka-cluster te consumeren.