Home / Dicas e Ferramentas / Kafka: o que é, como surgiu e por que dominou o streaming de dados?

Kafka: o que é, como surgiu e por que dominou o streaming de dados?

Apache Kafka

Em 2011, o LinkedIn tinha um problema que nenhuma ferramenta existente conseguia resolver. A plataforma estava processando mais de um bilhão de eventos por dia — cliques, visualizações de perfil, atualizações de feed, notificações — e a infraestrutura de mensageria existente estava entrando em colapso sob esse volume. As soluções disponíveis no mercado, como ActiveMQ e RabbitMQ, foram projetadas para volumes muito menores e simplesmente não escalavam para a realidade de uma rede social com dezenas de milhões de usuários ativos. Foi nesse contexto que um engenheiro chamado Jay Kreps, junto com Neha Narkhede e Jun Rao, começou a desenvolver internamente uma nova plataforma de mensageria distribuída. O projeto recebeu o nome de Kafka — em referência ao escritor Franz Kafka, escolhido, segundo Kreps, porque o sistema era “um sistema otimizado para escrita” e o nome soava bem. Pouco mais de um ano depois, em 2012, o projeto foi doado para a Apache Software Foundation e se tornou open source.

Hoje, o Kafka é utilizado por mais de 80% das empresas da Fortune 100. Está no coração de arquiteturas de streaming de dados da Netflix, Uber, Airbnb, Twitter, Goldman Sachs e de milhares de outras organizações ao redor do mundo. Ele processa trilhões de mensagens por dia em escala global. Neste artigo, você vai entender o que é o Kafka, de onde ele veio, como funciona sua arquitetura, quais os casos de uso mais comuns, por que ele se tornou o padrão da indústria para streaming de dados — e o que o diferencia de todas as alternativas.

O que é o Kafka?

O Kafka é uma plataforma distribuída de streaming de eventos. Em termos simples: é um sistema que permite que diferentes aplicações se comuniquem entre si de forma assíncrona, confiável e em altíssima escala, através do envio e recebimento de mensagens em tempo real.

Mas essa definição, por mais correta que seja, não captura a magnitude do que o Kafka representa. Para entender o Kafka de verdade, é preciso partir de um problema universal no mundo do software: como fazer diferentes sistemas se comunicarem sem que um dependa diretamente do outro?

Imagine uma loja virtual. Quando um cliente finaliza uma compra, o que precisa acontecer? O estoque precisa ser atualizado. O sistema de pagamento precisa ser acionado. O setor de logística precisa receber o pedido. O sistema de CRM precisa registrar a compra para futuras campanhas de marketing. O sistema de nota fiscal precisa emitir o documento. E o cliente precisa receber uma confirmação por e-mail.

Se cada um desses sistemas precisar chamar o outro diretamente, você cria um emaranhado de dependências frágeis: se o sistema de logística estiver fora do ar no momento da compra, a venda falha. Se o sistema de e-mail estiver lento, o checkout trava esperando a resposta. Isso é o que os engenheiros chamam de acoplamento forte — e é um pesadelo em sistemas distribuídos.

O Kafka como barramento central de eventos

O Kafka resolve esse problema funcionando como um barramento central de eventos (event bus). Em vez de o sistema de checkout chamar cada um dos outros sistemas diretamente, ele simplesmente publica um evento — “compra realizada” — no Kafka. Cada sistema interessado (estoque, logística, CRM, fiscal, e-mail) assina esse tópico e processa o evento de forma independente, no seu próprio ritmo.

Se o sistema de logística estiver temporariamente fora do ar, sem problema: o Kafka armazena o evento e o entrega assim que o sistema voltar. O checkout não precisa esperar. A compra não falha. Os dados não se perdem.

Essa arquitetura tem um nome: publish-subscribe, ou pub/sub. O Kafka não a inventou, mas a implementou em uma escala e com uma confiabilidade que nenhum sistema anterior havia conseguido.

Kafka é um banco de dados? Um message broker? Ou um stream processor?

O Kafka desafia categorizações simples — e esse é um dos motivos de tanta confusão para quem está chegando agora. Ele pode funcionar como:

  • Message broker: intermediando mensagens entre sistemas, como o RabbitMQ
  • Log distribuído imutável: armazenando os eventos em ordem de forma que podem ser relidos, como um banco de dados de append-only
  • Plataforma de stream processing: com o Kafka Streams e o ksqlDB, ele processa fluxos de dados em tempo real

A definição mais precisa, adotada pelo próprio projeto, é plataforma de streaming de eventos — um sistema que registra, armazena e processa eventos em tempo real, com durabilidade e escalabilidade.

A história do Kafka: do LinkedIn à Apache Software Foundation

A história do Kafka é, antes de tudo, uma história de engenharia sob pressão extrema. Para entendê-la completamente, é preciso voltar ao LinkedIn de 2009 e 2010.

O problema que criou o Kafka

Naquela época, o LinkedIn era uma das plataformas de crescimento mais rápido da internet. A equipe de engenharia enfrentava um desafio triplo: volumes de dados crescendo exponencialmente, latência inaceitável nos pipelines existentes e a necessidade de alimentar sistemas de machine learning com dados em tempo real para gerar recomendações personalizadas.

A infraestrutura de dados do LinkedIn naquela época era um conjunto fragmentado de pipelines customizados, cada um conectando dois sistemas específicos. Quando o número de sistemas cresceu, o número de pipelines cresceu de forma quadrática — e a manutenção se tornou insustentável. Havia dezenas de pipelines diferentes, cada um com sua própria lógica de tratamento de falhas, monitoramento e formato de dados.

Jay Kreps, então engenheiro sênior, descreveu o problema em um post que se tornaria famoso na comunidade de engenharia: a necessidade não era de mais um pipeline, mas de uma infraestrutura de dados unificada que qualquer sistema pudesse usar para publicar e consumir dados de forma padronizada.

O desenvolvimento interno (2010–2011)

O projeto começou internamente no LinkedIn em meados de 2010. A equipe, liderada por Jay Kreps, Neha Narkhede e Jun Rao, estabeleceu desde o início alguns princípios de design que viriam a definir o Kafka:

  • Throughput extremamente alto: o sistema precisava processar centenas de milhares de mensagens por segundo em hardware comum
  • Baixa latência: a entrega de mensagens deveria ocorrer em milissegundos, não segundos
  • Persistência durável: as mensagens deveriam ser armazenadas em disco de forma durável, não apenas mantidas em memória
  • Escalabilidade horizontal: adicionar mais capacidade deveria ser tão simples quanto adicionar mais servidores
  • Replicação e tolerância a falhas: a perda de um servidor não poderia significar perda de dados

Esses princípios eram, em muitos aspectos, contraintuitivos para os message brokers da época. O RabbitMQ, por exemplo, era projetado para entregar mensagens rapidamente e então descartá-las — a persistência era opcional e cara em termos de performance. O Kafka inverteu essa lógica: a persistência em disco era o comportamento padrão e, graças a otimizações de I/O sequencial, era também o comportamento mais rápido.

A doação para a Apache Foundation (2011–2012)

Em junho de 2011, o LinkedIn tornou o Kafka open source, publicando o código no GitHub e anunciando o projeto para a comunidade técnica. A recepção foi imediata e entusiasmada: engenheiros de outras grandes empresas de tecnologia reconheceram no Kafka a solução para problemas que eles também enfrentavam.

Em outubro de 2012, o Kafka se tornou um projeto de nível superior (top-level project) na Apache Software Foundation — o mais alto reconhecimento que a fundação concede a projetos open source. O nome “Apache Kafka” havia nascido.

💡 Dica: O nome “Kafka” não tem relação técnica com as características do sistema. Jay Kreps simplesmente admirava a obra do escritor Franz Kafka e achou que o nome soava bem para “um sistema otimizado para escrita”. A escolha foi estética, não metafórica — embora muitos tentem encontrar paralelos com os labirintos burocráticos das histórias do escritor tcheco.

A fundação da Confluent e a comercialização (2014)

Em 2014, Jay Kreps, Neha Narkhede e Jun Rao — os três criadores originais do Kafka — deixaram o LinkedIn para fundar a Confluent, empresa focada em oferecer uma versão comercial e gerenciada do Kafka. A Confluent se tornaria responsável por grande parte do desenvolvimento do ecossistema Kafka, incluindo o Kafka Streams, o ksqlDB, o Schema Registry e o Kafka Connect.

A decisão foi um marco: demonstrava que o Kafka havia amadurecido de projeto interno para tecnologia com potencial de mercado bilionário. Em 2021, a Confluent abriu capital na NASDAQ com avaliação de mais de US$ 9 bilhões.

Como o Kafka funciona? Arquitetura e conceitos fundamentais

Entender o Kafka em profundidade exige conhecer seus componentes fundamentais. A arquitetura do Kafka é elegante em sua simplicidade conceitual — mas poderosa em sua capacidade de escalar.

Tópicos, Partições e Offsets

O conceito central do Kafka é o tópico (topic). Um tópico é uma categoria ou feed de mensagens — pense nele como um canal de TV: você publica no canal e quem estiver sintonizado recebe. Exemplos de tópicos: compras-realizadas, logs-de-erro, eventos-de-clique, transacoes-financeiras.

Cada tópico é dividido em partições (partitions). As partições são a unidade de paralelismo do Kafka: diferentes partições de um mesmo tópico podem ser processadas por diferentes consumidores simultaneamente, o que permite escalar o throughput de forma quase linear adicionando mais partições.

Dentro de cada partição, as mensagens são armazenadas em ordem sequencial e imutável. Cada mensagem recebe um identificador numérico chamado offset — sua posição na partição. O offset 0 é a primeira mensagem, o offset 1 é a segunda, e assim por diante. Os consumidores controlam sua própria posição de leitura (offset), o que significa que podem reler mensagens históricas ou processar eventos em paralelo de forma independente.

Produtores e Consumidores

Produtores (producers) são as aplicações que publicam mensagens nos tópicos do Kafka. Um produtor envia uma mensagem, especifica o tópico de destino e — opcionalmente — a partição específica. O Kafka garante a entrega da mensagem e confirma o recebimento (acknowledgment) antes de o produtor considerar a operação concluída.

Consumidores (consumers) são as aplicações que leem mensagens dos tópicos. Eles se organizam em grupos de consumidores (consumer groups): dentro de um grupo, cada partição é atribuída a um único consumidor, garantindo que cada mensagem seja processada exatamente uma vez pelo grupo. Grupos diferentes, porém, podem consumir as mesmas partições de forma independente — o que permite que múltiplos sistemas processem os mesmos eventos sem interferência entre si.

Brokers e Clusters

Um broker é um servidor Kafka — uma instância do software em execução em uma máquina. Um cluster Kafka é formado por múltiplos brokers trabalhando em conjunto. Os tópicos e suas partições são distribuídos entre os brokers do cluster, com replicação para garantir durabilidade.

Cada partição tem um broker designado como líder: ele recebe todas as escritas e leituras daquela partição. Os demais brokers que possuem réplicas da partição são chamados de followers e mantêm cópias sincronizadas dos dados. Se o broker líder falhar, um dos followers é automaticamente promovido a líder — sem perda de dados e com mínima interrupção.

O ZooKeeper e o KRaft

Historicamente, o Kafka dependia do Apache ZooKeeper para gerenciar metadados do cluster — informações sobre tópicos, partições, líderes e configurações. O ZooKeeper era um componente externo obrigatório, o que adicionava complexidade operacional significativa.

A partir da versão 2.8 (2021), o Kafka começou a migrar para o KRaft (Kafka Raft Metadata Mode), um protocolo de consenso próprio que elimina a dependência do ZooKeeper. Na versão 3.3 (2022), o KRaft foi declarado production-ready. Isso simplifica drasticamente a operação de clusters Kafka, especialmente em ambientes containerizados como Kubernetes.

⚠️ Atenção: Se você está começando um novo projeto com Kafka, use KRaft desde o início. O suporte ao ZooKeeper está sendo descontinuado e será removido em versões futuras.

Veja também:

O ecossistema Kafka: muito além do message broker

Um dos fatores que explica a dominância do Kafka no mercado de streaming de dados não é apenas o broker em si — é o ecossistema robusto que se desenvolveu ao seu redor. Hoje, o Kafka não é apenas um sistema de mensageria; é uma plataforma completa para engenharia de dados em tempo real.

Kafka Connect

O Kafka Connect é um framework para integração de dados que permite conectar o Kafka a fontes e destinos externos de forma declarativa — sem escrever código. Existem centenas de conectores prontos para uso: bancos de dados relacionais (PostgreSQL, MySQL, Oracle), bancos NoSQL (MongoDB, Cassandra, Elasticsearch), serviços de nuvem (Amazon S3, Google BigQuery, Azure Blob Storage), sistemas de CRM e ERP, e muito mais.

Com o Kafka Connect, é possível criar pipelines de ingestão de dados em minutos: um source connector lê dados de um banco de dados e os publica no Kafka; um sink connector consome esses dados do Kafka e os entrega a um data warehouse.

Kafka Streams

O Kafka Streams é uma biblioteca Java para processamento de streams em tempo real. Diferentemente de frameworks como Apache Flink ou Apache Spark Streaming, o Kafka Streams não requer um cluster separado de processamento — ele roda dentro da aplicação, usando o próprio Kafka como backend de estado.

Com o Kafka Streams, é possível realizar operações como:

  • Filtrar e transformar eventos em tempo real
  • Enriquecer eventos com dados de outras fontes (stream-table joins)
  • Agregar eventos em janelas de tempo (windowed aggregations)
  • Detectar padrões em sequências de eventos (CEP)

ksqlDB

O ksqlDB (anteriormente chamado de KSQL) é um banco de dados de streaming que permite interagir com dados do Kafka usando uma linguagem semelhante ao SQL. Em vez de escrever código Java com o Kafka Streams, você pode escrever queries como:

SELECT user_id, COUNT(*) AS total_compras
FROM compras_realizadas
WINDOW TUMBLING (SIZE 1 HOUR)
GROUP BY user_id;

O ksqlDB executa essa query de forma contínua sobre o stream de eventos, produzindo resultados em tempo real conforme novos eventos chegam.

Schema Registry

O Schema Registry (parte da plataforma Confluent, mas disponível como open source) resolve um problema crítico em sistemas de streaming: como garantir que produtores e consumidores concordem sobre o formato dos dados?

Sem um Schema Registry, um produtor pode alterar o formato de uma mensagem e quebrar todos os consumidores que dependem do formato anterior. O Schema Registry centraliza a gestão de schemas (usando Apache Avro, Protobuf ou JSON Schema) e aplica políticas de compatibilidade que evitam quebras acidentais de contrato.

Casos de uso do Kafka

O Kafka hoje está presente em praticamente todos os setores da economia digital. Conhecer os casos de uso mais comuns ajuda a entender tanto o poder da ferramenta quanto os cenários onde ela faz mais sentido.

Streaming de eventos em tempo real

Este é o caso de uso original e mais comum do Kafka. Qualquer aplicação que gera um fluxo contínuo de eventos — cliques, transações, logs, sensores IoT, atualizações de localização — pode usar o Kafka como backbone de dados em tempo real.

A Uber, por exemplo, usa o Kafka para processar bilhões de eventos por dia: posições de motoristas e passageiros, solicitações de corridas, dados de precificação dinâmica e eventos de pagamento. O Kafka garante que todos os sistemas relevantes recebam os dados corretos com latência mínima.

Integração de Sistemas (EDA — Event-Driven Architecture)

Em arquiteturas orientadas a eventos, o Kafka funciona como o barramento central que desacopla microsserviços. Em vez de serviços chamarem APIs uns dos outros diretamente (acoplamento síncrono), eles publicam e consomem eventos via Kafka (acoplamento assíncrono).

A Netflix usa o Kafka extensivamente para coordenar seus microsserviços: quando um usuário assiste a um vídeo, dezenas de eventos são publicados no Kafka — dados de visualização, métricas de qualidade de stream, atualização de recomendações, registro para o sistema de billing. Cada um desses sistemas consome os eventos de forma independente.

Pipelines de Dados e ETL em tempo real

O Kafka substitui pipelines de ETL tradicionais (batch) por pipelines de streaming contínuos. Em vez de processar dados em lotes noturnos, as transformações acontecem em tempo real, à medida que os dados chegam.

O LinkedIn usa a ferramenta para alimentar seu pipeline de dados analíticos: eventos de comportamento dos usuários são publicados no Kafka, processados pelo Kafka Streams para enriquecimento e agregação, e então entregues a sistemas de machine learning que atualizam os algoritmos de recomendação em tempo real.

Monitoramento e Observabilidade

O Kafka é amplamente usado como backend para sistemas de logs e métricas em tempo real. Aplicações publicam logs no Kafka; ferramentas como Elasticsearch, Splunk ou sistemas internos consomem esses logs para análise, alertas e dashboards.

💡 Dica: O Kafka não substitui ferramentas especializadas de observabilidade como Prometheus, Grafana ou Datadog — ele complementa essas ferramentas, servindo como camada de transporte confiável para os dados de telemetria.

Detecção de fraudes em tempo real

Instituições financeiras usam o Kafka para processar transações em tempo real e aplicar modelos de detecção de fraude antes de autorizar ou recusar uma operação. A latência do Kafka (tipicamente abaixo de 10ms) é compatível com os SLAs de autorização de pagamentos.

Kafka vs. alternativas: o que o diferencia?

Com a popularidade do Kafka, surgiram ao longo dos anos diversas alternativas — algumas com propostas similares, outras com abordagens radicalmente diferentes. Entender o que diferencia o Kafka é essencial para avaliar se ele é a ferramenta certa para cada cenário.

Kafka vs. RabbitMQ

O RabbitMQ é um message broker tradicional, focado no padrão AMQP. As diferenças fundamentais:

  • Modelo de entrega: o RabbitMQ entrega mensagens e as remove da fila após o consumo; o Kafka retém as mensagens pelo período de retenção configurado, permitindo reprocessamento
  • Throughput: o Kafka é significativamente mais performático em volumes altos (milhões de mensagens/segundo vs. dezenas de milhares no RabbitMQ)
  • Ordering: o Kafka garante ordenação dentro de uma partição; o RabbitMQ não garante ordenação global
  • Casos de uso: RabbitMQ é melhor para filas de tarefas tradicionais (task queues) com roteamento complexo; Kafka é melhor para streaming de dados em alta escala e pipelines de eventos

Kafka vs. Amazon SQS/SNS

Os serviços de mensageria da AWS (SQS e SNS) são gerenciados e simples de operar, mas com limitações significativas em relação ao Kafka:

  • Retenção: SQS retém mensagens por no máximo 14 dias; Kafka pode reter dados por tempo indeterminado
  • Throughput e escala: Kafka escala para volumes muito maiores
  • Stream processing: SQS/SNS não possuem capacidades nativas de processamento de streams; Kafka tem o Kafka Streams e o ksqlDB

Kafka vs. Apache Pulsar

O Apache Pulsar é o concorrente mais direto do Kafka no espaço de streaming de eventos. Criado pelo Yahoo e doado para a Apache Foundation em 2017, o Pulsar oferece algumas vantagens arquiteturais sobre o Kafka — separação entre armazenamento e computação, suporte nativo a multi-tenancy e geo-replicação simplificada. No entanto, o Kafka tem uma vantagem enorme em termos de maturidade, ecossistema e adoção de mercado.

Perguntas frequentes sobre o Kafka

O que é Kafka em termos simples?


O Kafka é uma plataforma de streaming de eventos distribuída — um sistema que permite que diferentes aplicações se comuniquem trocando mensagens em tempo real, de forma confiável em alta escala. Pense nele como um barramento central: uma aplicação publica uma mensagem (por exemplo, “compra realizada”) e todas as outras aplicações interessadas nessa informação (estoque, logística, CRM, e-mail) a recebem e processam de forma independente, sem precisar se comunicar diretamente entre si.

O que é o Kafka e para que serve na prática?


O Kafka serve principalmente para três cenários: integração de sistemas em arquiteturas de microsserviços (onde ele desacopla serviços que antes se comunicavam diretamente), pipelines de dados em tempo real (substituindo processos de ETL em batch por fluxos contínuos) e streaming de eventos de alta escala (processamento de logs, clickstreams, dados de sensores IoT e transações financeiras). Empresas como Netflix, Uber, LinkedIn e Airbnb usam o Kafka como infraestrutura central de dados.

Quem criou o Kafka e por que?


O Kafka foi criado por Jay Kreps, Neha Narkhede e Jun Rao enquanto trabalhavam no LinkedIn, por volta de 2010. O problema que motivou sua criação era a necessidade do LinkedIn de processar mais de um bilhão de eventos por dia para alimentar pipelines de dados e sistemas de recomendação em tempo real. As ferramentas existentes não escalavam para esse volume, o que levou a equipe a criar o Kafka do zero. O projeto foi doado para a Apache Software Foundation em 2011 e tornou-se open source.

Kafka é difícil de aprender?


O Kafka tem uma curva de aprendizado moderada. Os conceitos fundamentais — tópicos, partições, produtores, consumidores e offsets — podem ser compreendidos em algumas horas. Para operação básica e desenvolvimento de aplicações simples, uma semana de estudo dedicado é suficiente. A complexidade aumenta na operação de clusters em produção (tuning de performance, monitoramento, gestão de replicação) e no uso do ecossistema mais avançado (Kafka Streams, ksqlDB, Schema Registry). A documentação oficial é excelente e há muitos recursos gratuitos disponíveis.

Quando devo usar Kafka em vez de RabbitMQ?

Escolha o Kafka quando precisar de: alto throughput (milhões de mensagens por segundo), retenção de mensagens para reprocessamento histórico, múltiplos consumidores independentes lendo os mesmos dados, processamento de streams em tempo real ou pipelines de dados em escala. Escolha o RabbitMQ quando precisar de: roteamento de mensagens complexo e flexível, filas de tarefas tradicionais (task queues), entrega garantida com confirmação individual por mensagem ou volume menor com simplicidade operacional. Para a maioria dos sistemas modernos de dados em escala, o Kafka é a escolha mais adequada.

Conclusão

O Kafka percorreu um caminho extraordinário: nasceu como solução interna para um problema específico do LinkedIn, tornou-se open source, foi adotado pelas maiores empresas de tecnologia do mundo e redefiniu o que é possível fazer com dados em tempo real.

Mais do que uma ferramenta técnica, o Kafka representa uma mudança de paradigma na forma como sistemas distribuídos são construídos. A arquitetura orientada a eventos, impulsionada pelo Kafka, permite construir sistemas mais resilientes, escaláveis e manuteníveis do que os modelos de integração ponta-a-ponta que dominavam antes.

Os três pilares que explicam o sucesso do Kafka continuam sendo os mesmos que guiaram seu design original: throughput extremo, durabilidade confiável e escalabilidade horizontal. A esses três, o ecossistema adicionou um quarto: versatilidade — com o Kafka Connect, Kafka Streams e ksqlDB, o Kafka não é apenas um broker de mensagens, mas uma plataforma completa para engenharia de dados em tempo real.

Se você trabalha com desenvolvimento de software, arquitetura de sistemas ou engenharia de dados, entender o Kafka não é mais opcional — é parte essencial do repertório técnico de qualquer profissional que trabalha com sistemas distribuídos modernos.

👉 Compartilhe este artigo com seu time de engenharia e salve para consultar quando for projetar sua próxima arquitetura de dados.

Deixe um Comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *