Der Shop ist online

Wir bauen Workstation AI-Maschinen für Websites, KI-Agenten und LLM-Training – online konfigurieren und kaufen.

Händlerpreise erhalten
KI-Produkte
KI-LabsOpenAI-AgentenClaude-AgentenGrok-BotWorkstation AI-natives CRMMarketingAlle Produkte
KI-Lösungen
Angewandte KIKI-AgentenGenerative KIKI-AutomatisierungKI-WeiterbildungKI-Pakete für KMUEnterprise AI LabKI-WorkstationsNVIDIA-Hardware & -SoftwareNVIDIA Accelerated ComputingPrivate KIGPU-Private-CloudGPU-ClusterEdge-KIKI nach Branche
KI-Services
PlattformmodernisierungDigital EngineeringDatengrundlagen & KIAutonomer BetriebKI-BeratungDevOps-AutomatisierungCybersicherheitSoftwareentwicklungAgentenentwicklungMLOps-EinrichtungGPU-LeasingGPU-Private-Cloud
Über uns
UnternehmenUnsere GeschichtePartnerKundengeschichten
KI-Rechenzentren
KI-RechenzentrenGPU-Private-CloudGPU-ClusterGPU-Leasing
KI-EinblickeJev-ReiheBenchmark LabModellauswahl
Technische Hinweise
Dokumentation
Linux-BetriebssystemeUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
KI-Cloud-PlattformenAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-Clouds & Marktplätze
Private KI-RechenzentrenFür AnwaltskanzleienFür Steuer- und WirtschaftsprüfungskanzleienOn-Premises-PlattformenVollständig abgesicherte Cloud
ToolsRing PromoterJobshout
News
Blog
KontaktAnmelden

KI-Workstations, Multi-Agenten-KI-Software, GPU-Infrastruktur und intelligente Agentenlösungen für moderne Unternehmen.

Kontakt

KI-Lösungen

Angewandte KIKI-AgentenGenerative KIKI-AutomatisierungKI-WeiterbildungKI-Pakete für KMUEnterprise AI LabKI nach Branche

Produkte

Alle ProdukteWorkstation AI-natives CRM & ERPMarketingOpenAI-AgentenRing PromoterJobshout

Unternehmen

Über unsUnternehmenKI-RechenzentrenWarum WorkstationPartnerKundengeschichtenPreiseKontaktTenthMatrix

Ressourcen

KI-EinblickeTechnische HinweiseDokumentationLinux-BetriebssystemeKI-Cloud-PlattformenPrivate KI-RechenzentrenBlogSucheSitemap
Büro Belgien
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Mo – Fr: 9:00 – 18:00 Uhr MEZ
+32 492 45 67 46
Hauptsitz Großbritannien
77-79 Marlowes, Hemel Hempstead HP1 1LFAnfahrt – Ausfahrt 20 der M25 (Outer London)Handelsregisternr.: 11641870Mo – Fr: 9:00 – 18:00 Uhr GMT
+44 7515 356 146
Büro Indien
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Büro Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Mo – Fr: 9:00 – 18:00 Uhr Taiwan-Zeit (GMT+8)
+886 926 892 701+32 492 45 67 46
Büro Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMo - Fr: 9:00 - 18:00 Uhr estnischer Zeit (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle Rechte vorbehalten.

DatenschutzDatenlöschungCookiesNutzungsbedingungenWebsite-Sitemap

NVIDIA, das NVIDIA-Logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX und HGX sind Marken und/oder eingetragene Marken der NVIDIA Corporation in den USA und anderen Ländern. AMD, das AMD-Arrow-Logo, EPYC, Instinct, Ryzen und Threadripper sind Marken von Advanced Micro Devices, Inc. Dell und PowerEdge sind Marken der Dell Inc. oder ihrer Tochtergesellschaften. Intel und Xeon sind Marken der Intel Corporation oder ihrer Tochtergesellschaften. AMAX, AceleMax und LiquidMax sind Marken der AMAX Engineering Corporation. Alle anderen Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Inhaber. Wir verwenden sie ausschließlich, um die Produkte zu kennzeichnen, die wir beschreiben, liefern oder unterstützen; ihre Verwendung bedeutet nicht, dass ihre Inhaber uns empfehlen.

Startseite / Technische Hinweise / Technology
AISecurityObservabilityAI Agents

NVIDIA Cybersecurity-KI mit OpenTelemetry und SIEM: BlueField, DOCA Argus, OpenShell und Guardrails in Elastic Security, Dynatrace, Prometheus und Grafana

Bedrohungen für KI-Rechenzentren und zugehörige Kontrollen, NVIDIAs Sicherheitsportfolio Schicht für Schicht, eine validierte OpenTelemetry-Sicherheitspipeline, vierzehn getestete Elastic-Erkennungsregeln, Prometheus-Alarme, Response-Playbooks, Zuordnung zu UK GDPR und ISO 27001, Aufbewahrung, HA und ein phasenweises Vorgehen

9. November 2026Technology56 min read

Ein Leitfaden aus der Praxis zur Absicherung von KI-Rechenzentren und KI-Agenten mit NVIDIAs Cybersecurity-Portfolio und zur Überwachung all dessen über eine einzige OpenTelemetry-Pipeline, die die Werkzeuge speist, die Sicherheitsteams bereits betreiben: Elastic Security als SIEM, Dynatrace, Prometheus mit Alertmanager sowie Grafana. Er behandelt die spezifischen Bedrohungen für GPU-Umgebungen und Agenten, was jedes NVIDIA-Produkt Schicht für Schicht leistet (BlueField und DOCA, DOCA Argus, DOCA Vault, Sentry, Confidential Computing, OpenShell, Nemotron Safety, NeMo Guardrails, garak und Morpheus), welche Telemetrie jedes davon tatsächlich ausgibt, eine validierte Collector-Konfiguration, vierzehn Elastic-Erkennungsregeln, die in ein laufendes Kibana geladen und mit Testereignissen ausgelöst wurden, Prometheus-Alarmregeln mit Unit-Tests, Response-Playbooks, Compliance-Zuordnung, Aufbewahrung und Kosten, Hochverfügbarkeit und wie Workstation dies umsetzt.

Sicherheitssignale von BlueField-DPUs, Confidential-GPUs, OpenShell-Sandboxes, Guardrails und Kubernetes fließen über OpenTelemetry-Security-Gateways zu Elastic Security, Dynatrace, Prometheus mit Alertmanager und Grafana.

Zusammenfassung. NVIDIA liefert inzwischen Sicherheitskontrollen auf jeder Schicht eines KI-Rechenzentrums: in der DPU, in der GPU, in der Runtime, die Agenten hostet, und in den Modellen und Guardrails darum herum. Jede Kontrolle erzeugt Nachweise. Diese Nachweise sind nur dann nützlich, wenn sie ein SIEM in einheitlicher Form erreichen, schnell genug, um darauf zu reagieren, und ohne unterwegs Secrets oder Prompts preiszugeben. Unser Design erfasst jedes Sicherheitssignal einmal über OpenTelemetry Collectors, bildet es auf das Elastic Common Schema ab, schwärzt es und verteilt es: jedes Ereignis an Elastic Security für Erkennung, Untersuchung und Cases; Ereignisse höherer Schwere, Metriken und Traces an Dynatrace; Zähler mit geringer Kardinalität an Prometheus für Alarme; und Dashboards in Grafana. Reaktionen laufen über dieselben Alarme, mit automatischer Eindämmung nur dort, wo sie umkehrbar ist, und überall sonst mit der Freigabe durch eine namentlich benannte Person.
Was getestet wurde und was nicht. Die Collector-Konfigurationen wurden mit otelcol-contrib validate 0.165.0 validiert und anschließend Ende-zu-Ende betrieben: Testereignisse liefen über ein echtes Gateway in Elasticsearch 9.2.0 und Prometheus 3.12.0. Ingest-Pipeline, Index-Template und Lifecycle-Policy wurden auf diesem Elasticsearch angewendet, und alle vierzehn Erkennungsregeln wurden über die Detection Engine von Kibana 9.2.0 angelegt, erfolgreich ausgeführt und lösten die erwarteten Alarme aus. Die Prometheus-Regeln bestanden promtool check rules und promtool test rules; die Alertmanager-Konfiguration bestand amtool check-config; das Kubernetes-Manifest bestand kubeconform. Dynatrace, BlueField-4, Sentry, DOCA Vault und Confidential-Computing-Hardware standen im Test nicht zur Verfügung; diese Teile sind daher anhand der öffentlichen Dokumentation von NVIDIA und Dynatrace beschrieben, und wir weisen jeweils darauf hin. Abschnitt 18 führt alle Quellen und Lücken auf.

Dieser Artikel erweitert zwei frühere Technotes, statt sie zu ersetzen. Das Referenzdesign zu UFM, DCGM und OpenTelemetry beschreibt den Collector-Agenten auf jedem Node und das Gateway-Paar, das wir für operative Telemetrie verwenden, und das Minerva-AIOps-Runbook behandelt Incident-Korrelation und änderungskontrollierte Behebung. Sicherheitstelemetrie folgt demselben Muster aus Agent und Gateway, mit einer Änderung: Sie erhält ein eigenes Gateway-Paar, das dem Sicherheitsteam gehört. Unser Standard Big Prometheus und MoSCoW gilt weiterhin: OpenTelemetry ist der Telemetrie-Vertrag, PromQL ist die Metriksprache, und jede Art von Log hat genau einen primären Speicher.

1. Management-Zusammenfassung

KI-Rechenzentren sind aus Gründen attraktive Ziele, die für gewöhnliche Serverräume nicht gelten. Die Hardware ist teuer, und es ist leicht, ihr Rechenzeit abzuzweigen. Modellgewichte und Trainingsdaten sind oft das wertvollste geistige Eigentum eines Unternehmens. Und KI-Agenten handeln inzwischen selbstständig: Sie lesen nicht vertrauenswürdige Webseiten und Dokumente, rufen Werkzeuge auf, verwenden Zugangsdaten und verändern Systeme. Eine einzige versteckte Anweisung in einem Dokument kann einen hilfreichen Agenten in einen Innentäter verwandeln.

NVIDIAs Antwort ist Defense in Depth über den gesamten Stack. Einfach ausgedrückt:

  • Die DPU überwacht den Server von außerhalb. BlueField betreibt Sicherheitsdienste in einer eigenen isolierten Domäne, sodass Malware auf dem Host sie nicht abschalten kann. DOCA Argus untersucht den Hostspeicher auf Laufzeitbedrohungen; Sentry überwacht Agenten und kann sie innerhalb von Millisekunden unter Quarantäne stellen; DOCA Vault schützt sensible Daten.
  • Die GPU schützt Daten während der Nutzung. Confidential Computing hält Daten und Modellgewichte verschlüsselt und isoliert innerhalb der GPU, und die Attestierung weist dies nach, bevor etwas Sensibles freigegeben wird.
  • Agenten laufen in einer Sandbox mit schriftlicher Policy. OpenShell legt fest, welche Dateien, Netzwerkziele, Prozesse und Zugangsdaten ein Agent verwenden darf, setzt dies im Kernel und im Proxy durch und protokolliert jede Entscheidung in einem standardisierten Sicherheitsschema.
  • Modelle werden auf dem Hin- und Rückweg geprüft. Nemotron-Safety-Modelle und NeMo Guardrails filtern unsichere Prompts und Antworten; garak greift Ihre Agenten an, bevor Angreifer es tun.

Was NVIDIAs Produkte allein nicht leisten: einem Security-Operations-Team einen zentralen Ort zu geben, an dem es all dies sehen, mit Identität, Kubernetes, dem Web-Edge und Secrets korrelieren und darauf reagieren kann. Genau darum geht es in diesem Artikel, und hier kommt Workstations Praxis für Observability und SIEM ins Spiel. Das Ergebnis für das Unternehmen:

  • Jede Sicherheitskontrolle erzeugt Nachweise, die innerhalb von Sekunden in einem einheitlichen Schema in Ihrem SIEM landen;
  • Erkennungen für die Angriffe, die in KI-Umgebungen zählen (Agent-Hijacking, Modelldiebstahl, GPU-Missbrauch, Missbrauch von Berechtigungen), jeweils mit einer getesteten Reaktion;
  • Eindämmung, die nur dann automatisch erfolgt, wenn sie sicher und umkehrbar ist, und andernfalls eine menschliche Freigabe erfordert;
  • Nachweise für Auditoren unter UK GDPR, ISO 27001 und NIS-artigen Regelwerken, zu planbaren Kosten.

Workstation ist NVIDIA-Partner. Wir liefern die Hardware und stellen Engineering, Software und Personal bereit, um dies gemeinsam mit Ihnen zu entwerfen, aufzubauen und zu betreiben, von einer ersten Bewertung bis zur laufenden Monitoring-Unterstützung (Abschnitt 17).

2. Die Bedrohungslage für KI-Rechenzentren und Agenten

Die meisten Bedrohungen für eine KI-Umgebung sind bekannte Bedrohungen mit neuen Zielen. Die Tabelle ordnet jeder zu, wo sie auftritt, welche Kontrolle sie verhindert oder begrenzt und welches Signal Ihnen zeigt, dass sie eingetreten ist. Abschnitt 11 macht aus jedem Signal eine Erkennungsregel.

BedrohungWie sie sich zeigtPräventive KontrollenSignal, das wir beobachten
Direkte Prompt Injection und JailbreaksNutzer formulieren Prompts so, dass ein Modell seine Anweisungen ignoriert oder schädliche Ausgaben erzeugtInput Rails von NeMo Guardrails, Nemotron-Safety-Klassifikatoren, garak-Tests in der CIRail-Blockierungen pro Nutzer; garak-Angriffserfolgsrate pro Probe
Indirekte Prompt Injection und Goal HijackingIn einer Webseite, E-Mail oder einem Dokument, das der Agent liest, versteckte Anweisungen lenken ihn auf ein neues Ziel um, oft ExfiltrationNetzwerk- und Datei-Policy von OpenShell (standardmäßig verweigern), Retrieval Rails, menschliche Freigabe für neue ZugriffeOpenShell-Verweigerungen und neue Ziele; Häufungen von Verweigerungen pro Sandbox
DatenabflussPersonenbezogene Daten, Secrets oder Quellcode in Prompts, Antworten, Logs oder Uploads von AgentenOutput Rails der Guardrails und Maskierung sensibler Daten, Egress-Policy von OpenShell, Credential Injection, sodass Agenten nie echte Secrets besitzenOutput-Rail-Blockierungen, Egress-Verweigerungen, Funde sensibler Daten (Morpheus oder Rails)
Diebstahl von Modellen und GewichtenGroße Übertragungen von Checkpoints oder Gewichten; untypische Lesezugriffe auf Modell-RegistriesConfidential Computing, DOCA Vault, in wslvault verwahrte Schlüssel, NetzwerksegmentierungEgress-Volumen von Inferenz- und Storage-Nodes; Secret-Zugriffe außerhalb der Geschäftszeiten; fehlgeschlagene Attestierungen
LieferketteVergiftete Modelldateien, von Agenten installierte bösartige Pakete, manipulierte Container-ImagesProzess- und Paket-Policy von OpenShell, Image-Signierung und Admission Control, garak-RegressionstestsNeue Prozessausführungen (Argus, auditd), unerwartete Image-Hashes, garak-Regressionen
Laterale BewegungEin kompromittierter Agent oder Pod erreicht die Kubernetes-API, den Cloud-Metadatendienst oder andere MandantenOpenShell blockiert Control-Plane-Ports und Link-Local-Adressen; Kubernetes-RBAC und Network Policy; BlueField-IsolationVerweigerungen im SSRF-Stil, sandboxübergreifende Autorisierungsbefunde, Erstellung privilegierter Pods
GPU-CryptojackingMiner nutzen gestohlene GPU-Zeit, oft auf ungenutzten oder schlecht geplanten NodesGPU-Zugriff nur über den Scheduler, Ausführungs-Policy, Laufzeiterkennung mit DOCA ArgusGPU ausgelastet ohne geplanten Job (DCGM); Ausführungen aus /tmp; Argus-Alarme
Missbrauch durch InnentäterEin Administrator oder kompromittiertes Konto liest Secrets, erweitert Agentenberechtigungen oder deaktiviert das MonitoringSingle Sign-on mit Freigabeschritten, Least Privilege, Funktionstrennung für die SicherheitspipelineAuffällige Anmeldung, gefolgt von privilegierter Freigabe; Secret-Zugriffe außerhalb vereinbarter Zeiten; Telemetrielücken
Nicht vertrauenswürdige InfrastrukturEin Hosting-Anbieter, Mitmandant oder Betreiber mit Hostzugriff versucht, Daten oder Gewichte während der Nutzung zu lesenConfidential Computing mit Attestierung vor der SchlüsselfreigabeFehlgeschlagene Attestierungen; Workloads, die ohne erfolgreiche Attestierung gestartet wurden

3. NVIDIAs Cybersecurity-Portfolio, Schicht für Schicht

Fünf Schichten von unten: Silizium und DPU (BlueField, DOCA, DOCA Argus, DOCA Vault, Sentry, DOCA Telemetry Service), Plattform (Confidential Computing und Attestierung), Agenten-Runtime (OpenShell, mit NemoClaw darüber), Modelle und Guardrails (Nemotron Safety, NeMo Guardrails, garak) sowie Pipelines (Morpheus), jeweils mit den Signalen, die sie an ein SIEM übergeben.

NVIDIA fasst diese Produkte auf seiner Seite zu Cybersecurity-KI-Lösungen zusammen. Wir finden es übersichtlicher, sie nach der Schicht zu ordnen, die sie schützen, denn daraus ergibt sich, woher die Telemetrie jedes Produkts stammt und was es sehen kann, was die anderen nicht sehen.

3.1 Silizium und DPU: BlueField, DOCA, DOCA Argus, DOCA Vault und Sentry

BlueField ist NVIDIAs Data Processing Unit: ein Netzwerkadapter mit eigenen Arm-Kernen, eigenem Speicher und eigenem Betriebssystem, der zwischen Server und Netzwerk sitzt. DOCA ist das Software-Framework zu seiner Programmierung. Der Sicherheitsaspekt ist die Trennung. Dienste auf der DPU laufen in einer Domäne, die das Host-Betriebssystem nicht kontrolliert; ein Angreifer mit Root-Rechten auf dem Host kann sie also weder lesen noch stoppen.

DOCA Argus nutzt diese Position, um den Host zu beobachten. Laut NVIDIAs DOCA-Argus-Serviceleitfaden läuft es als Container auf BlueField-3 oder neuer (im DPU-Modus), liest ausgewählte Kernel-Strukturen per DMA aus dem Hostspeicher und rekonstruiert daraus ein Bild von Prozessen, Binärdateien mit ihren Hashes, Kommandozeilen, Dateien, Netzwerkverbindungen, Containern und VMs sowie der GPU-Nutzung pro Prozess, ohne dass ein Agent auf dem Host installiert ist. Daraus erzeugt es Alarme für Laufzeitbedrohungen wie Reverse Shells und unerwartete Ausführungen. Für die Integration wichtig:

  • Nachrichten haben einen message_type von EVENT, ALERT oder SYSTEM_ACTIVITY und einen severity von INFO bis CRITICAL, mit Payload-Abschnitten wie workload_information und activity_data.
  • Der Telemetrieexport ist standardmäßig deaktiviert. Er wird mit telemetry_address, telemetry_format (JSON oder Syslog) und telemetry_tag konfiguriert, und NVIDIAs Beispiele senden ihn per TCP an Fluent Bit oder Vector.
  • NVIDIA gibt an, dass Argus mit führenden Enterprise-XDR-Plattformen integriert ist. Wenn Sie eine solche betreiben, kann sie der primäre Empfänger bleiben; unsere Pipeline erhält dann eine Kopie zur Korrelation mit allem anderen.

Unser Gateway empfängt Argus-JSON direkt auf einem TCP-Listener (Abschnitt 6). Trennt Ihr Argus-Release Nachrichten nicht durch Zeilenumbrüche, schalten Sie Fluent Bit oder Vector dazwischen, wie es NVIDIAs Leitfaden zeigt, und leiten per OTLP an den Collector weiter; der Rest des Designs bleibt unverändert. NVIDIAs Leitfaden zeigt die Nachrichtenfelder in seinem Beispiel auf oberster Ebene, beschreibt in seiner Schematabelle aber eine message_header-Wurzel; prüfen Sie daher eine echte Nachricht aus Ihrem Release, bevor Sie sich auf die Feldpfade in unserer Regel verlassen.

DOCA Vault ist ein Sicherheits-Microservice auf BlueField, der sensible Daten mit Kontrollen im Silizium und Zero-Trust-Zugriff schützt. Wir haben ihn nicht getestet und beschreiben seine Schnittstellen hier nicht. In unseren Designs steht er neben dem Schlüsselmanagement, das Secrets an Workloads freigibt (bei uns wslvault), nicht an dessen Stelle.

NVIDIA Sentry on BlueField ist der neueste Baustein. NVIDIA beschreibt ihn als Teil seiner Open Agent Safety Platform: Er läuft in der hardwareisolierten Domäne von BlueField-4, unabhängig vom Host und von der eigenen Software des Agenten, überwacht das Verhalten von Agenten auf Policy-Abweichungen und verdächtige Aktivitäten, liefert vertrauenswürdige Telemetrie und kann einen Agenten mithilfe der Infrastrukturkontrollen der DPU innerhalb von Millisekunden unter Quarantäne stellen. Da er Out-of-Band arbeitet, funktioniert er auch dann noch, wenn der Host oder die Agenten-Runtime kompromittiert wurde, also genau dann, wenn Sie ihn brauchen. Wir behandeln die Alarme und Quarantänemaßnahmen von Sentry als vollwertige SIEM-Ereignisse; das genaue Exportformat sollte der Sentry-Dokumentation von NVIDIA für das eingesetzte Release entnommen werden.

DOCA Telemetry Service exportiert DPU-Zähler im Prometheus-Format. Er ist bereits Teil des UFM-Referenzdesigns und erfordert hier keine Änderung, außer dass Port- und Drop-Zähler auf DPUs vor Agenten-Hosts zu nützlichem Kontext bei Sicherheitsuntersuchungen werden.

3.2 Plattform: Confidential Computing und Attestierung

Confidential Computing schützt Daten und Modelle während der Nutzung. Die GPU führt die Workload in einer hardwarebasierten Trusted Execution Environment aus, sodass weder das Host-Betriebssystem noch der Hypervisor noch die Personen, die die Infrastruktur betreiben, den Speicher lesen können, und die GPU kann ihren Zustand per Attestierung nachweisen. Damit ist es die Kontrolle für zwei Bedrohungen, die nichts anderes in der Tabelle gut abdeckt: einen nicht vertrauenswürdigen Hosting-Anbieter und die gemeinsame Nutzung von Daten oder Modellen mit einer Partei, der Sie nicht vollständig vertrauen.

Die Betriebsregel ist einfach: keine erfolgreiche Attestierung, keine Schlüssel. Ein Start-Wrapper attestiert die GPU (und die Confidential VM), bevor die Workload startet, und fordert erst dann beim Schlüsseldienst den Entschlüsselungsschlüssel für Datensatz oder Modell an. NVIDIA veröffentlicht die Attestierungswerkzeuge in nvTrust; dessen README kennzeichnet das Python-Attestierungs-SDK und den lokalen GPU-Verifier als veraltet zugunsten eines C++-SDK und einer CLI; planen Sie neue Integrationen daher auf dieser Basis. Wir protokollieren jedes Attestierungsergebnis als strukturiertes Ereignis (bestanden oder fehlgeschlagen, welche GPU, welche Workload, welcher Verifier) und alarmieren bei jedem Fehlschlag.

3.3 Runtime: OpenShell

OpenShell ist NVIDIAs Open-Source-Runtime (Apache 2.0) für autonome Agenten. Jeder Agent läuft in einer Sandbox; eine Policy legt fest, welche Dateien er lesen oder schreiben darf, welche Netzwerkziele und HTTP-Methoden er verwenden darf, welche Prozesse er ausführen und welche Zugangsdaten er nutzen darf, und OpenShell setzt dies im Kernel und in einem Policy-prüfenden Proxy durch. Echte Zugangsdaten bleiben außerhalb der Sandbox: OpenShell fügt sie in ausgehende Anfragen ein, und nur dann, wenn das Ziel ein freigegebener Endpunkt ist. Bevor eine Policy-Änderung angewendet wird, markiert ein formaler Verifikationsschritt neue Zugriffe, die eine menschliche Prüfung erfordern. Unser früherer OpenShell-Artikel zeigt Schritt für Schritt, wie Agenten darunter betrieben werden.

Für ein SIEM ist OpenShell die ergiebigste Quelle im Stack, weil es jede Sicherheitsentscheidung im Open Cybersecurity Schema Framework (OCSF) in Version 1.8.0 aufzeichnet. Aus seiner Observability-Dokumentation:

  • Sandbox-Supervisoren und das Gateway geben OCSF-Ereignisse für Netzwerkaktivität (Klasse 4001), HTTP-Aktivität (4002), SSH (4007), Prozessaktivität (1007), Detection Findings (2004), Authentifizierung (3002), Konfigurationsänderungen (5019), Anwendungslebenszyklus (6002) und API-Aktivität (6003) aus.
  • Verweigerte Netzwerk- und HTTP-Ereignisse tragen den Grund in status_detail, zum Beispiel no matching policy oder resolves to always-blocked address (ein Link-Local- oder Loopback-Ziel wie ein Cloud-Metadaten-Endpunkt).
  • Ruft ein Sandbox-Credential eine Methode oder eine andere Sandbox auf, die es niemals berühren sollte, erzeugt das Gateway ein Detection Finding hoher Schwere mit finding_info.uid sandbox-authorization-boundary: Das Credential könnte kompromittiert sein.
  • Wird enabled = true unter [openshell.gateway.otlp.ocsf] in gateway.toml gesetzt, werden OCSF-Ereignisse als OTLP-Log-Records unter dem Instrumentation Scope openshell.ocsf exportiert. Der Body ist das OCSF-Ereignis als JSON; zu den Attributen gehören ocsf.class_uid, ocsf.severity_id, ocsf.metadata.uid und openshell.sandbox.id; Supervisoren senden ihre eigenen Ereignisse an denselben Endpunkt.
  • Die Zustellung erfolgt mindestens einmal (at least once); deduplizieren Sie daher anhand von ocsf.metadata.uid. Vom Gateway verworfene Records werden in openshell_ocsf_otlp_dropped_total gezählt, und der nächste Batch enthält einen Warn-Record namens openshell.ocsf.gap.
  • Das Gateway stellt Prometheus-Metriken auf einem separaten Listener ohne Authentifizierung bereit; halten Sie ihn daher intern. Interceptor-Fehler, die eine Anfrage durchlassen, werden in openshell_gateway_interceptor_fail_open_total gezählt.

Die Kurzform der Logzeile für eine verweigerte Verbindung sieht so aus (aus NVIDIAs Dokumentation):

OCSF NET:OPEN [MED] DENIED /usr/bin/curl(64) -> httpbin.org:443 [policy:- engine:opa] [reason:no matching policy]

NVIDIAs OpenShell Reference Architecture baut einen vollständigen Stack um die Runtime herum: Vera-CPUs betreiben die Agenten-Harnesses und ihre Werkzeuge, Vera-Rubin-Systeme stellen die Inferenz bereit, und Sentry auf BlueField-4 ergänzt Überwachung und Durchsetzung, die nicht vom Host abhängen. NVIDIA stellt ausdrücklich klar, dass OpenShell auch auf anderen CPU-Systemen läuft und dass Vera und BlueField optional sind; sie bringen Effizienz und die Out-of-Band-Schicht, nicht die Grundfunktion. NemoClaw, NVIDIAs Sammlung offener Blueprints für spezialisierte Agenten auf Basis von Nemotron-Modellen, betreibt seine Agenten innerhalb von OpenShell; alles in diesem Artikel gilt daher unverändert für NemoClaw-Agenten. NemoClaw selbst behandeln wir in einem separaten Artikel.

3.4 Modelle und Guardrails: Nemotron Safety, NeMo Guardrails und garak

Nemotron ist NVIDIAs Familie offener Modelle; NVIDIA positioniert einige für Planung und Reasoning, einige für schnelle Tool-Aufrufe in hohem Volumen sowie eine Reihe von Nemotron-Safety-Modellen, die unsichere Inhalte in Text und Bildern klassifizieren, sodass sie auf dem Weg in eine Agentenpipeline oder aus ihr heraus gefiltert werden können. Mit NeMo spezialisiert, können Nemotron-Modelle auch die eigenen Agenten der Verteidiger für Alarm-Triage, kontinuierliches Threat Hunting und Red-Team-Simulation betreiben.

NeMo Guardrails (zum Zeitpunkt der Erstellung aktuelles Release 0.24.1) setzt programmierbare Rails zwischen eine Anwendung und ihr Modell: Input Rails (zum Beispiel Jailbreak-Prüfungen und Maskierung sensibler Daten), Dialog Rails, Retrieval Rails auf RAG-Chunks, Execution Rails auf Tool-Ein- und -Ausgaben sowie Output Rails. Hinter einer Rail kann ein Sicherheitsklassifikator wie ein Nemotron-Safety-Modell sitzen. Für das Monitoring hat seine config.yml einen Abschnitt tracing mit einem OpenTelemetry-Adapter; die Bibliothek verwendet nur die OpenTelemetry-API, und Ihre Anwendung konfiguriert SDK und Exporter. Prompt- und Antwortinhalte werden nicht erfasst, sofern Sie nicht enable_content_capture: true setzen; lassen Sie dies in der Produktion deaktiviert, denn Prompts enthalten oft personenbezogene Daten.

Spans zeigen Ihnen, welche Rails gelaufen sind und wie lange sie gedauert haben, was ideal für Dynatrace ist. Für das SIEM möchten wir zusätzlich ein Ereignis pro Blockierung, mit wer, welche Rail und was geschehen ist, aber ohne Inhalt. Dieses erzeugen wir über einen schlanken Wrapper um den Rails-Aufruf, mit unserer eigenen Feldkonvention (event.action: input_rail_blocked, rule.name auf den Rail-Flow gesetzt, user.id). Diese Konvention stammt von Workstation und ist nicht Teil von NeMo Guardrails.

garak ist NVIDIAs Schwachstellenscanner für LLMs: Er führt Probes (Prompt Injection, Jailbreaks wie die DAN-Familie, Datenabfluss, Encoding-Tricks, Wiedergabe von Trainingsdaten und mehr) gegen einen Modell- oder Agenten-Endpunkt aus und bewertet die Antworten mit Detektoren. Jeder Lauf schreibt einen JSONL-Bericht; dessen Evaluierungs-Records haben entry_type: "eval" mit probe, detector, passed, fails und total_evaluated. Wir führen garak in der CI bei jeder Änderung an einem Modell, einem Prompt oder einer Guardrail-Konfiguration aus und senden diese Records an das SIEM, sodass eine Regression eine Erkennung wie jede andere ist.

# 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 ist ci/garak-staging.yaml eine garak-Konfigurationsdatei, die dem REST-Generator die URI und die Anfragevorlage Ihres Endpunkts übergibt (siehe garak-Dokumentation; es gibt auch Generatoren für OpenAI-kompatible Endpunkte, Hugging Face, Bedrock und andere). Aktuelle garak-Releases wählen Probes mit --spec aus; das ältere Flag --probes funktioniert noch, ist aber veraltet. Kopieren Sie die resultierende *.report.jsonl in das Verzeichnis, das der Collector des CI-Runners überwacht.

3.5 Pipelines: Morpheus

Morpheus ist NVIDIAs GPU-beschleunigtes Framework zum Aufbau von Cybersecurity-Inferenzpipelines über große Datenströme. Sein Repository enthält Beispielpipelines und vortrainierte Modelle für digitales Fingerprinting des Verhaltens von Nutzern und Maschinen, Phishing-Erkennung, Erkennung sensibler Informationen, Log-Parsing, Ransomware-Erkennung aus AppShield-Daten, Betrugserkennung mit Graph Neural Networks, Data Loss Prevention und Profilierung auffälligen Verhaltens, darunter ein Beispiel, das Kryptowährungs-Mining anhand von GPU-Telemetrie erkennt. Prüfen Sie den Status, bevor Sie damit planen: Zum Zeitpunkt der Erstellung ist das neueste getaggte Release 25.06 (Juli 2025). Wo ein Kunde bereits Morpheus-Pipelines betreibt, sind deren Ausgaben einfach eine weitere bewertete Quelle: Wir senden die Scores und markierten Records als Ereignisse in dasselbe Gateway.

4. Workstations Referenzarchitektur für Security Observability

Quellen links (Node-Agenten, OpenShell, DOCA Argus, Appliance-Syslog, abgesicherte Anwendungen) speisen ein Security-Gateway-Paar, das OCSF parst, auf ECS abbildet, schwärzt, routet und zählt; rechts erhält Elastic Security jedes Log, Dynatrace Ereignisse höherer Schwere, Metriken und Traces, Prometheus mit Alertmanager Zählwerte und Metriken, und Grafana liest beide; ein unteres Band zeigt Alarm, Case, Freigabe und Eindämmung.

Fünf Prinzipien bestimmen das Design:

  1. Eine Pipeline. Jedes Sicherheitssignal gelangt über einen OpenTelemetry Collector hinein. Backends ziehen niemals direkt von Quellen; ein Backend hinzuzufügen oder zu ersetzen ist daher eine Änderung am Gateway, nicht an der gesamten Flotte.
  2. Einmal normalisieren, am Gateway. Felder werden auf ECS-Namen (und, wo vorhanden, auf OTel Semantic Conventions) abgebildet, bevor sich die Daten verzweigen, sodass eine Regel in Elastic und ein Dashboard in Grafana über dasselbe destination.domain sprechen.
  3. Schwärzen, bevor etwas hinausgeht. Authorization-Header, Cookies, API-Tokens sowie Prompt- oder Completion-Text werden am Gateway entfernt. Kein Backend speichert sie jemals, daher muss keinem Backend damit vertraut werden.
  4. Jedes Backend tut, was es am besten kann. Elastic Security hält jedes Sicherheitsereignis vor und führt Korrelationsregeln und Cases aus. Dynatrace erhält die Ereignisse höherer Schwere, Metriken und Traces, damit seine KI Sicherheitsereignisse mit dem Zustand von Diensten verknüpfen kann. Prometheus erhält Zähler mit geringer Kardinalität sowie die GPU- und Netzwerkmetriken, die es bereits vorhält, für schnelle, kostengünstige Alarme. Grafana ist der gemeinsame Bildschirm.
  5. Die Pipeline überwacht sich selbst. Verworfene Records, fehlschlagende Exporte und verlorene Gateways sind Sicherheitsalarme, keine Betriebstickets (Abschnitt 15).

Ebenen

  • Node-Agenten sind dieselben Agenten wie im UFM-Design: ein Collector pro GPU-, Storage-, Login- und Control-Plane-Node. Wir ergänzen drei Receiver (auditd, das Audit-Log des Kubernetes-API-Servers und garak-Berichte auf CI-Runnern) sowie einen zweiten Exporter, der Sicherheitslogs an die Security-Gateways statt an die Operations-Gateways sendet.
  • Ein Security-Gateway-Paar (oder mehr) hinter einer virtuellen IP oder einem DNS-Namen, betrieben vom Sicherheitsteam. Es empfängt OTLP von Agenten, von OpenShell-Gateways und -Supervisoren sowie von abgesicherten Anwendungen; Argus-JSON per TCP; und Syslog über TLS von Appliances. Es scrapt die Metrik-Endpunkte des OpenShell-Gateways und von wslproxy. Backend-Zugangsdaten existieren nur hier.
  • Die Operations-Gateways bleiben unverändert. DCGM-, Node- und Fabric-Metriken fließen weiterhin wie im UFM-Design an Mimir oder Prometheus; die Cryptojacking- und Exfiltrationsalarme in Abschnitt 9 laufen dort, weil die Daten bereits dort liegen.

Warum separate Security-Gateways? Funktionstrennung (das Plattformteam kann Sicherheitsereignisse nicht unbemerkt herausfiltern), unterschiedliche Aufbewahrungs- und Zugriffsregeln und ein kleinerer Schadensradius: Eine fehlerhafte Dashboard-Abfrage oder eine Betriebsänderung kann die Sicherheitspipeline nicht aushungern.

Quellen

QuelleWas sie uns verrätTransport in die PipelineDatensatz
OpenShell-Gateway und -SupervisorenJede Erlaubnis und Verweigerung für Netzwerk-, HTTP-, Prozess-, SSH-, Authentifizierungs- und API-Aufrufe; Policy-Ladevorgänge; FindingsOCSF über OTLP von [openshell.gateway.otlp.ocsf]; Gateway-Metriken per Scrapeopenshell.ocsf
DOCA Argus auf BlueFieldLaufzeitalarme und Aktivitäten aus der Analyse des HostspeichersJSON per TCP an das Gatewaydoca.argus
Sentry auf BlueField-4Verhaltensabweichungen von Agenten, QuarantänemaßnahmenGemäß NVIDIAs Sentry-Dokumentation; wir bilden es auf dasselbe Datensatzmuster abnvidia.sentry (geplant)
Confidential ComputingAttestierung bestanden oder fehlgeschlagen pro GPU und WorkloadStart-Wrapper protokolliert ECS-JSON an Syslogcc.attestation
Anwendungen mit NeMo GuardrailsRail-Blockierungen (Ereignisse) und Rail-Laufzeiten (Spans)OTLP von der Anwendungnemo.guardrails
garak in der CIAngriffserfolgsrate pro Probe und DetektorCollector des Runners liest den JSONL-Bericht mitgarak.eval
Kubernetes-API-ServerWer was erstellt, geändert oder per exec betreten hatAgent auf Control-Plane-Nodes liest das Audit-Log mitkubernetes.audit_logs
wslproxy-WAFJede WAF-Entscheidung mit Signatur, Client und Route; Prometheus-Zählerwafsec-JSON über Syslog; Metriken per Scrapewslproxy.waf
wslvaultLese-, Schreib- und abgelehnte Zugriffe auf Secrets pro IdentitätECS-JSON über Syslogwslvault.audit
OpsAPI Single Sign-onAnmeldungen, Fehlschläge, Freigaben privilegierter AgentenzugriffeECS-JSON über Syslogopsapi.sso
Linux-HostsAusführungen, Rechteänderungen, Dateiüberwachung (auditd)Agent liest /var/log/audit/audit.log mitauditd.log
DCGM und node-exporterGPU-Auslastung ohne Job, Egress-VolumenBestehende Betriebspipeline (Prometheus oder Mimir)Metriken

Die Feldliste von wafsec stammt aus unserem Artikel zur WAF Engine v2. Für wslvault und OpsAPI konfigurieren wir die Produkte so, dass sie JSON mit ECS-Feldnamen protokollieren (event.action, event.outcome, user.id, source.ip), was die Zuordnung am Gateway trivial hält; die in den Regeln dieses Artikels verwendeten Aktionsnamen (secret.read, login, agent.approval.granted) sind unsere Konvention, passen Sie sie also an das an, was Ihre Installation ausgibt.

5. Normalisierung: OCSF, ECS und OpenTelemetry Semantic Conventions

In dieser Pipeline treffen drei Schemata aufeinander. OpenShell spricht OCSF; die Regeln, Timelines und vorgefertigten Inhalte von Elastic Security erwarten ECS; und OpenTelemetry hat eigene Semantic Conventions für Ressourcen und Attribute. Wir lassen den ursprünglichen Record für die Forensik unverändert und fügen ECS-Felder daneben ein. Das Gateway übernimmt die Zuordnung, die jedes Backend benötigt (damit Dynatrace dieselben Namen sieht wie Elastic), und eine Elasticsearch-Ingest-Pipeline übernimmt die Elastic-spezifische Anreicherung.

OCSF-Feld (OpenShell)ECS-FeldWo es zugeordnet wird
action (Allowed, Denied)event.actionGateway
status_id (1 Erfolg, 2 Fehlschlag)event.outcomeGateway
status_detail, bzw. finding_info.uid für Findingsevent.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 (Domain, Port), 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 (die Sandbox)container.name, container.idGateway, Ingest-Pipeline
firewall_rule.name (die zutreffende Policy)rule.nameGateway
metadata.product.name, .versionobserver.product, observer.versionIngest-Pipeline
time (Epoch-Millisekunden)@timestampIngest-Pipeline
gesamter Recordevent.original (nicht indiziert) und ocsf.* (flattened)Ingest-Pipeline

Die OpenShell-Dokumentation weist darauf hin, dass die Sandbox-Identität in OCSF-1.8.0-Records von einem Objekt container auf oberster Ebene nach device.container verschoben wurde, und fordert SIEM-Parser auf, dem zu folgen. Unsere Zuordnung liest nur den neuen Ort; pinnen Sie daher die OpenShell-Version in Ihren Change Records und testen Sie die Zuordnung bei einem Upgrade erneut.

6. Collector-Konfiguration

Die gesamte folgende Konfiguration verwendet Komponentennamen aus otelcol-contrib 0.165.0, das Namen in snake_case eingeführt hat (file_log, tcp_log, otlp_grpc, otlp_http, prometheus_remote_write, cumulative_to_delta, delta_to_cumulative, resource_detection). Die älteren Namen in unseren UFM- und Minerva-Artikeln funktionieren weiterhin als veraltete Aliase und protokollieren beim Start eine Warnung. Secrets sind Umgebungsplatzhalter.

Node-Agent: Sicherheits-Receiver

Diese Pipelines werden dem bestehenden Node-Agenten hinzugefügt. Auf einem Node, der weder Control Plane noch CI-Runner ist, bleiben die Receiver für nicht vorhandene Dateien einfach untätig.

# /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]

Hinweise:

  • Der auditd-Parser trennt den Record-Header von seinen Schlüssel-Wert-Paaren. Hex-codierte Felder wie proctitle dekodiert er nicht; falls Sie sie benötigen, dekodieren Sie sie in der Ingest-Pipeline. Aktivieren Sie die gewünschten Audit-Regeln (zum Beispiel execve auf GPU-Nodes) in Ihrer auditd-Konfiguration; der Collector liefert nur, was auditd schreibt.
  • Der Kubernetes-Audit-Receiver sieht nur, was die Audit-Policy Ihres API-Servers aufzeichnet. Um privilegierte Pods zu erkennen, benötigen Sie mindestens die Stufe RequestResponse oder die Stufe Request für Create, Update und Patch auf pods, damit der Request-Body im Log steht.
  • Der garak-Receiver behält nur Evaluierungs-Records und versieht sie mit der CI-Pipeline als Label, sodass eine Regression auf die Änderung verweist, die sie verursacht hat.

Security-Gateway

# /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

Hinweise zu den Entscheidungen:

  • Dokument-ID aus der OCSF-Ereignis-ID. OpenShell liefert mindestens einmal. Wird elasticsearch.document_id aus ocsf.metadata.uid gesetzt und ist logs_dynamic_id aktiviert, bleibt ein wiederholt gesendeter Record wirkungslos: In unserem Ende-zu-Ende-Test wies Elasticsearch die zweite Kopie mit einem Versionskonflikt ab, und es wurde nur ein Dokument gespeichert.
  • Dynamische Ingest-Pipeline. Das Attribut elasticsearch.ingest_pipeline wählt die OCSF-Pipeline nur für OpenShell-Records aus; andere Datensätze verwenden die Standards des Data Streams.
  • Routing nach Schwere. Der Routing-Connector kopiert Records ab OTel-Schwere WARN2 (OpenShell bildet OCSF Medium auf WARN2 und High auf ERROR ab) an Dynatrace, während jeder Record an Elasticsearch geht. So bleiben Volumen und Kosten bei Dynatrace verhältnismäßig.
  • Ereignisse zu Metriken zählen. Der Count-Connector gibt ws.security.events mit nur drei Attributen aus: Datensatz, Ergebnis und Aktion. Er erzeugt Delta-Summen, die Dynatrace benötigt und Prometheus Remote Write nicht; der Prometheus-Pfad konvertiert daher mit delta_to_cumulative. In unserem Test erhielt Prometheus ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied", event_outcome="failure"} mit den Labels site und cluster.
  • Kumulativ zu Delta für Dynatrace. Die OTLP-Ingestion von Dynatrace erfordert Delta-Temporalität für Metriken; gescrapte Metriken laufen daher nur auf dem Dynatrace-Pfad durch cumulative_to_delta.
  • Konstante Labels. resource_constant_labels macht nur site und cluster zu Prometheus-Labels. Sandbox-IDs, Pod-Namen und Domains werden nie zu Labels (Abschnitt 14).
  • Batching. Der Elasticsearch-Exporter bildet intern Batches, daher hat seine Pipeline keinen batch-Prozessor; andernfalls warnt der Collector vor doppeltem Batching.

Seite von OpenShell

Richten Sie auf dem OpenShell-Gateway den OCSF-Export auf die Security-Gateways. NVIDIAs Beispiel verwendet einen clusterinternen Servicenamen; unserer ist die Adresse des Security-Gateways. Supervisoren verwenden denselben Endpunkt, er muss also aus den Sandboxes erreichbar sein, und sie erhalten die Export-Header des Gateways zusammen mit ihren Start-Credentials statt über die Sandbox-Umgebung.

[openshell.gateway.otlp.ocsf]
enabled  = true
endpoint = "https://otel-security.sec.internal:4317"

Halten Sie die Entscheidung über OpenShells eigene anonyme Produkttelemetrie davon getrennt: Sie hat mit diesem Export nichts zu tun und wird über OPENSHELL_TELEMETRY_ENABLED oder den Helm-Wert server.telemetryEnabled gesteuert.

7. Elastic Security als SIEM

Elastic Security hält jedes Sicherheitsereignis vor, führt die Erkennungsregeln aus und ist der Ort, an dem Analysten untersuchen (Timelines) und Arbeit verfolgen (Cases). Wir betreiben es als dedizierten Security-Cluster oder als dedizierten Space mit eigenen Rollen, getrennt von der operativen Logsuche.

Ingest-Pipeline: von OCSF zu ECS

Diese Pipeline wurde in Elasticsearch 9.2.0 geladen und sowohl mit _simulate als auch mit Records geprüft, die über das Gateway eintrafen.

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}}}"] } }
  ]
}

Index-Template und Aufbewahrung

Das Objekt ocsf wird als flattened gemappt, sodass die vielen optionalen Felder von OCSF keine Mapping-Explosion verursachen können, Analysten aber trotzdem danach filtern können. Der ursprüngliche Record wird gespeichert, aber nicht indiziert. Das Template setzt sich aus Elastics eingebauten logs@mappings, logs@settings und ecs@mappings zusammen.

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 } } }
      }
    }
  }
}

Wir erstellen pro Sicherheitsdatensatz ein Template mit derselben Struktur und einer Lifecycle-Policy, die seiner Aufbewahrungsanforderung entspricht (Abschnitt 14). Dreizehn Monate sind ein üblicher Standard für Sicherheitsereignisse, weil sie einen vollen Jahresvergleich plus die Zeit für die Untersuchung eines spät entdeckten Vorfalls abdecken; den tatsächlichen Wert legen Ihre Verantwortlichen für Recht und Compliance fest.

Erkennungsregeln

Vierzehn Regeln, angelegt über die Detection-Engine-API von Kibana (POST /api/detection_engine/rules, API-Version 2023-10-31). Jede wurde erfolgreich gegen Testdaten ausgeführt, und jede Regel außer der Vault-Regel für Zugriffe außerhalb der Geschäftszeiten (deren Testereignis innerhalb der Geschäftszeiten lag) löste ihren erwarteten Alarm aus. Die Tabelle listet alle auf; zwei werden danach vollständig gezeigt.

RegelTypSchwere
Egress eines KI-Agenten durch OpenShell-Policy verweigert
ws-ai-001-agent-egress-denied
KQL-Abfragemedium
KI-Agent hat eine Domain erreicht, die 14 Tage lang nicht gesehen wurde
ws-ai-002-agent-new-egress-domain
New Terms (KQL)low
KI-Agent hat versucht, eine Link-Local- oder Loopback-Adresse zu erreichen
ws-ai-003-agent-ssrf-blocked
KQL-Abfragehigh
OpenShell-Sandbox-Credential außerhalb seiner Grenze verwendet
ws-ai-004-sandbox-boundary-finding
KQL-Abfragecritical
Häufung von OpenShell-Policy-Verweigerungen aus einer Sandbox
ws-ai-005-policy-denial-spike
Threshold (KQL)high
Wiederholte, von NeMo Guardrails blockierte Jailbreak-Versuche
ws-ai-006-guardrail-jailbreak-attempts
Threshold (KQL)medium
garak-Angriffserfolgsrate über 5 % in der CI
ws-ai-007-garak-regression
ES|QLhigh
DOCA-Argus-Laufzeitalarm auf einem GPU-Host
ws-ai-008-doca-argus-alert
KQL-Abfragecritical
Anmeldung von außerhalb Großbritanniens, gefolgt von einer Agentenfreigabe
ws-ai-009-sso-anomaly-then-agent-approval
EQL-Sequenzhigh
wslvault-Secret außerhalb von 07:00 bis 19:00 UTC gelesen
ws-ai-010-vault-read-out-of-hours
ES|QLmedium
Privilegierter Pod in Kubernetes erstellt oder geändert
ws-ai-011-k8s-privileged-pod
KQL-Abfragehigh
Confidential-Computing-Attestierung fehlgeschlagen
ws-ai-012-attestation-failure
KQL-Abfragecritical
wslproxy-WAF blockiert einen Client wiederholt
ws-ai-013-waf-block-burst
Threshold (KQL)medium
Programm aus /tmp oder /dev/shm auf einem GPU-Node ausgeführt
ws-ai-014-exec-from-tmp
KQL-Abfragehigh

Die Abfragen, wie 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/*)

Eine Abfrageregel mit Alarmunterdrückung und ATT&CK-Zuordnung. Die Unterdrückung fasst wiederholte Verweigerungen für dieselbe Sandbox und dasselbe Ziel zu einem Alarm pro Stunde zusammen; dadurch bleibt diese Regel auf einem stark ausgelasteten Cluster nutzbar:

{
  "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/"
        }
      ]
    }
  ]
}

Eine EQL-Sequenz, die zwei Quellen korreliert, die ein Analyst sonst von Hand zusammenführen müsste: eine Anmeldung von außerhalb Großbritanniens, auf die innerhalb von 30 Minuten die Freigabe eines privilegierten Agentenzugriffs durch denselben Nutzer folgt:

{
  "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"
  ]
}

Drei praktische Punkte zu Regeln:

  • ES|QL-Regeln benötigen Metadaten zur Deduplizierung. Nicht aggregierende ES|QL-Regeln sollten METADATA _id, _index, _version auswählen und diese Felder behalten, wie es unsere tun, damit die Engine doppelte Alarme vermeiden kann.
  • Nutzen Sie auch die vorgefertigten Regeln von Elastic. Elastic liefert Hunderte vorgefertigter Regeln für Linux, Kubernetes, Cloud und Identität. Unsere schließen die KI-spezifischen Lücken. Wo eine vorgefertigte Regel dasselbe Gebiet mit einer anderen Datenquelle abdeckt (etwa Elastics eigene Kubernetes-Audit-Integration), verwenden Sie die eine oder die andere, nicht beide.
  • Regeln sind Code. Wir halten sie in Git, laden sie in der CI und testen jede mit einem gezielt erstellten Ereignis, genau wie bei der Validierung für diesen Artikel. Eine Regel ohne Test ist eine Vermutung.

Timelines und Cases

Jeder Alarm öffnet sich in einer Timeline. Für Agentenvorfälle speichern wir ein Timeline-Template, gefiltert auf container.name (die Sandbox), das die OpenShell-Ereignisse der Sandbox, die Guardrail-Ereignisse und garak-Ergebnisse für dieselbe Anwendung sowie Argus-Alarme für den Host, auf dem sie lief, zusammenführt, sodass ein Analyst die letzten Aktionen des Agenten in der richtigen Reihenfolge sieht. Cases sammeln Alarme, Timelines, Notizen und Reaktionsmaßnahmen; wir verbinden sie über die Case-Connectoren von Elastic mit ServiceNow, damit Ticket und Case synchron bleiben, und der Response-Dienst (Abschnitt 12) schreibt jede automatisierte Maßnahme als Kommentar in den Case zurück.

8. Dynatrace

Viele Unternehmen setzen Dynatrace für Anwendungs- und Infrastruktur-Monitoring ein. Werden ihm die Sicherheitssignale gesendet, die für Service-Verantwortliche relevant sind, erscheint ein verweigerter Egress oder eine Guardrail-Spitze neben dem betroffenen Dienst, und Davis, die KI-Engine von Dynatrace, kann dies mit Änderungen im Verhalten dieses Dienstes in Beziehung setzen.

  • Endpunkt. Laut der OTLP-API-Dokumentation von Dynatrace lautet die Basis-URL für SaaS https://{your-environment-id}.live.dynatrace.com/api/v2/otlp (oder eine ActiveGate-Adresse), und der Exporter hängt /v1/traces, /v1/metrics und /v1/logs an. Die eigenen Metriken unseres Test-Collectors bestätigten, dass er an /api/v2/otlp/v1/logs sendete.
  • Protokoll. OTLP über HTTP ausschließlich mit binärem Protobuf: kein gRPC und kein JSON. Daher otlp_http im Gateway.
  • Authentifizierung. Ein Dynatrace-Plattform-Token in einem Authorization: Bearer-Header mit den Scopes openpipeline:logs:ingest, openpipeline:metrics:ingest und openpipeline:traces:ingest. Ältere Umgebungen mit klassischen Access Tokens sollten der Dynatrace-Dokumentation für ihren Token-Typ folgen.
  • Metrik-Temporalität. Nur Delta, wie oben erwähnt.

Was wir senden: OpenShell- und andere Ereignisse ab Schwere Medium, die ws.security.events-Zähler, die gescrapten OpenShell- und WAF-Metriken sowie Guardrail-Traces (mit deaktivierter Inhaltserfassung). Was wir in Dynatrace tun, gemäß dessen Dokumentation und nicht über eine hier erfundene API: Anomalieerkennung auf den Sicherheitszählern einrichten, damit Davis ihr normales Niveau pro Cluster lernt und bei einer anhaltenden Veränderung ein Problem meldet; die Sicherheitsereignisse in die Dashboards und Notebooks aufnehmen, die Service-Verantwortliche bereits nutzen; und, sofern die Dynatrace-Lizenz des Kunden dessen Sicherheitsfunktionen umfasst, die Records hoher Schwere über OpenPipeline in den Security-Event-Speicher von Dynatrace leiten, damit sie zusammen mit Schwachstellenbefunden analysiert werden können. OpenPipeline-Routing-Regeln haben wir für diesen Artikel nicht in einem echten Tenant verifiziert; daher beschreiben wir diesen Schritt ohne Konfiguration.

Dynatrace ist eine Zweitmeinung und eine Sicht für Service-Verantwortliche, kein zweites SIEM. Erkennung, Untersuchung und Cases bleiben in Elastic Security, sodass es genau einen Ort gibt, an dem ein Vorfall verantwortet wird.

9. Prometheus und Alertmanager

Prometheus ist der schnellste und günstigste Ort, um auf Zahlen zu alarmieren. Drei Sicherheitsanwendungsfälle sind von Natur aus numerisch, und die Daten für zwei davon (GPU-Auslastung aus DCGM und Netzwerk-Bytes aus node-exporter) liegen bereits aus dem UFM-Design im Speicher für Betriebsmetriken. Der dritte nutzt die Ereigniszähler, die das Security-Gateway erzeugt. Die zweite Regelgruppe überwacht die Sicherheitspipeline selbst.

# /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 }}"

Hinweise:

  • ws:gpu_util:ratio ist die Recording Rule aus dem UFM-Artikel, die die alten und neuen Metriknamen von dcgm-exporter überbrückt. Die Cryptojacking-Regel setzt voraus, dass dcgm-exporter genutzten GPUs pod (Kubernetes) oder hpc_job (Slurm) zuordnet. Ist die Job-Zuordnung nicht eingeschaltet, trifft die Regel auf jede ausgelastete GPU zu; prüfen Sie das also zuerst.
  • node_role ist das Label, das der UFM-Agent aus WS_NODE_ROLE setzt; verwenden Sie das Rollen-Label, das Ihre Flotte hat.
  • Die eigenen Metriknamen des Collectors haben im getesteten Build 0.165.0 ihr Suffix _total verloren (otelcol_exporter_send_failed_log_records); SiemExportFailing trifft daher auf beide Schreibweisen zu.
  • Regeln, die mit der Vorwoche oder dem Vortag vergleichen, benötigen so viel Historie, bevor sie aussagekräftig sind. Betreiben Sie sie in den ersten zwei Wochen über eine Route ohne Paging.

Unit-Tests für die beiden Regeln, die am wahrscheinlichsten bearbeitet werden, ausgeführt mit 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 sendet Sicherheitsalarme der Stufen high und critical an PagerDuty und an den Response-Dienst, alles andere an Tickets. Secrets stammen aus Dateien, niemals 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 hat keinen nativen ServiceNow-Receiver; der Webhook geht an eine kleine Bridge oder an die eigene Event-Integration von ServiceNow, je nachdem, was der Kunde betreibt.

10. Grafana-SOC-Dashboards

Grafana ist der gemeinsame Bildschirm für SOC-, Plattform- und KI-Teams, mit Prometheus und Elasticsearch als Datenquellen (und Loki nur, wenn ein Kunde eine Grafana-native Logsuche für Nicht-Sicherheitslogs wünscht; Sicherheitsereignisse bleiben in Elasticsearch). Ein Übersichts-Dashboard mit Drill-downs:

PanelTypAbfrage (Datenquelle)
Sicherheitsereignisse pro Minute nach Datensatz und ErgebnisGestapelte Zeitreihesum by (data_stream_dataset, event_outcome) (rate(ws_security_events_total[5m])) * 60 (Prometheus)
Agentenverweigerungen jetzt im Vergleich zu gesternZeitreihe mit Offsetsum(rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[5m])) und dasselbe mit offset 1d
Häufigste verweigerte ZieleBar GaugeTerms-Aggregation auf destination.domain mit event.action:Denied (Elasticsearch)
Sandboxes mit den meisten VerweigerungenTabelleTerms auf container.name, letzte Stunde (Elasticsearch)
Offene Sicherheitsalarme nach SchwereStatALERTS{team="soc", alertstate="firing"} gezählt nach severity (Prometheus); Elastic-Alarmzahlen aus dem Index .alerts-security.alerts-*
Ausgelastete GPUs ohne JobTabellews:gpu_util:ratio{pod="", hpc_job=""} > 0.3 (Prometheus)
Egress von Modell- und Storage-NodesZeitreihesum by (instance) (rate(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[5m]))
garak-Angriffserfolgsrate nach ProbeHeatmapgarak.fails / garak.total_evaluated nach garak.probe über CI-Läufe (Elasticsearch)
Guardrail-Blockierungen nach RailZeitreiheAnzahl nach rule.name in nemo.guardrails (Elasticsearch)
WAF-Blockierungen und -FehlerZeitreihesum by (host) (rate(waf_blocked[5m])) und waf_errors
Pipeline-ZustandStat-ZeileGateways aktiv, Exportfehler, OpenShell-OCSF-Verluste, Queue-Füllstand

Dashboards werden wie die Regeln aus Git bereitgestellt. Wir versehen jedes Panel mit einer Beschreibung, die angibt, wie der Normalzustand aussieht und welche Regel oder welches Runbook gilt, sodass ein neuer Analyst den Bildschirm vom ersten Tag an nutzen kann.

11. Erkennungsanwendungsfälle

Jeder Anwendungsfall verknüpft ein Signal mit einer Regel und einer geplanten Reaktion. Die Reaktionsstufen werden in Abschnitt 12 erläutert: auto bedeutet eine vorab genehmigte, umkehrbare Maßnahme; approve bedeutet einen Klick durch eine namentlich benannte freigebende Person; advise bedeutet, dass der Case eine Empfehlung gibt und Menschen handeln.

#AnwendungsfallSignalRegelReaktion
1Agenten-Egress zu einer nicht freigegebenen DomainOpenShell-Netzwerkverweigerungws-ai-001 (Elastic, unterdrückt pro Sandbox und Domain)Advise: die Quelle prüfen, die der Agent gelesen hat; bei bestätigter Injection Stopp der Sandbox freigeben
2Agent erreicht eine nie zuvor gesehene DomainOpenShell-Netzwerkerlaubnisws-ai-002 (New Terms, 14-tägige Historie)Advise: das Ziel bestätigen; eine zu weit gefasste Policy-Regel verschärfen
3Spitze bei Policy-VerweigerungenVerweigerungen pro Sandbox; clusterweite Ratews-ai-005 (Threshold); AgentPolicyDenialSurge (Prometheus)Auto: die Sandbox stoppen, wenn zusammen mit einem Finding; andernfalls approve
4SSRF- oder Metadaten-ZugriffsversuchVerweigerung mit resolves to always-blocked addressws-ai-003Approve: Sandbox stoppen, alle von ihr gehaltenen Zugangsdaten rotieren
5Sandbox-Credential missbrauchtOpenShell-Finding sandbox-authorization-boundaryws-ai-004 (critical)Auto: Sandbox stoppen, Pod unter Quarantäne stellen, seine Secrets widerrufen
6Jailbreak-Versuche gegen GuardrailsInput-Rail-Blockierungen pro Nutzerws-ai-006Approve: den Nutzer drosseln oder sperren; die Metadaten der Konversation prüfen
7garak-Regression in der CIAngriffserfolgsrate über 5 % für eine Probews-ai-007 (ES|QL)Auto: das Pipeline-Gate fehlschlagen lassen; den Modellverantwortlichen informieren
8DOCA-Argus-LaufzeitalarmArgus-ALERT mit HIGH oder CRITICALws-ai-008Approve: den Host isolieren (Sentry- oder BlueField-Kontrollen, wo vorhanden; andernfalls Cordon und Network Policy)
9GPU-CryptojackingGPU ausgelastet ohne Pod oder Slurm-Job; Ausführungen aus /tmpGpuBusyWithoutScheduledWork (Prometheus); ws-ai-014 (auditd)Approve: den Node leeren und den Prozess beenden; zuvor Beweise sichern
10Exfiltration von ModellgewichtenStündlicher Egress von Inferenz- oder Storage-Nodes über dem 3-Fachen der VorwocheUnusualEgressFromModelNodes (Prometheus)Approve: Egress für den Node blockieren; Registry- und Vault-Zugriffe prüfen
11Auffällige Anmeldung, dann privilegierte AgentenfreigabeOpsAPI-SSO-Anmeldung außerhalb Großbritanniens, Freigabe innerhalb von 30 Minutenws-ai-009 (EQL-Sequenz)Approve: Freigabe und Sitzungen widerrufen; mit dem Nutzer über einen anderen Kanal verifizieren
12Secret außerhalb des vereinbarten Zeitfensters gelesenwslvault-secret.read außerhalb von 07:00 bis 19:00 UTCws-ai-010 (ES|QL)Advise: mit dem Verantwortlichen klären; bei fehlender Erklärung rotieren
13Privilegierter Pod erstelltKubernetes-Audit, privilegierter Container in einer Pod-Spezifikationws-ai-011Approve: den Pod löschen; das RBAC der erstellenden Identität prüfen
14Fehlgeschlagene Confidential-Computing-AttestierungAttestierungsergebnis failurews-ai-012 (critical)Auto: Der Schlüsseldienst hat bereits abgelehnt; alarmieren und den Node aus dem Pool heraushalten
15Brute Force am Web-Edgewslproxy-WAF-Blockierungen pro Clientws-ai-013Auto: Die WAF blockiert bereits; nach Freigabe zur Edge-Sperrliste hinzufügen
16Sicherheitstelemetrie verlorenOpenShell-OCSF-Verluste; SIEM-Exportfehler; nur noch ein Gateway übrigOpenShellOcsfExportDropping, SiemExportFailing, SecurityGatewayRedundancyLostDas SOC alarmieren: Ein blinder Fleck ist ein Vorfall

Ein Beispiel in fünf Schritten: eine versteckte Anweisung in einer Webseite, OpenShell verweigert die Verbindung, Gateway und Elastic-Regel erkennen dies, ein vorab genehmigtes Playbook stoppt die Sandbox und stellt sie unter Quarantäne, und ein Analyst prüft und ergänzt eine garak-Probe; darunter die drei Automatisierungsstufen.

12. Reaktion und SOAR

Erkennung ohne Reaktion ist ein Bericht. Wir verknüpfen Reaktionen mit Alarmen über einen kleinen Response-Dienst (das Webhook-Ziel in Alertmanager und ein Elastic-Connector für Erkennungsregeln), der den Case öffnet oder aktualisiert, die Reaktionsstufe für die Regel prüft und dann entweder ein Playbook ausführt, um Freigabe bittet oder nur eine Empfehlung festhält.

Eindämmungsoptionen, von der engsten zur weitesten

  • Die Sandbox stoppen (OpenShell). openshell sandbox stop <name> stoppt einen Agenten und behält die Sandbox für die Untersuchung; openshell sandbox delete <name> entfernt sie, sobald die Beweise gesichert sind. Um eine einzelne Berechtigung zu entziehen, statt den Agenten zu stoppen: openshell policy update <name> --remove-rule <rule> --wait. Sichern Sie die OCSF-Dateien des Supervisors vor dem Löschen: Unter Kubernetes liegen sie in emptyDir des Supervisor-Pods und verschwinden mit ihm.
  • Den Pod unter Quarantäne stellen (Kubernetes). Eine namespaceweite NetworkPolicy isoliert jeden Pod mit einem Quarantäne-Label; das Playbook fügt nur das Label hinzu, was schnell, umkehrbar und leicht zu auditieren ist. Ihr CNI muss NetworkPolicy durchsetzen, wie es auch OpenShells eigene Kubernetes-Empfehlungen verlangen.
  • Secrets widerrufen. Widerrufen Sie die Leases der Agentenidentität im Schlüsseldienst, damit alles, was sie exfiltriert hat, nicht mehr funktioniert. Mit wslvault hat der Agent von vornherein nie langlebige Schlüssel besessen, was begrenzt, was überhaupt zu widerrufen ist.
  • Den Host isolieren (BlueField und Sentry). Wo Sentry auf BlueField-4 eingesetzt ist, stellt NVIDIAs Design einen Agenten innerhalb von Millisekunden an der DPU unter Quarantäne, unabhängig vom Host. Wo nicht, besteht der Rückfall darin, den Node abzusperren (Cordon) und zu leeren (Drain) und eine Netzwerksperre auf Hostebene anzuwenden. DPU-seitige Aktionen steuern wir nur über die Schnittstellen, die NVIDIA für das eingesetzte Release dokumentiert; undokumentierte skripten wir nicht.
  • An die XDR-Plattform eskalieren. Wo DOCA Argus das XDR eines Kunden speist, bleiben die eigenen Reaktionsmaßnahmen dieser Plattform verfügbar, und der Case hält fest, welches Werkzeug gehandelt hat.
# 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

Freigabeschritte über OpsAPI Single Sign-on

Jede nicht vorab genehmigte Reaktion durchläuft einen Freigabeschritt in OpsAPI: Die freigebende Person meldet sich per Single Sign-on (und Multi-Faktor-Authentifizierung) an, sieht die Case-Zusammenfassung und genehmigt oder lehnt ab. Die Freigabe ist selbst ein Sicherheitsereignis (opsapi.sso, agent.approval.granted und verwandte Ereignisse); deshalb kann Anwendungsfall 11 auf eine verdächtige Anmeldung mit anschließender Freigabe achten. Wir konfigurieren es so, dass Freigebende ihre eigenen Anträge nicht genehmigen können und Änderungen an der Konfiguration der Sicherheitspipeline selbst zwei Personen erfordern. Dasselbe Muster für Agentenberechtigungen beschreibt unser Artikel zur Sicherheit agentischer KI.

ServiceNow und PagerDuty

Alarme der Stufen high und critical werden über PagerDuty gemeldet; jeder Alarm öffnet oder aktualisiert einen ServiceNow-Incident (oder Security Incident, falls der Kunde dieses Modul betreibt), verknüpft mit dem Elastic-Case. Die Auflösung fließt zurück: Wird der Case geschlossen, wird der Incident gelöst und der PagerDuty-Alarm aufgehoben. Wir vereinbaren die Automatisierungsstufe für jede Regel schriftlich mit dem Kunden, überprüfen sie vierteljährlich und stufen ein Playbook erst dann auf auto hoch, wenn es sich auf der Stufe approve fehlerfrei bewährt hat.

13. Compliance-Zuordnung

Monitoring ist der Weg, um nachzuweisen, dass Kontrollen funktionieren. Die folgende Zuordnung ist eine allgemeine Orientierung, keine Rechtsberatung; die endgültigen Entscheidungen treffen Ihr Datenschutzbeauftragter und Ihre Compliance-Verantwortlichen.

RegelwerkWas es allgemein erwartetWie dieses Design hilft
UK GDPRAngemessene Sicherheit der Verarbeitung (Artikel 32), Integrität und Vertraulichkeit (Artikel 5(1)(f)), Datenschutz durch Technikgestaltung (Artikel 25), Meldung von Verletzungen des Schutzes personenbezogener Daten an das ICO unverzüglich und möglichst binnen 72 Stunden (Artikel 33) sowie Folgenabschätzungen für Verarbeitungen mit hohem Risiko (Artikel 35)Erkennungen und Timelines liefern die Fakten, die eine Bewertung einer Datenschutzverletzung innerhalb der Frist benötigt; Schwärzung am Gateway und deaktivierte Inhaltserfassung halten personenbezogene Daten in Logs auf ein Minimum; die Aufbewahrung ist pro Datensatz festgelegt und dokumentiert. Sicherheitslogs enthalten selbst personenbezogene Daten (Nutzer-IDs, IP-Adressen); halten Sie daher die Rechtsgrundlage fest (meist berechtigte Interessen), beschränken Sie den Zugriff und beziehen Sie das SIEM in Ihre DSFA ein
NIS-artige Pflichten (die britischen NIS Regulations, die EU-Richtlinie NIS2 für Tätigkeiten in der EU und geplante britische Reformen)Risikomanagementmaßnahmen, Vorfallbehandlung, Betriebskontinuität, Sicherheit der Lieferkette und fristgerechte Meldung erheblicher Vorfälle an die zuständige Behörde; Rechenzentrums- und Cloud-Dienste fallen in einigen Regelwerken in den AnwendungsbereichEine dokumentierte Erkennungs- und Reaktionsfähigkeit mit Betriebsnachweisen; Lieferkettensignale (garak in der CI, Image- und Paket-Policy); durch Case-Records gestützte Meldefristen. Ob eine bestimmte Organisation in den Anwendungsbereich fällt, ist eine Rechtsfrage
ISO/IEC 27001:2022 Anhang A8.15 Protokollierung, 8.16 Überwachungstätigkeiten, 8.17 Uhrensynchronisation, 5.24 bis 5.28 Vorfallmanagement einschließlich Sammlung von Beweismaterial, 8.12 Verhinderung von Datenlecks, 8.8 Handhabung technischer SchwachstellenZentrale, geschützte, aufbewahrte Logs (8.15); Regeln und Dashboards mit Verantwortlichen (8.16); per NTP synchronisierte Zeitstempel aus dem Quellereignis (8.17); Cases, Timelines und gesicherte Originale (5.24 bis 5.28); Egress- und Output-Rail-Kontrollen (8.12); garak- und Image-Prüfungen als Schwachstellenmanagement für KI (8.8)
Cyber EssentialsFünf technische Kontrollen: Firewalls, sichere Konfiguration, Management von Sicherheitsupdates, Benutzerzugriffskontrolle und Malware-SchutzCyber Essentials ist eine Grundabsicherung und verlangt kein SIEM, aber dieselbe Telemetrie zeigt, dass die Kontrollen funktionieren: WAF und Egress-Policy (Firewalls), Erkennungen privilegierter Pods und Konfigurationsänderungen (sichere Konfiguration), SSO- und Freigabelogs (Zugriffskontrolle) sowie Argus- und auditd-Erkennungen (Malware-Schutz)

14. Aufbewahrung, Kosten und Kardinalität

Sicherheitstelemetrie wächst unbemerkt, bis die Rechnung kommt. Vier Regeln halten sie planbar:

  1. Nach Datensatz aufbewahren, nicht global. Ein typischer Ausgangspunkt: OpenShell, SSO, Vault, Kubernetes-Audit, Attestierung und Argus 13 Monate; WAF-Entscheidungen 90 Tage in Elasticsearch, bei Bedarf mit längerer Archivierung; garak-Evaluierungs-Records für die Lebensdauer des Modells; erlaubte (nicht verweigerte) OpenShell-Netzwerkereignisse 30 bis 90 Tage, weil sie vor allem für Baselines nützlich sind. Ältere Daten können in Searchable Snapshots oder Object Storage verschoben werden, sofern die Elastic-Lizenz dies erlaubt.
  2. Anhand der Ereignisse pro Agent dimensionieren. Als Rechenbeispiel, nicht als Messung: 200 Agenten, die durchschnittlich 2.000 OCSF-Ereignisse pro Stunde mit je etwa 1,2 KB erzeugen, ergeben rund 11,5 GB pro Tag vor Replikaten und Kompression. Erlaubte Netzwerkereignisse dominieren; Verweigerungen und Findings sind ein kleiner Bruchteil. Messen Sie Ihre eigene Rate in einem Pilotprojekt, bevor Sie dimensionieren.
  3. Metriken bleiben bei geringer Kardinalität. Der Ereigniszähler hat drei Labels mit jeweils einer Handvoll Werte, plus site und cluster. Sandbox-IDs, Pod-Namen, Nutzer-IDs und Domains sind unbegrenzt und gehören nach Elasticsearch, niemals in Prometheus-Labels. Ein einziges falsch gewähltes Label (eine Sandbox-ID auf einem stark ausgelasteten Cluster) kann Tausende neuer Serien pro Tag hinzufügen.
  4. Jedem Backend nur senden, was es nutzt. Jedes Ereignis geht einmal an Elasticsearch; Dynatrace erhält Medium und höher; Prometheus erhält Zählwerte. Traces bleiben in der Anwendung gesampelt. Alles in jedes Werkzeug zu duplizieren, ist der häufigste Kostenfehler, den wir sehen.

15. Hochverfügbarkeit der Sicherheitspipeline

Ein Angreifer, der das SIEM blind machen kann, hat die halbe Schlacht gewonnen; die Pipeline ist daher so gebaut, dass sie bei Ausfällen weiterarbeitet und laut wird, wenn sie das nicht kann.

  • Gateways: mindestens zwei pro Standort hinter einem Load Balancer oder DNS-Namen, zustandslos abgesehen von ihren persistenten Queues auf lokaler Festplatte. Agenten und OpenShell wiederholen Sendungen an das Gateway, das antwortet; ein Gateway-Neustart verliert nichts aus der Queue.
  • At-least-once Ende-zu-Ende: persistente Sende-Queues auf Agenten und Gateways, OpenShells eigene Wiederholungen und Dokument-IDs aus Ereignis-IDs, sodass Wiederholungen nie Duplikate erzeugen.
  • Elasticsearch: mindestens drei master-fähige Nodes über Fehlerdomänen hinweg, ein Replikat für jeden Sicherheitsindex, Snapshots in einen separaten Speicher und eine Schreibrolle für die Gateways, die keine Daten löschen kann.
  • Prometheus und Alertmanager: zwei Prometheus-Replikate (in Mimir dedupliziert, wie im UFM-Design) und ein Alertmanager-Cluster mit drei Nodes.
  • Selbstüberwachung: die Pipeline-Zustandsregeln aus Abschnitt 9 plus ein Heartbeat: Eine synthetische OpenShell-Verweigerung, die alle fünf Minuten in einer Canary-Sandbox erzeugt wird, muss in Elasticsearch ankommen, sonst löst eine Regel einen Alarm aus. Lücken-Records von OpenShell (openshell.ocsf.gap) sind ebenfalls durchsuchbare Ereignisse.
  • Funktionstrennung: Das Sicherheitsteam verantwortet die Gateway-Konfiguration und das SIEM; Änderungen werden von zwei Personen geprüft; das Plattformteam kann den Pipeline-Zustand sehen, aber nicht ändern, was erfasst wird.
  • Uhren: Jede Quelle und jedes Gateway ist mit denselben Zeitquellen synchronisiert, und @timestamp wird aus dem Quellereignis übernommen, nicht aus dem Ingest-Zeitpunkt, damit Sequenzen über Quellen hinweg übereinstimmen.

16. Nachweis der Funktion: Übungen bei der Übergabe

Wir übergeben keine Erkennung, die wir nicht haben auslösen sehen. Im Beisein des Kundenteams führen wir durch und protokollieren:

  1. Ein Agent in einer Test-Sandbox liest eine Seite mit einer platzierten Anweisung und versucht, auf eine Paste-Site hochzuladen: eine OpenShell-Verweigerung, ein unterdrückter Elastic-Alarm, eine Timeline, die das Lesen und den Versuch zeigt.
  2. Eine Test-Sandbox ruft mit ihrem eigenen Credential die API einer anderen Sandbox auf: ein kritisches Finding, der automatische Stopp, das gesetzte Quarantäne-Label, der mit jeder Maßnahme aktualisierte Case.
  3. Eine bekanntermaßen schädliche Probe wird einem CI-Branch hinzugefügt: Die garak-Angriffserfolgsrate überschreitet 5 %, und das Pipeline-Gate schlägt fehl.
  4. Ein Benchmark-Job läuft auf einer GPU ohne zugeordneten Scheduler-Job: Der Cryptojacking-Alarm löst innerhalb seines 15-Minuten-Fensters aus.
  5. Ein Test-Pod mit privilegiertem Container wird erstellt: Die Kubernetes-Regel löst aus, und das Playbook bittet um Freigabe.
  6. Ein Security-Gateway wird gestoppt: keine verlorenen Ereignisse, ein Redundanzalarm, Wiederherstellung bei seiner Rückkehr.
  7. Das SIEM wird 15 Minuten lang von den Gateways abgeschnitten: Der Alarm für Exportfehler löst aus, die Queues füllen sich und leeren sich anschließend, und der Heartbeat zeigt keine Lücke.

17. Wie Workstation dies umsetzt und betreibt

Sieben Phasen: Bewertung, Design, Aufbau, Erkennung, Feinabstimmung, Übergabe und Betrieb, jeweils mit einem Ergebnis: Bedrohungs- und Kontrollkarte, unterzeichnetes Design, funktionierende Pipeline, Regelbibliothek mit Tests, vereinbartes Alarmbudget, bestandene Übungen und Monatsbericht.

  1. Bewertung. Bestandsaufnahme der Umgebung, der Agenten und dessen, worauf sie zugreifen können, der Daten- und Modell-Assets sowie der vorhandenen SIEM-, Monitoring- und Reaktionswerkzeuge. Ergebnis: eine Bedrohungs- und Kontrollkarte wie in Abschnitt 2, speziell für Sie.
  2. Architektur. Auswahl von Quellen, Schema, Backends, Aufbewahrung, HA und der Position zu UK GDPR. Ergebnis: ein unterzeichnetes Design.
  3. Aufbau. Collector-Agenten und Security-Gateways, OCSF-Export von OpenShell, Ingest-Pipelines, Index-Templates, Lifecycle-Policies und Dashboards, alles aus versionskontrollierter Konfiguration in Ihren Repositories.
  4. Detection Engineering. Regeln, Alarme und Playbooks für Ihre Anwendungsfälle, jeweils mit einem Testereignis und einem Verantwortlichen.
  5. Feinabstimmung. Zwei bis vier Wochen stiller Betrieb, Rauschen reduzieren, Schwellenwerte und Unterdrückung festlegen und ein Alarmbudget vereinbaren, das das Team dauerhaft bewältigen kann.
  6. Übergabe. Die Übungen aus Abschnitt 16, Runbooks sowie Schulungen für Analysten und Plattformingenieure.
  7. Managed Monitoring Support. Laufende Monitoring-Unterstützung an der Seite Ihres Teams (oder als Abdeckung außerhalb der Geschäftszeiten): Regelaktualisierungen, wenn sich NVIDIAs Produkte und die Bedrohungslage ändern, Upgrades der Pipeline, regelmäßige Threat-Hunting-Reviews und ein monatlicher Bericht zu Erkennungen, Reaktionszeiten, Rauschen und Abdeckung. Die genauen Service-Levels werden pro Kunde vereinbart.

NVIDIA-Partner: Engineering, Software und Personal

Workstation ist NVIDIA-Partner; neben der Hardware stellen wir daher Engineering, Software und Personal bereit, um KI-Rechenzentren durchgängig aufzubauen und zu betreiben, einschließlich des Sicherheitsmonitorings rund um sie. Wir spezifizieren und liefern die Plattform, installieren und konfigurieren sie, bauen die hier beschriebene Observability- und SIEM-Integration und stellen Ingenieure, die anschließend innerhalb Ihres Change-Prozesses arbeiten.

  • DPUs und Netzwerk: NVIDIA-BlueField-DPUs (einschließlich der BlueField-3 B3220, der Mindestgeneration für DOCA Argus), ConnectX-8 SuperNICs und die Spectrum-X-Ethernet-Plattform.
  • GPU-Systeme: DGX B300, HGX-B300-Server, DGX SuperPOD und Vera Rubin NVL72, die Systemklasse in NVIDIAs OpenShell Reference Architecture für Inferenz.
  • Software: Abonnements für NVIDIA AI Enterprise sowie Einrichtung und Support für OpenShell, NeMo Guardrails, garak und die offenen Komponenten in diesem Artikel.

Um Ihre Umgebung zu besprechen, fragen Sie unseren AI Sales Engineer; er leitet Sie an den richtigen Ingenieur weiter.

18. Quellen und Hinweise zur Verifizierung

  • Überblick über NVIDIAs Portfolio: die offizielle NVIDIA-Seite zu Cybersecurity-KI-Lösungen, gelesen im November 2026, zu OpenShell und seiner Referenzarchitektur, Sentry on BlueField, BlueField und DOCA, DOCA Argus, DOCA Vault, Confidential Computing, Nemotron und Nemotron Safety, NeMo, garak und NemoClaw. Alle Formulierungen hier sind unsere eigene Zusammenfassung.
  • OpenShell: das README des GitHub-Repositorys und seine Dokumentationsseiten zu Sandbox-Logging, OCSF-JSON-Export, Gateway-Konfiguration (OCSF-JSONL- und OTLP-Export), Gateway-Metriken, Sandboxes und Policies. OCSF-Klassen, Grund-Strings, das Finding sandbox-authorization-boundary, OTLP-Attribute, Metriknamen und CLI-Befehle sind aus diesen Seiten zitiert. Der Beispiel-OCSF-Record in unserem Test wurde aus dem Beispiel der Dokumentation erstellt.
  • DOCA Argus: NVIDIAs DOCA-Argus-Serviceleitfaden zu Anforderungen, Nachrichtentypen, Schweregraden und Telemetrieschlüsseln. Nicht auf Hardware getestet; Feldpfade sollten anhand einer echten Nachricht aus Ihrem Release geprüft werden.
  • Sentry, DOCA Vault und die OpenShell Reference Architecture: ausschließlich anhand der öffentlichen NVIDIA-Seite beschrieben. Schnittstellen, Formate oder Befehle dafür werden hier nicht angegeben.
  • Confidential Computing: NVIDIAs Seite und das README von nvTrust. Das Format des Attestierungsereignisses ist eine Konvention von Workstation.
  • NeMo Guardrails: das README des Repositorys (Rail-Typen, Release 0.24.1) und seine Referenz zur Tracing-Konfiguration. Die Konvention für Blockierungsereignisse stammt von Workstation.
  • garak: das README des Repositorys, die CLI-Optionen und der Quellcode des Evaluators für die Felder der Eval-Records. Die Probe-Auswahl im CI-Beispiel dient der Veranschaulichung.
  • Morpheus: README, Beispiele und Release-Liste des Repositorys (zum Zeitpunkt der Erstellung neuester Tag 25.06, Juli 2025).
  • Dynatrace: die Dokumentation von Dynatrace zur OTLP-API und zur Collector-Konfiguration für Endpunkt, Protokoll, Token-Scopes und Delta-Temporalität. Nicht gegen einen echten Tenant getestet: Der Exporter wurde validiert und lief, aber seine Anfragen gingen an eine Platzhalter-Umgebung. Davis-Anomalieerkennung und Routing von Sicherheitsereignissen sind gemäß der Dokumentation von Dynatrace allgemein beschrieben.
  • OpenTelemetry Collector: beide Konfigurationen mit otelcol-contrib validate in otel/opentelemetry-collector-contrib:0.165.0 validiert und anschließend betrieben: Test-Records für OCSF, Argus, Appliances, Guardrails, auditd, Kubernetes-Audit und garak wurden über einen Agenten und das Gateway in Elasticsearch und Prometheus gesendet, und die resultierenden Dokumente und Serien wurden geprüft. Endpunkte und Hostnamen sind Platzhalter.
  • Elastic: Ingest-Pipeline, Index-Template und Lifecycle-Policy auf Elasticsearch 9.2.0 angewendet; alle vierzehn Regeln über die Detection-Engine-API von Kibana 9.2.0 angelegt, erfolgreich ausgeführt und mit den erwarteten Alarmen (dreizehn ausgelöst; die Regel für Zugriffe außerhalb der Geschäftszeiten korrekterweise nicht, weil ihr Testereignis innerhalb der Geschäftszeiten lag). Timeline-Templates, Case-Connectoren und Überschneidungen mit vorgefertigten Regeln wurden nicht getestet.
  • Prometheus und Alertmanager: Regeln mit promtool check rules validiert und mit promtool test rules per Unit-Test geprüft, Prometheus 3.12.0; Alertmanager-Konfiguration mit amtool check-config validiert, Alertmanager 0.34.2. DCGM-Metriknamen folgen dcgm-exporter 4.9.0 über die Recording Rules ws: aus dem UFM-Artikel.
  • Kubernetes: die Quarantäne-NetworkPolicy mit kubeconform 0.8.0 im Strict-Modus validiert. Nicht gegen ein echtes CNI getestet.
  • Konventionen von Workstation: Datensatznamen, Regel-IDs, die Metrik ws.security.events, Aktionsnamen für wslvault und OpsAPI, das Guardrail-Blockierungsereignis und das Attestierungsereignis stammen von uns.
  • Veranschaulichende Zahlen: Ereignisraten, Volumen, Schwellenwerte und Zeitangaben sind Rechenbeispiele, keine Messungen aus einem Kundensystem.
  • Compliance: nur allgemeine Orientierung, keine Rechtsberatung.

Hinweis zu Rechten: NVIDIA, das 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 und NVIDIA AI Enterprise sind Marken und/oder eingetragene Marken der NVIDIA Corporation in den Vereinigten Staaten und anderen Ländern. NVIDIA-Produkte und -Technologien können durch Patente und andere Rechte des geistigen Eigentums der NVIDIA Corporation geschützt sein; alle diese Rechte werden anerkannt und bleiben ihren Inhabern vorbehalten. Produktinformationen sind in unseren eigenen Worten aus öffentlichem Material von NVIDIA zusammengefasst; maßgebliche Quelle sind die Website und die Dokumentation von NVIDIA. garak ist ein von NVIDIA gepflegtes Open-Source-Projekt. Elastic, Elasticsearch, Kibana, Logstash, Elastic Security, Dynatrace, Davis, Prometheus, Alertmanager, Grafana, Loki, OpenTelemetry, Kubernetes, ServiceNow, PagerDuty, MITRE ATT&CK, Fluent Bit, Vector und Slurm sind Marken oder eingetragene Marken ihrer jeweiligen Inhaber, und andere Namen können Marken ihrer jeweiligen Inhaber sein. Eine Billigung durch eines dieser Unternehmen ist damit nicht verbunden. Die eigenen Konfigurationen, Regeln, Diagramme und Texte von Workstation sind © Workstation.

Diesen Artikel teilen

Mehr zu Technology

Laptops für KI-Entwickler: LLMs lokal unter Linux mit GPUs mit 16 GB und 24 GB betreiben (Leitfaden 2026)

Laptops für KI-Entwickler: LLMs lokal unter Linux mit GPUs mit 16 GB und 24 GB betreiben (Leitfaden 2026)

Was auf eine RTX 5080 oder RTX 5090 Laptop GPU passt, die Speicherrechnung, die lohnenden offenen Modelle, die Einrichtung von Ubuntu 26.04 mit dem NVIDIA-Stack, Ollama, llama.cpp und vLLM, Coding-Assistenten, LoRA-Fine-Tuning, Sicherheit und wann Arbeit auf einen Server gehört

Weiterlesen
ML- und LLM-Systeme testen, deren Korrektheit sich nicht beweisen lässt: ein Python-Evidenz-Kit

ML- und LLM-Systeme testen, deren Korrektheit sich nicht beweisen lässt: ein Python-Evidenz-Kit

Evidenz statt Beweise, in etwa 400 Zeilen Python mit echter Ausgabe: Slice-Metriken mit Bootstrap-Intervallen und einem Pass/Fail-Vertrag, Property- und metamorphe Tests mit Hypothesis, Kalibrierung und Conformal Prediction, Pydantic-Verträge und Regressionsevaluierungen für LLM-Ausgaben, Drift-Prüfungen, ein CI-Gate und die exakte Verifikation eines kleinen neuronalen Netzes

Weiterlesen
TorchCurves in der Praxis: lernbare B-Spline- und Legendre-Kurven in PyTorch

TorchCurves in der Praxis: lernbare B-Spline- und Legendre-Kurven in PyTorch

torchcurves installieren, eine Kurve anpassen und dimensionieren, B-Spline oder Legendre und die Eingabeabbildung wählen, eine monotone Kalibrierungskurve und ein additives Modell auf tabellarischen Daten bauen, mit SciPy, scikit-learn, einem KAN und einem MLP vergleichen, Koeffizienten nach JSON exportieren, testen und in der Produktion betreiben, mit echten Ausgaben

Weiterlesen