# Kubernetes (K8s) — Resumo Completo para Concursos

---

## 1. O que é Kubernetes

**Kubernetes** (K8s) é uma plataforma de **orquestração de contêineres** open-source, originalmente desenvolvida pelo Google e atualmente mantida pela **CNCF (Cloud Native Computing Foundation)**. Seu objetivo é automatizar o **deploy, escalonamento e gerenciamento** de aplicações em contêineres.

> **"K8s"** = abreviação de Kubernetes (8 letras entre K e s).

### Por que Kubernetes existe?

O Docker resolve o problema de empacotar e rodar contêineres individualmente. Kubernetes resolve o problema de gerenciar **centenas ou milhares de contêineres** em múltiplos servidores (hosts), garantindo:

- Alta disponibilidade (HA)
- Escalonamento automático
- Autorrecuperação (self-healing)
- Balanceamento de carga
- Rollouts e rollbacks controlados

---

## 2. Arquitetura do Kubernetes

O Kubernetes segue o modelo **Control Plane + Worker Nodes**.

┌─────────────────────────────────────────────────────┐
│                   CONTROL PLANE                      │
│  ┌──────────────┐  ┌──────────┐  ┌───────────────┐  │
│  │  API Server  │  │ etcd     │  │  Scheduler    │  │
│  └──────────────┘  └──────────┘  └───────────────┘  │
│  ┌──────────────────────────────────────────────┐    │
│  │         Controller Manager                   │    │
│  └──────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────┘
         │                    │
┌────────▼──────┐    ┌────────▼──────┐
│  WORKER NODE  │    │  WORKER NODE  │
│  ┌──────────┐ │    │  ┌──────────┐ │
│  │ kubelet  │ │    │  │ kubelet  │ │
│  ├──────────┤ │    │  ├──────────┤ │
│  │kube-proxy│ │    │  │kube-proxy│ │
│  ├──────────┤ │    │  ├──────────┤ │
│  │  Pod     │ │    │  │  Pod     │ │
│  │  Pod     │ │    │  │  Pod     │ │
│  └──────────┘ │    │  └──────────┘ │
└───────────────┘    └───────────────┘

---

## 3. Componentes do Control Plane

| Componente | Função |
|---|---|
| **kube-apiserver** | Ponto central de comunicação. Toda interação com o cluster passa por ele (REST API). É o único componente que se comunica com o etcd. |
| **etcd** | Banco de dados chave-valor distribuído. Armazena **todo o estado do cluster** (configurações, pods, secrets, etc.). Componente crítico — sua perda significa perda do cluster. |
| **kube-scheduler** | Decide em qual Node um Pod será executado, com base em recursos disponíveis, afinidades e restrições. |
| **kube-controller-manager** | Executa os controladores que monitoram o estado do cluster e tomam ações corretivas (ex.: recriar pods que falharam). |
| **cloud-controller-manager** | Integra o cluster com APIs de provedores de nuvem (AWS, GCP, Azure). Gerencia load balancers, volumes e nós na nuvem. |

---

## 4. Componentes dos Worker Nodes

| Componente | Função |
|---|---|
| **kubelet** | Agente que roda em cada Node. Garante que os contêineres definidos nos Pods estejam em execução e saudáveis. Comunica-se com o API Server. |
| **kube-proxy** | Mantém as regras de rede no Node. Permite a comunicação de rede para os Pods (implementa o conceito de Service). |
| **Container Runtime** | Software que executa os contêineres (ex.: containerd, CRI-O, Docker). O K8s usa a interface **CRI (Container Runtime Interface)**. |

---

## 5. Objetos Fundamentais do Kubernetes

### 5.1 Pod

- **Menor unidade do Kubernetes.**
- Agrupa um ou mais contêineres que compartilham rede e armazenamento.
- Cada Pod tem um **IP único** dentro do cluster.
- Pods são **efêmeros** — quando morrem, não ressuscitam sozinhos (para isso existem os controllers).
- Contêineres dentro de um mesmo Pod se comunicam via `localhost`.

apiVersion: v1
kind: Pod
metadata:
  name: meu-pod
spec:
  containers:
    - name: nginx
      image: nginx:1.25
      ports:
        - containerPort: 80

### 5.2 ReplicaSet

- Garante que um número específico de réplicas de um Pod esteja sempre em execução.
- Se um Pod falha, o ReplicaSet cria um novo automaticamente (**self-healing**).
- Raramente usado diretamente — geralmente gerenciado pelo Deployment.

### 5.3 Deployment

- **Objeto mais usado no dia a dia.**
- Gerencia ReplicaSets e permite **atualizações declarativas** de aplicações.
- Suporta **rolling update** (atualização gradual) e **rollback**.
- Estratégias de deploy: `RollingUpdate` (padrão) e `Recreate`.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: meu-deploy
spec:
  replicas: 3
  selector:
    matchLabels:
      app: minha-app
  template:
    metadata:
      labels:
        app: minha-app
    spec:
      containers:
        - name: nginx
          image: nginx:1.25

### 5.4 Service

- Expõe um conjunto de Pods como um **endpoint de rede estável**.
- Os Pods têm IPs dinâmicos; o Service fornece um IP/DNS fixo.
- Usa **seletores de labels** para encontrar os Pods.

**Tipos de Service:**

| Tipo | Descrição |
|---|---|
| **ClusterIP** (padrão) | Expõe o serviço apenas **dentro do cluster**. IP interno. |
| **NodePort** | Expõe o serviço em uma porta estática em **cada Node** (30000–32767). Acesso externo possível. |
| **LoadBalancer** | Cria um load balancer externo (em ambientes de nuvem). Acesso externo com IP público. |
| **ExternalName** | Mapeia o Service para um nome DNS externo (CNAME). |

### 5.5 Namespace

- Mecanismo de **isolamento lógico** dentro do cluster.
- Permite dividir um cluster entre múltiplas equipes/projetos.
- Namespaces padrão: `default`, `kube-system`, `kube-public`, `kube-node-lease`.
- Recursos como Nodes e PersistentVolumes são **globais** (não pertencem a um namespace).

### 5.6 ConfigMap

- Armazena dados de configuração **não sensíveis** em pares chave-valor.
- Desacopla configuração da imagem do contêiner.
- Pode ser montado como variável de ambiente ou arquivo.

### 5.7 Secret

- Armazena dados **sensíveis** (senhas, tokens, chaves) codificados em **Base64**.
- Atenção: Base64 **não é criptografia** — Secrets precisam de criptografia adicional em repouso para segurança real.
- Tipos comuns: `Opaque`, `kubernetes.io/tls`, `kubernetes.io/dockerconfigjson`.

### 5.8 PersistentVolume (PV) e PersistentVolumeClaim (PVC)

- **PV:** recurso de armazenamento provisionado no cluster (NFS, EBS, disco local, etc.).
- **PVC:** solicitação de armazenamento feita por um Pod. O K8s faz o binding entre PVC e PV.
- **StorageClass:** permite provisionamento dinâmico de volumes.

---

## 6. Objetos Avançados

### 6.1 StatefulSet

- Para aplicações com **estado** (bancos de dados, filas, Kafka, etc.).
- Garante **identidade estável** para cada Pod (nome fixo: `pod-0`, `pod-1`, ...).
- Volumes persistentes por Pod, que não são deletados quando o Pod é removido.
- Pods são criados e deletados em **ordem**.

### 6.2 DaemonSet

- Garante que **todos os Nodes** (ou um subconjunto) executem uma cópia de um Pod.
- Usado para agentes de monitoramento, coletores de logs, proxies de rede.
- Exemplos: Fluentd, Prometheus Node Exporter, kube-proxy.

### 6.3 Job e CronJob

- **Job:** executa uma tarefa até a conclusão (não fica em loop). Útil para processamento em batch.
- **CronJob:** agenda Jobs para execução periódica (sintaxe cron). Ex.: `"0 3 * * *"` = todo dia às 3h.

### 6.4 Ingress

- Gerencia o **acesso HTTP/HTTPS externo** aos Services dentro do cluster.
- Funciona como um roteador de camada 7 (baseado em host ou caminho URL).
- Requer um **Ingress Controller** instalado (ex.: NGINX Ingress Controller, Traefik).

Usuário → Ingress → /api   → Service A
                 → /web   → Service B
                 → /admin → Service C

### 6.5 HorizontalPodAutoscaler (HPA)

- Escala automaticamente o número de réplicas de um Deployment/ReplicaSet com base em métricas (CPU, memória, métricas customizadas).

### 6.6 ResourceQuota e LimitRange

- **ResourceQuota:** limita o total de recursos consumidos por um namespace.
- **LimitRange:** define limites padrão e máximos por container/Pod dentro de um namespace.

---

## 7. Rede no Kubernetes

- Cada Pod recebe um **IP único e roteável** dentro do cluster.
- Contêineres no mesmo Pod se comunicam via `localhost`.
- Pods de Nodes diferentes se comunicam diretamente (sem NAT) — modelo **flat network**.
- A rede é implementada por **plugins CNI** (Container Network Interface): Calico, Flannel, Cilium, Weave.

### NetworkPolicy

- Define regras de firewall para o tráfego entre Pods.
- Por padrão, todos os Pods podem se comunicar livremente.
- Com NetworkPolicy, é possível restringir tráfego de entrada (ingress) e saída (egress).

---

## 8. Agendamento (Scheduling)

O Scheduler decide onde cada Pod vai rodar com base em:

| Mecanismo | Descrição |
|---|---|
| **nodeSelector** | Seleciona Nodes por label. Forma mais simples. |
| **Node Affinity** | Versão avançada do nodeSelector, com operadores (`In`, `NotIn`, etc.). |
| **Pod Affinity / Anti-Affinity** | Coloca Pods próximos ou separados de outros Pods. |
| **Taints e Tolerations** | Nodes "repelem" Pods por padrão (taint); Pods com toleration passam pelo filtro. |
| **Resource Requests/Limits** | `requests` = mínimo garantido; `limits` = máximo permitido. Influencia o scheduling. |

---

## 9. Comandos kubectl Essenciais

# Contexto e cluster
kubectl config get-contexts          # Lista contextos
kubectl config use-context <nome>    # Troca de contexto

# Pods
kubectl get pods                     # Lista pods no namespace default
kubectl get pods -n kube-system      # Lista pods em namespace específico
kubectl get pods -o wide             # Mostra IPs e Nodes
kubectl describe pod <nome>          # Detalhes do pod
kubectl logs <pod>                   # Logs do pod
kubectl exec -it <pod> -- bash       # Acessa terminal do pod
kubectl delete pod <nome>            # Deleta pod

# Deployments
kubectl get deployments
kubectl apply -f deployment.yaml     # Aplica manifesto (cria ou atualiza)
kubectl rollout status deployment/<nome>
kubectl rollout undo deployment/<nome>    # Rollback
kubectl scale deployment/<nome> --replicas=5

# Services
kubectl get services
kubectl expose deployment/<nome> --port=80 --type=ClusterIP

# Geral
kubectl get all                      # Lista todos os recursos principais
kubectl get nodes                    # Lista nodes do cluster
kubectl top pods                     # Uso de CPU/memória (requer metrics-server)
kubectl top nodes
kubectl delete -f arquivo.yaml       # Remove recursos pelo manifesto

---

## 10. Labels, Selectors e Annotations

- **Labels:** pares chave-valor anexados a objetos. Usados para seleção e organização. Ex.: `app: frontend`, `env: prod`.
- **Selectors:** filtram objetos por labels. Usados por Services, Deployments, etc.
- **Annotations:** metadados adicionais **não usados para seleção**. Usados para informações descritivas (ex.: versão de build, contato do time).

---

## 11. Ciclo de Vida de um Pod

| Fase | Descrição |
|---|---|
| `Pending` | Pod aceito pelo cluster, aguardando ser agendado ou baixar imagens. |
| `Running` | Pod agendado em um Node, pelo menos um contêiner em execução. |
| `Succeeded` | Todos os contêineres terminaram com sucesso (código 0). |
| `Failed` | Pelo menos um contêiner terminou com falha. |
| `Unknown` | Estado do Pod não pode ser determinado (geralmente problema de rede com o Node). |

### Probes (verificações de saúde)

| Probe | Função |
|---|---|
| **livenessProbe** | Verifica se o contêiner está vivo. Se falhar, reinicia o contêiner. |
| **readinessProbe** | Verifica se o contêiner está pronto para receber tráfego. Se falhar, remove o Pod do Service. |
| **startupProbe** | Verifica se a aplicação iniciou. Útil para apps lentas na inicialização. |

---

## 12. RBAC — Controle de Acesso

**RBAC (Role-Based Access Control)** controla quem pode fazer o quê no cluster.

| Objeto | Descrição |
|---|---|
| **Role** | Define permissões dentro de um **namespace**. |
| **ClusterRole** | Define permissões em **todo o cluster** (ou recursos globais). |
| **RoleBinding** | Vincula um Role a um usuário/grupo/ServiceAccount em um namespace. |
| **ClusterRoleBinding** | Vincula um ClusterRole a um usuário/grupo no cluster inteiro. |
| **ServiceAccount** | Identidade para **processos** dentro de Pods (não para usuários humanos). |

---

## 13. Helm — Gerenciador de Pacotes do Kubernetes

- **Helm** é o gerenciador de pacotes do K8s (análogo ao apt/yum).
- Pacotes são chamados de **Charts**.
- Um Chart é um conjunto de templates YAML que geram manifestos do K8s.
- **Helm Hub / Artifact Hub:** repositório público de charts.

helm install minha-release bitnami/nginx    # Instala um chart
helm upgrade minha-release bitnami/nginx    # Atualiza
helm rollback minha-release 1               # Rollback para revisão 1
helm uninstall minha-release                # Remove
helm list                                   # Lista releases instaladas

---

## 14. Estratégias de Deploy

| Estratégia | Descrição |
|---|---|
| **RollingUpdate** (padrão) | Substitui Pods gradualmente. Zero downtime. Controla `maxSurge` e `maxUnavailable`. |
| **Recreate** | Mata todos os Pods antes de criar os novos. Causa downtime. |
| **Blue/Green** | Mantém duas versões simultaneamente; troca o tráfego de uma vez (via Service). |
| **Canary** | Envia uma fração do tráfego para a nova versão antes do rollout completo. |

---

## 15. Ferramentas do Ecossistema

| Ferramenta | Função |
|---|---|
| **Minikube** | Cluster K8s local para desenvolvimento/testes (single node). |
| **kind** | Kubernetes in Docker — clusters locais com múltiplos nodes via Docker. |
| **k3s** | Distribuição leve do K8s para edge computing e IoT (Rancher/SUSE). |
| **Lens / OpenLens** | IDE visual para gerenciar clusters Kubernetes. |
| **Prometheus + Grafana** | Stack padrão de monitoramento para K8s. |
| **Istio / Linkerd** | Service Mesh — gerencia comunicação, segurança e observabilidade entre serviços. |
| **ArgoCD / Flux** | GitOps — sincroniza o estado do cluster com um repositório Git. |

---

## 16. Comparação: Docker vs Kubernetes

| Aspecto | Docker (isolado) | Kubernetes |
|---|---|---|
| Escopo | Único host | Multi-host (cluster) |
| Orquestração | Docker Compose (básico) | Nativa e avançada |
| Self-healing | Não | Sim |
| Escalonamento automático | Não | Sim (HPA/VPA) |
| Balanceamento de carga | Manual | Automático (Services) |
| Complexidade | Baixa | Alta |
| Uso típico | Dev/teste local | Produção em escala |

---

## 17. Pontos que Mais Caem em Concursos

- Kubernetes é um **orquestrador de contêineres**, não um runtime de contêineres.
- **etcd** armazena o estado do cluster — é o componente mais crítico para backup.
- **kube-apiserver** é o único componente que acessa o etcd diretamente.
- **kubelet** roda em cada Node e é responsável por manter os Pods rodando.
- **Pod** é a menor unidade implantável do K8s (não o contêiner).
- **Service do tipo ClusterIP** só é acessível dentro do cluster.
- **NodePort** expõe o serviço em uma porta entre 30000 e 32767.
- **LoadBalancer** requer suporte de um provedor de nuvem.
- **Ingress** requer um **Ingress Controller** instalado — não funciona sozinho.
- **StatefulSet** para apps com estado; **Deployment** para apps sem estado (stateless).
- **DaemonSet** garante um Pod em cada Node do cluster.
- **ConfigMap** para configurações; **Secret** para dados sensíveis (em Base64).
- **Secret não é criptografado por padrão** — apenas codificado em Base64.
- **RBAC**: Role e RoleBinding são namespaced; ClusterRole e ClusterRoleBinding são globais.
- **livenessProbe** reinicia o contêiner; **readinessProbe** controla o tráfego do Service.
- Kubernetes foi originalmente criado pelo **Google** e doado à **CNCF** em 2016.
- A sigla K8s vem das 8 letras entre o **K** e o **s** de Kubernetes.

## Extra

Requests (Solicitações): É a garantia mínima. O Scheduler (escalonador) do Kubernetes usa esse valor para decidir em qual Nó (Node) o Pod vai rodar. Se um Pod "solicita" 2GB de RAM, o Kubernetes só o colocará em um servidor que tenha, no mínimo, 2GB livres.

Limits (Limites): É o teto máximo. Uma vez rodando, se o contêiner tentar usar mais CPU do que o limite, ele será estrangulado (throttled). Se tentar usar mais Memória do que o limite, ele será morto pelo sistema.