← Retour au blog

Héberger un LLM privé sur OpenShift : Guide Infrastructure NVIDIA GPU

28/11/2025

Chargement…

Déployer une IA Générative Souveraine sur OpenShift : Guide Complet GPU & Ollama

Introduction

L'hébergement d'une intelligence artificielle générative en entreprise ne se résume pas au choix du modèle : c'est avant tout un défi d'infrastructure et d'architecture. Pour garantir la souveraineté des données et éviter les fuites vers des API publiques, il est crucial de maîtriser la stack complète, du matériel jusqu'au conteneur d'inférence.

Ce guide technique détaille, étape par étape, comment préparer un cluster Red Hat OpenShift pour exploiter la puissance des GPU NVIDIA et déployer un LLM (Large Language Model) via Ollama.

Prérequis

Avant de vous lancer dans ce déploiement, assurez-vous de disposer des éléments suivants :

  • Cluster OpenShift (OCP) : Version 4.12 ou supérieure recommandée.
  • Matériel : Des nœuds workers équipés de cartes NVIDIA compatibles (ex: Tesla T4, A100, V100, L40S).
  • Accès administratif : La CLI oc configurée avec les droits cluster-admin.
  • Outillage : Helm 3 installé localement.
  • Licences : Accès au catalogue OperatorHub (marketplace Red Hat) et, si nécessaire, un compte NVIDIA AI Enterprise (optionnel pour les drivers standards).

Tutoriel Pas à Pas

1. Installation du Node Feature Discovery (NFD)

L'opérateur NFD est la boussole de votre cluster : il détecte les capacités matérielles (PCI, USB, CPU flags) et étiquette les nœuds (labels) en conséquence. Sans lui, Kubernetes ignore quels nœuds possèdent des GPU.

A. Création du Namespace et de l'Opérateur

Créez un fichier nfd-install.yaml :

apiVersion: v1
kind: Namespace
metadata:
  name: openshift-nfd
---
apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
  generateName: openshift-nfd-
  name: openshift-nfd
  namespace: openshift-nfd
---
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
  name: nfd
  namespace: openshift-nfd
spec:
  channel: "stable"
  installPlanApproval: Automatic
  name: nfd
  source: redhat-operators
  sourceNamespace: openshift-marketplace

Appliquez la configuration :

oc apply -f nfd-install.yaml

B. Instanciation du NFD Une fois l'opérateur installé, créez une instance pour scanner le cluster :

oc apply -f - <<EOF
kind: NodeFeatureDiscovery
apiVersion: nfd.openshift.io/v1
metadata:
  name: nfd-instance
  namespace: openshift-nfd
spec:
  operand:
    image: registry.redhat.io/openshift4/ose-node-feature-discovery:v4.12
    servicePort: 12000
EOF

2. Déploiement du NVIDIA GPU Operator

Cet opérateur orchestre tout ce qui est nécessaire pour NVIDIA : drivers, container toolkit, device plugin et monitoring DCGM.

Ajoutez le dépôt Helm NVIDIA :

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

Installez l'opérateur. Notez que nous activons le driver par défaut :

helm install gpu-operator nvidia/gpu-operator \
  -n nvidia-gpu-operator \
  --create-namespace \
  --set driver.enabled=true \
  --set toolkit.enabled=true

3. Validation de l'Infrastructure

Cette étape est critique. Il faut s'assurer que la couche matérielle est correctement exposée à Kubernetes.

Vérification des pods système :

oc get pods -n nvidia-gpu-operator
# Tous les pods (driver-daemonset, device-plugin, etc.) doivent être en Running

Vérification de la capacité GPU : Repérez un nœud GPU et vérifiez ses ressources allouables :

NODE_NAME=$(oc get nodes -l nvidia.com/gpu.present=true -o jsonpath='{.items[0].metadata.name}')
oc describe node $NODE_NAME | grep "nvidia.com/gpu"

Sortie attendue : nvidia.com/gpu: 1 (ou plus selon la carte).

4. Déploiement du LLM (Ollama)

Nous allons déployer Ollama, un runtime léger et performant pour les LLM.

A. Manifeste de Déploiement Créez le fichier ollama-stack.yaml. Ce fichier inclut le Deployment et le Service pour exposer l'API.

apiVersion: v1
kind: Service
metadata:
  name: ollama-service
  namespace: ai-workloads
spec:
  selector:
    app: ollama
  ports:
    - protocol: TCP
      port: 11434
      targetPort: 11434
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-llm
  namespace: ai-workloads
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      containers:
      - name: ollama
        image: ollama/ollama:latest
        ports:
        - containerPort: 11434
        resources:
          limits:
            nvidia.com/gpu: 1  # Verrouille une carte GPU entière
          requests:
            memory: "16Gi"     # Ajustez selon la taille du modèle
            cpu: "4"
        volumeMounts:
        - name: ollama-storage
          mountPath: /root/.ollama
      volumes:
      - name: ollama-storage
        emptyDir: {} # ⚠️ En prod : Remplacez par un PersistentVolumeClaim (PVC)

B. Application

oc create ns ai-workloads
oc apply -f ollama-stack.yaml

C. Chargement du Modèle Une fois le pod démarré, téléchargez le modèle (ici llama3) directement dans le conteneur. Note : Pour la production, pré-construisez une image Docker contenant déjà les modèles.

oc exec -it deployment/ollama-llm -n ai-workloads -- ollama run llama3
# Une fois le prompt ">" affiché, faites Ctrl+D pour sortir, le modèle est chargé.

Sécurité et Bonnes Pratiques 🔐

  1. Gestion des Privilèges (SCC) : Le GPU Operator a besoin de droits élevés. Assurez-vous que les SCC (Security Context Constraints) sont appliquées correctement au ServiceAccount de l'opérateur, mais ne donnez pas de droits privilégiés au pod Ollama lui-même (sauf si nécessaire pour le montage de périphériques spécifiques, ce qui est géré par le Device Plugin).
  2. Network Policies : Isolez votre IA.
    • Interdisez l'accès internet sortant au pod Ollama (sauf pour le pull initial des modèles).
    • Autorisez l'entrée sur le port 11434 uniquement depuis vos applications frontales (ex: UI Chatbot, RAG backend).
  3. Supply Chain : Utilisez des images signées. Scannez l'image ollama/ollama avec Red Hat ACS (Advanced Cluster Security) pour détecter les vulnérabilités avant le déploiement.

Observabilité 📈

Le GPU Operator déploie nvidia-dcgm-exporter. Configurez la stack Prometheus d'OpenShift pour scraper ce service.

Métriques clés à surveiller (PromQL) :

  • Charge GPU : DCGM_FI_DEV_GPU_UTIL
  • Mémoire VRAM utilisée : DCGM_FI_DEV_FB_USED
  • Throttle thermique : DCGM_FI_DEV_GPU_TEMP

Tests et Validation ✅

1. Smoke Test GPU Vérifiez que le conteneur voit bien la carte via nvidia-smi :

oc exec -it deployment/ollama-llm -n ai-workloads -- nvidia-smi

2. Test d'Inférence (API) Depuis un autre pod dans le cluster (ou via un terminal oc debug), testez l'API :

curl http://ollama-service.ai-workloads:11434/api/generate -d '{
  "model": "llama3",
  "prompt": "Explique-moi Kubernetes en une phrase.",
  "stream": false
}'

Erreurs Fréquentes & Diagnostics (Troubleshooting)

Symptôme Cause Probable Solution
Pod en Pending Aucun nœud n'a de GPU disponible ou les Taints NVIDIA bloquent le scheduling. Vérifiez oc describe node pour les labels nvidia.com/gpu. Ajoutez une toleration dans le YAML si le GPU Operator a "tainted" le nœud.
OOMKilled Le modèle est trop gros pour la VRAM de la carte. Utilisez une version quantifiée ("q4_0", "q5_k_m") ou passez sur une carte A100/H100.
CrashLoopBackOff Problème de driver NVIDIA sur le nœud hôte. Vérifiez les logs du pod nvidia-driver-daemonset dans le namespace de l'opérateur.

Checklist de Mise en Prod 🚀

  • NFD et GPU Operator sont stables et à jour.
  • Un PersistentVolume rapide (SSD/NVMe) est configuré pour /root/.ollama afin d'éviter de retélécharger les modèles.
  • Les ResourceQuotas du namespace prennent en compte les GPU.
  • Les alertes Prometheus (VRAM saturée, Température critique) sont actives.
  • Le MIG (Multi-Instance GPU) est configuré si vous utilisez des cartes A100/A30 pour partitionner les ressources.

Conclusion

Vous disposez maintenant d'un socle OpenShift AI-ready. Cette infrastructure vous permet d'internaliser vos traitements IA, garantissant performance et confidentialité. La prochaine étape ? Connecter ce backend Ollama à une interface comme Open WebUI ou l'intégrer dans vos pipelines CI/CD pour des tests automatisés assistés par IA.