Magazine LLM Opensource · 12 October 2026

Kubernetes, DRA et llm-d : l’infrastructure LLM-native passe à l’échelle en 2026

Qwen3.8-Max pèse 2,4 billions de paramètres, Kimi K3 et DeepSeek V4 Pro rivalisent avec les meilleurs modèles propriétaires, GLM-5.3 vient de talonner Kimi K3 au sommet des classements, Hy4 de Tencent s’ajoute à la course avec 770 milliards de paramètres — et Mistral Large 4, « Le Chonk », vient rappeler le 6 octobre que l’Europe n’a pas dit son dernier mot avec ses 1 000 milliards de paramètres. Pourtant le vrai goulot d’étranglement n’est plus le modèle, c’est l’infrastructure qui le sert. Pendant que les poids ouverts s’empilent sur Hugging Face, une bataille plus discrète mais tout aussi décisive se joue dans les couloirs de Kubernetes : comment ordonnancer des dizaines de milliers de GPU, partitionner finement les cartes les plus chères du marché, et surveiller en temps réel des clusters qui consomment des mégawatts. Bienvenue dans l’infrastructure LLM-native.

Le GPU est le nouveau pétrole, Kubernetes le nouveau pipeline

Il y a encore trois ans, déployer un LLM en production relevait de l’exploit artisanal : quelques GPU monolithiques, un script Python, et beaucoup de prières. En 2026, la donne a changé du tout au tout. Alibaba a dévoilé Qwen3.8-Max le 3 août 2026, un modèle open source de 2,4 billions de paramètres avec une fenêtre de contexte d’un million de tokens — une taille qui aurait semblé absurde il y a deux ans. Kimi K3 de Moonshot AI, présenté comme le plus grand modèle open source jamais développé, a fait sensation fin juillet. Et la liste des modèles ouverts de qualité ne cesse de s’allonger : DeepSeek V4 Pro est sorti de sa préversion le 12 août 2026 (build V4 Pro 0813), GLM-5.3 de Z.ai a été lancé le 14 août 2026 — un modèle MoE de 743 milliards de paramètres qui réutilise la base de GLM-5.2 sans aucun nouveau paramètre, mais qui, par le seul post-entraînement, fait passer Terminal-Bench 3.0 de 4,6 % à 28,3 % et s’impose en tête du benchmark cybersécurité CyberGym avec 84,5 %, devançant Claude Sonnet 5 et GPT-5.6 Sol. Meta a publié les 10-11 août Muse Glimmer, un modèle agentique multimodal de 30 milliards de paramètres sous licence Apache 2.0, conçu pour tourner sur un simple PC ou Mac — un retournement spectaculaire après quatre mois de verrouillage. Fin août, Tencent a ouvert à son tour les poids de Hy4 preview, un modèle de 770 milliards de paramètres (49 milliards d’actifs) avec un contexte d’un million de tokens, pensé pour le codage, la bureautique et la recherche scientifique.

Et l’automne n’a pas ralenti le mouvement. Le 5 octobre 2026, Reflection AI — soutenue par Nvidia — a dévoilé Beam, son premier modèle à poids ouverts : un système Mixture-of-Experts sparse de 501 milliards de paramètres (23 milliards actifs), taillé pour le codage, le raisonnement et les usages agentiques. Le pari de Reflection est moins la performance brute que l’économie de calcul : selon Help Net Security, Beam revendique 3 à 4 fois moins de calcul d’inférence que ses rivaux, quitte à traîner sur les benchmarks de code. Le lendemain, 6 octobre, Mistral a frappé un grand coup avec Mistral Large 4, surnommé « Le Chonk » : plus de 1 000 milliards de paramètres dont 49 milliards activés par requête, multimodal, orienté agents, cyberdéfense et analyse géospatiale. L’aperçu public a été ouvert le 6 octobre, les poids sont annoncés sur Hugging Face pour le 27 octobre — un détail qui compte pour la suite de cet article. Cloudflare, enfin, a publié début octobre ses modèles de décision Clef 27B et Clef-flash 9B sous Apache 2.0, avec des latences revendiquées de 38,8 ms contre 524 ms pour Jev.

Mais voici le paradoxe : un modèle de 2,4T de paramètres ne sert à rien s’il n’y a pas d’infrastructure capable de le faire tourner. Chaque requête d’inférence sur un tel modèle mobilise des centaines de gigaoctets de mémoire GPU, des dizaines de cartes interconnectées par NVLink, et une orchestration millimétrée pour que la latence reste acceptable. C’est là que Kubernetes entre en scène.

L’orchestrateur de conteneurs domine désormais le paysage : selon Jonathan Bryce, directeur exécutif de la CNCF, « 66 % des organisations utilisent déjà Kubernetes comme système d’exploitation pour l’IA », une statistique citée lors de l’annonce du programme du KubeCon Japan 2026. Les clusters de calcul pour l’IA atteignent des tailles que personne n’imaginait : Run:ai et CoreWeave démontrent des déploiements de plus de 50 000 GPU sur Kubernetes. OpenAI, selon des données non officielles rapportées par le blog Introl, orchestrerait 25 000 GPU à travers plusieurs clusters pour entraîner GPT, avec un taux d’utilisation de 97 % et des pannes GPU toutes les 2,5 heures en moyenne.

Ces chiffres, il faut le dire, sont à prendre avec des pincettes : ils proviennent d’une source unique, un blog tiers daté de décembre 2025, sans recoupement indépendant. Mais même s’ils sont approximatifs, ils dessinent une tendance claire : Kubernetes est devenu la couche de contrôle incontournable pour servir les LLM à grande échelle. Et avec cette centralité viennent deux défis majeurs : l’ordonnancement des GPU (comment allouer efficacement des ressources coûteuses et hétérogènes) et l’observabilité (comment savoir ce qui se passe réellement dans un cluster de plusieurs milliers de nœuds).

KubeCon 2026 : quand Kubernetes apprend à parler GPU

L’année 2026 a été marquée par une série d’événements qui cristallisent cette convergence. Le KubeCon + CloudNativeCon Japan, tenu fin juillet à Yokohama, a été le théâtre d’annonces majeures. Selon TechTimes, la communauté cloud-native y a franchi un cap : « l’ordonnancement GPU, l’observabilité et l’autorisation ont tous atteint la maturité de production en même temps, et c’est le premier KubeCon où les praticiens peuvent repartir en sachant que la pile complète est prête ». Trois conditions bloquantes ont été levées simultanément : la DRA (Dynamic Resource Allocation) a atteint la disponibilité générale dans Kubernetes 1.34 (sorti en août 2025) et est activée par défaut ; OpenTelemetry a gradué ; et un nouveau Special Interest Group « AI Infrastructure » a fait ses débuts sous Cloud Native Community Japan.

Mais l’événement qui a réellement fait basculer l’infrastructure LLM-native est le KubeCon + CloudNativeCon Europe 2026, tenu à Amsterdam au printemps. Non pas une mais trois annonces majeures y ont été faites — et c’est leur combinaison qui compte.

NVIDIA donne son pilote DRA au projet Kubernetes. Le constructeur a annoncé le don de son pilote Dynamic Resource Allocation (DRA) pour GPU au projet Kubernetes, avec un transfert de gouvernance vers le SIG-Node de la CNCF. La proposition a été soumise en février 2026 par Kevin Klues, ingénieur NVIDIA, sur la liste de diffusion des développeurs Kubernetes. Le code source est disponible sur GitHub sous licence Apache 2.0.

Cette décision est lourde de sens. Pendant des années, NVIDIA a maintenu ses pilotes GPU comme des composants propriétaires, intégrés à son GPU Operator mais contrôlés par l’entreprise. En les donnant à la communauté, NVIDIA acte une réalité : Kubernetes est devenu le système d’exploitation de l’IA, et il vaut mieux être un citoyen de première classe dans cet écosystème qu’un fournisseur périphérique.

La réception a été unanime, selon le site Goodtech.info qui cite les déclarations des acteurs : Sergey Kanzhelev, responsable du SIG-Node, s’est dit enthousiaste ; Microsoft collabore pour l’intégration avec Azure RDMA ; AWS a rendu DRA disponible en général sur EKS à partir de Kubernetes 1.33 ; Google Cloud l’adopte pour les GPU et TPU sur GKE ; Red Hat l’intègre dans OpenShift ; SUSE y voit un accélérateur pour sa distribution.

Le timing est crucial. Le pilote cible Kubernetes 1.32 et versions ultérieures, et DRA a atteint la disponibilité générale dans Kubernetes 1.34, sorti en août 2025 — un point confirmé par le blog officiel Kubernetes et par la couverture du KubeCon Japan 2026. Notons une divergence entre les sources : le blog Introl, daté de décembre 2025, affirmait déjà que DRA était GA en 1.31+. Il est possible que la version 1.31 ait introduit une première forme de DRA, affinée ensuite jusqu’à la GA complète en 1.34. Quoi qu’il en soit, la dynamique est claire : l’allocation dynamique des ressources est devenue une fonctionnalité standard de Kubernetes, et NVIDIA en a fait le véhicule de son support GPU de nouvelle génération.

IBM, Red Hat et Google Cloud donnent llm-d à la CNCF. Le même KubeCon Europe 2026 a vu l’annonce du don de llm-d, un framework open source d’inférence distribuée, à la CNCF comme projet sandbox. Le blog officiel de la CNCF date cette acceptation de fin mars 2026, en amont du salon. llm-d, lancé en 2025 par Neural Magic (acquis par Red Hat en 2025), est un blueprint Kubernetes réplicable pour déployer des stacks d’inférence pour n’importe quel modèle, sur n’importe quel accélérateur, dans n’importe quel cloud. Le mouvement est soutenu par NVIDIA et CoreWeave, ainsi que par AMD, Cisco, Hugging Face, Intel, Lambda et Mistral AI. Red Hat a officiellement lancé la communauté et le projet llm-d, comme l’a rapporté Computer Weekly.

Concrètement, llm-d transforme l’inférence LLM en un système distribué : il sépare les phases de préfill et de decode (désagrégation) et les exécute sur des pods distincts, permettant de scaler et de tuner chaque phase indépendamment. Il ajoute une couche de routage et d’ordonnancement LLM-aware via une extension de gateway qui route les requêtes en fonction de l’état du KV-cache, de la charge des pods et des caractéristiques matérielles, pour améliorer latence et débit. Enfin, il fournit une stack modulaire sur Kubernetes utilisant vLLM comme moteur d’inférence — llm-d ne remplace ni vLLM ni KServe, il se construit au-dessus et autour d’eux. L’objectif, selon Carlos Costa, IBM Research Distinguished Engineer, est de « faire du serving de modèles à grande échelle un workload cloud-native de première classe ».

KAI Scheduler et Grove complètent la pile. La troisième brique, moins médiatisée mais tout aussi structurante, est l’arrivée du KAI Scheduler comme projet CNCF Sandbox, accompagné de Grove (issu de NVIDIA Dynamo). KAI Scheduler gère l’ordonnancement des workloads GPU à l’échelle du cluster — files d’attente, priorités, préemption, co-placement de groupes de GPU — tandis que Grove orchestre la topologie fine des déploiements d’inférence. C’est l’assemblage de ces quatre composants — llm-d, DRA, KAI Scheduler, Grove — qui forme ce que la communauté appelle désormais la « pile d’inférence LLM Kubernetes-native ».

Cette triple annonce marque un tournant : la CNCF s’empare officiellement du sujet de l’inférence LLM, et les grands acteurs (NVIDIA, IBM, Red Hat, Google) alignent leurs stratégies sur Kubernetes comme socle commun. Comme le résume Kaden Projects, « pris individuellement, chacun de ces composants ressemble à un progrès incrémental ; pris ensemble, ils décrivent une pile complète pour l’inférence LLM en production ».

DRA et le partitionnement fin : du GPU monolithique au GPU partagé

Pour comprendre l’importance de la DRA, il faut revenir à la situation antérieure. Kubernetes, à l’origine, traitait les GPU comme des ressources comptables opaques — une simple métrique nvidia.com/gpu sans notion de topologie, de partitionnement, ni de différence entre entraînement distribué et inférence. Le scheduler ne connaissait ni la topologie NVLink vs InfiniBand, ni les contraintes de co-placement. Résultat : des GPU sous-utilisés, des performances aléatoires, et une gestion des coûts approximative.

La DRA change la donne en permettant des demandes structurées basées sur des attributs : mémoire, partitions de calcul, contraintes de topologie. Comme le résume TechTimes, elle « permet aux workloads de déclarer des exigences spécifiques en matière de GPU et d’accélérateurs en utilisant des règles basées sur des expressions plutôt qu’en demandant des nombres entiers de dispositifs opaques ». Concrètement, elle ouvre la voie au partitionnement fin des GPU, une nécessité absolue quand une carte H100 coûte plusieurs dizaines de milliers d’euros et que personne ne veut la gaspiller pour un petit modèle d’inférence.

Trois grandes familles de partitionnement coexistent :

Le MIG (Multi-Instance GPU) de NVIDIA — la solution la plus mature. Elle permet de découper physiquement un GPU en plusieurs instances isolées, chacune avec sa propre mémoire et ses propres cœurs de calcul. Les découpages typiques vont de 1g.5gb (un septième du GPU, 5 Go de mémoire) à 2g.10gb (deux septièmes, 10 Go). Le MIG offre une isolation matérielle réelle : une instance qui plante n’affecte pas ses voisines. C’est la solution idéale pour l’inférence de modèles de petite et moyenne taille, où l’on peut servir plusieurs modèles sur une même carte physique sans risque d’interférence. NVIDIA a amélioré sa gestion MIG dans le GPU Operator 24.6+, qui ajoute également le support de l’architecture Blackwell.

Le time-slicing — une approche logicielle qui consiste à faire tourner plusieurs workloads sur un même GPU en partageant le temps de calcul. C’est simple à mettre en œuvre, mais l’isolation est faible : un workload gourmand en calcul peut dégrader les performances de ses voisins. Pour l’inférence LLM, c’est souvent un pis-aller, acceptable pour des charges légères ou des tests, risqué pour de la production.

Le vGPU (GPU virtuel) — une couche de virtualisation qui permet de partager un GPU physique entre plusieurs machines virtuelles ou conteneurs. Les solutions commerciales (NVIDIA vGPU, ou des alternatives open source) offrent un bon compromis entre flexibilité et isolation, mais ajoutent une couche de complexité et un léger surcoût en performance.

Le choix entre ces approches dépend du workload. Pour l’inférence de modèles de 7 à 13 milliards de paramètres, le MIG est souvent le meilleur choix : on peut servir plusieurs modèles sur une seule H100 avec une isolation correcte. Pour l’entraînement distribué, en revanche, le partitionnement est contre-productif : il faut au contraire agréger les GPU en groupes homogènes interconnectés par NVLink.

Un piège classique, rapporté par le blog Introl : une mauvaise planification qui sépare des GPU connectés via NVLink peut causer une dégradation de performance de 8x. Concrètement, si le scheduler place deux GPU d’un même groupe tensoriel sur des nœuds physiques différents reliés seulement par Ethernet, la communication inter-GPU devient le facteur limitant, et le débit s’effondre. C’est précisément ce que KAI Scheduler et la DRA cherchent à éviter en rendant la topologie explicite dans les demandes de ressources : on ne demande plus « un GPU », on demande « un GPU avec 80 Go de mémoire, dans le même domaine NVLink que tel autre, avec une partition MIG 3g.40gb ».

La désagrégation préfill/decode : la vraie rupture de 2026

Si la DRA règle le problème de l’allocation, elle ne règle pas celui de l’efficacité du serving lui-même. C’est là qu’intervient le concept le plus important de l’année pour l’inférence à grande échelle : la désagrégation préfill/decode.

L’idée est simple à énoncer, complexe à mettre en œuvre. Le traitement d’un prompt (préfill) est une phase compute-bound : elle parallélise sur les tokens d’entrée et sature les FLOPS du GPU. La génération des tokens de sortie (decode) est memory-bandwidth-bound : elle est autorégressive, séquentielle, et relit en boucle le KV-cache. Ces deux phases ont des besoins matériels fondamentalement différents. Les faire tourner sur le même GPU revient à n’optimiser ni l’une ni l’autre — et surtout, cela empêche de les scaler indépendamment.

La désagrégation consiste à les exécuter sur des pods distincts, avec des pools de GPU dimensionnés séparément. On peut alors allouer beaucoup de GPU au préfill (qui aime les gros calculs parallèles) et un nombre différent au decode (qui aime la bande passante mémoire), et ajuster les deux en fonction de la charge réelle. C’est exactement ce que fait llm-d, en s’appuyant sur vLLM pour l’exécution.

Le second pilier est le routage cache-aware. Un Service Kubernetes standard route les requêtes en round-robin, sans savoir quel pod a déjà le préfixe de KV-cache pertinent en mémoire. Chaque cache miss ajoute de la latence au TTFT (Time To First Token). Sous charge, cela se cumule : un pod surchargé continue de recevoir des requêtes alors qu’un pod voisin a déjà le cache chaud. llm-d ajoute une extension de gateway qui route en fonction de l’état du KV-cache, de la charge des pods et des caractéristiques matérielles.

Les chiffres revendiqués sont spectaculaires : selon Kaden Projects, la combinaison llm-d + DRA + KAI Scheduler + Grove permet jusqu’à 57x plus rapide sur le TTFT et 2x de débit agrégé par rapport à un serving en round-robin. Il faut prendre ces chiffres pour ce qu’ils sont — des mesures constructeur sur des configurations de référence, avec du réseau RDMA (InfiniBand ou RoCE), au moins 8 GPU NVIDIA, et Kubernetes 1.34.2+ recommandé. Sur un seul nœud ou un poste de travail, la recommandation reste le vLLM standalone : cette pile est faite pour les équipes plateforme qui opèrent de l’inférence multi-nœuds et multi-modèles à l’échelle.

Un point de vigilance, cependant : cette pile n’est pas encore un standard figé. Les versions de pilotes requises ont plusieurs mois de retard sur les dernières sorties matérielles, et l’intégration entre KAI Scheduler et DRA reste en cours de maturation. Les équipes qui l’adoptent aujourd’hui sont des early adopters qui acceptent une certaine instabilité en échange d’un avantage de performance.

Observabilité : voir ce qui se passe vraiment dans un cluster de 50 000 GPU

Le troisième pilier de l’infrastructure LLM-native est l’observabilité. Un cluster de plusieurs milliers de nœuds GPU qui consomme des mégawatts ne se pilote pas à l’aveugle. Et les métriques classiques de Kubernetes — CPU, mémoire, réseau — ne suffisent pas.

Ce qu’il faut mesurer dans un cluster d’inférence LLM est spécifique : le TTFT par requête, le débit de tokens par seconde et par pod, le taux d’occupation du KV-cache, le taux de cache hit, la latence de communication inter-GPU, la température et la puissance des cartes, et surtout le taux d’utilisation réel des GPU — pas le taux d’allocation, qui est une fiction comptable, mais le pourcentage de temps où les cœurs de calcul tournent effectivement.

C’est là qu’OpenTelemetry entre en jeu. Sa graduation au KubeCon Japan 2026 a été saluée comme l’un des trois déblocages majeurs de l’année. Le standard de télémétrie permet de tracer une requête de bout en bout à travers les couches : gateway, routeur cache-aware, pod de préfill, pod de decode, et jusqu’au GPU lui-même. Sans cette traçabilité, diagnostiquer une régression de latence dans un système désagrégé devient un cauchemar — on ne sait pas si le problème vient du routage, du préfill, du decode, ou du réseau.

Les outils de la CNCF se sont adaptés : Prometheus collecte les métriques GPU exposées par le DCGM exporter de NVIDIA, Grafana les visualise, et les dashboards communautaires pour llm-d commencent à circuler. Mais l’enjeu dépasse l’outillage : il touche à la compétence. Comme le souligne CTO at Work, Kubernetes étant devenu le système d’exploitation de l’IA, la question n’est plus seulement « comment déployer un modèle » mais « comment repenser la compétence DevOps » pour une infrastructure où le GPU est la ressource critique et où la topologie réseau détermine la performance.

Ce que cela change pour les praticiens

Pour les équipes qui déploient des LLM open source en production, l’année 2026 marque un basculement net. Trois conséquences concrètes.

Premièrement, la barrière à l’entrée de l’inférence sérieuse s’est déplacée. Elle n’est plus dans le modèle — les poids ouverts de qualité sont disponibles gratuitement, de Qwen3.8-Max à Mistral Large 4 en passant par Beam. Elle est dans la capacité à orchestrer efficacement des GPU hétérogènes. Une équipe qui sait faire tourner llm-d avec DRA sur un cluster multi-nœuds peut servir des modèles de frontière à un coût marginal bien inférieur à celui d’une API propriétaire. Une équipe qui ne sait pas le faire reste dépendante des fournisseurs cloud.

Deuxièmement, la souveraineté redevient un argument technique, pas seulement politique. Mistral Large 4, entièrement entraîné en Europe et dont les poids arrivent sur Hugging Face le 27 octobre, s’inscrit dans cette logique : maîtriser le modèle ne sert à rien si l’on ne maîtrise pas aussi la pile qui le sert. C’est pourquoi les annonces de la CNCF — DRA, llm-d, KAI Scheduler — ont une portée qui dépasse la technique : elles donnent aux acteurs non-américains une base open source pour construire leur propre infrastructure d’inférence.

Troisièmement, la frontière entre local et cloud se brouille. Un modèle comme Muse Glimmer (30 milliards de paramètres, Apache 2.0) tourne sur un PC ; un modèle comme Mistral Large 4 (1 000 milliards de paramètres) nécessite un cluster. Entre les deux, la même pile logicielle — vLLM, llm-d, Kubernetes — s’applique, à des échelles différentes. C’est la promesse de llm-d : « n’importe quel modèle, sur n’importe quel accélérateur, dans n’importe quel cloud ». Reste à voir si la promesse tient face à la diversité réelle du matériel et à la complexité opérationnelle.

Une chose est sûre : en 2026, le débat sur les LLM open source ne se joue plus seulement sur les benchmarks des modèles. Il se joue sur la capacité à les faire tourner. Et sur ce terrain, Kubernetes a gagné.

Sources

• Welcome llm-d to the CNCF: Evolving Kubernetes into SOTA AI Infrastructure — CNCF, 24 mars 2026
• Kubernetes LLM Inference Stack 2026: llm-d, DRA & KAI — Kaden Projects, 2026
• llm-d Joins CNCF Sandbox: Kubernetes-Native LLM Inference Is Here — Toolhalla, 2026
• llm-d: Kubernetes-Native Distributed LLM Inference and CNCF’s Answer to the AI Inference Gap — IT-Stud, 2026
• Kubernetes est devenu le système d’exploitation de l’IA : faut-il repenser la compétence DevOps ? — CTO at Work, 2026
• Kubernetes OS par défaut de l’IA 2026 : inférence à l’échelle — AlgeriaTech, 2026
• Reflection debuts Beam, an open-weight AI model to rival Chinese models at lower compute cost — TechCrunch, 5 octobre 2026
• Reflection’s Beam trails top open models on coding tests but claims lower inference compute — Help Net Security, 6 octobre 2026
• Mistral dévoile Large 4, un modèle à plus de 1 000 milliards de paramètres — Le Monde Informatique, 7 octobre 2026
• Mistral Large 4, le modèle à 1 000 milliards de paramètres surnommé Le Chonk — Korben, 7 octobre 2026
• Sortie de Mistral Large 4 : aperçu API et poids — NeoTeo, 7 octobre 2026
• Mistral Says Its New AI Model ‘Le Chonk’ Is the Best Open-Weight Offering Outside of China — Wired, 6 octobre 2026
• Cloudflare Clef : l’open source 13 fois plus rapide que Jev — AI-Stat, 3 octobre 2026
• Clef-Flash vs Qwen3-8B : probabilités vs prose — OrcaRouter, 2 octobre 2026
• Blog Introl (décembre 2025) — données non officielles sur les clusters OpenAI, à considérer avec prudence
• TechTimes — couverture du KubeCon + CloudNativeCon Japan 2026 (Yokohama)
• Goodtech.info — déclarations des acteurs sur le don du pilote DRA NVIDIA
• Computer Weekly — lancement de la communauté et du projet llm-d par Red Hat

Article recherché et rédigé automatiquement · Magazine Electrosens