Curso Microservices With Spring Docker Kubernetes

  • DevOps | CI | CD | Kubernetes | Web3

Curso Microservices With Spring Docker Kubernetes

32 horas
Visão Geral

Curso Microservices With Spring Docker Kubernetes. Este curso intensivo e altamente prático foi desenhado para desenvolvedores Java, arquitetos de software e engenheiros DevOps que buscam dominar a construção, implantação e gerenciamento de microsserviços escaláveis e resilientes utilizando as tecnologias líderes de mercado: Spring Boot para o desenvolvimento da aplicação, Docker para conteinerização e Kubernetes para orquestração. Do ponto de vista técnico, você mergulhará na arquitetura de microsserviços, aprenderá a quebrar monolitos, desenvolver APIs RESTful com Spring Boot, conteinerizar suas aplicações com Docker, e, crucialmente, como orquestrar, escalar e gerenciar esses contêineres em um cluster Kubernetes. Abordaremos tópicos essenciais como descoberta de serviços, gerenciamento de configuração, balanceamento de carga, tolerância a falhas, observability (logging, métricas, tracing) e estratégias de deployment avançadas. O curso será repleto de exemplos práticos, hands-on em um cluster Kubernetes real (ou simulado), e as melhores práticas para construir e operar sistemas distribuídos complexos.

Curso Microservices With Spring Docker Kubernetes, a arquitetura de microsserviços é a espinha dorsal de aplicações modernas, escaláveis e ágeis, sendo fundamental para empresas que operam em ambientes de alta demanda, como e-commerce, serviços financeiros, SaaS e Big Data. Dominar a tríade Spring Boot, Docker e Kubernetes significa que os profissionais são capazes de acelerar o ciclo de vida de desenvolvimento, implantar funcionalidades de forma independente, garantir a alta disponibilidade e escalar a infraestrutura de forma elástica, respondendo rapidamente às necessidades do negócio. Isso se traduz em maior agilidade no mercado, redução de custos operacionais (otimização de recursos), resiliência do sistema e uma base tecnológica robusta para a inovação contínua. Profissionais com essa expertise são altamente demandados e estratégicos, pois são os pilares para a construção de plataformas digitais de próxima geração.

Objetivo

Ao final do Curso Microservices With Spring Docker Kubernetes, você será capaz de:

  • Compreender os princípios e padrões de arquitetura de microsserviços.
  • Desenvolver microsserviços RESTful com Spring Boot, incluindo descoberta de serviços e configuração centralizada.
  • Conteinerizar aplicações Spring Boot com Docker, otimizando imagens.
  • Orquestrar e gerenciar microsserviços em um cluster Kubernetes, utilizando Pods, Deployments, Services, ConfigMaps e Secrets.
  • Implementar balanceamento de carga, resiliência e tolerância a falhas em ambientes Kubernetes.
  • Configurar observabilidade (logging centralizado, métricas e tracing distribuído) para microsserviços.
  • Aplicar estratégias de deployment (Rolling Updates, Canary Deployments) e rollback no Kubernetes.
  • Realizar a migração de um monolito simples para microsserviços (exemplo prático).
  • Implementar melhores práticas para segurança e performance de microsserviços em produção.
Publico Alvo
  • Desenvolvedores Java: Que desejam migrar para arquitetura de microsserviços e trabalhar com conteinerização e orquestração.
  • Arquitetos de Software: Para projetar soluções de microsserviços com Spring, Docker e Kubernetes.
  • Engenheiros DevOps: Responsáveis pela implantação, operação e automação de pipelines de microsserviços.
  • Profissionais de SRE (Site Reliability Engineering): Que buscam aprimorar o gerenciamento de sistemas distribuídos em Kubernetes.
Pre-Requisitos
  • Conhecimento sólido de Java e Spring Boot: Experiência na criação de APIs RESTful básicas com Spring Boot.
  • Noções básicas de HTTP e REST: Métodos, códigos de status.
  • Familiaridade com a linha de comando (terminal): Linux/macOS.
  • Noções básicas de Git: Controle de versão.
  • (Desejável) Noções básicas de Docker.
  • (Desejável) Conhecimento básico de SQL e bancos de dados.
Materiais
Inglês/Português/Lab Prático
Conteúdo Programatico

Módulo 1: Introdução a Microsserviços e Spring Boot Avançado (6 horas)

  • 1.1. Monolito vs. Microsserviços:
    • Vantagens e Desafios da Arquitetura de Microsserviços.
    • Quando e por que adotar microsserviços.
    • Padrões de Comunicação (Síncrona vs. Assíncrona).
  • 1.2. Design de APIs RESTful para Microsserviços:
    • Princípios RESTful e maturidade de Richardson.
    • Versionamento de APIs.
    • Tratamento de Erros Padronizado (Problem Details).
  • 1.3. Desenvolvendo Microsserviços com Spring Boot:
    • Criação de projetos Spring Boot para APIs.
    • Spring Data JPA para persistência de dados.
    • Hands-on: Desenvolver dois microsserviços Spring Boot (ex: Serviço de Produtos e Serviço de Pedidos) com APIs RESTful básicas.
  • 1.4. Descoberta de Serviços (Service Discovery):
    • Por que precisamos de descoberta de serviços em microsserviços.
    • Eureka Server (Spring Cloud Eureka) como Service Registry.
    • Eureka Client para registrar e descobrir serviços.
    • Hands-on: Configurar um Eureka Server e integrar os microsserviços como clientes.
  • 1.5. Configuração Distribuída (Spring Cloud Config):
    • Centralizando a configuração de microsserviços.
    • Spring Cloud Config Server e Client.
    • Integração com Git para armazenamento de configurações.
    • Hands-on: Implementar um Config Server e fazer os microsserviços consumirem configurações centralizadas.
  • Prática: Criar dois microsserviços Spring Boot interconectados. Implementar Service Discovery com Eureka e Configuração Distribuída com Spring Cloud Config.

Módulo 2: Conteinerização com Docker (6 horas)

  • 2.1. Introdução ao Docker:
    • O que são contêineres e por que usá-los.
    • Docker Engine, Docker Images, Docker Containers, Docker Hub.
    • Comandos Docker essenciais (docker run, docker ps, docker build, docker pull).
  • 2.2. Criando Imagens Docker para Aplicações Spring Boot:
    • Dockerfile: Instruções para construir imagens.
    • Melhores práticas para Dockerfiles (multi-stage builds, otimização de camadas, .dockerignore).
    • Expondo portas, volumes.
    • Hands-on: Criar Dockerfiles otimizados para os microsserviços Spring Boot.
  • 2.3. Docker Compose para Ambiente de Desenvolvimento:
    • Orquestrando múltiplos contêineres para desenvolvimento local.
    • Redes no Docker Compose.
    • Hands-on: Montar um docker-compose.yml para rodar o Eureka, Config Server e os dois microsserviços localmente.
  • 2.4. Gerenciamento de Imagens e Volumes:
    • Tags de imagens, push/pull para registry (Docker Hub).
    • Tipos de volumes e persistência de dados.
  • Prática: Conteinerizar os microsserviços. Utilizar Docker Compose para levantar todo o ambiente de desenvolvimento localmente.

Módulo 3: Introdução ao Kubernetes e Deploy de Microsserviços (10 horas)

  • 3.1. Conceitos Fundamentais do Kubernetes:
    • Cluster, Master (Control Plane), Nodes (Workers).
    • kubectl CLI: Comandos básicos.
    • Pods, Deployments, Services, Namespaces.
    • Hands-on: Configurar um cluster local com Minikube/Kind. Explorar os componentes básicos com kubectl.
  • 3.2. Pods: A Menor Unidade de Implantação:
    • Definição de Pods (YAML).
    • Containers em um Pod, compartilhamento de rede e volume.
    • Lifecycle de Pods.
    • Hands-on: Criar e inspecionar Pods simples.
  • 3.3. Deployments: Gerenciando Aplicações Conteinerizadas:
    • Como Deployments gerenciam Pods e ReplicaSets.
    • Estratégias de atualização (Rolling Update).
    • Rollbacks.
    • Hands-on: Criar Deployments para cada microsserviço Spring Boot.
  • 3.4. Services: Expondo Aplicações:
    • Tipos de Service: ClusterIP, NodePort, LoadBalancer, ExternalName.
    • Descoberta de Serviços no Kubernetes (DNS).
    • Hands-on: Expor os microsserviços usando Services (ClusterIP e NodePort/LoadBalancer).
  • 3.5. ConfigMaps e Secrets: Gerenciamento de Configuração e Credenciais:
    • Separando configuração e dados sensíveis do código da imagem.
    • Hands-on: Usar ConfigMaps para configurar os microsserviços e Secrets para credenciais de banco de dados.
  • 3.6. Persistência de Dados em Kubernetes:
    • Persistent Volumes (PV) e Persistent Volume Claims (PVC).
    • Storage Classes (conceitual).
    • Hands-on: Configurar um PVC para um banco de dados em contêiner no cluster Kubernetes.
  • Prática: Implantar o Eureka Server, Config Server e os dois microsserviços no Kubernetes, usando Deployments, Services, ConfigMaps e Secrets. Testar a comunicação entre eles.

Módulo 4: Resiliência, Observabilidade e Escalabilidade em Kubernetes (8 horas)

  • 4.1. Health Checks e Liveness/Readiness Probes:
    • Garantindo a saúde dos contêineres e o tráfego correto.
    • Hands-on: Configurar Liveness e Readiness Probes nos Deployments dos microsserviços.
  • 4.2. Balanceamento de Carga e Ingress:
    • Iniciando com Ingress Controllers (Nginx Ingress como exemplo).
    • Rotas baseadas em host e path.
    • Hands-on: Configurar um Ingress para expor o microsserviço principal ao mundo externo.
  • 4.3. Escalabilidade Automática (Horizontal Pod Autoscaler - HPA):
    • Escalando Pods com base em métricas de CPU/Memória.
    • Hands-on: Configurar um HPA para um dos microsserviços e simular carga para observar o escalonamento.
  • 4.4. Observabilidade em Microsserviços (Logging, Métricas, Tracing):
    • Logging Centralizado: Estratégias (ELK Stack/Loki/Grafana - conceitual).
    • Métricas: Prometheus e Grafana para monitoramento do cluster e das aplicações (com Micrometer/Spring Boot Actuator).
    • Tracing Distribuído: OpenTelemetry/Zipkin/Jaeger (conceitual para entender o problema).
    • Hands-on: Adicionar Spring Boot Actuator e Micrometer para expor métricas dos microsserviços. Configurar um Prometheus e Grafana simples (via Minikube addons ou Docker Compose) para coletar e visualizar métricas.
  • 4.5. Estratégias de Deployment Avançadas:
    • Canary Deployments, Blue/Green Deployments (conceitual e com exemplos de como Kubernetes pode ajudar).
  • Prática: Implementar health checks, balanceamento de carga com Ingress, escalabilidade automática com HPA. Configurar monitoramento básico com Prometheus e Grafana para os microsserviços.

Módulo 5: Segurança, Padrões e Próximos Passos (2 horas)

  • 5.1. Segurança em Kubernetes e Microsserviços:
    • Network Policies (controle de tráfego entre Pods).
    • RBAC (Role-Based Access Control) para autorização de usuários e serviços.
    • Segurança de imagens Docker.
    • Gerenciamento de Secrets.
  • 5.2. Padrões Comuns de Microsserviços:
    • API Gateway (Spring Cloud Gateway).
    • Circuit Breaker (Resilience4j).
    • Saga Pattern (Coreografia vs. Orquestração).
  • 5.3. Integração Contínua/Entrega Contínua (CI/CD) para Microsserviços:
    • Pipelines de build e deploy (conceitual com Jenkins, GitLab CI, GitHub Actions).
    • Automação do processo de build de imagem Docker e deploy para Kubernetes.
  • 5.4. Próximos Passos e Ecossistema:
    • Service Mesh (Istio, Linkerd).
    • Event-Driven Architectures (Kafka, RabbitMQ com microsserviços).
    • Serverless com Kubernetes (Knative).
  • Prática: Discutir e aplicar conceitos de segurança e padrões avançados. Planejar um pipeline CI/CD de alto nível para os microsserviços.
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