Seminar Apache NiFi – Java-Erweiterungen: Prozessoren und Controller Services

Eigene Komponenten benötigen ein genaues Verständnis von NiFi-Lebenszyklus, FlowFile-Semantik und Nebenläufigkeit. Der Weg führt vom minimalen Processor bis zur getesteten Erweiterung mit Controller Service.

Inhaltsübersicht

• Einordnung und Zielsetzung
• Zielgruppe und Voraussetzungen
• Lernziele
• Projekt- und NAR-Struktur
• Processor-Lebenszyklus
• Properties und Validierung
• ProcessSession und Streaming
• Controller Services
• State und Nebenläufigkeit
• Fehler, Logging und Provenance
• Tests und Deployment
• Praxisübungen
• Anwendungsszenarien

Einordnung und Zielsetzung

Vier Tage sind notwendig, weil Implementierung, Streaming, Controller-Service-Design, State, Nebenläufigkeit, Tests und NAR-Deployment jeweils programmiert und in der Laufzeit validiert werden.

Zielgruppe

Java- und Integrationsentwicklung, Plattform-Engineering und technische Architektur.

Voraussetzungen

Sichere Java-Kenntnisse, Maven-Grundlagen, Unit-Test-Erfahrung und NiFi-Anwenderkenntnisse.

Lernziele

• NAR-Projekt aufbauen.
• Processor-Lebenszyklus implementieren.
• FlowFiles streamingfähig verarbeiten.
• Controller Services entwickeln.
• State und Nebenläufigkeit beherrschen.
• Komponenten testen, paketieren und deployen.

Seminarinhalte

1. Projekt- und NAR-Struktur

Erweiterungen werden als Maven-Module mit klaren API- und NAR-Abhängigkeiten aufgebaut.

1. Schritt 1: JDK und Maven prüfen.
2. Schritt 2: Projektgrundgerüst erzeugen.
3. Schritt 3: Processor- und NAR-Modul trennen.
4. Schritt 4: Scopes konfigurieren.
5. Schritt 5: Erstes NAR bauen und kontrollieren.

2. Processor-Lebenszyklus

Annotationen, Descriptoren und Lifecycle-Methoden bestimmen Darstellung und Verhalten.

1. Schritt 1: Processor-Klasse anlegen.
2. Schritt 2: Properties initialisieren.
3. Schritt 3: Relationships definieren.
4. Schritt 4: Scheduling-Hinweise festlegen.
5. Schritt 5: Komponente in NiFi verifizieren.

3. Properties und Validierung

Ungültige Konfiguration wird vor dem Start erkannt.

1. Schritt 1: Pflicht- und optionale Properties definieren.
2. Schritt 2: Sensitive Werte kennzeichnen.
3. Schritt 3: Validatoren einsetzen.
4. Schritt 4: Expression-Language-Kontext festlegen.
5. Schritt 5: Positiv- und Negativfälle testen.

4. ProcessSession und Streaming

ProcessSession bildet die transaktionale Grenze für Inhalt, Attribute und Transfer.

1. Schritt 1: FlowFile aus der Session beziehen.
2. Schritt 2: Inhalt streamingfähig lesen und schreiben.
3. Schritt 3: Attribute atomar ergänzen.
4. Schritt 4: FlowFile einer Relationship zuordnen.
5. Schritt 5: Ausnahmen ohne Ressourcenleck behandeln.

5. Controller Services

Gemeinsame Clients und Verbindungen werden hinter einer stabilen Schnittstelle gekapselt.

1. Schritt 1: Service-API definieren.
2. Schritt 2: Implementierung mit Properties erstellen.
3. Schritt 3: Ressource bei Aktivierung aufbauen.
4. Schritt 4: Processor-Abhängigkeit deklarieren.
5. Schritt 5: Mehrere Processor-Instanzen testen.

6. State und Nebenläufigkeit

Komponenten bleiben bei paralleler Ausführung und Neustart deterministisch.

1. Schritt 1: Lokalen oder clusterweiten State wählen.
2. Schritt 2: State atomar aktualisieren.
3. Schritt 3: Thread-Sicherheit bewerten.
4. Schritt 4: Ressourcen im Lifecycle verwalten.
5. Schritt 5: Mehrere Concurrent Tasks testen.

7. Fehler, Logging und Provenance

Fehlerpfade sind diagnostizierbar und geben keine sensitiven Inhalte preis.

1. Schritt 1: Datenfehler von Systemfehler trennen.
2. Schritt 2: Log-Level gezielt wählen.
3. Schritt 3: Fehlerattribute standardisieren.
4. Schritt 4: Provenance für externe Übertragung ergänzen.
5. Schritt 5: Yield und Penalty begründet einsetzen.

8. Tests und Deployment

Automatisierte Tests und kontrollierte Paketierung sichern die Freigabe.

1. Schritt 1: TestRunner erstellen.
2. Schritt 2: Konfiguration und Relationships prüfen.
3. Schritt 3: Inhalt und Attribute verifizieren.
4. Schritt 4: NAR versioniert bauen.
5. Schritt 5: Deployment, Smoke-Test und Rollback durchführen.

Praxisübungen

1. Processor mit Properties und Relationships entwickeln.
2. FlowFile streamingfähig transformieren.
3. Controller Service implementieren.
4. State und Nebenläufigkeit testen.
5. NAR bauen und in NiFi abnehmen.

Anwendungsszenarien

• Proprietäre Protokolladapter
• Wiederverwendbare Plattformservices
• Fachliche Spezialvalidierung
• Integration eigener Bibliotheken