Apache Kafka gegen Apache Storm

Apache Kafka: Verteiltes Nachrichtensystem
Apache Storm: Echtzeit-Nachrichtenverarbeitung

Wie können wir beide Technologien in einer Echtzeitdatenpipeline zur Verarbeitung von Ereignisdaten verwenden?

In Bezug auf die Echtzeit-Datenpipeline scheinen mir beide den Job identisch zu machen. Wie können wir beide Technologien in einer Datenpipeline verwenden?

Sie verwenden Apache Kafka als verteilte und robuste Warteschlange, die Daten mit hohem Datenvolumen verarbeiten kann und es Ihnen ermöglicht, Nachrichten von einem Endpunkt an einen anderen zu übergeben.

Sturm ist keine Warteschlange. Es handelt sich um ein System mit verteilten Echtzeitverarbeitungsfunktionen, sodass Sie alle Arten von Manipulationen an Echtzeitdaten parallel ausführen können.

Der gemeinsame Ablauf dieser Tools (wie ich ihn kenne) sieht wie folgt aus:

Echtzeitsystem -> Kafka -> Storm -> NoSql -> BI (optional)

Sie haben also Ihre Echtzeit-App, die Daten mit hohem Datenvolumen verarbeitet und an die Kafka-Warteschlange sendet. Storm zieht die Daten aus Kafka und führt einige erforderliche Manipulationen durch. An diesem Punkt möchten Sie normalerweise einige Vorteile aus diesen Daten ziehen, sodass Sie sie entweder für zusätzliche BI-Berechnungen an eine Nosql-Datenbank senden oder diese NoSql einfach von einem anderen System abfragen können.

Kafka und Storm haben einen etwas anderen Zweck:

Kafka ist ein verteilter Nachrichtenbroker, der eine große Anzahl von Nachrichten pro Sekunde verarbeiten kann. Es verwendet das Publish-Subscribe-Paradigma und stützt sich auf Themen und Partitionen. Kafka verwendet Zookeeper, um den Status zwischen Brokern zu teilen und zu speichern. Kafka ist also grundsätzlich für die Übertragung von Nachrichten von einem Computer auf einen anderen verantwortlich.

Storm ist ein skalierbares, fehlertolerantes Echtzeit-Analysesystem (denken Sie wie Hadoop in Echtzeit). Es verbraucht Daten aus Quellen (Ausläufen) und leitet sie an die Pipeline (Bolts) weiter. Sie können sie in der Topologie kombinieren. Storm ist also im Grunde eine Recheneinheit (Aggregation, maschinelles Lernen).

Sie können sie jedoch zusammen verwenden: Ihre Anwendung verwendet beispielsweise kafka, um Daten an andere Server zu senden, die Storm verwenden, um einige Berechnungen daran durchzuführen.

Ich weiß, dass dies ein älterer Thread ist und die Vergleiche von Apache Kafka und Storm gültig und korrekt waren, als sie geschrieben wurden, aber es ist erwähnenswert, dass sich Apache Kafka im Laufe der Jahre stark weiterentwickelt hat und seit Version 0.10 (April 2016) Kafka enthalten hat Eine Kafka Streams-API, die Stream-Verarbeitungsfunktionen bietet, ohne dass zusätzliche Software wie Storm erforderlich ist. Kafka enthält auch die Connect-API für die Verbindung mit verschiedenen Datenquellen und -senken (-zielen).

Ankündigungsblog - https://www.confluent.io/blog/introducing-kafka-streams-stream-processing-made-simple/

Aktuelle Apache-Dokumentation - https://kafka.apache.org/documentation/streams/

In 0.11 Kafka wurde die Stream-Verarbeitungsfunktionalität weiter erweitert, um genau einmalige Semantik und Transaktionen bereitzustellen.

https://www.confluent.io/blog/exactly-once-semantics-are-possible-heres-how-apache-kafka-does-it/

So funktioniert es

Kafka - Um einen Echtzeit-Stream bereitzustellen

Sturm - Um einige Operationen an diesem Stream durchzuführen

Sie können sich das GitHub-Projekt ansehen https://github.com/abhishekgoel137/kafka-nodejs-d3js .

(D3js ist eine Grafikdarstellungsbibliothek)

Idealfall:

Realtime application -> Kafka -> Storm -> NoSQL -> d3js

Dieses Repository basiert auf:

Realtime application -> Kafka -> <plain Node.js> -> NoSQL -> d3js

Wie jeder Ihnen erklärt, ist Apache Kafka: eine kontinuierliche Messaging-Warteschlange

Apache Storm: ist ein kontinuierliches Verarbeitungswerkzeug

Hier in diesem Aspekt erhält Kafka die Daten von jeder Website wie FB, Twitter mithilfe von APIs. Diese Daten werden mithilfe von Apache Storm verarbeitet, und Sie können die verarbeiteten Daten in einer beliebigen Datenbank speichern.

https://github.com/miguno/kafka-storm-starter

Folgen Sie ihm einfach, Sie werden eine Vorstellung davon bekommen

Wenn ich einen Anwendungsfall habe, bei dem ich Muster visualisieren oder alarmieren muss (denken Sie an Twitter-Trends), während ich die Ereignisse weiter verarbeite, habe ich mehrere Muster.
Mit NiFi könnte ich ein Ereignis verarbeiten und einen persistenten Datenspeicher mit geringer (er) Stapelaggregation mit sehr, sehr wenig benutzerdefinierter Codierung aktualisieren.
Storm (viele benutzerdefinierte Codierungen) ermöglicht mir den Zugriff auf die Trendereignisse nahezu in Echtzeit.
Wenn ich viele Sekunden warten kann, kann ich aus kafka in hdfs (Parkett) stapeln und verarbeiten.
Wenn ich es in Sekunden wissen muss, brauche ich NiFi und wahrscheinlich sogar Storm. (Denken Sie daran, Tausende von Bodenstationen zu überwachen, bei denen ich die Wetterbedingungen in kleinen Regionen für Tornado-Warnungen sehen muss.)

Senden Sie einfach die Nachrichten von Kafka vom Knoten an einen anderen, und Storm verarbeitet die Nachrichten. Sehen Sie sich dieses Beispiel an, wie Sie Apache Kafka With Storm integrieren können