Curso Spring RabbitMQ For High Load

  • DevOps | CI | CD | Kubernetes | Web3

Curso Spring RabbitMQ For High Load

24 horas
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
Inglês/Português/Lab Prático
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.

TENHO INTERESSE

Cursos Relacionados

Curso Ansible Red Hat Basics Automation Technical Foundation

16 horas

Curso Terraform Deploying to Oracle Cloud Infrastructure

24 Horas

Curso Ansible Linux Automation with Ansible

24 horas

Ansible Overview of Ansible architecture

16h

Advanced Automation: Ansible Best Practices

32h