Docker Kubernetes

Colocar modelos de machine learning em produção é um dos maiores desafios em MLOps. Docker e Kubernetes fornecem ferramentas poderosas para empacotar, distribuir e gerenciar modelos ML em escala.

Por que Docker para ML?

Docker resolve o problema clássico de "funciona na minha máquina" ao empacotar seu modelo, dependências e ambiente em um container isolado e portável.

Vantagens:

  • Consistência: Mesmo ambiente em desenvolvimento e produção
  • Isolamento: Dependências não conflitam entre projetos
  • Portabilidade: Roda em qualquer lugar que suporte Docker
  • Escalabilidade: Fácil replicar e escalar containers

Criando um Dockerfile para ML

Exemplo básico de Dockerfile para um modelo ML:

FROM python:3.9-slim

WORKDIR /app

# Instalar dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código e modelo
COPY . .

# Expor porta
EXPOSE 8000

# Comando para iniciar API
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Construindo a API

Uma API simples com FastAPI para servir o modelo:

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
model = joblib.load("model.pkl")

class Input(BaseModel):
    feature1: float
    feature2: float

@app.post("/predict")
def predict(input: Input):
    prediction = model.predict([[input.feature1, input.feature2]])
    return {"prediction": prediction[0]}

Orquestração com Kubernetes

Kubernetes gerencia containers em escala, fornecendo auto-scaling, load balancing e alta disponibilidade.

Conceitos Principais:

  • Pods: Unidade menor de deployment (containers)
  • Services: Abstração para expor pods via rede
  • Deployments: Gerenciam réplicas de pods
  • Horizontal Pod Autoscaler: Escala automaticamente baseado em métricas

Deployment Kubernetes Exemplo

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
      - name: api
        image: ml-model:latest
        ports:
        - containerPort: 8000
        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:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Considerações Importantes

Performance

  • Use modelos otimizados (quantização, pruning)
  • Cache previsões quando apropriado
  • Batching para processar múltiplas requisições
  • GPU support se necessário

Recursos

  • Alocar memória suficiente para carregar o modelo
  • CPU/GPU conforme necessário
  • Storage para modelos grandes (PVCs)

Monitoramento

  • Logs estruturados
  • Métricas de performance (latência, throughput)
  • Health checks
  • Alertas para falhas

Alternativas Simples

Para começar mais simples, considere:

  • FastAPI + Docker: Para APIs simples
  • Flask + Docker Compose: Para desenvolvimento
  • Cloud ML Platforms: AWS SageMaker, GCP AI Platform, Azure ML
  • Serverless: AWS Lambda, Google Cloud Functions

Workflow Recomendado

  1. Desenvolver e treinar modelo localmente
  2. Empacotar modelo e API em Docker
  3. Testar container localmente
  4. Publicar imagem em registry (Docker Hub, ECR, etc.)
  5. Deploy em Kubernetes
  6. Configurar monitoramento e alertas
← Voltar para AI in Production