La boutique est ouverte

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

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

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

Nous contacter

Solutions IA

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

Produits

Tous les produitsCRM & ERP natifs Workstation AIMarketingAgents OpenAIRing PromoterJobshout

Entreprise

À proposEntrepriseCentres de données IAPourquoi WorkstationPartenairesTémoignages clientsTarifsContactTenthMatrix

Ressources

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

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

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

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

Accueil / Notes techniques / Technology
AISecurityObservabilityAI Agents

Cybersécurité IA de NVIDIA avec OpenTelemetry et SIEM : BlueField, DOCA Argus, OpenShell et Guardrails vers Elastic Security, Dynatrace, Prometheus et Grafana

Menaces des centres de données d’IA associées aux contrôles, portefeuille de sécurité NVIDIA couche par couche, pipeline de sécurité OpenTelemetry validé, quatorze règles de détection Elastic testées, alertes Prometheus, playbooks de réponse, correspondance UK GDPR et ISO 27001, conservation, haute disponibilité et accompagnement par phases

9 novembre 2026Technology70 min read

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.

Les signaux de sécurité issus des DPU BlueField, des GPU confidentiels, des sandboxes OpenShell, des garde-fous et de Kubernetes transitent par des passerelles de sécurité OpenTelemetry vers Elastic Security, Dynatrace, Prometheus avec Alertmanager, et Grafana.

En résumé. NVIDIA livre désormais des contrôles de sécurité à chaque couche d’un centre de données d’IA : dans le DPU, dans le GPU, dans le runtime qui héberge les agents, et dans les modèles et les garde-fous qui les entourent. Chaque contrôle produit des preuves. Ces preuves ne sont utiles que si elles parviennent à un SIEM sous une forme cohérente, assez vite pour agir, sans laisser fuir de secrets ni de prompts en chemin. Notre conception collecte chaque signal de sécurité une seule fois via des OpenTelemetry Collectors, le met en correspondance avec l’Elastic Common Schema, le masque, puis le distribue : chaque événement vers Elastic Security pour la détection, l’investigation et les dossiers ; les événements de gravité plus élevée, les métriques et les traces vers Dynatrace ; les compteurs à faible cardinalité vers Prometheus pour les alertes ; et les tableaux de bord dans Grafana. Les réponses partent des mêmes alertes, avec un confinement automatique uniquement lorsqu’il est réversible et une approbation humaine nominative partout ailleurs.
Ce qui a été testé, et ce qui ne l’a pas été. Les configurations du Collector ont été validées avec 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.

MenaceComment elle se manifesteContrôles préventifsSignal surveillé
Injection de prompt directe et jailbreaksDes utilisateurs rédigent des prompts pour amener un modèle à ignorer ses instructions ou à produire un contenu nuisibleRails d’entrée NeMo Guardrails, classifieurs Nemotron Safety, tests garak dans la CIBlocages des rails par utilisateur ; taux de réussite des attaques garak par sonde
Injection de prompt indirecte et détournement d’objectifDes 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’exfiltrationPolitique réseau et fichiers d’OpenShell (refus par défaut), rails de récupération, approbation humaine pour tout nouvel accèsRefus OpenShell et nouvelles destinations ; rafales de refus par sandbox
Fuite de donnéesDonnées personnelles, secrets ou code source dans les prompts, les réponses, les journaux ou les téléversements des agentsRails 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 secretsBlocages des rails de sortie, refus de sortie, détections de données sensibles (Morpheus ou rails)
Vol de modèles et de poidsTransferts volumineux de checkpoints ou de poids ; lectures inhabituelles dans les registres de modèlesConfidential computing, DOCA Vault, clés détenues par wslvault, segmentation réseauVolume sortant des nœuds d’inférence et de stockage ; lectures de secrets en dehors des heures ; échecs d’attestation
Chaîne d’approvisionnementFichiers de modèles empoisonnés, paquets malveillants installés par des agents, images de conteneurs altéréesPolitique de processus et de paquets d’OpenShell, signature des images et contrôle d’admission, tests de régression garakNouvelles exécutions de processus (Argus, auditd), empreintes d’images inattendues, régressions garak
Mouvement latéralUn agent ou un pod compromis atteint l’API Kubernetes, le service de métadonnées cloud ou d’autres tenantsOpenShell bloque les ports du plan de contrôle et les adresses link-local ; RBAC et politique réseau Kubernetes ; isolation BlueFieldRefus de type SSRF, constats d’autorisation entre sandboxes, création de pods privilégiés
Cryptojacking GPUDes mineurs exploitent du temps GPU volé, souvent sur des nœuds inactifs ou mal planifiésAccès aux GPU uniquement via l’ordonnanceur, politique d’exécution, détection à l’exécution par DOCA ArgusGPU occupé sans tâche planifiée (DCGM) ; exécutions depuis /tmp ; alertes Argus
Abus interneUn administrateur ou un compte compromis lit des secrets, élargit les permissions des agents ou désactive la supervisionAuthentification 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 fiableUn 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’utilisationConfidential 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

Cinq couches en partant du bas : silicium et DPU (BlueField, DOCA, DOCA Argus, DOCA Vault, Sentry, DOCA Telemetry Service), plateforme (confidential computing et attestation), runtime des agents (OpenShell, avec NemoClaw au-dessus), modèles et garde-fous (Nemotron Safety, NeMo Guardrails, garak), et pipelines (Morpheus), chacune avec les signaux qu’elle transmet à un SIEM.

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_type valant EVENT, ALERT ou SYSTEM_ACTIVITY et un severity allant de INFO à CRITICAL, avec des sections de charge utile telles que workload_information et activity_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) et telemetry_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 exemple no matching policy ou resolves 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.uid sandbox-authorization-boundary : l’identifiant est peut-être compromis.
  • Définir enabled = true sous [openshell.gateway.otlp.ocsf] dans gateway.toml exporte les événements OCSF sous forme d’enregistrements de journal OTLP dans le périmètre d’instrumentation openshell.ocsf. Le corps est l’événement OCSF en JSON ; les attributs comprennent ocsf.class_uid, ocsf.severity_id, ocsf.metadata.uid et openshell.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 dans openshell_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

À gauche, les sources (agents de nœud, OpenShell, DOCA Argus, syslog des appliances, applications protégées) alimentent une paire de passerelles de sécurité qui analyse l’OCSF, met en correspondance avec l’ECS, masque, route et comptabilise ; à droite, Elastic Security reçoit tous les journaux, Dynatrace reçoit les événements de gravité plus élevée, les métriques et les traces, Prometheus avec Alertmanager reçoit les compteurs et les métriques, et Grafana lit les deux ; une bande inférieure montre l’alerte, le dossier, l’approbation et le confinement.

Cinq principes guident la conception :

  1. 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.
  2. 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.
  3. 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.
  4. 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é.
  5. 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

SourceCe qu’elle nous apprendTransport vers le pipelineDataset
Passerelle et superviseurs OpenShellChaque autorisation et chaque refus pour les appels réseau, HTTP, processus, SSH, authentification et API ; chargements de politiques ; constatsOCSF via OTLP depuis [openshell.gateway.otlp.ocsf] ; métriques de la passerelle par scrapingopenshell.ocsf
DOCA Argus sur BlueFieldAlertes et activité à l’exécution issues de l’analyse de la mémoire de l’hôteJSON en TCP vers la passerelledoca.argus
Sentry sur BlueField-4Écarts de comportement des agents, actions de quarantaineSelon la documentation Sentry de NVIDIA ; nous les mettons en correspondance selon le même modèle de datasetnvidia.sentry (prévu)
Confidential computingRéussite ou échec de l’attestation par GPU et par charge de travailLe wrapper de lancement journalise du JSON ECS vers syslogcc.attestation
Applications NeMo GuardrailsBlocages des rails (événements) et durées des rails (spans)OTLP depuis l’applicationnemo.guardrails
garak dans la CITaux de réussite des attaques par sonde et par détecteurLe Collector du runner suit le rapport JSONLgarak.eval
Serveur d’API KubernetesQui a créé, modifié quoi, ou exécuté une commande dans quoiL’agent des nœuds du plan de contrôle suit le journal d’auditkubernetes.audit_logs
WAF wslproxyChaque décision du WAF avec signature, client et route ; compteurs PrometheusJSON wafsec via syslog ; métriques par scrapingwslproxy.waf
wslvaultLectures, écritures et refus de secrets par identitéJSON ECS via syslogwslvault.audit
Authentification unique OpsAPIConnexions, échecs, approbations d’accès privilégiés des agentsJSON ECS via syslogopsapi.sso
Hôtes LinuxExécutions, changements de privilèges, surveillance de fichiers (auditd)L’agent suit /var/log/audit/audit.logauditd.log
DCGM et node-exporterUtilisation des GPU sans tâche, volume sortantPipeline 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 ECSLieu de la mise en correspondance
action (Allowed, Denied)event.actionPasserelle
status_id (1 succès, 2 échec)event.outcomePasserelle
status_detail, ou finding_info.uid pour les constatsevent.reasonPipeline d’ingestion
class_uidevent.category (network, process, authentication, api, configuration, intrusion_detection)Pipeline d’ingestion
type_uid, severity_id, metadata.uidevent.code, event.severity, event.idPipeline d’ingestion
dst_endpoint.domain, .ip, .portdestination.domain, destination.ip, destination.portPasserelle (domaine, port), pipeline d’ingestion (ip)
src_endpoint.ipsource.ipPipeline d’ingestion
actor.process.name, .pid, .cmd_lineprocess.executable, process.pid, process.command_linePasserelle, pipeline d’ingestion
actor.user.uiduser.idPipeline d’ingestion
device.container.name, .uid (la sandbox)container.name, container.idPasserelle, pipeline d’ingestion
firewall_rule.name (la politique correspondante)rule.namePasserelle
metadata.product.name, .versionobserver.product, observer.versionPipeline d’ingestion
time (millisecondes epoch)@timestampPipeline d’ingestion
enregistrement completevent.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 exemple execve sur 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 niveau Request, pour les opérations create, update et patch sur pods, 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 de ocsf.metadata.uid avec logs_dynamic_id activé 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_pipeline sé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 WARN2 et au-delà (OpenShell fait correspondre OCSF Medium à WARN2 et 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.events avec 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 avec delta_to_cumulative. Lors de notre test, Prometheus a reçu ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied", event_outcome="failure"} avec les étiquettes site et cluster.
  • 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_delta sur le seul chemin Dynatrace.
  • Étiquettes constantes. resource_constant_labels ne transforme que site et cluster en é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ègleTypeGravité
Trafic sortant d’un agent IA refusé par la politique OpenShell
ws-ai-001-agent-egress-denied
Requête KQLmedium
Un agent IA a atteint un domaine jamais vu depuis 14 jours
ws-ai-002-agent-new-egress-domain
Nouveaux termes (KQL)low
Un agent IA a tenté d’atteindre une adresse link-local ou loopback
ws-ai-003-agent-ssrf-blocked
Requête KQLhigh
Identifiant de sandbox OpenShell utilisé hors de son périmètre
ws-ai-004-sandbox-boundary-finding
Requête KQLcritical
Rafale de refus de politique OpenShell provenant d’une même sandbox
ws-ai-005-policy-denial-spike
Seuil (KQL)high
Tentatives répétées de jailbreak bloquées par NeMo Guardrails
ws-ai-006-guardrail-jailbreak-attempts
Seuil (KQL)medium
Taux de réussite des attaques garak supérieur à 5 % dans la CI
ws-ai-007-garak-regression
ES|QLhigh
Alerte d’exécution DOCA Argus sur un hôte GPU
ws-ai-008-doca-argus-alert
Requête KQLcritical
Connexion depuis l’extérieur du Royaume-Uni suivie d’une approbation d’agent
ws-ai-009-sso-anomaly-then-agent-approval
Séquence EQLhigh
Lecture d’un secret wslvault en dehors de la plage 07:00–19:00 UTC
ws-ai-010-vault-read-out-of-hours
ES|QLmedium
Pod privilégié créé ou modifié dans Kubernetes
ws-ai-011-k8s-privileged-pod
Requête KQLhigh
Échec de l’attestation de confidential computing
ws-ai-012-attestation-failure
Requête KQLcritical
Le WAF wslproxy bloque un même client de façon répétée
ws-ai-013-waf-block-burst
Seuil (KQL)medium
Programme exécuté depuis /tmp ou /dev/shm sur un nœud GPU
ws-ai-014-exec-from-tmp
Requête KQLhigh

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, _version et 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/metrics et /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_http dans la passerelle.
  • Authentification. Un jeton de plateforme Dynatrace dans un en-tête Authorization: Bearer, avec les scopes openpipeline:logs:ingest, openpipeline:metrics:ingest et openpipeline: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:ratio est 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 rattache pod (Kubernetes) ou hpc_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_role est l’étiquette que l’agent UFM définit à partir de WS_NODE_ROLE ; utilisez l’étiquette de rôle propre à votre parc.
  • Les noms des métriques propres au Collector ont perdu leur suffixe _total dans la version 0.165.0 que nous avons testée (otelcol_exporter_send_failed_log_records) : SiemExportFailing correspond 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 :

PanneauTypeRequête (source de données)
Événements de sécurité par minute, par dataset et par résultatSérie temporelle empiléesum by (data_stream_dataset, event_outcome) (rate(ws_security_events_total[5m])) * 60 (Prometheus)
Refus des agents maintenant par rapport à la veilleSérie temporelle avec décalagesum(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éesJauge en barresAgrégation par termes sur destination.domain où event.action:Denied (Elasticsearch)
Sandboxes avec le plus de refusTableauTermes sur container.name, dernière heure (Elasticsearch)
Alertes de sécurité ouvertes par gravitéStatistiqueALERTS{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âcheTableauws:gpu_util:ratio{pod="", hpc_job=""} > 0.3 (Prometheus)
Trafic sortant des nœuds de modèles et de stockageSérie temporellesum by (instance) (rate(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[5m]))
Taux de réussite des attaques garak par sondeCarte de chaleurgarak.fails / garak.total_evaluated par garak.probe sur les exécutions de CI (Elasticsearch)
Blocages des garde-fous par railSérie temporelleNombre par rule.name dans nemo.guardrails (Elasticsearch)
Blocages et erreurs du WAFSérie temporellesum by (host) (rate(waf_blocked[5m])) et waf_errors
Santé du pipelineLigne de statistiquesPasserelles 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’usageSignalRègleRéponse
1Trafic sortant d’un agent vers un domaine non approuvéRefus réseau OpenShellws-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
2Un agent atteint un domaine jamais vu auparavantAutorisation réseau OpenShellws-ai-002 (nouveaux termes, historique de 14 jours)Advise : confirmer la destination ; resserrer une règle de politique trop large
3Pic de refus de politiqueRefus par sandbox ; taux à l’échelle du clusterws-ai-005 (seuil) ; AgentPolicyDenialSurge (Prometheus)Auto : arrêter la sandbox si cela s’accompagne d’un constat ; sinon approve
4Tentative de SSRF ou d’accès aux métadonnéesRefus avec resolves to always-blocked addressws-ai-003Approve : arrêter la sandbox, effectuer la rotation de tous les identifiants qu’elle détenait
5Identifiant de sandbox détournéConstat OpenShell sandbox-authorization-boundaryws-ai-004 (critical)Auto : arrêter la sandbox, mettre le pod en quarantaine, révoquer ses secrets
6Tentatives de jailbreak contre les garde-fousBlocages des rails d’entrée par utilisateurws-ai-006Approve : limiter le débit de l’utilisateur ou le suspendre ; examiner les métadonnées de la conversation
7Régression garak dans la CITaux de réussite des attaques supérieur à 5 % pour une sondews-ai-007 (ES|QL)Auto : faire échouer le point de contrôle du pipeline ; informer le responsable du modèle
8Alerte d’exécution DOCA ArgusArgus ALERT en HIGH ou CRITICALws-ai-008Approve : isoler l’hôte (contrôles Sentry ou BlueField là où ils sont déployés ; sinon cordon et politique réseau)
9Cryptojacking GPUGPU occupé sans pod ni tâche Slurm ; exécutions depuis /tmpGpuBusyWithoutScheduledWork (Prometheus) ; ws-ai-014 (auditd)Approve : vider le nœud et tuer le processus ; préserver d’abord les preuves
10Exfiltration de poids de modèlesTrafic sortant horaire des nœuds d’inférence ou de stockage plus de 3 fois supérieur à la semaine précédenteUnusualEgressFromModelNodes (Prometheus)Approve : bloquer le trafic sortant du nœud ; vérifier les lectures du registre et du coffre
11Connexion anormale, puis approbation d’un accès privilégié pour un agentConnexion SSO OpsAPI hors du Royaume-Uni, approbation dans les 30 minutesws-ai-009 (séquence EQL)Approve : révoquer l’approbation et les sessions ; vérifier auprès de l’utilisateur par un autre canal
12Lecture d’un secret en dehors de la plage convenuewslvault secret.read en dehors de 07:00–19:00 UTCws-ai-010 (ES|QL)Advise : confirmer avec le responsable ; effectuer une rotation si inexpliqué
13Pod privilégié crééAudit Kubernetes, conteneur privilégié dans la spécification d’un podws-ai-011Approve : supprimer le pod ; examiner le RBAC de l’identité qui l’a créé
14Échec de l’attestation de confidential computingRésultat d’attestation failurews-ai-012 (critical)Auto : le service de clés a déjà refusé ; appeler l’astreinte et maintenir le nœud hors du pool
15Force brute en périphérie webBlocages du WAF wslproxy par clientws-ai-013Auto : le WAF bloque déjà ; ajouter à la liste de refus en périphérie après approbation
16Perte de télémétrie de sécuritéPertes OCSF d’OpenShell ; échecs d’export vers le SIEM ; une seule passerelle restanteOpenShellOcsfExportDropping, SiemExportFailing, SecurityGatewayRedundancyLostAppeler le SOC : un angle mort est un incident

Un exemple détaillé en cinq étapes : une instruction cachée dans une page web, OpenShell refusant la connexion, la passerelle et la règle Elastic la détectant, un playbook pré-approuvé arrêtant la sandbox et la mettant en quarantaine, et un analyste examinant l’incident et ajoutant une sonde garak ; en dessous, les trois niveaux d’automatisation.

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 le emptyDir du 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égimeCe qu’il attend, en termes générauxComment cette conception y contribue
UK GDPRSé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égimesUne 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 A8.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 techniquesJournaux 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 EssentialsCinq 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 malveillantsCyber 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 :

  1. 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.
  2. 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.
  3. Les métriques restent à faible cardinalité. Le compteur d’événements a trois étiquettes ayant chacune une poignée de valeurs, plus site et cluster. 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.
  4. 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 @timestamp pris 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 :

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Un pod de test avec un conteneur privilégié est créé : la règle Kubernetes se déclenche et le playbook demande une approbation.
  6. Une passerelle de sécurité est arrêtée : aucun événement perdu, un appel de redondance, rétablissement à son retour.
  7. 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

Sept phases : évaluation, conception, construction, détection, réglage, transfert et exploitation, chacune avec un livrable : carte des menaces et des contrôles, conception signée, pipeline opérationnel, bibliothèque de règles avec tests, budget d’alertes convenu, exercices réussis et rapport mensuel.

  1. É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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. Transfert. Les exercices de la section 16, les runbooks, et la formation des analystes et des ingénieurs plateforme.
  7. 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 validate dans otel/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 rules et testées unitairement avec promtool test rules, Prometheus 3.12.0 ; configuration d’Alertmanager validée avec amtool check-config, Alertmanager 0.34.2. Les noms de métriques DCGM suivent dcgm-exporter 4.9.0 via les règles d’enregistrement ws: de l’article UFM.
  • Kubernetes : la NetworkPolicy de quarantaine a été validée avec kubeconform 0.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.

Partager cet article

Plus dans Technology

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

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

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

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

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

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

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

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

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

Lire la suite