Introdução ao Apache NiFi
Tags: brasil, tutorial
Published: 2020-05-10 23:35:39

Nesse artigo vou apresentar os conceitos principais da ferramenta [Apache Nifi](https://nifi.apache.org/) e depois seguiremos para um simples tutorial de como instalar localmente e configurar um fluxo de dados básico, que será mover conteúdo de um arquivo para outro.

Como o NiFi é uma ferramenta gráfica, recomendo ler esse artigo em uma tela grande (desktop) pois esse artigo terá muitas imagens.

![Um gato lendo código no computador](https://media.giphy.com/media/3oKIPnAiaMCws8nOsE/giphy.gif)

Esse texto foi escrito com base na versão 1.11.4 do NiFi.

# Principais definições
O Apache NiFi é um programa usado para automatizar fluxo de dados usando uma interface gráfica acessada através de um navegador. Isso quer dizer que não dependemos de código para criar por exemplo, uma tarefa recorrente (cron) que move dados novos de um banco para outro banco ou mesmo para uma fila (ex.: Apache Kafka).

Para compreendermos melhor o tutorial que virá a seguir temos que entender algumas terminologias que existem no contexto do NiFi:

## Processor
Um *processor* é um elemento atômico que faz uma tarefa simples. O próprio NiFi já possui uma infinidade de *processors*, bastando apenas configurá-lo de acordo com o seu *data flow*. Por exemplo, se quisermos usar o [PutMongoRecord](https://nifi.apache.org/docs/nifi-docs/components/org.apache.nifi/nifi-mongodb-nar/1.11.4/org.apache.nifi.processors.mongodb.PutMongo/index.html), temos que configurar a *connection string*, usuário e senha do banco Mongo que queremos usar.

![NiFi PutMongo Processor](https://dev-to-uploads.s3.amazonaws.com/i/u6ak7yxjr2adws3u17h9.png)

## FlowFile
É uma abstração do próprio dado no ambiente do NiFi. Um processor pode gerar um *FlowFile* a partir de um *datasource* como um arquivo ou transformar um *FlowFile* em outro, por exemplo de XML para JSON.

## Connection
É a ligação entre dois *processors*, gerando uma *Queue* (fila). Possui um tipo, normalmente *success* ou *failure*, referente ao *procssor* origem e nele é possível ver a quantidade que *FlowFiles* enfileirado (*queued*) assim como o tamanho deles em bytes.

![NiFi Queue](https://dev-to-uploads.s3.amazonaws.com/i/32xdbsgtnq4e9ct32osr.png)

# Instalação
Como pré-requisito, é necessário ter o Java 8 ou 11 instalado. Se você está usando um sistema operacional baseado em UNIX, recomendo usar o [SDKMAN](https://sdkman.io/install) para instalar o Java.

Em seguida, vá até a [página de downloads do NiFi](https://nifi.apache.org/download.html) e baixe a [versão binária](https://www.apache.org/dyn/closer.lua?path=/nifi/1.11.4/nifi-1.11.4-bin.zip).

Para o rodar o NiFi, basta rodar comando:
```shell
bin/nifi.sh start
```
A partir desse ponto já conseguimos acessar o NiFi acessando o endereço [http://localhost:8080/nifi/](http://localhost:8080/nifi/) através do navegador.

# Criando seu *dataflow*
Primeiro precisamos criar dois diretórios localmente, um servirá como entrada e o outro como saida. Nesse tutorial usarei respectivamente os diretórios `/home/fabiohiroki/nifi-test/input` e `/home/fabiohiroki/nifi-test/output`.

## *GetFile processor*
O primeiro *processor* que vamos criar se chama `GetFile` que é responsável por criar `FlowFiles` a partir de arquivos criados em diretórios específicos.

Para fazer isso basta clicar e arrastar o ícone de `Processors` na barra superior, depois filtramos por `GetFile`. Uma caixa representando o processor recém adicionado irá aparecer no meio da tela.

![Animação mostrando a adição de um novo processor](https://dev-to-uploads.s3.amazonaws.com/i/83s1br3ms99dj036ruj6.gif)

## *PutFile processor*
Similar ao passo acima, vamos adicionar um segundo processor chamado `PuFile`, responsável por efetivamente criar um arquivo em um diretório específico.

![Animação mostrando a adição do processor PutFile](https://dev-to-uploads.s3.amazonaws.com/i/cxnfrpz8wi32lbsnhl46.gif)

## Conectando *processors*
Para conectar dois *processors* e gerar uma *queue* entre eles, basta escolher o *processor* de origem, clicar no ícone de seta, segurar e soltar o botão esquerdo do *mouse* no *processor* destino, e em seguida clicar em `Add`. Nesse caso uma conexão automaticamente será gerada uma vez que o *processor* *GetFile* possui apenas um tipo de relacionamento chamado `success.`

![Animação mostrando como conectar dois processors](https://dev-to-uploads.s3.amazonaws.com/i/3zna9iuhkd76d2d2siig.gif)

## Configuração dos `processors`
Até agora ainda não é possível rodar e testar esse *dataflow* devido a algumas configurações mínimas que precisamos adicionar em cada *processor*. Cada um deles possui uma infinidade de opções de customização, então uma dica é verificar as mensagens de erro mostradas quando colocamos o mouse sob o ícone de alerta. Dessa forma conseguimos saber exatamente o que temos que configurar para conseguir rodar cada *processor*.

![Mensagem indicando que o processor GetFile está inválido](https://dev-to-uploads.s3.amazonaws.com/i/wdcms2xfr88ctnlo65lg.png)

No caso do *processor GetFile* só precisamos então adicionar o caminho para o diretório de entrada. Para fazer isso, clique duas vezes no *processor*, depois na aba *Properties* e depois coloque o caminho absoluto no campo `Input Directory`. Ao fazer isso o ícone de alerta desaparecerá.

![Animação mostrando como adicionar o caminho de origem no processor GetFile](https://dev-to-uploads.s3.amazonaws.com/i/kf211ugo9k8yfmdih9k6.gif)

Seguindo o mesmo processo para o *PutFile*, adicionamos um caminho absoluto de destino e também indicamos que ele não terá relacionamentos em caso de sucesso ou falha.

![Configuração do processor PutFile](https://dev-to-uploads.s3.amazonaws.com/i/y0dbh4kgufshnde7bbwy.gif)

## Teste dos *processors*
Para ligar um *processor* basta clicar com o botão direito e depois em *Start*. Para fins didáticos vamos começar ligando primeiro apenas o processor `GetFile`.

Coloque um arquivo qualquer no diretório definido como `Input Folder` do *processor* `GetFile`. Se você estiver em um sistema operacional UNIX, pode usar o comando `touch` no terminal:
```bash
touch /home/fabiohiroki/nifi-test/input/exemplo.txt
```

Se as configurações estiverem corretas até agora, veremos um novo *FlowFile* na fila, referente ao arquivo que acabamos de criar.

![Fila sendo populate com arquivo criado](https://dev-to-uploads.s3.amazonaws.com/i/azw9fbqdw54oo60q14cu.gif)

Agora se ligarmos o processor *PutFile*, veremos a fila se esvaziar e o arquivo sendo criado na pasta destino.

![Fluxo todo ligado](https://dev-to-uploads.s3.amazonaws.com/i/kv4hshw94xckuq5iub36.gif)

# Conclusão
O fluxo apresentado dificilmente será um caso de uso real em produção, mas é suficiente para apresentar os conceitos iniciais do Apache NiFi e seu funcionamento na prática.