Eclipse Hono Agora Suporta Apache Kafka para Mensageria de Dispositivos Perfeita

Eclipse Hono é um projeto open-source para conectar grandes números de dispositivos heterogêneos a um backend (cloud). Hono define interfaces de serviço que permitem comunicação uniforme entre dispositivos, que podem usar protocolos amplamente diferentes, bem como aplicações de negócio. O projeto existe há algum tempo e tem sido usado com sucesso no Bosch IoT Device Management por vários anos. O que é novo é que agora suporta Apache Kafka para mensageria. Os benefícios resultantes e mudanças no uso do Hono são apresentados neste artigo.

Dados vindos de dispositivos são transformados no Hono para um formato de mensagem uniforme por adaptadores de protocolo (ex: existem para MQTT, HTTP e CoAP) e passados a um sistema de mensageria. Aplicações de negócio leem essas mensagens, que são ou mensagens de telemetria ou eventos, diretamente do sistema de mensageria (também podem usar Comando e Controle para enviar mensagens a dispositivos e receber respostas). Para mensageria, que não faz parte do Hono mas deve ser provida externamente, o protocolo AMQP 1.0 tem sido usado até agora.

Desde a versão 1.7, Hono suporta Apache Kafka para mensageria como preview técnico. Um recurso chave do Hono é a definição e implementação de APIs para encaminhar mensagens de e para um sistema de mensageria. Como as definições de API são baseadas em mensageria e dependem diretamente de suas propriedades, suportar um novo sistema de mensageria é uma inovação fundamental para o Hono. Para todas as APIs de mensageria no Hono (telemetria, evento e comando e controle), novas especificações baseadas em Kafka foram criadas, tanto voltadas para o adaptador de protocolo quanto para a aplicação de negócio. Cuidado foi tomado para garantir que se comportem da forma mais similar possível às APIs baseadas em AMQP.

Benefícios

Apache Kafka é uma plataforma distribuída de streaming de eventos projetada para throughput muito alto enquanto fornece certas garantias na ordem das mensagens. É um ótimo ajuste para os requisitos do Hono sobre mensageria por várias razões. Benefícios-chave são:

• Escalabilidade: Múltiplos servidores Kafka operam simultaneamente como um cluster que pode ser expandido conforme necessário. Kafka é otimizado para permitir que muitos processos escrevam e leiam dados simultaneamente. Com AMQP 1.0, múltiplos processos também podem consumir mensagens do mesmo endereço em paralelo. No entanto, isso significa que perdem sua ordem.
• Ordenação de mensagens: Um dos recursos centrais do Kafka é a particionamento de dados por meio de uma chave de partição, que pode ser usada para selecionar dados para os quais a ordem deve ser mantida e dados que podem ser processados em paralelo. No Hono, isso nos permite garantir facilmente que todos os eventos de um dispositivo sejam fornecidos à aplicação de negócio na ordem correta. Os dados de telemetria do dispositivo podem ser processados em paralelo, e sua ordem também é garantida. Mensagens de todos os outros dispositivos podem ser consumidas em paralelo, completamente independentes, mesmo em múltiplas instâncias da aplicação de negócio sendo usadas concurrentemente.
• Adoção em larga escala: Kafka é usado por um grande número de empresas e suportado por muitas outras tecnologias. Várias empresas oferecem Kafka como serviço que pode ser contratado em várias plataformas de cloud. Isso torna fácil prover o Hono com um sistema de mensageria operado profissionalmente. Vendor lock-in também é evitado.

Mudanças

AMQP 1.0 é um protocolo de comunicação onde peers se conectam para trocar mensagens. Em contraste, um cluster Kafka consiste em brokers que coordenam a escrita (e leitura) de dados em armazenamento permanente. Essa diferença tem duas consequências: Primeiro, uma mensagem fica disponível para recuperação por um tempo antes de ser eventualmente deletada. Para alcançar esse efeito no Hono com AMQP, você tipicamente provê um message broker separado onde eventos são armazenados para evitar perda de mensagens caso a aplicação de negócio esteja temporariamente indisponível. Com Kafka, toda mensagem é armazenada. Isso inclui mensagens de telemetria (o tempo de armazenamento, no entanto, depende da configuração dos tópicos de telemetria no cluster Kafka). Em segundo lugar, comunicar via armazenamento permanente desacopla as operações de envio e recebimento uma da outra: O adaptador de protocolo não pode mais reportar de volta ao dispositivo se não há consumidor conectado no momento. Em vez disso, simplesmente armazena as mensagens sem "saber" se ou quando uma aplicação de negócio as lerá.

Testando

Ao instalar Hono, você precisa implantar ou uma rede de mensageria AMQP ou um cluster Kafka. Também há a possibilidade de configurar Hono para usar ambos sistemas de mensageria. Então, cada tenant (um subconjunto de dispositivos e configuração) pode ser configurado para usar AMQP ou Kafka. O projeto Hono fornece um ambiente sandbox publicamente acessível na Internet onde você pode experimentar com Hono usando mensageria baseada em AMQP ou Kafka.

Exemplo prático

A seguir, guiamos você através de um pequeno exemplo de como usar mensageria baseada em Apache Kafka no sandbox do Hono. Você enviará uma mensagem de telemetria ao adaptador de protocolo HTTP e então a lerá do cluster Kafka.

Simulamos um dispositivo habilitado para Internet enviando comandos HTTP da linha de comando. Para isso, usamos a popular ferramenta open-source curl. Se não estiver instalado no seu computador, consulte as instruções de instalação na página inicial do curl. Para simular a aplicação de negócio, usamos o cliente de linha de comando do Hono, que pode ser baixado da página de downloads do Hono. Observe que Java deve ser instalado na versão 11 pelo menos para rodá-lo.

Se qualquer um dos comandos mostrados abaixo não funcionar (o que pode sempre acontecer com tais instruções), consulte o Kafka Messaging Guide onde as explicações cobrem mais detalhes.

Registrando um dispositivo

Primeiro, você precisa criar um novo tenant no sandbox para evitar interferir com outros usuários. O seguinte comando cria um tenant com ID aleatório e o configura para usar Kafka para mensageria.

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

A saída deve conter algo como: {"id":"85f63e23-1b78-4156-8500-debcbd1a8d35"}.

Agora copie este ID e defina-o como variável de ambiente da seguinte forma:

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

Registre um dispositivo para o tenant:

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

e mais uma vez forneça o ID retornado como variável de ambiente da seguinte forma:

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

Finalmente defina uma senha para o dispositivo:

$ 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

Enviando uma mensagem

Agora que você registrou um dispositivo, pode enviar e receber mensagens.

Abra uma segunda janela de terminal para receber as mensagens. Vá ao diretório onde baixou o cliente de linha de comando do Hono. Agora inicie o cliente com o seguinte comando, certificando-se de substituir my-tenant pelo ID do tenant que você acabou de criar:

# no diretório onde o arquivo hono-cli-*-exec.jar foi baixado
$ java -jar hono-cli-*-exec.jar --spring.profiles.active=receiver,sandbox,kafka --tenant.id="my-tenant"

O cliente está pronto para receber mensagens se a saída contiver uma linha similar à seguinte:
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

Agora você pode enviar uma mensagem do seu dispositivo simulado para o Hono. Para isso, volte à primeira janela de terminal. O seguinte comando envia uma mensagem de telemetria ao 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

A mensagem deve agora ser impressa no segundo terminal.

Você também pode enviar um 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

Agora você deve ter, esperançosamente, sucesso em enviar mensagens de um dispositivo para o Hono e recebê-las do cluster Kafka. Como próximo passo, você pode dar uma olhada nos exemplos mais detalhados no Kafka Messaging Guide do Hono. Ele também mostra como enviar um comando da aplicação de negócio para o dispositivo e responder a ele. Se quiser se aprofundar, pode querer dar uma olhada nas especificações das APIs baseadas em Kafka, que podem ser encontradas nas API Specifications do Hono.

Conclusão

O sistema de mensageria é a base para a funcionalidade central do Eclipse Hono porque suas interfaces são fornecidas sobre ele. Suportar Kafka junto com AMQP 1.0 é uma mudança muito profunda para o Hono, onde grande ênfase foi colocada em garantir que interfaces possam ser facilmente mapeadas uma à outra. Os principais benefícios do Kafka são sua escalabilidade, suas garantias de ordenação, sua ampla adoção e riqueza de ofertas de serviços comerciais. As principais diferenças para mensageria com AMQP são que todos os tipos de mensagem são brokered. Isso significa que mensagens podem ser entregues mesmo se o destinatário estava desconectado por um momento. A comunicação também é desacoplada no tempo de forma que feedback direto do destinatário para o remetente de uma mensagem não é mais possível. Em um breve exemplo prático, mostramos como enviar mensagens de um dispositivo simulado para o sandbox do Hono e consumi-las do cluster Kafka.