Visão Geral

O Curso Kafka with Python (Faust / Confluent) foi desenvolvido para desenvolvedores e engenheiros de dados que desejam criar aplicações de streaming em tempo real usando Python com Kafka.
Durante o treinamento, os participantes aprenderão a construir producers, consumers e stream processors utilizando Faust e a integrar com Confluent Kafka, incluindo Schema Registry e Avro.
O curso combina teoria, exemplos práticos e laboratórios para capacitar os alunos a implementar pipelines de dados confiáveis, escaláveis e reativos em Python.

Objetivo

Ao concluir o curso Kafka with Python (Faust / Confluent), o participante será capaz de:

• Criar producers e consumers Kafka utilizando Python.
• Implementar stream processing com Faust.
• Integrar Kafka com Confluent Platform, incluindo Schema Registry e Avro.
• Construir microserviços reativos e pipelines de eventos confiáveis.
• Containerizar aplicações Python com Kafka usando Docker.
• Aplicar boas práticas de resiliência, monitoramento e escalabilidade em produção.

Publico Alvo

• Desenvolvedores Python que querem integrar aplicações com Kafka.
• Engenheiros de dados que constroem pipelines de streaming em tempo real.
• Arquitetos de software interessados em microserviços e processamento de eventos.
• Profissionais DevOps que precisam automatizar deployment e integração de pipelines Kafka em Python.

Pre-Requisitos

• Conhecimento básico de Apache Kafka.
• Experiência com Python (programação orientada a objetos e pacotes).
• Familiaridade com Docker e linha de comando Linux.
• Noções de mensageria, streaming e microserviços.

Informações Gerais

Metodologia:

• Curso ao vivo e online, via Microsoft Teams.
• Ministrado por instrutor especialista em Python e Kafka.
• Aulas com exemplos práticos, laboratórios e projeto final.
• Ambiente individual para cada participante, com Kafka, Faust, Confluent e Docker.
• Projeto final de pipeline de streaming completo e reativo.
• Fornecimento de material digital, scripts e Dockerfiles prontos.

Materiais

Conteúdo Programatico

Module 1: Introduction to Kafka with Python

1. Kafka concepts for Python developers
2. Overview of Faust and Confluent Python client libraries
3. Setting up development environment (Python, Kafka, Docker)
4. Creating basic producers and consumers in Python

Module 2: Faust Fundamentals

1. Introduction to Faust and event-driven Python applications
2. Streams, tables, agents, and topics in Faust
3. Creating and running Faust agents
4. Stateful vs stateless stream processing

Module 3: Confluent Python Client

1. Using Confluent Kafka Python library
2. Producing and consuming messages with Avro serialization
3. Working with Schema Registry
4. Error handling and retries

Module 4: Stream Processing with Faust

1. Filtering, mapping, and aggregating streams
2. Windowed operations and joins
3. Handling late-arriving and out-of-order events
4. Deploying Faust applications for production

Module 5: Integration with Confluent Platform

1. Configuring Kafka brokers, topics, and Schema Registry
2. Using Avro and Protobuf serialization in Python
3. Implementing message validation and schema evolution
4. Monitoring and logging Kafka applications

Module 6: Docker and Deployment

1. Containerizing Python applications with Docker
2. Running Kafka, Faust, and Confluent services in Docker Compose
3. Scaling agents and consumers in Dockerized environments
4. Best practices for deployment and monitoring

Module 7: Testing and Troubleshooting

1. Unit and integration testing of Python Kafka applications
2. Debugging message serialization and processing errors
3. Metrics collection and logging for Python streams
4. Handling failures and ensuring reliability

Module 8: Hands-On Project

Project: Build a fully functional Python streaming application using Faust and Confluent Kafka, implementing producers, consumers, stateful processing, and deploying it in Docker containers.