Introdução ao Apache Kafka: O que é e como funciona?

Apache Kafka é uma plataforma de streaming de dados em tempo real que permite a troca de mensagens entre sistemas de forma eficiente e escalável. Criado pela equipe do LinkedIn e tornado open-source, o Kafka foi desenvolvido para processar grandes volumes de dados de maneira rápida, tornando-se uma ferramenta essencial para arquiteturas de microsserviços, sistemas distribuídos e processamento de eventos.

Se você está apenas começando sua jornada no mundo da programação, talvez esteja se perguntando: “O que exatamente é o Kafka e como ele se encaixa em um projeto moderno?”

Imagine que você está desenvolvendo um sistema no qual várias partes do código precisam se comunicar constantemente, como um sistema de pedidos em um e-commerce, onde um serviço cuida dos pagamentos, outro dos envios, e outro do estoque. O Kafka atua como um “correio” intermediário, garantindo que as mensagens entre esses serviços sejam entregues de forma confiável e ordenada, sem sobrecarregar nenhum deles.

Neste artigo, vamos explorar os principais conceitos do Apache Kafka, como ele funciona, e veremos um exemplo prático de como utilizá-lo com NestJS.

O que é o Apache Kafka?

O Apache Kafka é um sistema de mensageria distribuído, projetado para processar e armazenar grandes quantidades de dados em tempo real. Ele permite que diferentes aplicações troquem mensagens de forma assíncrona, o que significa que o remetente e o destinatário não precisam estar disponíveis ao mesmo tempo para a comunicação ocorrer.

Conceitos chave:

Produtores: São os responsáveis por enviar mensagens ao Kafka. Imagine que eles são os serviços que produzem dados, como um serviço de pagamento em um sistema de e-commerce.
Consumidores: Estes são os sistemas ou serviços que leem as mensagens enviadas ao Kafka. No exemplo do e-commerce, o serviço de estoque poderia ser um consumidor, lendo as mensagens sobre novos pedidos processados.
Brokers: São os servidores que formam o cluster Kafka, onde as mensagens são armazenadas temporariamente.
Tópicos: As mensagens no Kafka são organizadas em “tópicos”, que são como caixas de correio onde as mensagens são armazenadas para que os consumidores possam acessá-las.

Por que usar o Apache Kafka?

Escalabilidade: O Kafka pode lidar com milhões de mensagens por segundo, o que o torna ideal para grandes sistemas com alta demanda de troca de informações.
Resiliência: Como um sistema distribuído, ele oferece alta disponibilidade e confiabilidade, mesmo que alguns de seus servidores falhem.
Desempenho em tempo real: Se você precisa de processamento de dados em tempo real, o Kafka é uma das soluções mais adequadas, pois permite uma latência muito baixa.
Integração fácil com sistemas distribuídos: Kafka é frequentemente usado em arquiteturas de microsserviços e sistemas distribuídos, pois facilita a comunicação entre serviços independentes.

Como o Kafka funciona?

O Kafka trabalha com o conceito de logs distribuídos, onde as mensagens são gravadas de maneira sequencial e podem ser lidas várias vezes pelos consumidores. Um ponto importante aqui é que o Kafka separa os papéis de “produtor” e “consumidor”, permitindo que os serviços continuem funcionando independentemente uns dos outros.

Exemplo prático: Integrando Kafka com NestJS

Agora que você já conhece os conceitos básicos do Kafka, vamos ver como ele pode ser utilizado em uma aplicação prática. No exemplo a seguir, vamos configurar uma aplicação NestJS para enviar e consumir mensagens usando o Kafka.

Passo 1: Instalação do Kafka e Pacotes Necessários

Para começar, você precisa ter o Kafka rodando no seu ambiente. Caso não tenha, você pode usar o Docker para subir uma instância local do Kafka rapidamente:

docker run -d --name zookeeper -p 2181:2181 zookeeper
docker run -d --name kafka -p 9092:9092 --link zookeeper wurstmeister/kafka

Em seguida, vamos instalar os pacotes necessários no NestJS:

npm install --save kafkajs @nestjs/microservices

Passo 2: Configuração do Microservice Kafka no NestJS

No arquivo main.ts, configure o Kafka como um microserviço dentro do NestJS:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.KAFKA,
      options: {
        client: {
          brokers: ['localhost:9092'],
        },
        consumer: {
          groupId: 'my-consumer-group',
        },
      },
    },
  );
  await app.listen();
}
bootstrap();

Passo 3: Criando um Produtor Kafka no NestJS

Agora, vamos criar um produtor que envia mensagens para um tópico Kafka:

import { Injectable } from '@nestjs/common';
import { ClientKafka } from '@nestjs/microservices';

@Injectable()
export class KafkaProducerService {
  constructor(private readonly clientKafka: ClientKafka) {}

  async sendMessage(topic: string, message: any) {
    await this.clientKafka.emit(topic, message);
  }
}

Passo 4: Consumindo Mensagens no NestJS

Vamos configurar um consumidor para ler as mensagens de um tópico específico:

import { Controller } from '@nestjs/common';
import { EventPattern } from '@nestjs/microservices';

@Controller()
export class KafkaConsumerController {
  @EventPattern('my-topic')
  async handleMessage(message: any) {
    console.log('Mensagem recebida: ', message);
  }
}

Conclusão

O Apache Kafka é uma ferramenta poderosa para sistemas que precisam lidar com grandes quantidades de dados em tempo real. Sua capacidade de escalabilidade e resiliência o torna ideal para arquiteturas distribuídas, como microsserviços. Com o NestJS, a integração com Kafka é direta, permitindo que você desenvolva aplicações que se beneficiem do processamento em tempo real e da comunicação assíncrona entre serviços.

Se você está apenas começando a aprender sobre Kafka, recomendamos que experimente a implementação básica mencionada acima e explore mais sobre suas funcionalidades avançadas, como compactação de logs e diferentes estratégias de partição.

Gostou do conteúdo? Tem alguma dúvida ou gostaria de saber mais sobre Apache Kafka ou outras tecnologias? Deixe seu comentário abaixo! Estamos aqui para ajudar e aprender juntos!

Com esse artigo, você está mais perto de dominar uma das ferramentas mais importantes para arquiteturas de dados em tempo real. Não deixe de explorar mais sobre o Apache Kafka e como ele pode transformar suas aplicações!