Kubernetes

Orquestração de contêineres com Kubernetes — pods, services, deployments, escalonamento automático e health checks.

O que é Kubernetes?

Kubernetes (K8s) é uma plataforma de orquestração de contêineres que automatiza o deploy, o escalonamento e o gerenciamento de aplicações conteinerizadas. Foi criado pelo Google e é hoje o padrão de fato para executar workloads em produção.

O Kubernetes resolve problemas que o Docker sozinho não consegue lidar em escala:

• Como distribuo meus contêineres em múltiplas máquinas?
• Como escalono automaticamente quando há mais tráfego?
• O que acontece se um contêiner falhar — quem o reinicia?
• Como faço rolling updates sem downtime?

Conceitos fundamentais

Pod

Um Pod é a unidade mínima de deploy no Kubernetes. Contém um ou mais contêineres que compartilham rede e armazenamento. Na prática, a maioria dos pods tem apenas um contêiner.

apiVersion: v1
kind: Pod
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  containers:
    - name: my-app
      image: my-app:1.0.0
      ports:
        - containerPort: 3000

Service

Um Service expõe um conjunto de pods como um serviço de rede estável. Os pods são efêmeros (podem morrer e ser recriados), mas o Service mantém um IP e um DNS fixos.

Tipos de Service:

• ClusterIP (default): acessível apenas dentro do cluster
• NodePort: expõe o serviço em uma porta de cada nó
• LoadBalancer: cria um balanceador de carga externo (em cloud providers)

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

Deployment

Um Deployment gerencia o ciclo de vida dos pods: quantas réplicas executar, como atualizá-las e como fazer rollback se algo falhar.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: my-app:1.0.0
          ports:
            - containerPort: 3000
          resources:
            requests:
              memory: "128Mi"
              cpu: "250m"
            limits:
              memory: "256Mi"
              cpu: "500m"

Health checks

O Kubernetes usa probes para verificar o estado dos contêineres:

Liveness probe

Verifica se o contêiner está vivo. Se falhar, o Kubernetes reinicia o contêiner.

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 10
  periodSeconds: 15
  failureThreshold: 3

Readiness probe

Verifica se o contêiner está pronto para receber tráfego. Se falhar, o Kubernetes para de enviar requests a ele (mas não o reinicia).

readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 10

Startup probe

Para aplicações que demoram para iniciar. Enquanto o startup probe não passar, os outros probes não são executados.

startupProbe:
  httpGet:
    path: /health
    port: 3000
  failureThreshold: 30
  periodSeconds: 5

Escalonamento

Escalonamento manual

kubectl scale deployment my-app --replicas=5

Horizontal Pod Autoscaler (HPA)

Escala automaticamente o número de pods com base em métricas como CPU ou memória:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

ConfigMaps e Secrets

ConfigMap

Para configuração não sensível:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-app-config
data:
  LOG_LEVEL: "info"
  API_TIMEOUT: "30s"

Secret

Para dados sensíveis (codificados em base64):

apiVersion: v1
kind: Secret
metadata:
  name: my-app-secrets
type: Opaque
data:
  DATABASE_PASSWORD: cGFzc3dvcmQxMjM=

Namespaces

Os namespaces permitem dividir um cluster em ambientes lógicos isolados:

kubectl create namespace staging
kubectl create namespace production

Cada namespace pode ter seus próprios recursos, limites e políticas de acesso.

Resumo

O Kubernetes é a plataforma padrão para orquestrar contêineres em produção. Suas abstrações-chave — Pods, Services, Deployments — junto com health checks, auto-scaling e gerenciamento de configuração, fornecem tudo o que é necessário para executar aplicações distribuídas de forma confiável e escalável.