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.
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 :
- 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.
- 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
| Composant | Rôle | Où il s'exécute |
|---|---|---|
| Plan de gestion NVKE | API REST et contrôleurs qui créent et exploitent les clusters de charges de travail | Le cluster de gestion (trois serveurs CPU) |
nvkectl | CLI de l'opérateur : amorce le site, publie les release sets, crée les clusters, récupère les kubeconfigs | Hô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 + CAPNICo | Interface de provisionnement Kubernetes standard, avec le fournisseur d'infrastructure Cluster API pour NICo | Cluster de gestion |
| NICo (NVIDIA Infra Controller) | Cycle de vie bare metal : capacité enrôlée, VPC et préfixes, types d'instances, démarrage iPXE | Votre site (installation distincte) |
| Serveur et agents SPIRE | Attestation des nœuds par TPM et identités SPIFFE ; un nœud n'obtient ses identifiants d'adhésion qu'après attestation | Cluster de gestion et chaque nœud |
| Agent de nœud NVKE | Agent sur le nœud, compilé dans l'image de nœud par NVKR | Chaque nœud |
| OVN-Kubernetes et NodeLocal DNSCache | Réseau du cluster et cache DNS, installés par NVKE lors du provisionnement | Chaque 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 OTLP | Clusters de gestion et de charges de travail |
| NVKR | CLI, 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, NVSentinel | Ajouté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 état | Clusters de charges de travail |
3. Architecture
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ément | Version de la préversion | Remarques |
|---|---|---|
| Kubernetes (clusters de gestion et de charges de travail) | 1.36.3 | 1.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œuds | Ubuntu 24.04 LTS ou 26.04 LTS | La MachineImage d'exemple installe Ubuntu 24.04 à partir de l'ISO d'installation |
| Architectures CPU | amd64, arm64 | Images 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.6 | clusterctl v1.13.6 |
| CAPNICo | v0.1.0 | NICo est le fournisseur d'infrastructure par défaut ; LaunchLayer peut aussi être activé |
| OVN-Kubernetes | 2.4.2 | Compilé à partir des sources dans l'image de nœud |
| Agent SPIRE | 1.14.1, plugin TPM 1.9.0 | Version amont figée par somme de contrôle |
| Outils d'amorçage | kind v0.32.0, kubectl v1.36.0, Helm v4.2.4 | Plus containerd et nerdctl en mode rootful sur l'hôte d'amorçage |
| Chaîne d'outils Go | 1.27.4 ou ultérieure pour NVKE ; 1.27.2 figée pour NVKR | Le lanceur NVKR propose d'installer localement sa version de Go figée |
5. NVKR : Definition, Run, Release, Verify
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 :
- 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.
- 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.
- 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ération | Ce qu'elle établit |
|---|---|
| Parcourir une Release | Inspecte 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 authenticity | Authentifie les signatures et les preuves selon votre politique, sans télécharger les contenus |
Vérifier artifact-publication | Authentifie 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
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 :
- Image machine : le script iPXE que NICo exécute pour démarrer un serveur.
- 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.
- 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 :
- 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.
- 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 aveckubectlet le kubeconfig administrateur du cluster de gestion. - 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;
}
}
- 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âche | Comment dans la préversion | Points de vigilance |
|---|---|---|
| Mettre à l'échelle un pool de nœuds | nvkectl patch nodepool (n'accepte que desiredNodeCount) | La capacité doit exister dans NICo pour le type d'instance |
| Mettre à niveau le plan de contrôle | nvkectl patch cluster en modifiant controlPlaneKubernetesVersion | Testez d'abord avec une release de cluster correspondante |
| Mettre à niveau le Kubernetes d'un pool de nœuds | Envoyez 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ètes | Avec un recycleBudget supérieur à 0, le mode automatique les marque avec nvke.nvidia.com/NeedsRecycle ; vous ou NVSentinel les supprimez | NVKE 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œuds | Fixés à la création et appliqués une seule fois lorsqu'un nœud rejoint le cluster ; utilisez ensuite kubectl label et kubectl taint | Les étiquettes supprimées ne sont pas rajoutées |
| Modifier la configuration d'un pool de nœuds | Seuls les nœuds créés après la modification l'utilisent | Planifiez un recyclage pour converger |
| Mettre à niveau ou sauvegarder le plan de gestion | Pas encore de procédure | Conservez 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) | Risque | Atténuation |
|---|---|---|
| L'API est en HTTP simple avec l'authentification désactivée après l'installation | Toute personne présente sur un réseau admis peut créer ou supprimer des clusters | Admettre les réseaux, activer l'authentification, proxy TLS, VLAN de gestion isolé (section 7.2) |
| Aucune autorisation | Tout détenteur de jeton peut gérer chaque cluster | Peu 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 certificat | Le 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 seul | Une panne matérielle ou une mise à niveau exige un travail manuel | Trois 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 gestion | Une perte d'état impose de reconstruire le plan de gestion | Sé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 gestion | Les nœuds ne peuvent ni s'attester ni rejoindre le cluster | Pré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écution | Dérive de configuration entre les nœuds | Recyclage 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éel | Valider ensemble l'image et l'imageur sur le matériel cible avant utilisation |
| Les images FDE n'assurent aucune confidentialité des données au repos | Faux sentiment de chiffrement | Ne 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 à Grafana | Perte de données et tableaux de bord ouverts | Diriger NKTP vers votre propre backend |
| Aucune Release NVKR n'est qualifiée | Combinaisons d'artefacts non éprouvées | Exé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 :
| Approche | Points forts | Compromis | Idéal pour |
|---|---|---|---|
| NVKE + NVKR | Conç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 source | Préversion publique ; centré sur NICo ; plan de gestion encore en cours de maturation ; pas encore de couche d'autorisation | Clouds 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 outils | Le même standard ouvert que celui utilisé par NVKE ; contrôle total ; large écosystème de fournisseurs | Vous 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 parcs | Matures, supportées, nombreuses intégrations ; plusieurs éditeurs intègrent des composants NVKE | Qualification GPU et intégration bare metal variables ; coûts de licence | Entreprises 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 GPU | Ni matériel ni plan de contrôle à exploiter ; démarrage rapide | Moins de contrôle sur le matériel, la localisation des données et le coût en cas d'utilisation soutenue | Charges 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
- 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. - 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
authenticityetartifact-publicationen CI. Objectif : vous pouvez reconstruire et vérifier chaque artefact que vous déploieriez. - 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.
- 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.