Eclipse Hono apoiando Apache Kafka para mensagens

Eclipse Hono é um projeto de código aberto para conectar um grande número de dispositivos heterogêneos a um back-end (nuvem). Hono define interfaces de serviço que permitem a comunicação uniforme entre dispositivos, que podem usar protocolos amplamente diferentes, bem como aplicativos de negócios. O projeto já existe há algum tempo e tem sido usado com sucesso no Bosch IoT Device Management por vários anos. A novidade é que agora ele suporta Apache Kafka para mensagens. Os benefícios e mudanças resultantes no uso do Hono são apresentados neste artigo.

Os dados provenientes de dispositivos são transformados em Hono para um formato de mensagem uniforme por adaptadores de protocolo (por exemplo, existem alguns para MQTT, HTTP e CoAp) e passados ​​para um sistema de mensagens. Os aplicativos de negócios leem essas mensagens, que são mensagens de telemetria ou eventos , diretamente do sistema de mensagens (eles também podem usar Comando e Controle para enviar mensagens para dispositivos e receber respostas). Para mensagens, que não fazem parte do Hono, mas devem ser fornecidas externamente, o protocolo AMQP 1.0 foi usado até agora.

Desde a versão 1.7, Hono suporta Apache Kafka para mensagens como uma prévia técnica . Um recurso importante do Hono é a definição e implementação de APIs para encaminhar mensagens de e para um sistema de mensagens. Como as definições de API são baseadas em mensagens e dependem diretamente de suas propriedades, o suporte a um novo sistema de mensagens é uma inovação fundamental para Hono. Para todas as APIs de mensagens em Hono ( telemetria , evento , e comando e controle ), foram criadas novas especificações baseadas no Kafka, tanto voltadas para o adaptador de protocolo quanto para o aplicativo de negócios. Foi tomado cuidado para garantir que eles se comportassem da forma mais semelhante possível às APIs baseadas em AMQP.

Benefícios

Apache Kafka é uma plataforma de streaming de eventos distribuída projetada para um rendimento muito alto, enquanto fornece certas garantias na ordem das mensagens. É uma excelente opção para os requisitos de Hono em relação a mensagens por vários motivos. Os principais benefícios são:

• Dimensionamento :Vários servidores Kafka são operados simultaneamente como um cluster que pode ser expandido conforme necessário. O Kafka é otimizado para permitir que muitos processos gravem e leiam dados simultaneamente. Com o AMQP 1.0, vários processos também podem consumir mensagens do mesmo endereço em paralelo. No entanto, isso significa que eles perderam o pedido.
• Ordem de mensagens :Um dos principais recursos do Kafka é o particionamento de dados por meio de uma chave de partição, que pode ser usado para selecionar dados para os quais o pedido deve ser mantido e dados que podem ser processados ​​em paralelo. No Hono, isso nos permite garantir facilmente que todos os eventos de um dispositivo sejam fornecidos ao aplicativo de negócios na ordem correta. Os dados de telemetria do aparelho podem ser processados ​​em paralelo, e sua ordem também é garantida. As mensagens de todos os outros dispositivos podem ser consumidas em paralelo, de forma totalmente independente, mesmo em várias instâncias do aplicativo de negócios sendo usado simultaneamente.
• Adoção em larga escala :Kafka é usado por um grande número de empresas e é suportado por muitas outras tecnologias. Várias empresas oferecem o Kafka como um serviço que pode ser reservado em várias plataformas de nuvem. Isso torna mais fácil fornecer à Hono um sistema de mensagens operado profissionalmente. O aprisionamento do fornecedor também é evitado.

Mudanças

AMQP 1.0 é um protocolo de comunicação onde os pares se conectam entre si para trocar mensagens. Em contraste, um cluster Kafka consiste em brokers que coordenam a gravação (e leitura) de dados para armazenamento permanente. Essa diferença tem duas consequências:primeiro, uma mensagem fica disponível para recuperação por um tempo antes de ser excluída. Para obter esse efeito em Hono com AMQP, você normalmente fornece um agente de mensagens separado, onde eventos são armazenados para evitar a perda de mensagens caso o aplicativo de negócios esteja temporariamente indisponível. Com o Kafka, todas as mensagens são armazenadas. 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, a comunicação por meio de armazenamento permanente separa as operações de envio e recebimento umas das outras:o adaptador de protocolo não pode mais relatar para o dispositivo se não houver nenhum consumidor conectado. Em vez disso, ele simplesmente armazena as mensagens sem “saber” se ou quando um aplicativo de negócios as lerá.

Experimentando

Ao instalar o Hono, você precisa implantar uma rede de mensagens AMQP ou um cluster Kafka. Também existe a possibilidade de configurar o Hono para usar ambos sistemas de mensagens. Em seguida, cada locatário (um subconjunto de dispositivos e configuração) pode ser configurado para usar AMQP ou Kafka. O projeto Hono fornece um ambiente de área restrita acessível ao público na Internet, onde você pode experimentar o Hono usando AMQP ou mensagens baseadas em Kafka.

Exemplo prático

A seguir, vamos percorrer um pequeno exemplo de como usar mensagens baseadas em Apache Kafka no sandbox Hono. Você enviará uma mensagem de telemetria ao adaptador de protocolo HTTP e, em seguida, a lerá do cluster Kafka.

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

Se algum dos comandos mostrados abaixo não funcionar (o que sempre pode acontecer com essas instruções), consulte o Guia de Mensagens Kafka, onde as explicações cobrem mais detalhes.

Registrando um dispositivo

Primeiro, você precisa criar um novo inquilino na sandbox para evitar interferir com outros usuários. O comando a seguir cria um inquilino com um ID aleatório e o configura para usar o Kafka para mensagens.
$ curl -i -H "content-type:application / json" --data-binary '{ "ext":{ "tipo de mensagem":"kafka" } } 'http://hono.eclipseprojects.io:28080/v1/tenants
A saída deve conter algo ao longo das linhas de: {"id":"85f63e23-1b78-4156-8500-debcbd1a8d35"} .

Agora copie este ID e defina-o como uma variável de ambiente da seguinte maneira:
$ export MY_TENANT =85f63e23-1b78-4156-8500-debcbd1a8d35
Registre um dispositivo para o locatário:
$ curl -i -X ​​POST http://hono.eclipseprojects.io:28080/v1/devices/$MY_TENANT
e, mais uma vez, forneça o ID retornado como uma variável de ambiente da seguinte maneira:
$ export MY_DEVICE =4412abe2-f219-4099-ae14-b446604ae9c6
Por fim, defina uma senha para o dispositivo:
$ export MY_PWD =my-pwd $ curl -i -X ​​PUT -H "content-type:application / json" --data-binary '[{ "tipo":"senha com hash", "auth-id":"'$ MY_DEVICE'", "segredos":[{ "pwd-plain":"'$ MY_PWD'" }] }] 'http://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á para o diretório onde você baixou o cliente de linha de comando Hono. Agora inicie o cliente com o seguinte comando, certificando-se de substituir my-tenant com o ID do locatário que você acabou de criar:
# no diretório onde o arquivo hono-cli - * - exec.jar foi baixado para $ 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 semelhante à 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] criado com sucesso, pressione ctrl-c para sair

Agora você pode enviar uma mensagem do seu dispositivo simulado para Hono. Para fazer isso, volte para a primeira janela do terminal. O comando a seguir 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}' http://hono.eclipseprojects.io:8080 /telemetria
A mensagem agora deve 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"}' http://hono.eclipseprojects.io :8080 / evento
Agora você deve ter tido sucesso ao enviar mensagens de um dispositivo para Hono e recebê-las do cluster Kafka. Como uma próxima etapa, você pode dar uma olhada nos exemplos mais detalhados no Guia de Mensagens Kafka de Hono. Ele também mostra como enviar um comando do aplicativo de negócios para o dispositivo e respondê-lo. Se você quiser se aprofundar, pode dar uma olhada nas especificações das APIs baseadas em Kafka, que podem ser encontradas nas Especificações da API de Hono.

Conclusão

O sistema de mensagens é a base para a funcionalidade central do Eclipse Hono porque suas interfaces são fornecidas em cima dele. Apoiar Kafka junto com AMQP 1.0 é uma mudança muito profunda para Hono, onde grande ênfase foi colocada em garantir que as interfaces possam ser facilmente mapeadas entre si. Os principais benefícios do Kafka são sua escalabilidade, suas garantias de pedidos, sua adoção em larga escala e a riqueza de ofertas de serviços comerciais. As principais diferenças nas mensagens com AMQP são que todos os tipos de mensagens são intermediados. Isso significa que as mensagens podem ser entregues mesmo que o destinatário tenha se desconectado por um momento. A comunicação também é desacoplada em termos de tempo, de modo que o feedback direto do destinatário ao remetente da mensagem não é mais possível. Em um breve exemplo prático, mostramos como enviar mensagens de um dispositivo simulado para a sandbox Hono e consumi-las do cluster Kafka.