Introdução

Neste tutorial, vamos explorar como implementar valas de dados utilizando Apache Kafka e Apache NiFi para criar fluxos de dados em tempo real em aplicações modernas. Os dados são uma das principais riquezas de uma organização, e a capacidade de gerenciá-los e processá-los em tempo real é um diferencial competitivo. O Apache Kafka é uma plataforma robusta de mensagens que permite a transmissão de dados entre serviços de forma escalável e resiliente, enquanto o Apache NiFi é uma ferramenta poderosa para automação do fluxo de dados. Juntos, esses sistemas formam uma solução eficiente para a orquestração e manipulação de dados. Você aprenderá a configurar ambos, criar tópicos no Kafka, projetar fluxos no NiFi e integrar tudo isso em uma aplicação Java com Spring Boot, proporcionando uma experiência prática e completa.

Etapas

  1. Configurando o Ambiente

    Antes de começarmos, garanta que você possui o JDK e o Maven instalados em sua máquina. Além disso, você precisará baixar e configurar tanto o Apache Kafka quanto o Apache NiFi. Verifique as versões instaladas usando os comandos ‘java -version’ e ‘mvn -version’. Se você não os tem, consulte a documentação oficial.

    commands
    # Verificar versões instaladas
    java -version
    mvn -version

  2. Instalando e Configurando o Apache Kafka

    Baixe a distribuição do Apache Kafka e descompacte o arquivo. Navegue até o diretório do Kafka e inicie o servidor Zookeeper e o Kafka. Use os seguintes comandos no terminal para iniciar os serviços.

    commands
    # Iniciar o Zookeeper
    bin/zookeeper-server-start.sh config/zookeeper.properties
    # Iniciar o Kafka
    bin/kafka-server-start.sh config/server.properties

  3. Criando um Tópico no Kafka

    Crie um tópico no Kafka que será utilizado para a troca de mensagens. Execute o seguinte comando para criar um tópico chamado ‘dados’.

    commands
    bin/kafka-topics.sh --create --topic dados --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

  4. Instalando e Configurando o Apache NiFi

    Baixe e instale o Apache NiFi. Após a instalação, você poderá iniciar o NiFi usando o comando no terminal. O NiFi fornece uma interface web que facilita a configuração de fluxos de dados.

    commands
    # Iniciar o NiFi
    bin/nifi.sh start

  5. Criando um Fluxo de Dados no NiFi

    Após iniciar o NiFi, acesse a interface web (geralmente em http://localhost:8080ifi). Crie um novo fluxo que leia de um arquivo JSON e envie os dados para o tópico ‘dados’ do Kafka. Utilize os processadores ‘GetFile’ para ler os arquivos e ‘PublishKafka’ para enviar os dados.

    configuration
    Adicione um processador 'GetFile' e configure o diretório onde estão os arquivos JSON. Conecte-o a um processador 'PublishKafka', configurando-o para enviar dados para o tópico 'dados'.

  6. Configurando a Aplicação Java com Spring Boot

    Crie um novo projeto Spring Boot utilizando o Spring Initializr. Adicione as dependências ‘Spring Web’ e ‘Spring Kafka’ no arquivo pom.xml.

    pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>valas-de-dados</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>valas-de-dados</name>
  <description>Valas de Dados com Kafka e NiFi</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.kafka</groupId>
      <artifactId>spring-kafka</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  7. Configurando a Classe KafkaProducer

    Crie uma classe KafkaProducer que será responsável por enviar mensagens para o tópico ‘dados’. Implemente a lógica de produção de mensagens nesta classe.

    KafkaProducer.java
    package com.example.valasdados;

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class KafkaProducer {
    private final KafkaTemplate<String, String> kafkaTemplate;

    public KafkaProducer(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String message) {
        kafkaTemplate.send("dados", message);
    }
}

  8. Implementando o Controlador para Receber Dados

    Crie um controlador no Spring Boot que irá expor um endpoint para receber dados e enviá-los para o Kafka usando o KafkaProducer.

    DataController.java
    package com.example.valasdados;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DataController {
    @Autowired
    private KafkaProducer kafkaProducer;

    @PostMapping("/send")
    public void sendData(@RequestBody String data) {
        kafkaProducer.sendMessage(data);
    }
}

  9. Implementando Testes Unitários

    Implemente testes unitários para validar a funcionalidade do controlador e do produtor de Kafka. Utilize o JUnit e Mockito para isso.

    DataControllerTest.java
    package com.example.valasdados;

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class DataControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private KafkaProducer kafkaProducer;

    @Test
    public void testSendData() throws Exception {
        Mockito.doNothing().when(kafkaProducer).sendMessage(Mockito.anyString());
        mockMvc.perform(MockMvcRequestBuilders.post("/send")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"data\":\"teste\"}"))
                .andExpect(status().isOk());
    }
}

  10. Executando a Aplicação e Testes

    Use o Maven para compilar e executar a aplicação Spring Boot. Em seguida, utilize ferramentas como Postman ou cURL para testar os endpoints do Kafka e do controlador de dados.

    commands
    # Compilar e executar a aplicação
    mvn spring-boot:run
    # Executar os testes unitários
    mvn test
    # Enviar dados para o controlador
    curl -X POST -H 'Content-Type: application/json' -d '{"data":"Teste de dados"}' http://localhost:8080/send

Conclusão

Neste tutorial, você aprendeu a implementar valas de dados utilizando Apache Kafka e Apache NiFi. Mostramos desde a configuração de ambiente e dos serviços até a implementação de uma aplicação em Spring Boot que se integra a esses sistemas, permitindo o envio e recebimento de dados em tempo real. Ao final, você obteve conhecimento não apenas sobre a tecnologia, mas também sobre como orquestrar dados de forma eficiente dentro de uma arquitetura moderna.

Hashtags

#Kafka #NiFi #SpringBoot #FluxoDeDados #APIs #DesenvolvimentoDeSoftware