Cloud & DevOps

Lance-toi en ML Infrastructure Kubernetes : ton premier pas concret aujourd'hui

ML Infrastructure Kubernetes : l'essentiel en un article — vrai code, schémas et étapes concrètes, extraits d'un cours de 41 leçons.

REHOUMA Haythem

• 13 min read
Lance-toi en ML Infrastructure Kubernetes : ton premier pas concret aujourd'hui

La meilleure façon d'apprendre ML Infrastructure Kubernetes, c'est de faire. Cet article te met le pied à l'étrier avec des extraits pratiques tirés d'un cours de 41 leçons — de quoi obtenir un premier résultat dès aujourd'hui.

tl;dr
  • Installer l'environnement Kubernetes
  • Decouvrir Kubernetes
  • Objets Kubernetes essentiels
  • Fichiers YAML et configuration
  • Deployer une API ML avec Flask
~$ cat ./parcours.md # ML Infrastructure Kubernetes — 11 chapitres
01
Installer l'environnement Kubernetes
→ Télécharger Docker Desktop et kubectl→ Installer Minikube et créer un cluster+ 1 autres leçons
02
Découvrir Kubernetes
→ C'est quoi Kubernetes et pourquoi l'utiliser ?→ Architecture Kubernetes (Master et Workers)+ 1 autres leçons
03
Objets Kubernetes essentiels
→ Pods, ReplicaSets et Deployments→ Services et Networking+ 1 autres leçons
04
Fichiers YAML et configuration
→ Anatomie d'un fichier YAML Kubernetes→ ConfigMaps et Secrets+ 1 autres leçons
05
Déployer une API ML avec Flask
→ Rappel Flask et création d'une API ML→ Dockerfile et Deployment Kubernetes+ 1 autres leçons
06
Déployer une API ML avec FastAPI
→ Rappel FastAPI et création d'une API de prédiction→ Deployment FastAPI et HPA+ 1 autres leçons
07
Stockage et persistance
→ C'est quoi les Volumes Kubernetes ?→ PersistentVolumes et PersistentVolumeClaims+ 1 autres leçons
08
Helm et gestion des packages
→ Pourquoi Helm ? Le package manager de Kubernetes→ Installer des Charts et personnaliser+ 2 autres leçons
🏁
Projet final (+ 3 chapitres en chemin)
→ Tu repars avec un projet concret et démontrable

Projet Final – Guide Complet Étape par Étape

Guide • 5 parties • Backend • Frontend • Helm • Monitoring • CI/CD

NOTEPrésentation — Ce guide vous accompagne étape par étape pour réaliser le projet final. Suivez chaque partie dans l'ordre pour construire une plateforme ML complète sur Kubernetes.

Partie 1 : Backend API (FastAPI + Modèle ML)

1.1 Initialiser le projet

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 Entraîner le modèle

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 Créer les schémas 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 Créer le module de chargement du modèle

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 Créer l'application 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 et Secrets

NOTEObjectif — Apprendre à externaliser la configuration et les données sensibles de vos applications ML grâce aux ConfigMaps et Secrets Kubernetes.

Objectifs pédagogiques

TIPÀ l'issue de ce module — Vous serez capable de maîtriser ces compétences essentielles.

1. Pourquoi externaliser la configuration ?

TIPAnalogie — Imaginez un chef cuisinier qui garde ses recettes (code) séparées des ingrédients (configuration). Selon le repas (environnement), il utilise différents ingrédients avec la même recette. C'est exactement le rôle des ConfigMaps.

En ML, votre API a besoin de paramètres qui varient selon l'environnement :

Développement

Staging

Production

Avec les ConfigMaps, vous changez la configuration sans reconstruire l'image Docker.

2. ConfigMaps : stocker la configuration

2.1 Créer un ConfigMap depuis des littéraux

bash
# Créer un ConfigMap avec des paires clé-valeur
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 Créer un ConfigMap depuis un fichier

Créez d'abord un fichier de configuration :

output
# config.properties
model.name=iris_classifier
model.version=v2
model.threshold=0.85
api.port=5000
api.workers=4
log.level=INFO
bash
# Créer le ConfigMap depuis le fichier
kubectl create configmap ml-config --from-file=config.properties

# Créer depuis un dossier entier
kubectl create configmap ml-config --from-file=./config/

2.3 ConfigMap en YAML déclaratif

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
NOTEClé multi-lignes — Le symbole | permet d'inclure un fichier entier comme valeur d'une clé. Très utile pour les fichiers de configuration complets.

3. Utiliser les ConfigMaps dans les Pods

3.1 En tant que variables d'environnement

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éthodeUsageDescription
envFromToutes les clésInjecte toutes les clés du ConfigMap en variables d'environnement
valueFromClé spécifiqueInjecte une seule clé du ConfigMap dans une variable nommée

3.2 En tant que volume monté

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

Anatomie d'un fichier YAML Kubernetes

NOTEObjectif — Comprendre la syntaxe YAML et la structure des manifests Kubernetes pour décrire vos ressources d'infrastructure ML de manière déclarative.

Objectifs pédagogiques

TIPÀ l'issue de ce module — Vous serez capable de maîtriser ces compétences essentielles.

1. Introduction à YAML

YAML signifie « YAML Ain't Markup Language ». C'est un format de sérialisation de données lisible par l'humain, très utilisé pour la configuration.

TIPAnalogie — Pensez à YAML comme à une recette de cuisine. Chaque recette décrit les ingrédients (clés-valeurs), les étapes (listes) et les sections (maps imbriquées). Kubernetes lit cette recette pour « cuisiner » votre infrastructure.

1.1 Règles de base de YAML

RègleDescriptionExemple
IndentationUniquement des espaces (jamais de tabulations), généralement 2 espaces  key: value
Clé-valeurSéparées par : suivi d'un espacename: mon-pod
ListesPréfixées par un tiret -- item1
CommentairesCommencent par ## Ceci est un commentaire
ChaînesGuillemets optionnels sauf caractères spéciauxname: "mon:pod"
Booléenstrue / falseenabled: true

1.2 Paires clé-valeur

La structure la plus simple en YAML — une clé associée à une valeur :

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

1.3 Listes (séquences)

Les listes utilisent le tiret - pour chaque élément :

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

1.4 Maps imbriquées (dictionnaires)

Les maps permettent de créer des structures hiérarchiques :

output
serveur:
  host: 0.0.0.0
  port: 5000
  options:
    debug: true
    workers: 4
WARNINGAttention — L'indentation est cruciale en YAML. Une erreur d'un seul espace peut casser tout le fichier. Utilisez toujours 2 espaces et jamais de tabulations.

1.5 Types de données YAML

Chaînes

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

Nombres

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

Spéciaux

output
vrai: true
faux: false
vide: null
date: 2026-03-05
va-plus-loin

Cet article couvre les extraits les plus utiles — le cours complet ML Infrastructure Kubernetes (12 chapitres, 41 leçons, exercices corrigés et projet final) t'emmène jusqu'au bout.

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

FAQ

Combien de temps pour apprendre ML Infrastructure Kubernetes ?
Avec une progression structurée (12 chapitres, 41 leçons courtes et pratiques), on atteint un niveau opérationnel en quelques semaines à raison de 30 à 60 minutes par jour. L'important est de pratiquer chaque notion immédiatement.
Faut-il des prérequis ?
Mieux vaut être à l'aise avec les fondamentaux du domaine : ce contenu va en profondeur, avec des cas réels.
Par où commencer concrètement ?
Reproduis les commandes de cet article, puis suis le cours complet ML Infrastructure Kubernetes : il enchaîne les 41 leçons dans l'ordre, avec exercices et projet final.
./a-lire-aussi
→ Docker Containerization expliqué simplement (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

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.

Stay up to date

Enter your email
Subscribe