Curso Spring RabbitMQ For High Load
24 horasVisã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
Inglês/Português/Lab PráticoConteú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.
- Adicionando dependências (
- 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.
- Converteres de Mensagem:
- 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
eReturns
.
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.
- Modos de ACK:
- 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
emaxConcurrency
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.
- Estratégias de retries:
- 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).
- Quando usar mensagens persistentes (
- 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.