Kubernetes (K8s) — Do Zero ao Deploy em Minutos ·

Table of Contents

TL;DR: Kubernetes (K8s) é um orquestrador de contêineres que automatiza deploy, escala e gerenciamento de aplicativos containerizados. Este guia traz visão geral, arquitetura, YAMLs prontos, comandos do dia a dia e um mini-projeto para você subir um serviço web com Ingress em minutos.

O que é Kubernetes?
#

Kubernetes é uma plataforma open source para orquestrar contêineres (geralmente Docker) em clusters. Ele cuida de:

Escalonamento automático (HPA, VPA, Cluster Autoscaler)
Alta disponibilidade e autorrecuperação (ReplicaSet, probes)
Deploys previsíveis (rolling update, canary/blue‑green)
Rede, DNS interno e balanceamento (Services/Ingress)
Configuração e segredos (ConfigMaps/Secrets)
Armazenamento persistente (PV/PVC/StorageClass)

Arquitetura (Visão Rápida)
#

Plano de Controle (Control Plane):

kube-apiserver: porta de entrada para toda interação com o cluster.
etcd: banco de dados chave‑valor que guarda o estado do cluster.
scheduler: decide em qual nó um Pod deve rodar.
controller-manager / cloud-controller-manager: reconcilia estado desejado vs. atual; integra com provedores de nuvem.

Nós de Trabalho (Workers):

kubelet: agente do nó; garante que os Pods estão rodando.
kube-proxy: regras de rede e load balancing por Service.
Container runtime: ex. containerd.

Objetos Fundamentais
#

Pod: menor unidade implantável (um ou mais contêineres).
ReplicaSet/Deployment: réplicas + estratégia de atualização.
StatefulSet: estado estável/identidade fixa (bancos, filas, etc.).
DaemonSet: um Pod por nó (ex.: agentes de log/monitoramento).
Job/CronJob: tarefas pontuais ou agendadas.
Service: expõe um conjunto de Pods (ClusterIP/NodePort/LoadBalancer).
Ingress: roteamento HTTP/HTTPS externo para Services.
ConfigMap/Secret: configuração e credenciais.
Namespace/RBAC: isolamento lógico e permissões.
PV/PVC/StorageClass: armazenamento persistente e provisionamento dinâmico.

Mão na massa: subindo um app web
#

Abaixo, um app NGINX com Deployment, Service e Ingress.

Pré‑requisitos locais: kubectl + um cluster (ex.: minikube ou kind) e um Ingress Controller (no minikube: minikube addons enable ingress).

1) Deployment + Service (arquivo `deploy.yaml`)
#

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-deploy
  labels:
    app: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:1.27-alpine
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: "100m"
              memory: "64Mi"
            limits:
              cpu: "250m"
              memory: "128Mi"
          readinessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 5
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 15
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: web-svc
spec:
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: ClusterIP

2) Ingress (arquivo `ingress.yaml`)
#

Para clusters locais, use o addon do minikube ou instale NGINX Ingress Controller.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
    - host: web.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web-svc
                port:
                  number: 80

3) Aplicando e testando
#

kubectl apply -f deploy.yaml
kubectl apply -f ingress.yaml
kubectl get pods -w
kubectl get svc,ingress

Minikube:

minikube addons enable ingress
# Mapear host local
echo "$(minikube ip)  web.local" | sudo tee -a /etc/hosts
# Teste
curl -I http://web.local

kind:

Crie o cluster com portas mapeadas (ex.: 80/443) e instale um ingress controller (NGINX). Consulte o manifesto do projeto do ingress‑nginx.

Configuração e Segredos
#

ConfigMap + Secret (exemplo)
#

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_MESSAGE: "Hello from ConfigMap"
---
apiVersion: v1
kind: Secret
metadata:
  name: app-secret
type: Opaque
stringData:
  DB_PASSWORD: supersecreta

Uso no Pod (trecho de Deployment):

    spec:
      containers:
        - name: app
          image: nginx:1.27-alpine
          env:
            - name: APP_MESSAGE
              valueFrom:
                configMapKeyRef:
                  name: app-config
                  key: APP_MESSAGE
            - name: DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: app-secret
                  key: DB_PASSWORD

Armazenamento Persistente
#

PVC genérico (StorageClass padrão)
#

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 1Gi

Uso no Pod:

      volumes:
        - name: data
          persistentVolumeClaim:
            claimName: data-pvc
      containers:
        - name: app
          volumeMounts:
            - name: data
              mountPath: /var/lib/data

Dica: em nuvem, use StorageClass do provedor (EBS/GCE PD/Azure Disk). Em local, o minikube já oferece uma classe padrão.

Autoscaling
#

Horizontal Pod Autoscaler (HPA)
#

Requer metrics-server instalado.

kubectl autoscale deployment web-deploy --cpu-percent=70 --min=3 --max=10
kubectl get hpa

VPA (Vertical) e Cluster Autoscaler (nós) complementam o HPA.

Estratégias de Deploy
#

RollingUpdate (padrão): atualiza gradualmente, com maxSurge/maxUnavailable.
Recreate: derruba tudo e sobe a nova versão (downtime).
Blue/Green / Canary: roteamento gradual via Ingress/Service + labels/seletores.

Ex.: Ajuste de estratégia no Deployment (já incluído acima):

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxSurge: 1
    maxUnavailable: 0

Observabilidade & Debug (Cheat Sheet)
#

# Explorar recursos
kubectl get nodes
kubectl get ns
kubectl get all -n default

# Descrever e inspecionar
kubectl describe pod <pod>
kubectl logs <pod>            # logs do contêiner principal
kubectl logs -f <pod> -c <container>

# Acesso a um Pod
kubectl exec -it <pod> -- sh
kubectl port-forward svc/web-svc 8080:80

# Deploys e rollouts
kubectl rollout status deploy/web-deploy
kubectl rollout history deploy/web-deploy
kubectl rollout undo deploy/web-deploy

# Aplicar/Validar YAML
kubectl apply -f arquivo.yaml
kubectl diff -f arquivo.yaml
kubectl delete -f arquivo.yaml

Segurança (Boas Práticas)
#

RBAC mínimo necessário; use ServiceAccount específico por app.
Namespaces por time/produto para isolamento + ResourceQuota/LimitRange.
Requests/Limits sempre definidos para cada contêiner.
Secrets para credenciais; evite segredos em ConfigMap/envs em claro.
NetworkPolicies para restringir tráfego L3/L4 entre Pods.
PSA/PSS (Pod Security Standards) para políticas de execução mais rígidas.
Imagens confiáveis e scan (Trivy/Grype) + pull sempre com digest quando possível.

Checklist de Produção
#

Ingress com TLS (LetsEncrypt/ACME) + redirecionamento HTTP→HTTPS
metrics-server + HPA
Logs centralizados (Loki/ELK) e métricas (Prometheus/Grafana)
Backups de etcd e volumes
Alertas (Alertmanager) e dashboards
Políticas: NetworkPolicy, RBAC, PSS
Cotas por namespace; requests/limits revisados
CI/CD com manifests versionados (Kustomize/Helm/GitOps)

Erros Comuns e Soluções
#

Pods em CrashLoopBackOff: ver kubectl logs e probes (talvez initialDelaySeconds curto).
ImagePullBackOff: ver nome/tag/registry/credenciais (imagePullSecret).
Service não responde: conferir selector e labels do Pod; portas corretas.
Ingress 404: regra/host errados ou Ingress Controller não instalado.
Sem métricas no HPA: instalar/configurar metrics-server.

Próximos Passos
#

Converter os YAMLs em Helm charts ou Kustomize.
Adicionar canary via Ingress + peso de tráfego.
Criar pipelines CI/CD com validação (lint), kubectl diff e deploy automático.

Referências úteis: Documentação oficial do Kubernetes; projetos ingress‑nginx, metrics‑server, Prometheus, Grafana, Loki, Kustomize e Helm.

Apêndice — Criando um cluster local rapidamente
#

minikube:

minikube start --driver=docker
minikube addons enable ingress

kind: (exemplo de config mínima kind-config.yaml)

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    kubeadmConfigPatches:
      - |
        kind: ClusterConfiguration
        apiServer:
          extraArgs:
            enable-admission-plugins: NodeRestriction
    extraPortMappings:
      - containerPort: 80
        hostPort: 80
        protocol: TCP
      - containerPort: 443
        hostPort: 443
        protocol: TCP

kind create cluster --name k8s-lab --config kind-config.yaml
# instalar o NGINX Ingress Controller conforme documentação do projeto

Nota final: Este post foi escrito para o tema Hugo Relearn. Seções, TOC e navegação lateral são geradas automaticamente pelo tema. Caso seu Hugo esteja desatualizado, atualize para uma versão ≥ 0.126.3 para evitar avisos de compatibilidade.

O que é Kubernetes?#

Arquitetura (Visão Rápida)#

Objetos Fundamentais#

Mão na massa: subindo um app web#

1) Deployment + Service (arquivo deploy.yaml)#

2) Ingress (arquivo ingress.yaml)#

3) Aplicando e testando#

Configuração e Segredos#

ConfigMap + Secret (exemplo)#

Armazenamento Persistente#

PVC genérico (StorageClass padrão)#

Autoscaling#

Horizontal Pod Autoscaler (HPA)#

Estratégias de Deploy#

Observabilidade & Debug (Cheat Sheet)#

Segurança (Boas Práticas)#

Checklist de Produção#

Erros Comuns e Soluções#

Próximos Passos#

Apêndice — Criando um cluster local rapidamente#