Visão Geral

Curso Road To Kubernetes. Este curso prático e abrangente é o seu mapa completo para o Kubernetes, ideal para desenvolvedores, engenheiros DevOps, arquitetos de software e profissionais de infraestrutura que desejam não apenas entender, mas dominar a orquestração de contêineres em escala. Se você já trabalha com Docker e sente que está na hora de escalar suas aplicações e gerenciar ambientes complexos, este é o curso certo para você. Do ponto de vista técnico, começaremos revisitando os conceitos essenciais do Docker para garantir uma base sólida, e então faremos a transição gradual para o Kubernetes. Você aprenderá a arquitetura do Kubernetes, como criar e gerenciar Pods, Deployments, Services, ConfigMaps e Secrets. Mergulharemos em tópicos cruciais como estratégias de deployment, escalabilidade (manual e automática), resiliência, e como configurar probes para garantir a saúde das suas aplicações. O curso será intensamente prático, com muitos hands-on em um ambiente Kubernetes local (Minikube ou Kind) e discussões sobre as melhores práticas para operar em produção.

Curso Road To Kubernetes, o Kubernetes é o padrão de fato para a orquestração de contêineres, sendo indispensável para empresas que buscam alta disponibilidade, escalabilidade elástica, resiliência e agilidade na entrega de software. Dominar o Kubernetes significa que você será capaz de reduzir o tempo de inatividade das aplicações, otimizar o uso de recursos de infraestrutura, acelerar o deploy de novas funcionalidades e construir sistemas mais robustos e tolerantes a falhas. Isso se traduz em maior valor para a organização, empregabilidade em alta e a capacidade de trabalhar nas plataformas de nuvem mais modernas. Profissionais com a habilidade de operar e otimizar ambientes Kubernetes são extremamente procurados e valorizados no mercado, impulsionando a inovação e a eficiência.

Objetivo

Ao final do Curso Road to Kubernetes Do Docker à Orquestração de Contêineres, você será capaz de:

• Relembrar e consolidar os fundamentos do Docker (imagens, contêineres, redes, volumes).
• Compreender a arquitetura do Kubernetes e seus componentes principais.
• Utilizar kubectl para interagir com clusters Kubernetes.
• Criar e gerenciar Pods, Deployments e ReplicaSets para suas aplicações.
• Expor aplicações usando Services (ClusterIP, NodePort, LoadBalancer) e Ingress.
• Gerenciar configurações (ConfigMaps) e dados sensíveis (Secrets) no Kubernetes.
• Implementar persistência de dados com Persistent Volumes e Persistent Volume Claims.
• Configurar probes de Liveness e Readiness para garantir a saúde das aplicações.
• Aplicar estratégias de deployment (Rolling Updates) e realizar rollbacks.
• Entender os conceitos básicos de escalabilidade (HPA) e observabilidade no Kubernetes.
• Estar preparado para aprofundar seus conhecimentos em tópicos avançados de Kubernetes.

Publico Alvo

• Desenvolvedores: Que querem implantar e escalar suas aplicações conteinerizadas.
• Engenheiros DevOps e SRE: Responsáveis pela operação, automação e gerenciamento de clusters Kubernetes.
• Administradores de Sistemas e Infraestrutura: Que precisam migrar para ambientes conteinerizados e orquestrados.
• Arquitetos de Software: Para projetar soluções modernas e escaláveis em Kubernetes.
• Qualquer profissional com experiência em Docker que busca dar o próximo passo na orquestração.

Pre-Requisitos

• Conhecimento intermediário de Docker: Experiência na criação de Dockerfiles e uso de docker-compose.yml para aplicações multi-contêiner.
• Noções básicas de linha de comando (terminal): Familiaridade com comandos básicos de sistema operacional.
• Conhecimento básico de YAML: Capacidade de ler e entender arquivos YAML.
• (Desejável) Noções básicas de alguma linguagem de programação (para exemplos de aplicação).

Materiais

Conteúdo Programatico

Módulo 1: Recaptulando Docker e os Desafios de Escala (4 horas)

• 1.1. Revisão Rápida do Docker:
  • Imagens, Contêineres, Dockerfile e docker-compose.yml.
  • Volumes e Redes Docker.
  • Hands-on: Conteinerizar uma aplicação simples multi-serviço (ex: Node.js API + MongoDB) usando docker-compose.yml.
• 1.2. Limitações do Docker Isolado para Produção:
  • Gerenciamento de múltiplos contêineres em múltiplos hosts.
  • Alta disponibilidade e auto-cura.
  • Escalabilidade, balanceamento de carga e descoberta de serviços.
  • Atualizações e rollbacks.
• 1.3. O Que é Orquestração de Contêineres?
  • Por que precisamos de orquestradores (Kubernetes, Docker Swarm, Nomad).
  • Visão geral das capacidades de um orquestrador.
• 1.4. Introdução ao Kubernetes:
  • História, filosofia e ecossistema.
  • Por que Kubernetes se tornou o padrão de mercado.
  • Hands-on: Instalar e configurar Minikube (ou Kind) e o kubectl CLI. Testar a instalação com kubectl cluster-info.
• Prática: Criar um projeto Docker Compose para uma aplicação multi-serviço. Levantar um cluster Kubernetes local e verificar seus componentes básicos.

Módulo 2: Arquitetura do Kubernetes e Primeiras Implementações (6 horas)

• 2.1. Arquitetura do Kubernetes: Master e Workers:
  • Control Plane (Master Node): Kube-apiserver, Kube-scheduler, Kube-controller-manager, etcd.
  • Worker Nodes: Kubelet, Kube-proxy, Container Runtime (Docker, containerd).
  • Hands-on: Usar kubectl get nodes e kubectl describe node para inspecionar o cluster.
• 2.2. O kubectl CLI: Seu Principal Ferramenta:
  • Comandos essenciais: get, describe, apply, delete, logs, exec.
  • Formatos de saída (-o yaml, -o json, -w).
  • Hands-on: Praticar os comandos básicos de kubectl.
• 2.3. Namespaces: Organização Lógica do Cluster:
  • Como Namespaces ajudam a organizar recursos e isolar ambientes.
  • Hands-on: Criar e alternar entre Namespaces.
• 2.4. Pods: A Menor Unidade de Implantação no Kubernetes:
  • O que é um Pod e por que não rodamos contêineres diretamente.
  • Múltiplos contêineres em um Pod (sidecar pattern).
  • Ciclo de vida de um Pod.
  • Hands-on: Criar um Pod simples com uma imagem Docker (ex: nginx).
• 2.5. Deployments: Gerenciando Pods em Escala:
  • O papel dos Deployments para gerenciar ReplicaSets e Pods.
  • Estratégias de deployment padrão: RollingUpdate.
  • Hands-on: Criar um Deployment para a aplicação de exemplo, escalando para múltiplos Pods.
• Prática: Explorar a arquitetura do Kubernetes. Implantar sua primeira aplicação no cluster usando Pods e Deployments.

Módulo 3: Expondo Aplicações e Gerenciando Configurações (6 horas)

• 3.1. Services: Expondo Aplicações no Cluster e Externamente:
  • O problema de acesso a Pods efêmeros.
  • Tipos de Services:
    • ClusterIP: Acesso interno ao cluster.
    • NodePort: Expondo uma porta em cada Node.
    • LoadBalancer: Integrando com Load Balancers de provedores de nuvem.
  • Hands-on: Criar Services de diferentes tipos para acessar a aplicação.
• 3.2. Ingress: Roteamento de Tráfego HTTP/HTTPS:
  • O que é Ingress e o papel do Ingress Controller.
  • Regras de roteamento baseadas em host e path.
  • Hands-on: Instalar um Ingress Controller (ex: Nginx Ingress Controller no Minikube) e criar uma regra Ingress para a aplicação.
• 3.3. ConfigMaps: Gerenciando Configurações Não-Sensíveis:
  • Separando configurações do código da imagem do contêiner.
  • Como injetar ConfigMaps como variáveis de ambiente ou arquivos.
  • Hands-on: Criar um ConfigMap para a aplicação e usá-lo para alterar o comportamento sem reconstruir a imagem.
• 3.4. Secrets: Gerenciando Dados Sensíveis:
  • Como armazenar credenciais, chaves de API e outros dados sensíveis.
  • Injetando Secrets como variáveis de ambiente ou volumes.
  • Hands-on: Criar um Secret para as credenciais do banco de dados e usá-lo na aplicação.
• Prática: Expor a aplicação usando Services e Ingress. Gerenciar configurações e credenciais de forma segura com ConfigMaps e Secrets.

Módulo 4: Persistência, Resiliência e Escalabilidade (6 horas)

• 4.1. Persistência de Dados no Kubernetes:
  • Desafios da persistência em contêineres.
  • PersistentVolume (PV): Recurso de armazenamento provisionado.
  • PersistentVolumeClaim (PVC): Requisição de armazenamento pelos Pods.
  • StorageClasses (conceitual).
  • Hands-on: Configurar um banco de dados (ex: MongoDB) em um contêiner com persistência de dados usando PV/PVC.
• 4.2. Health Checks: Liveness e Readiness Probes:
  • Liveness Probe: Reiniciar contêineres com falha.
  • Readiness Probe: Controlar o tráfego para contêineres prontos.
  • Hands-on: Adicionar Liveness e Readiness Probes aos Deployments da aplicação.
• 4.3. Resource Requests e Limits:
  • Definindo solicitações e limites de CPU e memória para Pods.
  • Impacto na alocação de recursos e na estabilidade do cluster.
  • Hands-on: Configurar Requests e Limits nos Deployments.
• 4.4. Escalabilidade de Aplicações:
  • Escalabilidade Manual (kubectl scale).
  • Horizontal Pod Autoscaler (HPA): Escalabilidade automática baseada em métricas de CPU/Memória.
  • Hands-on: Configurar um HPA e testar o escalonamento da aplicação sob carga.
• Prática: Configurar persistência para um banco de dados. Implementar health checks para garantir a disponibilidade. Aplicar estratégias de escalabilidade manual e automática.

Módulo 5: Estratégias de Deployment e Próximos Passos (2 horas)

• 5.1. Atualização e Rollback de Deployments:
  • Rolling Update: Como o Kubernetes gerencia atualizações sem interrupção.
  • kubectl rollout status, kubectl rollout undo.
  • Hands-on: Realizar uma atualização da aplicação e um rollback para uma versão anterior.
• 5.2. Introdução a Estratégias de Deployment Avançadas (Conceitual):
  • Canary Deployments: Lançamento gradual para um subconjunto de usuários.
  • Blue/Green Deployments: Dois ambientes idênticos para troca rápida.
  • Hands-on: Discutir a implementação dessas estratégias com Kubernetes.
• 5.3. Observabilidade em Kubernetes (Conceitual):
  • Logging Centralizado (Fluentd, ELK Stack, Grafana Loki).
  • Métricas (Prometheus, Grafana).
  • Tracing Distribuído (Jaeger, Zipkin).
• 5.4. Próximos Passos na Jornada Kubernetes:
  • Helm Charts para gerenciamento de pacotes.
  • Service Meshes (Istio, Linkerd).
  • Operators e CRDs (Custom Resource Definitions).
  • Kubernetes em produção (Cloud Providers).
• Prática: Executar um rolling update e um rollback. Debater as próximas etapas no aprendizado de Kubernetes.