Construindo um processador Python usando Apache NiFi 2.0.0

[Antevisão da transmissão ao vivo] Os modelos grandes substituirão os programadores? "

O processador Python integrado na versão mais recente do Apache NiFi simplifica as tarefas de processamento de dados, aumenta a flexibilidade e acelera o desenvolvimento.

Traduzido de Apache NiFi 2.0.0: Construindo processadores Python , autor Robert Kimani.

Apache NiFi é uma plataforma poderosa dedicada ao gerenciamento de fluxo de dados , que oferece muitos recursos projetados para aumentar a eficiência e flexibilidade do processamento de dados. Sua interface de usuário baseada na Web oferece uma experiência perfeita para projetar, controlar e monitorar fluxos de dados.

NiFi suporta a construção de processadores e extensões personalizados, permitindo aos usuários adaptar a plataforma às suas necessidades específicas.

Com uma experiência de usuário multilocatário, o NiFi garante que vários usuários possam interagir com o sistema simultaneamente, cada um com seu próprio conjunto de direitos de acesso.

O manipulador Python fornece uma maneira poderosa de estender a funcionalidade do NiFi, permitindo que os usuários aproveitem um rico ecossistema de bibliotecas e ferramentas Python em seus fluxos de dados. Aqui, discutimos os benefícios de incorporar Python em fluxos de trabalho NiFi e exploramos casos de uso do mundo real onde os processadores Python podem simplificar tarefas de processamento de dados, aumentar a flexibilidade e acelerar o desenvolvimento.

Se você deseja integrar algoritmos de aprendizado de máquina, realizar transformações de dados personalizadas ou interagir com sistemas externos, construir um processador Python no Apache NiFi pode ajudá-lo a atender a essas necessidades de integração de dados.

Uma característica marcante do NiFi é sua natureza altamente configurável, permitindo aos usuários personalizar o roteamento de dados, a transformação e a lógica de mediação do sistema de acordo com seus requisitos específicos. NiFi ajuda os usuários a alcançar os resultados de processamento de dados que desejam, como priorizar a tolerância a falhas em vez da entrega garantida ou otimizar para baixa latência em vez de alto rendimento.

A priorização dinâmica permite ajustes em tempo real na prioridade dos dados em um fluxo, enquanto a capacidade de modificar fluxos em tempo de execução adiciona uma camada de flexibilidade para adaptação às necessidades em constante mudança. NiFi também incorpora um mecanismo de contrapressão para regular as taxas de fluxo de dados e evitar sobrecarga, garantindo uma operação suave e eficiente mesmo sob cargas de trabalho variadas.

NiFi foi projetado para suportar escala vertical e horizontal. Seja escalando para aproveitar todo o poder de uma única máquina ou usando um modelo de cluster líder zero, o NiFi pode se adaptar a tarefas de processamento de dados de qualquer tamanho.

A proveniência dos dados é outro recurso importante que permite aos usuários rastrear a jornada dos dados desde sua origem até seu destino final. Isso fornece informações valiosas para auditoria, solução de problemas e garantia da integridade dos dados durante todo o processo.

A segurança é fundamental no NiFi, que suporta SSL, SSH, HTTPS e conteúdo criptografado, entre outras medidas de segurança. Mecanismos de autenticação e autorização conectáveis e refinados baseados em funções garantem que o acesso aos fluxos de dados seja cuidadosamente controlado, permitindo que várias equipes gerenciem e compartilhem com segurança partes específicas do fluxo.

A filosofia de design do NiFi, inspirada em conceitos como programação baseada em fluxo e arquitetura orientada a eventos encenado , oferece várias vantagens atraentes:

Interface visual intuitiva para projetar e gerenciar fluxos de dados, melhorando a produtividade e a facilidade de uso.
Modelo de processamento assíncrono que suporta alto rendimento e buffer natural para acomodar cargas flutuantes.
O gerenciamento de simultaneidade integrado abstrai a complexidade da programação multithread.
Ênfase na reutilização e testabilidade de componentes, promovendo métodos de design modulares e robustos.
O suporte nativo para contrapressão e tratamento de erros garante robustez e confiabilidade em pipelines de processamento de dados.
Obtenha uma compreensão abrangente da dinâmica do fluxo de dados para monitoramento e solução de problemas eficazes.

Por que usar compilações Python no Apache NiFi?

Apache NiFi é uma ferramenta poderosa para ingestão, transformação e roteamento de dados. O processador Python no NiFi oferece uma maneira flexível de estender sua funcionalidade, especialmente para processamento de dados não estruturados ou integração com sistemas externos, como modelos de IA ou armazenamentos de vetores, como o banco de dados de vetores nativo da nuvem Milvus .

Ao lidar com os tipos de arquivos não estruturados que ferramentas como Cloudera Data Flow podem extrair, os processadores Python são essenciais para implementar lógica personalizada para analisar e manipular os dados. Por exemplo, você pode usar Python para extrair informações específicas de arquivos de texto, realizar análises de sentimentos em dados de texto ou pré-processar imagens antes de análises adicionais.

Por outro lado, os tipos de arquivos estruturados muitas vezes podem ser processados usando o processador integrado do NiFi sem a necessidade de código Python personalizado. NiFi fornece uma ampla gama de processadores para processar formatos de dados estruturados, como CSV, JSON, Avro, e para interagir com bancos de dados , APIs e outros sistemas corporativos.

Quando você precisa interagir com modelos de IA ou outros sistemas externos, como Milvus, o processador Python fornece uma maneira conveniente de integrar essa funcionalidade ao seu fluxo de dados NiFi. Para tarefas como processamento de texto para texto, texto para imagem ou texto para fala, você pode escrever código Python para interagir com o modelo ou serviço relevante e incorporar esse processamento em seu pipeline NiFi.

Python: uma nova era no NiFi 2.0.0

Apache NiFi 2.0.0 traz algumas melhorias importantes para a plataforma, especialmente em termos de integração Python e melhorias de desempenho. A capacidade de integrar perfeitamente scripts Python em fluxos de dados NiFi abre uma ampla gama de possibilidades para trabalhar com uma variedade de fontes de dados e aproveitar o poder da IA generativa.

Antes deste lançamento, embora fosse possível usar Python no NiFi, a flexibilidade pode ser limitada e a execução de scripts Python pode não ser tão simplificada quanto os usuários gostariam. No entanto, com a versão mais recente, a integração do Python foi bastante melhorada, permitindo uma execução mais contínua do código Python em pipelines NiFi.

Além disso, o suporte para JDK 21+ traz melhorias de desempenho que tornam o NiFi mais rápido e eficiente, especialmente ao lidar com tarefas multithread. Isto pode melhorar significativamente a escalabilidade e a capacidade de resposta dos fluxos de dados NiFi, especialmente ao lidar com grandes quantidades de dados ou tarefas de processamento complexas.

A introdução de recursos como grupos de processos como operações sem estado e um mecanismo de regras para assistência ao desenvolvimento aprimora ainda mais a funcionalidade e a usabilidade do NiFi, dando aos desenvolvedores mais flexibilidade e ferramentas para construir pipelines de fluxo de dados poderosos.

Um exemplo de processador: Watson SDK para modelo básico de IA

Este código Python define um processador NiFi chamado NiFi que interage com o serviço IBM WatsonX AI para gerar respostas com base em prompts de entrada. Observe que para NiFi 2.0.0, Python3.10+ é o requisito mínimo.

Vamos decompor o código e explicar as várias partes.

importar

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

A seguir estão as importações necessárias para o script:

json e re são módulos integrados do Python para processar dados JSON e expressões regulares, respectivamente.
FlowFileTransform e FlowFileTransformResult são classes do módulo customizado (nifiapi.flowfiletransform) relacionado ao processamento NiFi.
PropertyDescriptor, StandardValidators e ExpressionLanguageScope são classes de outro módulo customizado (nifiapi.properties) usado para definir propriedades do processador.

definição de classe

class CallWatsonXAI(FlowFileTransform):
    ...

Isso define uma classe chamada CallWatsonXAI, que estende a classe FlowFileTransform, que lida com a transformação de dados em NiFi.

Detalhes do processador

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'],
}

Defina detalhes do processador, como versão, descrição e tags. No entanto, observe que 2.0.0-M2 é a versão atual.

descritor de propriedade

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
)

Define os recursos que podem ser definidos para este processador. Neste caso existem PROMPT_TEXT, WATSONXAI_API_KEY e WATSONXAI_PROJECT_ID.

Construtor

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)

Inicialize a classe do processador e anexe o descritor de propriedade à lista de propriedades.

getPropertyDescriptors

def get_property_descriptors(self):
    return self.property_descriptors

Este método é exigido pelo processador NiFi para obter uma lista de propriedades.

método de transformação

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

Este método é responsável pelo processamento dos dados. O método recebe um objeto de contexto contendo informações sobre o ambiente de execução do processador e um objeto de arquivo stream contendo os dados a serem processados.

Integração IBM WatsonX

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

Importe o módulo de aprendizado de máquina 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()

Obtenha valores de entrada como texto de prompt, chave de API WatsonX e ID do projeto por meio das propriedades do processador 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)

Configure e chame o módulo IBM WatsonX para gerar uma resposta com base no texto do prompt.

Processamento de saída

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

Defina propriedades de saída para converter a resposta gerada no formato JSON.

Registro e devoluções

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

Grave o texto do prompt.

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

Retorna o resultado da conversão, indicando se a conversão foi bem-sucedida e fornecendo dados e propriedades de saída.

Processador Python pré-empacotado

O NiFi 2.0.0 vem com um conjunto diversificado de processadores Python que fornecem uma ampla gama de funcionalidades.

Interface VectorDB da Pinecone : Este processador facilita a interação com o Pinecone , um serviço de banco de dados vetorial, permitindo aos usuários consultar e armazenar dados de forma eficiente.
ChunkDocument : Este processador divide documentos grandes em pedaços menores, tornando-os adequados para processamento e armazenamento, especialmente em bancos de dados vetoriais onde podem ser aplicadas restrições de tamanho.
ParseDocument : Este processador parece ser muito versátil, capaz de analisar vários formatos de documentos como Markdown, PowerPoint, Google Docs e Excel , extraindo conteúdo de texto para posterior processamento ou armazenamento.
ConvertCSVtoExcel : Como o nome sugere, este processador converte dados do formato CSV para o formato Excel, proporcionando flexibilidade para troca e processamento de dados.
DetectObjectInImage : Este processador parece utilizar técnicas de aprendizagem profunda para detecção de objetos em imagens , permitindo aos usuários analisar dados de imagens e extrair informações valiosas.
PromptChatGPT : Este processador parece interessante – ele se integra ao ChatGPT ou modelos de IA de conversação semelhantes para permitir que os usuários gerem respostas ou participem de conversas com base em prompts.
PutChroma e QueryChroma : Esses processadores estão relacionados ao Chroma , um banco de dados de código aberto para grandes modelos de linguagem (LLMs). Eles facilitam o armazenamento de dados (PutChroma) e a recuperação/consulta (QueryChroma) em um banco de dados Chroma ou sistema similar.

para concluir

Priorizar a integração do Python no Apache NiFi é um marco importante na redução da lacuna entre engenheiros de dados e cientistas de dados , ao mesmo tempo em que expande a versatilidade e aplicabilidade da plataforma.

Ao permitir que os entusiastas do Python desenvolvam componentes NiFi perfeitamente em Python, o ciclo de desenvolvimento é simplificado, acelerando a implementação de pipelines de dados e fluxos de trabalho.

É um momento emocionante para os processadores Python em NiFi e contribuir para o ecossistema pode ser muito valioso. O desenvolvimento e o compartilhamento de processadores Python podem estender a funcionalidade do NiFi e resolver casos de uso específicos.

Para começar a usar o NiFi, os usuários podem consultar o Guia de início rápido para desenvolvimento e o Guia do desenvolvedor NiFi para obter informações mais abrangentes sobre como contribuir para o projeto.

Este artigo foi publicado pela primeira vez em Yunyunzhongsheng ( https://yylives.cc/ ), todos são bem-vindos para visitar.