Apache Kafka: sistema de mensagens distribuídas
Apache Storm: processamento de mensagens em tempo real
Como podemos usar as duas tecnologias em um pipeline de dados em tempo real para processar dados de eventos?
Em termos de pipeline de dados em tempo real, ambos parecem fazer o trabalho idêntico. Como podemos usar ambas as tecnologias em um pipeline de dados?
Respostas:
Você usa o Apache Kafka como uma fila distribuída e robusta que pode lidar com dados de alto volume e permite que você passe mensagens de um terminal para outro.
Storm não é uma fila. É um sistema que possui capacidades de processamento distribuído em tempo real, o que significa que você pode executar todo tipo de manipulação de dados em tempo real em paralelo.
O fluxo comum dessas ferramentas (como eu sei) é o seguinte:
sistema em tempo real -> Kafka -> Tempestade -> NoSql -> BI (opcional)
Então você tem seu aplicativo em tempo real gerenciando dados de alto volume e os envia para a fila Kafka. Storm extrai os dados do kafka e aplica alguma manipulação necessária. Neste ponto, você normalmente gostaria de obter alguns benefícios desses dados, então você os envia para algum banco de dados Nosql para cálculos adicionais de BI ou pode simplesmente consultar este NoSql de qualquer outro sistema.
Kafka e Storm têm uma finalidade ligeiramente diferente:
Kafka é um corretor de mensagens distribuído que pode lidar com uma grande quantidade de mensagens por segundo. Ele usa o paradigma publicar-assinar e depende de tópicos e partições. Kafka usa o Zookeeper para compartilhar e salvar estados entre corretores. Portanto, Kafka é basicamente responsável por transferir mensagens de uma máquina para outra.
Storm é um sistema analítico escalável, tolerante a falhas e em tempo real (pense como o Hadoop em tempo real). Ele consome dados de fontes (Spouts) e os passa para o pipeline (Bolts). Você pode combiná-los na topologia. Então Storm é basicamente uma unidade de computação (agregação, aprendizado de máquina).
Mas você pode usá-los juntos: por exemplo, seu aplicativo usa kafka para enviar dados a outros servidores que usam o storm para fazer alguns cálculos sobre ele.
Eu sei que este é um tópico mais antigo e as comparações de Apache Kafka e Storm eram válidas e corretas quando foram escritas, mas é importante notar que Apache Kafka evoluiu muito ao longo dos anos e desde a versão 0.10 (abril de 2016) Kafka incluiu uma API Kafka Streams que fornece recursos de processamento de stream sem a necessidade de nenhum software adicional, como Storm. Kafka também inclui a API Connect para conectar-se a várias fontes e coletores (destinos) de dados.
Blog de anúncio - https://www.confluent.io/blog/introducing-kafka-streams-stream-processing-made-simple/
Documentação atual do Apache - https://kafka.apache.org/documentation/streams/
No 0.11 Kafka, a funcionalidade de processamento de fluxo foi expandida ainda mais para fornecer a Semântica e Transações Exatamente Uma Vez.
https://www.confluent.io/blog/exactly-once-semantics-are-possible-heres-how-apache-kafka-does-it/
Kafka - para fornecer uma transmissão em tempo real
Tempestade - Para realizar algumas operações nesse fluxo
Você pode dar uma olhada no projeto GitHub https://github.com/abhishekgoel137/kafka-nodejs-d3js .
(D3js é uma biblioteca de representação gráfica)
Caso ideal:
Realtime application -> Kafka -> Storm -> NoSQL -> d3js
Este repositório é baseado em:
Realtime application -> Kafka -> <plain Node.js> -> NoSQL -> d3js
Como todos explicam que Apache Kafka: é uma fila de mensagens contínuas
Apache Storm: é uma ferramenta de processamento contínuo
aqui, neste aspecto, Kafka obterá os dados de qualquer site como FB, Twitter usando APIs e esses dados são processados usando Apache Storm e você pode armazenar os dados processados em qualquer banco de dados de sua preferência.
https://github.com/miguno/kafka-storm-starter
Basta seguir você terá uma ideia
Quando tenho um caso de uso que exige que eu visualize ou alerte padrões (pense nas tendências do twitter), enquanto continuo processando os eventos, tenho vários padrões.
A NiFi me permitiria processar um evento e atualizar um armazenamento de dados persistente com agregação de lote baixa (er) com muito, muito pouca codificação personalizada.
Storm (muita codificação customizada) me permite acesso quase em tempo real aos eventos de tendência.
Se eu puder esperar muitos segundos, então poderei sair do kafka em lote para hdfs (Parquet) e processar.
Se eu precisar saber em segundos, preciso de NiFi e provavelmente até de Storm. (Pense em monitorar milhares de estações terrenas, onde preciso ver as condições climáticas de pequenas regiões quanto a avisos de tornado).
Simplesmente Kafka envia as mensagens de um nó para outro, e Storm processa as mensagens. Veja este exemplo de como você pode integrar o Apache Kafka com o Storm