Een praktijkgids voor het beveiligen van AI-datacenters en AI-agents met het cybersecurityportfolio van NVIDIA, en voor het bewaken van dat alles via één OpenTelemetry-pipeline die de tools voedt die securityteams al gebruiken: Elastic Security als SIEM, Dynatrace, Prometheus met Alertmanager, en Grafana. Hij behandelt de dreigingen die specifiek zijn voor GPU-omgevingen en agents, wat elk NVIDIA-product laag voor laag doet (BlueField en DOCA, DOCA Argus, DOCA Vault, Sentry, confidential computing, OpenShell, Nemotron Safety, NeMo Guardrails, garak en Morpheus), de telemetrie die elk product werkelijk uitstuurt, een gevalideerde Collector-configuratie, veertien Elastic-detectieregels die in een live Kibana zijn geladen en op testevents zijn afgegaan, Prometheus-alertregels met unittests, responsplaybooks, compliance-mapping, retentie en kosten, hoge beschikbaarheid, en hoe Workstation het levert.
otelcol-contrib validate 0.165.0 en daarna end-to-end gedraaid: testevents gingen via een echte gateway naar Elasticsearch 9.2.0 en Prometheus 3.12.0. De ingest-pipeline, de indextemplate en de lifecycle policy zijn op die Elasticsearch toegepast, en alle veertien detectieregels zijn aangemaakt via de detection engine van Kibana 9.2.0, succesvol uitgevoerd en hebben de verwachte alerts gegenereerd. De Prometheus-regels doorstonden promtool check rules en promtool test rules; de Alertmanager-configuratie doorstond amtool check-config; het Kubernetes-manifest doorstond kubeconform. We hadden geen Dynatrace, BlueField-4, Sentry, DOCA Vault of confidential-computinghardware in de test, dus die onderdelen zijn beschreven op basis van de openbare documentatie van NVIDIA en Dynatrace, en dat wordt ook vermeld. Sectie 18 noemt elke bron en elk hiaat.Dit artikel bouwt voort op twee eerdere technotes in plaats van ze te vervangen. Het referentieontwerp voor UFM, DCGM en OpenTelemetry beschrijft de Collector-agent op elke node en het gatewaypaar dat we voor operationele telemetrie gebruiken, en het Minerva AIOps-runbook behandelt incidentcorrelatie en remediatie onder change control. Securitytelemetrie volgt hetzelfde agent-en-gatewaypatroon, met één wijziging: ze krijgt een eigen gatewaypaar, dat eigendom is van het securityteam. Onze Big Prometheus- en MoSCoW-standaard blijft van kracht: OpenTelemetry is het telemetriecontract, PromQL is de metricstaal, en elk soort log heeft één primaire opslag.
1. Managementsamenvatting
AI-datacenters zijn aantrekkelijke doelwitten om redenen die voor gewone serverruimtes niet gelden. De hardware is duur en er valt gemakkelijk rekentijd van te stelen. De modelgewichten en trainingsdata zijn vaak het waardevolste intellectuele eigendom dat een bedrijf bezit. En AI-agents handelen nu zelfstandig: ze lezen niet-vertrouwde webpagina's en documenten, roepen tools aan, gebruiken credentials en wijzigen systemen. Eén verborgen instructie in een document kan een behulpzame agent in een insider veranderen.
Het antwoord van NVIDIA is defence in depth over de hele stack. Eenvoudig gezegd:
- De DPU bewaakt de server van buitenaf. BlueField draait securitydiensten in een eigen geïsoleerd domein, zodat malware op de host ze niet kan uitschakelen. DOCA Argus inspecteert het hostgeheugen op runtimedreigingen; Sentry bewaakt agents en kan ze binnen milliseconden in quarantaine plaatsen; DOCA Vault beschermt gevoelige gegevens.
- De GPU beschermt gegevens terwijl ze worden gebruikt. Confidential computing houdt gegevens en modelgewichten versleuteld en geïsoleerd binnen de GPU, en attestatie bewijst dat voordat er iets gevoeligs wordt vrijgegeven.
- Agents draaien in een sandbox met een geschreven policy. OpenShell bepaalt welke bestanden, netwerkbestemmingen, processen en credentials een agent mag gebruiken, dwingt dat af in de kernel en de proxy, en logt elke beslissing in een standaard securityschema.
- Modellen worden gecontroleerd op weg naar binnen en naar buiten. Nemotron Safety-modellen en NeMo Guardrails filteren onveilige prompts en antwoorden; garak valt uw agents aan voordat aanvallers dat doen.
Wat de producten van NVIDIA op zichzelf niet doen, is een security-operationsteam één plek geven om dit allemaal te zien, het te correleren met identiteit, Kubernetes, de webedge en secrets, en te reageren. Daar gaat dit artikel over, en daar komt de observability- en SIEM-praktijk van Workstation in beeld. Het resultaat voor de organisatie is:
- elke securitymaatregel levert bewijs op dat binnen enkele seconden in uw SIEM belandt, in één schema;
- detecties voor de aanvallen die ertoe doen in AI-omgevingen (kaping van agents, modeldiefstal, GPU-misbruik, misbruik van privileges), elk met een geteste respons;
- inperking die alleen automatisch is wanneer dat veilig en omkeerbaar is, en anders goedkeuring door een mens vereist;
- bewijs voor auditors onder UK GDPR, ISO 27001 en NIS-achtige regimes, tegen voorspelbare kosten.
Workstation is een NVIDIA-partner. Wij leveren de hardware, en wij bieden de engineering, software en mensen om dit samen met u te ontwerpen, te bouwen en te beheren, van een eerste assessment tot doorlopende monitoringondersteuning (sectie 17).
2. Het dreigingslandschap voor AI-datacenters en agents
De meeste dreigingen voor een AI-omgeving zijn bekende dreigingen met nieuwe doelwitten. De tabel koppelt elke dreiging aan waar ze zichtbaar wordt, welke maatregel haar voorkomt of beperkt, en welk signaal u vertelt dat ze is opgetreden. Sectie 11 zet elk signaal om in een detectieregel.
| Dreiging | Hoe ze zichtbaar wordt | Preventieve maatregelen | Signaal dat we bewaken |
|---|---|---|---|
| Directe prompt injection en jailbreaks | Gebruikers stellen prompts op om een model zijn instructies te laten negeren of schadelijke output te laten produceren | Input rails van NeMo Guardrails, Nemotron Safety-classifiers, garak-tests in CI | Rail-blokkades per gebruiker; slagingspercentage van garak-aanvallen per probe |
| Indirecte prompt injection en goal hijacking | Instructies verborgen in een webpagina, e-mail of document dat de agent leest, sturen hem naar een nieuw doel, vaak exfiltratie | Netwerk- en bestandspolicy van OpenShell (standaard weigeren), retrieval rails, menselijke goedkeuring voor nieuwe toegang | OpenShell-weigeringen en nieuwe bestemmingen; reeksen weigeringen per sandbox |
| Datalekken | Persoonsgegevens, secrets of broncode in prompts, antwoorden, logs of uploads van agents | Output rails van guardrails en maskering van gevoelige gegevens, egress-policy van OpenShell, injectie van credentials zodat agents nooit echte secrets in handen hebben | Output-rail-blokkades, egress-weigeringen, bevindingen over gevoelige gegevens (Morpheus of rails) |
| Diefstal van modellen en gewichten | Grote overdrachten van checkpoints of gewichten; afwijkende leesacties uit modelregistries | Confidential computing, DOCA Vault, sleutels in wslvault, netwerksegmentatie | Egress-volume vanaf inferentie- en opslagnodes; leesacties op secrets buiten kantooruren; mislukte attestaties |
| Supply chain | Vergiftigde modelbestanden, kwaadaardige packages die door agents zijn geïnstalleerd, gemanipuleerde container-images | Proces- en packagepolicy van OpenShell, image signing en admission control, garak-regressietests | Nieuwe procesuitvoeringen (Argus, auditd), onverwachte image-hashes, garak-regressies |
| Laterale beweging | Een gecompromitteerde agent of pod bereikt de Kubernetes-API, de metadataservice van de cloud of andere tenants | OpenShell blokkeert control-plane-poorten en link-local-adressen; Kubernetes RBAC en network policy; BlueField-isolatie | SSRF-achtige weigeringen, autorisatiebevindingen tussen sandboxes, aanmaak van privileged pods |
| GPU-cryptojacking | Miners gebruiken gestolen GPU-tijd, vaak op idle of slecht ingeplande nodes | Alleen toegang tot GPU's via de scheduler, uitvoeringspolicy, runtimedetectie met DOCA Argus | GPU bezet zonder ingeplande job (DCGM); uitvoeringen vanuit /tmp; Argus-alerts |
| Misbruik door insiders | Een beheerder of gecompromitteerd account leest secrets, verruimt agentrechten of schakelt monitoring uit | Single sign-on met goedkeuringsstappen, least privilege, functiescheiding voor de securitypipeline | Afwijkende aanmelding gevolgd door een geprivilegieerde goedkeuring; leesacties op secrets buiten afgesproken tijden; gaten in de telemetrie |
| Niet-vertrouwde infrastructuur | Een hostingprovider, mede-tenant of operator met hosttoegang probeert gegevens of gewichten in gebruik te lezen | Confidential computing met attestatie voordat sleutels worden vrijgegeven | Mislukte attestaties; workloads gestart zonder geslaagde attestatie |
3. Het cybersecurityportfolio van NVIDIA, laag voor laag
NVIDIA groepeert deze producten op zijn pagina over cybersecurity-AI-oplossingen. Wij vinden het duidelijker om ze te ordenen naar de laag die ze beschermen, omdat dat vertelt waar de telemetrie van elk product vandaan komt en wat het kan zien dat de andere niet kunnen.
3.1 Silicium en DPU: BlueField, DOCA, DOCA Argus, DOCA Vault en Sentry
BlueField is de data processing unit van NVIDIA: een netwerkadapter met eigen Arm-cores, geheugen en besturingssysteem, die tussen de server en het netwerk zit. DOCA is het softwareframework om hem te programmeren. Het securitypunt is scheiding. Diensten op de DPU draaien in een domein dat het besturingssysteem van de host niet beheert, dus een aanvaller met root op de host kan ze nog steeds niet lezen of stoppen.
DOCA Argus gebruikt die positie om de host te bewaken. Volgens NVIDIA's DOCA Argus service guide draait het als container op BlueField-3 of later (in DPU-modus), leest het geselecteerde kernelstructuren uit het hostgeheugen via DMA, en bouwt het een beeld op van processen, binaries met hun hashes, command lines, bestanden, netwerkverbindingen, containers en VM's, en GPU-gebruik per proces, zonder dat er een agent op de host is geïnstalleerd. Op basis daarvan genereert het alerts voor runtimedreigingen zoals reverse shells en onverwachte uitvoeringen. Wat belangrijk is voor de integratie:
- Berichten hebben een
message_typevanEVENT,ALERTofSYSTEM_ACTIVITYen eenseverityvanINFOtotCRITICAL, met payloadsecties zoalsworkload_informationenactivity_data. - Telemetrie-export staat standaard uit. Ze wordt geconfigureerd met
telemetry_address,telemetry_format(JSON of syslog) entelemetry_tag, en de voorbeelden van NVIDIA sturen haar via TCP naar Fluent Bit of Vector. - NVIDIA stelt dat Argus integreert met toonaangevende XDR-platforms voor ondernemingen. Als u er een gebruikt, kan dat de primaire afnemer blijven; onze pipeline ontvangt dan een kopie voor correlatie met al het andere.
Onze gateway ontvangt Argus-JSON rechtstreeks op een TCP-listener (sectie 6). Als uw Argus-release berichten niet met newlines scheidt, zet dan Fluent Bit of Vector ertussen zoals de gids van NVIDIA laat zien en stuur door naar de Collector via OTLP; de rest van het ontwerp blijft ongewijzigd. De gids van NVIDIA toont de berichtvelden in zijn voorbeeld op het hoogste niveau, maar beschrijft in zijn schematabel een message_header-root, dus controleer een echt bericht van uw release voordat u op de veldpaden in onze regel vertrouwt.
DOCA Vault is een security-microservice op BlueField die gevoelige gegevens beschermt met maatregelen in het silicium en zero-trusttoegang. We hebben het niet getest en we beschrijven de interfaces hier niet. In onze ontwerpen staat het naast, niet in plaats van, het sleutelbeheer dat secrets aan workloads vrijgeeft (bij ons wslvault).
NVIDIA Sentry op BlueField is het nieuwste onderdeel. NVIDIA beschrijft het als onderdeel van zijn Open Agent Safety Platform: het draait in het hardwarematig geïsoleerde domein van BlueField-4, onafhankelijk van de host en van de eigen software van de agent, bewaakt het gedrag van agents op afwijkingen van de policy en verdachte activiteit, levert betrouwbare telemetrie, en kan een agent binnen milliseconden in quarantaine plaatsen met de infrastructuurmaatregelen van de DPU. Omdat het out-of-band is, werkt het nog steeds als de host of de agentruntime is gecompromitteerd, en dat is precies wanneer u het nodig hebt. Wij behandelen de alerts en quarantaineacties van Sentry als volwaardige SIEM-events; het exacte exportformaat moet worden overgenomen uit de Sentry-documentatie van NVIDIA voor de release die u uitrolt.
DOCA Telemetry Service exporteert DPU-counters in Prometheus-formaat. Het maakt al deel uit van het UFM-referentieontwerp en hoeft hier niet te veranderen, behalve dat poort- en dropcounters op DPU's vóór agenthosts nuttige context worden bij securityonderzoeken.
3.2 Platform: confidential computing en attestatie
Confidential computing beschermt gegevens en modellen tijdens gebruik. De GPU draait de workload in een hardwarematige trusted execution environment, zodat noch het besturingssysteem van de host, noch de hypervisor, noch de mensen die de infrastructuur beheren het geheugen kunnen lezen, en de GPU kan zijn toestand bewijzen via attestatie. Daarmee is het de maatregel tegen twee dreigingen die niets anders in de tabel goed afdekt: een niet-vertrouwde hostingprovider, en het delen van gegevens of modellen met een partij die u niet volledig vertrouwt.
De operationele regel is eenvoudig: geen geslaagde attestatie, geen sleutels. Een launch-wrapper attesteert de GPU (en de confidential VM) voordat de workload start en vraagt pas daarna de sleuteldienst om de ontsleutelingssleutel voor de dataset of het model. NVIDIA publiceert de attestatietools in nvTrust; de README markeert de Python-attestatie-SDK en de lokale GPU-verifier als deprecated ten gunste van een C++-SDK en CLI, dus plan nieuwe integraties daarop. We loggen elk attestatieresultaat als gestructureerd event (geslaagd of mislukt, welke GPU, welke workload, welke verifier) en alerteren bij elke mislukking.
3.3 Runtime: OpenShell
OpenShell is de open-source (Apache 2.0) runtime van NVIDIA voor autonome agents. Elke agent draait in een sandbox; een policy legt vast welke bestanden hij mag lezen of schrijven, welke netwerkbestemmingen en HTTP-methoden hij mag gebruiken, welke processen hij mag draaien en welke credentials hij mag gebruiken, en OpenShell dwingt dat af in de kernel en in een proxy die de policy controleert. Echte credentials blijven buiten de sandbox: OpenShell injecteert ze in uitgaande verzoeken, en alleen wanneer de bestemming een goedgekeurd endpoint is. Voordat een policywijziging wordt toegepast, markeert een formele verificatiestap nieuwe toegang die menselijke beoordeling nodig heeft. Ons eerdere artikel over OpenShell laat zien hoe u agents eronder draait.
Voor een SIEM is OpenShell de rijkste bron in de stack, omdat het elke securitybeslissing vastlegt in het Open Cybersecurity Schema Framework (OCSF) versie 1.8.0. Uit de observability-documentatie:
- Sandboxsupervisors en de gateway sturen OCSF-events uit voor netwerkactiviteit (klasse 4001), HTTP-activiteit (4002), SSH (4007), procesactiviteit (1007), detectiebevindingen (2004), authenticatie (3002), configuratiewijzigingen (5019), applicatielevenscyclus (6002) en API-activiteit (6003).
- Geweigerde netwerk- en HTTP-events bevatten de reden in
status_detail, bijvoorbeeldno matching policyofresolves to always-blocked address(een link-local- of loopbackbestemming zoals een metadata-endpoint van de cloud). - Wanneer een sandboxcredential een methode of een andere sandbox aanroept die hij nooit zou mogen aanraken, genereert de gateway een detectiebevinding met hoge ernst met
finding_info.uidsandbox-authorization-boundary: de credential is mogelijk gecompromitteerd. - Door
enabled = truein te stellen onder[openshell.gateway.otlp.ocsf]ingateway.tomlworden OCSF-events geëxporteerd als OTLP-logrecords onder de instrumentation scopeopenshell.ocsf. De body is het OCSF-event als JSON; attributen zijn onder meerocsf.class_uid,ocsf.severity_id,ocsf.metadata.uidenopenshell.sandbox.id; supervisors sturen hun eigen events naar hetzelfde endpoint. - Aflevering is at least once, dus dedupliceer op
ocsf.metadata.uid. Records die de gateway laat vallen, worden geteld inopenshell_ocsf_otlp_dropped_total, en de volgende batch bevat een waarschuwingsrecord met de naamopenshell.ocsf.gap. - De gateway serveert Prometheus-metrics op een aparte listener, zonder authenticatie, dus houd die intern; fouten in interceptors die een verzoek doorlaten, worden geteld in
openshell_gateway_interceptor_fail_open_total.
De verkorte logregel voor een geweigerde verbinding ziet er zo uit (uit de documentatie van NVIDIA):
OCSF NET:OPEN [MED] DENIED /usr/bin/curl(64) -> httpbin.org:443 [policy:- engine:opa] [reason:no matching policy]
De OpenShell Reference Architecture van NVIDIA bouwt een volledige stack rond de runtime: Vera-CPU's draaien de agentharnesses en hun tools, Vera Rubin-systemen serveren inferentie, en Sentry op BlueField-4 voegt monitoring en handhaving toe die niet van de host afhangt. NVIDIA zegt expliciet dat OpenShell ook op andere CPU-systemen draait en dat Vera en BlueField optioneel zijn; ze voegen efficiëntie en de out-of-bandlaag toe, geen basisfunctionaliteit. NemoClaw, NVIDIA's verzameling open blueprints voor gespecialiseerde agents op basis van Nemotron-modellen, draait zijn agents binnen OpenShell, dus alles in dit artikel geldt ongewijzigd voor NemoClaw-agents; NemoClaw zelf behandelen we in een apart artikel.
3.4 Modellen en guardrails: Nemotron Safety, NeMo Guardrails en garak
Nemotron is de familie open modellen van NVIDIA; NVIDIA positioneert sommige voor planning en redeneren, sommige voor snelle tool calls in grote volumes, en een reeks Nemotron Safety-modellen die onveilige inhoud in tekst en afbeeldingen classificeren, zodat die kan worden gefilterd op weg naar binnen of naar buiten een agentpipeline. Gespecialiseerd met NeMo kunnen Nemotron-modellen ook de eigen agents van de verdedigers draaien, voor alerttriage, continue threat hunting en red-teamsimulatie.
NeMo Guardrails (laatste release 0.24.1 op het moment van schrijven) plaatst programmeerbare rails tussen een applicatie en haar model: input rails (bijvoorbeeld jailbreakcontroles en maskering van gevoelige gegevens), dialog rails, retrieval rails op RAG-chunks, execution rails op tool-in- en -output, en output rails. Een safety-classifier zoals een Nemotron Safety-model kan achter een rail zitten. Voor monitoring heeft de config.yml een sectie tracing met een OpenTelemetry-adapter; de library gebruikt alleen de OpenTelemetry-API en uw applicatie configureert de SDK en de exporter. Inhoud van prompts en antwoorden wordt niet vastgelegd tenzij u enable_content_capture: true instelt; laat dat in productie uit, omdat prompts vaak persoonsgegevens bevatten.
Spans vertellen u welke rails zijn uitgevoerd en hoe lang ze duurden, wat ideaal is voor Dynatrace. Voor de SIEM willen we daarnaast één event per blokkade, met wie, welke rail en wat er gebeurde, maar zonder inhoud. Dat sturen we uit vanuit een dunne wrapper rond de rails-aanroep, met onze eigen veldconventie (event.action: input_rail_blocked, rule.name ingesteld op de rail-flow, user.id). Die conventie is van Workstation, geen onderdeel van NeMo Guardrails.
garak is de LLM-kwetsbaarheidsscanner van NVIDIA: hij voert probes uit (prompt injection, jailbreaks zoals de DAN-familie, datalekken, coderingstrucs, replay van trainingsdata en meer) tegen een model- of agentendpoint, en beoordeelt de antwoorden met detectors. Elke run schrijft een JSONL-rapport; de evaluatierecords daarin hebben entry_type: "eval" met probe, detector, passed, fails en total_evaluated. We draaien garak in CI bij elke wijziging aan een model, prompt of guardrailconfiguratie en sturen die records naar de SIEM, zodat een regressie een detectie is zoals elke andere.
# 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}
Hier is ci/garak-staging.yaml een garak-configuratiebestand dat de REST-generator de URI en het verzoeksjabloon van uw endpoint geeft (zie de documentatie van garak; er zijn ook generators voor OpenAI-compatibele endpoints, Hugging Face, Bedrock en andere). Huidige garak-releases selecteren probes met --spec; de oudere vlag --probes werkt nog maar is deprecated. Kopieer de resulterende *.report.jsonl naar de map die de Collector van de CI-runner bewaakt.
3.5 Pipelines: Morpheus
Morpheus is het GPU-versnelde framework van NVIDIA voor het bouwen van cybersecurity-inferentiepipelines over grote datastromen. De repository bevat voorbeeldpipelines en voorgetrainde modellen voor digital fingerprinting van gebruikers- en machinegedrag, phishingdetectie, detectie van gevoelige informatie, logparsing, ransomwaredetectie op basis van AppShield-gegevens, fraudedetectie met graph neural networks, data loss prevention en profilering van afwijkend gedrag, waaronder een voorbeeld dat cryptocurrency-mining detecteert op basis van GPU-telemetrie. Controleer de status voordat u erop gaat plannen: op het moment van schrijven is de laatste getagde release 25.06 (juli 2025). Waar een klant al Morpheus-pipelines heeft, zijn de outputs gewoon nog een bron met scores: we sturen de scores en gemarkeerde records als events naar dezelfde gateway.
4. Het referentieontwerp van Workstation voor security-observability
Vijf principes sturen het ontwerp:
- Eén pipeline. Elk securitysignaal komt binnen via een OpenTelemetry Collector. Backends halen nooit rechtstreeks gegevens op bij bronnen, dus een backend toevoegen of vervangen is een wijziging aan de gateway, niet aan de hele vloot.
- Eén keer normaliseren, bij de gateway. Velden worden naar ECS-namen gemapt (en naar OTel semantic conventions waar die bestaan) voordat de gegevens splitsen, zodat een regel in Elastic en een dashboard in Grafana het over hetzelfde
destination.domainhebben. - Redigeren voordat iets vertrekt. Authorization-headers, cookies, API-tokens en prompt- of completiontekst worden bij de gateway verwijderd. Geen enkele backend slaat ze ooit op, dus geen enkele backend hoeft ermee te worden vertrouwd.
- Elke backend doet waar hij het beste in is. Elastic Security bewaart elk securityevent en draait correlatieregels en cases. Dynatrace krijgt de events met hogere ernst, metrics en traces, zodat de AI securityevents aan de gezondheid van diensten kan koppelen. Prometheus krijgt counters met lage cardinaliteit en de GPU- en netwerkmetrics die het al bevat, voor snelle, goedkope alerting. Grafana is het gedeelde scherm.
- De pipeline bewaakt zichzelf. Gedropte records, mislukte exports en verloren gateways zijn securityalerts, geen operationele tickets (sectie 15).
Lagen
- Node-agents zijn dezelfde agents als in het UFM-ontwerp: één Collector per GPU-, opslag-, login- en control-plane-node. We voegen drie receivers toe (auditd, het auditlog van de Kubernetes-API-server, en garak-rapporten op CI-runners) en een tweede exporter die securitylogs naar de securitygateways stuurt in plaats van naar de operationele gateways.
- Een security-gatewaypaar (of meer), achter een virtueel IP-adres of DNS-naam, beheerd door het securityteam. Het ontvangt OTLP van agents, van OpenShell-gateways en -supervisors en van beveiligde applicaties; Argus-JSON via TCP; en syslog via TLS van appliances. Het scrapet de metrics-endpoints van de OpenShell-gateway en van wslproxy. Backendcredentials bestaan alleen hier.
- De operationele gateways blijven ongewijzigd. DCGM-, node- en fabricmetrics stromen nog steeds naar Mimir of Prometheus zoals in het UFM-ontwerp; de cryptojacking- en exfiltratiealerts in sectie 9 draaien daar, omdat de gegevens daar al staan.
Waarom aparte securitygateways? Functiescheiding (het platformteam kan securityevents niet stilletjes wegfilteren), andere regels voor retentie en toegang, en een kleinere blast radius: een slecht werkende dashboardquery of een operationele wijziging kan de securitypipeline niet uithongeren.
Bronnen
| Bron | Wat het ons vertelt | Transport naar de pipeline | Dataset |
|---|---|---|---|
| OpenShell-gateway en -supervisors | Elke toestemming en weigering voor netwerk-, HTTP-, proces-, SSH-, authenticatie- en API-aanroepen; geladen policies; bevindingen | OCSF via OTLP vanuit [openshell.gateway.otlp.ocsf]; gatewaymetrics via scrape | openshell.ocsf |
| DOCA Argus op BlueField | Runtimealerts en activiteit uit analyse van het hostgeheugen | JSON via TCP naar de gateway | doca.argus |
| Sentry op BlueField-4 | Afwijkingen in agentgedrag, quarantaineacties | Volgens de Sentry-documentatie van NVIDIA; we mappen naar hetzelfde datasetpatroon | nvidia.sentry (gepland) |
| Confidential computing | Attestatie geslaagd of mislukt per GPU en workload | Launch-wrapper logt ECS-JSON naar syslog | cc.attestation |
| NeMo Guardrails-applicaties | Rail-blokkades (events) en rail-timings (spans) | OTLP vanuit de applicatie | nemo.guardrails |
| garak in CI | Slagingspercentage van aanvallen per probe en detector | Collector van de runner volgt het JSONL-rapport | garak.eval |
| Kubernetes-API-server | Wie wat heeft aangemaakt, gewijzigd of er een exec in heeft gedaan | Agent op control-plane-nodes volgt het auditlog | kubernetes.audit_logs |
| wslproxy WAF | Elke WAF-beslissing met signature, client en route; Prometheus-counters | wafsec-JSON via syslog; metrics via scrape | wslproxy.waf |
| wslvault | Leesacties, schrijfacties en weigeringen voor secrets per identiteit | ECS-JSON via syslog | wslvault.audit |
| OpsAPI single sign-on | Aanmeldingen, mislukkingen, goedkeuringen van geprivilegieerde agenttoegang | ECS-JSON via syslog | opsapi.sso |
| Linux-hosts | Uitvoeringen, privilegewijzigingen, file watches (auditd) | Agent volgt /var/log/audit/audit.log | auditd.log |
| DCGM en node-exporter | GPU-gebruik zonder job, egress-volume | Bestaande operationele pipeline (Prometheus of Mimir) | metrics |
De lijst met wafsec-velden komt uit ons artikel over WAF Engine v2. Voor wslvault en OpsAPI configureren we de producten om JSON met ECS-namen te loggen (event.action, event.outcome, user.id, source.ip), waardoor de mapping in de gateway triviaal blijft; de actienamen die in de regels van dit artikel worden gebruikt (secret.read, login, agent.approval.granted) zijn onze conventie, dus pas ze aan aan wat uw implementatie uitstuurt.
5. Normalisatie: OCSF, ECS en OpenTelemetry semantic conventions
In deze pipeline komen drie schema's samen. OpenShell spreekt OCSF; de regels, timelines en kant-en-klare content van Elastic Security verwachten ECS; en OpenTelemetry heeft eigen semantic conventions voor resources en attributen. We houden het originele record intact voor forensisch onderzoek en voegen ECS-velden ernaast toe. De gateway doet de mapping die elke backend nodig heeft (zodat Dynatrace dezelfde namen ziet als Elastic), en een Elasticsearch-ingest-pipeline doet de Elastic-specifieke verrijking.
| OCSF-veld (OpenShell) | ECS-veld | Waar het wordt gemapt |
|---|---|---|
action (Allowed, Denied) | event.action | Gateway |
status_id (1 geslaagd, 2 mislukt) | event.outcome | Gateway |
status_detail, of finding_info.uid voor bevindingen | event.reason | Ingest-pipeline |
class_uid | event.category (network, process, authentication, api, configuration, intrusion_detection) | Ingest-pipeline |
type_uid, severity_id, metadata.uid | event.code, event.severity, event.id | Ingest-pipeline |
dst_endpoint.domain, .ip, .port | destination.domain, destination.ip, destination.port | Gateway (domein, poort), ingest-pipeline (ip) |
src_endpoint.ip | source.ip | Ingest-pipeline |
actor.process.name, .pid, .cmd_line | process.executable, process.pid, process.command_line | Gateway, ingest-pipeline |
actor.user.uid | user.id | Ingest-pipeline |
device.container.name, .uid (de sandbox) | container.name, container.id | Gateway, ingest-pipeline |
firewall_rule.name (de policy die overeenkwam) | rule.name | Gateway |
metadata.product.name, .version | observer.product, observer.version | Ingest-pipeline |
time (epoch in milliseconden) | @timestamp | Ingest-pipeline |
| volledig record | event.original (niet geïndexeerd) en ocsf.* (flattened) | Ingest-pipeline |
De documentatie van OpenShell vermeldt dat de sandboxidentiteit in OCSF 1.8.0-records is verhuisd van een container-object op het hoogste niveau naar device.container, en waarschuwt SIEM-parsers om dat te volgen. Onze mapping leest alleen de nieuwe locatie, dus pin de OpenShell-versie in uw changerecords en test de mapping opnieuw bij een upgrade.
6. Collector-configuratie
Alle onderstaande configuratie gebruikt componentnamen uit otelcol-contrib 0.165.0, waarin snake_case-namen zijn geïntroduceerd (file_log, tcp_log, otlp_grpc, otlp_http, prometheus_remote_write, cumulative_to_delta, delta_to_cumulative, resource_detection). De oudere namen in onze UFM- en Minerva-artikelen werken nog als deprecated aliassen en loggen bij het opstarten een waarschuwing. Secrets zijn omgevingsplaceholders.
Node-agent: securityreceivers
Deze pipelines worden aan de bestaande node-agent toegevoegd. Op een node die geen control plane of CI-runner is, staan de receivers voor bestanden die niet bestaan gewoon stil.
# /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]
Opmerkingen:
- De auditd-parser splitst de recordheader van de key-valueparen. Hij decodeert geen hex-gecodeerde velden zoals
proctitle; als u die nodig hebt, decodeer ze dan in de ingest-pipeline. Schakel de auditregels in die u wilt (bijvoorbeeldexecveop GPU-nodes) in uw auditd-configuratie; de Collector verstuurt alleen wat auditd schrijft. - De Kubernetes-auditreceiver ziet alleen wat de auditpolicy van uw API-server vastlegt. Om privileged pods te detecteren hebt u minstens niveau
RequestResponse, of niveauRequest, nodig voor create, update en patch vanpods, zodat de request body in het log staat. - De garak-receiver bewaart alleen evaluatierecords en labelt ze met de CI-pipeline, zodat een regressie wijst naar de wijziging die haar heeft veroorzaakt.
Securitygateway
# /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
Toelichting bij de keuzes:
- Document-ID uit de OCSF-event-ID. OpenShell levert at least once af. Door
elasticsearch.document_idin te stellen vanuitocsf.metadata.uidmetlogs_dynamic_idingeschakeld, wordt een opnieuw verstuurd record een no-op: in onze end-to-endtest werd de tweede kopie door Elasticsearch geweigerd met een versieconflict en werd er maar één document opgeslagen. - Dynamische ingest-pipeline. Het attribuut
elasticsearch.ingest_pipelineselecteert de OCSF-pipeline alleen voor OpenShell-records; andere datasets gebruiken de standaardinstellingen van de data stream. - Routering op ernst. De routing connector kopieert records met OTel-ernst
WARN2en hoger (OpenShell mapt OCSF Medium naarWARN2, High naarERROR) naar Dynatrace, terwijl elk record naar Elasticsearch gaat. Zo blijven de volumes en kosten van Dynatrace in verhouding. - Events tellen als metrics. De count connector stuurt
ws.security.eventsuit met slechts drie attributen: dataset, outcome en action. Hij stuurt delta-sommen uit, wat Dynatrace wil en Prometheus remote write niet, dus het Prometheus-pad converteert metdelta_to_cumulative. In onze test ontving Prometheusws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied", event_outcome="failure"}met de labelssiteencluster. - Cumulative naar delta voor Dynatrace. De OTLP-ingest van Dynatrace vereist delta-temporaliteit voor metrics, dus gescrapete metrics gaan alleen op het Dynatrace-pad door
cumulative_to_delta. - Constante labels.
resource_constant_labelsmaakt alleen vansiteenclusterPrometheus-labels. Sandbox-ID's, podnamen en domeinen worden nooit labels (sectie 14). - Batching. De Elasticsearch-exporter batcht intern, dus zijn pipeline heeft geen
batch-processor; anders waarschuwt de Collector voor dubbele batching.
OpenShell-kant
Richt op de OpenShell-gateway de OCSF-export op de securitygateways. Het voorbeeld van NVIDIA gebruikt een servicenaam binnen het cluster; de onze is het adres van de securitygateway. Supervisors gebruiken hetzelfde endpoint, dus het moet vanuit sandboxes bereikbaar zijn, en zij ontvangen de exportheaders van de gateway samen met hun launchcredentials in plaats van via de sandboxomgeving.
[openshell.gateway.otlp.ocsf]
enabled = true
endpoint = "https://otel-security.sec.internal:4317"
Houd de beslissing over de eigen anonieme producttelemetrie van OpenShell gescheiden: die staat los van deze export en wordt geregeld met OPENSHELL_TELEMETRY_ENABLED of de Helm-waarde server.telemetryEnabled.
7. Elastic Security als SIEM
Elastic Security bewaart elk securityevent, draait de detectieregels en is de plek waar analisten onderzoek doen (timelines) en werk bijhouden (cases). We draaien het als een apart securitycluster of een aparte space met eigen rollen, gescheiden van het operationeel doorzoeken van logs.
Ingest-pipeline: OCSF naar ECS
Deze pipeline is in Elasticsearch 9.2.0 geladen en getest zowel met _simulate als met records die via de gateway binnenkwamen.
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}}}"] } }
]
}
Indextemplate en retentie
Het object ocsf is gemapt als flattened, zodat de vele optionele velden van OCSF geen mapping explosion kunnen veroorzaken, terwijl analisten er toch op kunnen filteren. Het originele record wordt opgeslagen maar niet geïndexeerd. De template combineert de ingebouwde logs@mappings, logs@settings en ecs@mappings van Elastic.
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 } } }
}
}
}
}
We maken per securitydataset één template met dezelfde vorm en een lifecycle policy die past bij de retentie-eis (sectie 14). Dertien maanden is een gangbare standaard voor securityevents, omdat dat een volledig jaar vergelijking dekt plus de tijd om een laat ontdekt incident te onderzoeken; uw juridische en compliance-eigenaren bepalen het werkelijke cijfer.
Detectieregels
Veertien regels, aangemaakt via de detection-engine-API van Kibana (POST /api/detection_engine/rules, API-versie 2023-10-31). Elke regel is succesvol uitgevoerd op testdata, en elke regel behalve de vaultregel voor buiten kantooruren (waarvan het testevent binnen de uren viel) genereerde de verwachte alert. De tabel noemt ze allemaal; twee worden erna volledig getoond.
| Regel | Type | Ernst |
|---|---|---|
Egress van AI-agent geweigerd door OpenShell-policyws-ai-001-agent-egress-denied | KQL-query | medium |
AI-agent bereikte een domein dat in 14 dagen niet is gezienws-ai-002-agent-new-egress-domain | New terms (KQL) | low |
AI-agent probeerde een link-local- of loopbackadres te bereikenws-ai-003-agent-ssrf-blocked | KQL-query | high |
OpenShell-sandboxcredential gebruikt buiten zijn grensws-ai-004-sandbox-boundary-finding | KQL-query | critical |
Reeks OpenShell-policyweigeringen vanuit één sandboxws-ai-005-policy-denial-spike | Threshold (KQL) | high |
Herhaalde jailbreakpogingen geblokkeerd door NeMo Guardrailsws-ai-006-guardrail-jailbreak-attempts | Threshold (KQL) | medium |
Slagingspercentage van garak-aanvallen boven 5% in CIws-ai-007-garak-regression | ES|QL | high |
DOCA Argus-runtimealert op een GPU-hostws-ai-008-doca-argus-alert | KQL-query | critical |
Aanmelding van buiten het VK gevolgd door een agentgoedkeuringws-ai-009-sso-anomaly-then-agent-approval | EQL-sequence | high |
Leesactie op wslvault-secret buiten 07:00 tot 19:00 UTCws-ai-010-vault-read-out-of-hours | ES|QL | medium |
Privileged pod aangemaakt of gewijzigd in Kubernetesws-ai-011-k8s-privileged-pod | KQL-query | high |
Attestatie voor confidential computing misluktws-ai-012-attestation-failure | KQL-query | critical |
wslproxy WAF blokkeert één client herhaaldelijkws-ai-013-waf-block-burst | Threshold (KQL) | medium |
Programma uitgevoerd vanuit /tmp of /dev/shm op een GPU-nodews-ai-014-exec-from-tmp | KQL-query | high |
De queries, zoals geladen:
# 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/*)
Een queryregel met alert suppression en een ATT&CK-mapping. Suppression groepeert herhaalde weigeringen voor dezelfde sandbox en bestemming tot één alert per uur, en dat houdt deze regel bruikbaar op een druk cluster:
{
"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/"
}
]
}
]
}
Een EQL-sequence die twee bronnen correleert die een analist anders met de hand zou moeten koppelen: een aanmelding van buiten het VK, binnen 30 minuten gevolgd door dezelfde gebruiker die geprivilegieerde agenttoegang goedkeurt:
{
"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"
]
}
Drie praktische punten over regels:
- ES|QL-regels hebben metadata nodig voor deduplicatie. Niet-aggregerende ES|QL-regels moeten
METADATA _id, _index, _versionselecteren en die velden behouden, zoals de onze doen, zodat de engine dubbele alerts kan voorkomen. - Gebruik ook de kant-en-klare regels van Elastic. Elastic levert honderden kant-en-klare regels voor Linux, Kubernetes, cloud en identiteit. De onze vullen de AI-specifieke gaten. Waar een kant-en-klare regel hetzelfde terrein afdekt met een andere gegevensbron (bijvoorbeeld de eigen Kubernetes-auditintegratie van Elastic), gebruik dan de ene of de andere, niet beide.
- Regels zijn code. We bewaren ze in Git, laden ze in CI en testen elke regel met een samengesteld event, precies zoals bij de validatie in dit artikel. Een regel zonder test is een gok.
Timelines en cases
Elke alert opent in een timeline. Voor agentincidenten slaan we een timelinetemplate op, gefilterd op container.name (de sandbox), die de OpenShell-events van de sandbox ophaalt, de guardrail-events en garak-resultaten voor dezelfde applicatie, en de Argus-alerts voor de host waarop hij draaide, zodat een analist de laatste acties van de agent op volgorde ziet. Cases verzamelen alerts, timelines, notities en responsacties; we koppelen ze via de case connectors van Elastic aan ServiceNow, zodat het ticket en de case gelijk oplopen, en de responsdienst (sectie 12) schrijft elke geautomatiseerde actie als commentaar terug naar de case.
8. Dynatrace
Veel ondernemingen gebruiken Dynatrace voor applicatie- en infrastructuurmonitoring. Door het de securitysignalen te sturen die voor service owners belangrijk zijn, verschijnt een geweigerde egress of een piek in guardrail-blokkades naast de dienst die erdoor wordt geraakt, en kan Davis, de AI-engine van Dynatrace, dat relateren aan veranderingen in het gedrag van die dienst.
- Endpoint. Volgens de OTLP-API-documentatie van Dynatrace is de basis-URL voor SaaS
https://{your-environment-id}.live.dynatrace.com/api/v2/otlp(of een ActiveGate-adres), en voegt de exporter/v1/traces,/v1/metricsen/v1/logstoe. De eigen metrics van onze test-Collector bevestigden dat hij naar/api/v2/otlp/v1/logspostte. - Protocol. Alleen OTLP via HTTP met binaire protobuf: geen gRPC en geen JSON. Vandaar
otlp_httpin de gateway. - Authenticatie. Een Dynatrace-platformtoken in een
Authorization: Bearer-header, met de scopesopenpipeline:logs:ingest,openpipeline:metrics:ingestenopenpipeline:traces:ingest. Oudere omgevingen met klassieke access tokens moeten de documentatie van Dynatrace voor hun tokentype volgen. - Metric-temporaliteit. Alleen delta, zoals hierboven vermeld.
Wat we sturen: OpenShell- en andere events met ernst Medium en hoger, de ws.security.events-counters, de gescrapete OpenShell- en WAF-metrics, en guardrail-traces (met content capture uit). Wat we in Dynatrace doen, volgens de documentatie en niet volgens een API die we hier verzinnen: anomaliedetectie instellen op de securitycounters, zodat Davis hun normale niveau per cluster leert en bij een aanhoudende verandering een problem aanmaakt; de securityevents toevoegen aan de dashboards en notebooks die service owners al gebruiken; en, waar de Dynatrace-licentie van de klant de securityfuncties omvat, de records met hoge ernst via OpenPipeline naar de security-eventopslag van Dynatrace routeren, zodat ze samen met kwetsbaarheidsbevindingen kunnen worden geanalyseerd. We hebben de routeringsregels van OpenPipeline voor dit artikel niet in een live tenant geverifieerd, dus we beschrijven die stap zonder configuratie.
Dynatrace is een second opinion en een weergave voor service owners, geen tweede SIEM. Detectie, onderzoek en cases blijven in Elastic Security, zodat er één plek is waar een incident eigenaarschap heeft.
9. Prometheus en Alertmanager
Prometheus is de snelste en goedkoopste plek om op getallen te alerteren. Drie securityscenario's zijn van nature numeriek, en de gegevens voor twee ervan (GPU-gebruik uit DCGM en netwerkbytes uit node-exporter) staan al in de operationele metricsopslag uit het UFM-ontwerp. Het derde gebruikt de eventcounters die de securitygateway produceert. De tweede groep regels bewaakt de securitypipeline zelf.
# /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 }}"
Opmerkingen:
ws:gpu_util:ratiois de recording rule uit het UFM-artikel die de oude en nieuwe metricnamen van dcgm-exporter overbrugt. De cryptojackingregel vertrouwt erop dat dcgm-exporterpod(Kubernetes) ofhpc_job(Slurm) koppelt aan GPU's die in gebruik zijn. Als job-mapping niet is ingeschakeld, matcht elke bezette GPU, dus controleer dat eerst.node_roleis het label dat de UFM-agent instelt vanuitWS_NODE_ROLE; gebruik het rollabel dat uw vloot heeft.- De eigen metricnamen van de Collector verloren hun
_total-suffix in de 0.165.0-build die we testten (otelcol_exporter_send_failed_log_records), dusSiemExportFailingmatcht beide schrijfwijzen. - Regels die vergelijken met vorige week of gisteren hebben zoveel historie nodig voordat ze iets betekenen. Laat ze de eerste twee weken in een route draaien die niet paget.
Unittests voor de twee regels die het vaakst zullen worden aangepast, uitgevoerd met 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 stuurt securityalerts met ernst high en critical naar PagerDuty en naar de responsdienst, en al het andere naar tickets. Secrets komen uit bestanden, nooit inline:
# /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 heeft geen native ServiceNow-receiver; de webhook gaat naar een kleine bridge of naar de eigen eventintegratie van ServiceNow, afhankelijk van wat de klant gebruikt.
10. Grafana SOC-dashboards
Grafana is het gedeelde scherm voor het SOC, het platformteam en de AI-teams, met Prometheus en Elasticsearch als gegevensbronnen (en Loki alleen als een klant Grafana-native logzoekfuncties wil voor niet-securitylogs; securityevents blijven in Elasticsearch). Eén overzichtsdashboard, met drill-downs:
| Paneel | Type | Query (gegevensbron) |
|---|---|---|
| Securityevents per minuut per dataset en outcome | Gestapelde tijdreeks | sum by (data_stream_dataset, event_outcome) (rate(ws_security_events_total[5m])) * 60 (Prometheus) |
| Agentweigeringen nu versus gisteren | Tijdreeks met offset | sum(rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[5m])) en hetzelfde met offset 1d |
| Meest geweigerde bestemmingen | Bar gauge | Terms-aggregatie op destination.domain waar event.action:Denied (Elasticsearch) |
| Sandboxes met de meeste weigeringen | Tabel | Terms op container.name, afgelopen uur (Elasticsearch) |
| Openstaande securityalerts per ernst | Stat | ALERTS{team="soc", alertstate="firing"} geteld per severity (Prometheus); Elastic-alerttellingen uit de index .alerts-security.alerts-* |
| Bezette GPU's zonder job | Tabel | ws:gpu_util:ratio{pod="", hpc_job=""} > 0.3 (Prometheus) |
| Egress vanaf model- en opslagnodes | Tijdreeks | sum by (instance) (rate(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[5m])) |
| Slagingspercentage van garak-aanvallen per probe | Heatmap | garak.fails / garak.total_evaluated per garak.probe over CI-runs (Elasticsearch) |
| Guardrail-blokkades per rail | Tijdreeks | Telling per rule.name in nemo.guardrails (Elasticsearch) |
| WAF-blokkades en -fouten | Tijdreeks | sum by (host) (rate(waf_blocked[5m])) en waf_errors |
| Gezondheid van de pipeline | Stat-rij | Gateways up, exportfouten, OpenShell-OCSF-drops, vulling van wachtrijen |
Dashboards worden net als de regels vanuit Git geprovisioned. We geven elk paneel een beschrijving die zegt hoe normaal eruitziet en welke regel of welk runbook van toepassing is, zodat een nieuwe analist het scherm vanaf dag één kan gebruiken.
11. Detectiescenario's
Elk scenario koppelt een signaal aan een regel en een geplande respons. Responsniveaus worden uitgelegd in sectie 12: auto betekent een vooraf goedgekeurde, omkeerbare actie; approve betekent één klik door een benoemde goedkeurder; advise betekent dat de case een aanbeveling doet en mensen handelen.
| # | Scenario | Signaal | Regel | Respons |
|---|---|---|---|---|
| 1 | Agent-egress naar een niet-goedgekeurd domein | OpenShell-netwerkweigering | ws-ai-001 (Elastic, onderdrukt per sandbox en domein) | Advise: beoordeel de bron die de agent las; bij bevestigde injectie de stop van de sandbox goedkeuren |
| 2 | Agent bereikt een domein dat nog nooit is gezien | OpenShell-netwerktoestemming | ws-ai-002 (new terms, historie van 14 dagen) | Advise: bevestig de bestemming; scherp een te ruime policyregel aan |
| 3 | Piek in policyweigeringen | Weigeringen per sandbox; clusterbreed tempo | ws-ai-005 (threshold); AgentPolicyDenialSurge (Prometheus) | Auto: stop de sandbox als dit samengaat met een bevinding; anders approve |
| 4 | Poging tot SSRF of toegang tot metadata | Weigering met resolves to always-blocked address | ws-ai-003 | Approve: stop de sandbox, roteer alle credentials die hij had |
| 5 | Misbruik van sandboxcredential | OpenShell-bevinding sandbox-authorization-boundary | ws-ai-004 (critical) | Auto: stop de sandbox, plaats de pod in quarantaine, trek zijn secrets in |
| 6 | Jailbreakpogingen bij guardrails | Input-rail-blokkades per gebruiker | ws-ai-006 | Approve: beperk het tempo van de gebruiker of schort hem op; beoordeel de metadata van het gesprek |
| 7 | garak-regressie in CI | Slagingspercentage van aanvallen boven 5% voor een probe | ws-ai-007 (ES|QL) | Auto: laat de pipeline-gate falen; informeer de modeleigenaar |
| 8 | DOCA Argus-runtimealert | Argus-ALERT op HIGH of CRITICAL | ws-ai-008 | Approve: isoleer de host (Sentry- of BlueField-maatregelen waar uitgerold; anders cordon en network policy) |
| 9 | GPU-cryptojacking | GPU bezet zonder pod of Slurm-job; uitvoeringen vanuit /tmp | GpuBusyWithoutScheduledWork (Prometheus); ws-ai-014 (auditd) | Approve: drain de node en beëindig het proces; bewaar eerst het bewijs |
| 10 | Exfiltratie van modelgewichten | Egress per uur vanaf inferentie- of opslagnodes meer dan 3x vorige week | UnusualEgressFromModelNodes (Prometheus) | Approve: blokkeer egress voor de node; controleer leesacties in registry en vault |
| 11 | Afwijkende aanmelding, daarna geprivilegieerde agentgoedkeuring | OpsAPI SSO-aanmelding buiten het VK, goedkeuring binnen 30 minuten | ws-ai-009 (EQL-sequence) | Approve: trek de goedkeuring en sessies in; verifieer out-of-band bij de gebruiker |
| 12 | Leesactie op secret buiten het afgesproken venster | wslvault-secret.read buiten 07:00 tot 19:00 UTC | ws-ai-010 (ES|QL) | Advise: bevestig bij de eigenaar; roteer als het onverklaard blijft |
| 13 | Privileged pod aangemaakt | Kubernetes-audit, privileged container in een podspecificatie | ws-ai-011 | Approve: verwijder de pod; beoordeel de RBAC van de identiteit die hem aanmaakte |
| 14 | Mislukte attestatie voor confidential computing | Attestatieresultaat failure | ws-ai-012 (critical) | Auto: de sleuteldienst heeft al geweigerd; page, en houd de node buiten de pool |
| 15 | Brute force aan de webedge | wslproxy WAF-blokkades per client | ws-ai-013 | Auto: de WAF blokkeert al; na goedkeuring toevoegen aan de denylijst van de edge |
| 16 | Securitytelemetrie verloren | OpenShell-OCSF-drops; SIEM-exportfouten; nog maar één gateway over | OpenShellOcsfExportDropping, SiemExportFailing, SecurityGatewayRedundancyLost | Page het SOC: een blinde vlek is een incident |
12. Respons en SOAR
Detectie zonder respons is een rapport. We koppelen responsen aan alerts via een kleine responsdienst (het webhookdoel in Alertmanager, en een Elastic-connector voor detectieregels) die de case opent of bijwerkt, het responsniveau voor de regel controleert, en vervolgens een playbook uitvoert, om goedkeuring vraagt of alleen een aanbeveling vastlegt.
Inperkingsopties, van smalst naar breedst
- De sandbox stoppen (OpenShell).
openshell sandbox stop <name>stopt een agent en bewaart de sandbox voor onderzoek;openshell sandbox delete <name>verwijdert hem zodra het bewijs is verzameld. Om één recht in te trekken in plaats van de agent te stoppen:openshell policy update <name> --remove-rule <rule> --wait. Verzamel de OCSF-bestanden van de supervisor vóór verwijdering: op Kubernetes staan ze in deemptyDirvan de supervisorpod en verdwijnen ze daarmee. - De pod in quarantaine plaatsen (Kubernetes). Een NetworkPolicy voor de hele namespace isoleert elke pod met een quarantainelabel; het playbook voegt alleen het label toe, wat snel, omkeerbaar en gemakkelijk te auditen is. Uw CNI moet NetworkPolicy afdwingen, zoals ook de eigen Kubernetes-richtlijnen van OpenShell vereisen.
- Secrets intrekken. Trek de leases van de agentidentiteit in bij de sleuteldienst, zodat alles wat hij heeft geëxfiltreerd niet meer werkt. Met wslvault had de agent sowieso nooit langlevende sleutels, wat beperkt wat er in te trekken valt.
- De host isoleren (BlueField en Sentry). Waar Sentry op BlueField-4 is uitgerold, plaatst het ontwerp van NVIDIA een agent binnen milliseconden in quarantaine bij de DPU, onafhankelijk van de host. Waar dat niet zo is, is de terugvaloptie om de node te cordonen en te drainen en een netwerkblokkade op hostniveau toe te passen. We sturen acties aan de DPU-kant alleen aan via de interfaces die NVIDIA voor de uitgerolde release documenteert; ongedocumenteerde interfaces scripten we niet.
- Escaleren naar het XDR-platform. Waar DOCA Argus de XDR van een klant voedt, blijven de eigen responsacties van dat platform beschikbaar en legt de case vast welke tool heeft gehandeld.
# 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
Goedkeuringsstappen via OpsAPI single sign-on
Elke respons die niet vooraf is goedgekeurd, gaat door een goedkeuringsstap in OpsAPI: de goedkeurder meldt zich aan met single sign-on (en multifactorauthenticatie), ziet de samenvatting van de case, en keurt goed of af. De goedkeuring is zelf een securityevent (opsapi.sso, agent.approval.granted en verwante events), en daarom kan scenario 11 letten op een verdachte aanmelding gevolgd door een goedkeuring. We configureren het zo dat goedkeurders hun eigen verzoeken niet kunnen goedkeuren, en wijzigingen aan de eigen configuratie van de securitypipeline twee personen vereisen. Hetzelfde patroon wordt voor agentrechten beschreven in ons artikel over de beveiliging van agentic AI.
ServiceNow en PagerDuty
Alerts met ernst high en critical pagen via PagerDuty; alles opent of werkt een ServiceNow-incident bij (of een security incident, als de klant die module gebruikt), gekoppeld aan de Elastic-case. De afhandeling stroomt terug: wanneer de case sluit, wordt het incident opgelost en verdwijnt de PagerDuty-alert. We spreken het automatiseringsniveau voor elke regel schriftelijk met de klant af, beoordelen het elk kwartaal, en promoveren een playbook pas naar auto na een schone staat van dienst op approve.
13. Compliance-mapping
Monitoring is hoe u laat zien dat maatregelen werken. De onderstaande mapping is algemene richtlijn, geen juridisch advies; uw functionaris voor gegevensbescherming en compliance-eigenaren nemen de uiteindelijke beslissingen.
| Regime | Wat het in algemene termen verwacht | Hoe dit ontwerp helpt |
|---|---|---|
| UK GDPR | Passende beveiliging van de verwerking (artikel 32), integriteit en vertrouwelijkheid (artikel 5, lid 1, onder f), gegevensbescherming door ontwerp (artikel 25), melding van inbreuken in verband met persoonsgegevens aan de ICO zonder onredelijke vertraging en, waar mogelijk, binnen 72 uur (artikel 33), en effectbeoordelingen voor verwerkingen met een hoog risico (artikel 35) | Detecties en timelines leveren de feiten die een beoordeling van een inbreuk binnen de termijn nodig heeft; redactie bij de gateway en uitgeschakelde content capture houden persoonsgegevens in logs tot een minimum beperkt; retentie wordt per dataset ingesteld en gedocumenteerd. Securitylogs bevatten zelf persoonsgegevens (gebruikers-ID's, IP-adressen), dus leg de rechtsgrond vast (meestal gerechtvaardigd belang), beperk de toegang, en neem de SIEM op in uw DPIA |
| NIS-achtige verplichtingen (de Britse NIS Regulations, de EU-NIS2-richtlijn voor activiteiten in de EU, en voorgestelde Britse hervormingen) | Risicobeheersmaatregelen, incidentafhandeling, bedrijfscontinuïteit, beveiliging van de toeleveringsketen, en tijdige melding van significante incidenten aan de bevoegde autoriteit; datacenter- en clouddiensten vallen in sommige regimes binnen het toepassingsgebied | Een gedocumenteerd detectie- en responsvermogen met bewijs van werking; signalen uit de toeleveringsketen (garak in CI, image- en packagepolicy); meldingstermijnen ondersteund door caserecords. Of een bepaalde organisatie binnen het toepassingsgebied valt, is een juridische vraag |
| ISO/IEC 27001:2022 Annex A | 8.15 Logging, 8.16 Monitoringactiviteiten, 8.17 Kloksynchronisatie, 5.24 tot 5.28 incidentbeheer inclusief het verzamelen van bewijs, 8.12 Voorkomen van datalekken, 8.8 Beheer van technische kwetsbaarheden | Centrale, beschermde, bewaarde logs (8.15); regels en dashboards met eigenaren (8.16); NTP-gesynchroniseerde tijdstempels uit het bronevent (8.17); cases, timelines en bewaarde originelen (5.24 tot 5.28); egress- en output-rail-maatregelen (8.12); garak- en imagecontroles als kwetsbaarheidsbeheer voor AI (8.8) |
| Cyber Essentials | Vijf technische maatregelen: firewalls, veilige configuratie, beheer van beveiligingsupdates, toegangsbeheer voor gebruikers en bescherming tegen malware | Cyber Essentials is een basisniveau en vereist geen SIEM, maar dezelfde telemetrie laat zien dat de maatregelen werken: WAF- en egress-policy (firewalls), detecties van privileged pods en configuratiewijzigingen (veilige configuratie), SSO- en goedkeuringslogs (toegangsbeheer), en Argus- en auditd-detecties (bescherming tegen malware) |
14. Retentie, kosten en cardinaliteit
Securitytelemetrie groeit ongemerkt tot de rekening komt. Vier regels houden het voorspelbaar:
- Bewaar per dataset, niet globaal. Een typisch uitgangspunt: OpenShell, SSO, vault, Kubernetes-audit, attestatie en Argus 13 maanden; WAF-beslissingen 90 dagen in Elasticsearch met een langer archief indien nodig; garak-evaluatierecords gedurende de levensduur van het model; toegestane (niet geweigerde) OpenShell-netwerkevents 30 tot 90 dagen, omdat ze vooral nuttig zijn voor baselines. Oudere gegevens kunnen naar searchable snapshots of objectopslag als de Elastic-licentie dat toestaat.
- Dimensioneer op basis van events per agent. Als uitgewerkt voorbeeld, geen meting: 200 agents die gemiddeld 2.000 OCSF-events per uur produceren van ongeveer 1,2 KB elk, is ruwweg 11,5 GB per dag vóór replica's en compressie. Toegestane netwerkevents domineren; weigeringen en bevindingen zijn een klein deel. Meet uw eigen tempo in een pilot voordat u dimensioneert.
- Metrics blijven laag in cardinaliteit. De eventcounter heeft drie labels met elk een handvol waarden, plus
siteencluster. Sandbox-ID's, podnamen, gebruikers-ID's en domeinen zijn onbegrensd en horen in Elasticsearch, nooit in Prometheus-labels. Eén verkeerd gekozen label (een sandbox-ID op een druk cluster) kan duizenden nieuwe series per dag toevoegen. - Stuur elke backend alleen wat hij gebruikt. Elk event gaat één keer naar Elasticsearch; Dynatrace krijgt Medium en hoger; Prometheus krijgt tellingen. Traces blijven gesampled in de applicatie. Alles naar elke tool dupliceren is de meest voorkomende kostenfout die we zien.
15. Hoge beschikbaarheid van de securitypipeline
Een aanvaller die de SIEM blind kan maken, heeft de strijd al half gewonnen, dus de pipeline is gebouwd om bij storingen te blijven werken en alarm te slaan wanneer dat niet lukt.
- Gateways: minstens twee per locatie achter een load balancer of DNS-naam, stateless op hun persistente wachtrijen op lokale schijf na. Agents en OpenShell proberen opnieuw bij de gateway die antwoordt; een herstart van een gateway verliest niets wat in de wachtrij staat.
- End-to-end at least once: persistente verzendwachtrijen op agents en gateways, de eigen retries van OpenShell, en document-ID's uit event-ID's, zodat retries nooit duplicaten opleveren.
- Elasticsearch: minstens drie master-eligible nodes verspreid over failure domains, één replica voor elke securityindex, snapshots naar een aparte opslag, en een schrijfrol voor de gateways die geen gegevens kan verwijderen.
- Prometheus en Alertmanager: twee Prometheus-replica's (gededupliceerd in Mimir, zoals in het UFM-ontwerp) en een Alertmanager-cluster met drie nodes.
- Zelfmonitoring: de regels voor de gezondheid van de pipeline in sectie 9, plus een heartbeat: een synthetische OpenShell-weigering die elke vijf minuten in een canary-sandbox wordt gegenereerd, moet in Elasticsearch aankomen, anders paget een regel. Gap-records van OpenShell (
openshell.ocsf.gap) zijn ook doorzoekbare events. - Functiescheiding: het securityteam is eigenaar van de gatewayconfiguratie en de SIEM; wijzigingen worden door twee personen beoordeeld; het platformteam kan de gezondheid van de pipeline zien maar niet wijzigen wat er wordt verzameld.
- Klokken: elke bron en gateway gesynchroniseerd met dezelfde tijdbronnen, en
@timestampovergenomen uit het bronevent, niet uit het ingesttijdstip, zodat sequences over bronnen heen op elkaar aansluiten.
16. Bewijzen dat het werkt: oefeningen bij de overdracht
We dragen geen detectie over die we niet hebben zien afgaan. Terwijl het team van de klant meekijkt, voeren we het volgende uit en leggen het vast:
- Een agent in een testsandbox leest een pagina met een geplante instructie en probeert te uploaden naar een pastesite: één OpenShell-weigering, één onderdrukte Elastic-alert, een timeline die de leesactie en de poging toont.
- Een testsandbox roept de API van een andere sandbox aan met zijn eigen credential: een kritieke bevinding, de automatische stop, het quarantainelabel toegepast, de case bijgewerkt met elke actie.
- Een bekend slechte probe wordt aan een CI-branch toegevoegd: het slagingspercentage van garak-aanvallen overschrijdt 5% en de pipeline-gate faalt.
- Een benchmarkjob draait op een GPU zonder gekoppelde schedulerjob: de cryptojackingalert gaat af binnen zijn venster van 15 minuten.
- Er wordt een testpod met een privileged container aangemaakt: de Kubernetes-regel gaat af en het playbook vraagt om goedkeuring.
- Eén securitygateway wordt gestopt: geen verloren events, een redundantiepage, herstel wanneer hij terugkomt.
- De SIEM wordt 15 minuten afgesloten van de gateways: de exportfoutpage gaat af, wachtrijen lopen vol en daarna weer leeg, en de heartbeat toont geen gat.
17. Hoe Workstation dit levert en beheert
- Assessment. Inventariseer de omgeving, de agents en wat ze kunnen aanraken, de data- en modelassets, en de bestaande SIEM-, monitoring- en responstools. Deliverable: een dreigings- en maatregelenkaart zoals in sectie 2, specifiek voor u.
- Architectuur. Kies bronnen, schema, backends, retentie, HA en het standpunt ten aanzien van UK GDPR. Deliverable: een ondertekend ontwerp.
- Bouw. Collector-agents en securitygateways, OpenShell-OCSF-export, ingest-pipelines, indextemplates, lifecycle policies en dashboards, allemaal vanuit configuratie onder versiebeheer in uw repositories.
- Detection engineering. Regels, alerts en playbooks voor uw scenario's, elk met een testevent en een eigenaar.
- Tuning. Twee tot vier weken stil laten draaien, ruis wegnemen, drempels en suppression instellen, en een alertbudget afspreken dat het team kan volhouden.
- Overdracht. De oefeningen uit sectie 16, runbooks, en training voor analisten en platformengineers.
- Managed monitoringondersteuning. Doorlopende monitoringondersteuning naast uw team (of als dekking buiten kantooruren voor uw team): regelupdates naarmate de producten van NVIDIA en het dreigingslandschap veranderen, upgrades van de pipeline, regelmatige threat-hunting-reviews, en een maandrapport over detecties, responstijden, ruis en dekking. De exacte serviceniveaus worden per klant afgesproken.
NVIDIA-partner: engineering, software en mensen
Workstation is een NVIDIA-partner, dus naast de hardware bieden we de engineering, software en medewerkers om AI-datacenters end-to-end op te zetten en te beheren, inclusief de securitymonitoring eromheen. We specificeren en leveren het platform, installeren en configureren het, bouwen de hier beschreven observability- en SIEM-integratie, en leveren engineers die daarna binnen uw changeproces werken.
- DPU's en netwerken: NVIDIA BlueField-DPU's (waaronder de BlueField-3 B3220, de minimale generatie voor DOCA Argus), ConnectX-8 SuperNICs en het Spectrum-X Ethernet-platform.
- GPU-systemen: DGX B300, HGX B300-servers, DGX SuperPOD en Vera Rubin NVL72, de systeemklasse in NVIDIA's OpenShell Reference Architecture voor inferentie.
- Software: abonnementen op NVIDIA AI Enterprise, en installatie en ondersteuning voor OpenShell, NeMo Guardrails, garak en de open componenten in dit artikel.
Om uw omgeving te bespreken, vraag het onze AI Sales Engineer; die verwijst u door naar de juiste engineer.
18. Bronnen en verificatienotities
- Overzicht van het NVIDIA-portfolio: de officiële pagina over cybersecurity-AI-oplossingen van NVIDIA, gelezen in november 2026, voor OpenShell en de referentiearchitectuur, Sentry op BlueField, BlueField en DOCA, DOCA Argus, DOCA Vault, confidential computing, Nemotron en Nemotron Safety, NeMo, garak en NemoClaw. Alle formuleringen hier zijn onze eigen samenvatting.
- OpenShell: de README van de GitHub-repository en de documentatiepagina's over sandboxlogging, OCSF-JSON-export, gatewayconfiguratie (OCSF-JSONL- en OTLP-export), gatewaymetrics, sandboxes en policies. OCSF-klassen, redenstrings, de bevinding
sandbox-authorization-boundary, OTLP-attributen, metricnamen en CLI-commando's zijn van die pagina's overgenomen. Het voorbeeld-OCSF-record in onze test is gebouwd op basis van het voorbeeld in de documentatie. - DOCA Argus: NVIDIA's DOCA Argus service guide voor vereisten, berichttypen, ernstniveaus en telemetriesleutels. Niet op hardware getest; veldpaden moeten worden gecontroleerd tegen een echt bericht van uw release.
- Sentry, DOCA Vault en de OpenShell Reference Architecture: alleen beschreven op basis van de openbare pagina van NVIDIA. Er worden hier geen interfaces, formaten of commando's voor gegeven.
- Confidential computing: de pagina van NVIDIA en de README van nvTrust. Het formaat van het attestatie-event is een conventie van Workstation.
- NeMo Guardrails: de README van de repository (railtypen, release 0.24.1) en de referentie voor de tracingconfiguratie. De conventie voor blokkade-events is van Workstation.
- garak: de README van de repository, CLI-opties en de broncode van de evaluator voor de velden van het evaluatierecord. De probeset in het CI-voorbeeld is illustratief.
- Morpheus: de README, voorbeelden en releaselijst van de repository (laatste tag 25.06, juli 2025, op het moment van schrijven).
- Dynatrace: de documentatie van Dynatrace over de OTLP-API en de Collector-configuratie voor endpoint, protocol, tokenscopes en delta-temporaliteit. Niet getest tegen een live tenant: de exporter is gevalideerd en gedraaid, maar zijn verzoeken gingen naar een placeholderomgeving. Anomaliedetectie met Davis en routering van securityevents zijn in algemene termen beschreven, volgens de documentatie van Dynatrace.
- OpenTelemetry Collector: beide configuraties gevalideerd met
otelcol-contrib validateinotel/opentelemetry-collector-contrib:0.165.0, en daarna gedraaid: test-records voor OCSF, Argus, appliances, guardrails, auditd, Kubernetes-audit en garak zijn via een agent en de gateway naar Elasticsearch en Prometheus gestuurd, en de resulterende documenten en series zijn geïnspecteerd. Endpoints en hostnamen zijn placeholders. - Elastic: ingest-pipeline, indextemplate en lifecycle policy toegepast op Elasticsearch 9.2.0; alle veertien regels aangemaakt via de detection-engine-API van Kibana 9.2.0, succesvol uitgevoerd, en met de verwachte alerts (dertien gingen af; de regel voor buiten kantooruren terecht niet, omdat zijn testevent binnen de uren viel). Timelinetemplates, case connectors en overlap met kant-en-klare regels zijn niet getest.
- Prometheus en Alertmanager: regels gevalideerd met
promtool check rulesen unitgetest metpromtool test rules, Prometheus 3.12.0; Alertmanager-configuratie gevalideerd metamtool check-config, Alertmanager 0.34.2. DCGM-metricnamen volgen dcgm-exporter 4.9.0 via dews:-recording rules uit het UFM-artikel. - Kubernetes: de quarantaine-NetworkPolicy gevalideerd met
kubeconform0.8.0 in strict mode. Niet getest tegen een live CNI. - Conventies van Workstation: datasetnamen, regel-ID's, de metric
ws.security.events, actienamen voor wslvault en OpsAPI, het guardrail-blokkade-event en het attestatie-event zijn van ons. - Illustratieve cijfers: eventtempo's, volumes, drempels en timings zijn uitgewerkte voorbeelden, geen metingen van een klantsysteem.
- Compliance: alleen algemene richtlijn, geen juridisch advies.
Erkenning van rechten: NVIDIA, het NVIDIA-logo, 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 en NVIDIA AI Enterprise zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de Verenigde Staten en andere landen. Producten en technologieën van NVIDIA kunnen worden beschermd door octrooien en andere intellectuele-eigendomsrechten van NVIDIA Corporation, en al deze rechten worden erkend en voorbehouden aan hun eigenaars. Productinformatie is in onze eigen woorden samengevat op basis van openbaar materiaal van NVIDIA; de website en documentatie van NVIDIA zijn de gezaghebbende bron. garak is een opensourceproject dat door NVIDIA wordt onderhouden. Elastic, Elasticsearch, Kibana, Logstash, Elastic Security, Dynatrace, Davis, Prometheus, Alertmanager, Grafana, Loki, OpenTelemetry, Kubernetes, ServiceNow, PagerDuty, MITRE ATT&CK, Fluent Bit, Vector en Slurm zijn handelsmerken of gedeponeerde handelsmerken van hun respectieve eigenaars, en andere namen kunnen handelsmerken van hun respectieve eigenaars zijn. Er wordt geen goedkeuring door een van deze bedrijven gesuggereerd. De eigen configuraties, regels, diagrammen en teksten van Workstation zijn © Workstation.