Deploy de ML em Produção: Docker, Kubernetes e o Custo Real de Escalar em 2026 (Tutorial Passo a Passo)

78% dos modelos de machine learning nunca chegam à produção. O dado é da Gartner (2025) e revela um abismo entre o laboratório de dados e o mundo real. O gargalo não está mais na qualidade do modelo, mas na infraestrutura para servir previsões em escala.

Este tutorial prático mostra como fazer deploy de um modelo ML usando Docker e Kubernetes. Vamos do container ao cluster, passando por monitoramento e uma conta real de custos em 2026.

Por que Docker e Kubernetes dominam o Model Serving em 2026

Containerizar um modelo de ML resolve o problema clássico de "funciona na minha máquina". Com Docker, você empacota o modelo, as dependências e as bibliotecas em uma imagem imutável. O Kubernetes, por sua vez, orquestra esses containers em produção.

O custo médio de deploy em Kubernetes é de US$ 0,10 por hora por pod no AWS EKS (dados de 2026). Parece barato, mas escala rápido. Um cluster com 10 pods rodando 24 horas por dia custa US$ 720 por mês. Sem otimização, o orçamento explode.

A escolha entre AWS, Google Cloud ou Azure depende do seu ecossistema. Mas o padrão de deploy é o mesmo: Dockerfile + manifesto Kubernetes.

Passo 1: Containerizar o modelo com Docker

Vamos usar um modelo de regressão treinado com scikit-learn. O objetivo é expor uma API REST com Flask.

Arquivo app.py:

from flask import Flask, request, jsonify
import pickle
import numpy as np

app = Flask(name) model = pickle.load(open('model.pkl', 'rb'))

@app.route('/predict', methods=['POST']) def predict(): data = request.get_json() features = np.array(data['features']).reshape(1, -1) prediction = model.predict(features) return jsonify({'prediction': prediction.tolist()})

if name == 'main': app.run(host='0.0.0.0', port=5000)

Arquivo Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Construa a imagem:

docker build -t ml-model:v1 .

Teste localmente:

docker run -p 5000:5000 ml-model:v1

Se a API responder, o container está pronto. Agora, envie para um registry como Docker Hub ou ECR.

"Containerizar o modelo é o primeiro passo para matar o 'funciona na minha máquina'. Sem isso, o deploy em produção é uma aposta." — Priscila Lima, engenheira de ML na Nubank, em entrevista ao NeuralPulse (2026).

Passo 2: Deploy no Kubernetes com escalabilidade

Crie um deployment e um service no Kubernetes. O arquivo YAML define quantos pods rodam, a porta e como expor o serviço.

Arquivo deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
      - name: ml-model
        image: seuuser/ml-model:v1
        ports:
        - containerPort: 5000
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: ml-model-service
spec:
  selector:
    app: ml-model
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5000
  type: LoadBalancer

Aplique no cluster:

kubectl apply -f deployment.yaml

O Kubernetes cria 3 pods. Se um cair, o deployment recria. O service distribui o tráfego entre eles.

Para escalar manualmente:

kubectl scale deployment ml-model-deployment --replicas=5

Mas o ideal é usar Horizontal Pod Autoscaler (HPA). Ele ajusta o número de pods com base no uso de CPU ou memória.

Arquivo hpa.yaml:

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

Com HPA, o cluster escala de 2 a 10 pods automaticamente. Você paga só pelo que usa.

Passo 3: Monitoramento e MLflow para rastrear versões

Monitorar o modelo em produção é tão importante quanto o deploy. Use MLflow para versionar modelos e métricas. Integre com Prometheus e Grafana para métricas em tempo real.

Instale o MLflow Tracking Server:

pip install mlflow
mlflow server --host 0.0.0.0 --port 5001

No código de treino, registre cada experimento:

import mlflow
mlflow.set_tracking_uri("http://localhost:5001")
with mlflow.start_run():
    mlflow.log_param("model_type", "regression")
    mlflow.log_metric("rmse", 0.23)
    mlflow.sklearn.log_model(model, "model")

O MLflow guarda o modelo e as métricas. Para deploy, use o modelo registrado em vez de um arquivo local.

Para monitoramento, configure Prometheus para coletar métricas dos pods. Crie um dashboard no Grafana com:

• Latência média das requisições
• Taxa de erros
• Uso de CPU e memória por pod
• Número de previsões por segundo

Se a latência subir, o HPA escala. Se o erro aumentar, o alerta dispara. Sem monitoramento, você voa cego.

Comparativo de custos: Docker standalone vs Kubernetes em 2026

A tabela abaixo compara custos para servir um modelo com 100 requisições por segundo (RPS) durante 30 dias.

Fonte: AWS Pricing Calculator, junho de 2026.

O Docker standalone é mais barato para cargas estáveis. Mas o Kubernetes brilha quando o tráfego varia. Com HPA, você paga pela média, não pelo pico.

Quando usar cada um?

• Docker standalone: protótipos, modelos com tráfego previsível, equipes pequenas.
• Kubernetes: produção com escala variável, múltiplos modelos, times de ML maduros.

A escolha errada pode custar caro. Um cluster Kubernetes mal configurado gera desperdício de recursos. Um Docker sem orquestração quebra sob pico de requisições.

Boas práticas para deploy de ML em produção

1. Use versionamento de modelos: MLflow ou DVC. Nunca substitua um modelo sem rastrear a versão anterior.
2. Teste o container localmente: antes de subir para o cluster, rode docker run e faça requisições de teste.
3. Defina limites de recursos: pods sem limites de CPU/memória podem derrubar o cluster.
4. Implemente health checks: o Kubernetes usa probes para saber se o pod está vivo e pronto.
5. Colete métricas de negócio: além de latência e erro, monitore a acurácia do modelo em produção. Dados reais degradam modelos.

O deploy de ML não termina quando o modelo sobe. Ele começa. A cada nova versão, repita o ciclo. Containerize, deploy, monitore, melhore.

O custo de não fazer isso é alto. 78% dos modelos nunca chegam à produção (Gartner, 2025). Os 22% que chegam, muitas vezes, morrem por falta de manutenção.

Com Docker e Kubernetes, você reduz esse risco. Mas só se seguir o passo a passo com disciplina. O tutorial termina aqui. A produção começa agora.

Artigos Relacionados

Confira também: Como Usar IA para Criar Conteúdo de Alta Qualidade em 2026 Confira também: Do Dataset ao Ollama: Fine-Tuning de LLMs com Unsloth na Sua GPU em 2026 Confira também: 48% Não Testam, 40% Alucinam: Como Avaliar LLMs em 2026 — Guia Analítico