Un guide de praticien pour sécuriser les centres de données d’IA et les agents IA avec le portefeuille de cybersécurité de NVIDIA, et pour surveiller l’ensemble au moyen d’un pipeline OpenTelemetry unique qui alimente les outils que les équipes de sécurité utilisent déjà : Elastic Security comme SIEM, Dynatrace, Prometheus avec Alertmanager, et Grafana. Il couvre les menaces propres aux parcs GPU et aux agents, le rôle de chaque produit NVIDIA couche par couche (BlueField et DOCA, DOCA Argus, DOCA Vault, Sentry, confidential computing, OpenShell, Nemotron Safety, NeMo Guardrails, garak et Morpheus), la télémétrie que chacun émet réellement, une configuration de Collector validée, quatorze règles de détection Elastic chargées dans un Kibana en fonctionnement et déclenchées par des événements de test, des règles d’alerte Prometheus avec tests unitaires, des playbooks de réponse, la mise en correspondance avec les référentiels de conformité, la conservation et les coûts, la haute disponibilité, et la manière dont Workstation livre le tout.
otelcol-contrib validate 0.165.0, puis exécutées de bout en bout : des événements de test ont traversé une véritable passerelle jusqu’à Elasticsearch 9.2.0 et Prometheus 3.12.0. Le pipeline d’ingestion, le modèle d’index et la politique de cycle de vie ont été appliqués à cet Elasticsearch, et les quatorze règles de détection ont été créées via le moteur de détection de Kibana 9.2.0, se sont exécutées correctement et ont levé les alertes attendues. Les règles Prometheus ont passé promtool check rules et promtool test rules ; la configuration d’Alertmanager a passé amtool check-config ; le manifeste Kubernetes a passé kubeconform. Nous ne disposions ni de Dynatrace, ni de BlueField-4, ni de Sentry, ni de DOCA Vault, ni de matériel de confidential computing pour ce test : ces parties sont donc décrites à partir de la documentation publique de NVIDIA et de Dynatrace, et le précisent. La section 18 liste toutes les sources et les lacunes.
Cet article prolonge deux notes techniques précédentes plutôt que de les remplacer. La conception de référence UFM, DCGM et OpenTelemetry présente l’agent Collector sur chaque nœud et la paire de passerelles que nous utilisons pour la télémétrie opérationnelle, et le runbook AIOps Minerva couvre la corrélation des incidents et la remédiation sous gestion des changements. La télémétrie de sécurité suit le même schéma agent-passerelle, à une différence près : elle dispose de sa propre paire de passerelles, détenue par l’équipe de sécurité. Notre norme Big Prometheus et MoSCoW s’applique toujours : OpenTelemetry est le contrat de télémétrie, PromQL est le langage des métriques, et chaque type de journal a un seul magasin principal.
1. Synthèse
Les centres de données d’IA sont des cibles attrayantes pour des raisons qui ne s’appliquent pas aux salles de serveurs ordinaires. Le matériel est coûteux et il est facile d’en détourner du temps de calcul. Les poids des modèles et les données d’entraînement constituent souvent la propriété intellectuelle la plus précieuse d’une entreprise. Et les agents IA agissent désormais d’eux-mêmes : ils lisent des pages web et des documents non fiables, appellent des outils, utilisent des identifiants et modifient des systèmes. Une seule instruction cachée dans un document peut transformer un agent utile en menace interne.
La réponse de NVIDIA est une défense en profondeur sur toute la pile. Concrètement :
- Le DPU surveille le serveur depuis l’extérieur. BlueField exécute des services de sécurité dans son propre domaine isolé, de sorte qu’un logiciel malveillant sur l’hôte ne peut pas les désactiver. DOCA Argus inspecte la mémoire de l’hôte à la recherche de menaces à l’exécution ; Sentry surveille les agents et peut les mettre en quarantaine en quelques millisecondes ; DOCA Vault protège les données sensibles.
- Le GPU protège les données pendant leur utilisation. Le confidential computing maintient les données et les poids des modèles chiffrés et isolés à l’intérieur du GPU, et l’attestation le prouve avant que quoi que ce soit de sensible ne soit libéré.
- Les agents s’exécutent dans une sandbox avec une politique écrite. OpenShell décide quels fichiers, destinations réseau, processus et identifiants un agent peut utiliser, l’applique dans le noyau et le proxy, et journalise chaque décision dans un schéma de sécurité standard.
- Les modèles sont contrôlés en entrée et en sortie. Les modèles Nemotron Safety et NeMo Guardrails filtrent les prompts et les réponses dangereux ; garak attaque vos agents avant que des attaquants ne le fassent.
Ce que les produits de NVIDIA ne font pas à eux seuls, c’est offrir à une équipe d’opérations de sécurité un endroit unique pour voir tout cela, le corréler avec l’identité, Kubernetes, la périphérie web et les secrets, et réagir. C’est l’objet de cet article, et c’est là qu’intervient la pratique d’observabilité et de SIEM de Workstation. Le résultat pour l’entreprise :
- chaque contrôle de sécurité produit des preuves qui arrivent dans votre SIEM en quelques secondes, dans un schéma unique ;
- des détections pour les attaques qui comptent dans les parcs d’IA (détournement d’agents, vol de modèles, usage abusif des GPU, abus de privilèges), chacune avec une réponse testée ;
- un confinement automatique uniquement lorsqu’il est sûr et réversible, avec approbation humaine dans les autres cas ;
- des preuves pour les auditeurs au titre du UK GDPR, de l’ISO 27001 et des régimes de type NIS, pour un coût prévisible.
Workstation est partenaire NVIDIA. Nous fournissons le matériel, ainsi que l’ingénierie, les logiciels et les personnes pour concevoir, construire et exploiter cette solution avec vous, d’une première évaluation jusqu’au support de supervision continu (section 17).
2. Le paysage des menaces pour les centres de données d’IA et les agents
La plupart des menaces qui pèsent sur un parc d’IA sont des menaces connues visant de nouvelles cibles. Le tableau associe chacune à la manière dont elle se manifeste, au contrôle qui la prévient ou la limite, et au signal qui vous indique qu’elle s’est produite. La section 11 transforme chaque signal en règle de détection.
| Menace | Comment elle se manifeste | Contrôles préventifs | Signal surveillé |
|---|---|---|---|
| Injection de prompt directe et jailbreaks | Des utilisateurs rédigent des prompts pour amener un modèle à ignorer ses instructions ou à produire un contenu nuisible | Rails d’entrée NeMo Guardrails, classifieurs Nemotron Safety, tests garak dans la CI | Blocages des rails par utilisateur ; taux de réussite des attaques garak par sonde |
| Injection de prompt indirecte et détournement d’objectif | Des instructions cachées dans une page web, un e-mail ou un document lu par l’agent le redirigent vers un nouvel objectif, souvent l’exfiltration | Politique réseau et fichiers d’OpenShell (refus par défaut), rails de récupération, approbation humaine pour tout nouvel accès | Refus OpenShell et nouvelles destinations ; rafales de refus par sandbox |
| Fuite de données | Données personnelles, secrets ou code source dans les prompts, les réponses, les journaux ou les téléversements des agents | Rails de sortie des garde-fous et masquage des données sensibles, politique de sortie d’OpenShell, injection d’identifiants pour que les agents ne détiennent jamais de vrais secrets | Blocages des rails de sortie, refus de sortie, détections de données sensibles (Morpheus ou rails) |
| Vol de modèles et de poids | Transferts volumineux de checkpoints ou de poids ; lectures inhabituelles dans les registres de modèles | Confidential computing, DOCA Vault, clés détenues par wslvault, segmentation réseau | Volume sortant des nœuds d’inférence et de stockage ; lectures de secrets en dehors des heures ; échecs d’attestation |
| Chaîne d’approvisionnement | Fichiers de modèles empoisonnés, paquets malveillants installés par des agents, images de conteneurs altérées | Politique de processus et de paquets d’OpenShell, signature des images et contrôle d’admission, tests de régression garak | Nouvelles exécutions de processus (Argus, auditd), empreintes d’images inattendues, régressions garak |
| Mouvement latéral | Un agent ou un pod compromis atteint l’API Kubernetes, le service de métadonnées cloud ou d’autres tenants | OpenShell bloque les ports du plan de contrôle et les adresses link-local ; RBAC et politique réseau Kubernetes ; isolation BlueField | Refus de type SSRF, constats d’autorisation entre sandboxes, création de pods privilégiés |
| Cryptojacking GPU | Des mineurs exploitent du temps GPU volé, souvent sur des nœuds inactifs ou mal planifiés | Accès aux GPU uniquement via l’ordonnanceur, politique d’exécution, détection à l’exécution par DOCA Argus | GPU occupé sans tâche planifiée (DCGM) ; exécutions depuis /tmp ; alertes Argus |
| Abus interne | Un administrateur ou un compte compromis lit des secrets, élargit les permissions des agents ou désactive la supervision | Authentification unique avec points d’approbation, moindre privilège, séparation des tâches pour le pipeline de sécurité | Connexion anormale suivie d’une approbation privilégiée ; lectures de secrets en dehors des heures convenues ; lacunes dans la télémétrie |
| Infrastructure non fiable | Un hébergeur, un co-tenant ou un opérateur disposant d’un accès à l’hôte tente de lire des données ou des poids en cours d’utilisation | Confidential computing avec attestation avant la libération des clés | Échecs d’attestation ; charges de travail démarrées sans attestation réussie |
3. Le portefeuille de cybersécurité de NVIDIA, couche par couche
NVIDIA regroupe ces produits sur sa page des solutions d’IA pour la cybersécurité. Nous trouvons plus clair de les organiser selon la couche qu’ils protègent, car cela indique d’où provient la télémétrie de chacun et ce qu’il peut voir que les autres ne voient pas.
3.1 Silicium et DPU : BlueField, DOCA, DOCA Argus, DOCA Vault et Sentry
BlueField est l’unité de traitement des données (DPU) de NVIDIA : une carte réseau dotée de ses propres cœurs Arm, de sa mémoire et de son système d’exploitation, placée entre le serveur et le réseau. DOCA est le framework logiciel qui permet de la programmer. Sur le plan de la sécurité, l’essentiel est la séparation. Les services du DPU s’exécutent dans un domaine que le système d’exploitation de l’hôte ne contrôle pas : un attaquant disposant des droits root sur l’hôte ne peut donc toujours pas les lire ni les arrêter.
DOCA Argus tire parti de cette position pour surveiller l’hôte. Selon le guide du service DOCA Argus de NVIDIA, il s’exécute sous forme de conteneur sur BlueField-3 ou ultérieur (en mode DPU), lit certaines structures du noyau dans la mémoire de l’hôte par DMA, et reconstitue une image des processus, des binaires avec leurs empreintes, des lignes de commande, des fichiers, des connexions réseau, des conteneurs et des VM, et de l’utilisation des GPU par processus, sans aucun agent installé sur l’hôte. À partir de là, il lève des alertes sur des menaces à l’exécution telles que les reverse shells et les exécutions inattendues. Ce qui compte pour l’intégration :
- Les messages ont un
message_typevalantEVENT,ALERTouSYSTEM_ACTIVITYet unseverityallant deINFOàCRITICAL, avec des sections de charge utile telles queworkload_informationetactivity_data. - L’export de télémétrie est désactivé par défaut. Il se configure avec
telemetry_address,telemetry_format(JSON ou syslog) ettelemetry_tag, et les exemples de NVIDIA l’envoient en TCP vers Fluent Bit ou Vector. - NVIDIA indique qu’Argus s’intègre aux principales plateformes XDR d’entreprise. Si vous en exploitez une, elle peut rester le consommateur principal ; notre pipeline en reçoit alors une copie pour la corréler avec tout le reste.
Notre passerelle reçoit directement le JSON d’Argus sur un listener TCP (section 6). Si votre version d’Argus ne sépare pas les messages par des sauts de ligne, intercalez Fluent Bit ou Vector comme le montre le guide de NVIDIA et transmettez au Collector en OTLP ; le reste de la conception est inchangé. Le guide de NVIDIA présente les champs du message au niveau racine dans son exemple, mais décrit une racine message_header dans son tableau de schéma : vérifiez donc un message réel de votre version avant de vous fier aux chemins de champs de notre règle.
DOCA Vault est un microservice de sécurité sur BlueField qui protège les données sensibles avec des contrôles intégrés au silicium et un accès zero trust. Nous ne l’avons pas testé et ne décrivons pas ses interfaces ici. Dans nos conceptions, il vient s’ajouter à la gestion des clés qui libère les secrets pour les charges de travail (pour nous, wslvault), sans la remplacer.
NVIDIA Sentry sur BlueField est la brique la plus récente. NVIDIA la décrit comme une partie de son Open Agent Safety Platform : s’exécutant dans le domaine isolé matériellement de BlueField-4, indépendamment de l’hôte et du logiciel propre à l’agent, elle surveille le comportement des agents pour détecter les écarts de politique et les activités suspectes, fournit une télémétrie de confiance, et peut mettre un agent en quarantaine en quelques millisecondes grâce aux contrôles d’infrastructure du DPU. Comme elle fonctionne hors bande, elle reste opérationnelle si l’hôte ou le runtime de l’agent a été compromis, c’est-à-dire précisément quand vous en avez besoin. Nous traitons les alertes et les actions de quarantaine de Sentry comme des événements SIEM de premier plan ; le format d’export exact doit être tiré de la documentation Sentry de NVIDIA pour la version que vous déployez.
DOCA Telemetry Service exporte les compteurs du DPU au format Prometheus. Il fait déjà partie de la conception de référence UFM et ne nécessite aucune modification ici, si ce n’est que les compteurs de ports et de pertes des DPU placés devant les hôtes d’agents deviennent un contexte utile dans les investigations de sécurité.
3.2 Plateforme : confidential computing et attestation
Le confidential computing protège les données et les modèles en cours d’utilisation. Le GPU exécute la charge de travail dans un environnement d’exécution de confiance matériel, de sorte que ni le système d’exploitation de l’hôte, ni l’hyperviseur, ni les personnes qui exploitent l’infrastructure ne peuvent lire la mémoire, et le GPU peut prouver son état par attestation. Cela en fait le contrôle adapté à deux menaces que rien d’autre dans le tableau ne traite bien : un hébergeur non fiable, et le partage de données ou de modèles avec une partie en laquelle vous n’avez pas entièrement confiance.
La règle opérationnelle est simple : pas d’attestation réussie, pas de clés. Un wrapper de lancement atteste le GPU (et la VM confidentielle) avant le démarrage de la charge de travail, et ce n’est qu’ensuite qu’il demande au service de clés la clé de déchiffrement du jeu de données ou du modèle. NVIDIA publie les outils d’attestation dans nvTrust ; son README signale le SDK d’attestation Python et le vérificateur GPU local comme obsolètes au profit d’un SDK et d’une CLI C++ : prévoyez donc les nouvelles intégrations sur ces derniers. Nous journalisons chaque résultat d’attestation sous forme d’événement structuré (réussite ou échec, quel GPU, quelle charge de travail, quel vérificateur) et déclenchons une alerte à chaque échec.
3.3 Runtime : OpenShell
OpenShell est le runtime open source (Apache 2.0) de NVIDIA pour les agents autonomes. Chaque agent s’exécute dans une sandbox ; une politique déclare les fichiers qu’il peut lire ou écrire, les destinations réseau et méthodes HTTP qu’il peut utiliser, les processus qu’il peut exécuter et les identifiants qu’il peut employer, et OpenShell l’applique dans le noyau et dans un proxy de contrôle des politiques. Les identifiants réels restent hors de la sandbox : OpenShell les injecte dans les requêtes sortantes, et uniquement lorsque la destination est un endpoint approuvé. Avant qu’une modification de politique ne soit appliquée, une étape de vérification formelle signale tout nouvel accès nécessitant une revue humaine. Notre précédent article sur OpenShell détaille l’exécution d’agents sous ce runtime.
Pour un SIEM, OpenShell est la source la plus riche de la pile, car il enregistre chaque décision de sécurité dans l’Open Cybersecurity Schema Framework (OCSF) version 1.8.0. D’après sa documentation d’observabilité :
- Les superviseurs de sandbox et la passerelle émettent des événements OCSF pour l’activité réseau (classe 4001), l’activité HTTP (4002), SSH (4007), l’activité des processus (1007), les constats de détection (2004), l’authentification (3002), les modifications de configuration (5019), le cycle de vie des applications (6002) et l’activité des API (6003).
- Les événements réseau et HTTP refusés indiquent la raison dans
status_detail, par exempleno matching policyouresolves to always-blocked address(une destination link-local ou loopback, comme un endpoint de métadonnées cloud). - Lorsqu’un identifiant de sandbox appelle une méthode ou une autre sandbox qu’il ne devrait jamais toucher, la passerelle lève un constat de détection de haute gravité avec
finding_info.uidsandbox-authorization-boundary: l’identifiant est peut-être compromis. - Définir
enabled = truesous[openshell.gateway.otlp.ocsf]dansgateway.tomlexporte les événements OCSF sous forme d’enregistrements de journal OTLP dans le périmètre d’instrumentationopenshell.ocsf. Le corps est l’événement OCSF en JSON ; les attributs comprennentocsf.class_uid,ocsf.severity_id,ocsf.metadata.uidetopenshell.sandbox.id; les superviseurs envoient leurs propres événements au même endpoint. - La livraison est de type « au moins une fois » : dédupliquez donc sur
ocsf.metadata.uid. Les enregistrements abandonnés par la passerelle sont comptabilisés dansopenshell_ocsf_otlp_dropped_total, et le lot suivant comporte un enregistrement d’avertissement nomméopenshell.ocsf.gap. - La passerelle expose des métriques Prometheus sur un listener distinct, sans authentification : gardez-le interne ; les défaillances d’intercepteur qui laissent passer une requête sont comptabilisées dans
openshell_gateway_interceptor_fail_open_total.
La ligne de journal abrégée d’une connexion refusée se présente ainsi (d’après la documentation de NVIDIA) :
OCSF NET:OPEN [MED] DENIED /usr/bin/curl(64) -> httpbin.org:443 [policy:- engine:opa] [reason:no matching policy]
L’OpenShell Reference Architecture de NVIDIA construit une pile complète autour du runtime : des processeurs Vera exécutent les harnais d’agents et leurs outils, des systèmes Vera Rubin servent l’inférence, et Sentry sur BlueField-4 ajoute une supervision et une application des règles qui ne dépendent pas de l’hôte. NVIDIA précise explicitement qu’OpenShell fonctionne aussi sur d’autres systèmes CPU et que Vera et BlueField sont optionnels ; ils apportent l’efficacité et la couche hors bande, pas les fonctions de base. NemoClaw, la collection de blueprints ouverts de NVIDIA pour des agents spécialisés construits sur les modèles Nemotron, exécute ses agents dans OpenShell : tout ce qui figure dans cet article s’applique donc tel quel aux agents NemoClaw ; nous traitons NemoClaw lui-même dans un article distinct.
3.4 Modèles et garde-fous : Nemotron Safety, NeMo Guardrails et garak
Nemotron est la famille de modèles ouverts de NVIDIA ; NVIDIA en positionne certains pour la planification et le raisonnement, d’autres pour des appels d’outils rapides et à fort volume, et un ensemble de modèles Nemotron Safety qui classifient les contenus dangereux dans le texte et les images afin qu’ils puissent être filtrés à l’entrée ou à la sortie d’un pipeline d’agents. Spécialisés avec NeMo, les modèles Nemotron peuvent aussi faire fonctionner les agents des défenseurs eux-mêmes, pour le tri des alertes, la chasse aux menaces en continu et la simulation de red team.
NeMo Guardrails (dernière version 0.24.1 au moment de la rédaction) place des rails programmables entre une application et son modèle : rails d’entrée (par exemple contrôles anti-jailbreak et masquage des données sensibles), rails de dialogue, rails de récupération sur les fragments RAG, rails d’exécution sur les entrées et sorties des outils, et rails de sortie. Un classifieur de sécurité tel qu’un modèle Nemotron Safety peut se placer derrière un rail. Pour la supervision, son config.yml comporte une section tracing avec un adaptateur OpenTelemetry ; la bibliothèque n’utilise que l’API OpenTelemetry, et c’est votre application qui configure le SDK et l’exportateur. Le contenu des prompts et des réponses n’est pas capturé, sauf si vous définissez enable_content_capture: true ; laissez-le désactivé en production, car les prompts contiennent souvent des données personnelles.
Les spans indiquent quels rails se sont exécutés et combien de temps ils ont pris, ce qui est idéal pour Dynatrace. Pour le SIEM, nous voulons aussi un événement par blocage, indiquant qui, quel rail et ce qui s’est passé, mais sans le contenu. Nous l’émettons depuis un fin wrapper autour de l’appel aux rails, en utilisant notre propre convention de champs (event.action: input_rail_blocked, rule.name renseigné avec le flux du rail, user.id). Cette convention est propre à Workstation et ne fait pas partie de NeMo Guardrails.
garak est le scanner de vulnérabilités LLM de NVIDIA : il exécute des sondes (injection de prompt, jailbreaks comme la famille DAN, fuite de données, astuces d’encodage, rejeu de données d’entraînement, etc.) contre un endpoint de modèle ou d’agent, et note les réponses avec des détecteurs. Chaque exécution écrit un rapport JSONL ; ses enregistrements d’évaluation ont entry_type: "eval" avec probe, detector, passed, fails et total_evaluated. Nous exécutons garak dans la CI à chaque modification d’un modèle, d’un prompt ou d’une configuration de garde-fous et envoyons ces enregistrements au SIEM : une régression devient ainsi une détection comme une autre.
# CI step (example): scan the staging endpoint with a fixed probe set
python -m garak --config ci/garak-staging.yaml --target_type rest \
--spec probes.promptinject,probes.dan,probes.encoding,probes.leakreplay \
--report_prefix ci-${CI_PIPELINE_ID}
Ici, ci/garak-staging.yaml est un fichier de configuration garak qui fournit au générateur REST l’URI et le modèle de requête de votre endpoint (voir la documentation de garak ; il dispose aussi de générateurs pour les endpoints compatibles OpenAI, Hugging Face, Bedrock et d’autres). Les versions actuelles de garak sélectionnent les sondes avec --spec ; l’ancienne option --probes fonctionne toujours mais est obsolète. Copiez le *.report.jsonl obtenu dans le répertoire surveillé par le Collector du runner de CI.
3.5 Pipelines : Morpheus
Morpheus est le framework de NVIDIA, accéléré par GPU, pour construire des pipelines d’inférence de cybersécurité sur de grands flux de données. Son dépôt fournit des exemples de pipelines et des modèles pré-entraînés pour l’empreinte numérique du comportement des utilisateurs et des machines, la détection de phishing, la détection d’informations sensibles, l’analyse de journaux, la détection de ransomware à partir de données AppShield, la détection de fraude avec des réseaux de neurones sur graphes, la prévention des pertes de données et le profilage de comportements anormaux, dont un exemple qui détecte le minage de cryptomonnaie à partir de la télémétrie GPU. Vérifiez son statut avant de planifier autour : au moment de la rédaction, la dernière version taguée est la 25.06 (juillet 2025). Lorsqu’un client dispose déjà de pipelines Morpheus, leurs sorties ne sont qu’une source notée de plus : nous envoyons les scores et les enregistrements signalés dans la même passerelle, sous forme d’événements.
4. L’architecture de référence d’observabilité de la sécurité de Workstation
Cinq principes guident la conception :
- Un pipeline unique. Chaque signal de sécurité entre par un OpenTelemetry Collector. Les backends ne puisent jamais directement dans les sources : ajouter ou remplacer un backend est donc une modification de la passerelle, et non du parc.
- Normaliser une seule fois, au niveau de la passerelle. Les champs sont mis en correspondance avec les noms ECS (et les conventions sémantiques OTel lorsqu’elles existent) avant que les données ne se séparent, de sorte qu’une règle dans Elastic et un tableau de bord dans Grafana parlent du même
destination.domain. - Masquer avant que quoi que ce soit ne sorte. Les en-têtes d’autorisation, les cookies, les jetons d’API et le texte des prompts ou des complétions sont supprimés au niveau de la passerelle. Aucun backend ne les stocke jamais : aucun backend n’a donc besoin qu’on lui en confie la garde.
- Chaque backend fait ce qu’il fait le mieux. Elastic Security conserve tous les événements de sécurité et exécute les règles de corrélation et les dossiers. Dynatrace reçoit les événements de gravité plus élevée, les métriques et les traces, afin que son IA puisse relier les événements de sécurité à la santé des services. Prometheus reçoit les compteurs à faible cardinalité ainsi que les métriques GPU et réseau qu’il détient déjà, pour des alertes rapides et peu coûteuses. Grafana est l’écran partagé.
- Le pipeline se surveille lui-même. Les enregistrements abandonnés, les exports en échec et les passerelles perdues sont des alertes de sécurité, et non des tickets d’exploitation (section 15).
Niveaux
- Les agents de nœud sont les mêmes que dans la conception UFM : un Collector par nœud GPU, de stockage, de connexion et du plan de contrôle. Nous ajoutons trois récepteurs (auditd, le journal d’audit du serveur d’API Kubernetes et les rapports garak sur les runners de CI) et un second exportateur qui envoie les journaux de sécurité aux passerelles de sécurité plutôt qu’aux passerelles d’exploitation.
- Une paire de passerelles de sécurité (ou davantage), derrière une IP virtuelle ou un nom DNS, exploitée par l’équipe de sécurité. Elle reçoit l’OTLP des agents, des passerelles et superviseurs OpenShell et des applications protégées ; le JSON d’Argus en TCP ; et le syslog sur TLS des appliances. Elle collecte les endpoints de métriques de la passerelle OpenShell et de wslproxy. Les identifiants des backends n’existent qu’à cet endroit.
- Les passerelles d’exploitation sont inchangées. Les métriques DCGM, des nœuds et de la fabric continuent d’aller vers Mimir ou Prometheus comme dans la conception UFM ; les alertes de cryptojacking et d’exfiltration de la section 9 s’y exécutent, car c’est là que se trouvent déjà les données.
Pourquoi des passerelles de sécurité séparées ? Pour la séparation des tâches (l’équipe plateforme ne peut pas filtrer discrètement des événements de sécurité), pour des règles de conservation et d’accès différentes, et pour un rayon d’impact réduit : une requête de tableau de bord défaillante ou une modification d’exploitation ne peut pas priver de ressources le pipeline de sécurité.
Sources
| Source | Ce qu’elle nous apprend | Transport vers le pipeline | Dataset |
|---|---|---|---|
| Passerelle et superviseurs OpenShell | Chaque autorisation et chaque refus pour les appels réseau, HTTP, processus, SSH, authentification et API ; chargements de politiques ; constats | OCSF via OTLP depuis [openshell.gateway.otlp.ocsf] ; métriques de la passerelle par scraping | openshell.ocsf |
| DOCA Argus sur BlueField | Alertes et activité à l’exécution issues de l’analyse de la mémoire de l’hôte | JSON en TCP vers la passerelle | doca.argus |
| Sentry sur BlueField-4 | Écarts de comportement des agents, actions de quarantaine | Selon la documentation Sentry de NVIDIA ; nous les mettons en correspondance selon le même modèle de dataset | nvidia.sentry (prévu) |
| Confidential computing | Réussite ou échec de l’attestation par GPU et par charge de travail | Le wrapper de lancement journalise du JSON ECS vers syslog | cc.attestation |
| Applications NeMo Guardrails | Blocages des rails (événements) et durées des rails (spans) | OTLP depuis l’application | nemo.guardrails |
| garak dans la CI | Taux de réussite des attaques par sonde et par détecteur | Le Collector du runner suit le rapport JSONL | garak.eval |
| Serveur d’API Kubernetes | Qui a créé, modifié quoi, ou exécuté une commande dans quoi | L’agent des nœuds du plan de contrôle suit le journal d’audit | kubernetes.audit_logs |
| WAF wslproxy | Chaque décision du WAF avec signature, client et route ; compteurs Prometheus | JSON wafsec via syslog ; métriques par scraping | wslproxy.waf |
| wslvault | Lectures, écritures et refus de secrets par identité | JSON ECS via syslog | wslvault.audit |
| Authentification unique OpsAPI | Connexions, échecs, approbations d’accès privilégiés des agents | JSON ECS via syslog | opsapi.sso |
| Hôtes Linux | Exécutions, changements de privilèges, surveillance de fichiers (auditd) | L’agent suit /var/log/audit/audit.log | auditd.log |
| DCGM et node-exporter | Utilisation des GPU sans tâche, volume sortant | Pipeline d’exploitation existant (Prometheus ou Mimir) | métriques |
La liste de champs wafsec provient de notre article sur le WAF Engine v2. Pour wslvault et OpsAPI, nous configurons les produits pour qu’ils journalisent du JSON avec des noms ECS (event.action, event.outcome, user.id, source.ip), ce qui rend la mise en correspondance au niveau de la passerelle triviale ; les noms d’actions utilisés dans les règles de cet article (secret.read, login, agent.approval.granted) relèvent de notre convention : adaptez-les à ce qu’émet votre déploiement.
5. Normalisation : OCSF, ECS et conventions sémantiques OpenTelemetry
Trois schémas se rencontrent dans ce pipeline. OpenShell parle OCSF ; les règles, timelines et contenus prédéfinis d’Elastic Security attendent de l’ECS ; et OpenTelemetry a ses propres conventions sémantiques pour les ressources et les attributs. Nous conservons l’enregistrement d’origine intact pour l’analyse forensique et ajoutons les champs ECS à côté. La passerelle effectue la mise en correspondance dont chaque backend a besoin (de sorte que Dynatrace voie les mêmes noms qu’Elastic), et un pipeline d’ingestion Elasticsearch réalise l’enrichissement propre à Elastic.
| Champ OCSF (OpenShell) | Champ ECS | Lieu de la mise en correspondance |
|---|---|---|
action (Allowed, Denied) | event.action | Passerelle |
status_id (1 succès, 2 échec) | event.outcome | Passerelle |
status_detail, ou finding_info.uid pour les constats | event.reason | Pipeline d’ingestion |
class_uid | event.category (network, process, authentication, api, configuration, intrusion_detection) | Pipeline d’ingestion |
type_uid, severity_id, metadata.uid | event.code, event.severity, event.id | Pipeline d’ingestion |
dst_endpoint.domain, .ip, .port | destination.domain, destination.ip, destination.port | Passerelle (domaine, port), pipeline d’ingestion (ip) |
src_endpoint.ip | source.ip | Pipeline d’ingestion |
actor.process.name, .pid, .cmd_line | process.executable, process.pid, process.command_line | Passerelle, pipeline d’ingestion |
actor.user.uid | user.id | Pipeline d’ingestion |
device.container.name, .uid (la sandbox) | container.name, container.id | Passerelle, pipeline d’ingestion |
firewall_rule.name (la politique correspondante) | rule.name | Passerelle |
metadata.product.name, .version | observer.product, observer.version | Pipeline d’ingestion |
time (millisecondes epoch) | @timestamp | Pipeline d’ingestion |
| enregistrement complet | event.original (non indexé) et ocsf.* (aplati) | Pipeline d’ingestion |
La documentation d’OpenShell indique que l’identité de la sandbox est passée d’un objet container de premier niveau à device.container dans les enregistrements OCSF 1.8.0, et invite les analyseurs SIEM à suivre ce changement. Notre mise en correspondance ne lit que le nouvel emplacement : épinglez donc la version d’OpenShell dans vos enregistrements de changement et retestez la mise en correspondance lors des mises à niveau.
6. Configuration du Collector
Toute la configuration ci-dessous utilise les noms de composants de otelcol-contrib 0.165.0, qui a introduit des noms en snake_case (file_log, tcp_log, otlp_grpc, otlp_http, prometheus_remote_write, cumulative_to_delta, delta_to_cumulative, resource_detection). Les anciens noms utilisés dans nos articles UFM et Minerva fonctionnent toujours comme alias obsolètes et affichent un avertissement au démarrage. Les secrets sont des espaces réservés d’environnement.
Agent de nœud : récepteurs de sécurité
Ces pipelines sont ajoutés à l’agent de nœud existant. Sur un nœud qui n’est ni un nœud du plan de contrôle ni un runner de CI, les récepteurs dont les fichiers n’existent pas restent simplement inactifs.
# /etc/otelcol-contrib/security-agent.yaml (added to the node agent)
extensions:
file_storage:
directory: /var/lib/otelcol/queue
create_directory: true
receivers:
# Linux audit (auditd): one record per line, key=value pairs
file_log/auditd:
include: [/var/log/audit/audit.log]
start_at: end
storage: file_storage
operators:
- type: regex_parser
regex: '^type=(?P<record_type>\S+) msg=audit\((?P<epoch>[\d.]+):(?P<sequence>\d+)\): ?(?P<kv>.*)$'
parse_to: attributes["auditd.log"]
- type: key_value_parser
parse_from: attributes["auditd.log"]["kv"]
parse_to: attributes["auditd.data"]
on_error: send
- type: remove
field: attributes["auditd.log"]["kv"]
- type: add
field: attributes["data_stream.dataset"]
value: auditd.log
# Kubernetes API server audit log (control-plane nodes only)
file_log/k8s-audit:
include: [/var/log/kubernetes/audit/audit.log]
start_at: end
storage: file_storage
operators:
- type: json_parser
parse_to: attributes["kubernetes.audit"]
- type: add
field: attributes["data_stream.dataset"]
value: kubernetes.audit_logs
# garak eval records from CI runners (one report per run)
file_log/garak:
include: [/var/lib/ci/garak/*.report.jsonl]
start_at: beginning
storage: file_storage
operators:
- type: json_parser
parse_to: attributes["garak"]
- type: filter
expr: 'attributes.garak.entry_type != "eval"'
- type: add
field: attributes["data_stream.dataset"]
value: garak.eval
- type: add
field: attributes["ci.pipeline"]
value: EXPR(env("CI_PIPELINE_NAME"))
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
resource_detection:
detectors: [env, system]
batch:
send_batch_size: 2048
timeout: 5s
exporters:
otlp_grpc/security-gateway:
endpoint: otel-security.sec.internal:4317
tls:
ca_file: /etc/otelcol-contrib/ca.pem
sending_queue:
enabled: true
storage: file_storage
service:
extensions: [file_storage]
pipelines:
logs/security:
receivers: [file_log/auditd, file_log/k8s-audit, file_log/garak]
processors: [memory_limiter, resource_detection, batch]
exporters: [otlp_grpc/security-gateway]
Remarques :
- L’analyseur auditd sépare l’en-tête de l’enregistrement de ses paires clé-valeur. Il ne décode pas les champs encodés en hexadécimal tels que
proctitle; si vous en avez besoin, décodez-les dans le pipeline d’ingestion. Activez les règles d’audit souhaitées (par exempleexecvesur les nœuds GPU) dans votre configuration auditd ; le Collector n’envoie que ce qu’écrit auditd. - Le récepteur d’audit Kubernetes ne voit que ce que la politique d’audit de votre serveur d’API enregistre. Pour détecter les pods privilégiés, il vous faut au moins le niveau
RequestResponse, ou le niveauRequest, pour les opérations create, update et patch surpods, afin que le corps de la requête figure dans le journal. - Le récepteur garak ne conserve que les enregistrements d’évaluation et les étiquette avec le pipeline de CI, de sorte qu’une régression désigne la modification qui l’a causée.
Passerelle de sécurité
# /etc/otelcol-contrib/security.yaml (security gateway pair)
extensions:
health_check:
endpoint: 0.0.0.0:13133
file_storage:
directory: /var/lib/otelcol/queue
create_directory: true
basicauth/es:
client_auth:
username: ${env:ES_USER}
password: ${env:ES_PASSWORD}
receivers:
# Agents, OpenShell gateway and supervisors (OCSF over OTLP),
# NeMo Guardrails spans and CI jobs all arrive here
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
http:
endpoint: 0.0.0.0:4318
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
# DOCA Argus telemetry (JSON lines over TCP from each BlueField)
tcp_log/argus:
listen_address: 0.0.0.0:5170
operators:
- type: json_parser
parse_to: attributes["argus"]
- type: add
field: attributes["data_stream.dataset"]
value: doca.argus
# wslproxy WAF decisions (wafsec), wslvault and OpsAPI SSO audit, appliance syslog
syslog/security:
tcp:
listen_address: 0.0.0.0:6514
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
protocol: rfc5424
# Security-relevant metrics that live off-node: OpenShell gateway, wslproxy
prometheus/security:
config:
scrape_configs:
- job_name: openshell-gateway
scrape_interval: 30s
kubernetes_sd_configs:
- role: pod
namespaces:
names: [openshell]
relabel_configs:
- source_labels: [__meta_kubernetes_pod_container_port_name]
regex: metrics
action: keep
- source_labels: [__meta_kubernetes_pod_name]
target_label: pod
- job_name: wslproxy
scrape_interval: 30s
file_sd_configs:
- files: ["/etc/otelcol-contrib/targets/wslproxy-*.yaml"]
metric_relabel_configs:
- source_labels: [__name__]
regex: "waf_(blocked|monitored|inspections|latency|errors).*"
action: keep
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
resource/security:
attributes:
- key: site
value: ${env:WS_SITE}
action: upsert
- key: cluster
value: ${env:WS_CLUSTER}
action: upsert
# OpenShell OCSF records: body is the OCSF event as a JSON string.
# Lift the fields every backend needs into attributes with ECS names,
# tag the dataset and ingest pipeline, and use the OCSF event id as the
# Elasticsearch document id so at-least-once retries do not duplicate.
transform/ocsf:
error_mode: ignore
log_statements:
- conditions:
- scope.name == "openshell.ocsf"
statements:
- set(log.cache["ocsf"], ParseJSON(log.body)) where IsString(log.body)
- set(log.attributes["event.action"], log.cache["ocsf"]["action"])
- set(log.attributes["event.outcome"], "failure") where log.cache["ocsf"]["status_id"] == 2
- set(log.attributes["event.outcome"], "success") where log.cache["ocsf"]["status_id"] == 1
- set(log.attributes["destination.domain"], log.cache["ocsf"]["dst_endpoint"]["domain"])
- set(log.attributes["destination.port"], Int(log.cache["ocsf"]["dst_endpoint"]["port"])) where log.cache["ocsf"]["dst_endpoint"]["port"] != nil
- set(log.attributes["process.executable"], log.cache["ocsf"]["actor"]["process"]["name"])
- set(log.attributes["container.name"], log.cache["ocsf"]["device"]["container"]["name"])
- set(log.attributes["rule.name"], log.cache["ocsf"]["firewall_rule"]["name"])
- set(log.attributes["ocsf.status_detail"], log.cache["ocsf"]["status_detail"])
- set(log.attributes["data_stream.dataset"], "openshell.ocsf")
- set(log.attributes["elasticsearch.ingest_pipeline"], "ws-ocsf-to-ecs")
- set(log.attributes["elasticsearch.document_id"], log.attributes["ocsf.metadata.uid"])
# Syslog from our own appliances: wslproxy's wafsec JSON is mapped field by
# field; wslvault, OpsAPI SSO and the attestation wrapper already log
# ECS-named JSON, so it is merged as it is and only the dataset is tagged.
transform/appliances:
error_mode: ignore
log_statements:
- conditions:
- log.attributes["appname"] == "wafsec"
statements:
- set(log.attributes["wafsec"], ParseJSON(log.attributes["message"]))
- set(log.attributes["data_stream.dataset"], "wslproxy.waf")
- set(log.attributes["event.action"], log.attributes["wafsec"]["action"])
- set(log.attributes["source.ip"], log.attributes["wafsec"]["client_ip"])
- set(log.attributes["rule.id"], log.attributes["wafsec"]["signature_id"])
- set(log.attributes["url.path"], log.attributes["wafsec"]["uri"])
- delete_key(log.attributes, "message")
- conditions:
- log.attributes["appname"] == "wslvault" or log.attributes["appname"] == "opsapi-sso" or log.attributes["appname"] == "cc-attest"
statements:
- merge_maps(log.attributes, ParseJSON(log.attributes["message"]), "upsert")
- set(log.attributes["data_stream.dataset"], "wslvault.audit") where log.attributes["appname"] == "wslvault"
- set(log.attributes["data_stream.dataset"], "opsapi.sso") where log.attributes["appname"] == "opsapi-sso"
- set(log.attributes["data_stream.dataset"], "cc.attestation") where log.attributes["appname"] == "cc-attest"
- delete_key(log.attributes, "message")
# Never let credentials or prompt text reach any backend
transform/redact:
error_mode: ignore
log_statements:
- statements:
- delete_key(log.attributes, "http.request.header.authorization")
- delete_key(log.attributes, "http.request.header.cookie")
- delete_key(log.attributes, "gen_ai.prompt")
- delete_key(log.attributes, "gen_ai.completion")
- replace_pattern(log.body, "(?i)(bearer|api-token)\\s+[A-Za-z0-9._~+/=-]{16,}", "$$1 [REDACTED]") where IsString(log.body)
trace_statements:
- statements:
- delete_key(span.attributes, "gen_ai.prompt")
- delete_key(span.attributes, "gen_ai.completion")
# Dynatrace wants delta sums; Prometheus wants cumulative ones
cumulative_to_delta:
max_staleness: 25h
delta_to_cumulative:
max_stale: 10m
batch:
send_batch_size: 4096
timeout: 2s
connectors:
# Everything goes to the SIEM; Medium and above is copied to Dynatrace
routing/severity:
default_pipelines: [logs/elastic]
table:
- condition: log.severity_number >= SEVERITY_NUMBER_WARN2
action: copy
pipelines: [logs/dynatrace]
# Turn security events into low-cardinality counters for Prometheus
count/security:
logs:
ws.security.events:
description: Security events by source, outcome and action
attributes:
- key: data_stream.dataset
default_value: unknown
- key: event.outcome
default_value: unknown
- key: event.action
default_value: unknown
exporters:
elasticsearch/siem:
endpoints:
- https://es-sec-1.sec.internal:9200
- https://es-sec-2.sec.internal:9200
mapping:
allowed_modes: [ecs]
logs_dynamic_id:
enabled: true
logs_dynamic_pipeline:
enabled: true
auth:
authenticator: basicauth/es
tls:
ca_file: /etc/otelcol-contrib/es-ca.pem
sending_queue:
enabled: true
storage: file_storage
otlp_http/dynatrace:
endpoint: https://${env:DT_ENV_ID}.live.dynatrace.com/api/v2/otlp
headers:
Authorization: "Bearer ${env:DT_PLATFORM_TOKEN}"
sending_queue:
enabled: true
storage: file_storage
prometheus_remote_write/sec:
endpoint: https://prometheus.sec.internal/api/v1/write
# only the fleet labels; never sandbox or pod ids
resource_constant_labels:
included: [site, cluster]
tls:
ca_file: /etc/otelcol-contrib/ca.pem
service:
extensions: [health_check, file_storage, basicauth/es]
pipelines:
logs/in:
receivers: [otlp, tcp_log/argus, syslog/security]
processors: [memory_limiter, resource/security, transform/ocsf, transform/appliances, transform/redact]
exporters: [routing/severity, count/security]
logs/elastic:
receivers: [routing/severity]
processors: []
exporters: [elasticsearch/siem]
logs/dynatrace:
receivers: [routing/severity]
processors: [batch]
exporters: [otlp_http/dynatrace]
metrics/scraped:
receivers: [otlp, prometheus/security]
processors: [memory_limiter, resource/security, batch]
exporters: [prometheus_remote_write/sec]
metrics/dynatrace:
receivers: [otlp, prometheus/security]
processors: [memory_limiter, resource/security, cumulative_to_delta, batch]
exporters: [otlp_http/dynatrace]
metrics/counts:
receivers: [count/security]
processors: [delta_to_cumulative, batch]
exporters: [prometheus_remote_write/sec]
metrics/counts-dt:
receivers: [count/security]
processors: [batch]
exporters: [otlp_http/dynatrace]
traces:
receivers: [otlp]
processors: [memory_limiter, resource/security, transform/redact, batch]
exporters: [otlp_http/dynatrace]
telemetry:
metrics:
level: detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
Remarques sur les choix effectués :
- Identifiant de document issu de l’identifiant d’événement OCSF. OpenShell livre « au moins une fois ». Définir
elasticsearch.document_idà partir deocsf.metadata.uidaveclogs_dynamic_idactivé rend sans effet un enregistrement renvoyé : lors de notre test de bout en bout, la seconde copie a été rejetée par Elasticsearch avec un conflit de version et un seul document a été stocké. - Pipeline d’ingestion dynamique. L’attribut
elasticsearch.ingest_pipelinesélectionne le pipeline OCSF uniquement pour les enregistrements OpenShell ; les autres datasets utilisent les valeurs par défaut du data stream. - Routage par gravité. Le connecteur de routage copie vers Dynatrace les enregistrements de gravité OTel
WARN2et au-delà (OpenShell fait correspondre OCSF Medium àWARN2et High àERROR), tandis que chaque enregistrement va vers Elasticsearch. Cela maintient les volumes et les coûts Dynatrace dans des proportions raisonnables. - Comptage des événements en métriques. Le connecteur count émet
ws.security.eventsavec seulement trois attributs : dataset, résultat et action. Il émet des sommes delta, ce que Dynatrace attend et que le remote write de Prometheus n’accepte pas : le chemin Prometheus effectue donc la conversion avecdelta_to_cumulative. Lors de notre test, Prometheus a reçuws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied", event_outcome="failure"}avec les étiquettessiteetcluster. - Cumulatif vers delta pour Dynatrace. L’ingestion OTLP de Dynatrace exige une temporalité delta pour les métriques : les métriques collectées passent donc par
cumulative_to_deltasur le seul chemin Dynatrace. - Étiquettes constantes.
resource_constant_labelsne transforme quesiteetclusteren étiquettes Prometheus. Les identifiants de sandbox, les noms de pods et les domaines ne deviennent jamais des étiquettes (section 14). - Traitement par lots. L’exportateur Elasticsearch regroupe les lots en interne : son pipeline n’a donc pas de processeur
batch; sinon, le Collector avertit d’un double traitement par lots.
Côté OpenShell
Sur la passerelle OpenShell, dirigez l’export OCSF vers les passerelles de sécurité. L’exemple de NVIDIA utilise un nom de service interne au cluster ; le nôtre est l’adresse de la passerelle de sécurité. Les superviseurs utilisent le même endpoint, qui doit donc être joignable depuis les sandboxes, et ils reçoivent les en-têtes d’export de la passerelle avec leurs identifiants de lancement plutôt que par l’environnement de la sandbox.
[openshell.gateway.otlp.ocsf]
enabled = true
endpoint = "https://otel-security.sec.internal:4317"
Traitez séparément la décision concernant la télémétrie produit anonyme propre à OpenShell : elle est sans rapport avec cet export et se contrôle avec OPENSHELL_TELEMETRY_ENABLED ou la valeur Helm server.telemetryEnabled.
7. Elastic Security comme SIEM
Elastic Security conserve tous les événements de sécurité, exécute les règles de détection, et c’est là que les analystes enquêtent (timelines) et suivent leur travail (dossiers). Nous l’exploitons comme un cluster de sécurité dédié ou un espace dédié avec ses propres rôles, séparé de la recherche dans les journaux d’exploitation.
Pipeline d’ingestion : d’OCSF vers ECS
Ce pipeline a été chargé dans Elasticsearch 9.2.0 et testé à la fois avec _simulate et avec des enregistrements arrivant par la passerelle.
PUT _ingest/pipeline/ws-ocsf-to-ecs
{
"description": "OpenShell OCSF 1.8.0 records to ECS (Workstation)",
"processors": [
{ "json": { "field": "message", "target_field": "ocsf", "if": "ctx.message instanceof String && ctx.message.startsWith('{')" } },
{ "set": { "field": "event.original", "copy_from": "message", "if": "ctx.ocsf != null" } },
{ "remove": { "field": "message", "if": "ctx.ocsf != null" } },
{ "date": { "field": "ocsf.time", "formats": ["UNIX_MS"], "target_field": "@timestamp", "if": "ctx.ocsf?.time != null" } },
{ "set": { "field": "event.module", "value": "openshell" } },
{ "set": { "field": "event.dataset", "value": "openshell.ocsf" } },
{ "set": { "field": "event.kind", "value": "event" } },
{ "set": { "field": "event.kind", "value": "alert", "if": "ctx.ocsf?.class_uid == 2004" } },
{ "set": { "field": "event.code", "value": "{{{ocsf.type_uid}}}", "if": "ctx.ocsf?.type_uid != null" } },
{ "set": { "field": "event.severity", "copy_from": "ocsf.severity_id", "if": "ctx.ocsf?.severity_id != null" } },
{ "set": { "field": "event.id", "copy_from": "ocsf.metadata.uid", "if": "ctx.ocsf?.metadata?.uid != null" } },
{ "set": { "field": "event.reason", "copy_from": "ocsf.status_detail", "if": "ctx.ocsf?.status_detail != null" } },
{ "set": { "field": "event.reason", "copy_from": "ocsf.finding_info.uid", "if": "ctx.ocsf?.finding_info?.uid != null" } },
{ "script": {
"lang": "painless",
"if": "ctx.ocsf?.class_uid != null",
"source": "def m = ['4001': 'network', '4002': 'network', '4007': 'network', '1007': 'process', '3002': 'authentication', '6003': 'api', '5019': 'configuration', '2004': 'intrusion_detection', '6002': 'process']; def c = m.get(String.valueOf(ctx.ocsf.class_uid)); if (c != null) { if (ctx.event == null) { ctx.event = [:]; } ctx.event.category = [c]; }"
} },
{ "set": { "field": "observer.product", "copy_from": "ocsf.metadata.product.name", "if": "ctx.ocsf?.metadata?.product?.name != null" } },
{ "set": { "field": "observer.version", "copy_from": "ocsf.metadata.product.version", "if": "ctx.ocsf?.metadata?.product?.version != null" } },
{ "set": { "field": "source.ip", "copy_from": "ocsf.src_endpoint.ip", "if": "ctx.ocsf?.src_endpoint?.ip != null" } },
{ "set": { "field": "destination.ip", "copy_from": "ocsf.dst_endpoint.ip", "if": "ctx.ocsf?.dst_endpoint?.ip != null" } },
{ "set": { "field": "destination.domain", "copy_from": "ocsf.dst_endpoint.domain", "override": false, "if": "ctx.ocsf?.dst_endpoint?.domain != null" } },
{ "set": { "field": "process.command_line", "copy_from": "ocsf.actor.process.cmd_line", "if": "ctx.ocsf?.actor?.process?.cmd_line != null" } },
{ "set": { "field": "process.pid", "copy_from": "ocsf.actor.process.pid", "if": "ctx.ocsf?.actor?.process?.pid != null" } },
{ "set": { "field": "user.id", "copy_from": "ocsf.actor.user.uid", "if": "ctx.ocsf?.actor?.user?.uid != null" } },
{ "set": { "field": "container.id", "copy_from": "ocsf.device.container.uid", "if": "ctx.ocsf?.device?.container?.uid != null" } },
{ "set": { "field": "container.name", "copy_from": "ocsf.device.container.name", "override": false, "if": "ctx.ocsf?.device?.container?.name != null" } },
{ "set": { "field": "url.full", "copy_from": "ocsf.http_request.url.url_string", "if": "ctx.ocsf?.http_request?.url?.url_string != null", "ignore_failure": true } },
{ "append": { "field": "related.hosts", "value": ["{{{destination.domain}}}"], "allow_duplicates": false, "if": "ctx.destination?.domain != null" } },
{ "append": { "field": "related.ip", "value": ["{{{source.ip}}}"], "allow_duplicates": false, "if": "ctx.source?.ip != null" } }
],
"on_failure": [
{ "set": { "field": "event.kind", "value": "pipeline_error" } },
{ "append": { "field": "error.message", "value": ["{{{_ingest.on_failure_message}}}"] } }
]
}
Modèle d’index et conservation
L’objet ocsf est mappé en flattened, de sorte que les nombreux champs optionnels d’OCSF ne peuvent pas provoquer d’explosion du mapping, tout en permettant aux analystes de filtrer dessus. L’enregistrement d’origine est stocké mais non indexé. Le modèle compose les éléments intégrés d’Elastic logs@mappings, logs@settings et ecs@mappings.
PUT _ilm/policy/ws-security-13m
{
"policy": {
"phases": {
"hot": { "actions": { "rollover": { "max_age": "1d", "max_primary_shard_size": "50gb" } } },
"warm": { "min_age": "14d", "actions": { "forcemerge": { "max_num_segments": 1 }, "allocate": { "number_of_replicas": 1 } } },
"cold": { "min_age": "90d", "actions": { "set_priority": { "priority": 0 } } },
"delete": { "min_age": "400d", "actions": { "delete": {} } }
}
}
}
PUT _index_template/logs-openshell.ocsf
{
"index_patterns": ["logs-openshell.ocsf-*"],
"data_stream": {},
"priority": 200,
"composed_of": ["logs@mappings", "logs@settings", "ecs@mappings"],
"template": {
"settings": { "index.lifecycle.name": "ws-security-13m" },
"mappings": {
"properties": {
"ocsf": { "type": "flattened" },
"event": { "properties": { "original": { "type": "keyword", "index": false, "doc_values": false } } }
}
}
}
}
Nous créons un modèle par dataset de sécurité, de même structure, avec une politique de cycle de vie correspondant à son exigence de conservation (section 14). Treize mois est une valeur par défaut courante pour les événements de sécurité, car cela couvre une année complète de comparaison plus le temps d’enquêter sur un incident découvert tardivement ; ce sont vos responsables juridiques et de la conformité qui fixent la durée réelle.
Règles de détection
Quatorze règles, créées via l’API du moteur de détection de Kibana (POST /api/detection_engine/rules, version d’API 2023-10-31). Chacune s’est exécutée correctement sur les données de test, et toutes les règles sauf celle sur les accès au coffre en dehors des heures (dont l’événement de test se situait pendant les heures) ont levé l’alerte attendue. Le tableau les liste toutes ; deux sont présentées en entier ensuite.
| Règle | Type | Gravité |
|---|---|---|
Trafic sortant d’un agent IA refusé par la politique OpenShellws-ai-001-agent-egress-denied | Requête KQL | medium |
Un agent IA a atteint un domaine jamais vu depuis 14 joursws-ai-002-agent-new-egress-domain | Nouveaux termes (KQL) | low |
Un agent IA a tenté d’atteindre une adresse link-local ou loopbackws-ai-003-agent-ssrf-blocked | Requête KQL | high |
Identifiant de sandbox OpenShell utilisé hors de son périmètrews-ai-004-sandbox-boundary-finding | Requête KQL | critical |
Rafale de refus de politique OpenShell provenant d’une même sandboxws-ai-005-policy-denial-spike | Seuil (KQL) | high |
Tentatives répétées de jailbreak bloquées par NeMo Guardrailsws-ai-006-guardrail-jailbreak-attempts | Seuil (KQL) | medium |
Taux de réussite des attaques garak supérieur à 5 % dans la CIws-ai-007-garak-regression | ES|QL | high |
Alerte d’exécution DOCA Argus sur un hôte GPUws-ai-008-doca-argus-alert | Requête KQL | critical |
Connexion depuis l’extérieur du Royaume-Uni suivie d’une approbation d’agentws-ai-009-sso-anomaly-then-agent-approval | Séquence EQL | high |
Lecture d’un secret wslvault en dehors de la plage 07:00–19:00 UTCws-ai-010-vault-read-out-of-hours | ES|QL | medium |
Pod privilégié créé ou modifié dans Kubernetesws-ai-011-k8s-privileged-pod | Requête KQL | high |
Échec de l’attestation de confidential computingws-ai-012-attestation-failure | Requête KQL | critical |
Le WAF wslproxy bloque un même client de façon répétéews-ai-013-waf-block-burst | Seuil (KQL) | medium |
Programme exécuté depuis /tmp ou /dev/shm sur un nœud GPUws-ai-014-exec-from-tmp | Requête KQL | high |
Les requêtes, telles que chargées :
# ws-ai-001-agent-egress-denied (KQL query)
data_stream.dataset:"openshell.ocsf" and event.category:"network" and event.action:"Denied"
# ws-ai-002-agent-new-egress-domain (New terms (KQL))
# new terms: destination.domain since now-14d
data_stream.dataset:"openshell.ocsf" and event.category:"network" and event.action:"Allowed" and destination.domain:*
# ws-ai-003-agent-ssrf-blocked (KQL query)
data_stream.dataset:"openshell.ocsf" and event.reason:"resolves to always-blocked address"
# ws-ai-004-sandbox-boundary-finding (KQL query)
data_stream.dataset:"openshell.ocsf" and event.kind:"alert" and event.reason:"sandbox-authorization-boundary"
# ws-ai-005-policy-denial-spike (Threshold (KQL))
# threshold: 25 or more per container.name
data_stream.dataset:"openshell.ocsf" and event.action:"Denied"
# ws-ai-006-guardrail-jailbreak-attempts (Threshold (KQL))
# threshold: 5 or more per user.id
data_stream.dataset:"nemo.guardrails" and event.action:"input_rail_blocked" and rule.name:"check jailbreak"
# ws-ai-007-garak-regression (ES|QL)
FROM logs-garak.eval-* METADATA _id, _index, _version
| WHERE garak.entry_type == "eval" AND garak.total_evaluated > 0
| EVAL attack_success_rate = garak.fails / garak.total_evaluated
| WHERE attack_success_rate > 0.05
| KEEP _id, _index, _version, @timestamp, ci.pipeline, garak.probe, garak.detector, garak.fails, garak.total_evaluated, attack_success_rate
# ws-ai-008-doca-argus-alert (KQL query)
data_stream.dataset:"doca.argus" and argus.message_type:"ALERT" and argus.severity:("HIGH" or "CRITICAL")
# ws-ai-009-sso-anomaly-then-agent-approval (EQL sequence)
sequence by user.id with maxspan=30m
[authentication where data_stream.dataset == "opsapi.sso" and event.outcome == "success" and source.geo.country_iso_code != "GB"]
[any where data_stream.dataset == "opsapi.sso" and event.action == "agent.approval.granted"]
# ws-ai-010-vault-read-out-of-hours (ES|QL)
FROM logs-wslvault.audit-* METADATA _id, _index, _version
| WHERE event.action == "secret.read" AND event.outcome == "success"
| EVAL hour = DATE_EXTRACT("hour_of_day", @timestamp)
| WHERE hour < 7 OR hour >= 19
| KEEP _id, _index, _version, @timestamp, user.id, wslvault.path, source.ip, hour
# ws-ai-011-k8s-privileged-pod (KQL query)
data_stream.dataset:"kubernetes.audit_logs" and kubernetes.audit.objectRef.resource:"pods" and kubernetes.audit.verb:("create" or "update" or "patch") and kubernetes.audit.requestObject.spec.containers.securityContext.privileged:true
# ws-ai-012-attestation-failure (KQL query)
data_stream.dataset:"cc.attestation" and event.outcome:"failure"
# ws-ai-013-waf-block-burst (Threshold (KQL))
# threshold: 50 or more per source.ip
data_stream.dataset:"wslproxy.waf" and event.action:"block"
# ws-ai-014-exec-from-tmp (KQL query)
data_stream.dataset:"auditd.log" and auditd.log.record_type:"SYSCALL" and auditd.data.syscall:"59" and auditd.data.exe:(/tmp/* or /dev/shm/*)
Une règle de requête avec suppression d’alertes et correspondance ATT&CK. La suppression regroupe les refus répétés pour une même sandbox et une même destination en une seule alerte par heure, ce qui permet à cette règle de rester exploitable sur un cluster très actif :
{
"rule_id": "ws-ai-001-agent-egress-denied",
"name": "AI agent egress denied by OpenShell policy",
"description": "An agent inside an OpenShell sandbox tried to reach a destination its policy does not allow. Often the first sign of indirect prompt injection or goal hijacking: the agent has been told to send data somewhere new.",
"type": "query",
"language": "kuery",
"index": [
"logs-openshell.ocsf-*"
],
"query": "data_stream.dataset:\"openshell.ocsf\" and event.category:\"network\" and event.action:\"Denied\"",
"severity": "medium",
"risk_score": 47,
"interval": "5m",
"from": "now-6m",
"alert_suppression": {
"group_by": [
"container.name",
"destination.domain"
],
"duration": {
"value": 1,
"unit": "h"
},
"missing_fields_strategy": "suppress"
},
"tags": [
"Workstation",
"Domain: AI agents",
"Data Source: OpenShell"
],
"threat": [
{
"framework": "MITRE ATT&CK",
"tactic": {
"id": "TA0010",
"name": "Exfiltration",
"reference": "https://attack.mitre.org/tactics/TA0010/"
},
"technique": [
{
"id": "T1567",
"name": "Exfiltration Over Web Service",
"reference": "https://attack.mitre.org/techniques/T1567/"
}
]
}
]
}
Une séquence EQL qui corrèle deux sources qu’un analyste devrait sinon rapprocher à la main : une connexion depuis l’extérieur du Royaume-Uni suivie, dans les 30 minutes, de l’approbation par le même utilisateur d’un accès privilégié pour un agent :
{
"rule_id": "ws-ai-009-sso-anomaly-then-agent-approval",
"name": "Sign-in from outside the UK followed by an agent approval",
"description": "An OpsAPI SSO sign-in from outside the UK, then the same user approving privileged agent access within 30 minutes.",
"type": "eql",
"language": "eql",
"index": [
"logs-opsapi.sso-*"
],
"query": "sequence by user.id with maxspan=30m\n [authentication where data_stream.dataset == \"opsapi.sso\" and event.outcome == \"success\" and source.geo.country_iso_code != \"GB\"]\n [any where data_stream.dataset == \"opsapi.sso\" and event.action == \"agent.approval.granted\"]",
"severity": "high",
"risk_score": 73,
"interval": "5m",
"from": "now-35m",
"tags": [
"Workstation",
"Domain: Identity",
"Data Source: OpsAPI"
]
}
Trois remarques pratiques sur les règles :
- Les règles ES|QL ont besoin de métadonnées pour la déduplication. Les règles ES|QL sans agrégation doivent sélectionner
METADATA _id, _index, _versionet conserver ces champs, comme les nôtres, afin que le moteur puisse éviter les alertes en double. - Utilisez aussi les règles prédéfinies d’Elastic. Elastic fournit des centaines de règles prédéfinies pour Linux, Kubernetes, le cloud et l’identité. Les nôtres comblent les lacunes propres à l’IA. Lorsqu’une règle prédéfinie couvre le même terrain avec une source de données différente (l’intégration d’audit Kubernetes propre à Elastic, par exemple), utilisez l’une ou l’autre, pas les deux.
- Les règles sont du code. Nous les conservons dans Git, les chargeons dans la CI et testons chacune avec un événement construit à cet effet, exactement comme lors de la validation de cet article. Une règle sans test n’est qu’une supposition.
Timelines et dossiers
Chaque alerte s’ouvre sur une timeline. Pour les incidents d’agents, nous enregistrons un modèle de timeline filtré sur container.name (la sandbox) qui rassemble les événements OpenShell de la sandbox, les événements des garde-fous et les résultats garak pour la même application, ainsi que les alertes Argus de l’hôte sur lequel elle s’exécutait : un analyste voit ainsi les dernières actions de l’agent dans l’ordre. Les dossiers rassemblent les alertes, les timelines, les notes et les actions de réponse ; nous les relions à ServiceNow via les connecteurs de dossiers d’Elastic afin que le ticket et le dossier restent synchronisés, et le service de réponse (section 12) inscrit chaque action automatisée dans le dossier sous forme de commentaire.
8. Dynatrace
De nombreuses entreprises utilisent Dynatrace pour la supervision des applications et de l’infrastructure. Lui envoyer les signaux de sécurité qui comptent pour les responsables de services permet qu’un refus de trafic sortant ou un pic d’activité des garde-fous apparaisse à côté du service qu’il affecte, et que Davis, le moteur d’IA de Dynatrace, puisse le relier aux changements de comportement de ce service.
- Endpoint. Selon la documentation de l’API OTLP de Dynatrace, l’URL de base en SaaS est
https://{your-environment-id}.live.dynatrace.com/api/v2/otlp(ou une adresse ActiveGate), et l’exportateur y ajoute/v1/traces,/v1/metricset/v1/logs. Les métriques propres à notre Collector de test ont confirmé qu’il publiait vers/api/v2/otlp/v1/logs. - Protocole. OTLP sur HTTP en protobuf binaire uniquement : ni gRPC ni JSON. D’où
otlp_httpdans la passerelle. - Authentification. Un jeton de plateforme Dynatrace dans un en-tête
Authorization: Bearer, avec les scopesopenpipeline:logs:ingest,openpipeline:metrics:ingestetopenpipeline:traces:ingest. Les environnements plus anciens utilisant des jetons d’accès classiques doivent suivre la documentation Dynatrace correspondant à leur type de jeton. - Temporalité des métriques. Delta uniquement, comme indiqué plus haut.
Ce que nous envoyons : les événements OpenShell et autres de gravité Medium et au-delà, les compteurs ws.security.events, les métriques OpenShell et WAF collectées, et les traces des garde-fous (capture de contenu désactivée). Ce que nous faisons dans Dynatrace, d’après sa documentation et non d’après une API que nous inventerions ici : configurer la détection d’anomalies sur les compteurs de sécurité afin que Davis apprenne leur niveau normal par cluster et signale un problème en cas de changement durable ; ajouter les événements de sécurité aux tableaux de bord et notebooks que les responsables de services utilisent déjà ; et, lorsque la licence Dynatrace du client inclut ses fonctionnalités de sécurité, router les enregistrements de haute gravité vers le stockage des événements de sécurité de Dynatrace via OpenPipeline, afin qu’ils puissent être analysés avec les constats de vulnérabilités. Nous n’avons pas vérifié les règles de routage OpenPipeline dans un tenant réel pour cet article : nous décrivons donc cette étape sans configuration.
Dynatrace est un second avis et une vue pour les responsables de services, pas un second SIEM. La détection, l’investigation et les dossiers restent dans Elastic Security, de sorte qu’il existe un seul endroit où un incident est pris en charge.
9. Prometheus et Alertmanager
Prometheus est l’endroit le plus rapide et le moins coûteux pour déclencher des alertes sur des valeurs numériques. Trois cas d’usage de sécurité sont naturellement numériques, et les données de deux d’entre eux (l’utilisation des GPU issue de DCGM et les octets réseau issus de node-exporter) se trouvent déjà dans le magasin de métriques d’exploitation de la conception UFM. Le troisième utilise les compteurs d’événements produits par la passerelle de sécurité. Le second groupe de règles surveille le pipeline de sécurité lui-même.
# /etc/prometheus/rules/ai-security.yml
groups:
- name: ai-security-signals
rules:
# GPU busy with no Kubernetes pod and no Slurm job attached: possible cryptojacking.
# Needs dcgm-exporter's pod mapping (Kubernetes) or HPC job mapping (Slurm) switched on.
- alert: GpuBusyWithoutScheduledWork
expr: |
max by (site, cluster, Hostname, gpu) (ws:gpu_util:ratio{pod="", hpc_job=""}) > 0.3
for: 15m
labels:
severity: high
team: soc
use_case: cryptojacking
annotations:
summary: "GPU {{ $labels.gpu }} on {{ $labels.Hostname }} busy with no scheduled job"
description: "Utilisation {{ $value | humanizePercentage }} for 15 minutes with no pod or Slurm job label. Check for miners and unscheduled processes."
# Egress from inference and storage nodes far above the same hour last week:
# model weights or datasets leaving.
- alert: UnusualEgressFromModelNodes
expr: |
(
sum by (site, cluster, instance) (increase(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[1h]))
> 3 * sum by (site, cluster, instance) (increase(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[1h] offset 7d))
)
and
sum by (site, cluster, instance) (increase(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[1h])) > 50e9
for: 10m
labels:
severity: high
team: soc
use_case: exfiltration
annotations:
summary: "{{ $labels.instance }} sent {{ $value | humanize1024 }}B in the last hour, over 3x last week"
# OpenShell denials across the cluster, from the gateway's count connector
- alert: AgentPolicyDenialSurge
expr: |
sum by (site, cluster) (rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[10m]))
> 3 * sum by (site, cluster) (rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[1d] offset 1d))
and
sum by (site, cluster) (rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[10m])) > 0.2
for: 10m
labels:
severity: medium
team: soc
use_case: agent-misuse
annotations:
summary: "OpenShell denials in {{ $labels.cluster }} at 3x yesterday's rate"
- name: ai-security-pipeline-health
rules:
# Losing security telemetry is itself a security event
- alert: OpenShellOcsfExportDropping
expr: sum by (namespace, pod) (increase(openshell_ocsf_otlp_dropped_total[10m])) > 0
labels:
severity: high
team: soc
annotations:
summary: "OpenShell gateway {{ $labels.pod }} dropped OCSF audit records"
- alert: OpenShellInterceptorFailOpen
expr: sum by (namespace, pod) (increase(openshell_gateway_interceptor_fail_open_total[10m])) > 0
labels:
severity: high
team: soc
annotations:
summary: "OpenShell interceptor failed open on {{ $labels.pod }}"
- alert: WafFailingOpen
expr: sum by (host) (rate(waf_errors[5m])) > 0
for: 10m
labels:
severity: medium
team: platform
annotations:
summary: "wslproxy WAF on {{ $labels.host }} is erroring and therefore allowing requests"
- alert: SiemExportFailing
expr: |
sum by (instance, exporter) (rate({__name__=~"otelcol_exporter_send_failed_log_records(_total)?", exporter="elasticsearch/siem"}[5m])) > 0
for: 10m
labels:
severity: high
team: soc
annotations:
summary: "Security gateway {{ $labels.instance }} cannot write to the SIEM"
- alert: SecurityGatewayRedundancyLost
expr: count by (site) (up{job="otel-security-gateway"} == 1) < 2
for: 5m
labels:
severity: high
team: soc
annotations:
summary: "Only one security gateway left at {{ $labels.site }}"
Remarques :
ws:gpu_util:ratioest la règle d’enregistrement de l’article UFM qui fait le lien entre les anciens et les nouveaux noms de métriques de dcgm-exporter. La règle de cryptojacking repose sur le fait que dcgm-exporter rattachepod(Kubernetes) ouhpc_job(Slurm) aux GPU en cours d’utilisation. Si l’association aux tâches n’est pas activée, tous les GPU occupés correspondront : vérifiez donc ce point en premier.node_roleest l’étiquette que l’agent UFM définit à partir deWS_NODE_ROLE; utilisez l’étiquette de rôle propre à votre parc.- Les noms des métriques propres au Collector ont perdu leur suffixe
_totaldans la version 0.165.0 que nous avons testée (otelcol_exporter_send_failed_log_records) :SiemExportFailingcorrespond donc aux deux graphies. - Les règles qui comparent avec la semaine précédente ou la veille ont besoin de cet historique avant d’avoir un sens. Faites-les passer par une route sans appel d’astreinte pendant leurs deux premières semaines.
Tests unitaires pour les deux règles les plus susceptibles d’être modifiées, exécutés avec promtool test rules :
rule_files:
- security-rules.yml
evaluation_interval: 1m
tests:
- interval: 1m
input_series:
# GPU 0 busy, no job: should fire. GPU 1 busy inside a pod: must not.
- series: 'ws:gpu_util:ratio{site="lon2",cluster="ai-prod-1",Hostname="gpu-r07-n03",gpu="0"}'
values: '0.95x30'
- series: 'ws:gpu_util:ratio{site="lon2",cluster="ai-prod-1",Hostname="gpu-r07-n03",gpu="1",pod="train-7f9",namespace="research"}'
values: '0.95x30'
alert_rule_test:
- eval_time: 20m
alertname: GpuBusyWithoutScheduledWork
exp_alerts:
- exp_labels:
severity: high
team: soc
use_case: cryptojacking
site: lon2
cluster: ai-prod-1
Hostname: gpu-r07-n03
gpu: "0"
exp_annotations:
summary: "GPU 0 on gpu-r07-n03 busy with no scheduled job"
description: "Utilisation 95% for 15 minutes with no pod or Slurm job label. Check for miners and unscheduled processes."
- interval: 1m
input_series:
- series: 'openshell_ocsf_otlp_dropped_total{namespace="openshell",pod="openshell-0",reason="queue_capacity"}'
values: '0 0 0 5 9 9 9 9 9 9 9 9'
alert_rule_test:
- eval_time: 8m
alertname: OpenShellOcsfExportDropping
exp_alerts:
- exp_labels:
severity: high
team: soc
namespace: openshell
pod: openshell-0
exp_annotations:
summary: "OpenShell gateway openshell-0 dropped OCSF audit records"
Alertmanager envoie les alertes de sécurité de gravité high et critical à PagerDuty et au service de réponse, et tout le reste vers des tickets. Les secrets proviennent de fichiers, jamais en ligne :
# /etc/alertmanager/alertmanager.yml (security routes only)
route:
receiver: platform-tickets
group_by: [alertname, site, cluster]
group_wait: 30s
group_interval: 5m
repeat_interval: 4h
routes:
- matchers: ['team="soc"', 'severity=~"high|critical"']
receiver: soc-page-and-respond
continue: true
- matchers: ['team="soc"']
receiver: soc-tickets
inhibit_rules:
# If the whole security gateway tier is down, do not also page for every export failure
- source_matchers: ['alertname="SecurityGatewayRedundancyLost"']
target_matchers: ['alertname="SiemExportFailing"']
equal: [site]
receivers:
- name: soc-page-and-respond
pagerduty_configs:
- routing_key_file: /etc/alertmanager/secrets/pagerduty-soc
severity: '{{ if eq .CommonLabels.severity "critical" }}critical{{ else }}error{{ end }}'
webhook_configs:
# Workstation response service: opens the case and runs the matching playbook
- url_file: /etc/alertmanager/secrets/soar-webhook-url
send_resolved: true
- name: soc-tickets
webhook_configs:
- url_file: /etc/alertmanager/secrets/servicenow-bridge-url
send_resolved: true
- name: platform-tickets
webhook_configs:
- url_file: /etc/alertmanager/secrets/servicenow-bridge-url
Alertmanager n’a pas de récepteur ServiceNow natif ; le webhook est envoyé à une petite passerelle de liaison ou à l’intégration d’événements propre à ServiceNow, selon ce qu’exploite le client.
10. Tableaux de bord SOC dans Grafana
Grafana est l’écran partagé des équipes SOC, plateforme et IA, avec Prometheus et Elasticsearch comme sources de données (et Loki uniquement si un client souhaite une recherche de journaux native Grafana pour les journaux hors sécurité ; les événements de sécurité restent dans Elasticsearch). Un tableau de bord de synthèse, avec des vues détaillées :
| Panneau | Type | Requête (source de données) |
|---|---|---|
| Événements de sécurité par minute, par dataset et par résultat | Série temporelle empilée | sum by (data_stream_dataset, event_outcome) (rate(ws_security_events_total[5m])) * 60 (Prometheus) |
| Refus des agents maintenant par rapport à la veille | Série temporelle avec décalage | sum(rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[5m])) et la même avec offset 1d |
| Destinations les plus refusées | Jauge en barres | Agrégation par termes sur destination.domain où event.action:Denied (Elasticsearch) |
| Sandboxes avec le plus de refus | Tableau | Termes sur container.name, dernière heure (Elasticsearch) |
| Alertes de sécurité ouvertes par gravité | Statistique | ALERTS{team="soc", alertstate="firing"} comptées par severity (Prometheus) ; nombre d’alertes Elastic issu de l’index .alerts-security.alerts-* |
| GPU occupés sans tâche | Tableau | ws:gpu_util:ratio{pod="", hpc_job=""} > 0.3 (Prometheus) |
| Trafic sortant des nœuds de modèles et de stockage | Série temporelle | sum by (instance) (rate(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[5m])) |
| Taux de réussite des attaques garak par sonde | Carte de chaleur | garak.fails / garak.total_evaluated par garak.probe sur les exécutions de CI (Elasticsearch) |
| Blocages des garde-fous par rail | Série temporelle | Nombre par rule.name dans nemo.guardrails (Elasticsearch) |
| Blocages et erreurs du WAF | Série temporelle | sum by (host) (rate(waf_blocked[5m])) et waf_errors |
| Santé du pipeline | Ligne de statistiques | Passerelles actives, échecs d’export, pertes OCSF d’OpenShell, remplissage des files d’attente |
Les tableaux de bord sont provisionnés depuis Git, comme les règles. Nous dotons chaque panneau d’une description qui indique à quoi ressemble la normale et quelle règle ou quel runbook s’applique, afin qu’un nouvel analyste puisse utiliser l’écran dès le premier jour.
11. Cas d’usage de détection
Chaque cas d’usage associe un signal à une règle et à une réponse prévue. Les niveaux de réponse sont expliqués à la section 12 : auto désigne une action pré-approuvée et réversible ; approve désigne un clic d’un approbateur nommé ; advise signifie que le dossier formule une recommandation et que des personnes agissent.
| # | Cas d’usage | Signal | Règle | Réponse |
|---|---|---|---|---|
| 1 | Trafic sortant d’un agent vers un domaine non approuvé | Refus réseau OpenShell | ws-ai-001 (Elastic, supprimée par sandbox et par domaine) | Advise : examiner la source que lisait l’agent ; si l’injection est confirmée, approuver l’arrêt de la sandbox |
| 2 | Un agent atteint un domaine jamais vu auparavant | Autorisation réseau OpenShell | ws-ai-002 (nouveaux termes, historique de 14 jours) | Advise : confirmer la destination ; resserrer une règle de politique trop large |
| 3 | Pic de refus de politique | Refus par sandbox ; taux à l’échelle du cluster | ws-ai-005 (seuil) ; AgentPolicyDenialSurge (Prometheus) | Auto : arrêter la sandbox si cela s’accompagne d’un constat ; sinon approve |
| 4 | Tentative de SSRF ou d’accès aux métadonnées | Refus avec resolves to always-blocked address | ws-ai-003 | Approve : arrêter la sandbox, effectuer la rotation de tous les identifiants qu’elle détenait |
| 5 | Identifiant de sandbox détourné | Constat OpenShell sandbox-authorization-boundary | ws-ai-004 (critical) | Auto : arrêter la sandbox, mettre le pod en quarantaine, révoquer ses secrets |
| 6 | Tentatives de jailbreak contre les garde-fous | Blocages des rails d’entrée par utilisateur | ws-ai-006 | Approve : limiter le débit de l’utilisateur ou le suspendre ; examiner les métadonnées de la conversation |
| 7 | Régression garak dans la CI | Taux de réussite des attaques supérieur à 5 % pour une sonde | ws-ai-007 (ES|QL) | Auto : faire échouer le point de contrôle du pipeline ; informer le responsable du modèle |
| 8 | Alerte d’exécution DOCA Argus | Argus ALERT en HIGH ou CRITICAL | ws-ai-008 | Approve : isoler l’hôte (contrôles Sentry ou BlueField là où ils sont déployés ; sinon cordon et politique réseau) |
| 9 | Cryptojacking GPU | GPU occupé sans pod ni tâche Slurm ; exécutions depuis /tmp | GpuBusyWithoutScheduledWork (Prometheus) ; ws-ai-014 (auditd) | Approve : vider le nœud et tuer le processus ; préserver d’abord les preuves |
| 10 | Exfiltration de poids de modèles | Trafic sortant horaire des nœuds d’inférence ou de stockage plus de 3 fois supérieur à la semaine précédente | UnusualEgressFromModelNodes (Prometheus) | Approve : bloquer le trafic sortant du nœud ; vérifier les lectures du registre et du coffre |
| 11 | Connexion anormale, puis approbation d’un accès privilégié pour un agent | Connexion SSO OpsAPI hors du Royaume-Uni, approbation dans les 30 minutes | ws-ai-009 (séquence EQL) | Approve : révoquer l’approbation et les sessions ; vérifier auprès de l’utilisateur par un autre canal |
| 12 | Lecture d’un secret en dehors de la plage convenue | wslvault secret.read en dehors de 07:00–19:00 UTC | ws-ai-010 (ES|QL) | Advise : confirmer avec le responsable ; effectuer une rotation si inexpliqué |
| 13 | Pod privilégié créé | Audit Kubernetes, conteneur privilégié dans la spécification d’un pod | ws-ai-011 | Approve : supprimer le pod ; examiner le RBAC de l’identité qui l’a créé |
| 14 | Échec de l’attestation de confidential computing | Résultat d’attestation failure | ws-ai-012 (critical) | Auto : le service de clés a déjà refusé ; appeler l’astreinte et maintenir le nœud hors du pool |
| 15 | Force brute en périphérie web | Blocages du WAF wslproxy par client | ws-ai-013 | Auto : le WAF bloque déjà ; ajouter à la liste de refus en périphérie après approbation |
| 16 | Perte de télémétrie de sécurité | Pertes OCSF d’OpenShell ; échecs d’export vers le SIEM ; une seule passerelle restante | OpenShellOcsfExportDropping, SiemExportFailing, SecurityGatewayRedundancyLost | Appeler le SOC : un angle mort est un incident |
12. Réponse et SOAR
Une détection sans réponse n’est qu’un rapport. Nous relions les réponses aux alertes via un petit service de réponse (la cible webhook dans Alertmanager, et un connecteur Elastic pour les règles de détection) qui ouvre ou met à jour le dossier, vérifie le niveau de réponse de la règle, puis exécute un playbook, demande une approbation, ou se contente d’enregistrer une recommandation.
Options de confinement, de la plus restreinte à la plus large
- Arrêter la sandbox (OpenShell).
openshell sandbox stop <name>arrête un agent et conserve la sandbox pour l’enquête ;openshell sandbox delete <name>la supprime une fois les preuves collectées. Pour retirer une permission plutôt que d’arrêter l’agent,openshell policy update <name> --remove-rule <rule> --wait. Collectez les fichiers OCSF du superviseur avant la suppression : sur Kubernetes, ils résident dans leemptyDirdu pod superviseur et disparaissent avec lui. - Mettre le pod en quarantaine (Kubernetes). Une NetworkPolicy à l’échelle du namespace isole tout pod portant une étiquette de quarantaine ; le playbook se contente d’ajouter l’étiquette, ce qui est rapide, réversible et facile à auditer. Votre CNI doit appliquer les NetworkPolicy, comme l’exigent aussi les recommandations Kubernetes d’OpenShell.
- Révoquer les secrets. Révoquez les baux de l’identité de l’agent dans le service de clés afin que tout ce qu’il a pu exfiltrer cesse de fonctionner. Avec wslvault, l’agent n’a de toute façon jamais détenu de clés à longue durée de vie, ce qui limite ce qu’il y a à révoquer.
- Isoler l’hôte (BlueField et Sentry). Là où Sentry sur BlueField-4 est déployé, la conception de NVIDIA met un agent en quarantaine au niveau du DPU en quelques millisecondes, indépendamment de l’hôte. Là où il ne l’est pas, la solution de repli consiste à isoler (cordon) et vider le nœud et à appliquer un blocage réseau au niveau de l’hôte. Nous ne pilotons les actions côté DPU qu’au travers des interfaces documentées par NVIDIA pour la version déployée ; nous n’en scriptons pas de non documentées.
- Escalader vers la plateforme XDR. Là où DOCA Argus alimente la plateforme XDR d’un client, les actions de réponse propres à cette plateforme restent disponibles et le dossier consigne quel outil a agi.
# Applied once per namespace; the playbook only adds the label
# kubectl -n agents label pod <pod> ws.security/quarantine=true
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: quarantine
namespace: agents
spec:
podSelector:
matchLabels:
ws.security/quarantine: "true"
policyTypes: [Ingress, Egress]
ingress:
# forensics tooling only
- from:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: soc-forensics
egress:
# DNS stays up so the pod's own logs about failures still make sense
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- protocol: UDP
port: 53
- protocol: TCP
port: 53
Points d’approbation via l’authentification unique OpsAPI
Toute réponse non pré-approuvée passe par une étape d’approbation dans OpsAPI : l’approbateur se connecte par authentification unique (et authentification multifacteur), consulte le résumé du dossier, puis approuve ou rejette. L’approbation est elle-même un événement de sécurité (opsapi.sso, agent.approval.granted et les événements apparentés), ce qui explique que le cas d’usage 11 puisse surveiller une connexion suspecte suivie d’une approbation. Nous la configurons de sorte que les approbateurs ne puissent pas approuver leurs propres demandes, et que les modifications de la configuration du pipeline de sécurité lui-même nécessitent deux personnes. Le même schéma est décrit pour les permissions des agents dans notre article sur la sécurité de l’IA agentique.
ServiceNow et PagerDuty
Les alertes high et critical déclenchent un appel via PagerDuty ; chaque alerte ouvre ou met à jour un incident ServiceNow (ou un incident de sécurité, si le client exploite ce module), lié au dossier Elastic. La résolution suit le chemin inverse : lorsque le dossier est clos, l’incident est résolu et l’alerte PagerDuty est levée. Nous convenons par écrit avec le client du niveau d’automatisation de chaque règle, le réexaminons chaque trimestre, et ne faisons passer un playbook en auto qu’après un historique sans faute en approve.
13. Correspondance avec les référentiels de conformité
La supervision est le moyen de démontrer que les contrôles fonctionnent. La correspondance ci-dessous constitue une orientation générale, et non un avis juridique ; votre délégué à la protection des données et vos responsables de la conformité ont le dernier mot.
| Régime | Ce qu’il attend, en termes généraux | Comment cette conception y contribue |
|---|---|---|
| UK GDPR | Sécurité appropriée du traitement (article 32), intégrité et confidentialité (article 5(1)(f)), protection des données dès la conception (article 25), notification des violations de données personnelles à l’ICO dans les meilleurs délais et, si possible, dans les 72 heures (article 33), et analyses d’impact pour les traitements à haut risque (article 35) | Les détections et les timelines fournissent les faits nécessaires à l’évaluation d’une violation dans le délai imparti ; le masquage au niveau de la passerelle et la désactivation de la capture de contenu réduisent au minimum les données personnelles dans les journaux ; la conservation est définie par dataset et documentée. Les journaux de sécurité contiennent eux-mêmes des données personnelles (identifiants d’utilisateurs, adresses IP) : consignez donc la base légale (généralement l’intérêt légitime), restreignez l’accès et incluez le SIEM dans votre AIPD |
| Obligations de type NIS (les NIS Regulations britanniques, la directive européenne NIS2 pour les activités dans l’UE, et les réformes britanniques proposées) | Mesures de gestion des risques, traitement des incidents, continuité d’activité, sécurité de la chaîne d’approvisionnement, et notification en temps utile des incidents importants à l’autorité compétente ; les centres de données et les services cloud entrent dans le champ de certains régimes | Une capacité de détection et de réponse documentée, avec des preuves de son fonctionnement ; des signaux sur la chaîne d’approvisionnement (garak dans la CI, politique d’images et de paquets) ; des délais de notification étayés par les enregistrements des dossiers. Savoir si une organisation donnée entre dans le champ est une question juridique |
| ISO/IEC 27001:2022 Annexe A | 8.15 Journalisation, 8.16 Activités de surveillance, 8.17 Synchronisation des horloges, 5.24 à 5.28 gestion des incidents, y compris la collecte de preuves, 8.12 Prévention des fuites de données, 8.8 Gestion des vulnérabilités techniques | Journaux centralisés, protégés et conservés (8.15) ; règles et tableaux de bord avec des responsables (8.16) ; horodatages synchronisés par NTP et pris dans l’événement source (8.17) ; dossiers, timelines et originaux préservés (5.24 à 5.28) ; contrôles du trafic sortant et des rails de sortie (8.12) ; garak et contrôles d’images comme gestion des vulnérabilités pour l’IA (8.8) |
| Cyber Essentials | Cinq contrôles techniques : pare-feu, configuration sécurisée, gestion des mises à jour de sécurité, contrôle des accès utilisateurs et protection contre les logiciels malveillants | Cyber Essentials est un socle de base et n’exige pas de SIEM, mais la même télémétrie montre que les contrôles fonctionnent : WAF et politique de trafic sortant (pare-feu), détections de pods privilégiés et de modifications de configuration (configuration sécurisée), journaux SSO et d’approbation (contrôle des accès), et détections Argus et auditd (protection contre les logiciels malveillants) |
14. Conservation, coûts et cardinalité
La télémétrie de sécurité grossit discrètement jusqu’à l’arrivée de la facture. Quatre règles la rendent prévisible :
- Conserver par dataset, et non globalement. Un point de départ typique : OpenShell, SSO, coffre, audit Kubernetes, attestation et Argus à 13 mois ; décisions du WAF à 90 jours dans Elasticsearch avec un archivage plus long si nécessaire ; enregistrements d’évaluation garak pendant toute la durée de vie du modèle ; événements réseau OpenShell autorisés (et non refusés) à 30 à 90 jours, car ils servent surtout à établir des références. Les données plus anciennes peuvent passer sur des snapshots consultables ou du stockage objet si la licence Elastic le permet.
- Dimensionner à partir des événements par agent. À titre d’exemple chiffré, et non de mesure : 200 agents produisant en moyenne 2 000 événements OCSF par heure d’environ 1,2 KB chacun représentent environ 11,5 GB par jour avant réplicas et compression. Les événements réseau autorisés dominent ; les refus et les constats n’en représentent qu’une petite fraction. Mesurez votre propre débit lors d’un pilote avant de dimensionner.
- Les métriques restent à faible cardinalité. Le compteur d’événements a trois étiquettes ayant chacune une poignée de valeurs, plus
siteetcluster. Les identifiants de sandbox, noms de pods, identifiants d’utilisateurs et domaines sont non bornés : ils ont leur place dans Elasticsearch, jamais dans des étiquettes Prometheus. Une seule étiquette mal choisie (un identifiant de sandbox sur un cluster très actif) peut ajouter des milliers de nouvelles séries par jour. - N’envoyer à chaque backend que ce qu’il utilise. Chaque événement va une fois vers Elasticsearch ; Dynatrace reçoit Medium et au-delà ; Prometheus reçoit les comptages. Les traces restent échantillonnées au niveau de l’application. Tout dupliquer dans chaque outil est l’erreur de coût la plus fréquente que nous constatons.
15. Haute disponibilité du pipeline de sécurité
Un attaquant capable d’aveugler le SIEM a déjà gagné la moitié de la bataille : le pipeline est donc conçu pour continuer à fonctionner en cas de défaillance et pour donner l’alerte lorsqu’il n’y parvient pas.
- Passerelles : au moins deux par site derrière un répartiteur de charge ou un nom DNS, sans état hormis leurs files d’attente persistantes sur disque local. Les agents et OpenShell réessaient vers la passerelle qui répond ; un redémarrage de passerelle ne fait rien perdre de ce qui est en file d’attente.
- « Au moins une fois » de bout en bout : files d’envoi persistantes sur les agents et les passerelles, nouvelles tentatives propres à OpenShell, et identifiants de documents issus des identifiants d’événements, afin que les nouvelles tentatives ne créent jamais de doublons.
- Elasticsearch : au moins trois nœuds éligibles comme maîtres répartis sur des domaines de défaillance, un réplica pour chaque index de sécurité, des snapshots vers un magasin séparé, et un rôle d’écriture pour les passerelles qui ne peut pas supprimer de données.
- Prometheus et Alertmanager : deux réplicas Prometheus (dédupliqués dans Mimir, comme dans la conception UFM) et un cluster Alertmanager à trois nœuds.
- Auto-surveillance : les règles de santé du pipeline de la section 9, plus un heartbeat : un refus OpenShell synthétique généré toutes les cinq minutes dans une sandbox canari doit arriver dans Elasticsearch, faute de quoi une règle déclenche un appel. Les enregistrements de lacune d’OpenShell (
openshell.ocsf.gap) sont eux aussi des événements consultables. - Séparation des tâches : l’équipe de sécurité détient la configuration des passerelles et le SIEM ; les modifications passent par une revue à deux personnes ; l’équipe plateforme peut voir la santé du pipeline mais ne peut pas modifier ce qui est collecté.
- Horloges : chaque source et chaque passerelle synchronisées sur les mêmes sources de temps, et
@timestamppris dans l’événement source et non à l’ingestion, afin que les séquences entre sources s’alignent.
16. Prouver que cela fonctionne : exercices lors du transfert
Nous ne remettons pas une détection que nous n’avons pas vue se déclencher. Sous les yeux de l’équipe du client, nous exécutons et enregistrons :
- Un agent dans une sandbox de test lit une page contenant une instruction piégée et tente un téléversement vers un site de partage de texte : un refus OpenShell, une alerte Elastic supprimée, une timeline montrant la lecture et la tentative.
- Une sandbox de test appelle l’API d’une autre sandbox avec son propre identifiant : un constat critique, l’arrêt automatique, l’étiquette de quarantaine appliquée, le dossier mis à jour à chaque action.
- Une sonde malveillante connue est ajoutée à une branche de CI : le taux de réussite des attaques garak dépasse 5 % et le point de contrôle du pipeline échoue.
- Une tâche de benchmark s’exécute sur un GPU sans tâche d’ordonnanceur associée : l’alerte de cryptojacking se déclenche dans sa fenêtre de 15 minutes.
- Un pod de test avec un conteneur privilégié est créé : la règle Kubernetes se déclenche et le playbook demande une approbation.
- Une passerelle de sécurité est arrêtée : aucun événement perdu, un appel de redondance, rétablissement à son retour.
- Le SIEM est coupé des passerelles pendant 15 minutes : l’appel pour échec d’export se déclenche, les files d’attente se remplissent puis se vident ensuite, et le heartbeat ne montre aucune lacune.
17. Comment Workstation livre et exploite cette solution
- Évaluation. Inventaire du parc, des agents et de ce qu’ils peuvent toucher, des actifs de données et de modèles, ainsi que des outils existants de SIEM, de supervision et de réponse. Livrable : une carte des menaces et des contrôles comme celle de la section 2, propre à votre contexte.
- Architecture. Choix des sources, du schéma, des backends, de la conservation, de la haute disponibilité et de la position au regard du UK GDPR. Livrable : une conception signée.
- Construction. Agents Collector et passerelles de sécurité, export OCSF d’OpenShell, pipelines d’ingestion, modèles d’index, politiques de cycle de vie et tableaux de bord, le tout à partir d’une configuration sous gestion de versions dans vos dépôts.
- Ingénierie de détection. Règles, alertes et playbooks pour vos cas d’usage, chacun avec un événement de test et un responsable.
- Réglage. Fonctionnement discret pendant deux à quatre semaines, réduction du bruit, définition des seuils et des suppressions, et accord sur un budget d’alertes soutenable pour l’équipe.
- Transfert. Les exercices de la section 16, les runbooks, et la formation des analystes et des ingénieurs plateforme.
- Support de supervision géré. Un support de supervision continu aux côtés de votre équipe (ou en couverture hors heures ouvrées pour votre équipe) : mises à jour des règles au fil de l’évolution des produits NVIDIA et du paysage des menaces, mises à niveau du pipeline, revues régulières de chasse aux menaces, et un rapport mensuel sur les détections, les délais de réponse, le bruit et la couverture. Les niveaux de service exacts sont convenus avec chaque client.
Partenaire NVIDIA : ingénierie, logiciels et personnes
Workstation est partenaire NVIDIA : en plus du matériel, nous fournissons donc l’ingénierie, les logiciels et le personnel pour mettre en place et exploiter des centres de données d’IA de bout en bout, y compris la supervision de sécurité qui les entoure. Nous spécifions et fournissons la plateforme, l’installons et la configurons, construisons l’intégration d’observabilité et de SIEM décrite ici, et mettons à disposition des ingénieurs qui travaillent ensuite au sein de votre processus de gestion des changements.
- DPU et réseau : DPU NVIDIA BlueField (dont la BlueField-3 B3220, la génération minimale pour DOCA Argus), SuperNIC ConnectX-8 et la plateforme Ethernet Spectrum-X.
- Systèmes GPU : DGX B300, serveurs HGX B300, DGX SuperPOD et Vera Rubin NVL72, la classe de systèmes retenue pour l’inférence dans l’OpenShell Reference Architecture de NVIDIA.
- Logiciels : abonnements NVIDIA AI Enterprise, et mise en place et support d’OpenShell, de NeMo Guardrails, de garak et des composants ouverts présentés dans cet article.
Pour discuter de votre parc, interrogez notre AI Sales Engineer, qui vous orientera vers le bon ingénieur.
18. Sources et notes de vérification
- Vue d’ensemble du portefeuille NVIDIA : la page officielle des solutions d’IA pour la cybersécurité de NVIDIA, consultée en novembre 2026, pour OpenShell et son architecture de référence, Sentry sur BlueField, BlueField et DOCA, DOCA Argus, DOCA Vault, le confidential computing, Nemotron et Nemotron Safety, NeMo, garak et NemoClaw. Toutes les formulations ici sont notre propre résumé.
- OpenShell : le README du dépôt GitHub et ses pages de documentation sur la journalisation des sandboxes, l’export JSON OCSF, la configuration de la passerelle (export OCSF JSONL et OTLP), les métriques de la passerelle, les sandboxes et les politiques. Les classes OCSF, les chaînes de raison, le constat
sandbox-authorization-boundary, les attributs OTLP, les noms de métriques et les commandes CLI sont cités à partir de ces pages. L’enregistrement OCSF d’exemple de notre test a été construit à partir de l’exemple de la documentation. - DOCA Argus : le guide du service DOCA Argus de NVIDIA pour les prérequis, les types de messages, les niveaux de gravité et les clés de télémétrie. Non testé sur matériel ; les chemins de champs doivent être vérifiés sur un message réel de votre version.
- Sentry, DOCA Vault et l’OpenShell Reference Architecture : décrits uniquement à partir de la page publique de NVIDIA. Aucune interface, aucun format ni aucune commande ne sont donnés ici pour ces éléments.
- Confidential computing : la page de NVIDIA et le README de nvTrust. Le format de l’événement d’attestation relève de la convention de Workstation.
- NeMo Guardrails : le README du dépôt (types de rails, version 0.24.1) et sa référence de configuration du traçage. La convention des événements de blocage relève de Workstation.
- garak : le README du dépôt, les options CLI et le code source de l’évaluateur pour les champs des enregistrements d’évaluation. L’ensemble de sondes de l’exemple de CI est illustratif.
- Morpheus : le README du dépôt, les exemples et la liste des versions (dernier tag 25.06, juillet 2025, au moment de la rédaction).
- Dynatrace : la documentation de Dynatrace sur l’API OTLP et la configuration du Collector, pour l’endpoint, le protocole, les scopes de jetons et la temporalité delta. Non testé sur un tenant réel : l’exportateur a été validé et s’est exécuté, mais ses requêtes allaient vers un environnement fictif. La détection d’anomalies Davis et le routage des événements de sécurité sont décrits de manière générale, d’après la documentation de Dynatrace.
- OpenTelemetry Collector : les deux configurations ont été validées avec
otelcol-contrib validatedansotel/opentelemetry-collector-contrib:0.165.0, puis exécutées : des enregistrements de test OCSF, Argus, d’appliance, de garde-fous, auditd, d’audit Kubernetes et garak ont été envoyés via un agent et la passerelle vers Elasticsearch et Prometheus, et les documents et séries obtenus ont été inspectés. Les endpoints et noms d’hôtes sont fictifs. - Elastic : pipeline d’ingestion, modèle d’index et politique de cycle de vie appliqués à Elasticsearch 9.2.0 ; les quatorze règles ont été créées via l’API du moteur de détection de Kibana 9.2.0, se sont exécutées correctement et ont levé les alertes attendues (treize se sont déclenchées ; la règle hors heures ne l’a pas fait, à juste titre, car son événement de test se situait pendant les heures). Les modèles de timeline, les connecteurs de dossiers et le recouvrement avec les règles prédéfinies n’ont pas été testés.
- Prometheus et Alertmanager : règles validées avec
promtool check ruleset testées unitairement avecpromtool test rules, Prometheus 3.12.0 ; configuration d’Alertmanager validée avecamtool check-config, Alertmanager 0.34.2. Les noms de métriques DCGM suivent dcgm-exporter 4.9.0 via les règles d’enregistrementws:de l’article UFM. - Kubernetes : la NetworkPolicy de quarantaine a été validée avec
kubeconform0.8.0 en mode strict. Non testée sur un CNI réel. - Conventions Workstation : les noms de datasets, les identifiants de règles, la métrique
ws.security.events, les noms d’actions pour wslvault et OpsAPI, l’événement de blocage des garde-fous et l’événement d’attestation sont les nôtres. - Chiffres illustratifs : les débits d’événements, volumes, seuils et durées sont des exemples chiffrés, et non des mesures issues d’un système client.
- Conformité : orientation générale uniquement, et non avis juridique.
Mention des droits : NVIDIA, le logo NVIDIA, BlueField, DOCA, DOCA Argus, DOCA Vault, Sentry, OpenShell, NemoClaw, Nemotron, NeMo, NeMo Guardrails, Morpheus, Vera, Vera Rubin, Blackwell, DGX, HGX, Spectrum, Spectrum-X, ConnectX, SuperNIC, NVLink, DCGM, UFM et NVIDIA AI Enterprise sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d’autres pays. Les produits et technologies NVIDIA peuvent être protégés par des brevets et d’autres droits de propriété intellectuelle détenus par NVIDIA Corporation, et tous ces droits sont reconnus et réservés à leurs titulaires. Les informations sur les produits sont résumées dans nos propres termes à partir des documents publics de NVIDIA ; le site web et la documentation de NVIDIA font foi. garak est un projet open source maintenu par NVIDIA. Elastic, Elasticsearch, Kibana, Logstash, Elastic Security, Dynatrace, Davis, Prometheus, Alertmanager, Grafana, Loki, OpenTelemetry, Kubernetes, ServiceNow, PagerDuty, MITRE ATT&CK, Fluent Bit, Vector et Slurm sont des marques commerciales ou des marques déposées de leurs propriétaires respectifs, et d’autres noms peuvent être des marques commerciales de leurs propriétaires respectifs. Aucune approbation de la part de ces entreprises n’est sous-entendue. Les configurations, règles, schémas et textes propres à Workstation sont © Workstation.