Configuration d'un laboratoire NiFi local avec exemples pratiques

Introduction

Apache NiFi est un outil puissant d'automatisation des flux de données, mais apprendre à l'utiliser de manière sûre et efficace nécessite un environnement pratique. Un laboratoire local vous offre un bac à sable pour tester des flux, expérimenter avec les processeurs et simuler des pannes sans risquer les données de production. Cet article vous guide dans la mise en place d'un laboratoire NiFi local avec des exemples concrets prêts à copier-coller. Vous apprendrez à installer NiFi, vérifier son état, construire et tester un flux de données simple, diagnostiquer les problèmes courants et récupérer après une panne. L'accent est mis sur la sécurité opérationnelle : observer avant de modifier, utiliser des variables génériques plutôt que des secrets, et documenter les étapes de vérification.

Ce guide s'adresse aux développeurs, consultants DevOps et équipes techniques de startups qui ont besoin d'un environnement local reproductible pour le développement et les tests avec NiFi. Il couvre la vérification de version, la configuration, les tests de flux, le diagnostic et la récupération, avec des commandes concrètes et les sorties attendues.

L'objectif est de vous fournir un flux de travail fiable qui rend les pannes visibles, protège les valeurs sensibles et limite les modifications à la ressource concernée. À la fin, vous serez capable d'exécuter NiFi localement, de créer un flux de données simple et de le dépanner comme un professionnel.

Inventaire de la version et de l'environnement

Avant de modifier quoi que ce soit, sachez exactement ce que vous exécutez. Exécutez ces vérifications en lecture seule pour inventorier votre environnement. Cette section couvre le composant concerné (NiFi), la plage de versions prises en charge, les prérequis, l'observation initiale et les commandes de vérification.

Vérifier les prérequis

NiFi nécessite Java 8 ou 11 (selon la version) et un système d'exploitation pris en charge. Exécutez cette commande pour vérifier votre version de Java :

java -version

Sortie attendue pour Java 11 :

openjdk version "11.0.20" 2023-07-18
OpenJDK Runtime Environment (build 11.0.20+8)
OpenJDK 64-Bit Server VM (build 11.0.20+8, mixed mode)

Si vous voyez une version inférieure à 8 ou supérieure à 11 pour les anciennes versions de NiFi, installez d'abord le JDK approprié.

Vérifiez également votre système d'exploitation et la mémoire disponible. NiFi fonctionne mieux avec au moins 4 Go de RAM alloués à la JVM. Utilisez free -h sous Linux ou systeminfo sous Windows pour vérifier la mémoire.

Identifier la version de NiFi

Si NiFi est déjà installé, identifiez sa version. En supposant que NiFi est installé dans /opt/nifi (Linux) ou C:\nifi (Windows), exécutez :

/opt/nifi/bin/nifi.sh status

Ou sous Windows :

C:\nifi\bin\nifi.bat status

Sortie attendue lorsqu'il est en cours d'exécution :

Apache NiFi is currently running, PID 20304

S'il n'est pas en cours d'exécution, démarrez-le puis vérifiez. Pour obtenir des informations détaillées sur la version, consultez le journal ou le répertoire lib. Une méthode fiable est :

/opt/nifi/bin/nifi.sh run > /tmp/nifi-console.log 2>&1 &

Vérifiez ensuite la bannière de démarrage dans /opt/nifi/logs/nifi-app.log. Sinon, une fois NiFi en cours d'exécution, accédez à l'interface utilisateur à https://localhost:8443/nifi et consultez la version sur la page de connexion. Pour des vérifications scriptées, utilisez :

curl -k https://localhost:8443/nifi-api/system-diagnostics | jq '.systemDiagnostics.aggregateSnapshot.versionInfo.niFiVersion'

Exemple de sortie attendue :

"1.20.0"

Capturer l'état actuel

Avant d'apporter des modifications, enregistrez l'état actuel, y compris les horodatages et la configuration.

date && /opt/nifi/bin/nifi.sh status && ls -l /opt/nifi/conf/nifi.properties

Cela vous donne un instantané à comparer après toute modification.

Plus petit changement justifié

Pour la configuration initiale, le plus petit changement est généralement l'installation de NiFi et son démarrage. Pour une instance existante, il peut s'agir d'activer un service spécifique. Définissez toujours le résultat attendu et le signal d'échec avant d'agir. Exemple : après le démarrage de NiFi, l'interface utilisateur doit être accessible sur le port 8443 et le nifi-app.log doit afficher NiFi has started.

Chemin de configuration sécurisé

Cette section montre comment installer NiFi localement et le configurer de manière minimale pour un laboratoire. Nous utiliserons la distribution tar sous Linux (adaptez sous Windows avec le zip). Les principes s'appliquent à tout environnement.

Installer NiFi

Tout d'abord, téléchargez la dernière version stable du binaire NiFi depuis le site officiel Apache. Remplacez 1.20.0 par la version souhaitée. Utilisez un espace réservé pour l'URL de téléchargement pour éviter de coder en dur un lien obsolète.

cd /tmp
curl -O https://archive.apache.org/dist/nifi/1.20.0/nifi-1.20.0-bin.tar.gz
tar -xzf nifi-1.20.0-bin.tar.gz
sudo mv nifi-1.20.0 /opt/nifi

Remarque : /opt/nifi est utilisé comme répertoire d'installation. Vous pouvez choisir un autre emplacement, mais mettez à jour toutes les commandes suivantes en conséquence.

Configurer les propriétés minimales

Modifiez le fichier de configuration principal conf/nifi.properties pour définir l'hôte et le port de l'interface web si vous devez modifier les valeurs par défaut. Pour un laboratoire local, les valeurs par défaut localhost et 8443 conviennent, mais assurez-vous que le port HTTPS n'est pas déjà utilisé.

Ouvrez le fichier :

vi /opt/nifi/conf/nifi.properties

Propriétés clés à examiner :

nifi.web.http.port=8080 (décommentez si vous voulez HTTP, mais HTTPS est la valeur par défaut)
nifi.web.https.port=8443
nifi.security.keystore=./conf/keystore.p12 et nifi.security.keystoreType=PKCS12 - pour le laboratoire, le certificat auto-signé par défaut est acceptable, mais vous pouvez en générer un nouveau si nécessaire.
nifi.sensitive.props.key=changeMe - c'est un espace réservé. Pour un laboratoire, vous pouvez le laisser tel quel, mais n'utilisez jamais une valeur par défaut en production.

Après modification, enregistrez et fermez.

Démarrer NiFi

Démarrez NiFi en arrière-plan et capturez la sortie de la console dans un fichier journal :

cd /opt/nifi/bin
./nifi.sh start

Vérifiez l'état et le journal :

./nifi.sh status
sleep 15
./nifi.sh status

Sortie d'état attendue :

Apache NiFi is currently running, PID 12345

S'il indique qu'il n'est pas en cours d'exécution, consultez /opt/nifi/logs/nifi-app.log pour les erreurs.

Vérifier l'interface utilisateur

Ouvrez un navigateur et accédez à https://localhost:8443/nifi. Vous devriez voir l'écran de connexion NiFi ou le canevas si l'authentification est désactivée. Pour un laboratoire, vous voudrez peut-être désactiver l'authentification pour plus de simplicité, mais soyez conscient des implications de sécurité. Pour désactiver, définissez nifi.security.user.login.identity.provider= sur vide et nifi.security.need.client.auth=false dans nifi.properties, puis redémarrez.

Après connexion, vous pouvez vérifier l'état de l'API :

curl -k https://localhost:8443/nifi-api/system-diagnostics | jq '.systemDiagnostics.aggregateSnapshot.totalNonHeap'

Cela renvoie un nombre JSON, confirmant que l'API est opérationnelle.

Rayon d'impact et récupération

Le changement ici consiste à ajouter une nouvelle instance NiFi. Le rayon d'impact est limité à la machine locale et aux ports choisis. En cas de problème, récupérez en arrêtant NiFi, en revenant sur nifi.properties et en redémarrant. Conservez une sauvegarde de la configuration d'origine :

cp /opt/nifi/conf/nifi.properties /opt/nifi/conf/nifi.properties.bak

Vérification et diagnostic

Maintenant que NiFi est en cours d'exécution, nous devons vérifier qu'il est opérationnel et qu'il peut traiter des données. Nous allons créer un flux de données simple à l'aide de l'interface utilisateur et le tester avec un outil en ligne de commande. Cette section fournit des commandes de vérification concrètes et les sorties attendues.

Créer un flux simple

Accédez à l'interface utilisateur de NiFi et faites glisser un processeur GenerateFlowFile sur le canevas. Configurez-le pour produire un petit fichier toutes les 5 secondes. Connectez-le ensuite à un processeur LogAttribute pour journaliser les attributs du flowfile. Enfin, ajoutez un processeur PutFile pour écrire le flowfile dans un répertoire local, par exemple /tmp/nifi-output.

Étapes :

GenerateFlowFile : planifiez l'exécution toutes les 5 secondes, définissez la taille du lot à 1.
LogAttribute : laissez les valeurs par défaut.
PutFile : définissez le répertoire sur /tmp/nifi-output, assurez-vous que le répertoire existe et que NiFi a la permission d'écriture.

Démarrez tous les processeurs.

Vérifier le flux de données avec la CLI

Vérifiez que les fichiers sont écrits. Ouvrez un terminal et exécutez :

ls -l /tmp/nifi-output

La sortie attendue montre des fichiers apparaissant :

-rw-r--r-- 1 user user  0 Aug 21 10:15 1234567890
-rw-r--r-- 1 user user  0 Aug 21 10:15 1234567895

Les noms de fichiers sont des horodatages. Si aucun fichier n'apparaît, vérifiez les bulletins des processeurs dans l'interface utilisateur ou consultez les journaux.

Vérifier l'état des processeurs via l'API

Utilisez l'API NiFi pour obtenir l'état des processeurs. Tout d'abord, obtenez l'ID du groupe de processus (racine).

curl -k https://localhost:8443/nifi-api/process-groups/root | jq '.processGroupFlow.id'

Listez ensuite les processeurs :

curl -k "https://localhost:8443/nifi-api/process-groups/{processGroupId}/processors" | jq '.processors[] | {name: .component.name, state: .component.state}'

Sortie attendue :

{
  "name": "GenerateFlowFile",
  "state": "RUNNING"
}
{
  "name": "LogAttribute",
  "state": "RUNNING"
}
{
  "name": "PutFile",
  "state": "RUNNING"
}

Requêtes de diagnostic

Pour diagnostiquer les problèmes, vérifiez le journal NiFi pour les erreurs :

grep -i 'error' /opt/nifi/logs/nifi-app.log | tail -20

Si un processeur ne fonctionne pas, son état peut afficher STOPPED ou INVALID. Utilisez l'API pour obtenir les bulletins :

curl -k "https://localhost:8443/nifi-api/processors/{processorId}/bulletins" | jq '.'

Cela renvoie tous les messages d'erreur qui aident à identifier le problème.

Modes de défaillance et récupération

Dans un laboratoire local, les pannes sont des occasions d'apprendre. Cette section couvre les modes de défaillance courants : conflits de ports, problèmes de permissions et erreurs de configuration. Nous montrerons comment détecter et récupérer de chacun.

Conflits de ports

Si le port 8443 est déjà utilisé, NiFi ne démarrera pas. Détectez en vérifiant le journal :

grep -i 'port.*in use' /opt/nifi/logs/nifi-app.log

Ou utilisez :

ss -tulpn | grep 8443

Récupération : arrêtez NiFi, changez le port HTTPS dans nifi.properties vers un port libre (par exemple 9443), redémarrez.

Problèmes de permissions

NiFi a besoin d'un accès en écriture à ses répertoires. Si vous voyez des erreurs comme Permission denied dans le journal, ajustez la propriété :

sudo chown -R $(whoami) /opt/nifi

Redémarrez ensuite NiFi.

Erreurs de configuration

Une faute de frappe dans nifi.properties peut empêcher le démarrage. Sauvegardez toujours le fichier avant de le modifier. Si le démarrage échoue, comparez avec la sauvegarde :

diff /opt/nifi/conf/nifi.properties /opt/nifi/conf/nifi.properties.bak

Corrigez la différence et redémarrez.

Tester la récupération avec un flux cassé

Cassez intentionnellement un flux pour pratiquer la récupération. Arrêtez le processeur PutFile et changez son répertoire vers un chemin inexistant. Démarrez le processeur et observez les flowfiles échoués. Corrigez ensuite le répertoire et redémarrez. Utilisez l'interface utilisateur ou l'API pour effacer l'état d'échec.

Exemple d'appel API pour démarrer/arrêter un processeur :

curl -k -X PUT "https://localhost:8443/nifi-api/processors/{processorId}" -H 'Content-Type: application/json' -d '{"revision":{"clientId":"test","version":0},"component":{"id":"{processorId}","state":"STOPPED"}}'

Vous devez fournir le numéro de révision correct, que vous pouvez obtenir par une requête GET sur le point de terminaison du processeur.

Liste de contrôle opérationnelle

Utilisez cette liste de contrôle pour vous assurer que votre laboratoire NiFi local est correctement configuré et que vous pouvez l'exploiter en toute sécurité.

Liste de contrôle avant configuration

Vérifiez la version de Java : java -version
Vérifiez l'espace disque disponible : df -h (assurez-vous d'avoir au moins 1 Go libre)
Confirmez qu'il n'y a pas de conflit de ports : ss -tulpn | grep -E '8080|8443'

Liste de contrôle de configuration

Téléchargez et extrayez l'archive NiFi.
Examinez et sauvegardez nifi.properties.
Démarrez NiFi avec ./nifi.sh start.
Vérifiez l'état : ./nifi.sh status (attendu : en cours d'exécution avec PID).
Accédez à l'interface utilisateur à https://localhost:8443/nifi.

Liste de contrôle de vérification

Créez un flux simple avec GenerateFlowFile -> LogAttribute -> PutFile.
Démarrez tous les processeurs.
Vérifiez le répertoire de sortie pour les fichiers générés : ls -l /tmp/nifi-output.
Interrogez l'API pour les états des processeurs : tous doivent être RUNNING.

Liste de contrôle des pannes et de la récupération

Simulez un conflit de port : arrêtez NiFi, démarrez un autre service sur 8443, essayez de démarrer NiFi, observez l'échec, corrigez le port.
Simulez un problème de permission : changez la propriété en root, essayez de démarrer, observez l'échec, corrigez la propriété.
Simulez une erreur de configuration : modifiez nifi.properties avec une valeur invalide, essayez de démarrer, observez l'échec, restaurez à partir de la sauvegarde.
Pour chaque cas, documentez la commande exacte et la sortie attendue pour la récupération.

Opérations quotidiennes

Surveillez les journaux pour les erreurs : tail -f /opt/nifi/logs/nifi-app.log
Vérifiez les diagnostics système : curl -k https://localhost:8443/nifi-api/system-diagnostics
Sauvegardez les configurations avant les modifications : cp /opt/nifi/conf/nifi.properties /opt/nifi/conf/nifi.properties.$(date +%Y%m%d)

Conclusion

Un laboratoire NiFi local est inestimable pour développer et tester des flux de données en toute sécurité. En suivant ce guide, vous avez configuré NiFi, vérifié son fonctionnement, créé un exemple pratique et appris à diagnostiquer et à récupérer des pannes courantes. Les principes clés sont : observer avant de modifier, utiliser des espaces réservés pour les valeurs sensibles, limiter les modifications à un seul composant et toujours définir les résultats attendus et les chemins de récupération.

Ensuite, choisissez une vérification à faible risque dans la liste de contrôle et exécutez-la. Enregistrez l'état actuel, exécutez la vérification, comparez la sortie avec le signal attendu et documentez le résultat. Ensuite, développez votre laboratoire en ajoutant d'autres processeurs et en expérimentant avec les modes de défaillance. N'oubliez pas qu'un flux de travail fiable rend les pannes visibles et protège votre environnement.