Geht nicht? Gibt’s nicht! Mein eigener Apache-NiFi-Prozessor

Apache NiFi ist ein leistungsstarkes Open-Source-Tool für die Datenintegration und -verarbeitung. Mit einer Vielzahl von vordefinierten Prozessoren und Integrationsmöglichkeiten bietet Apache NiFi eine flexible und benutzerfreundliche Plattform für die Entwicklung von Datenverarbeitungspipelines. Dennoch kann es vorkommen, dass die vorhandenen Prozessoren von Apache NiFi nicht alle Anforderungen abdecken, die für ein spezifisches Datenverarbeitungsszenario benötigt werden. In diesen Fällen kann die Entwicklung eines eigenen Prozessors notwendig sein, um die Effizienz und Genauigkeit des Datenverarbeitungsprozesses zu verbessern. In diesem Artikel werden wir uns genauer damit beschäftigen, warum ein eigener Prozessor in Apache NiFi manchmal notwendig ist und wie man Schritt für Schritt einen eigenen Prozessor entwickeln kann.

Grundsätzlich stehen in NiFi eine Vielzahl von über 300 verschiedenen Prozessoren zur Verfügung. Dadurch werden in der Regel alle gängigen Anforderungen abgedeckt.

Die Ausnahmen bestätigen allerdings die Regel und aus diesem Grund gibt es immer wieder Kundenanfragen zur Entwicklung eigener Prozessoren. Dass dies keine Raketentechnik ist, werde ich im Folgenden zeigen.

Brauche ich das wirklich?

Einen eigenen Prozessor zu entwickeln, macht immer dann Sinn, wenn ich beispielsweise spezifische, unternehmenseigene Anforderungen habe. Das können proprietäre Dateiformate oder Protokolle sein bzw. bereits existierende Anwendungen, die an NiFi angebunden werden sollen. Oftmals gibt es auch bereits Java-Pakete, die bestimmte Formate verarbeiten können oder Funktionen bereitstellen. In diesen Fällen kann es ebenso sinnvoll sein, einen eigenen Prozessor zu entwickeln und die Funktionalität dort zu integrieren.

Wir sehen, es gibt einige gute Gründe, die für einen eigenen Prozessor sprechen.

Aller Anfang ist schwer? Mit Nichten!

Wurde die Entscheidung getroffen einen eigenen Prozessor zu entwickeln, steht man oft vor der nächsten Frage: Wo und wie fange ich damit an?

Nachdem wir eine Java-Entwicklungsumgebung eingerichtet haben, können wir direkt mit der Entwicklung beginnen. Hierbei müssen wir aber nicht von Grund auf beginnen, denn stattdessen bietet uns NiFi ein Maven Archetype, das wir nutzen können. Maven Archetypes sind Vorlagen, die die Struktur und Konfiguration eines Maven-Projektes definieren. Dadurch können Entwickler schnell ein neues Projekt erstellen, ohne selbst eine neue Projektstruktur erstellen zu müssen. Stattdessen können wir einfach einen passenden Archetype auswählen, dass auf die Anforderungen zugeschnitten ist und Maven erstellt automatisch das neue Projekt mit der vorgegebenen Struktur und Konfiguration.

Für einen NiFi-Prozessor benötigen wir das „nifi-processor-bundle-archetype“ Template. Möchten wir einen Controller-Service erstellen, lautet die entsprechende Vorlage „nifi-service-bundle-archetype“.

Nach der Auswahl des Archetypes für Prozessoren, müssen wir sechs Properties angeben:

• groupId – Die Maven groupId des Bundles.
• artifactId – Die Maven artifactId des Bundles. Meist nifi-NAME-bundle ➔ NAME ist dabei der Name des Prozessors.
• version – Die Maven-Version. Achtung: Für den späteren „Build“ darf die Version das Wort „snapshot“ nicht beinhalten.
• artifactBaseName – Sollte denselben Wert, wie die artifactId haben.
• package – Der Java Package Name des neuen Prozessors

Sind alle Werte von uns ausgefüllt, übernimmt Maven die nächsten Schritte und erstellt uns ein entsprechendes Projekt.

Das Projekt sieht wie folgt aus:

.
├── nifi-nifi-blog-bundle-nar/
│   ├── pom.xml
│   └── target/
│       ├── classes
│       └── test-classes
├── nifi-nifi-blog-bundle-processors/
│   ├── pom.xml
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/
│   │   │   │   └── blog/
│   │   │   │       └── MyProcessor.java
│   │   │   └── resources/
│   │   │       └── META-INF/
│   │   │           └── services/
│   │   │               └── org.apache.nifi.processor.Processor
│   │   └── test/
│   │       └── java/
│   │           └── blog/
│   │               └── MyProcessorTest.java
│   └── target/
│       ├── classes/
│       │   ├── META-INF/
│       │   │   └── services/
│       │   │       └── org.apache.nifi.processor.Processor
│       │   └── blog/
│       │       └── MyProcessor.class
│       └── test-classes/
│           └── blog/
│               └── MyProcessorTest.class
└── pom.xml
 

Maven hat durch unseren Input die komplette Struktur, mit allen notwendigen Klassen und Konfigurationen erstellt. Wir können nun die Logik unseres Prozessors in der Klasse „MyProcessorTest.java“ implementieren.

Maven, Tests und mehr.

Wir können jetzt die vorhandenen Pakete, Funktionen und Klassen in unseren Prozessor einfügen. Natürlich sind wir ebenfalls in der Lage weitere eigene Prozessor-Properties mit verschiedenen Eigenschaften hinzufügen.

Alle Möglichkeiten und Details lassen sich detailliert und mit Beispielen im NiFi Developers Guide nachlesen.

Über die im Java-Umfeld bekannten Maven-Kommandos, wie mvn install wird aus der Java-Datei die nötige NAR-Datei gebaut, die wir in NiFi einbinden können. Die NAR-Datei befindet sich im NAR-Ordner und dort im Subverzeichnis target. Wie eigene NAR-Dateien, bzw. Prozessoren einer NiFi-Instanz hinzugefügt werden können, haben wir in einem früheren Blogartikel ausführlich erläutert.

Einem erfolgreichen mvn install-Befehl stehen nun nur noch die Unittests im Wege. Die Maven-Projekteinstellungen zwingen Sie als Entwickler dazu, mindestens einen erfolgreichen Test zu implementieren.

Es ist dringend zu empfehlen alle nötigen Edge-Cases und Fehlerfälle in den Tests abzufangen, sodass in der späteren Anwendung in NiFi keine unvorhergesehenen Fehler entstehen.

Das Projekt bietet dazu ein umfangreiches Testframework. Es lassen sich beliebig viele Tests definieren. Dafür werden sogenannte Mock-FlowFiles erzeugt, denen Attribute und Content zugewiesen werden können. Auch lassen sich Controller-Services einbinden und das Verhalten an verschiedenen Prozessor-Relationships kann simuliert werden. Dies geschieht im test-Ordner in der MyProcessorTest.java – Datei.

BUILD SUCCESS

In Summe kann die Entwicklung eines eigenen Prozessors in Apache NiFi eine wertvolle Ergänzung für komplexe DataFlows sein.

Durch die Verwendung von Maven Archetypes können Entwickler schnell und einfach einen eigenen Prozessor erstellen, der speziell auf ihre Anforderungen zugeschnitten ist. Es ist jedoch wichtig sicherzustellen, dass der selbst entwickelte Prozessor gut dokumentiert, getestet und in Übereinstimmung mit den Best Practices von Apache NiFi entwickelt wird.

Wenn diese Richtlinien beachtet werden, kann die Entwicklung eines eigenen Prozessors in Apache NiFi dazu beitragen, die Effizienz und Genauigkeit der Datenverarbeitung zu verbessern und die Anforderungen spezifischer Workflows und Datenformate zu erfüllen.

Wenn Sie weitere Fragen zu Apache NiFi haben, sprechen Sie uns gerne an oder nutzen Sie den Kommentarbereich dieses Blogbeitrags!

Seminarempfehlungen