Seminar open-appsec Intensivseminar – Administration, Kubernetes und DevSecOps

Das Intensivseminar bündelt das vollständige open-appsec-Seminarportfolio in einer zusammenhängenden Gesamtausbildung. Von Architektur und Installation über Kubernetes, Policies, maschinelles Lernen, API-Schutz und Monitoring bis zu GitOps und Troubleshooting wird eine produktionsnahe Laborumgebung schrittweise aufgebaut. Die abschließende Gesamtübung verbindet technische Konfiguration, Sicherheitsfreigabe und Betriebsübergabe.

Inhaltsverzeichnis

1. Seminarprofil
2. Lernziele
3. Zielgruppe
4. Voraussetzungen
5. Seminarinhalte
6. Praktische Übungen
7. Methodik und Unterlagen

Seminarprofil

Die Inhalte der Fachseminare werden verdichtet, ohne die zentralen Betriebsentscheidungen auszulassen. Der Schwerpunkt liegt auf einem durchgängigen System: Reverse Proxy oder API Gateway, open-appsec-Agent, lokale beziehungsweise zentrale Verwaltung, Kubernetes-Variante, Schutzrichtlinien, API-Kontrollen, Logs, Metriken und automatisierte Änderungen.

Lernziele

• Gesamtarchitektur und Bedrohungsmodell entwerfen.
• Linux-, Docker- und Kubernetes-Bereitstellungen fachlich auswählen und praktisch betreiben.
• Helm, CRDs und lokale Policy-Dateien sicher einsetzen.
• Assets, Practices, Lernphasen, Tuning und Exceptions beherrschen.
• API-Schema, Quellidentität, Rate Limiting und Zusatzmodule integrieren.
• Logging, SIEM, Metriken und Störungsdiagnose standardisieren.
• Konfiguration über GitOps und CI/CD kontrolliert ausrollen.
• Pilotbetrieb bis zur dokumentierten Betriebsfreigabe durchführen.

Zielgruppe

Geeignet für erfahrene System- und Kubernetes-Administration, Security Engineering, DevOps, DevSecOps, Plattformbetrieb, SOC-Engineering sowie technische Verantwortliche, die open-appsec ganzheitlich einführen oder übernehmen.

Voraussetzungen

Erforderlich sind praktische Linux- und Containerkenntnisse, HTTP/HTTPS, Reverse Proxy, YAML und Git. Kubernetes-Grundkenntnisse einschließlich kubectl, Services und Ingress werden vorausgesetzt. API- und OpenAPI-Grundkenntnisse sind hilfreich.

Seminarinhalte

1. Architektur, Bedrohungsmodell und Einführungsplanung

Web- und API-Datenflüsse werden inventarisiert, Integrationspunkte ausgewählt und Schutzbereiche priorisiert. Agent, Attachment, Management, Lernpersistenz und Betriebsverantwortung werden zu einer Zielarchitektur verbunden.

1. exponierte Anwendungen und APIs erfassen.
2. Proxy-, Ingress- und Gateway-Pfade dokumentieren.
3. Schutzbedarf und Verfügbarkeitsziel klassifizieren.
4. lokales oder zentrales Managementmodell wählen.
5. Pilotumfang, Abnahmekriterien und Rollback festlegen.

2. Linux- und Docker-Bereitstellung

Installation, Attachment-Anbindung, Persistenz, Rechte, Netzwerke, Logging, Healthchecks und Upgrade werden in einer Referenzumgebung umgesetzt. NGINX, Kong, APISIX und Envoy werden als Integrationsmuster verglichen.

1. Voraussetzungen prüfen und Konfiguration sichern.
2. Agent und Attachment bereitstellen.
3. Proxy- oder Gateway-Route mit Testbackend verbinden.
4. Policy und Logziel initialisieren.
5. Datenpfad und Ereigniserzeugung nachweisen.
6. Upgrade und Rückfall testen.

3. Kubernetes, Helm und CRDs

Eine Kubernetes-Bereitstellung wird mit Helm geplant. Policies, Practices, Exceptions, Log Trigger, Custom Responses, Source Identifiers und Trusted Sources werden als Custom Resources aufgebaut. Cluster- und Namespace-Scope, Persistenz, RBAC und GitOps werden berücksichtigt.

1. Cluster und Ingress- beziehungsweise Gateway-Stack prüfen.
2. versionierte Values-Datei erstellen.
3. Chart, CRDs und Workloads installieren.
4. geschützte Anwendung veröffentlichen.
5. Custom Resources anwenden und Policy-Load verifizieren.
6. Rollout und Rollback durchführen.

4. Richtlinien, Machine Learning und Tuning

Asset-Regeln werden exakt nach Host, Port und Pfad modelliert. Quellidentität, Lernfortschritt, Konfidenz und Tuning-Vorschläge steuern den Übergang von Detect/Learn zu Prevent/Learn. Ausnahmen werden minimal und überprüfbar gestaltet.

1. Anwendungsspezifische Regeln und Default-Verhalten trennen.
2. repräsentativen Lernverkehr sicherstellen.
3. Ereignisse und Tuning-Vorschläge analysieren.
4. legitimen Sonderfall reproduzieren.
5. eng begrenzte Exception mit Gegenprobe erstellen.
6. Prävention gestuft aktivieren und überwachen.

5. API-Sicherheit und zusätzliche Engines

API-Inventar, OpenAPI-Schema, JWT- oder Header-basierte Quellidentität, Rate Limiting und Bot-Szenarien werden praktisch behandelt. Snort, IPS, Datei-Sicherheit und DLP werden nach Edition, Datenfluss und Testbarkeit eingeordnet.

1. API-Endpunkte und Methoden inventarisieren.
2. Schema oder Negativtestbasis versionieren.
3. gültige und ungültige Requests prüfen.
4. Rate-Limit-Regel anhand gemessener Last dimensionieren.
5. Zusatzmodul mit eindeutigem Erfolgskriterium integrieren.

6. Logging, Monitoring und SIEM

Log Trigger bestimmen Ereignisse und Detailtiefe. Agent-Log, Standardausgabe, Syslog, CEF, Cloudziel und Kubernetes-Service werden bewertet. Metriken und Prometheus ergänzen den technischen Zustand. Datenschutz und Aufbewahrung werden in das Design einbezogen.

7. Troubleshooting und Ausfallszenarien

Störungen werden über Client, Proxy oder Gateway, Attachment, Agent, Policy und Backend eingegrenzt. Behandelt werden fehlende Transaktionen, Policy-Load, 413-Antworten, Timeout, Latenz, Registrierung und fehlerhafte Upgrades.

1. Symptom und betroffenen Datenpfad exakt erfassen.
2. Logs und Status jeder Schicht vergleichen.
3. kleinstmögliche Ursache reproduzieren.
4. Korrektur in Teststufe anwenden.
5. Positiv-, Negativ- und Rückfalltest durchführen.
6. Runbook und Präventionsmaßnahme aktualisieren.

8. DevSecOps, GitOps und kontrollierter Rollout

Policy-Dateien, CRDs, Helm-Values und Tests werden gemeinsam versioniert. Pipelines prüfen Syntax, Schema, Referenzen und organisatorische Sicherheitsregeln. Rollouts erfolgen gestuft; Drift und Rollback bleiben nachvollziehbar.

1. Repository-Struktur und Ownership definieren.
2. statische Validierung und Security-Gates einrichten.
3. Positiv- und Angriffstests automatisieren.
4. Canary- oder Detect-first-Rollout anwenden.
5. Istzustand, Commit und Freigabe verknüpfen.
6. Rollback auf geprüfte Version ausführen.

9. Gesamtübung: Pilot bis Betriebsfreigabe

Eine neue Anwendung wird vollständig aufgenommen, geschützt, getestet, überwacht und in den Betrieb übergeben. Die Übung verlangt technische Nachweise, Policy-Entscheidungen, Runbook, Rollback und Freigabedokumentation.

Praktische Übungen

1. Zielarchitektur und Einführungsplan erstellen.
2. Linux- oder Docker-Referenzsystem aufbauen und prüfen.
3. Kubernetes-Bereitstellung mit Helm und CRDs ergänzen.
4. Assets, Policies, Lernbetrieb und Exception-Review durchführen.
5. API-Schema- oder Rate-Limit-Schutz testen.
6. Logs an Analyseziel übertragen und Metrikalarme definieren.
7. vorgegebenen Betriebsfehler anhand des Diagnosebaums beheben.
8. Änderung über Git, Pipeline, Canary und Rollback steuern.
9. Gesamtübung mit Abnahme- und Betriebsübergabe abschließen.

Methodik und Unterlagen

Das Seminar arbeitet mit einer durchgängigen Laborlandschaft und aufeinander aufbauenden Aufgaben. Die Unterlagen enthalten Architektur- und Einführungschecklisten, Installationsmuster, CRD- und Policy-Beispiele, Testkatalog, Monitoringdesign, Troubleshooting-Runbooks und GitOps-Referenzprozess.