Construire un processeur Python à l'aide d'Apache NiFi 2.0.0

[Aperçu de diffusion en direct] Les grands modèles remplaceront-ils les programmeurs ? "

Le processeur Python intégré à la dernière version d'Apache NiFi simplifie les tâches de traitement des données, augmente la flexibilité et accélère le développement.

Traduit d' Apache NiFi 2.0.0 : Création de processeurs Python , auteur Robert Kimani.

Apache NiFi est une plateforme puissante dédiée à la gestion des flux de données , qui offre de nombreuses fonctionnalités conçues pour augmenter l'efficacité et la flexibilité du traitement des données. Son interface utilisateur Web offre une expérience transparente pour la conception, le contrôle et la surveillance des flux de données.

NiFi prend en charge la création de processeurs et d'extensions personnalisés, permettant aux utilisateurs d'adapter la plate-forme à leurs besoins spécifiques.

Avec une expérience utilisateur multi-tenant, NiFi garantit que plusieurs utilisateurs peuvent interagir simultanément avec le système, chacun avec son propre ensemble de droits d'accès.

Le gestionnaire Python fournit un moyen puissant d'étendre les fonctionnalités de NiFi, permettant aux utilisateurs d'exploiter un riche écosystème de bibliothèques et d'outils Python dans leurs flux de données. Nous discutons ici des avantages de l'intégration de Python dans les flux de travail NiFi et explorons des cas d'utilisation réels dans lesquels les processeurs Python peuvent simplifier les tâches de traitement des données, augmenter la flexibilité et accélérer le développement.

Que vous souhaitiez intégrer des algorithmes d'apprentissage automatique, effectuer des transformations de données personnalisées ou interagir avec des systèmes externes, la création d'un processeur Python dans Apache NiFi peut vous aider à répondre à ces besoins d'intégration de données.

Une caractéristique remarquable de NiFi est sa nature hautement configurable, permettant aux utilisateurs d'adapter la logique de routage des données, de transformation et de médiation système à leurs besoins spécifiques. NiFi aide les utilisateurs à obtenir les résultats de traitement de données qu'ils souhaitent, par exemple en donnant la priorité à la tolérance aux pannes plutôt qu'à la livraison garantie, ou en optimisant une faible latence plutôt qu'un débit élevé.

La priorisation dynamique permet d'ajuster en temps réel la priorité des données dans un flux, tandis que la possibilité de modifier les flux au moment de l'exécution ajoute une couche de flexibilité pour s'adapter aux besoins changeants. NiFi intègre également un mécanisme de contre-pression pour réguler les débits de données et éviter les surcharges, garantissant ainsi un fonctionnement fluide et efficace même sous des charges de travail variables.

NiFi est conçu pour prendre en charge la mise à l'échelle verticale et horizontale. Qu'il s'agisse d'une mise à l'échelle pour exploiter toute la puissance d'une seule machine ou de l'utilisation d'un modèle de cluster sans leader, NiFi peut s'adapter aux tâches de traitement de données de toute taille.

La provenance des données est une autre fonctionnalité clé qui permet aux utilisateurs de suivre le parcours des données depuis leur origine jusqu'à leur destination finale. Cela fournit des informations précieuses pour l’audit, le dépannage et la garantie de l’intégrité des données tout au long du processus.

La sécurité est primordiale dans NiFi, qui prend en charge SSL, SSH, HTTPS et le contenu crypté, entre autres mesures de sécurité. Des mécanismes d'authentification et d'autorisation enfichables et précis basés sur les rôles garantissent que l'accès aux flux de données est soigneusement contrôlé, permettant à plusieurs équipes de gérer et de partager en toute sécurité des parties spécifiques du flux.

La philosophie de conception de NiFi, inspirée de concepts tels que la programmation basée sur les flux et l'architecture événementielle par étapes , offre plusieurs avantages convaincants :

Interface visuelle intuitive pour concevoir et gérer les flux de données, améliorant la productivité et la facilité d'utilisation.
Modèle de traitement asynchrone qui prend en charge un débit élevé et une mise en mémoire tampon naturelle pour s'adapter aux charges fluctuantes.
La gestion intégrée de la concurrence fait abstraction de la complexité de la programmation multithread.
Accent mis sur la réutilisabilité et la testabilité des composants, en promouvant des méthodes de conception modulaires et robustes.
La prise en charge native de la contre-pression et de la gestion des erreurs garantit la robustesse et la fiabilité des pipelines de traitement de données.
Obtenez une compréhension complète de la dynamique des flux de données pour une surveillance et un dépannage efficaces.

Pourquoi utiliser les builds Python dans Apache NiFi ?

Apache NiFi est un outil puissant pour l'ingestion, la transformation et le routage des données. Le processeur Python de NiFi offre un moyen flexible d'étendre ses fonctionnalités, en particulier pour le traitement de données non structurées ou l'intégration avec des systèmes externes tels que des modèles d'IA ou des magasins de vecteurs comme la base de données vectorielles cloud native Milvus .

Lorsqu'il s'agit de types de fichiers non structurés que des outils tels que Cloudera Data Flow peuvent extraire, les processeurs Python sont essentiels pour implémenter une logique personnalisée pour analyser et manipuler les données. Par exemple, vous pouvez utiliser Python pour extraire des informations spécifiques à partir de fichiers texte, effectuer une analyse des sentiments sur des données textuelles ou prétraiter des images avant une analyse plus approfondie.

D'un autre côté, les types de fichiers structurés peuvent souvent être traités à l'aide du processeur intégré de NiFi sans avoir besoin de code Python personnalisé. NiFi fournit une large gamme de processeurs pour traiter les formats de données structurés tels que CSV, JSON, Avro et pour interagir avec les bases de données , les API et d'autres systèmes d'entreprise.

Lorsque vous devez interagir avec des modèles d'IA ou d'autres systèmes externes tels que Milvus, le processeur Python constitue un moyen pratique d'intégrer cette fonctionnalité dans votre flux de données NiFi. Pour les tâches telles que le traitement texte-texte, texte-image ou synthèse vocale, vous pouvez écrire du code Python pour interagir avec le modèle ou le service concerné et intégrer ce traitement dans votre pipeline NiFi.

Python : une nouvelle ère dans NiFi 2.0.0

Apache NiFi 2.0.0 apporte des améliorations majeures à la plateforme, notamment en termes d'intégration Python et d'amélioration des performances. La possibilité d'intégrer de manière transparente des scripts Python dans les flux de données NiFi ouvre un large éventail de possibilités pour travailler avec une variété de sources de données et tirer parti de la puissance de l'IA générative.

Avant cette version, même s'il était possible d'utiliser Python dans NiFi, la flexibilité pouvait être limitée et l'exécution de scripts Python pouvait ne pas être aussi rationalisée que les utilisateurs le souhaiteraient. Cependant, avec la dernière version, l'intégration de Python a été considérablement améliorée, permettant une exécution plus transparente du code Python dans les pipelines NiFi.

De plus, la prise en charge du JDK 21+ apporte des améliorations de performances qui rendent NiFi plus rapide et plus efficace, en particulier lors de la gestion de tâches multithread. Cela peut améliorer considérablement l'évolutivité et la réactivité des flux de données NiFi, en particulier lorsqu'il s'agit de grandes quantités de données ou de tâches de traitement complexes.

L'introduction de fonctionnalités telles que des groupes de processus comme opérations sans état et un moteur de règles pour l'aide au développement améliore encore la fonctionnalité et la convivialité de NiFi, offrant aux développeurs plus de flexibilité et d'outils pour créer de puissants pipelines de flux de données.

Un exemple de processeur : SDK Watson vers un modèle d'IA de base

Ce code Python définit un processeur NiFi appelé NiFi qui interagit avec le service IBM WatsonX AI pour générer des réponses basées sur des invites de saisie. Veuillez noter que pour NiFi 2.0.0, Python3.10+ est la configuration minimale requise.

Décomposons le code et expliquons les différentes parties.

importer

import json
import re
from nifiapi.flowfiletransform import FlowFileTransform, FlowFileTransformResult
from nifiapi.properties import PropertyDescriptor, StandardValidators, ExpressionLanguageScope

Voici les importations nécessaires pour le script :

json et re sont les modules intégrés de Python pour traiter respectivement les données JSON et les expressions régulières.
FlowFileTransform et FlowFileTransformResult sont des classes du module personnalisé (nifiapi.flowfiletransform) lié au traitement NiFi.
PropertyDescriptor, StandardValidators et ExpressionLanguageScope sont des classes d'un autre module personnalisé (nifiapi.properties) utilisées pour définir les propriétés du processeur.

définition de classe

class CallWatsonXAI(FlowFileTransform):
    ...

Cela définit une classe appelée CallWatsonXAI, qui étend la classe FlowFileTransform, qui gère la transformation des données dans NiFi.

Détails du processeur

processor_details = {
    'name': 'Call WatsonX AI',
    'version': '2.0.0-M2',
    'description': 'Calls IBM WatsonX AI service to generate responses based on input prompts.',
    'tags': ['watsonx', 'ai', 'response', 'generation'],
}

Définissez les détails du processeur tels que la version, la description et les balises. Veuillez cependant noter que la version 2.0.0-M2 est la version actuelle.

descripteur de propriété

PROMPT_TEXT = PropertyDescriptor(
    name="Prompt Text",
    description="Specifies whether or not the text (including full prompt with 
context) to send",
    required=True,
    validators=[StandardValidators.NON_EMPTY_VALIDATOR],
    
expression_language_scope=ExpressionLanguageScope.FLOWFILE_ATTRIBU
TES
)

Définit les fonctionnalités qui peuvent être définies pour ce processeur. Dans ce cas, il y a PROMPT_TEXT, WATSONXAI_API_KEY et WATSONXAI_PROJECT_ID.

Constructeur

def __init__(self, **kwargs):
    super().__init__()
    self.property_descriptors.append(self.PROMPT_TEXT)
    self.property_descriptors.append(self.WATSONXAI_API_KEY)
    self.property_descriptors.append(self.WATSONXAI_PROJECT_ID)

Initialisez la classe de processeur et ajoutez le descripteur de propriété à la liste des propriétés.

getPropertyDescriptors Description

def get_property_descriptors(self):
    return self.property_descriptors

Cette méthode est requise par le processeur NiFi pour obtenir une liste de propriétés.

méthode de transformation

def transform(self, context, flowfile):
    ...

Cette méthode est responsable du traitement des données. Le procédé reçoit un objet contextuel contenant des informations sur l'environnement d'exécution du processeur et un objet fichier de flux contenant les données à traiter.

Intégration IBM WatsonX

from ibm_watson_machine_learning.foundation_models.utils.enums import 
ModelTypes
from ibm_watson_machine_learning.foundation_models import Model

Importez le module d'apprentissage automatique IBM Watson.

prompt_text = 
context.getProperty(self.PROMPT_TEXT).evaluateAttributeExpressions(flowfil
e).getValue()
watsonx_api_key = 
context.getProperty(self.WATSONXAI_API_KEY).evaluateAttributeExpressions(
flowfile).getValue()
project_id = 
context.getProperty(self.WATSONXAI_PROJECT_ID).evaluateAttributeExpres
sions(flowfile).getValue()

Obtenez des valeurs d'entrée telles que le texte d'invite, la clé API WatsonX et l'ID de projet via les propriétés du processeur NiFi.

model_id = ModelTypes.LLAMA_2_70B_CHAT
gen_parms = None
project_id = project_id
space_id = None
verify = False

model = Model(model_id, my_credentials, gen_parms, project_id, space_id, verify)
gen_parms_override = None
generated_response = model.generate(prompt_text, gen_parms_override)

Configurez et appelez le module IBM WatsonX pour générer une réponse basée sur le texte de l'invite.

Traitement de sortie

attributes = {"mime.type": "application/json"}
output_contents = json.dumps(generated_response)

Définissez les propriétés de sortie pour convertir la réponse générée au format JSON.

Journalisation et retours

self.logger.debug(f"Prompt: {prompt_text}")

Enregistrez le texte de l'invite.

return FlowFileTransformResult(relationship="success", 
contents=output_contents, attributes=attributes)

Renvoie le résultat de la conversion, indiquant si la conversion a réussi et fournissant les données et propriétés de sortie.

Processeur Python préemballé

NiFi 2.0.0 est livré avec un ensemble diversifié de processeurs Python offrant un large éventail de fonctionnalités.

Interface VectorDB de Pinecone : Ce processeur facilite l'interaction avec Pinecone , un service de base de données vectorielle, permettant aux utilisateurs d'interroger et de stocker efficacement des données.
ChunkDocument : ce processeur divise les documents volumineux en morceaux plus petits, ce qui les rend adaptés au traitement et au stockage, en particulier dans les bases de données vectorielles où des restrictions de taille peuvent s'appliquer.
ParseDocument : Ce processeur semble être très polyvalent, capable d'analyser divers formats de documents tels que Markdown, PowerPoint, Google Docs et Excel , d'extraire le contenu du texte pour un traitement ou un stockage ultérieur.
ConvertCSVtoExcel : Comme son nom l'indique, ce processeur convertit les données du format CSV au format Excel, offrant une flexibilité pour l'échange et le traitement des données.
DetectObjectInImage : ce processeur semble utiliser des techniques d'apprentissage en profondeur pour la détection d'objets dans les images , permettant aux utilisateurs d'analyser les données d'image et d'extraire des informations précieuses.
PromptChatGPT : ce processeur semble intéressant : il s'intègre à ChatGPT ou à des modèles d'IA conversationnelle similaires pour permettre aux utilisateurs de générer des réponses ou de participer à des conversations basées sur des invites.
PutChroma et QueryChroma : Ces processeurs sont liés à Chroma , une base de données open source pour les grands modèles de langage (LLM). Ils facilitent le stockage des données (PutChroma) et la récupération/requête (QueryChroma) dans une base de données Chroma ou un système similaire.

en conclusion

Donner la priorité à l'intégration de Python dans Apache NiFi marque une étape importante dans la réduction du fossé entre les ingénieurs de données et les data scientists , tout en élargissant la polyvalence et l'applicabilité de la plateforme.

En permettant aux passionnés de Python de développer de manière transparente des composants NiFi en Python, le cycle de développement est simplifié, accélérant la mise en œuvre des pipelines de données et des flux de travail.

C'est une période passionnante pour les processeurs Python dans NiFi , et contribuer à l'écosystème peut être très précieux. Le développement et le partage de processeurs Python peuvent étendre les fonctionnalités de NiFi et résoudre des cas d'utilisation spécifiques.

Pour démarrer avec NiFi, les utilisateurs peuvent se référer au Guide de démarrage rapide pour le développement et au Guide du développeur NiFi pour des informations plus complètes sur la façon de contribuer au projet.

Cet article a été publié pour la première fois sur Yunyunzhongsheng ( https://yylives.cc/ ), tout le monde est invité à le visiter.