Automatisierung von NiFi mithilfe der CLI

Apache NiFi ist durch seine einfache Art und Weise, Daten zwischen Systemen zu transportieren, bekannt und gewinnt immer mehr an Beliebtheit. Dank der webbasierten Benutzeroberfläche wird dem User mit ein paar Klicks und einfachem Drag-and-Drop die Erstellung von NiFi-Flows ermöglicht. Doch gibt es eine Alternative zum altbewährten User-Interface und lassen sich die erstellten NiFi-Flows auch automatisieren? Genau diesen Fragen werden in diesem Blogartikel behandelt.

Command-Line-Interface (CLI) aus dem NiFi-Toolkit

In der Tat gibt es eine Alternative zum User-Interface, welche einige Funktionalitäten ersetzen kann. Hierbei handelt es sich um das Command-Line-Interface (CLI) aus dem NiFi-Toolkit. Bei dem NiFi-Toolkit handelt es sich um eine Sammlung von Programmen, die das Arbeiten mit Apache NiFi vereinfachen sollen. Die CLI ermöglicht die Interaktion mit NiFi- und Registry-Instanzen. Dabei können Kommandos abgegeben werden, um beispielsweise eine Liste aller vorhandenen Prozessgruppen zu erhalten, oder um eine Prozessgruppe zu starten. Damit kann der User seine NiFi-Flows automatisieren. Die CLI stellt eine Reihe vordefinierter Kommandos sowohl für NiFi als auch für die NiFi-Registry zur Verfügung.

Die Nifi-Registry, das Zusatz-Tool von NiFi, ermöglicht zum einen die Versionierung von Prozessgruppen, sodass vorhandene NiFi-Flows auf die neuste Version aktualisiert werden können. Zum anderen stellt die NiFi-Registry eine zentrale Anlaufstelle für die Speicherung und Verwaltung von NiFi-Flows über mehrere NiFi-Instanzen hinweg und realisiert damit die Bereitstellung der Daten zwischen mehreren Systemen. So können die NiFi-Flows, wie in der Abbildung 1 zu sehen ist, für Entwicklungs-, Test- und Produktionsumgebung zentral gespeichert werden und die erstellten NiFi-Flows problemlos übertragen und weitergegeben werden.

In diesem Blogartikel wird die Interaktion zwischen NiFi und der NiFi-Registry sowie der CLI demonstriert. Dies wird anhand folgendem NiFi-Flow (siehe Abbildung 2) dargestellt, welcher Daten aus einer REST-API liest, diese zerlegt und anschließend per E-Mail versendet. Aus diesem NiFi-Flow wird eine Prozessgruppe *ORDIX Blog* erstellt und es wird im Laufe dieses Artikels beschrieben, wie die Prozessgruppe versioniert wird und über CLI aufgerufen werden kann.

Anbindung der NiFi-Registry

Um die Verbindung mit der NiFi-Registry herzustellen, muss, wie in Abbildung 3 zu sehen ist, ein neuer Eintrag in den Controller Settings von NiFi erstellt werden. Hierzu muss im Tab „Registry Clients" die URL der NiFi-Registry angegeben werden. Somit kann NiFi mit der NiFi-Registry kommunizieren. Sollte jedes System (zum Beispiel DEV, TUD und PROD) eine eigene Registry haben, können hier mehrere Einträge mit der jeweiligen URL erstellt werden.

Erstellung eines Buckets in der NiFi-Registry

Nachdem die Vorbereitungen abgeschlossen sind, muss entweder über die CLI oder direkt im User-Interface der NiFi-Registry ein Bucket erstellt werden. Ein Bucket wird in der Registry benötigt, um die versionierten NiFi-Flows zu speichern und zu organisieren. Hierbei können mehrere Buckets erstellt werden und somit eine Kategorisierung ermöglichen. Zum Beispiel können mehrere Buckets nach verschiedenen Geschäftseinheiten oder Systemen organisiert werden und enthalten somit die zugehörigen NiFi-Flows.

Die im Bucket enthaltenen NiFi-Flows haben einen Namen, eine Beschreibung und mindestens ein Snapshot bzw. eine Version. Jede Version hat dabei Metadaten, bestehend aus Versionsnummer, einer Commit-Nachricht, einem Autor und einem Commit-Datum.

Versionierung starten

Nachdem mindestens ein Bucket erstellt wurde, kann nun die Versionierung für die Prozessgruppe gestartet werden.

Nun kann das gewünschte Bucket ausgewählt werden, welches zuvor in der NiFi-Registry erstellt wurde. Hierbei können zusätzliche Informationen zum NiFi-Flow und zur aktuellen Version angegeben werden.

Durch das Klicken auf „SAVE" werden diese Informationen an die Registry übertragen und es wird ein Eintrag im ausgewählten Registry erstellt.

Somit sind im NiFi-Registry alle relevanten und definierten Informationen zur jeweiligen Version des NiFi-Flows sichtbar. Sollen neue Änderungen am NiFi-Flow getätigt werden, können diese problemlos wieder in das Registry commited werden und somit eine neue Version erstellten werden.

Kommandos über die CLI

Das Toolkit wird bei der Installation von NiFi bereits mitgeliefert. Dementsprechend muss die CLI lediglich gestartet werden. Hierbei braucht es keine zusätzlichen Konfiguartions- oder Installationsschritte.

bash-4.4$ ./bin/cli.sh 

           _     ___  _ 

 Apache   (_)  .' ..](_)   , 

 _ .--.   __  _| |_  __    )\ 

[ `.-. | [  |'-| |-'[  |  /  \ 

|  | | |  | |  | |   | | '    ' 

[___||__][___][___] [___]',  ,' 

                           `' 

          CLI v1.13.2  

Type 'help' to see a list of available commands, use tab to auto-complete. 

Session loaded from /home/nifi/.nifi-cli.config 

#>          

Mithilfe der CLI können vordefinierte Kommandos, beispielsweise für das Starten/Stoppen von Prozessgruppen oder aber auch für das Setzen von Variablen, verwendet werden. Hierfür liefert die CLI sowohl für NiFi als auch für das NiFi-Registry eine ganze Reihe von Kommandos. So können mithilfe des Kommandos regsitry list-buckets alle erstellten Buckets aufgelistet werden:

#> registry list-buckets  

#      Name            Id                                      Description    

-     -----------      --------------------------------------  ----------- 

1      Entwicklung     04281e34-96e0-416f-9006-31ba7d07b177     (empty) 

2      MyBucket        69a6d761-40d7-40bf-bdcb-8f32225c368c     (empty) 

3      ORDIX Blog      9e3cf6ca-2dea-4d89-9f4f-7b6bce52d3d9     (empty) 

4      Produktion      1b5b4544-d02e-438c-b93a-308d4f0bfd4a     (empty)  

Zu sehen ist, dass jedes Bucket eine eigene ID zugewiesen bekommt, auf die später verwiesen werden kann. Somit können die in den Buckets enthaltenen Flows angezeigt werden. Hierfür kann das Kommando registry list-flows verwendet und dabei auf die ID des jeweiligen Buckets referenziert werden.

referenziert werden. 

#> registry list-flows -b 9e3cf6ca-2dea-4d89-9f4f-7b6bce52d3d9 

#   Name           	 Id                                   Description 

-   -------------     -----------------------------        ---------------------- 

1   FirstDataflow   59cb83cc-5b0a-4b24-abed-f1d9f48e5c0e   Mit diesem Dataflow soll.. 

Zusätzlich kann ermittelt werden, welche Versionen eines Flows gespeichert sind. Auch hier muss die ID des Flows angegeben werden.

#> registry list-flow-versions -f 59cb83cc-5b0a-4b24-abed-f1d9f48e5c0e 

Ver   Date                        Author      Message 

---   --------------------------  ---------   ---------------------------------------- 

1     Wed, Jul 14 2021 08:13 GMT   anonymous   Erste Version: InvokoHTTP - …  

Als nächstes soll der NiFi-Flow in eine andere Umgebung migriert werden. Dafür wurden bereits alle benötigten Informationen wie die Bucket-ID und die Flow-Version ermittelt. Hierfür muss der Flow exportiert und in das gewünschte Bucket bzw. die gewünschte Umgebung wieder importiert werden.

Für den Export wird ein Pfad angeben, in dem der Flow gespeichert werden soll.

#> registry export-flow-version -f 59cb83cc-5b0a-4b24-abed-f1d9f48e5c0e --outputFile /tmp/FirstDataflow.json --outputType json  

Der Bucket „Produktion" ist aktuell leer. Hier wird nun ein Flow erstellt und der bereits exportierte Flow hinein importiert.

#> registry list-buckets 

  

#   Name             Id                                      Description    

-   -----------      ------------------------------------    ----------- 

1   Entwicklung  	 04281e34-96e0-416f-9006-31ba7d07b177    (empty) 

2   MyBucket     	 69a6d761-40d7-40bf-bdcb-8f32225c368c    (empty) 

3   ORDIX Blog   	 9e3cf6ca-2dea-4d89-9f4f-7b6bce52d3d9    (empty) 

4   Produktion   	 1b5b4544-d02e-438c-b93a-308d4f0bfd4a    (empty) 

  

#> registry list-flows -b 1b5b4544-d02e-438c-b93a-308d4f0bfd4a 

#> 

 

#> registry create-flow --bucketIdentifier 1b5b4544-d02e-438c-b93a-308d4f0bfd4a --flowName SecondDataFlow 

  

fb677b02-c2e3-45ea-86b8-f9197d51d880 

  

#> 

#> registry list-flows -b 1b5b4544-d02e-438c-b93a-308d4f0bfd4a 

  

#   Name             Id                                      Description 

-   --------------  ------------------------------------     ----------- 

1   SecondDataFlow      fb677b02-c2e3-45ea-86b8-f9197d51d880   (empty) 

  

#> 

#> registry import-flow-version --flowIdentifier fb677b02-c2e3-45ea-86b8-f9197d51d880 --input /tmp/FirstDataflow.json 

  

1 

#> 

#> 

#> registry list-flows -b 1b5b4544-d02e-438c-b93a-308d4f0bfd4a 

  

#   Name                Id                                       Description    

-   --------------      ------------------------------------     ----------- 

1   SecondDataFlow      fb677b02-c2e3-45ea-86b8-f9197d51d880   (empty) 

#> 

#> registry list-flow-versions -f fb677b02-c2e3-45ea-86b8-f9197d51d880 

  

Ver   Date                         Author      Message 

---   --------------------------   ---------   -------------------------------------- 

1     Mon, Jul 19 2021 08:18 GMT   anonymous   Erste Version: InvokoHTTP - ..  

Diese Änderungen sind nun auch im User Interface der NiFi Registry zu sehen.

Mit dem Kommando nifi pg-start kann nun die Prozessgruppe aus der CLI gestartet werden. Hierzu wird die Prozessgruppen-ID benötigt, die vorher mit dem Kommando nifi pg-list ermittelt werden kann.

Fazit

Dieses hier dargestellte Beispiel zeigt, wie die Interaktion mit NiFi, NiFi-Registry und CLI realisierbar ist. Somit können entwickelte NiFi-Flows problemlos zentral gespeichert werden, sodass andere Umgebungen (z.B. Produktion) Zugriff haben. Mithilfe der NiFi-Registry kann also die Speicherung sowie der Import/Export von Templates vermieden werden.

Die CLI bietet, ohne großen Aufwand, viele Möglichkeiten für die Interaktion mit NiFi und dem NiFi-Registry. So können Prozessgruppen gestartet und gestoppt werden oder aber auch NiFi-Flows auf die neuste Version gesetzt werden. Diese und viele weitere Kommandos der CLI bieten dem User die Möglichkeit, NiFi-Flows zu automatisieren. So können die CLI-Kommandos in ein Skript integriert und ausgeführt werden.