Visão Geral

Curso Spring RabbitMQ For High Load. Este curso intensivo e altamente prático foi projetado para desenvolvedores Java, arquitetos de software e engenheiros de backend que precisam construir aplicações robustas e escaláveis capazes de lidar com grandes volumes de mensagens e alta concorrência usando Spring Boot e RabbitMQ. Do ponto de vista técnico, você mergulhará nos conceitos avançados do RabbitMQ (exchanges, filas, bindings, modos de persistência, confirmações de editor e consumidor). O foco será em como o Spring AMQP, o módulo do Spring para integração com RabbitMQ, facilita a criação de produtores e consumidores de alta performance. Abordaremos estratégias cruciais para alta carga, como processamento assíncrono, escalabilidade de consumidores, tratamento eficiente de erros, retries, Dead Letter Queues (DLQs), e o uso de recursos como o RabbitMQ Sharding e Stream (visão geral para lidar com grandes volumes). Além disso, exploraremos a configuração de pools de conexões, otimização de performance e monitoramento, garantindo que os participantes possam desenvolver e manter sistemas de mensageria resilientes e de alto throughput.

Curso Spring RabbitMQ For High Load., a capacidade de processar mensagens em massa e construir sistemas reativos é fundamental para empresas que operam em ambientes de alta demanda, como e-commerce, IoT, serviços financeiros e streaming de dados. Dominar o Spring RabbitMQ para alta carga permite que as organizações garantam a entrega de mensagens, gerenciem picos de tráfego, desacoplem microsserviços e mantenham a responsividade de suas aplicações, mesmo sob pressão extrema. Isso se traduz em melhor experiência do usuário, maior confiabilidade do sistema, redução de perdas de dados e a capacidade de escalar a infraestrutura de forma eficiente. Profissionais com essa expertise são altamente valorizados e estratégicos, pois são os responsáveis por construir a espinha dorsal de sistemas críticos de alto volume.

Objetivo

Ao final do Curso Spring RabbitMQ para Aplicações de Alta Carga, você será capaz de:

• Compreender os conceitos avançados do RabbitMQ e seu modelo de mensagens.
• Configurar o Spring AMQP para interagir eficientemente com o RabbitMQ.
• Desenvolver produtores que garantem a entrega de mensagens em ambientes de alta carga.
• Construir consumidores altamente performáticos e escaláveis para processamento de mensagens.
• Implementar estratégias robustas de tratamento de erros, retries e Dead Letter Queues (DLQs).
• Aplicar o padrão Confirmações de Editor e Confirmações de Consumidor (ACK/NACK) para garantir a confiabilidade da mensagem.
• Explorar técnicas de otimização de performance, como prefetch de mensagens e thread pooling.
• Entender a importância da perssistência e da durabilidade de mensagens.
• Monitorar o desempenho e a saúde de aplicações Spring RabbitMQ.
• Aplicar melhores práticas para construir sistemas de mensageria resilientes e de alto throughput.

Publico Alvo

• Desenvolvedores Java/Spring Boot: Que trabalham ou esperam trabalhar com sistemas distribuídos e mensageria de alta performance.
• Arquitetos de Software: Interessados em projetar soluções de mensageria resilientes e escaláveis.
• Engenheiros de Backend: Buscando aprimorar suas habilidades em processamento assíncrono e sistemas de eventos.

Pre-Requisitos

• Conhecimento sólido de Java e Spring Boot: Entendimento de injeção de dependências, componentes Spring, REST APIs.
• Noções básicas de Maven ou Gradle.
• Familiaridade com a linha de comando (terminal).
• (Desejável) Experiência prévia com mensageria (mesmo que básica) ou sistemas distribuídos.

Materiais

Conteúdo Programatico

Módulo 1: Fundamentos do RabbitMQ para Alta Carga (3 horas)

• 1.1. Introdução a Sistemas de Mensageria Distribuídos:
  • Por que usar mensageria? Vantagens e desvantagens.
  • Padrões de Mensageria: Ponto a Ponto vs. Publicar/Assinar.
  • Mensageria Assíncrona e Event-Driven Architecture.
• 1.2. Visão Geral do RabbitMQ:
  • Arquitetura: Produtores, Consumidores, Brokers (Nodes).
  • Componentes Chave: Exchanges (Tipos: Direct, Fanout, Topic, Headers), Queues, Bindings.
  • Modelo AMQP (Advanced Message Queuing Protocol).
• 1.3. Instalação e Gerenciamento do RabbitMQ:
  • Hands-on: Rodando RabbitMQ via Docker Compose.
  • Explorando a interface de gerenciamento do RabbitMQ (Management Plugin).
  • Criação de exchanges e filas via UI e CLI.
• 1.4. Durabilidade e Persistência:
  • Filas duráveis e mensagens persistentes.
  • Modos de armazenamento e replicação (visão geral).
• Prática: Montar o ambiente RabbitMQ local via Docker. Criar exchanges, filas e bindings. Enviar e receber mensagens simples via interface de gerenciamento para entender o fluxo.

Módulo 2: Spring AMQP: Produtores de Mensagens Otimizados (5 horas)

• 2.1. Configuração do Spring AMQP:
  • Adicionando dependências (spring-boot-starter-amqp).
  • Configuração básica de conexão no application.properties/application.yml.
  • RabbitTemplate: A abstração principal para envio de mensagens.
• 2.2. Enviando Mensagens para Exchanges:
  • Hands-on: Criando produtores para diferentes tipos de exchanges (Direct, Fanout, Topic).
  • Definindo routing keys.
• 2.3. Serialização de Mensagens para Alta Carga:
  • Converteres de Mensagem: SimpleMessageConverter, Jackson2JsonMessageConverter.
  • Melhores práticas para serialização: JSON, Avro, Protobuf (com foco em JSON).
  • Hands-on: Configurar Jackson2JsonMessageConverter para enviar objetos Java como JSON.
• 2.4. Confirmações de Editor (Publisher Confirms):
  • Garantindo a entrega da mensagem ao broker.
  • Modo síncrono vs. assíncrono.
  • Hands-on: Implementar Publisher Confirms e tratar retornos (ACK/NACK).
• 2.5. Retornos de Editor (Publisher Returns):
  • Quando a mensagem não pode ser roteada para uma fila.
  • Hands-on: Configurar Publisher Returns para lidar com mensagens não roteáveis.
• Prática: Desenvolver produtores Spring Boot que enviam mensagens para diferentes exchanges, usando serialização JSON e implementando Publisher Confirms e Returns.

Módulo 3: Consumidores Resilientes e Escaláveis (5 horas)

• 3.1. Criando Listeners de Mensagens com Spring AMQP:
  • @RabbitListener: Anotação para criar consumidores simples.
  • SimpleRabbitListenerContainerFactory.
  • Hands-on: Criar consumidores para as filas criadas no Módulo 2.
• 3.2. Confirmações de Consumidor (Consumer Acknowledgments):
  • Modos de ACK: AUTO, MANUAL (AcknowledgeMode.MANUAL).
  • basicAck, basicNack, basicReject.
  • Hands-on: Implementar ACK manual para garantir o processamento da mensagem.
• 3.3. Pré-busca de Mensagens (Prefetch Count):
  • Otimizando o consumo para alta carga.
  • Impacto no balanceamento de carga entre consumidores.
  • Hands-on: Configurar e testar diferentes valores de prefetch count.
• 3.4. Concorrência de Consumidores e Escalonamento:
  • concurrency e maxConcurrency no @RabbitListener.
  • Escalonamento horizontal de consumidores (múltiplas instâncias da aplicação).
  • Hands-on: Testar o comportamento do consumidor sob concorrência e escalabilidade.
• 3.5. Tratamento de Erros e Dead Letter Queues (DLQs):
  • Estratégias de retries: RetryTemplate, StatefulRetryOperationsInterceptor.
  • Configurando DLQs no RabbitMQ e Spring AMQP.
  • Hands-on: Implementar um mecanismo de retry com DLQ para mensagens que falham após tentativas.
• Prática: Desenvolver consumidores robustos com ACK manual, prefetch otimizado e tratamento de erros via DLQ. Testar a concorrência e escalabilidade dos consumidores.

Módulo 4: Otimização, Monitoramento e Melhores Práticas (5 horas)

• 4.1. Pools de Conexão e Channel Caching:
  • CachingConnectionFactory: Otimizando o uso de recursos.
  • Configurações de cache de conexão e canal.
• 4.2. Fluxos de Mensagens e Backpressure:
  • Como o RabbitMQ gerencia o fluxo de mensagens e a sobrecarga.
  • Estratégias para lidar com backpressure nas aplicações.
• 4.3. Persistência de Mensagens e Transações:
  • Quando usar mensagens persistentes (MessageProperties.setDeliveryMode).
  • Transações AMQP (visão geral, limitações).
• 4.4. Monitoramento do RabbitMQ e Aplicações:
  • Métricas do RabbitMQ (Management Plugin).
  • Integração com Spring Boot Actuator para métricas AMQP.
  • Visão geral de ferramentas de monitoramento (Prometheus, Grafana).
• 4.5. Considerações de Performance e Escalabilidade:
  • Evitando gargalos comuns.
  • Estratégias de particionamento de filas e exchanges (Federation, Shovel - conceitual).
  • RabbitMQ Stream para cenários de logs e telemetria de alto volume (visão geral).
• Prática: Otimizar a CachingConnectionFactory. Simular e monitorar cenários de alta carga. Avaliar métricas do RabbitMQ e da aplicação.

Módulo 5: Segurança e Cenários Avançados (2 horas)

• 5.1. Segurança no RabbitMQ:
  • Gerenciamento de usuários, permissões e Virtual Hosts.
  • Conexões TLS/SSL (visão geral).
• 5.2. Padrões de Mensageria para Alta Carga:
  • Request-Reply com RabbitMQ.
  • Fan-out para múltiplos consumidores.
• 5.3. Integração com Microsserviços:
  • Padrões de comunicação assíncrona.
  • Saga Pattern (coreografia vs. orquestração - conceitual).
• 5.4. Próximos Passos:
  • Clusters RabbitMQ (HA).
  • RabbitMQ Operators para Kubernetes.
  • Outras tecnologias de mensageria.
• Prática: Configurar um usuário e permissão básicos no RabbitMQ. Discutir cenários complexos e padrões de design.