Visão Geral

Curso Diving Deep into Kubernetes Networkin: Este curso avançado é projetado para administradores de Kubernetes, engenheiros de DevOps/SRE, arquitetos de nuvem e desenvolvedores seniores que buscam uma compreensão exaustiva do funcionamento da camada de rede no Kubernetes. Do ponto de vista técnico, você explorará as complexidades da rede Kubernetes, desde o modelo de rede fundamental "IP-por-Pod" até as implementações de CNI (Container Network Interface) e as nuances do kube-proxy. O curso cobrirá a comunicação entre Pods dentro e fora do nó, o roteamento de tráfego de serviço, a descoberta de serviços via DNS, a exposição de aplicações externas via Ingress e Load Balancers, e a aplicação de políticas de rede para segurança. O foco será em desmistificar "o que acontece debaixo do capô", aprofundando-se nos componentes Linux subjacentes e fornecendo ferramentas e técnicas avançadas para diagnóstico e solução de problemas de rede em ambientes Kubernetes.

Curso Diving Deep into Kubernetes Networkin, a rede é frequentemente o maior ponto de dor e um gargalo de desempenho em implantações de Kubernetes em larga escala. O domínio da rede Kubernetes permite que as organizações construam infraestruturas mais robustas, seguras e eficientes, reduzam o tempo de inatividade causado por problemas de conectividade, otimizem o desempenho de aplicações e controlem os custos operacionais através de escolhas de CNI e configurações de rede informadas. Profissionais com essa expertise são indispensáveis para garantir a estabilidade, a segurança e a escalabilidade de ambientes Kubernetes críticos para o negócio, transformando desafios de rede em vantagens competitivas.

Objetivo

Ao final do Curso Diving Deep into Kubernetes Networkin, você será capaz de:

• Explicar o modelo de rede do Kubernetes e seus princípios fundamentais (IP-per-Pod, flat network).
• Descrever a função do CNI (Container Network Interface) e comparar diferentes plugins (Calico, Flannel, Cilium).
• Analisar a comunicação de Pod-to-Pod dentro do mesmo nó e entre nós diferentes, detalhando os mecanismos de rede subjacentes.
• Compreender o funcionamento interno do kube-proxy nos modos iptables e IPVS.
• Dominar a descoberta de serviços via DNS (CoreDNS/kube-dns) e o impacto dos diferentes tipos de Serviço (ClusterIP, NodePort, LoadBalancer).
• Configurar e otimizar Ingress e Ingress Controllers para exposição de aplicações externas.
• Implementar e solucionar problemas de Network Policies para segmentação e segurança da rede.
• Utilizar ferramentas e técnicas avançadas de troubleshooting de rede em clusters Kubernetes (e.g., tcpdump, netstat, ip route).
• Discutir considerações de design para redes Kubernetes em larga escala e multi-cluster.

Publico Alvo

• Administradores de Kubernetes: Que precisam otimizar, solucionar problemas e manter a rede de clusters.
• Engenheiros de DevOps/SRE: Para projetar e operar pipelines e aplicações resilientes em Kubernetes.
• Arquitetos de Nuvem: Para tomar decisões informadas sobre o design da rede em clusters Kubernetes.
• Desenvolvedores de Aplicações: Que interagem profundamente com os aspectos de rede de suas aplicações em Kubernetes.
• Qualquer profissional que busca uma compreensão de nível expert sobre as redes do Kubernetes.

Pre-Requisitos

• Conhecimento sólido de Kubernetes: Experiência prática com Deployments, Services, Pods, Namespaces, Ingress, e uso avançado de kubectl. Este é um pré-requisito mandatório.
• Fundamentos de Redes Linux: Compreensão de namespaces de rede, iptables, roteamento IP, interfaces de rede, conceitos de桥接 (bridging).
• Conhecimento básico de TCP/IP, DNS, e Load Balancing.
• Familiaridade com o uso da linha de comando Linux.

Materiais

Conteúdo Programatico

Módulo 1: O Modelo de Rede Kubernetes e Fundamentos (4 horas)

• 1.1. Revisão do Problema:
  • Desafios de rede em ambientes distribuídos e orquestrados.
  • Por que a rede Kubernetes é "diferente" do networking tradicional.
• 1.2. O Modelo de Rede Kubernetes:
  • Princípio "IP-por-Pod": Cada Pod tem seu próprio IP.
  • Rede "Flat": Todos os Pods podem se comunicar sem NAT.
  • Comunicação Pod-to-Pod, Pod-to-Service, External-to-Service.
• 1.3. Componentes-Chave da Rede no Kubernetes:
  • Network Namespaces e vEth Pairs: A base do isolamento de rede no Linux.
  • Container Network Interface (CNI): O padrão para plugabilidade da rede.
  • kube-proxy: O proxy de serviço do Kubernetes (kube-proxy no Data Plane).
• 1.4. kube-proxy em Detalhe:
  • Modos de operação: iptables (regras SNAT/DNAT, Chain traversal).
  • Modos de operação: IPVS (desempenho, escalabilidade, hashing).
  • Comparativo e quando usar cada modo.
• Prática:
  • Inspecionar network namespaces e interfaces vEth dentro de um Pod.
  • Analisar as regras iptables criadas pelo kube-proxy em um nó.
  • (Opcional) Mudar o modo do kube-proxy para IPVS e observar as diferenças.

Módulo 2: Comunicação Pod-to-Pod e CNI Plugins (6 horas)

• 2.1. Comunicação Pod-to-Pod no Mesmo Nó:
  • O papel da bridge Docker/Containerd (cbr0, docker0).
  • Como os pacotes trafegam dentro do nó.
• 2.2. Comunicação Pod-to-Pod entre Nós Diferentes:
  • Overlay Networks (VXLAN, IPIP): Como encapsulam o tráfego.
  • Underlay Networks: Roteamento de pacotes diretamente na rede subjacente (BGP).
• 2.3. CNI Plugins em Detalhe:
  • Calico: Network Policy, IPAM, e roteamento BGP/IPIP.
  • Flannel: Simplicidade e overlay VXLAN.
  • Cilium: eBPF para rede, segurança e observabilidade.
  • Visão geral de outros CNIs (Weave Net, Antrea).
• 2.4. Ciclo de Vida de um Pod do Ponto de Vista da Rede:
  • Como o CNI atribui IPs e configura a rede do Pod.
  • Eventos de rede durante a criação e exclusão de Pods.
• Prática:
  • Implementar um cluster Minikube/Kind com diferentes CNIs (e.g., Flannel, Calico).
  • Realizar um ping entre Pods no mesmo nó e em nós diferentes, e usar tcpdump para capturar o tráfego e observar o encapsulamento (ou roteamento direto).
  • Inspecionar as rotas IP em um nó com diferentes CNIs.

Módulo 3: Serviços e Descoberta de Serviços (4 horas)

• 3.1. Tipos de Serviço Kubernetes:
  • ClusterIP: Serviço interno, como funciona o balanceamento de carga L4.
  • NodePort: Expondo serviços via portas nos nós.
  • LoadBalancer: Integração com Load Balancers de provedores de nuvem.
  • ExternalName: Mapeamento para nomes DNS externos.
• 3.2. Serviço DNS no Kubernetes (CoreDNS/kube-dns):
  • Como o CoreDNS resolve nomes de Pods e Serviços.
  • Registro de A records e SRV records.
  • Configuração de resolv.conf em Pods.
  • Stub domains e upstream servers.
• 3.3. Headless Services e EndpointSlices:
  • Quando usar Headless Services (para StatefulSets, serviço de descoberta customizado).
  • Como EndpointSlices melhoram a escalabilidade.
• 3.4. Fluxo de Pacotes através de um Serviço:
  • Rastreando um pacote de um Pod para um Serviço e para um Pod de destino.
• Prática:
  • Criar diferentes tipos de Serviços e testar sua acessibilidade.
  • Diagnosticar problemas de resolução de DNS em Pods.
  • Criar um Headless Service e observar a descoberta direta de Pods.

Módulo 4: Ingress e Acesso Externo (3 horas)

• 4.1. O Recurso Ingress:
  • Visão geral da API Ingress para roteamento L7.
  • Regras de Ingress (host-based, path-based routing).
• 4.2. Controladores de Ingress:
  • Nginx Ingress Controller: O mais comum, como funciona.
  • HAProxy, Traefik: Breve visão geral.
  • Controladores de Ingress específicos de nuvem (AWS ALB/NLB, Azure Application Gateway, GKE Ingress).
• 4.3. TLS Termination e Gerenciamento de Certificados:
  • Configurando TLS no Ingress.
  • Integração com cert-manager.
• 4.4. Comparativo: NodePort vs. LoadBalancer vs. Ingress.
  • Quando usar cada abordagem para exposição externa.
• Prática:
  • Implantar um Nginx Ingress Controller.
  • Configurar regras de Ingress para roteamento baseado em host e path para uma aplicação.
  • Configurar TLS termination em um Ingress.

Módulo 5: Network Policies e Segurança da Rede (3 horas)

• 5.1. A Necessidade de Network Policies:
  • Por que as redes "flat" necessitam de segmentação.
  • Modelo de segurança de rede "Zero Trust" no Kubernetes.
• 5.2. O Recurso NetworkPolicy:
  • Definição e sintaxe YAML.
  • podSelector, namespaceSelector, ipBlock.
  • Regras de Ingress e Egress.
• 5.3. Implementação e Enforceamento:
  • Como os CNI plugins (e.g., Calico, Cilium, Weave Net) implementam Network Policies.
  • Impacto no tráfego.
• 5.4. Boas Práticas de Network Policy:
  • Isolamento de Namespaces.
  • Políticas padrão "deny all".
  • Gerenciamento de políticas em escala.
• Prática:
  • Implantar um CNI que suporte Network Policies (e.g., Calico).
  • Criar Network Policies para isolar Pods e restringir a comunicação.
  • Testar as políticas e verificar seu funcionamento.

Módulo 6: Tópicos Avançados e Troubleshooting de Rede (4 horas)

• 6.1. Egress Gateways e Saída de Tráfego:
  • Controlando o tráfego de saída do cluster.
  • Limitar IPs de destino, forçar saída por IPs específicos.
• 6.2. Service Mesh e a Camada de Rede (Visão Conceitual):
  • Como Service Mesh (Istio, Linkerd) interage com a rede subjacente do Kubernetes.
  • Envoy Proxy e interceptação de tráfego.
• 6.3. Networking em Cluster Federation/Multi-Cluster (Conceitual):
  • Desafios de rede entre múltiplos clusters.
  • Soluções como Submariner, Project Antrea, KubeFed.
• 6.4. Ferramentas e Técnicas de Troubleshooting de Rede:
  • kubectl exec + ferramentas de rede: netstat, ss, ip route, ping, traceroute, curl, netcat.
  • tcpdump: Captura de pacotes dentro de Pods e nós.
  • kubectl debug (Ephemeral Containers): Para depuração em tempo de execução.
  • Verificando logs de componentes de rede (kube-proxy, CNI daemonset).
  • kube-state-metrics, Prometheus/Grafana: Monitoramento de saúde da rede.
• 6.5. Cenários Comuns de Problemas de Rede e Soluções:
  • Pod não consegue obter IP.
  • Comunicação Pod-to-Pod falha.
  • Serviço não acessível internamente/externamente.
  • Problemas de resolução de DNS.
  • Problemas de desempenho da rede.
• Prática:
  • Realizar um laboratório de troubleshooting guiado para diagnosticar e resolver problemas de rede pré-configurados.
  • Utilizar tcpdump para analisar o tráfego de rede em diferentes cenários.