Carregando
0xB0Lição 12 de 15

Contêineres e Kubernetes

Empacote serviços como imagens de contêiner e rode-os no Kubernetes com Deployments, Services, probes, configuração e autoscaling.

30 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Empacotar um serviço como imagem de contêiner com um Dockerfile
  • Descrever Pods, Deployments, Services, ConfigMaps e Secrets do Kubernetes
  • Configurar probes, recursos e autoscaling, e raciocinar sobre rolling updates

Doze serviços em quatro linguagens, cada um precisando de bibliotecas diferentes: “na minha máquina funciona” em escala. Os contêineres empacotam um serviço com tudo de que ele precisa numa imagem que roda igual em qualquer lugar. Um Dockerfile descreve como construí-la:

Dockerfile
1FROM python:3.12-slim
2WORKDIR /app
3COPY requirements.txt .
4RUN pip install --no-cache-dir -r requirements.txt   # cached unless requirements change
5COPY . .
6USER 1000                                            # don't run as root
7EXPOSE 8080
8CMD ["python", "-m", "ordering"]

Rodar dezenas de contêineres à mão não escala, então a maioria das equipes usa o Kubernetes, um orquestrador de contêineres. Você declara o estado desejado em YAML; o Kubernetes mantém a realidade igual a ele - reiniciando contêineres que caíram, reagendando-os quando uma máquina morre, distribuindo novas versões.

ObjetoO que é
Podum ou mais contêineres que rodam juntos; a menor unidade
Deploymentmantém N réplicas de um pod rodando e distribui novas versões
Serviceum nome e um IP estáveis que balanceiam a carga entre os pods saudáveis de um Deployment - descoberta de serviços embutida (http://ordering)
ConfigMap / Secretconfiguração e credenciais injetadas como variáveis de ambiente ou arquivos
Ingress / Gatewayencaminha o tráfego de fora para dentro
HorizontalPodAutoscaleradiciona ou remove réplicas com base em métricas
ordering.yaml
1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: ordering
5spec:
6  replicas: 3
7  selector:
8    matchLabels: {app: ordering}
9  strategy:
10    rollingUpdate: {maxSurge: 1, maxUnavailable: 0}
11  template:
12    metadata:
13      labels: {app: ordering}
14    spec:
15      containers:
16        - name: ordering
17          image: ghcr.io/galactic-noodle/ordering:1.8.2
18          ports: [{containerPort: 8080}]
19          env:
20            - name: DB_PASSWORD
21              valueFrom: {secretKeyRef: {name: ordering-db, key: password}}
22          resources:
23            requests: {cpu: 250m, memory: 256Mi}
24            limits: {memory: 512Mi}
25          readinessProbe: {httpGet: {path: /ready, port: 8080}}
26          livenessProbe: {httpGet: {path: /healthz, port: 8080}}
27---
28apiVersion: v1
29kind: Service
30metadata:
31  name: ordering
32spec:
33  selector: {app: ordering}
34  ports: [{port: 80, targetPort: 8080}]

Vale a pena reparar:

  • A tag da imagem é uma versão específica, nunca latest, para que todo deploy seja reprodutível e o rollback seja só a tag anterior.
  • A readiness controla o tráfego; a liveness dispara reinícios (a distinção da lição de observabilidade).
  • Os resource requests dizem ao agendador quanta CPU e memória reservar; um limite de memória impede que um contêiner com vazamento deixe os vizinhos sem recursos (ele é morto por OOM).
  • Os rolling updates substituem os pods aos poucos: maxSurge: 1, maxUnavailable: 0 adiciona um pod novo de cada vez e só remove um antigo depois que o novo está pronto - zero downtime, ao custo de um pouco de capacidade extra durante a distribuição.
autoscaling.py
1import math
2
3def desired_replicas(current, current_cpu, target_cpu, minimum, maximum):
4    ratio = current_cpu / target_cpu
5    if abs(ratio - 1) <= 0.1:              # within 10%: leave it alone
6        return current
7    return max(minimum, min(maximum, math.ceil(current * ratio)))
8
9print(desired_replicas(3, 90, 60, 2, 10))   # busy Friday night
10print(desired_replicas(3, 63, 60, 2, 10))   # close enough
11print(desired_replicas(6, 10, 60, 2, 10))   # quiet Tuesday morning
Saída
5
3
2

Principais conclusões

  • Contêineres empacotam um serviço e as suas dependências numa imagem que roda em qualquer lugar.

  • O Kubernetes mantém o estado declarado: Deployments para réplicas e distribuições, Services para descoberta.

  • Fixe as versões das imagens, configure probes de readiness e liveness, e defina resource requests e limites de memória.

  • Rolling updates e autoscaling (desejado = ceil(atual × métrica / alvo)) mantêm os serviços no ar e no tamanho certo.

Quiz da aula

7 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: simule padrões de microsserviços com Python

Crie pequenas simulações em Python dos padrões, como roteadores, sagas, outboxes, circuit breakers e traces, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contêineres.

Exercício 1

Faça autoscaling como o HPA

+25 XP

A primeira linha da entrada é min max target_cpu e o número inicial de réplicas, como 2 10 60 3. Cada linha seguinte é a CPU média, em %, medida naquele momento. Para cada medição, calcule as réplicas desejadas do jeito que o HorizontalPodAutoscaler do Kubernetes faz - ceil(current × measured / target), mantendo a contagem quando a razão estiver a menos de 10% de 1, limitada ao mínimo e ao máximo - e imprima cpu 90% -> 5 replicas (scale up), (scale down) ou (no change). A nova contagem vira a contagem atual da próxima linha.

  • Uma sexta à noite
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Simule um rolling update

+25 XP

A entrada é replicas maxSurge maxUnavailable. Simule um rolling update de todos os pods antigos para todos os novos. Em cada passo: (1) inicie pods novos enquanto o total ficar dentro de replicas + maxSurge e os pods novos não passarem de replicas; eles ficam prontos na hora; (2) depois pare pods antigos enquanto o número de pods rodando ficar em pelo menos replicas - maxUnavailable. Imprima step 1: old 4, new 1 depois de cada passo até todos os pods serem novos e então done in N steps.

Se maxSurge e maxUnavailable forem os dois 0, imprima invalid: the update could never make progress.

  • Surge de um em um
  • Mais rápido, com alguma indisponibilidade
  • Travado
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…