Cloud & DevOps

Comece em ML Infrastructure Kubernetes: seu primeiro passo concreto hoje

ML Infrastructure Kubernetes: o essencial em um artigo — código real, diagramas e etapas concretas, extraídos de um curso de 41 lições.

REHOUMA Haythem

12 Jun 2026 • 13 min read

A melhor forma de aprender ML Infrastructure Kubernetes é fazendo. Este artigo te dá o pontapé inicial com trechos práticos extraídos de um curso de 41 lições — o suficiente para obter um primeiro resultado já hoje.

tl;dr

Instalar o ambiente Kubernetes
Descobrir o Kubernetes
Objetos Kubernetes essenciais
Arquivos YAML e configuração
Implantar uma API ML com Flask

~$ cat ./parcours.md # ML Infrastructure Kubernetes — 11 capítulos

Instalar o ambiente Kubernetes

→ Baixar Docker Desktop e kubectl→ Instalar Minikube e criar um cluster+ 1 mais lições

Descobrir Kubernetes

→ O que é Kubernetes e por que usá-lo?→ Arquitetura Kubernetes (Master e Workers)+ 1 mais lições

Objetos Kubernetes essenciais

→ Pods, ReplicaSets e Deployments→ Services e Networking+ 1 mais lições

Arquivos YAML e configuração

→ Anatomia de um arquivo YAML Kubernetes→ ConfigMaps e Secrets+ 1 mais lições

Implantar uma API ML com Flask

→ Revisão Flask e criação de uma API ML→ Dockerfile e Deployment Kubernetes+ 1 mais lições

Implantar uma API ML com FastAPI

→ Revisão FastAPI e criação de uma API de predição→ Deployment FastAPI e HPA+ 1 mais lições

Armazenamento e persistência

→ O que são os Volumes Kubernetes?→ PersistentVolumes e PersistentVolumeClaims+ 1 mais lições

Helm e gerenciamento de pacotes

→ Por que Helm? O gerenciador de pacotes do Kubernetes→ Instalar Charts e personalizar+ 2 mais lições

🏁

Projeto final (+ 3 capítulos no caminho)

→ Você sai com um projeto concreto e demonstrável

Projeto Final – Guia Completo Passo a Passo

Guia • 5 partes • Backend • Frontend • Helm • Monitoramento • CI/CD

NOTEApresentação — Este guia acompanha você passo a passo para realizar o projeto final. Siga cada parte em ordem para construir uma plataforma ML completa no Kubernetes.

Parte 1 : Backend API (FastAPI + Modelo ML)

1.1 Inicializar o projeto

bash

mkdir -p ml-prediction-platform/{backend/{app,train,tests},frontend,helm,k8s/{security,monitoring},.github/workflows,docs}
cd ml-prediction-platform
git init

1.2 Treinar o modelo

output

# backend/train/train_model.py
import joblib
import numpy as np
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

accuracy = accuracy_score(y_test, model.predict(X_test))
print(f"Accuracy: {accuracy:.4f}")

model_info = {
    "model": model,
    "feature_names": list(iris.feature_names),
    "target_names": list(iris.target_names),
    "accuracy": accuracy,
    "version": "1.0.0"
}
joblib.dump(model_info, "model.pkl")

bash

cd backend/train
pip install scikit-learn joblib numpy
python train_model.py

1.3 Criar os schemas Pydantic

output

# backend/app/schemas.py
from pydantic import BaseModel, Field
from typing import List

class PredictionRequest(BaseModel):
    features: List[float] = Field(..., min_length=4, max_length=4)
    class Config:
        json_schema_extra = {"example": {"features": [5.1, 3.5, 1.4, 0.2]}}

class PredictionResponse(BaseModel):
    prediction: str
    prediction_id: int
    confidence: float
    probabilities: dict
    model_version: str

class HealthResponse(BaseModel):
    status: str
    model_loaded: bool
    version: str

1.4 Criar o módulo de carregamento do modelo

output

# backend/app/model.py
import os
import joblib
import numpy as np
import logging

logger = logging.getLogger(__name__)

class MLModel:
    def __init__(self):
        self.model = None
        self.feature_names = None
        self.target_names = None
        self.version = None
        self.loaded = False

    def load(self, path: str = None):
        path = path or os.getenv("MODEL_PATH", "/models/model.pkl")
        info = joblib.load(path)
        self.model = info["model"]
        self.feature_names = info["feature_names"]
        self.target_names = info["target_names"]
        self.version = info["version"]
        self.loaded = True
        logger.info(f"Model v{self.version} loaded")

    def predict(self, features: list) -> dict:
        X = np.array(features).reshape(1, -1)
        pred = self.model.predict(X)[0]
        proba = self.model.predict_proba(X)[0]
        return {
            "prediction": self.target_names[pred],
            "prediction_id": int(pred),
            "confidence": float(max(proba)),
            "probabilities": {
                n: float(p) for n, p in zip(self.target_names, proba)
            }
        }

ml_model = MLModel()

1.5 Criar a aplicação FastAPI

output

# backend/app/main.py
import os, time, logging
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from prometheus_client import Counter, Histogram, generate_latest
from starlette.responses import Response
from .model import ml_model
from .schemas import PredictionRequest, PredictionResponse, HealthResponse

logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO"))
app = FastAPI(title="ML Prediction API", version="1.0.0")
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])

PREDICTIONS = Counter("predictions_total", "Total predictions", ["status"])
LATENCY = Histogram("prediction_latency_seconds", "Prediction latency")

@app.on_event("startup")
async def startup():
    ml_model.load()

@app.get("/health", response_model=HealthResponse)
async def health():
    return HealthResponse(
        status="healthy" if ml_model.loaded else "unhealthy",
        model_loaded=ml_model.loaded,
        version=ml_model.version or "unknown"
    )

@app.post("/predict", response_model=PredictionResponse)
async def predict(req: PredictionRequest):
    start = time.time()
    try:
        result = ml_model.predict(req.features)
        PREDICTIONS.labels(status="success").inc()
        LATENCY.observe(time.time() - start)
        return PredictionResponse(model_version=ml_model.version, **result)
    except Exception as e:
        PREDICTIONS.labels(status="error").inc()
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/metrics")
async def metrics():
    return Response(content=generate_latest(), media_type="text/plain")

ConfigMaps e Secrets

NOTEObjetivo — Aprender a externalizar a configuração e os dados sensíveis de suas aplicações ML graças aos ConfigMaps e Secrets do Kubernetes.

Objetivos pedagógicos

TIPAo final deste módulo — Você será capaz de dominar estas competências essenciais.

1. Por que externalizar a configuração?

TIPAnalogia — Imagine um chef que mantém suas receitas (código) separadas dos ingredientes (configuração). Dependendo da refeição (ambiente), ele usa ingredientes diferentes com a mesma receita. É exatamente o papel dos ConfigMaps.

Em ML, sua API precisa de parâmetros que variam conforme o ambiente:

Desenvolvimento

Staging

Produção

Com os ConfigMaps, você altera a configuração sem reconstruir a imagem Docker.

2. ConfigMaps: armazenar a configuração

2.1 Criar um ConfigMap a partir de literais

bash

# Criar um ConfigMap com pares chave-valor
kubectl create configmap ml-config \
  --from-literal=MODEL_NAME=iris_classifier \
  --from-literal=MODEL_VERSION=v2 \
  --from-literal=LOG_LEVEL=INFO \
  --from-literal=MAX_BATCH_SIZE=32

2.2 Criar um ConfigMap a partir de um arquivo

Crie primeiro um arquivo de configuração:

output

# config.properties
model.name=iris_classifier
model.version=v2
model.threshold=0.85
api.port=5000
api.workers=4
log.level=INFO

bash

# Criar o ConfigMap a partir do arquivo
kubectl create configmap ml-config --from-file=config.properties

# Criar a partir de uma pasta inteira
kubectl create configmap ml-config --from-file=./config/

2.3 ConfigMap em YAML declarativo

output

apiVersion: v1
kind: ConfigMap
metadata:
  name: ml-config
  labels:
    app: ml-api
data:
  MODEL_NAME: "iris_classifier"
  MODEL_VERSION: "v2"
  LOG_LEVEL: "INFO"
  MAX_BATCH_SIZE: "32"
  FEATURE_COLUMNS: "sepal_length,sepal_width,petal_length,petal_width"
  config.yaml: |
    model:
      name: iris_classifier
      version: v2
      threshold: 0.85
    api:
      port: 5000
      workers: 4

NOTEChave multilinha — O símbolo | permite incluir um arquivo inteiro como valor de uma chave. Muito útil para arquivos de configuração completos.

3. Usar os ConfigMaps nos Pods

3.1 Como variáveis de ambiente

output

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ml-api
  template:
    metadata:
      labels:
        app: ml-api
    spec:
      containers:
        - name: ml-api
          image: monregistry/ml-api:v1
          ports:
            - containerPort: 5000
          envFrom:
            - configMapRef:
                name: ml-config
          env:
            - name: SPECIFIC_KEY
              valueFrom:
                configMapKeyRef:
                  name: ml-config
                  key: MODEL_NAME

Método	Uso	Descrição
`envFrom`	Todas as chaves	Injeta todas as chaves do ConfigMap como variáveis de ambiente
`valueFrom`	Chave específica	Injeta uma única chave do ConfigMap em uma variável nomeada

3.2 Como volume montado

output

apiVersion: v1
kind: Pod
metadata:
  name: ml-pod-config
spec:
  containers:
    - name: ml-api
      image: monregistry/ml-api:v1
      volumeMounts:
        - name: config-volume
          mountPath: /app/config
          readOnly: true
  volumes:
    - name: config-volume
      configMap:
        name: ml-config

Anatomia de um arquivo YAML Kubernetes

NOTEObjetivo — Compreender a sintaxe YAML e a estrutura dos manifests Kubernetes para descrever seus recursos de infraestrutura ML de forma declarativa.

Objetivos pedagógicos

TIPAo final deste módulo — Você será capaz de dominar estas competências essenciais.

1. Introdução ao YAML

YAML significa « YAML Ain't Markup Language ». É um formato de serialização de dados legível por humanos, muito utilizado para configuração.

TIPAnalogia — Pense no YAML como uma receita de cozinha. Cada receita descreve os ingredientes (chave-valor), as etapas (listas) e as seções (maps aninhados). O Kubernetes lê esta receita para « cozinhar » sua infraestrutura.

1.1 Regras básicas do YAML

Regra	Descrição	Exemplo
Indentação	Apenas espaços (nunca tabulações), geralmente 2 espaços	`key: value`
Chave-valor	Separadas por `:` seguido de um espaço	`name: mon-pod`
Listas	Prefixadas por um hífen `-`	`- item1`
Comentários	Começam com `#`	`# Ceci est un commentaire`
Strings	Aspas opcionais exceto caracteres especiais	`name: "mon:pod"`
Booleanos	`true` / `false`	`enabled: true`

1.2 Pares chave-valor

A estrutura mais simples em YAML — uma chave associada a um valor:

output

nom: flask-ml-api
version: "1.0"
replicas: 3
debug: false

1.3 Listas (sequências)

As listas usam o hífen - para cada elemento:

output

frameworks:
  - scikit-learn
  - tensorflow
  - pytorch
  - fastapi

1.4 Maps aninhados (dicionários)

Os maps permitem criar estruturas hierárquicas:

output

serveur:
  host: 0.0.0.0
  port: 5000
  options:
    debug: true
    workers: 4

WARNINGAtenção — A indentação é crucial em YAML. Um erro de apenas um espaço pode quebrar todo o arquivo. Use sempre 2 espaços e nunca tabulações.

1.5 Tipos de dados YAML

Strings

output

simple: hello
quotes: "world"
multi: |
  ligne 1
  ligne 2

Números

output

entier: 42
flottant: 3.14
scientifique: 1e+6
octal: 0o14

Especiais

output

vrai: true
faux: false
vide: null
date: 2026-03-05

va-plus-loin

Este artigo cobre os trechos mais úteis — o curso completo ML Infrastructure Kubernetes (12 capítulos, 41 lições, exercícios corrigidos e projeto final) leva você até o fim.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

Quanto tempo para aprender ML Infrastructure Kubernetes?

Com uma progressão estruturada (12 capítulos, 41 lições curtas e práticas), você atinge um nível operacional em algumas semanas dedicando 30 a 60 minutos por dia. O importante é praticar cada conceito imediatamente.

É preciso ter pré-requisitos?

É melhor estar à vontade com os fundamentos do domínio: este conteúdo vai em profundidade, com casos reais.

Por onde começar concretamente?

Reproduza os comandos deste artigo, depois siga o curso completo ML Infrastructure Kubernetes: ele encadeia as 41 lições em ordem, com exercícios e projeto final.

./a-lire-aussi

→ Docker Containerization explicado simplesmente (avec schémas et vrai code)→ Maîtriser Linux expliqué simplement (avec schémas et vrai code)→ Python Sécurité Ports Linux : les 9 étapes clés pour passer de zéro à opérationnel

📬 Você quer receber este tipo de guia toda semana? Inscreva-se gratuitamente — código real, zero enrolação.

Projeto Final – Guia Completo Passo a Passo

Parte 1 : Backend API (FastAPI + Modelo ML)

1.1 Inicializar o projeto

1.2 Treinar o modelo

1.3 Criar os schemas Pydantic

1.4 Criar o módulo de carregamento do modelo

1.5 Criar a aplicação FastAPI

ConfigMaps e Secrets

Objetivos pedagógicos

1. Por que externalizar a configuração?

Desenvolvimento

Staging

Produção

2. ConfigMaps: armazenar a configuração

2.1 Criar um ConfigMap a partir de literais

2.2 Criar um ConfigMap a partir de um arquivo

2.3 ConfigMap em YAML declarativo

3. Usar os ConfigMaps nos Pods

3.1 Como variáveis de ambiente

3.2 Como volume montado

Anatomia de um arquivo YAML Kubernetes

Objetivos pedagógicos

1. Introdução ao YAML

1.1 Regras básicas do YAML

1.2 Pares chave-valor

1.3 Listas (sequências)

1.4 Maps aninhados (dicionários)

1.5 Tipos de dados YAML

Strings

Números

Especiais

FAQ

Stay up to date