Visão Geral

Este Curso Apache Kafka Key Concepts é ideal para arquitetos de software, engenheiros de dados, desenvolvedores, profissionais de DevOps/SREs e qualquer entusiasta de tecnologia que busca uma compreensão profunda dos fundamentos do Apache Kafka. Do ponto de vista técnico, você explorará a arquitetura distribuída do Kafka, seus componentes essenciais (Produtores, Consumidores, Tópicos, Partições, Brokers, ZooKeeper/KRaft) e os princípios que o tornam uma plataforma tão poderosa para sistemas de alta performance e processamento de streams em tempo real. O foco será em desmistificar conceitos como garantias de entrega, durabilidade, escalabilidade e tolerância a falhas, preparando os participantes para interagir com e projetar sistemas que utilizam Kafka de forma eficaz, sem se aprofundar na implementação de código cliente ou administração de cluster (que seriam temas para cursos mais avançados).

Curso Apache Kafka Key Concepts, o Apache Kafka é a espinha dorsal de inúmeras arquiteturas de dados modernas, capacitando empresas a construir sistemas reativos, processar eventos em tempo real e habilitar microsserviços. O entendimento de seus conceitos chave permite que as organizações tomem decisões de design mais informadas, otimizem o fluxo de dados, melhorem a resiliência de seus sistemas e acelerem a entrega de funcionalidades baseadas em dados em tempo real. Profissionais com essa base conceitual sólida são essenciais para qualquer equipe que busca inovar em Big Data, IoT, Microserviços e Analytics em tempo real, garantindo que a plataforma seja utilizada de forma eficiente e segura.

Objetivo

Ao final do Curso Apache Kafka Key Concepts, você será capaz de:

• Explicar a motivação por trás do Apache Kafka e seus casos de uso comuns.
• Descrever a arquitetura distribuída do Kafka e a função de cada componente principal.
• Diferenciar Tópicos, Partições e Offsets e entender seu papel na durabilidade e paralelismo.
• Explicar o fluxo de mensagens desde a produção até o consumo.
• Compreender os mecanismos de tolerância a falhas e alta disponibilidade (Replication Factor, ISR).
• Analisar as garantias de entrega de mensagens (At-most-once, At-least-once, Exactly-once).
• Diferenciar o modelo Publish-Subscribe do Kafka em relação a filas de mensagens tradicionais.
• Entender a escalabilidade do Kafka e como ela é alcançada.
• Identificar quando o Kafka é a solução apropriada para um problema.
• Ter uma visão geral do ecossistema Kafka (Connect, Streams, Schema Registry).

Publico Alvo

• Arquitetos de Software: Para projetar sistemas que utilizam Kafka como barramento de mensagens ou plataforma de streaming.
• Engenheiros de Dados: Para entender como o Kafka se encaixa nos pipelines de dados e suas garantias.
• Desenvolvedores: Que vão interagir com clientes Kafka e precisam entender o comportamento subjacente.
• Profissionais de DevOps/SRE: Para compreender a lógica operacional do Kafka e seus requisitos.
• Gerentes de Produto/Projeto: Que precisam entender as capacidades e limitações do Kafka para planejar iniciativas.
• Qualquer profissional interessado em sistemas distribuídos e processamento de dados em tempo real.

Pre-Requisitos

• Noções básicas de sistemas distribuídos.
• Familiaridade com conceitos gerais de rede (TCP/IP).
• Conhecimento básico de linha de comando Linux (para demonstrações conceituais).
• (Opcional, mas útil) Noções de sistemas de mensagens ou filas.

Materiais

Conteúdo Programatico

Módulo 1: Introdução ao Apache Kafka e o Problema que Ele Resolve (3 horas)

• 1.1. O Cenário dos Dados em Tempo Real:
  • Desafios de sistemas distribuídos e processamento de grandes volumes de dados.
  • Problemas com sistemas de mensagens tradicionais (filas ponto a ponto, Pub/Sub limitado).
• 1.2. O que é Apache Kafka?
  • Definição: Plataforma de streaming distribuída e tolerante a falhas.
  • História e evolução do Kafka (LinkedIn para open source).
  • Principais casos de uso (pipelines de dados, rastreamento de atividades, microsserviços, métricas em tempo real).
• 1.3. Vantagens do Kafka:
  • Alta vazão e baixa latência.
  • Durabilidade e persistência de mensagens.
  • Escalabilidade horizontal.
  • Tolerância a falhas e alta disponibilidade.
  • Natureza de "commit log" distribuído.
• Prática (Conceitual/Discussão): Apresentar cenários do mundo real onde Kafka é aplicado e discutir os desafios que ele supera.

Módulo 2: Componentes Fundamentais do Kafka (5 horas)

• 2.1. Mensagens e Registros (Records):
  • Estrutura de uma mensagem Kafka (chave, valor, timestamp, headers).
  • Importância da chave para ordenação e paralelismo.
• 2.2. Tópicos (Topics) e Partições (Partitions):
  • Tópicos como categorias de mensagens.
  • Partições como a unidade de paralelismo e ordenação dentro de um tópico.
  • Impacto do número de partições na escalabilidade e no consumo.
  • Conceito de Offsets: o identificador único de uma mensagem dentro de uma partição.
• 2.3. Brokers (Servidores Kafka):
  • A função de um Broker em um cluster Kafka.
  • Líder (Leader) e Réplicas (Followers) de partições.
  • Como os Brokers armazenam e servem as mensagens.
• 2.4. Produtores (Producers):
  • Como os produtores publicam mensagens em tópicos.
  • Seleção de partição (key-based, round-robin).
  • Acknowledgements (ACKs) e seu impacto nas garantias de entrega.
• 2.5. Consumidores (Consumers) e Grupos de Consumidores (Consumer Groups):
  • Como os consumidores lêem mensagens de tópicos.
  • A importância dos Consumer Groups para escalabilidade e concorrência no consumo.
  • Offset Management e o __consumer_offsets topic.
  • Rebalanceamento de consumidores em um grupo.
• 2.6. ZooKeeper ou KRaft (Kafka Raft):
  • O papel do ZooKeeper na coordenação do cluster (descoberta de serviços, eleição de líderes, gerenciamento de metadados).
  • Transição para KRaft (Kafka Raft) em versões mais recentes: a eliminação da dependência externa do ZooKeeper.
• Prática (Demonstrativa/CLI): Criar um tópico com várias partições. Produzir mensagens com e sem chave. Consumir mensagens com um e múltiplos consumidores em um grupo, observando o rebalanceamento.

Módulo 3: Garantias, Durabilidade e Escalabilidade (4 horas)

• 3.1. Durabilidade de Dados:
  • Fator de Replicação (Replication Factor).
  • In-Sync Replicas (ISRs): o que são e por que são importantes.
  • Sincronização de réplicas e persistência em disco.
• 3.2. Garantias de Entrega de Mensagens (Delivery Semantics):
  • At-most-once: Entrega única, mas pode haver perda.
  • At-least-once: Pelo menos uma entrega, mas pode haver duplicação (Kafka padrão).
  • Exactly-once: Entrega única e sem duplicação (mais complexo, requer suporte do produtor e consumidor).
  • Estratégias para alcançar Exactly-once.
• 3.3. Tolerância a Falhas e Alta Disponibilidade:
  • Como o Kafka se recupera de falhas de Brokers.
  • Eleição de novos líderes para partições.
  • Recuperação de falhas de Produtores e Consumidores.
• 3.4. Escalabilidade do Kafka:
  • Escalabilidade horizontal (adicionando Brokers e Partições).
  • Capacidade de processar bilhões de eventos por dia.
  • Considerações de dimensionamento (throughput, armazenamento, latência).
• Prática (Discussão): Analisar cenários de falha e como o Kafka reage. Discutir as configurações de acks e seu impacto nas garantias de entrega.

Módulo 4: O Ecossistema Kafka e Casos de Uso Avançados (2 horas)

• 4.1. Kafka Connect:
  • O que é e para que serve (conexão com sistemas externos sem escrever código).
  • Conceitos de Sources e Sinks.
  • Connectors comuns (JDBC, S3, HDFS).
• 4.2. Kafka Streams API:
  • Processamento de stream leve em tempo real.
  • Transformações e agregações em fluxos de eventos.
  • Conceitos de KStream e KTable.
• 4.3. Schema Registry:
  • Gerenciamento de esquemas (Avro, Protobuf, JSON Schema) para evolução de dados.
  • Garantindo compatibilidade de dados entre versões.
• 4.4. KSQL (Kafka SQL):
  • Consultando e manipulando dados em streams usando SQL.
  • Criação de Continuous Queries.
• Prática (Discussão/Demonstração Conceitual): Apresentar exemplos de como Kafka Connect e Kafka Streams simplificam pipelines de dados e aplicações de streaming.

Módulo 5: Boas Práticas e Considerações de Design (2 horas)

• 5.1. Design de Tópicos:
  • Escolha do número de partições.
  • Fator de replicação.
  • Período de retenção de dados.
  • Considerações de nomeação.
• 5.2. Escolha da Chave da Mensagem:
  • Impacto da chave na ordenação, particionamento e joins.
  • Quando usar chaves nulas.
• 5.3. Design de Produtores e Consumidores:
  • Configurações importantes (acks, retries, max.poll.records).
  • Como lidar com falhas de consumidores e mensagens inválidas.
• 5.4. Monitoramento Essencial:
  • Métricas chave para monitorar um cluster Kafka.
  • Observabilidade e alertas.
• 5.5. Armadilhas Comuns e Anti-Padrões:
  • Over-partitioning, under-partitioning.
  • Consumidores lentos.
  • Problemas com chaves de partição.
• Prática (Discussão): Analisar um caso de uso real e discutir como os conceitos aprendidos seriam aplicados no design de um sistema Kafka.