Hands-on 5 — Orquestração

Além de uma máquina

• Escalonamento — posicionar os containers nos servidores adequados.
• Escala — adicionar ou remover containers conforme a demanda.
• Rede e descoberta de serviços — os containers se encontram.
• Autorrecuperação — reiniciar containers com falha, redistribuir workloads.

Docker Compose × Kubernetes

O Kompose ajuda a migrar um arquivo do Compose para manifestos do Kubernetes.

Alternativas ao Kubernetes

• Nomad e Swarm priorizam a simplicidade; as opções cloud-native reduzem o gerenciamento, mas prendem você a um provedor.
• As ferramentas locais não servem para produção — brilham no desenvolvimento e no aprendizado.

Os objetos do Kubernetes

Deployment → define um ReplicaSet → gerencia Pods → executam Containers

Tipos de Service

Postgres: Secret e ConfigMap

apiVersion: v1
kind: Secret
metadata:
    name: postgres-secrets
data:
    POSTGRES_USER: c3RvcmU=
    POSTGRES_PASSWORD: c3RvcmU=

apiVersion: v1
kind: ConfigMap
metadata:
    name: postgres-configmap
data:
    POSTGRES_HOST: postgres
    POSTGRES_DB: store

Postgres: o Deployment

spec:
  replicas: 1
  selector:
    matchLabels: { app: postgres }
  template:
    metadata:
      labels: { app: postgres }
    spec:
      containers:
        - name: postgres
          image: postgres:latest
          resources: { requests: { memory: "256Mi", cpu: "250m" },
                       limits:   { memory: "512Mi", cpu: "500m" } }

• O env lê POSTGRES_DB via configMapKeyRef, e o usuário e a senha via secretKeyRef.
• O selector precisa corresponder aos labels do Pod — é assim que o Deployment encontra seus Pods.

Postgres: Service e apply

kind: Service
metadata:
    name: postgres
spec:
    type: ClusterIP
    ports:
        - port: 5432
    selector:
        app: postgres

kubectl apply -f ./k8s/secrets.yaml      # then configmap, deployment, service
kubectl get secrets; kubectl get pods; kubectl get services

O nome do Service, postgres, é o hostname que os outros Pods usam — o mesmo valor de POSTGRES_HOST.

Gateway: um arquivo, dois objetos

O gateway-service/k8s/k8s.yaml contém um Deployment e um Service, separados por ---:

kind: Deployment
metadata: { name: gateway }
spec:
  replicas: 1
  template:
    spec:
      containers:
        - name: gateway
          image: humbertosandmann/gateway:latest
          imagePullPolicy: Always
          ports:
            - containerPort: 8080

kind: Service
metadata: { name: gateway }
spec:
  selector:
    app: gateway
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  type: LoadBalancer

A imagem vem do Docker Hub; imagePullPolicy: Always a baixa de novo sempre que um Pod sobe.

Executar e verificar

kubectl apply -f ./k8s/k8s.yaml
kubectl get deployments
kubectl get pods
kubectl get services

• O Service gateway recebe um EXTERNAL-IP (na AWS, um hostname …elb.amazonaws.com): abra http://<EXTERNAL-IP>:8080/health-check → {"hostname": …}.
• É HTTP, não HTTPS: TLS exige certificados e um Ingress.
• Um Ingress roteia o tráfego HTTP/S externo para vários serviços sob um único domínio.

No Minikube, um LoadBalancer fica <pending> até que o minikube tunnel esteja rodando.

Escala: o HPA

O Horizontal Pod Autoscaler muda o número de réplicas a partir da CPU observada (ou de outras métricas).

kubectl autoscale deployment <name> --cpu-percent=<target> --min=<min> --max=<max>
kubectl get hpa
kubectl delete hpa <hpa-name>
kubectl scale deployment <name> --replicas=<number>   # manual alternative

O essencial de kubectl e Minikube

Armadilhas comuns

• Labels: um selector de Service ou Deployment que não corresponde aos labels do Pod não encontra nada.
• Ordem: aplique o Secret e o ConfigMap antes do Deployment que os referencia.
• Imagens desatualizadas: :latest + imagePullPolicy: Always baixa a imagem a cada reinício — fixe as tags em produção.
• Segredos em texto puro: base64 é codificação; um secrets.yaml versionado é uma senha vazada.
• Tipo de Service errado: um banco de dados como LoadBalancer fica exposto à internet.

Pontos-chave

1. Um orquestrador faz escalonamento, escala, rede, autorrecuperação e descoberta de serviços.
2. O Compose é de um único hospedeiro; o Kubernetes reconcilia um estado desejado declarado em um cluster.
3. Deployment → ReplicaSet → Pod → Container; um Service expõe Pods por label.
4. ClusterIP para serviços internos (Postgres), LoadBalancer para o ponto de entrada (gateway).
5. Configuração em ConfigMaps, credenciais em Secrets (base64, não criptografia).
6. kubectl apply -f + kubectl get … para implantar e verificar; HPA para escalar pela CPU.
7. O Minikube roda um cluster de um único nó localmente; K8s gerenciado (EKS, GKE) na nuvem.