Visão Geral

Curso Ansible For Kubernetes. Este curso prático e aprofundado é projetado para engenheiros de DevOps, administradores de Kubernetes, SREs e arquitetos de nuvem que desejam alavancar o Ansible para automatizar o ciclo de vida completo de seus clusters e aplicações Kubernetes. Do ponto de vista técnico, você aprenderá a usar os módulos dedicados do Ansible para interagir com a API do Kubernetes, permitindo a criação, atualização e exclusão de recursos como Pods, Deployments, Services, ConfigMaps e Secrets. O curso abordará desde o provisionamento de clusters (visão conceitual de como o Ansible se encaixa em ferramentas como kubeadm), passando pela configuração de componentes do cluster, até a implantação e gerenciamento de aplicações complexas, e automação de operações do dia a dia (Day-2 Operations). O foco será em construir Playbooks e Roles robustos e idempotentes para garantir consistência, repetibilidade e escalabilidade em suas operações Kubernetes.

Curso Ansible For Kubernetes, a automação com Ansible para Kubernetes é uma habilidade altamente valorizada que permite às organizações acelerar a implantação de ambientes, padronizar configurações de cluster, garantir a conformidade e reduzir significativamente os erros manuais. Ao centralizar a gestão do Kubernetes no Ansible, as empresas podem implementar práticas de Infrastructure as Code (IaC) de forma mais eficaz, otimizar processos de CI/CD e escalar suas operações de forma mais sustentável. Profissionais com essa expertise são cruciais para equipes que buscam excelência em automação e gerenciamento de infraestrutura de contêineres em ambientes de produção.

Objetivo

Ao final do Curso Ansible For Kubernetes, você será capaz de:

• Compreender os diferentes métodos de integração entre Ansible e Kubernetes.
• Configurar o ambiente Ansible para se comunicar com a API do Kubernetes.
• Utilizar o módulo kubernetes.core.k8s (e outros relevantes) para gerenciar recursos Kubernetes via Playbooks.
• Automatizar a criação, atualização e exclusão de recursos Kubernetes como Namespaces, Deployments, Services, ConfigMaps e Secrets.
• Construir Playbooks e Roles para implantar aplicações completas em múltiplos ambientes Kubernetes.
• Gerenciar o ciclo de vida de nós Kubernetes (join, drain, cordão, uncordão).
• Proteger informações sensíveis ao interagir com o Kubernetes (e.g., senhas em Secrets) usando Ansible Vault.
• Implementar práticas de Infrastructure as Code (IaC) e GitOps com Ansible para Kubernetes.
• Solucionar problemas comuns em Playbooks Ansible que interagem com Kubernetes.

Publico Alvo

• Engenheiros de DevOps: Para automatizar o provisionamento, configuração e implantação em Kubernetes.
• Administradores de Kubernetes: Que buscam ferramentas para gerenciar clusters de forma mais eficiente.
• SREs (Site Reliability Engineers): Para padronizar operações e garantir a confiabilidade de sistemas.
• Arquitetos de Nuvem: Para projetar soluções de automação para infraestrutura conteinerizada.
• Profissionais com experiência em Ansible que desejam aplicá-lo ao ecossistema Kubernetes.

Pre-Requisitos

• Conhecimento sólido de Ansible: Experiência prática com Playbooks, Módulos, Roles, Inventários e Variáveis (ter cursado "Automação de Tarefas com Ansible" ou equivalente).
• Conhecimento sólido de Kubernetes: Compreensão de Pods, Deployments, Services, Namespaces, Ingress, ConfigMaps, Secrets, e familiaridade com kubectl CLI.
• Conhecimento de YAML e JSON.
• Noções básicas de Linux e SSH.

Materiais

Conteúdo Programatico

Módulo 1: Conectando Ansible e Kubernetes (3 horas)

• 1.1. Por que Unir Ansible e Kubernetes?
  • Vantagens da automação para o ciclo de vida do K8s (consistência, idempotência, escala).
  • Casos de uso: Provisionamento, Configuração, Implantação de Aplicações, Day-2 Operations.
• 1.2. Visão Geral da Integração:
  • Ansible controlando Kubernetes via API (sem agentes nos nós ou Pods K8s).
  • O papel do kubeconfig e das credenciais.
• 1.3. Configuração do Ambiente Ansible para Kubernetes:
  • Instalando a coleção kubernetes.core (ansible-galaxy collection install kubernetes.core).
  • Garantindo que o kubeconfig esteja acessível e configurado corretamente.
  • Definindo inventários para o cluster Kubernetes (e.g., localhost ou um nó mestre).
• 1.4. Métodos de Interação Inicial:
  • Executando comandos kubectl via módulos ansible.builtin.command ou ansible.builtin.shell.
  • Limitações e por que usar módulos nativos é preferível.
• Prática:
  • Configurar um ambiente Ansible para interagir com um cluster Kubernetes (Minikube/Kind).
  • Testar a conectividade usando o módulo k8s_info para obter informações do cluster.
  • Executar um comando kubectl via Ansible para listar Pods.

Módulo 2: Gerenciamento de Recursos Kubernetes com Módulos Ansible (6 horas)

• 2.1. O Módulo kubernetes.core.k8s:
  • Sintaxe básica e parâmetros (state, api_version, kind, name, definition).
  • Aplicando manifestos YAML do Kubernetes diretamente através do Ansible.
  • Idempotência e o módulo k8s.
• 2.2. Criação e Gerenciamento de Namespaces:
  • Automatizando a criação e exclusão de Namespaces.
  • Definindo variáveis para nomes de Namespaces.
• 2.3. Gerenciando Deployments:
  • Criando, atualizando e excluindo Deployments.
  • Estratégias de rollout (strategy, min_ready_seconds).
  • Atualizando imagens de contêiner.
• 2.4. Serviços (Services):
  • Criação de ClusterIP, NodePort e LoadBalancer Services.
  • Mapeamento de portas e seletores.
• 2.5. ConfigMaps e Secrets:
  • Criando e gerenciando ConfigMaps para configuração de aplicações.
  • Criando e gerenciando Secrets para dados sensíveis (e a importância de usar Ansible Vault para o conteúdo do Secret).
• Prática:
  • Escrever Playbooks para criar um Namespace, um Deployment simples e um Service.
  • Automatizar a criação de um ConfigMap e um Secret.
  • Atualizar a imagem de um Deployment e observar o rollout.

Módulo 3: Implantação de Aplicações e CI/CD com Ansible (4 horas)

• 3.1. Estrutura de Projeto para Implantação de Aplicações:
  • Organização de Playbooks, Roles e manifestos K8s.
  • Uso de templates Jinja2 para manifestos K8s dinâmicos.
• 3.2. Variáveis de Ambiente e Diferenciação de Ambientes:
  • Gerenciando configurações para diferentes ambientes (dev, staging, prod) usando group_vars e host_vars.
  • Passando variáveis específicas via linha de comando (-e).
• 3.3. Implantação de Aplicações Multi-tier:
  • Orquestrando a implantação de múltiplas partes de uma aplicação (DB, Backend, Frontend).
  • Garantindo a ordem de deploy e dependências.
• 3.4. (Conceitual) Integração com Pipelines CI/CD:
  • Como Ansible se encaixa em ferramentas como Jenkins, GitLab CI/CD, GitHub Actions.
  • Gatilhos para automação de deploy.
• Prática:
  • Criar Roles para implantar uma aplicação de múltiplos componentes (ex: Backend + Frontend).
  • Configurar diferentes variáveis para ambientes "dev" e "prod".
  • Simular um pipeline de deploy.

Módulo 4: Gerenciamento do Ciclo de Vida do Cluster e Day-2 Operations (4 horas)

• 4.1. Gerenciamento de Nós Kubernetes com Ansible:
  • Automatizando o processo de "cordon" e "drain" de nós.
  • Adicionando ou removendo nós de um cluster (visão conceitual, focando na orquestração).
  • Gerenciamento de patches e atualizações de nós.
• 4.2. Automação de Tarefas Administrativas:
  • Gerenciamento de kubeconfig files para diferentes usuários/ferramentas.
  • Executando scripts de manutenção e verificações de saúde.
  • Coletando logs e métricas.
• 4.3. Gerenciamento de StatefulSets e Persistent Volumes:
  • Automatizando a criação e gerenciamento de StatefulSets.
  • Provisionamento de PersistentVolumes e PersistentVolumeClaims.
• 4.4. (Conceitual) Backup e Restauração de Clusters:
  • Estratégias para backup de dados e configuração do etcd.
  • Ferramentas como Velero e como Ansible pode orquestrá-las.
• Prática:
  • Escrever Playbooks para "cordon" e "drain" de um nó.
  • Automatizar a criação de um StatefulSet com PVC.

Módulo 5: Boas Práticas, Troubleshooting e Tópicos Avançados (3 horas)

• 5.1. Boas Práticas de Automação para Kubernetes:
  • Princípios de Idempotência e declaratividade.
  • Versionamento de Playbooks e Roles (Git).
  • Revisão de código e colaboração.
• 5.2. Ansible Vault para Segredos Kubernetes:
  • Criptografando o conteúdo de Secrets antes de aplicar no K8s.
  • Gerenciando chaves do Vault.
• 5.3. Troubleshooting de Playbooks Ansible em K8s:
  • Modo verbose, debug module, --syntax-check, --check (dry run).
  • Verificando logs do Pod, eventos K8s (kubectl describe, kubectl get events).
  • Depurando problemas de permissão da API.
• 5.4. Tópicos Avançados (Visão Geral):
  • Usando Ansible para gerenciar Helm Charts (módulo kubernetes.core.helm).
  • Ansible Operator Pattern (construindo operadores Kubernetes com Ansible).
  • Integração com ferramentas de GitOps (FluxCD, Argo CD) e como Ansible complementa.
• Prática:
  • Realizar um laboratório de troubleshooting para um Playbook com problemas de deploy.
  • Discutir um cenário de integração GitOps e o papel do Ansible.