Apache Nifi & Registry com MinIO

Neste artigo vou trazer um cenário de ingestão de dados e inserção de multiplos arquivos no minIO utilização o Apache nifi com o nifi-registry, a idéia é consumir os dados de uma API pública e ir acompanhando via interface do nifi a ingestão no bucket do minIO em multiplos arquivos ;)

Apache NiFi e NiFi Registry formam uma dupla poderosa para o gerenciamento de fluxos de dados, oferecendo um controle de versão robusto e uma maneira fácil de compartilhar e implantar fluxos em diferentes ambientes. Vou te guiar, passo a passo, na montagem de um ambiente completo usando Docker Compose. Este tutorial vai abordar todos os detalhes de como configurar e entender o funcionamento de cada serviço, de uma forma acessível, mesmo para quem não é especialista em containers Docker.

Por que Apache NiFi e NiFi Registry?

O Apache NiFi é uma ferramenta visual para automação de fluxo de dados que permite mover e transformar dados de diferentes fontes com facilidade. Ele é usado por empresas para integrar dados de diversas aplicações, organizar ETL (extração, transformação e carregamento de dados), entre outras tarefas. O NiFi Registry complementa o NiFi, fornecendo versionamento dos fluxos de trabalho. Com ele, você pode manter um histórico das alterações feitas nos fluxos, compartilhar com a equipe e facilitar a automação entre ambientes como desenvolvimento, teste e produção.

Vamos usar o Docker Compose para criar um ambiente com NiFi, NiFi Registry e MinIO, um armazenamento S3 compatível que servirá para armazenar arquivos manipulados pelo NiFi. Vou te mostrar como cada serviço funciona e como configurá-los para um ambiente totalmente integrado.

Estrutura do Docker Compose

Aqui está a configuração completa do arquivo docker-compose.yml:

version: '3.8'

services:
  nifi:
    image: apache/nifi:latest
    ports:
      - "8080:8080"
    volumes:
      - nifi_data:/opt/nifi/nifi-current
    environment:
      - NIFI_WEB_HTTP_PORT=8080
      - NIFI_WEB_PROXY_HOST=http://localhost:8080
    networks:
      - nifi_network

  nifi-registry:
    image: apache/nifi-registry:latest
    ports:
      - "18080:18080"
    volumes:
      - nifi_registry_data:/opt/nifi-registry/nifi-registry-current
    networks:
      - nifi_network

  minio:
    image: minio/minio:latest
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      - MINIO_ROOT_USER=admin
      - MINIO_ROOT_PASSWORD=password
    command: server /data --address ":9000" --console-address ":9001"
    volumes:
      - minio_data:/data
    networks:
      - nifi_network

volumes:
  nifi_data:
  nifi_registry_data:
  minio_data:

networks:
  nifi_network:
    driver: bridge

Entendendo Cada Parte do Arquivo Docker Compose

1. Serviço NiFi

Imagem: Estamos usando a imagem oficial mais recente do Apache NiFi (apache/nifi:latest). Ela contém tudo que precisamos para rodar o NiFi.

Portas: O NiFi é exposto na porta 8080, o que significa que você pode acessá-lo em http://localhost:8080.

Volumes: Montamos o volume nifi_data para persistir os dados do NiFi, garantindo que os fluxos sejam mantidos mesmo que o contêiner seja reiniciado.

Variáveis de Ambiente:

**NIFI_WEB_HTTP_PORT: **Define a porta em que o NiFi será executado.

**NIFI_WEB_PROXY_HOST:** Define o host de proxy para acesso ao NiFi.

Rede: Utilizamos a rede nifi_network para permitir que o NiFi se comunique com outros serviços, como o NiFi Registry e o MinIO.

*Arquitetura do Apache NiFi
*
O Apache NiFi tem uma interface de usuário super intuitiva que permite arrastar e soltar componentes para criar fluxos de dados. Sua arquitetura é composta por três partes principais:

Web Server: Fornece a interface de usuário para gerenciar e monitorar os fluxos de dados.

Flow Controller: É o coração do NiFi, gerenciando a execução dos processos de dados definidos.

Provenance Repository: Armazena os metadados de cada evento dentro dos fluxos, facilitando o rastreamento de cada etapa.

Esses componentes trabalham em conjunto para garantir que os dados sejam processados de forma segura, eficiente e rastreável, permitindo que você monitore o comportamento dos fluxos em tempo real.

2. Serviço NiFi Registry

Imagem: Assim como o NiFi, usamos a imagem oficial mais recente do NiFi Registry.

Portas: O NiFi Registry é exposto na porta 18080, acessível em http://localhost:18080/nifi-registry.

Volumes: O volume nifi_registry_data é utilizado para persistir dados de versão dos fluxos.

Rede: Está conectado à mesma rede nifi_network para se comunicar com o NiFi.

Arquitetura do Apache NiFi Registry

O NiFi Registry é responsável por armazenar e gerenciar as versões dos fluxos de dados do NiFi. Sua arquitetura é composta principalmente por:

Buckets: Repositórios lógicos que armazenam as versões dos fluxos, permitindo a organização e categorização dos fluxos.

APIs REST: O Registry fornece APIs REST que permitem ao NiFi registrar, atualizar e obter versões dos fluxos.

Banco de Dados de Backend: O NiFi Registry utiliza um banco de dados para armazenar metadados dos fluxos e suas versões, garantindo persistência e rastreabilidade.

Essa arquitetura facilita o versionamento e a colaboração entre desenvolvedores que trabalham em fluxos de dados, garantindo que qualquer alteração possa ser revertida ou implantada em diferentes ambientes.

3. Serviço MinIO

Imagem: Usamos o MinIO como alternativa ao Amazon S3 para armazenamento de objetos.

Portas:

9000: Porta do serviço S3.

9001: Porta do painel de gerenciamento do MinIO, acessível em http://localhost:9001.

Variáveis de Ambiente:

MINIO_ROOT_USER e MINIO_ROOT_PASSWORD: Configurações de credenciais do usuário root para acesso.

Volumes: Usamos o volume minio_data para armazenar os dados.

Rede: Conectado à rede nifi_network para facilitar a comunicação com o NiFi.

Arquitetura do MinIO

O MinIO é um armazenamento de objetos compatível com S3, feito para ser simples e rápido. Sua arquitetura é composta por:

**Serviço de Armazenamento de Objetos: **O MinIO permite armazenar arquivos de qualquer tipo em formato de objetos, similar ao Amazon S3.

Console de Gerenciamento: A interface web acessível na porta 9001 permite gerenciar usuários, buckets e monitorar o uso do sistema de forma prática.

APIs Compatíveis com S3: O MinIO é totalmente compatível com as APIs S3, permitindo que aplicações que utilizam Amazon S3 se conectem ao MinIO sem nenhuma alteração no código.

Essa arquitetura torna o MinIO uma solução ideal para ambientes locais e de desenvolvimento, onde é necessário um armazenamento compatível com S3, mas sem a complexidade e os custos dos serviços em nuvem.

1. Volumes e Rede

Volumes: Servem para persistência dos dados dos três serviços. Dessa forma, os dados não são perdidos se os contêineres forem reiniciados.

Rede (nifi_network*): Todos os contêineres compartilham essa rede para poderem se comunicar diretamente. Usar uma rede personalizada garante mais controle sobre o isolamento dos serviços.
*
Configurando e Executando o Ambiente

**Crie o Arquivo **docker-compose.yml

Crie um arquivo chamado docker-compose.yml e cole o conteúdo mencionado acima.

Inicie os Contêineres

No terminal, navegue até o diretório onde está o arquivo docker-compose.yml e execute:

docker-compose up -d

O comando -d faz com que os contêineres sejam executados em segundo plano.

Acesse os Serviços

Apache NiFi: http://localhost:8080

NiFi Registry: http://localhost:18080/nifi-registry

MinIO: http://localhost:9001 (usuário: admin, senha: password)

Agora é hora da brincadeira

Com tudo UP verificando com comando simples docker ps

Vamos primeiramente configurar um process group para ficar organizado, para isso na tela inicial do nifi após logado, basta clicar e arrastar conforme imagem abaixo:

Pode denominar o nome que te interessar clicando com botão direito sobre o process-group e ir na parte de configurações.
Após criado faça um duplo clique para adentrar a esse grupo de processamento, isso é uma boa prática para dividir em camadas de dominio de negócio/orquestração, ao clicar deve ficar desta forma:

Isso no canto inferior esquerdo ;)

Criando o processor de InvokeHTTP

• Clique e arraste um processor, depois será aberto uma tela para você selecionar a ação que ele vai realizar, busque por InvokeHTTP:

• Posteriormente vamos configurar para que ele faça intervalos de requisições na API pública:

Estes são os parâmetros principais. Agora vamos configurar a integração do nosso apache Nifi com o minIO, para isso aplique e salve o processor de chamada da API e no canto superior direito selecione a opção Controller Settings

Depois vá até a aba de Management controller services e adicione um novo:

• Access Key ID = usuário do minIO especificado no docker-compose.
• Secret Access Key = senha do minIO especificado no docker-compose.
• Use Default Credentials = mantenha como false.

Clique em ok e depois clique no desenho do raio para habilitar:

Ao clicar será aberto a janela abaixo, selecione a opção conforme imagem:

Depois clique em Enable, todas as ativações devem ficar verdes sinalizado comunicação com o minIO:

Criando o processor de inserção no minIO - PutS3Object

Seguinte o mesmo processo do InvokeHTTP mas agora selecionando a opção "PutS3Object", após isso a configuração deve ser da seguinte forma:

• AWS Credentials Provider Service = selecione a configuração que criamos anteriormente (Só vai aparecer se foi clicado no icone do raio para ativar a integração).
• Bucket = Nome do bucket que será criado na interface do minIO.
• Object Key = vira por padrão ${filename}, mas você pode mudar se for de interesse.

Clique em OK e agora arraste uma seta do InvokeHTTP para o PutS3Object, para isso basta selecionar o Invoke pressionando com o botão esquerdo do mouse até o PutS3Object que a seta será criada automáticamente.

Agora calma que ainda precisamos criar nosso bucket na linda interface do minIO :)

Acessando o minIO e criando o Bucket

Abra uma nova guia no navegador e digite: http://localhost:9001/login
os dados de login são os especificados no docker-compose (admin e password)

Ao acessar clique em Buckets e depois na opção Create Bucket:

Crie um bucket com o nome nifi-bucket pois foi o nome que fornecemos no processor do Nifi de S3PutObject ;)

Após isso podemos agora iniciar e processGroup no Nifi e ver essa maravilha funcionando!!

Hora de iniciar!

Ambos os processos devem estar com essa caixinha vermelha, o que signifca que esta parado o processo:

Com isso você pode clicar com o botão direito e depois clicar em Start tanto primeiro no processo de InvokeHTTP e depois no PutS3Object como também você pode na parte inferior esquerda da interface voltar para a parte inicial e clicar em start em todo nosso processgroup para iniciar todos de uma vez.

Repare também que ao ligar os process foi criado uma caixa ao meio denominada Queued, ela é justamente a fila do que a etapa anterior ja processou e esta na fila para a proxima etapa. Inicie os processos e aguarde de 10 a 15 segundos, mas você pode ir reparando nos bytes de Read/Write na ultima etapa e isso garante que esta funcionando:

O numero 1 do lado direito do InvokeHTTP é o numero de threads em execução, terminado um pouco o processamento vamos clicar em stop em ambos os processor (se não ele vai ficar fazendo várias requisições) e vamos agora na interface do minIO acessar nosso bucket e visualizar os arquivos:

Clique em Object Browser e depois no bucket para visualizar os arquivos conforme imagem acima. Sensacional não?

Deixo aqui um repositório com esse projeto: https://github.com/AirtonLira/learning-nifi-minio

E as referências que tive para esse projeto (sugiro olhar a tonelada de tipos de processor que existem):

Documentação do Apache NiFi v2 - https://nifi.apache.org/docs/nifi-docs/
Processador InvokeHTTP - https://nifi.apache.org/docs/nifi-docs/components/org.apache.nifi/nifi-standard-nar/1.15.3/org.apache.nifi.processors.standard.InvokeHTTP/
Processador PutS3Object - https://nifi.apache.org/docs/nifi-docs/components/org.apache.nifi/nifi-aws-nar/1.15.3/org.apache.nifi.processors.aws.s3.PutS3Object/

Para fechar algumas curíosidades sobre o Apache Nifi:

• Ele foi criado pela NSA, ou seja uma agência de segurança nacional dos estados Unidos.
• Venho a se tornar pública pela Apache Foundation em 2014.
• Existe um nifi SaaS pela Cloudera após sua fusão com a Hortonworks.

Bom espero que tenham gostado desse artigo, assim como fiquei facinado com o Apache Nifi, vou seguir evoluindo esse projeto e me aprofundando mais por que isso é apenas a ponta do iceberg dessa ferramenta.