Visão Geral

O curso Producer Performance Tuning for Apache Kafka foi desenvolvido para profissionais que desejam dominar as técnicas de ajuste fino e otimização de desempenho dos produtores Kafka, garantindo maior eficiência, throughput e confiabilidade na publicação de mensagens em sistemas distribuídos.

Durante o curso, os participantes aprenderão a configurar e calibrar parâmetros críticos do Kafka Producer API, como acks, batch size, linger.ms, compression, retries e buffer.memory, bem como a realizar testes de carga, análises de métricas e identificação de gargalos.

Além disso, o treinamento inclui práticas avançadas para monitoramento e diagnóstico de desempenho em ambientes on-premise e cloud-native, integrando Prometheus, Grafana e Kafka CLI tools.

Objetivo

Após realizar este curso Producer Performance Tuning for Apache Kafka, você será capaz de:

• Compreender os principais fatores que afetam o desempenho de produtores Kafka.
• Configurar parâmetros ideais para otimizar latência e throughput.
• Medir e interpretar métricas de desempenho com ferramentas nativas e externas.
• Aplicar técnicas de compressão, batch e parallelism.
• Realizar testes de carga e benchmarking de performance.
• Diagnosticar e resolver gargalos em pipelines de publicação Kafka.

Publico Alvo

• Engenheiros de dados, desenvolvedores backend, arquitetos de software, administradores Kafka e profissionais DevOps interessados em otimizar o desempenho e a confiabilidade da produção de mensagens em clusters Kafka.

Pre-Requisitos

• Conhecimento básico em Apache Kafka (producers, topics, partitions).
• Noções de sistemas distribuídos e redes.
• Experiência com Java, Python ou Go (para uso da Producer API).
• Familiaridade com Linux e Docker.

Materiais

Conteúdo Programatico

Module 1: Kafka Producer Architecture and Workflow

1. Overview of Kafka Producer internals
2. Message serialization and delivery guarantees
3. Batching, buffering, and message dispatch
4. Understanding partitions and producer parallelism
5. The role of acknowledgments (acks) and retries

Module 2: Key Producer Performance Parameters

1. Configuring acks, retries, and max.in.flight.requests.per.connection
2. Optimizing batch.size, linger.ms, and buffer.memory
3. Compression types: gzip, snappy, lz4, zstd – trade-offs and impact
4. Tuning for latency vs throughput scenarios
5. Producer metrics overview: throughput, latency, record size

Module 3: Compression and Serialization Optimization

1. Impact of message size and schema design
2. Using Schema Registry with Avro and Protobuf
3. Comparing serialization formats: JSON vs Avro vs Protobuf
4. Optimizing compression for CPU vs network efficiency
5. End-to-end compression benchmarking

Module 4: Load Testing and Benchmarking

1. Using Kafka-producer-perf-test tool
2. Setting up synthetic workloads for performance validation
3. Analyzing producer latency and throughput metrics
4. Simulating message backpressure and network saturation
5. Real-world benchmarking case studies

Module 5: Monitoring and Observability

1. Collecting producer metrics with JMX and Prometheus
2. Visualizing latency and throughput with Grafana dashboards
3. Alerting on dropped or delayed messages
4. Correlating producer metrics with broker performance
5. Troubleshooting common performance bottlenecks

Module 6: Advanced Tuning and Scaling Strategies

1. Parallel producers and asynchronous publishing
2. Optimizing client-side memory management
3. Network-level tuning (TCP, socket buffers, DNS latency)
4. Multi-threaded and multi-instance producer design
5. Scaling Kafka producers in Kubernetes and cloud environments

Module 7: Real-World Scenarios and Best Practices

1. Tuning for high-frequency event streaming
2. Performance optimization in microservices environments
3. Ensuring consistency and durability under heavy load
4. Balancing cost, performance, and reliability
5. Continuous performance testing in CI/CD pipelines

Module 8: Hands-On Labs

1. Deploying and tuning producers in Docker-based Kafka cluster
2. Running producer benchmark tests with different configurations
3. Monitoring metrics with Prometheus and Grafana
4. Identifying and fixing a real-world performance bottleneck
5. Final performance tuning challenge