De shop is live

Wij bouwen Workstation AI-machines voor websites, AI-agents en LLM-training — configureer en koop online.

Bekijk handelsprijzen
AI-producten
AI LabsOpenAI-agentsClaude-agentsGrok-botWorkstation AI native CRMMarketingAlle producten
AI-oplossingen
Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI-werkstationsNVIDIA-hardware en -softwareNVIDIA Accelerated ComputingPrivate AIGPU private cloudGPU-clustersEdge AIAI per sector
AI-diensten
PlatformmoderniseringDigitale engineeringDatafundamenten en AIAutonome operatiesAI-adviesDevOps-automatiseringCybersecuritySoftwareontwikkelingAgentontwikkelingMLOps-opzetGPU-leasingGPU private cloud
Over ons
BedrijfOns verhaalPartnersKlantverhalen
AI-datacenters
AI-datacentersGPU private cloudGPU-clustersGPU-leasing
AI-inzichtenJev-reeksBenchmarklabModelkeuze
Technische notities
Documentatie
Linux-OSUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
AI-cloudplatformsAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-clouds en -marktplaatsen
Private AI-datacentersVoor advocatenkantorenVoor accountantskantorenOn-premises platformsVolledig beveiligde cloud
ToolsRing PromoterJobshout
Nieuws
Blog
Neem contact opInloggen

AI-werkstations, AI multi-agent software, GPU-infrastructuur en intelligente agentoplossingen voor moderne bedrijven.

Neem contact op

AI-oplossingen

Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI per sector

Producten

Alle productenWorkstation AI-native CRM & ERPMarketingOpenAI-agentsRing PromoterJobshout

Bedrijf

Over onsBedrijfAI-datacentersWaarom WorkstationPartnersKlantverhalenPrijzenContactTenthMatrix

Bronnen

AI-inzichtenTechnische notitiesDocumentatieLinux-OSAI-cloudplatformsPrivate AI-datacentersBlogZoekenSitemap
Kantoor België
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Ma - Vr: 9:00 - 18:00 CET
+32 492 45 67 46
Hoofdkantoor VK
77-79 Marlowes, Hemel Hempstead HP1 1LFRoute: neem afrit 20 van de M25, Outer LondonBedrijfsnummer: 11641870Ma - Vr: 9:00 - 18:00 GMT
+44 7515 356 146
Kantoor India
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Kantoor Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Ma - Vr: 9:00 - 18:00 Taiwanese tijd (GMT+8)
+886 926 892 701+32 492 45 67 46
Kantoor Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMa - vr: 9:00 - 18:00 uur Estse tijd (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle rechten voorbehouden.

PrivacyGegevensverwijderingCookiesServicevoorwaardenWebsite-sitemap

NVIDIA, het NVIDIA-logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX en HGX zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de VS en andere landen. AMD, het AMD Arrow-logo, EPYC, Instinct, Ryzen en Threadripper zijn handelsmerken van Advanced Micro Devices, Inc. Dell en PowerEdge zijn handelsmerken van Dell Inc. of haar dochterondernemingen. Intel en Xeon zijn handelsmerken van Intel Corporation of haar dochterondernemingen. AMAX, AceleMax en LiquidMax zijn handelsmerken van AMAX Engineering Corporation. Alle andere productnamen, logo's en merken zijn eigendom van hun respectieve eigenaren. Wij gebruiken ze uitsluitend om de producten aan te duiden die wij beschrijven, leveren of ondersteunen; het gebruik ervan betekent niet dat de eigenaren ons onderschrijven.

Home / Technische notities / Technology
AISecurityObservabilityAI Agents

NVIDIA cybersecurity-AI met OpenTelemetry en SIEM: BlueField, DOCA Argus, OpenShell en Guardrails naar Elastic Security, Dynatrace, Prometheus en Grafana

Dreigingen voor AI-datacenters gekoppeld aan maatregelen, het securityportfolio van NVIDIA laag voor laag, een gevalideerde OpenTelemetry-securitypipeline, veertien geteste Elastic-detectieregels, Prometheus-alerts, responsplaybooks, mapping naar UK GDPR en ISO 27001, retentie, HA en een gefaseerde aanpak

9 november 2026Technology58 min read

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.

Securitysignalen van BlueField-DPU's, confidential GPU's, OpenShell-sandboxes, guardrails en Kubernetes stromen via OpenTelemetry-securitygateways naar Elastic Security, Dynatrace, Prometheus met Alertmanager, en Grafana.

Samenvatting. NVIDIA levert nu securitymaatregelen op elke laag van een AI-datacenter: in de DPU, in de GPU, in de runtime die agents host, en in de modellen en guardrails eromheen. Elke maatregel levert bewijs op. Dat bewijs is alleen nuttig als het een SIEM bereikt in een consistente vorm, snel genoeg om erop te handelen, zonder onderweg secrets of prompts te lekken. Ons ontwerp verzamelt elk securitysignaal één keer via OpenTelemetry Collectors, mapt het naar het Elastic Common Schema, redigeert het en verdeelt het: elk event naar Elastic Security voor detectie, onderzoek en cases; events met hogere ernst, metrics en traces naar Dynatrace; counters met lage cardinaliteit naar Prometheus voor alerting; en dashboards in Grafana. Responsen draaien vanuit dezelfde alerts, met automatische inperking alleen waar die omkeerbaar is en een goedkeuring door een benoemd persoon overal elders.
Wat is getest, en wat niet. De Collector-configuraties zijn gevalideerd met 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.

DreigingHoe ze zichtbaar wordtPreventieve maatregelenSignaal dat we bewaken
Directe prompt injection en jailbreaksGebruikers stellen prompts op om een model zijn instructies te laten negeren of schadelijke output te laten producerenInput rails van NeMo Guardrails, Nemotron Safety-classifiers, garak-tests in CIRail-blokkades per gebruiker; slagingspercentage van garak-aanvallen per probe
Indirecte prompt injection en goal hijackingInstructies verborgen in een webpagina, e-mail of document dat de agent leest, sturen hem naar een nieuw doel, vaak exfiltratieNetwerk- en bestandspolicy van OpenShell (standaard weigeren), retrieval rails, menselijke goedkeuring voor nieuwe toegangOpenShell-weigeringen en nieuwe bestemmingen; reeksen weigeringen per sandbox
DatalekkenPersoonsgegevens, secrets of broncode in prompts, antwoorden, logs of uploads van agentsOutput rails van guardrails en maskering van gevoelige gegevens, egress-policy van OpenShell, injectie van credentials zodat agents nooit echte secrets in handen hebbenOutput-rail-blokkades, egress-weigeringen, bevindingen over gevoelige gegevens (Morpheus of rails)
Diefstal van modellen en gewichtenGrote overdrachten van checkpoints of gewichten; afwijkende leesacties uit modelregistriesConfidential computing, DOCA Vault, sleutels in wslvault, netwerksegmentatieEgress-volume vanaf inferentie- en opslagnodes; leesacties op secrets buiten kantooruren; mislukte attestaties
Supply chainVergiftigde modelbestanden, kwaadaardige packages die door agents zijn geïnstalleerd, gemanipuleerde container-imagesProces- en packagepolicy van OpenShell, image signing en admission control, garak-regressietestsNieuwe procesuitvoeringen (Argus, auditd), onverwachte image-hashes, garak-regressies
Laterale bewegingEen gecompromitteerde agent of pod bereikt de Kubernetes-API, de metadataservice van de cloud of andere tenantsOpenShell blokkeert control-plane-poorten en link-local-adressen; Kubernetes RBAC en network policy; BlueField-isolatieSSRF-achtige weigeringen, autorisatiebevindingen tussen sandboxes, aanmaak van privileged pods
GPU-cryptojackingMiners gebruiken gestolen GPU-tijd, vaak op idle of slecht ingeplande nodesAlleen toegang tot GPU's via de scheduler, uitvoeringspolicy, runtimedetectie met DOCA ArgusGPU bezet zonder ingeplande job (DCGM); uitvoeringen vanuit /tmp; Argus-alerts
Misbruik door insidersEen beheerder of gecompromitteerd account leest secrets, verruimt agentrechten of schakelt monitoring uitSingle sign-on met goedkeuringsstappen, least privilege, functiescheiding voor de securitypipelineAfwijkende aanmelding gevolgd door een geprivilegieerde goedkeuring; leesacties op secrets buiten afgesproken tijden; gaten in de telemetrie
Niet-vertrouwde infrastructuurEen hostingprovider, mede-tenant of operator met hosttoegang probeert gegevens of gewichten in gebruik te lezenConfidential computing met attestatie voordat sleutels worden vrijgegevenMislukte attestaties; workloads gestart zonder geslaagde attestatie

3. Het cybersecurityportfolio van NVIDIA, laag voor laag

Vijf lagen van onder naar boven: silicium en DPU (BlueField, DOCA, DOCA Argus, DOCA Vault, Sentry, DOCA Telemetry Service), platform (confidential computing en attestatie), agentruntime (OpenShell, met NemoClaw erbovenop), modellen en guardrails (Nemotron Safety, NeMo Guardrails, garak), en pipelines (Morpheus), elk met de signalen die het aan een SIEM doorgeeft.

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_type van EVENT, ALERT of SYSTEM_ACTIVITY en een severity van INFO tot CRITICAL, met payloadsecties zoals workload_information en activity_data.
  • Telemetrie-export staat standaard uit. Ze wordt geconfigureerd met telemetry_address, telemetry_format (JSON of syslog) en telemetry_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, bijvoorbeeld no matching policy of resolves 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.uid sandbox-authorization-boundary: de credential is mogelijk gecompromitteerd.
  • Door enabled = true in te stellen onder [openshell.gateway.otlp.ocsf] in gateway.toml worden OCSF-events geëxporteerd als OTLP-logrecords onder de instrumentation scope openshell.ocsf. De body is het OCSF-event als JSON; attributen zijn onder meer ocsf.class_uid, ocsf.severity_id, ocsf.metadata.uid en openshell.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 in openshell_ocsf_otlp_dropped_total, en de volgende batch bevat een waarschuwingsrecord met de naam openshell.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

Bronnen links (node-agents, OpenShell, DOCA Argus, syslog van appliances, beveiligde applicaties) voeden een security-gatewaypaar dat OCSF parseert, naar ECS mapt, redigeert, routeert en telt; rechts ontvangt Elastic Security elk log, Dynatrace events met hogere ernst, metrics en traces, Prometheus met Alertmanager tellingen en metrics, en Grafana leest beide; een onderste band toont alert, case, goedkeuring en inperking.

Vijf principes sturen het ontwerp:

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

BronWat het ons verteltTransport naar de pipelineDataset
OpenShell-gateway en -supervisorsElke toestemming en weigering voor netwerk-, HTTP-, proces-, SSH-, authenticatie- en API-aanroepen; geladen policies; bevindingenOCSF via OTLP vanuit [openshell.gateway.otlp.ocsf]; gatewaymetrics via scrapeopenshell.ocsf
DOCA Argus op BlueFieldRuntimealerts en activiteit uit analyse van het hostgeheugenJSON via TCP naar de gatewaydoca.argus
Sentry op BlueField-4Afwijkingen in agentgedrag, quarantaineactiesVolgens de Sentry-documentatie van NVIDIA; we mappen naar hetzelfde datasetpatroonnvidia.sentry (gepland)
Confidential computingAttestatie geslaagd of mislukt per GPU en workloadLaunch-wrapper logt ECS-JSON naar syslogcc.attestation
NeMo Guardrails-applicatiesRail-blokkades (events) en rail-timings (spans)OTLP vanuit de applicatienemo.guardrails
garak in CISlagingspercentage van aanvallen per probe en detectorCollector van de runner volgt het JSONL-rapportgarak.eval
Kubernetes-API-serverWie wat heeft aangemaakt, gewijzigd of er een exec in heeft gedaanAgent op control-plane-nodes volgt het auditlogkubernetes.audit_logs
wslproxy WAFElke WAF-beslissing met signature, client en route; Prometheus-counterswafsec-JSON via syslog; metrics via scrapewslproxy.waf
wslvaultLeesacties, schrijfacties en weigeringen voor secrets per identiteitECS-JSON via syslogwslvault.audit
OpsAPI single sign-onAanmeldingen, mislukkingen, goedkeuringen van geprivilegieerde agenttoegangECS-JSON via syslogopsapi.sso
Linux-hostsUitvoeringen, privilegewijzigingen, file watches (auditd)Agent volgt /var/log/audit/audit.logauditd.log
DCGM en node-exporterGPU-gebruik zonder job, egress-volumeBestaande 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-veldWaar het wordt gemapt
action (Allowed, Denied)event.actionGateway
status_id (1 geslaagd, 2 mislukt)event.outcomeGateway
status_detail, of finding_info.uid voor bevindingenevent.reasonIngest-pipeline
class_uidevent.category (network, process, authentication, api, configuration, intrusion_detection)Ingest-pipeline
type_uid, severity_id, metadata.uidevent.code, event.severity, event.idIngest-pipeline
dst_endpoint.domain, .ip, .portdestination.domain, destination.ip, destination.portGateway (domein, poort), ingest-pipeline (ip)
src_endpoint.ipsource.ipIngest-pipeline
actor.process.name, .pid, .cmd_lineprocess.executable, process.pid, process.command_lineGateway, ingest-pipeline
actor.user.uiduser.idIngest-pipeline
device.container.name, .uid (de sandbox)container.name, container.idGateway, ingest-pipeline
firewall_rule.name (de policy die overeenkwam)rule.nameGateway
metadata.product.name, .versionobserver.product, observer.versionIngest-pipeline
time (epoch in milliseconden)@timestampIngest-pipeline
volledig recordevent.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 (bijvoorbeeld execve op 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 niveau Request, nodig voor create, update en patch van pods, 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_id in te stellen vanuit ocsf.metadata.uid met logs_dynamic_id ingeschakeld, 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_pipeline selecteert 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 WARN2 en hoger (OpenShell mapt OCSF Medium naar WARN2, High naar ERROR) 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.events uit 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 met delta_to_cumulative. In onze test ontving Prometheus ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied", event_outcome="failure"} met de labels site en cluster.
  • 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_labels maakt alleen van site en cluster Prometheus-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.

RegelTypeErnst
Egress van AI-agent geweigerd door OpenShell-policy
ws-ai-001-agent-egress-denied
KQL-querymedium
AI-agent bereikte een domein dat in 14 dagen niet is gezien
ws-ai-002-agent-new-egress-domain
New terms (KQL)low
AI-agent probeerde een link-local- of loopbackadres te bereiken
ws-ai-003-agent-ssrf-blocked
KQL-queryhigh
OpenShell-sandboxcredential gebruikt buiten zijn grens
ws-ai-004-sandbox-boundary-finding
KQL-querycritical
Reeks OpenShell-policyweigeringen vanuit één sandbox
ws-ai-005-policy-denial-spike
Threshold (KQL)high
Herhaalde jailbreakpogingen geblokkeerd door NeMo Guardrails
ws-ai-006-guardrail-jailbreak-attempts
Threshold (KQL)medium
Slagingspercentage van garak-aanvallen boven 5% in CI
ws-ai-007-garak-regression
ES|QLhigh
DOCA Argus-runtimealert op een GPU-host
ws-ai-008-doca-argus-alert
KQL-querycritical
Aanmelding van buiten het VK gevolgd door een agentgoedkeuring
ws-ai-009-sso-anomaly-then-agent-approval
EQL-sequencehigh
Leesactie op wslvault-secret buiten 07:00 tot 19:00 UTC
ws-ai-010-vault-read-out-of-hours
ES|QLmedium
Privileged pod aangemaakt of gewijzigd in Kubernetes
ws-ai-011-k8s-privileged-pod
KQL-queryhigh
Attestatie voor confidential computing mislukt
ws-ai-012-attestation-failure
KQL-querycritical
wslproxy WAF blokkeert één client herhaaldelijk
ws-ai-013-waf-block-burst
Threshold (KQL)medium
Programma uitgevoerd vanuit /tmp of /dev/shm op een GPU-node
ws-ai-014-exec-from-tmp
KQL-queryhigh

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, _version selecteren 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/metrics en /v1/logs toe. De eigen metrics van onze test-Collector bevestigden dat hij naar /api/v2/otlp/v1/logs postte.
  • Protocol. Alleen OTLP via HTTP met binaire protobuf: geen gRPC en geen JSON. Vandaar otlp_http in de gateway.
  • Authenticatie. Een Dynatrace-platformtoken in een Authorization: Bearer-header, met de scopes openpipeline:logs:ingest, openpipeline:metrics:ingest en openpipeline: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:ratio is de recording rule uit het UFM-artikel die de oude en nieuwe metricnamen van dcgm-exporter overbrugt. De cryptojackingregel vertrouwt erop dat dcgm-exporter pod (Kubernetes) of hpc_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_role is het label dat de UFM-agent instelt vanuit WS_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), dus SiemExportFailing matcht 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:

PaneelTypeQuery (gegevensbron)
Securityevents per minuut per dataset en outcomeGestapelde tijdreekssum by (data_stream_dataset, event_outcome) (rate(ws_security_events_total[5m])) * 60 (Prometheus)
Agentweigeringen nu versus gisterenTijdreeks met offsetsum(rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[5m])) en hetzelfde met offset 1d
Meest geweigerde bestemmingenBar gaugeTerms-aggregatie op destination.domain waar event.action:Denied (Elasticsearch)
Sandboxes met de meeste weigeringenTabelTerms op container.name, afgelopen uur (Elasticsearch)
Openstaande securityalerts per ernstStatALERTS{team="soc", alertstate="firing"} geteld per severity (Prometheus); Elastic-alerttellingen uit de index .alerts-security.alerts-*
Bezette GPU's zonder jobTabelws:gpu_util:ratio{pod="", hpc_job=""} > 0.3 (Prometheus)
Egress vanaf model- en opslagnodesTijdreekssum by (instance) (rate(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[5m]))
Slagingspercentage van garak-aanvallen per probeHeatmapgarak.fails / garak.total_evaluated per garak.probe over CI-runs (Elasticsearch)
Guardrail-blokkades per railTijdreeksTelling per rule.name in nemo.guardrails (Elasticsearch)
WAF-blokkades en -foutenTijdreekssum by (host) (rate(waf_blocked[5m])) en waf_errors
Gezondheid van de pipelineStat-rijGateways 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.

#ScenarioSignaalRegelRespons
1Agent-egress naar een niet-goedgekeurd domeinOpenShell-netwerkweigeringws-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
2Agent bereikt een domein dat nog nooit is gezienOpenShell-netwerktoestemmingws-ai-002 (new terms, historie van 14 dagen)Advise: bevestig de bestemming; scherp een te ruime policyregel aan
3Piek in policyweigeringenWeigeringen per sandbox; clusterbreed tempows-ai-005 (threshold); AgentPolicyDenialSurge (Prometheus)Auto: stop de sandbox als dit samengaat met een bevinding; anders approve
4Poging tot SSRF of toegang tot metadataWeigering met resolves to always-blocked addressws-ai-003Approve: stop de sandbox, roteer alle credentials die hij had
5Misbruik van sandboxcredentialOpenShell-bevinding sandbox-authorization-boundaryws-ai-004 (critical)Auto: stop de sandbox, plaats de pod in quarantaine, trek zijn secrets in
6Jailbreakpogingen bij guardrailsInput-rail-blokkades per gebruikerws-ai-006Approve: beperk het tempo van de gebruiker of schort hem op; beoordeel de metadata van het gesprek
7garak-regressie in CISlagingspercentage van aanvallen boven 5% voor een probews-ai-007 (ES|QL)Auto: laat de pipeline-gate falen; informeer de modeleigenaar
8DOCA Argus-runtimealertArgus-ALERT op HIGH of CRITICALws-ai-008Approve: isoleer de host (Sentry- of BlueField-maatregelen waar uitgerold; anders cordon en network policy)
9GPU-cryptojackingGPU bezet zonder pod of Slurm-job; uitvoeringen vanuit /tmpGpuBusyWithoutScheduledWork (Prometheus); ws-ai-014 (auditd)Approve: drain de node en beëindig het proces; bewaar eerst het bewijs
10Exfiltratie van modelgewichtenEgress per uur vanaf inferentie- of opslagnodes meer dan 3x vorige weekUnusualEgressFromModelNodes (Prometheus)Approve: blokkeer egress voor de node; controleer leesacties in registry en vault
11Afwijkende aanmelding, daarna geprivilegieerde agentgoedkeuringOpsAPI SSO-aanmelding buiten het VK, goedkeuring binnen 30 minutenws-ai-009 (EQL-sequence)Approve: trek de goedkeuring en sessies in; verifieer out-of-band bij de gebruiker
12Leesactie op secret buiten het afgesproken vensterwslvault-secret.read buiten 07:00 tot 19:00 UTCws-ai-010 (ES|QL)Advise: bevestig bij de eigenaar; roteer als het onverklaard blijft
13Privileged pod aangemaaktKubernetes-audit, privileged container in een podspecificatiews-ai-011Approve: verwijder de pod; beoordeel de RBAC van de identiteit die hem aanmaakte
14Mislukte attestatie voor confidential computingAttestatieresultaat failurews-ai-012 (critical)Auto: de sleuteldienst heeft al geweigerd; page, en houd de node buiten de pool
15Brute force aan de webedgewslproxy WAF-blokkades per clientws-ai-013Auto: de WAF blokkeert al; na goedkeuring toevoegen aan de denylijst van de edge
16Securitytelemetrie verlorenOpenShell-OCSF-drops; SIEM-exportfouten; nog maar één gateway overOpenShellOcsfExportDropping, SiemExportFailing, SecurityGatewayRedundancyLostPage het SOC: een blinde vlek is een incident

Een uitgewerkt voorbeeld in vijf stappen: een verborgen instructie in een webpagina, OpenShell die de verbinding weigert, de gateway en een Elastic-regel die het detecteren, een vooraf goedgekeurd playbook dat de sandbox stopt en in quarantaine plaatst, en een analist die het beoordeelt en een garak-probe toevoegt; daaronder de drie automatiseringsniveaus.

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 de emptyDir van 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.

RegimeWat het in algemene termen verwachtHoe dit ontwerp helpt
UK GDPRPassende 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 toepassingsgebiedEen 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 A8.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 kwetsbaarhedenCentrale, 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 EssentialsVijf technische maatregelen: firewalls, veilige configuratie, beheer van beveiligingsupdates, toegangsbeheer voor gebruikers en bescherming tegen malwareCyber 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:

  1. 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.
  2. 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.
  3. Metrics blijven laag in cardinaliteit. De eventcounter heeft drie labels met elk een handvol waarden, plus site en cluster. 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.
  4. 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 @timestamp overgenomen 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:

  1. 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.
  2. 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.
  3. Een bekend slechte probe wordt aan een CI-branch toegevoegd: het slagingspercentage van garak-aanvallen overschrijdt 5% en de pipeline-gate faalt.
  4. Een benchmarkjob draait op een GPU zonder gekoppelde schedulerjob: de cryptojackingalert gaat af binnen zijn venster van 15 minuten.
  5. Er wordt een testpod met een privileged container aangemaakt: de Kubernetes-regel gaat af en het playbook vraagt om goedkeuring.
  6. Eén securitygateway wordt gestopt: geen verloren events, een redundantiepage, herstel wanneer hij terugkomt.
  7. 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

Zeven fasen: assessment, ontwerp, bouw, detectie, tuning, overdracht en beheer, elk met een deliverable: dreigings- en maatregelenkaart, ondertekend ontwerp, werkende pipeline, regelbibliotheek met tests, afgesproken alertbudget, geslaagde oefeningen en maandrapport.

  1. 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.
  2. Architectuur. Kies bronnen, schema, backends, retentie, HA en het standpunt ten aanzien van UK GDPR. Deliverable: een ondertekend ontwerp.
  3. Bouw. Collector-agents en securitygateways, OpenShell-OCSF-export, ingest-pipelines, indextemplates, lifecycle policies en dashboards, allemaal vanuit configuratie onder versiebeheer in uw repositories.
  4. Detection engineering. Regels, alerts en playbooks voor uw scenario's, elk met een testevent en een eigenaar.
  5. Tuning. Twee tot vier weken stil laten draaien, ruis wegnemen, drempels en suppression instellen, en een alertbudget afspreken dat het team kan volhouden.
  6. Overdracht. De oefeningen uit sectie 16, runbooks, en training voor analisten en platformengineers.
  7. 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 validate in otel/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 rules en unitgetest met promtool test rules, Prometheus 3.12.0; Alertmanager-configuratie gevalideerd met amtool check-config, Alertmanager 0.34.2. DCGM-metricnamen volgen dcgm-exporter 4.9.0 via de ws:-recording rules uit het UFM-artikel.
  • Kubernetes: de quarantaine-NetworkPolicy gevalideerd met kubeconform 0.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.

Deel dit artikel

Meer in Technology

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

Wat er past op een RTX 5080 of RTX 5090 Laptop GPU, de geheugenberekening, de open modellen die de moeite waard zijn, Ubuntu 26.04 inrichten met de NVIDIA-stack, Ollama, llama.cpp en vLLM, codeerassistenten, LoRA-fine-tuning, beveiliging, en wanneer werk naar een server moet

Lees meer
ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

Bewijsmateriaal in plaats van bewijzen, in ongeveer 400 regels Python met echte output: slice-metrics met bootstrap-intervallen en een pass/fail-contract, property- en metamorfe tests met Hypothesis, kalibratie en conformal prediction, Pydantic-contracten en regressie-evals voor LLM-output, driftcontroles, een CI-gate en exacte verificatie van een klein neuraal netwerk

Lees meer
TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

torchcurves installeren, een curve fitten en dimensioneren, kiezen tussen B-spline en Legendre en de input map, een monotone kalibratiecurve en een additief model op tabeldata bouwen, vergelijken met SciPy, scikit-learn, een KAN en een MLP, coëfficiënten naar JSON exporteren, testen en in productie draaien, met echte output

Lees meer