La boutique est ouverte

Nous construisons les machines Workstation AI pour les sites web, les agents IA et l'entraînement de LLM — configurez-les et achetez-les en ligne.

Obtenir les prix pro
Produits IA
Labs IAAgents OpenAIAgents ClaudeGrok BotCRM natif Workstation AIMarketingTous les produits
Solutions IA
IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseStations de travail IAMatériel et logiciels NVIDIACalcul accéléré NVIDIAIA privéeCloud privé GPUClusters GPUIA en périphérieIA par secteur
Services IA
Modernisation des plateformesIngénierie numériqueFondations data et IAOpérations autonomesConseil IAAutomatisation DevOpsCybersécuritéDéveloppement logicielCréation d'agentsMise en place MLOpsLocation de GPUCloud privé GPU
À propos
EntrepriseNotre histoirePartenairesTémoignages clients
Centres de données IA
Centres de données IACloud privé GPUClusters GPULocation de GPU
Analyses IASérie JevLabo de benchmarksChoix de modèles
Notes techniques
Documentation
OS LinuxUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
Plateformes cloud d'IAAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryClouds et places de marché GPU
Centres de données IA privésPour les cabinets d'avocatsPour les cabinets comptablesPlateformes sur siteCloud entièrement sécurisé
OutilsRing PromoterJobshout
Actualités
Blog
Nous contacterSe connecter

Stations de travail IA, logiciels multi-agents IA, infrastructure GPU et solutions d'agents intelligents pour les entreprises modernes.

Nous contacter

Solutions IA

IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseIA par secteur

Produits

Tous les produitsCRM & ERP natifs Workstation AIMarketingAgents OpenAIRing PromoterJobshout

Entreprise

À proposEntrepriseCentres de données IAPourquoi WorkstationPartenairesTémoignages clientsTarifsContactTenthMatrix

Ressources

Analyses IANotes techniquesDocumentationOS LinuxPlateformes cloud d'IACentres de données IA privésBlogRechercherPlan du site
Bureau de Belgique
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Lun - Ven : 9h00 - 18h00 CET
+32 492 45 67 46
Siège social au Royaume-Uni
77-79 Marlowes, Hemel Hempstead HP1 1LFItinéraire : prenez la sortie 20 de la M25, Outer LondonN° d'entreprise: 11641870Lun - Ven : 9h00 - 18h00 GMT
+44 7515 356 146
Bureau de l'Inde
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Bureau de Taïwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Lun - Ven : 9 h 00 - 18 h 00, heure de Taïwan (GMT+8)
+886 926 892 701+32 492 45 67 46
Bureau en Estonie
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaLun - Ven : 9 h 00 - 18 h 00, heure d’Estonie (EET)
+32 492 45 67 46

© 2026 Workstation AI. Tous droits réservés.

ConfidentialitéSuppression des donnéesCookiesConditions d'utilisationPlan du site web

NVIDIA, le logo NVIDIA, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX et HGX sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. AMD, le logo AMD Arrow, EPYC, Instinct, Ryzen et Threadripper sont des marques commerciales d'Advanced Micro Devices, Inc. Dell et PowerEdge sont des marques commerciales de Dell Inc. ou de ses filiales. Intel et Xeon sont des marques commerciales d'Intel Corporation ou de ses filiales. AMAX, AceleMax et LiquidMax sont des marques commerciales d'AMAX Engineering Corporation. Tous les autres noms de produits, logos et marques appartiennent à leurs propriétaires respectifs. Nous les utilisons uniquement pour identifier les produits que nous décrivons, fournissons ou prenons en charge ; leur utilisation ne signifie pas que leurs propriétaires nous cautionnent.

Accueil / Notes techniques / Technology
AIKubernetesDevOpsNVIDIA

Note technique NVKE et NVKR : construire un service Kubernetes GPU géré à partir du bare metal, avec des builds reproductibles et vérifiables

Architecture, composants et versions figées, le cycle Definition-Run-Release-Verify de NVKR, le workflow nvkectl complet des serveurs en rack jusqu'au cluster client, l'attestation des nœuds, l'exploitation au quotidien, chaque limitation de la préversion avec son atténuation, une comparaison avec d'autres approches et un plan d'évaluation par étapes

14 novembre 2026Technology26 min read

Un guide pratique de NVIDIA Kubernetes Engine (NVKE) et NVIDIA Kubernetes Recipes (NVKR), les deux projets open source que NVIDIA a publiés en préversion publique lors de la KubeCon North America du 10 novembre 2026. Il couvre l'architecture, chaque composant et chaque version figée, le cycle de build et de vérification de NVKR, le workflow complet depuis des serveurs installés en rack jusqu'à un cluster GPU client, le modèle de sécurité, l'exploitation au quotidien, les limitations connues de la préversion avec une liste de durcissement pour chacune, la comparaison de NVKE avec d'autres façons d'exploiter Kubernetes sur GPU, et un plan d'évaluation par étapes.

Un terminal affichant les commandes nvkectl qui amorcent un cluster de gestion, publient un release set et créent un cluster client, à côté des versions figées dans la préversion : Kubernetes 1.36.3, Cluster API 1.13.6, CAPNICo 0.1.0, OVN-Kubernetes 2.4.2 et SPIRE 1.14.1.

Synthèse. NVKR transforme une Definition déclarée, aux versions figées, en images de nœud, images de conteneurs, charts Helm et binaires, avec des SBOM, une provenance et des signatures que vous vérifiez selon votre propre politique. NVKE est un plan de gestion qui s'exécute sur un cluster de gestion à trois nœuds et utilise Cluster API avec le fournisseur CAPNICo pour obtenir des machines bare metal auprès de NVIDIA Infra Controller (NICo). Il crée des clusters de charges de travail isolés, chacun avec son propre plan de contrôle, son propre etcd et ses propres pools de nœuds GPU, et n'admet un nœud qu'après une attestation SPIFFE/SPIRE adossée au TPM. Les deux sont sous licence Apache 2.0 et en préversion publique : l'API est livrée en HTTP simple avec l'authentification désactivée, il n'existe pas de couche d'autorisation, et le cluster de gestion ne dispose encore d'aucune procédure de mise à niveau ni de sauvegarde. Évaluez-le dès maintenant ; prévoyez la production pour après la préversion.

Cette note technique accompagne notre article orienté métier, NVIDIA NVKE et NVKR : pourquoi Kubernetes pour GPU devient le système d'exploitation de l'usine d'IA. Tout ce qui suit est tiré de la présentation accompagnant l'annonce de NVIDIA, de la documentation de NVKE et des dépôts NVKE et NVKR au 14 novembre 2026. Les commandes sont celles de NVIDIA, sauf indication contraire signalant un exemple de Workstation. Les deux projets évoluent rapidement pendant la préversion ; vérifiez donc toujours la documentation actuelle pour les options et les champs.

1. Le problème que NVKE et NVKR se partagent

Une usine d'IA (le terme de NVIDIA pour un centre de données conçu pour produire de l'IA à grande échelle) qui veut vendre ou partager de la capacité GPU sous forme de Kubernetes fait face à deux problèmes distincts :

  1. Exploiter un service Kubernetes géré. Provisionnement piloté par API, isolement des locataires, mises à niveau, remplacement de nœuds et reprise, adossés à des engagements de service.
  2. Qualifier les logiciels. Savoir quelle combinaison de système d'exploitation, de noyau, de Kubernetes, de plug-in réseau, d'agents et d'environnement d'exécution GPU fonctionne sur quelle génération de GPU, et pouvoir reconstruire exactement cette combinaison plus tard.

NVKE prend en charge le premier problème et NVKR le second. Ils sont délibérément séparables : NVKE n'a aucune dépendance d'exécution envers NVKR, et NVKR peut construire des artefacts pour d'autres systèmes de gestion Kubernetes. L'usine garde la maîtrise de ses propres logiciels, de son exploitation, de son service et de son expérience client.

2. Les composants en un coup d'œil

ComposantRôleOù il s'exécute
Plan de gestion NVKEAPI REST et contrôleurs qui créent et exploitent les clusters de charges de travailLe cluster de gestion (trois serveurs CPU)
nvkectlCLI de l'opérateur : amorce le site, publie les release sets, crée les clusters, récupère les kubeconfigsHôte d'amorçage et postes de travail des opérateurs
Cluster d'amorçage (seed)Cluster kind temporaire à un seul nœud qui forme le cluster de gestion, puis est suppriméHôte d'amorçage
Cluster API + CAPNICoInterface de provisionnement Kubernetes standard, avec le fournisseur d'infrastructure Cluster API pour NICoCluster de gestion
NICo (NVIDIA Infra Controller)Cycle de vie bare metal : capacité enrôlée, VPC et préfixes, types d'instances, démarrage iPXEVotre site (installation distincte)
Serveur et agents SPIREAttestation des nœuds par TPM et identités SPIFFE ; un nœud n'obtient ses identifiants d'adhésion qu'après attestationCluster de gestion et chaque nœud
Agent de nœud NVKEAgent sur le nœud, compilé dans l'image de nœud par NVKRChaque nœud
OVN-Kubernetes et NodeLocal DNSCacheRéseau du cluster et cache DNS, installés par NVKE lors du provisionnementChaque cluster de charges de travail
Chaîne de télémétrie NVKE (NKTP)Chart Helm basé sur OpenTelemetry qui collecte journaux, métriques et traces et les exporte via OTLPClusters de gestion et de charges de travail
NVKRCLI, catalogues de composants et Definitions déclaratives qui construisent, signent et publient les artefacts NVKE et AI Cluster Runtime (AICR)Hôte de build ou GitHub Actions
AICR, NodeWright, NVSentinelAjoutés dans les clusters de charges de travail, respectivement pour l'environnement d'exécution accéléré par GPU, les paquets de nœud et l'automatisation de la remise en étatClusters de charges de travail

3. Architecture

NVKR, sur un hôte de build, publie des artefacts vers un registre OCI et un serveur d'images HTTP. Un hôte d'amorçage forme le cluster de gestion NVKE, qui exécute l'API REST, les release sets, Cluster API avec CAPNICo et un serveur SPIRE. Il demande des machines à NICo ; les serveurs GPU et CPU démarrent à partir de l'image de nœud et s'attestent avant de rejoindre les clusters de charges de travail des clients. Les clients utilisent kubectl et l'opérateur nvkectl ; la télémétrie part via OTLP vers votre propre backend.

Le flux de contrôle se lit le plus facilement du point de vue de l'opérateur. L'opérateur ne dialogue qu'avec l'API NVKE, via nvkectl. NVKE traduit une demande de cluster en objets Cluster API ; CAPNICo les transforme en demandes d'instances NICo ; NICo choisit des serveurs du type d'instance demandé dans le préfixe de VPC demandé et les démarre avec le script iPXE de l'image machine choisie. Chaque serveur démarre l'image construite par NVKR, son agent SPIRE s'atteste auprès du serveur SPIRE du cluster de gestion à l'aide du TPM du serveur, et ce n'est qu'alors que le nœud reçoit les identifiants dont il a besoin pour exécuter kubeadm et rejoindre le cluster. Les clients ne voient rien de tout cela : ils reçoivent un kubeconfig pour un cluster qui ressemble à n'importe quel autre cluster Kubernetes 1.36 conforme.

4. Versions figées dans la préversion

La référence de plateforme de NVKE liste la combinaison validée ci-dessous. Le figement est tout l'enjeu : NVKR construit à partir de ces entrées exactes et les enregistre, de sorte qu'un nœud peut être rattaché à ses sources.

ÉlémentVersion de la préversionRemarques
Kubernetes (clusters de gestion et de charges de travail)1.36.31.34.2, 1.35.3 et 1.37.2 sont présents dans l'image de nœud mais non pris en charge
Système d'exploitation des nœudsUbuntu 24.04 LTS ou 26.04 LTSLa MachineImage d'exemple installe Ubuntu 24.04 à partir de l'ISO d'installation
Architectures CPUamd64, arm64Images distinctes par architecture ; les pools de nœuds peuvent utiliser des images différentes
Cluster API (cœur, amorçage kubeadm et plan de contrôle)v1.13.6clusterctl v1.13.6
CAPNICov0.1.0NICo est le fournisseur d'infrastructure par défaut ; LaunchLayer peut aussi être activé
OVN-Kubernetes2.4.2Compilé à partir des sources dans l'image de nœud
Agent SPIRE1.14.1, plugin TPM 1.9.0Version amont figée par somme de contrôle
Outils d'amorçagekind v0.32.0, kubectl v1.36.0, Helm v4.2.4Plus containerd et nerdctl en mode rootful sur l'hôte d'amorçage
Chaîne d'outils Go1.27.4 ou ultérieure pour NVKE ; 1.27.2 figée pour NVKRLe lanceur NVKR propose d'installer localement sa version de Go figée

5. NVKR : Definition, Run, Release, Verify

Le cycle de vie de NVKR : une Definition avec des catalogues et un Environment, un Plan révisable et un graphe de dépendances, un Run exécuté en local ou dans GitHub Actions qui enregistre les sorties et les preuves, et une Release sous forme de référence OCI figée par digest avec SBOM et provenance, vérifiée selon votre propre politique avant que NVKE ne la déploie.

NVKR est un système de build et de publication plutôt qu'une collection de scripts. Son cycle de vie public comporte trois étapes :

  1. Définir les livrables. Une Definition sélectionne des sorties nommées (exécutables, images de conteneurs, charts Helm, bundles de déploiement ou images de nœud), leurs composants, plateformes et formats. Les Catalogs fournissent des sources, artefacts et outils figés. Un Environment fournit les paramètres d'exécution, de registre et de signature.
  2. Inspecter et exécuter. NVKR dérive un Plan et des graphes de dépendances que vous pouvez examiner avant toute exécution, puis l'exécute en local ou génère des workflows GitHub Actions. Chaque Run enregistre ses sorties requises, les artefacts effectivement observés, ses preuves et ses échecs.
  3. Publier et vérifier. Une Release est une référence de registre OCI figée par digest, qui relie les sorties à leurs SBOM et à leur provenance. Les consommateurs choisissent une Verification Policy (l'identité de workflow et l'émetteur qu'ils acceptent) et authentifient les affirmations avant d'utiliser les artefacts.

5.1 Premier build

Le démarrage rapide construit la CLI NVKE, l'image de conteneur du contrôleur et son chart Helm, avec les SBOM des dépendances. Il nécessite Git 2.38 ou ultérieur, Bash et un Docker en cours d'exécution ; le lanceur vérifie les prérequis, sélectionne le compilateur Go figé (en demandant avant de l'installer) et construit NVKR lui-même à partir des sources pour votre architecture CPU :

git clone https://github.com/dsx-ai-factory/nvkr.git &&
cd nvkr &&
bash scripts/nvkr-quickstart.sh

Attendez status: complete et observed outputs: 3. La CLI native est bin/nvkr. Rien n'est publié ni déployé, et un build local n'est pas signé. Pour construire également l'image de nœud, la présentation de NVIDIA exécute un second script :

NVKE_OS_ARCH=amd64 scripts/nvke-os-local.sh node-image-01

Ce build compile l'agent de nœud NVKE et OVN-Kubernetes à partir des sources, ajoute des versions amont figées par somme de contrôle des paquets Kubernetes 1.36 et de l'agent SPIRE, démarre une machine virtuelle à partir de l'installateur Ubuntu, installe les agents et dépose sur disque les paquets Kubernetes et réseau. Le résultat est une image QCOW2. L'hôte de build doit prendre en charge Docker et KVM.

Au-delà du démarrage rapide, la Definition du tutoriel NVKR sélectionne la CLI NVKE, l'image du plan de gestion et le bundle Helm, et la Definition candidate NVKE combinée étend cela aux images de conteneurs et de nœud pour amd64 et arm64.

5.2 Ce que la vérification prouve et ne prouve pas

NVKR est prudent dans ses affirmations, et votre processus de publication doit l'être aussi. Une signature authentifie l'auteur d'une déclaration concernant un artefact ; un digest lie cette déclaration à des octets précis. La signature ne revendique pas la propriété du logiciel contenu, et une signature valide ne suffit pas à rendre un artefact prêt à être déployé.

OpérationCe qu'elle établit
Parcourir une ReleaseInspecte uniquement les métadonnées ; aucune vérification de signature, aucun téléchargement de contenu
Récupérer une sortie (pull)Récupère le contenu et vérifie son intégrité ; ne vérifie ni les signatures ni votre politique
Vérifier authenticityAuthentifie les signatures et les preuves selon votre politique, sans télécharger les contenus
Vérifier artifact-publicationAuthentifie l'affirmation de publication selon votre politique et vérifie les contenus référencés

La vérification nécessite Linux, des outils figés et une politique explicite (les utilisateurs de macOS vérifient dans Docker). Pour la préversion, NVIDIA précise qu'aucune Release NVKR n'est qualifiée, que la vérification prise en charge n'établit ni une reproduction à l'octet près, ni l'absence de vulnérabilités, ni l'aptitude au déploiement, et que les SBOM des images de nœud enregistrent les sujets producteurs et matériels au lieu d'inspecter le contenu réellement installé sur le disque. Considérez les preuves de NVKR comme une donnée d'entrée parmi d'autres de votre propre contrôle de publication, aux côtés de l'analyse des vulnérabilités et de la validation matérielle.

6. Workflow : des serveurs installés en rack à un cluster client

Sept étapes : construire avec NVKR ; préparer les artefacts ; démarrer un cluster d'amorçage avec nvkectl bootstrap site ; basculer vers un cluster de gestion à trois nœuds provisionné par NICo ; installer et sécuriser le plan de gestion ; publier un release set ; créer le cluster client et remettre le kubeconfig.

6.1 Prérequis

  • Trois serveurs CPU pour le cluster de gestion, plus un hôte d'amorçage Linux distinct sur le réseau du site, avec containerd, nerdctl, kind, Helm et kubectl.
  • Trois serveurs CPU pour le plan de contrôle de chaque cluster de charges de travail.
  • Un pool de serveurs GPU pour les nœuds workers.
  • Une installation NICo avec de la capacité enrôlée.
  • Un hôte de build Linux prenant en charge Docker et KVM.
  • Un serveur HTTP pour l'image de nœud, un registre de conteneurs pour l'image du contrôleur, et un accès internet pour les images et charts Helm open source utilisés pendant l'installation.
  • Votre propre autorité de certification SPIRE. Les nœuds du cluster de gestion construits à partir de l'image de nœud ont besoin de vos fichiers d'AC à l'amorçage. Sans eux, SPIRE utilise une AC auto-signée à laquelle aucun nœud ne peut faire confiance à l'avance ; les nœuds ne peuvent donc ni s'attester ni rejoindre le cluster.

6.2 Construire et préparer

Construisez comme à la section 5.1, puis poussez l'image du contrôleur vers votre registre, copiez nvkectl sur l'hôte d'amorçage et placez l'image QCOW2 sur le serveur HTTP. NVIDIA souligne qu'un build d'image local n'est pas une release qualifiée : le build et le test de fumée ne valident ni un véritable démarrage NICo, ni la sélection du disque, ni la configuration complète du premier démarrage. Le provisionnement à partir d'une QCOW2 nécessite aussi un imageur EFI propre au site et un script iPXE qui télécharge l'image et l'écrit sur le disque, validés ensemble sur votre matériel.

6.3 Amorcer le cluster de gestion

nvkectl bootstrap site -f site-a.yaml \
  --nvke-controller-image registry.example.com/nvke/nvke-controller:<tag>

site-a.yaml contient les informations dont NICo a besoin pour provisionner trois serveurs de gestion. La commande démarre sur l'hôte d'amorçage un cluster kind temporaire à un seul nœud, qui héberge les logiciels NVKE nécessaires à la mise en place. Le contrôleur NVKE demande trois serveurs à NICo, NICo les démarre à partir de l'image de nœud et, lorsque les trois ont rejoint le cluster, l'amorçage supprime le cluster temporaire. C'est le schéma classique « bootstrap and pivot » de Cluster API.

Placez immédiatement le kubeconfig d'amorçage et le fichier de clé de chiffrement etcd dans un stockage sécurisé. Ce fichier de clé est la seule copie de la clé de chiffrement etcd du cluster de gestion qui ne se trouve pas sur un nœud, et il n'existe pas encore de procédure de sauvegarde ni de restauration.

6.4 Installer le plan de gestion et connecter nvkectl

Installez le plan de gestion NVKE sur le cluster de gestion, puis exécutez nvkectl config set-site pour diriger la CLI vers l'API NVKE. Pour une installation sans description de release, les images du contrôleur et des profils doivent être préparées sur les nœuds de gestion et nommées dans la configuration de la pile.

Avant que quiconque d'autre puisse y accéder, sécurisez l'API (section 7.2) : après l'installation, elle écoute sur le port 30080 de chaque nœud de gestion, en HTTP simple, avec l'authentification désactivée.

6.5 Publier un release set

Les clients ne manipulent jamais d'images de système d'exploitation ni de cloud-init. Ils choisissent une release nommée que vous publiez. Un release set comporte trois parties :

  1. Image machine : le script iPXE que NICo exécute pour démarrer un serveur.
  2. Release de cluster : une image machine plus la configuration cloud-init qui prépare un nœud de plan de contrôle, en enregistrant la version de Kubernetes qu'elle installe.
  3. Release de pool de nœuds : l'image et la configuration équivalentes pour les nœuds workers.
nvkectl create machineimage -f machineimage.yaml
nvkectl create clusterrelease -f clusterrelease.yaml
nvkectl create nodepoolrelease -f nodepoolrelease.yaml

Traitez les release sets comme un catalogue de produits. Nommez-les de sorte qu'un client sache ce qu'il obtient (l'exemple de NVIDIA utilise k8s-1.36.3-amd64), publiez des releases distinctes par architecture CPU et par génération de GPU, et ne modifiez jamais une release publiée sur place : publiez-en une nouvelle et faites migrer les clients de manière délibérée.

6.6 Créer le cluster client

Une demande de cluster reprend les informations NICo de la spécification du site et y ajoute une version de Kubernetes. Le plan de contrôle et chaque pool de nœuds ont leurs propres types d'instances, préfixes de VPC et release. L'exemple de NVIDIA :

name: customer-a
controlPlaneKubernetesVersion: 1.36.3
etcdEncrypted: true
controlPlaneVIP: 10.0.20.10
nico: {orgID: <org-id>, siteID: <site-id>, vpcID: <vpc-id>}
controlPlaneConfig:
  desiredCount: 3
  nico: {instanceTypePreference: [<cpu-instance-type>], vpcPrefixIDs: [<prefix-id>], release: k8s-1.36.3-amd64}
nodePools:
  - name: gpu
    nodeNamePrefix: gpu
    desiredNodeCount: 4
    nico: {instanceTypeID: <gpu-instance-type>, vpcPrefixIDs: [<prefix-id>], release: k8s-1.36.3-amd64}
nvkectl create cluster -f customer-a.yaml

Le cluster reste à l'état Provisioning jusqu'à ce que le premier nœud de plan de contrôle ait exécuté kubeadm init et que NVKE ait installé OVN-Kubernetes et NodeLocal DNSCache ; il passe alors à Provisioned. Notez etcdEncrypted: true : le chiffrement des données etcd est un choix par cluster, et nous recommandons d'en faire la valeur par défaut dans vos modèles de demande.

6.7 Remettre l'accès

nvkectl get kubeconfig customer-a --output-file customer-a.kubeconfig
kubeconfig written to customer-a.kubeconfig

Il s'agit d'un kubeconfig administrateur, et dans la préversion NVKE ne peut pas le révoquer : il reste valide jusqu'à l'expiration de son certificat client, car NVKE ne renouvelle pas l'autorité de certification d'un cluster de charges de travail. Ne le remettez qu'aux administrateurs du cluster du client, par un canal sécurisé, et demandez-leur de créer immédiatement des identifiants plus restreints dans le cluster. Un exemple de Workstation utilisant le RBAC Kubernetes standard :

# Workstation example: run once with the admin kubeconfig, then store it offline
export KUBECONFIG=customer-a.kubeconfig
kubectl create namespace ml-team
kubectl -n ml-team create serviceaccount deployer
kubectl -n ml-team create rolebinding deployer-edit \
  --clusterrole=edit --serviceaccount=ml-team:deployer
# Short-lived token for CI or a developer, instead of sharing the admin file
kubectl -n ml-team create token deployer --duration=8h

6.8 En faire un cluster GPU

NVKE fournit un Kubernetes conforme sur des serveurs GPU. L'environnement d'exécution accéléré par GPU s'ajoute dans chaque cluster de charges de travail avec l'AI Cluster Runtime (AICR) de NVIDIA, les paquets de nœud avec NodeWright, et l'automatisation de la remise en état avec NVSentinel. NVKR peut également construire des artefacts AICR. Une fois que l'environnement d'exécution annonce les GPU, un test de fumée consiste en un pod qui en demande un (exemple de Workstation ; choisissez un tag d'image CUDA qui correspond à votre pilote) :

apiVersion: v1
kind: Pod
metadata:
  name: gpu-smoke
spec:
  restartPolicy: Never
  containers:
    - name: cuda
      image: nvcr.io/nvidia/cuda:<tag>
      command: ["nvidia-smi"]
      resources:
        limits:
          nvidia.com/gpu: 1

7. Modèle de sécurité

7.1 Identité des nœuds

Chaque nœud présente une identité SPIFFE attestée, adossée à son TPM via SPIRE, avant de recevoir ses identifiants d'adhésion. Les nœuds du cluster de gestion font confiance à votre AC SPIRE (fournie à l'amorçage) ; les nœuds des clusters de charges de travail reçoivent le bundle de confiance SPIRE du cluster de gestion dans leurs données utilisateur. Cela comble une faille classique du bare metal : un serveur qui se contente d'atteindre le réseau ne peut pas rejoindre le cluster d'un client. L'exigence d'un TPM virtuel dans le démarrage rapide existe pour la même raison.

7.2 L'API : HTTP simple, pas d'authentification, pas d'autorisation

Par défaut, l'API NVKE écoute sur le port 30080 de chaque nœud de gestion sans TLS, et toute personne présente sur un réseau que vous admettez peut appeler chaque point de terminaison, y compris ceux de création et de suppression. Même avec l'authentification activée, NVKE n'applique aucune autorisation : tout appelant authentifié peut gérer chaque cluster de charges de travail. Notre minimum avant d'admettre le moindre appelant :

  1. Suivez la procédure de NVKE pour n'admettre que les réseaux qui ont besoin de l'API, et appliquez la même règle en bordure de votre réseau avec des règles de pare-feu ou des ACL de commutateur sur le VLAN de gestion.
  2. Activez l'authentification de l'API. Une fois activée, générez un kubeconfig OIDC avec nvkectl generate oidc-kubeconfig ; dans ce cas, quelques commandes qui lisent directement l'API Kubernetes du cluster de gestion (get kubeconfig, get providers, ainsi que les commandes relatives aux images machine et aux releases) doivent être exécutées avec kubectl et le kubeconfig administrateur du cluster de gestion.
  3. Placez votre propre point de terminaison TLS devant l'API, car sinon les jetons circulent en clair sur le réseau, et gardez le saut situé derrière lui sur un réseau de gestion isolé. Un exemple de Workstation avec nginx sur un bastion d'administration :
# Workstation example: TLS in front of the NVKE API (preview serves plain HTTP)
upstream nvke_api {
    server 10.0.10.11:30080;
    server 10.0.10.12:30080;
    server 10.0.10.13:30080;
}
server {
    listen 443 ssl;
    server_name nvke-api.example.internal;
    ssl_certificate     /etc/ssl/nvke-api/fullchain.pem;
    ssl_certificate_key /etc/ssl/nvke-api/privkey.pem;
    allow 10.20.0.0/24;   # operator and automation subnet only
    deny  all;
    location / {
        proxy_pass http://nvke_api;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}
  1. N'attribuez des jetons d'API NVKE qu'aux personnes et aux systèmes autorisés à gérer tous les clusters, et gardez cette liste courte. Placez tout libre-service par locataire dans votre propre portail, qui applique l'autorisation et appelle NVKE pour le compte du locataire.

7.3 Données au repos

Activez le chiffrement etcd pour chaque cluster. Ne vous fiez pas à la variante d'image de nœud avec chiffrement intégral du disque (FDE) : chaque build d'image génère une clé de volume unique dont héritent tous les nœuds construits à partir de cette image, la phrase de passe d'amorçage est publique et reste dans la configuration GRUB, et toute personne disposant de l'image et de la phrase de passe peut récupérer la clé. NVIDIA indique que les images FDE sont réservées à l'évaluation.

8. Exploitation au quotidien

TâcheComment dans la préversionPoints de vigilance
Mettre à l'échelle un pool de nœudsnvkectl patch nodepool (n'accepte que desiredNodeCount)La capacité doit exister dans NICo pour le type d'instance
Mettre à niveau le plan de contrôlenvkectl patch cluster en modifiant controlPlaneKubernetesVersionTestez d'abord avec une release de cluster correspondante
Mettre à niveau le Kubernetes d'un pool de nœudsEnvoyez kubernetesVersion dans une requête de mise à jour vers /api/nodePools/<NODE_POOL_ID>Les nœuds existants deviennent obsolètes ; ils ne sont pas remplacés automatiquement
Remplacer les nœuds obsolètesAvec un recycleBudget supérieur à 0, le mode automatique les marque avec nvke.nvidia.com/NeedsRecycle ; vous ou NVSentinel les supprimezNVKE ne draine ni ne supprime ; nvkectl ne peut ni définir les champs du mode automatique ni afficher les nœuds marqués
Modifier les étiquettes ou les taints des nœudsFixés à la création et appliqués une seule fois lorsqu'un nœud rejoint le cluster ; utilisez ensuite kubectl label et kubectl taintLes étiquettes supprimées ne sont pas rajoutées
Modifier la configuration d'un pool de nœudsSeuls les nœuds créés après la modification l'utilisentPlanifiez un recyclage pour converger
Mettre à niveau ou sauvegarder le plan de gestionPas encore de procédureConservez le kubeconfig d'amorçage et la clé etcd ; prévoyez une reconstruction

Comme NVKE marque les nœuds sans les drainer, le schéma de recyclage sûr pour les nœuds GPU est le schéma habituel : cordon, attendre la fin des tâches longues ou leur point de reprise, drainer, supprimer, puis laisser le pool remplacer le nœud à partir de la nouvelle release. Automatisez-le dans NVSentinel ou dans votre propre contrôleur, avec un budget d'un nœud à la fois par pool pour les pools d'entraînement.

9. Télémétrie

La chaîne de télémétrie NVKE (NKTP) est un chart Helm basé sur OpenTelemetry qui collecte journaux, métriques et traces et les exporte via OTLP. Son backend par défaut est réservé à l'évaluation : il conserve les données en mémoire et donne aux utilisateurs anonymes un accès administrateur à Grafana. Dirigez-le vers votre propre backend avant que quiconque ne s'y fie. Dans notre conception de référence pour l'observabilité NVIDIA, nous envoyons l'OTLP vers une passerelle Collector qui le distribue à Grafana Mimir, Tempo et Grafana pour les métriques et les traces, et à la pile Elastic pour les journaux, en ajoutant DCGM pour la santé des GPU et UFM pour la fabric InfiniBand. NKTP s'y insère comme une source OTLP supplémentaire.

Signaux qui méritent une alerte dès le premier jour : erreurs des contrôleurs du plan de gestion, clusters bloqués à l'état Provisioning, nœuds dont l'attestation échoue, nœuds marqués NeedsRecycle plus longtemps que votre fenêtre de recyclage, capacité NICo par type d'instance, et expiration des certificats des kubeconfigs remis.

10. Limitations de la préversion et ce que nous faisons pour chacune

Limitation (d'après l'état de préversion indiqué par NVIDIA)RisqueAtténuation
L'API est en HTTP simple avec l'authentification désactivée après l'installationToute personne présente sur un réseau admis peut créer ou supprimer des clustersAdmettre les réseaux, activer l'authentification, proxy TLS, VLAN de gestion isolé (section 7.2)
Aucune autorisationTout détenteur de jeton peut gérer chaque clusterPeu de jetons ; libre-service des locataires via votre propre portail
Les clients ne reçoivent qu'un kubeconfig administrateur, qui ne peut pas être révoquéUn fichier divulgué reste valide jusqu'à l'expiration du certificatLe remettre uniquement aux administrateurs du cluster ; créer des comptes de service RBAC et des jetons à courte durée de vie ; suivre l'expiration
Le cluster de gestion ne se met pas à niveau, ne se met pas à l'échelle et ne se remplace pas tout seulUne panne matérielle ou une mise à niveau exige un travail manuelTrois nœuds sur des alimentations et des commutateurs distincts ; pièces de rechange ; runbook de reconstruction documenté
Pas de procédure de mise à niveau ni de sauvegarde/restauration du plan de gestionUne perte d'état impose de reconstruire le plan de gestionSécuriser la clé etcd et le kubeconfig ; traiter les sites en préversion comme des laboratoires reconstructibles
Une AC SPIRE propre est requise pour les nœuds de gestionLes nœuds ne peuvent ni s'attester ni rejoindre le clusterPréparer les fichiers d'AC avant l'amorçage
Les modifications de configuration d'un pool de nœuds ne remplacent pas les nœuds en cours d'exécutionDérive de configuration entre les nœudsRecyclage automatisé avec NVSentinel ou un contrôleur
Les builds d'image locaux ne sont pas des releases qualifiées ; une QCOW2 nécessite un imageur propre au siteÉchecs de démarrage ou de premier démarrage sur du matériel réelValider ensemble l'image et l'imageur sur le matériel cible avant utilisation
Les images FDE n'assurent aucune confidentialité des données au reposFaux sentiment de chiffrementNe pas les utiliser pour des données réelles ; s'appuyer sur le chiffrement etcd et votre propre dispositif de chiffrement des disques
Le backend de télémétrie par défaut est en mémoire, avec un accès administrateur anonyme à GrafanaPerte de données et tableaux de bord ouvertsDiriger NKTP vers votre propre backend
Aucune Release NVKR n'est qualifiéeCombinaisons d'artefacts non éprouvéesExécuter votre propre contrôle de qualification par génération de GPU

11. Comparaison de NVKE avec d'autres approches

NVKE n'est pas le seul moyen d'exploiter Kubernetes sur des serveurs GPU. Une comparaison équitable, au niveau de la conception plutôt que de fonctionnalités qui changent de mois en mois :

ApprochePoints fortsCompromisIdéal pour
NVKE + NVKRConçus pour les usines GPU multilocataires ; cluster isolé par client ; nœuds attestés par le matériel ; combinaisons logicielles validées par NVIDIA ; open sourcePréversion publique ; centré sur NICo ; plan de gestion encore en cours de maturation ; pas encore de couche d'autorisationClouds GPU, opérateurs télécoms et grands parcs GPU partagés qui préparent un service Kubernetes géré
Cluster API avec vos propres outilsLe même standard ouvert que celui utilisé par NVKE ; contrôle total ; large écosystème de fournisseursVous construisez et maintenez vous-même la couche de service, le pipeline d'images et la qualification GPUÉquipes dotées d'une solide ingénierie de plateforme et d'une infrastructure non NICo
Distributions Kubernetes généralistes et gestionnaires de parcsMatures, supportées, nombreuses intégrations ; plusieurs éditeurs intègrent des composants NVKEQualification GPU et intégration bare metal variables ; coûts de licenceEntreprises qui ont besoin dès aujourd'hui de contrats de support et d'une maturité de production
Kubernetes hébergé sur un cloud public ou GPUNi matériel ni plan de contrôle à exploiter ; démarrage rapideMoins de contrôle sur le matériel, la localisation des données et le coût en cas d'utilisation soutenueCharges de travail variables ou en phase initiale ; équipes sans exploitation de centre de données

Ces approches ne s'excluent pas. Le modèle d'images de nœud figées et signées de NVKR mérite d'être adopté quel que soit l'outil qui installe vos clusters, et NVIDIA cite plusieurs éditeurs de distributions et de plateformes qui intègrent des composants NVKE à leurs propres produits.

12. Un plan d'évaluation par étapes

  1. Semaine 1 : démarrage rapide local. Un hôte Linux ou une VM (amd64 ou arm64) avec au moins 6 CPU, 12 GiB de mémoire libre et 100 GiB d'espace disque libre, Docker et la prise en charge d'un TPM virtuel ; sur macOS, le guide de site local de NVKE s'exécute dans une VM Colima. Suivez-le jusqu'à la création d'un cluster de charges de travail et vérifiez que les nœuds indiquent Ready. Objectif : l'équipe comprend les objets (site, release set, cluster, pool de nœuds) et l'API.
  2. Semaines 2 à 3 : NVKR dans votre pipeline. Exécutez la Definition du tutoriel, puis la candidate NVKE combinée ; publiez vers un registre privé ; rédigez une Verification Policy et vérifiez authenticity et artifact-publication en CI. Objectif : vous pouvez reconstruire et vérifier chaque artefact que vous déploieriez.
  3. Semaines 3 à 6 : laboratoire matériel. Trois serveurs de gestion, trois serveurs de plan de contrôle et deux à quatre serveurs GPU sur NICo. Validez l'image et l'imageur sur votre matériel, amorcez, sécurisez l'API comme à la section 7, publiez deux release sets et créez deux clusters de locataires. Ajoutez AICR, exécutez des tests de fumée GPU et une tâche d'entraînement multi-nœuds, recyclez un nœud, mettez à niveau un plan de contrôle. Objectif : une liste écrite des écarts par rapport à vos engagements de service.
  4. Après la préversion : pilote. Refaites le laboratoire sur la version en disponibilité générale, comblez les écarts, puis menez un pilote avec un locataire interne avant tout client externe.

Critères de sortie à consigner avant de commencer : délai entre la demande et l'état Provisioned, échecs d'attestation des nœuds, temps de recyclage par nœud GPU, perturbation des tâches en cours lors des mises à niveau, et nombre d'étapes manuelles restant dans chaque runbook.

13. Les compétences que cela exige des équipes plateforme et DevOps

  • Cluster API et provisionnement bare metal : machines, bootstrap and pivot, iPXE et création d'images, VPC et types d'instances.
  • Sécurité de la chaîne d'approvisionnement logicielle : entrées figées, SBOM, provenance, politiques de signature et ce que chacune prouve réellement.
  • Identité des charges de travail : SPIFFE/SPIRE, attestation TPM, autorités de certification et bundles de confiance.
  • Kubernetes multilocataire : isolement, RBAC, cycle de vie des identifiants, chiffrement etcd.
  • Exploitation des GPU : pools de nœuds par génération de GPU, qualification de l'environnement d'exécution et des pilotes, recyclage sûr des nœuds exécutant de longues tâches.
  • Observabilité : chaînes OpenTelemetry, télémétrie des GPU et de la fabric, alertes sur les échecs de provisionnement et d'attestation.

14. Comment Workstation peut vous aider

Nous concevons, fournissons et exploitons des infrastructures GPU au Royaume-Uni. Pour les équipes qui étudient NVKE et NVKR, nous pouvons planifier l'évaluation, dimensionner et fournir le matériel de laboratoire et de production, concevoir le réseau de gestion et le durcissement de l'API, intégrer votre contrôle de vérification NVKR à la CI, raccorder NKTP, DCGM et la télémétrie de la fabric à une pile OpenTelemetry, et rédiger les runbooks de recyclage et de mise à niveau. Si vous n'êtes pas prêt à exploiter vos propres racks, notre page cloud GPU privé compare les options de construction, et gpuleasing.co.uk compare la location et l'achat. Contactez-nous ou demandez à notre ingénieur commercial IA de dimensionner un cluster.

Notes et sources

  • NVIDIA Technical Blog, Manage Kubernetes Clusters for GPU Infrastructure with NVIDIA Kubernetes Engine, 10 novembre 2026.
  • Documentation de NVKE, y compris les pages sur l'état de la préversion, les plateformes prises en charge et l'authentification de l'API.
  • GitHub : dsx-ai-factory/nvke, dsx-ai-factory/nvkr, cluster-api-provider-nico et leurs feuilles de route publiques.
  • Les deux projets sont en préversion publique. Les API, la configuration et le comportement peuvent changer d'une version à l'autre, et NVIDIA ne les recommande pas encore pour des charges de travail de production. Les versions et limitations sont celles documentées au 14 novembre 2026.
  • Les exemples signalés comme « exemple de Workstation » sont les nôtres et ne font pas partie de la documentation de NVIDIA.

Mention des droits : NVIDIA, le logo NVIDIA, DSX et CUDA sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. Kubernetes est une marque déposée de The Linux Foundation. Les autres noms de produits et de sociétés mentionnés sont la propriété de leurs détenteurs respectifs. Tous ces droits sont reconnus et réservés à leurs titulaires.

Partager cet article

Plus dans Technology

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Ce qui tient sur un GPU RTX 5080 ou RTX 5090 Laptop, le calcul de mémoire, les modèles ouverts qui valent la peine, la configuration d'Ubuntu 26.04 avec la pile NVIDIA, Ollama, llama.cpp et vLLM, les assistants de code, l'affinage LoRA, la sécurité, et quand passer le travail sur un serveur

Lire la suite
Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Des éléments probants à la place des preuves, en environ 400 lignes de Python avec une sortie réelle : métriques par segment avec intervalles bootstrap et contrat de réussite ou d'échec, tests de propriétés et métamorphiques avec Hypothesis, calibration et prédiction conforme, contrats Pydantic et évaluations de non-régression pour les sorties LLM, contrôles de dérive, barrière en CI et vérification exacte d'un petit réseau de neurones

Lire la suite
TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

Installer torchcurves, ajuster et dimensionner une courbe, choisir entre B-spline et Legendre ainsi que l’application d’entrée, construire une courbe de calibration monotone et un modèle additif sur des données tabulaires, comparer avec SciPy, scikit-learn, un KAN et un MLP, exporter les coefficients en JSON, tester et exploiter en production, avec des sorties réelles

Lire la suite