Next:
Impressum
openshift
1
Impressum
2
Ziele und Erwartungen der Teilnehmenden
2.1
Kernziel der Schulung
2.2
Wichtige Einordnung: Der Einstieg in eine umfangreiche Welt
2.3
Fokus: Breite statt Tiefe
2.4
Was Sie nach der Schulung erreicht haben werden
2.5
Bewusste Abgrenzungen - Was definitiv nicht erreicht wird
2.6
Unser gemeinsamer Ausgangspunkt
3
Ablauf und didaktisches Konzept
3.1
Praxisfokus ohne Infrastrukturballast
3.2
Reduktion auf das Wesentliche: Single-Node statt Produktionscluster
3.3
Was Sie praktisch erleben
3.4
Theoretische Fundierung komplexer Themen
3.5
Replizierbarkeit als didaktisches Prinzip
3.6
Strukturierter, interaktiver Lernprozess
3.7
Realistische Grenzen des Schulungssetups
3.8
Ihr konkreter Nutzen
4
Was ist OpenShift?
4.1
OpenShift in einem Satz
4.2
Was macht OpenShift anders?
4.2.1
Von Kubernetes zu OpenShift
4.2.2
Die drei Säulen von OpenShift
4.3
Wie funktioniert OpenShift?
4.3.1
Der OpenShift-Ansatz
4.3.2
Kernkomponenten
4.4
Sicherheit von Grund auf
4.5
OpenShift-Varianten
4.5.1
OpenShift Container Platform (OCP)
4.5.2
Red Hat OpenShift Service on AWS (ROSA)
4.5.3
Azure Red Hat OpenShift
4.5.4
OpenShift Online
4.5.5
OpenShift Local (ehemals CodeReady Containers)
4.6
Integration in die IT-Landschaft
4.7
Für wen ist OpenShift?
5
OpenShift vs. Kubernetes
5.1
Die Beziehung verstehen
5.1.1
Kubernetes: Das Fundament
5.1.2
OpenShift: Das komplette Paket
5.2
Was ist identisch?
5.3
Die wichtigsten Unterschiede
5.3.1
Benutzerfreundlichkeit
5.3.2
Sicherheit von Anfang an
5.3.3
Developer Experience
5.3.4
Betrieb und Monitoring
5.3.5
Konzepte und Terminologie
5.4
Wann welche Lösung?
5.4.1
Kubernetes ist die richtige Wahl
5.4.2
OpenShift macht mehr Sinn
5.5
Die Kostenfrage
5.6
Migration zwischen den Systemen
5.7
Fazit: Ergänzung statt Konkurrenz
6
Architekturüberblick
6.1
Das große Bild verstehen
6.1.1
Die drei Hauptebenen
6.2
Das Control Plane im Detail
6.2.1
Die wichtigsten Komponenten
6.2.2
OpenShift-Erweiterungen
6.3
Netzwerk: Wie alles miteinander spricht
6.3.1
Die Netzwerk-Ebenen
6.3.2
Network Policies: Die Sicherheitskontrolle
6.4
Storage: Wo die Daten leben
6.4.1
Persistent Volumes
6.4.2
Storage Classes
6.4.3
Dynamische Bereitstellung
6.5
Sicherheit: Schutz auf allen Ebenen
6.5.1
Security Context Constraints (SCCs)
6.5.2
Role-Based Access Control (RBAC)
6.5.3
Isolation durch Namespaces
6.6
Hochverfügbarkeit: Wenn etwas ausfällt
6.6.1
Redundanz in der Control Plane
6.6.2
Automatische Wiederherstellung
6.6.3
Load Balancing
6.7
Monitoring und Logging: Den Überblick behalten
6.7.1
Metriken mit Prometheus
6.7.2
Zentrales Logging
6.7.3
Alerting
6.8
Skalierung: Wachsen mit den Anforderungen
6.8.1
Horizontal Pod Autoscaler
6.8.2
Cluster-Skalierung
7
Hauptkomponenten: Master, Nodes, Pods, Services, Routes
7.1
Master Nodes: Die Control Plane
7.1.1
API Server
7.1.2
etcd
7.1.3
Controller Manager
7.1.4
Scheduler
7.2
Worker Nodes: Die Compute-Ebene
7.2.1
Kubelet
7.2.2
Kube-Proxy
7.2.3
Container Runtime
7.2.4
OpenShift Node Service
7.3
Pods: Die kleinste deploybare Einheit
7.3.1
Netzwerk und Kommunikation
7.3.2
Konfiguration und Verwaltung
7.3.3
Ephemere Natur
7.4
Services: Netzwerk-Abstraktion
7.4.1
ClusterIP Services
7.4.2
NodePort Services
7.4.3
LoadBalancer Services
7.4.4
Service Discovery
7.5
Routes: Externe HTTP/HTTPS-Konnektivität
7.5.1
OpenShift Router
7.5.2
Route-Konfiguration
7.5.3
Erweiterte Features
7.6
Komponenteninteraktion
7.6.1
Pod-zu-Pod-Kommunikation
7.6.2
Externe Konnektivität
7.6.3
Separation of Concerns
8
Vorteile von OpenShift
8.1
Betriebseffizienz
8.2
Developer Experience
8.3
Sicherheit und Compliance
8.4
Hybrid Cloud Flexibilität
8.5
Skalierungsvorteile
8.6
Enterprise Integration
8.7
Total Cost of Ownership
8.8
Langfristige strategische Vorteile
9
Hardware- und Software-Anforderungen
9.1
Single-Node-Installationen
9.1.1
Minimale Hardware-Anforderungen (OpenShift Local)
9.1.2
Empfohlene Entwicklungsumgebung
9.2
Multi-Node-Cluster für Produktion
9.2.1
Master-Nodes (Control Plane)
9.2.2
Worker-Nodes
9.2.3
Infrastructure-Nodes
9.3
Betriebssystem-Anforderungen
9.3.1
Primäre Betriebssysteme
9.3.2
Alternative Betriebssysteme
9.4
Storage-Anforderungen
9.4.1
Lokaler Node-Speicher
9.4.2
Etcd-Storage (Performance-kritisch)
9.4.3
Container-Image-Storage
9.4.4
Persistent Storage für Anwendungen
9.5
Netzwerk-Anforderungen
9.5.1
Basis-Netzwerk-Anforderungen
9.5.2
Port-Anforderungen
9.6
Container-Runtime-Komponenten
9.7
Sizing-Richtlinien nach Umgebungsgröße
9.7.1
Entwicklung/Test-Umgebungen
9.7.2
Kleine Produktionsumgebungen (< 50 Anwendungen)
9.7.3
Mittlere Produktionsumgebungen (50-200 Anwendungen)
9.7.4
Große Produktionsumgebungen (> 200 Anwendungen)
9.8
Kapazitätsplanung und Monitoring
10
Netzwerkvoraussetzungen
10.1
DNS-Konfiguration und Namensauflösung
10.1.1
Forward- und Reverse-DNS-Auflösung
10.1.2
Wildcard-DNS für Application Routes
10.1.3
Interne DNS-Services
10.2
IP-Adressplanung und Netzwerksegmentierung
10.2.1
Netzwerkbereiche im Überblick
10.2.2
Machine Network (Host-Netzwerk)
10.2.3
Pod- und Service-Netzwerke
10.2.4
Load Balancer VIPs
10.3
Firewall-Konfigurationen und Port-Freigaben
10.3.1
Control Plane Ports
10.3.2
Worker Node Ports
10.3.3
Container Network Ports
10.3.4
Application Traffic
10.4
Load Balancer-Anforderungen
10.4.1
API Load Balancer
10.4.2
Application Load Balancer
10.4.3
Load Balancer-Implementierungen
10.5
Internetkonnektivität und Air-Gapped-Umgebungen
10.5.1
Container-Image-Repositories
10.5.2
Operator Hub und Marketplace
10.5.3
Telemetrie und Monitoring
10.5.4
Air-Gapped-Installationen
10.5.5
Proxy-Konfigurationen
10.6
Netzwerk-Performance und -Optimierung
10.6.1
Bandbreiten-Anforderungen
10.6.2
Quality of Service (QoS)
10.7
Monitoring und Troubleshooting
11
Sicherheitsvorkehrungen
11.1
Authentifizierung und Identity Management
11.1.1
OAuth-Server und Token-Management
11.1.2
Enterprise Identity Provider Integration
11.1.3
Service Account-Management
11.2
Role-Based Access Control (RBAC)
11.2.1
Cluster-weite Berechtigungen
11.2.2
Projekt-basierte Zugriffssteuerung
11.2.3
Custom Roles und Group-Management
11.3
Container-Sicherheit und Security Context Constraints
11.3.1
Standard Security Context Constraints
11.3.2
Privilegierte Container und Sonderberechtigungen
11.3.3
SELinux und Capabilities
11.4
Netzwerk-Sicherheit und Network Policies
11.4.1
Zero-Trust-Netzwerk-Architektur
11.4.2
Namespace-Isolation und Segmentierung
11.4.3
Application-spezifische Network Policies
11.5
Verschlüsselung und Zertifikatsverwaltung
11.5.1
Automatische TLS-Verschlüsselung
11.5.2
Application-Route-Verschlüsselung
11.5.3
Data-at-Rest-Verschlüsselung
11.5.4
Secret-Management
11.6
Compliance und Security Scanning
11.6.1
Automatisierte Compliance-Überwachung
11.6.2
Container-Image-Scanning
11.6.3
Runtime-Security-Monitoring
11.7
Backup und Disaster Recovery
11.7.1
Kritische Backup-Komponenten
11.7.2
Disaster Recovery-Planung
12
Installationsmethoden im Überblick
12.1
Überblick der Installationsmethoden
12.2
OpenShift Local
12.2.1
Technische Architektur
12.2.2
Hardware-Anforderungen
12.2.3
Funktionsumfang und Einschränkungen
12.3
Installer-Provisioned Infrastructure (IPI)
12.3.1
Cloud-Platform-Support
12.3.2
Installationsprozess
12.3.3
Vorteile und Limitierungen
12.4
User-Provisioned Infrastructure (UPI)
12.4.1
Infrastruktur-Vorbereitung
12.4.2
Installationsphasen
12.4.3
Anwendungsszenarien
12.5
Agent-Based Installation
12.5.1
Discovery-Agent-Konzept
12.5.2
Installations-Workflow
12.6
Assisted Installer
12.6.1
Web-Console-Integration
12.6.2
Validierungs- und Monitoring-Features
12.7
Single-Node OpenShift (SNO)
12.7.1
Konsolidierte Architektur
12.7.2
Ressourcen-Anforderungen
12.7.3
Edge-Computing-Anwendungen
12.8
Sandbox- und Evaluierungsumgebungen
12.8.1
Gehostete Sandbox-Optionen
12.8.2
Evaluierungs-Strategien
12.9
Auswahlkriterien für Installationsmethoden
12.9.1
Technische Faktoren
12.9.2
Organisatorische Faktoren
13
Single-Node Installation
13.1
Architektur und Konzept
13.1.1
Unterschiede zu Multi-Node-Clusters
13.2
Hardware-Anforderungen
13.2.1
Minimale Systemanforderungen
13.2.2
Storage-Überlegungen
13.3
Installationsmethoden
13.3.1
Assisted Installer (Empfohlen)
13.3.2
Agent-Based Installation
13.3.3
Manual Installation mit openshift-install
13.4
Konfigurationsbesonderheiten
13.4.1
Scheduler-Konfiguration
13.4.2
Resource Management
13.4.3
Storage-Konfiguration
13.4.4
Netzwerk-Vereinfachungen
13.5
Limitierungen und Einschränkungen
13.5.1
Hochverfügbarkeit
13.5.2
Feature-Einschränkungen
13.5.3
Performance-Charakteristik
13.6
Einsatzszenarien
13.6.1
Entwicklungsumgebungen
13.6.2
Edge Computing
13.6.3
Proof of Concept und Demos
13.7
Betriebsaspekte und Best Practices
13.7.1
Backup-Strategien
13.7.2
Monitoring und Alerting
13.7.3
Ressourcen-Management
13.7.4
Upgrade und Wartung
14
OpenShift Local (ehemals CodeReady Containers)
14.1
Technische Architektur
14.1.1
Kern-Komponenten
14.2
Hardware-Anforderungen
14.2.1
System-Voraussetzungen
14.2.2
Plattform-spezifische Anforderungen
14.2.3
Netzwerk-Überlegungen
14.3
Installation und Ersteinrichtung
14.3.1
Download und Installation
14.3.2
Initiale Konfiguration
14.3.3
Erststart und Setup
14.4
Bundle-System und Versionierung
14.4.1
Bundle-Management
14.5
Konfigurationsoptionen
14.5.1
Ressourcen-Tuning
14.5.2
Enterprise-Integration
14.5.3
Netzwerk-Konfiguration
14.6
Entwicklungsworkflows
14.6.1
Lokale Container-Registry
14.6.2
Source-to-Image Builds
14.6.3
IDE-Integration
14.6.4
Monitoring und Debugging
14.7
Wartung und Lifecycle-Management
14.7.1
Routine-Wartung
14.7.2
Performance-Optimierung
14.7.3
Troubleshooting häufiger Probleme
14.8
Einschränkungen und Grenzen
14.8.1
Architektur-Limitierungen
14.8.2
Resource-Impact auf Host-System
14.8.3
Update- und Migrations-Überlegungen
15
Multi-Node Installation (Konzept)
15.1
Architekturgrundlagen
15.1.1
Netzwerk-Segmentierung
15.2
Master-Node-Konfiguration
15.2.1
Hochverfügbarkeits-Design
15.2.2
Hardware-Anforderungen für Master-Nodes
15.3
Worker-Node-Architektur
15.3.1
Node-Spezialisierung
15.3.2
Node-Klassifizierung und -Verwaltung
15.4
Netzwerkdesign
15.4.1
Container Network Interface (CNI)
15.4.2
Externe Konnektivität
15.4.3
DNS-Integration
15.5
Storage-Architektur
15.5.1
Storage-Klassen und Dynamic Provisioning
15.5.2
Container Storage Interface (CSI)
15.6
Installationsmethodiken
15.6.1
Installer-Provisioned Infrastructure (IPI)
15.6.2
User-Provisioned Infrastructure (UPI)
15.6.3
Assisted Installer
15.7
Skalierung und Kapazitätsplanung
15.7.1
Automatisierte Skalierung
15.7.2
Machine Sets und Machine Pools
15.7.3
Kapazitäts-Metriken
15.8
Wartung und Lifecycle-Management
15.8.1
Rolling Updates und Node-Wartung
15.8.2
Machine Config Operator
15.8.3
Monitoring und Observability
15.8.4
Backup und Disaster Recovery
16
OpenShift Sandbox und Playground-Umgebungen
16.1
Konzept und Architektur
16.1.1
Verfügbare Sandbox-Optionen
16.2
Red Hat Developer Sandbox
16.2.1
Zugang und Registrierung
16.2.2
Ressourcen und Limitierungen
16.2.3
Verfügbare Features
16.3
Playground- und Learning-Umgebungen
16.3.1
Interactive Learning Platform
16.3.2
Hands-on Labs
16.4
Technische Implementierung
16.4.1
Resource Management
16.4.2
Storage und Persistierung
16.5
Sicherheit und Isolation
16.5.1
Security Context Constraints
16.5.2
Netzwerk-Isolation
16.5.3
Audit und Compliance
16.6
Integration in Entwicklungsworkflows
16.6.1
Git-Integration
16.6.2
CI/CD-Pipeline-Integration
16.6.3
IDE-Integration
16.7
Limitierungen verstehen
16.7.1
Technische Einschränkungen
16.7.2
Nicht verfügbare Features
16.8
Einsatzszenarien und Best Practices
16.8.1
Ideale Anwendungsgebiete
16.8.2
Best Practices für Sandbox-Nutzung
17
Einführung in die OpenShift CLI (oc)
17.1
Konzeptionelle Grundlagen
17.1.1
Architektur und Kommunikation
17.2
Installation und Setup
17.2.1
Download-Optionen
17.2.2
Linux-Installation
17.2.3
Windows-Installation
17.3
Authentifizierung und Cluster-Verbindung
17.3.1
Login-Methoden
17.3.2
Konfigurationsverwaltung
17.4
Grundlegende CLI-Operationen
17.4.1
Cluster- und Projekt-Management
17.4.2
Anwendungs-Deployment
17.4.3
Resource-Management
17.5
Monitoring und Debugging
17.5.1
Log-Management
17.5.2
Pod- und Container-Debugging
17.5.3
Resource-Monitoring
17.6
Erweiterte CLI-Features
17.6.1
Template- und Kustomization-Support
17.6.2
Batch-Operationen und Automation
17.7
OpenShift-spezifische Befehle
17.7.1
Build- und Image-Management
17.7.2
Route- und Service-Management
17.7.3
Security und RBAC
17.8
Produktivitäts-Features
17.8.1
Auto-Completion und Aliase
17.8.2
Plugin-Erweiterungen
17.9
Best Practices und Troubleshooting
17.9.1
Häufige CLI-Patterns
17.9.2
Troubleshooting-Workflows
18
Grundlegende CLI-Befehle
18.1
Befehlsstruktur und Syntax
18.1.1
Grundlegende Syntax-Beispiele
18.2
Authentifizierung und Cluster-Verbindung
18.2.1
Login und Logout
18.2.2
Cluster-Informationen
18.3
Projekt- und Namespace-Management
18.3.1
Projekt-Befehle
18.3.2
Kontext-Management
18.4
Ressourcenabfrage und -inspektion
18.4.1
Grundlegende Get-Befehle
18.4.2
Output-Formate
18.4.3
Filtering und Selektion
18.4.4
Detaillierte Ressourcen-Informationen
18.5
Anwendungslebenszyklus-Management
18.5.1
Anwendung Deployment
18.5.2
Service-Exposition
18.5.3
Skalierung
18.6
Konfiguration und Secrets-Management
18.6.1
ConfigMaps
18.6.2
Secrets-Management
18.6.3
Umgebungsvariablen
18.7
Debugging und Logs
18.7.1
Log-Management
18.7.2
Interactive Debugging
18.7.3
Port-Forwarding
18.8
Labels und Annotations
18.8.1
Label-Management
18.8.2
Annotations
18.9
Batch-Operationen und erweiterte Befehle
18.9.1
Bulk-Operationen
18.9.2
YAML-basierte Operationen
18.9.3
Advanced Querying
18.10
Pipeline-Integration und Automation
18.10.1
Scripting-freundliche Befehle
19
Web-Konsole Navigation
19.1
Zugang zur Web-Konsole
19.1.1
Login-Prozess
19.2
Hauptnavigationsstruktur
19.2.1
Perspektiven-Übersicht
19.2.2
Perspektiven wechseln
19.3
Developer-Perspektive
19.3.1
Haupt-Navigationsbereiche
19.3.2
Topology-Ansicht Navigation
19.3.3
Deployment-Workflows
19.4
Administrator-Perspektive
19.4.1
Hauptnavigationsbereiche
19.4.2
Projekt-Management
19.4.3
Resource-Management-Workflows
19.5
Observe-Perspektive
19.5.1
Monitoring-Bereiche
19.5.2
Dashboard-Navigation
19.6
Suche und Filterung
19.6.1
Globale Suche
19.6.2
Listen-Filterung
19.6.3
Advanced Search-Patterns
19.7
Benutzeroberflächen-Anpassung
19.7.1
Theme und Darstellung
19.7.2
Sprach- und Lokalisierungseinstellungen
19.7.3
Dashboard-Personalisierung
19.8
Mobile und Responsive Navigation
19.8.1
Mobile Navigation-Pattern
19.8.2
Offline-Funktionalität
19.9
Performance-Optimierung
19.9.1
Browser-Optimierung
19.9.2
Cluster-Performance-Überlegungen
20
Hauptfunktionen der Web-Konsole
20.1
Dashboard und Cluster-Übersicht
20.1.1
Home Dashboard Komponenten
20.1.2
Dashboard-Personalisierung
20.2
Projektmanagement
20.2.1
Projekt erstellen und konfigurieren
20.2.2
Resource Quotas und Limits
20.2.3
Team-Collaboration
20.3
Anwendungsdeployment
20.3.1
Source-to-Image (S2I) Deployment
20.3.2
Container Image Deployment
20.3.3
Helm Charts
20.4
Build und Pipeline-Management
20.4.1
Build-Konfiguration
20.4.2
Tekton Pipelines
20.5
Monitoring und Observability
20.5.1
Observe-Dashboard
20.5.2
Custom Dashboards
20.5.3
Alerting
20.6
Networking und Service-Management
20.6.1
Service-Verwaltung
20.6.2
Route-Management
20.6.3
Network Policies
20.7
Storage-Management
20.7.1
Persistent Volume Claims
20.7.2
Volume-Snapshots
20.8
Security und Compliance
20.8.1
Security Context Constraints (SCCs)
20.8.2
Certificate Management
20.8.3
RBAC-Verwaltung
20.9
Multi-Cluster-Management
20.9.1
Advanced Cluster Management (ACM)
20.9.2
Cluster-übergreifende Features
21
Erstellung und Verwaltung von Projekten
21.1
Was sind OpenShift-Projekte?
21.1.1
Projekte vs. Kubernetes Namespaces
21.2
Projekt-Lifecycle-Management
21.2.1
Projekterstellung
21.2.2
Projekt-Konfiguration
21.2.3
Projektarchivierung und -löschung
21.3
Benutzer- und Berechtigungsmanagement
21.3.1
Standard-Projekt-Rollen
21.3.2
Benutzerzuweisung
21.3.3
Service Accounts
21.4
Projekt-Templates und Standardisierung
21.4.1
Template-Struktur
21.4.2
Template-Versionierung
21.5
Netzwerksegmentierung und Isolation
21.5.1
Standard-Netzwerkinsolation
21.5.2
Explizite Netzwerk-Policies
21.6
Monitoring und Observability
21.6.1
Projekt-Metriken
21.6.2
Event-Monitoring
21.6.3
Audit und Compliance
21.7
CI/CD-Integration
21.7.1
Build-Konfigurationen
21.7.2
GitOps-Integration
21.7.3
Multi-Stage-Promotion
21.8
Projekt-Verwaltung Best Practices
21.8.1
Naming Conventions
21.8.2
Ressourcenplanung
21.8.3
Sicherheitskonfiguration
22
Deployments und ReplicaSets
22.1
Die Beziehung zwischen Deployments und ReplicaSets
22.1.1
Praktisches Beispiel der Hierarchie
22.2
Deployment-Strategien
22.2.1
Rolling Updates
22.2.2
Blue-Green-Deployments
22.2.3
Canary-Deployments
22.3
Skalierung und Replica-Management
22.3.1
Manuelle Skalierung
22.3.2
Automatische Skalierung
22.3.3
Desired State Management
22.3.4
Pod Disruption Budgets
22.4
Ressourcen-Management
22.4.1
Ressourcen-Spezifikation
22.4.2
Quality of Service Klassen
22.4.3
Node-Platzierung
22.5
Health Checks und Lifecycle-Management
22.5.1
Probe-Arten
22.5.2
Lifecycle Hooks
22.6
Storage-Integration
22.6.1
Persistent Volume Claims
22.6.2
Init Container
22.6.3
Shared Volumes
22.7
Rollback und Versions-Management
22.7.1
Rollback-Operationen
22.7.2
Revision-Limits
22.7.3
Annotations und Labels
22.8
Service Discovery Integration
22.8.1
Service-Deployment-Kopplung
22.8.2
Label-basierte Gruppierung
22.9
Best Practices für Deployment-Management
22.9.1
Deployment-Konfiguration
22.9.2
Monitoring und Observability
23
Services definieren
23.1
Was sind Services und warum sind sie notwendig?
23.1.1
Das Pod-IP-Problem
23.1.2
Service-Discovery-Mechanismus
23.2
Service-Typen und Verwendungsszenarien
23.2.1
ClusterIP Services
23.2.2
NodePort Services
23.2.3
LoadBalancer Services
23.2.4
ExternalName Services
23.2.5
Service-Typ-Vergleich
23.3
Load Balancing und Traffic Distribution
23.3.1
Session Affinity
23.3.2
Erweiterte Load Balancing-Strategien
23.4
Multi-Port Services und Port-Management
23.4.1
Port-Mapping-Flexibilität
23.4.2
Protokoll-Unterstützung
23.5
Service Discovery-Integration
23.5.1
DNS-Namen für Services
23.5.2
Environment Variable-basierte Discovery
23.5.3
Service Discovery-Beispiel
23.6
Health Checking und Endpoint-Management
23.6.1
Automatisches Endpoint-Management
23.6.2
Endpoint-Objekte
23.6.3
Custom Endpoints
23.7
Service-Security und Network Policies
23.7.1
Beispiel Network Policy für Service-Kommunikation
23.7.2
Service Account Integration
23.8
Service-Monitoring und Troubleshooting
23.8.1
Service-Metriken überwachen
23.8.2
Häufige Service-Probleme
23.9
Service-Definition Best Practices
23.9.1
Naming Conventions
23.9.2
Port-Definitionen
23.9.3
Selector-Design
23.9.4
Performance-Optimierungen
24
ConfigMaps und Secrets
24.1
Grundlegende Unterscheidung: ConfigMaps vs. Secrets
24.1.1
ConfigMaps: Nicht-sensitive Konfigurationsdaten
24.1.2
Secrets: Sensitive Daten
24.2
ConfigMaps erstellen und verwenden
24.2.1
ConfigMap-Erstellung
24.2.2
Umgebungsspezifische ConfigMaps
24.3
Secret-Typen und Verwendung
24.3.1
Generic Secrets
24.3.2
TLS Secrets
24.3.3
Docker Registry Secrets
24.3.4
Service Account Tokens
24.4
Konfiguration in Pods konsumieren
24.4.1
Environment Variable-Injection
24.4.2
Volume Mounts
24.4.3
Projected Volumes
24.4.4
Subpath-Mounts
24.5
Update-Verhalten und Lifecycle
24.5.1
Update-Szenarien
24.5.2
Immutable ConfigMaps/Secrets
24.5.3
Versionierung für Rolling Updates
24.6
Sicherheitsüberlegungen
24.6.1
Encryption at Rest
24.6.2
RBAC-Integration
24.6.3
Secret-Rotation
24.6.4
Pod Security Context
24.7
Integration mit externen Systemen
24.7.1
External Secrets Operator
24.7.2
GitOps-Integration
24.8
Performance und Skalierung
24.8.1
Size-Limits beachten
24.8.2
Caching und Performance
24.9
Troubleshooting häufiger Probleme
24.9.1
ConfigMap/Secret nicht gefunden
24.9.2
Environment Variables nicht gesetzt
24.9.3
Volume-Mount-Probleme
24.9.4
Base64-Dekodierung
24.10
Best Practices für ConfigMaps und Secrets
24.10.1
Strukturierung und Organisation
24.10.2
Security Best Practices
24.10.3
Deployment-Strategien
25
Ressourcen-Quotas und Limits
25.1
Das Problem: Unkontrollierter Ressourcenverbrauch
25.2
Resource Quotas: Projektweite Ressourcenkontrolle
25.2.1
Compute Resource Quotas
25.2.2
Storage Quotas
25.2.3
API Object Quotas
25.2.4
Scoped Quotas
25.2.5
Resource Quota-Status prüfen
25.3
Limit Ranges: Default-Werte und Constraints
25.3.1
Container-Limit Range
25.3.2
Pod-Limit Range
25.3.3
Persistent Volume Claim Limits
25.3.4
Request-to-Limit-Ratios
25.4
Quality of Service-Klassifikation
25.4.1
QoS-Klassen im Detail
25.4.2
Guaranteed QoS
25.4.3
Burstable QoS
25.4.4
BestEffort QoS
25.4.5
QoS-Klasse eines Pods prüfen
25.5
Praktische Ressourcen-Spezifikation
25.5.1
CPU-Spezifikation verstehen
25.5.2
Memory-Spezifikation
25.5.3
Typische Resource-Patterns
25.6
Monitoring und Troubleshooting
25.6.1
Resource-Usage überwachen
25.6.2
Quota-Probleme diagnostizieren
25.6.3
Häufige Resource-Probleme
25.7
Autoscaling-Integration
25.7.1
Horizontal Pod Autoscaler (HPA)
25.7.2
Vertical Pod Autoscaler (VPA)
25.8
Multi-Tenancy und Isolation
25.8.1
Projekt-basierte Ressourcentrennung
25.8.2
Priority Classes für Workload-Priorisierung
25.9
Cost Management und Ressourcenoptimierung
25.9.1
Resource-Utilization analysieren
25.9.2
Right-Sizing von Ressourcen
25.9.3
Kostenallokation
25.10
Best Practices für Ressourcen-Management
25.10.1
Sizing-Strategien
25.10.2
Quota-Design
25.10.3
Monitoring-Setup
26
Container-Images und Registries
26.1
Container-Images verstehen
26.1.1
Image-Schichten verstehen
26.1.2
Image-Manifest-Struktur
26.2
Registry-Architekturen
26.2.1
Registry-Typen im Vergleich
26.2.2
Public Registries
26.2.3
Private Registries
26.2.4
OpenShift Integrated Registry
26.3
Image-Build-Strategien in OpenShift
26.3.1
Source-to-Image (S2I) Builds
26.3.2
Docker Strategy Builds
26.3.3
Custom Strategy Builds
26.3.4
Pipeline Strategy Builds
26.4
Image Streams: OpenShift-spezifische Abstraktion
26.4.1
Image Stream-Definition
26.4.2
Image Stream-Verwendung
26.5
Security und Image-Scanning
26.5.1
Base Image-Security
26.5.2
Vulnerability Scanning
26.5.3
Image Signing und Content Trust
26.6
Multi-Platform-Images
26.6.1
Multi-Arch Build mit Buildah
26.6.2
Platform-spezifische Optimierungen
26.7
Performance-Optimierung
26.7.1
Layer Caching-Strategien
26.7.2
Multi-Stage Builds
26.7.3
Image-Size-Optimierung
26.8
Registry-Integration und Authentication
26.8.1
Pull Secrets konfigurieren
26.8.2
Registry-Authentication per ServiceAccount
26.9
Registry Mirroring und Air-Gapped-Umgebungen
26.9.1
Mirror Registry Setup
26.9.2
Image Content Source Policy
26.10
Image Governance und Policies
26.10.1
Admission Control für Images
26.10.2
Image Stream Import-Policies
26.10.3
Image Pruning
26.11
Troubleshooting häufiger Image-Probleme
26.11.1
Image Pull-Probleme
26.11.2
Registry-Connectivity testen
26.11.3
Build-Probleme diagnostizieren
26.11.4
Image-Inspection und Debugging
26.12
Performance-Monitoring
26.12.1
Image-Pull-Performance
26.12.2
Storage-Usage überwachen
27
Deployment-Konfigurationen
27.1
Deklarative Konfiguration verstehen
27.1.1
Template-basierte Konfigurationen
27.1.2
Kustomize-Integration
27.2
Container-Spezifikationen im Detail
27.2.1
Basis-Container-Konfiguration
27.2.2
Init Container-Konfigurationen
27.2.3
Multi-Container Pods (Sidecar Pattern)
27.3
Security Context und Service Accounts
27.3.1
Service Account-Konfiguration
27.3.2
Security Context-Einstellungen
27.3.3
Pod Security Standards
27.4
Environment-spezifische Konfiguration
27.4.1
ConfigMap-Integration
27.4.2
Projected Volumes
27.4.3
Downward API-Integration
27.5
Health Checks und Probes
27.5.1
Probe-Konfiguration im Detail
27.5.2
Verschiedene Probe-Typen
27.6
Resource Management und Scheduling
27.6.1
Erweiterte Resource-Konfiguration
27.6.2
Node Affinity und Pod Placement
27.7
Lifecycle Hooks
27.7.1
Lifecycle Hook-Beispiele
27.8
Advanced Deployment-Konfigurationen
27.8.1
Rolling Update-Strategien
27.8.2
Recreate-Strategie
27.8.3
Deployment-Annotations für Metadata
27.9
Erweiterte Konfigurationspatterns
27.9.1
Blue-Green Deployment Setup
27.9.2
Canary Deployment mit Traffic-Splitting
27.10
Troubleshooting Deployment-Konfigurationen
27.10.1
Deployment-Status prüfen
27.10.2
Häufige Konfigurationsprobleme
27.10.3
Konfigurationsvalidierung
28
Deployment-Strategien
28.1
Die vier Hauptstrategien im Überblick
28.1.1
Strategien-Vergleich
28.2
Rolling Deployments: Der Standard-Ansatz
28.2.1
Rolling Update-Konfiguration
28.2.2
Parameter-Tuning für verschiedene Szenarien
28.2.3
Rolling Update überwachen
28.3
Recreate Strategy: Einfach aber mit Downtime
28.3.1
Recreate-Konfiguration
28.3.2
Wann Recreate verwenden?
28.4
Blue-Green Deployments: Zero-Downtime mit doppelten Ressourcen
28.4.1
Blue-Green Setup-Beispiel
28.4.2
Blue-Green Deployment-Prozess
28.4.3
Database-Synchronisation bei Blue-Green
28.5
Canary Deployments: Risikokontrollierte Einführung
28.5.1
Einfacher Canary-Setup
28.5.2
Progressive Canary-Rollout
28.5.3
Automatisierter Canary mit Flagger (Istio/Service Mesh)
28.6
A/B Testing und Feature Flags
28.6.1
Header-basiertes A/B Testing
28.6.2
Feature Flags mit External Config
28.7
Failure Recovery und Monitoring
28.7.1
Automatischer Rollback-Trigger
28.7.2
Health Check-Amplification
28.7.3
Monitoring-Dashboard für Deployments
28.8
Multi-Environment Promotion
28.8.1
GitOps-basierte Promotion-Pipeline
28.8.2
Environment-spezifische Rollback-Strategien
28.9
Ressourcen-Optimierung für Deployment-Strategien
28.9.1
Ressourcen-Overhead nach Strategie
28.9.2
Resource-Aware Deployment-Scheduling
28.9.3
Deployment-Performance-Tuning
29
Rollbacks und Versionierung
29.1
Versionierung verstehen und implementieren
29.1.1
OpenShift Revision-System
29.1.2
Semantic Versioning-Integration
29.1.3
Image Tag-Strategien
29.2
Rollback-Mechanismen und -Strategien
29.2.1
Automated Rollback-Triggers
29.2.2
Manual Rollback-Procedures
29.2.3
Partial Rollback-Capabilities
29.3
Revision History Management
29.3.1
Retention Policy-Konfigurationen
29.3.2
Revision Metadata-Enrichment
29.3.3
Revision-Diff-Analysis
29.4
Database und State-Management bei Rollbacks
29.4.1
Database Schema-Rollback-Strategien
29.4.2
Stateful Application-Rollbacks
29.4.3
Data Migration-Rollbacks
29.5
Emergency Rollback-Procedures
29.5.1
Break-Glass Rollback-Mechanisms
29.5.2
Communication-Automation während Rollbacks
29.6
Testing und Validation von Rollback-Procedures
29.6.1
Rollback Testing-Frameworks
29.6.2
Automated Rollback-Validation
29.7
CI/CD-Pipeline-Integration
29.7.1
GitOps-basierte Rollback-Automation
29.7.2
Approval-Gate-Integration für Rollbacks
29.7.3
Metrics-Integration für Rollback-Operations
29.8
Rollback-Performance-Optimierung
29.8.1
Fast Rollback-Strategien
29.8.2
Rollback-Monitoring Dashboard
30
Skalierung von Anwendungen
30.1
Skalierungsmodelle und -ansätze
30.1.1
Horizontale Skalierung (Scale-Out)
30.1.2
Vertikale Skalierung (Scale-Up)
30.1.3
Cluster-Auto-Skalierung
30.2
Horizontal Pod Autoscaler (HPA)
30.2.1
Metriken-basierte Skalierung
30.2.2
Skalierungs-Policies
30.2.3
Multi-Metriken Skalierung
30.3
Vertical Pod Autoscaler (VPA)
30.3.1
Ressourcen-Empfehlungen
30.3.2
VPA-Modi
30.3.3
Quality of Service Integration
30.4
Custom Metrics und External Metrics
30.4.1
Application-Level Metrics
30.4.2
External Metrics Integration
30.4.3
Scheduled Scaling
30.5
Skalierungs-Performance und -Optimierung
30.5.1
Scale-Up Optimierung
30.5.2
Scale-Down Safety
30.6
Multi-Tier Application Skalierung
30.6.1
Dependency-Aware Scaling
30.6.2
Service Mesh Integration
30.7
Ressourcen-Constraints und Limits
30.7.1
Skalierungs-Grenzen
30.7.2
Node-Capacity Awareness
30.7.3
Priority-based Scaling
30.8
Cost-Optimization und Efficiency
30.8.1
Cost-Aware Scaling
30.8.2
Predictive Scaling
30.8.3
Resource Efficiency Metrics
31
Service-Definitionen und Cluster-IP
31.1
Das Problem: Dynamische Pod-IPs
31.1.1
Warum Services essentiell sind
31.2
ClusterIP-Services: Die Grundlage
31.2.1
Basis-Service-Definition
31.2.2
Service-Erstellung und -Verifikation
31.3
Endpoint-Management und Pod-Discovery
31.3.1
Automatische Endpoint-Verwaltung
31.3.2
Label-Selektor-Mechanismen
31.3.3
Headless Services
31.4
DNS-basierte Service Discovery
31.4.1
DNS-Naming-Konventionen
31.4.2
DNS-Konfiguration und -Optimierung
31.4.3
Custom DNS-Policies
31.5
Load Balancing und Traffic-Distribution
31.5.1
Standard Load-Balancing-Verhalten
31.5.2
Session Affinity
31.5.3
External Traffic Policy
31.6
Multi-Port Services und Port-Management
31.6.1
Multi-Port Service-Definition
31.6.2
Target-Port-Mapping
31.7
Service-Monitoring und Observability
31.7.1
Service-Metriken sammeln
31.7.2
Distributed Tracing Integration
31.7.3
Service-Dependency Mapping
32
NodePort und LoadBalancer
32.1
NodePort-Services: Grundlagen und Funktionsweise
32.1.1
Automatische Port-Zuordnung
32.1.2
Hochverfügbarkeit durch Distributed Proxy
32.1.3
Port-Management
32.2
LoadBalancer-Services: Cloud-Integration
32.2.1
Automatische Load-Balancer-Bereitstellung
32.2.2
Health Check Integration
32.2.3
External-IP-Assignment
32.3
Service-Typen im Vergleich
32.4
Traffic-Flow und Load-Balancing-Strategien
32.4.1
External Traffic Policy
32.4.2
Source-IP-Erhaltung
32.4.3
Session Affinity
32.5
Cloud-Provider-spezifische Implementierungen
32.5.1
Amazon Web Services (AWS)
32.5.2
Google Cloud Platform (GCP)
32.5.3
Microsoft Azure
32.5.4
Private Cloud und On-Premises
32.6
Sicherheitsüberlegungen
32.6.1
Firewall-Regeln für NodePort
32.6.2
TLS-Terminierung
32.6.3
DDoS-Schutz
32.7
Performance und Skalierung
32.7.1
LoadBalancer-Performance-Charakteristika
32.7.2
Auto-Scaling Integration
32.7.3
Connection-Pooling und Keep-Alive
32.8
Monitoring und Observability
32.8.1
LoadBalancer-Metriken
32.8.2
Health-Check-Monitoring
32.8.3
Traffic-Pattern-Analyse
32.9
Entwicklungs- und Test-Szenarien
32.9.1
NodePort in Single-Node-Umgebungen
32.9.2
LoadBalancer-Simulation
32.10
Cost-Optimization
32.10.1
LoadBalancer-Konsolidierung
32.10.2
Right-Sizing und Reserved Instances
32.10.3
Automatisiertes Lifecycle-Management
33
Routing und Ingress-Controller
33.1
OpenShift Routes vs. Kubernetes Ingress
33.1.1
OpenShift Routes
33.1.2
Kubernetes Ingress
33.2
HAProxy Router-Architektur
33.2.1
Dynamic Configuration Management
33.2.2
SSL-Zertifikats-Management
33.2.3
Performance-Optimierungen
33.3
Alternative Ingress-Controller
33.3.1
NGINX Ingress Controller
33.3.2
Traefik Ingress Controller
33.3.3
Istio Gateway Integration
33.4
Routing-Strategien
33.4.1
Host-basiertes Routing
33.4.2
Path-basiertes Routing
33.4.3
Wildcard-Domain-Support
33.5
SSL/TLS-Management
33.5.1
TLS-Terminierungs-Modi
33.5.2
Automatische Zertifikatserneuerung
33.5.3
Security Headers
33.6
Traffic-Management und Load-Balancing
33.6.1
Weighted Routing für Canary Deployments
33.6.2
Session Affinity
33.6.3
Rate Limiting
33.6.4
Health Checks
33.7
Monitoring und Observability
33.7.1
Request-Tracing
33.7.2
Access Logging
33.7.3
Performance-Metriken
33.7.4
Prometheus-Integration
33.8
Custom Annotations und erweiterte Funktionalität
33.8.1
HAProxy-spezifische Annotations
33.8.2
Custom Error Pages
33.8.3
Maintenance Mode
33.9
Development und Testing
33.9.1
Local Development mit nip.io
33.9.2
Port-Forwarding-Alternative
33.9.3
Local SSL-Testing
33.9.4
Multi-Environment Routing
34
Persistente Volumes (PV) und Volume Claims (PVC)
34.1
Grundkonzepte der Storage-Abstraktion
34.1.1
Die PV/PVC-Beziehung
34.1.2
Lifecycle-Management
34.2
Storage-Backend-Integration
34.2.1
Container Storage Interface (CSI)
34.2.2
Volume-Plugin-Architektur
34.2.3
Storage-Topology-Awareness
34.3
Access-Modi und Volume-Charakteristika
34.3.1
Volume-Access-Modi
34.3.2
Praktische Beispiele für Access-Modi
34.4
Volume-Lifecycle und Zustandsverwaltung
34.4.1
Provisioning-Strategien
34.4.2
Binding-Prozess
34.5
Reclaim-Policies und Datenmanagement
34.5.1
Policy-Typen
34.5.2
Data-Protection-Überlegungen
34.6
Volume-Mounting und Container-Integration
34.6.1
Mount-Spezifikationen
34.6.2
SubPath-Mounting
34.6.3
Security Context und Berechtigungen
34.7
Performance-Überlegungen
34.7.1
IOPS und Durchsatz-Anforderungen
34.7.2
Storage-Latenz-Optimierung
34.7.3
Caching-Strategien
34.8
Sicherheit und Verschlüsselung
34.8.1
Encryption-at-Rest
34.8.2
Encryption-in-Transit
34.8.3
Access Control Integration
34.9
Storage Classes und Dynamic Provisioning
34.9.1
Volume-Expansion
34.10
Single-Node-Storage-Überlegungen
34.10.1
Local Storage Integration
34.10.2
EmptyDir Volumes
34.10.3
HostPath Volumes (Vorsicht geboten)
34.11
Troubleshooting und Monitoring
34.11.1
Häufige PV/PVC-Probleme
34.11.2
Storage-Metriken
35
Storage-Klassen
35.1
Grundkonzepte der Storage-Klassen
35.1.1
Provisioner-Integration
35.1.2
Policy-Framework
35.1.3
Quality-of-Service-Klassifikation
35.2
Storage-Tier-Klassifikation
35.2.1
Performance-Tiers im Überblick
35.2.2
High-Performance Storage-Classes
35.2.3
Standard Storage-Classes
35.2.4
Archive Storage-Classes
35.2.5
Regional Storage-Classes
35.3
Provisioner-Typen und Backend-Integration
35.3.1
CSI-Provisioner (Modern)
35.3.2
In-Tree-Provisioner (Legacy)
35.3.3
External-Provisioner
35.4
Parameter-Management und Konfiguration
35.4.1
Volume-Binding-Modi
35.4.2
Allowed-Topologies
35.4.3
Mount-Options
35.5
Dynamic Provisioning-Workflows
35.5.1
PVC-zu-StorageClass-Binding
35.5.2
Volume-Size-Management
35.5.3
Provisioning-Retry und Error-Handling
35.6
Performance-Tuning und Optimierung
35.6.1
IOPS-Provisioning-Profile
35.6.2
Throughput-Optimierung
35.6.3
Latenz-Optimierung
35.7
Security-Integration
35.7.1
Encryption-at-Rest-Policies
35.7.2
Access-Control-Integration
35.7.3
Compliance-Tagging
35.8
Cost-Management und Optimierung
35.8.1
Cost-Tier-Definition
35.8.2
Lifecycle-Management
35.9
Multi-Cloud und Hybrid-Storage
35.9.1
Cloud-Provider-Integration
35.9.2
Cross-Cloud-Replication
35.10
Storage Class Best Practices
35.10.1
Naming Conventions
35.10.2
Default Storage Class Management
35.11
Monitoring und Troubleshooting
35.11.1
Storage Class Metriken
35.11.2
Troubleshooting Storage Classes
36
Dynamische Bereitstellung von Speicher
36.1
Grundlagen der dynamischen Bereitstellung
36.1.1
Funktionsweise des Dynamic Provisioning
36.1.2
Provisioner-Plugin-Architektur
36.2
Container Storage Interface (CSI) Integration
36.2.1
CSI-Treiber-Komponenten
36.2.2
Volume-Lifecycle-Operationen
36.2.3
Topology-Aware Provisioning
36.3
Provisioning-Workflows und Zustandsverwaltung
36.3.1
PVC-Analyse und Backend-Auswahl
36.3.2
Volume-Erstellungs-Orchestrierung
36.3.3
Binding-Automation
36.4
Capacity-Management und Ressourcen-Optimierung
36.4.1
Storage-Pool-Management
36.4.2
Thin Provisioning
36.4.3
Auto-Scaling Integration
36.5
Performance-Optimierung und Quality-of-Service
36.5.1
IOPS-Allocation-Management
36.5.2
Bandwidth-Throttling
36.6
Security-Integration
36.6.1
Verschlüsselungs-Key-Management
36.6.2
Access-Control-Integration
36.7
Fehlerbehandlung und Resilienz
36.7.1
Retry-Logik für fehlgeschlagene Bereitstellung
36.7.2
Fallback-Provisioner-Konfiguration
36.7.3
Partial-Failure-Recovery
36.8
Multi-Tenancy und Isolation
36.8.1
Namespace-basierte Storage-Isolation
36.8.2
Storage-Class-RBAC-Integration
36.9
Integration mit Anwendungszyklen
36.9.1
Application-Deployment-Integration
36.9.2
StatefulSet-Integration
36.10
Monitoring und Observability
36.10.1
Provisioning-Metriken
36.10.2
Capacity-Trending-Analyse
36.10.3
Cost-Tracking
36.11
Single-Node Dynamic Provisioning
36.11.1
Local-Storage-Optimierung
36.11.2
Ressourcen-Constraint-Bewusstsein
36.11.3
Development-optimierte Workflows
37
Backup-Strategien
37.1
Grundlagen von Container-Storage-Backup
37.1.1
Die Herausforderung der Zustandsverwaltung
37.1.2
Disaster-Recovery-Planung
37.1.3
DevOps-Integration
37.2
Volume-Snapshot-Mechanismen
37.2.1
CSI-Snapshot-Integration
37.2.2
Storage-Backend-Snapshots
37.2.3
Copy-on-Write Optimierung
37.3
Anwendungskonsistente Backup-Strategien
37.3.1
Pre- und Post-Backup-Hooks
37.3.2
Quiescing-Mechanismen
37.3.3
Multi-Volume-Konsistenzgruppen
37.4
Inkrementelle und differentielle Backup-Muster
37.4.1
Block-Level-Inkrementelle Backups
37.4.2
Deduplication und Compression
37.5
Cross-Cluster und Multi-Site-Backup
37.5.1
Replikationsbasierte Backup-Strategien
37.5.2
Cloud-Storage-Integration
37.6
Backup-Verifikation und Testing
37.6.1
Backup-Integritäts-Validierung
37.6.2
Recovery-Testing-Automation
37.7
Metadaten und Konfigurations-Backup
37.7.1
Kubernetes-Metadaten-Backup
37.7.2
etcd-Backup-Strategien
37.8
Automation und Orchestrierung
37.8.1
Backup-Policy-Engines
37.8.2
Workflow-Orchestrierung
37.9
Cost-Optimierung und Lifecycle-Management
37.9.1
Storage-Tier-Migration
37.9.2
Retention-Policy-Automation
37.10
Security und Compliance-Integration
37.10.1
Verschlüsselung und Zugriffskontrolle
37.10.2
Compliance-Reporting
37.11
Single-Node-Backup-Überlegungen
37.11.1
Lokale Backup-Storage-Integration
37.11.2
Ressourcen-schonende Backup-Zeitplanung
38
Benutzerverwaltung
38.1
Grundlagen der Identity-Verwaltung
38.1.1
Benutzertypen in OpenShift
38.1.2
Identity-Mapping
38.2
Gruppen-Management
38.2.1
Statische Gruppen
38.2.2
Dynamische Gruppen
38.2.3
Verschachtelte Gruppenstrukturen
38.2.4
Gruppensynchronisation
38.3
Service-Account-Management
38.3.1
Anwendungs-Service-Accounts
38.3.2
Custom Service-Accounts
38.3.3
Service-Account-Token-Management
38.4
Identity-Provider-Integration
38.4.1
OAuth2-Integration
38.4.2
LDAP-Integration
38.4.3
SAML-Integration
38.4.4
OpenID Connect-Integration
38.5
Multi-Tenancy und Isolation
38.5.1
Projekt-basierte Isolation
38.5.2
Cross-Projekt-Benutzer-Sharing
38.5.3
Benutzer-Quota-Management
38.6
Sicherheit und Compliance
38.6.1
Passwort-Richtlinien
38.6.2
Account-Lockout-Mechanismen
38.6.3
Audit-Protokollierung
38.6.4
Privilegierte Kontenverwaltung
38.7
Self-Service und Benutzererfahrung
38.7.1
Self-Service-Profilverwaltung
38.7.2
Passwort-Self-Service
38.7.3
Zugriffs-Anfrage-Workflows
38.8
Überwachung und Analytics
38.8.1
Identity-Provider-Performance-Überwachung
38.8.2
Zugriffsmuster-Analyse
38.8.3
Compliance-Berichte
39
Authentifizierungsmethoden
39.1
Grundlagen der OpenShift-Authentifizierung
39.1.1
Multi-Protokoll-Unterstützung
39.1.2
Token-Lebenszyklus
39.2
OAuth2 und OpenID Connect
39.2.1
Authorization Code Flow
39.2.2
Client Credentials Flow
39.2.3
PKCE-Enhancement
39.2.4
OpenID Connect-Erweiterungen
39.3
SAML-basierte Authentifizierung
39.3.1
SAML-Konfiguration
39.3.2
Assertion-Validierung
39.3.3
Attribut-Mapping
39.3.4
Single Logout
39.4
LDAP und Active Directory
39.4.1
LDAP-Bind-Authentifizierung
39.4.2
Gruppen-Synchronisation
39.4.3
Verschachtelte Gruppen-Unterstützung
39.4.4
Performance-Optimierung
39.5
Zertifikat-basierte Authentifizierung
39.5.1
Certificate Authority Integration
39.5.2
Zertifikat-Widerruf
39.5.3
Smart Card Integration
39.6
Multi-Faktor-Authentifizierung
39.6.1
TOTP-Integration
39.6.2
Hardware-Token-Unterstützung
39.6.3
Risikobasierte Authentifizierung
39.7
API-Authentifizierungsmuster
39.7.1
Bearer Token Authentication
39.7.2
Service Account Tokens
39.7.3
Basic Authentication
39.7.4
API-Schlüssel
39.8
Externe Identity-Provider
39.8.1
GitHub OAuth Integration
39.8.2
Google OAuth Integration
39.8.3
Microsoft Azure AD
39.8.4
Custom OIDC Provider
39.9
Sicherheitshärtung und Best Practices
39.9.1
Brute Force Protection
39.9.2
Passwort-Richtlinien
39.9.3
Audit-Protokollierung
39.9.4
Verschlüsselung in Transit
39.10
Performance-Optimierung
39.10.1
Authentication Caching
39.10.2
Connection Pooling
39.10.3
Load Balancing
39.10.4
Geographic Distribution
40
Rollenbasierte Zugriffskontrolle (RBAC)
40.1
Grundlagen von RBAC in OpenShift
40.1.1
RBAC-Komponenten
40.1.2
Berechtigungsmodell
40.2
Rollendefinition und Berechtigungszuordnung
40.2.1
Cluster Roles
40.2.2
Namespace Roles
40.2.3
Custom Role Creation
40.3
Subject-Typen und Zuweisungsmuster
40.3.1
User Role Bindings
40.3.2
Group Role Bindings
40.3.3
Service Account Role Bindings
40.4
Berechtigungsbereiche und Ressourcenzugriff
40.4.1
Namespace-Scoped Permissions
40.4.2
Cluster-Scoped Permissions
40.4.3
Resource-Specific Permissions
40.5
Built-in Roles und Standardberechtigungen
40.5.1
Standard OpenShift Roles
40.5.2
Admin Role
40.5.3
Edit Role
40.5.4
View Role
40.6
Security Context Constraints (SCC) Integration
40.6.1
SCC-Zuweisungssteuerung
40.6.2
Privilege Escalation Prevention
40.6.3
Standard SCCs
40.7
RBAC-Audit und Compliance-Management
40.7.1
Permission Audit Trails
40.7.2
Access Review Processes
40.7.3
Role Usage Analytics
40.8
Multi-Tenancy und Isolationsstrategien
40.8.1
Tenant Isolation
40.8.2
Cross-Tenant Permission Sharing
40.9
RBAC-Integration mit externen Systemen
40.9.1
LDAP Group Integration
40.9.2
Active Directory Integration
40.9.3
Custom Authorization Webhooks
40.10
RBAC-Troubleshooting und Debugging
40.10.1
Permission Debugging
40.10.2
Access Denied Analysis
40.10.3
Role Conflict Detection
40.10.4
Effektive Berechtigungen ermitteln
40.11
Best Practices für RBAC-Implementation
41
Projektzugriffsrechte
41.1
Grundlagen der Projekt-Sicherheit
41.1.1
Projekt-Sicherheitsmodell
41.2
Projektrollen und Berechtigungen
41.2.1
Standard-Projektrollen
41.2.2
Projekt-Admin-Rolle
41.2.3
Projekt-Editor-Rolle
41.2.4
Projekt-Viewer-Rolle
41.2.5
Custom Project Roles
41.3
Benutzer- und Gruppenzuweisungen
41.3.1
Direkte Benutzerzuweisung
41.3.2
Gruppenbasierte Zuweisungen
41.3.3
Service-Account-Projektzugriff
41.3.4
Temporäre Zugriffe
41.4
Ressourcenbasierte Zugriffskontrolle
41.4.1
Ressourcentyp-Berechtigungen
41.4.2
Ressourceninstanz-Berechtigungen
41.4.3
Label-basierte Zugriffskontrolle
41.5
Cross-Projekt-Zugriff und Zusammenarbeit
41.5.1
Cross-Projekt-Service-Zugriff
41.5.2
Geteilte Ressourcen
41.5.3
Kollaborative Projektmodelle
41.6
Netzwerk-Policy-Integration
41.6.1
Projekt-Netzwerk-Isolation
41.6.2
Ingress-Traffic-Kontrolle
41.6.3
Egress-Traffic-Beschränkungen
41.7
Ressourcenquoten und Limitverwaltung
41.7.1
Compute-Ressourcenquoten
41.7.2
Storage-Quotas
41.7.3
Objekt-Anzahl-Quotas
41.8
Sicherheitsrichtlinien-Durchsetzung
41.8.1
Security Context Constraints auf Projektebene
41.8.2
Image-Sicherheitsrichtlinien
41.9
Monitoring und Audit-Integration
41.9.1
Projekt-Aktivitäts-Monitoring
41.9.2
Zugriffsmuster-Analyse
41.9.3
Compliance-Berichte
41.10
Troubleshooting von Projektzugriffsrechten
41.10.1
Häufige Zugriffsprobleme
41.10.2
Zugriffs-Debugging
41.10.3
Automatisierte Zugriffs-Bereinigung
41.11
Best Practices für Projektzugriffsrechte
42
Monitoring mit Prometheus und Grafana
42.1
Grundlagen der Prometheus-Architektur
42.1.1
Prometheus-Komponenten
42.1.2
Datenmodell und Metriken-Typen
42.2
Metriken-Sammlung und Datenmodell
42.2.1
Counter-Metriken
42.2.2
Gauge-Metriken
42.2.3
Histogram-Metriken
42.2.4
Summary-Metriken
42.3
PromQL und Query-Funktionen
42.3.1
Grundlegende PromQL-Operationen
42.3.2
Aggregationsfunktionen
42.3.3
Mathematische Operationen
42.3.4
Join-Operationen
42.4
Grafana-Visualisierung und Dashboard-Management
42.4.1
Dashboard-Architektur
42.4.2
Template-Variablen
42.4.3
Panel-Typen und Visualisierungen
42.4.4
Alerting in Grafana
42.5
Performance-Monitoring und SLA-Management
42.5.1
Application Performance Monitoring
42.5.2
Infrastructure Performance Monitoring
42.5.3
Custom Business Metrics
42.5.4
SLA-Compliance-Tracking
42.6
Alert-Management und Incident-Response
42.6.1
Alert-Rule-Definition
42.6.2
AlertManager-Konfiguration
42.6.3
Alert-Korrelation und Gruppierung
42.7
Security-Monitoring und Compliance
42.7.1
Security-Metriken
42.7.2
Compliance-Monitoring
42.8
Capacity Planning und Ressourcen-Optimierung
42.8.1
Ressourcen-Trend-Analyse
42.8.2
Cost-Optimierung
42.9
Integration mit OpenShift-Operatoren
42.9.1
Prometheus Operator
42.9.2
ServiceMonitor CRD
42.9.3
PrometheusRule CRD
42.10
Performance-Optimierung für große Cluster
42.10.1
Sharding und Federation
42.10.2
Retention und Speicher-Optimierung
42.10.3
Recording Rules für Performance
43
Zentralisiertes Logging
43.1
Grundlagen des zentralisierten Logging
43.1.1
OpenShift Logging-Stack
43.1.2
Log-Lifecycle-Management
43.2
Log-Collection-Strategien
43.2.1
DaemonSet-basierte Log-Collection
43.2.2
Sidecar-Container-Logging
43.2.3
Container-Runtime-Integration
43.3
Log-Processing und -Transformation
43.3.1
Log-Parsing und -Strukturierung
43.3.2
Log-Enrichment
43.3.3
Log-Normalization
43.3.4
Multi-Line-Log-Processing
43.4
Storage-Architekturen und Retention-Management
43.4.1
Elasticsearch-Konfiguration
43.4.2
Index Lifecycle Management
43.4.3
Hot-Warm-Cold Storage-Architektur
43.5
Search und Query-Funktionen
43.5.1
Kibana Query-Beispiele
43.5.2
Structured Queries
43.5.3
Real-Time-Log-Streaming
43.6
Sicherheit und Zugriffskontrolle
43.6.1
RBAC für Log-Zugriff
43.6.2
Log-Daten-Verschlüsselung
43.6.3
Log-Anonymisierung
43.7
Alerting-Integration
43.7.1
Log-basierte Alert-Rules
43.7.2
Prometheus-Integration für Log-Metriken
43.8
Performance-Optimierung
43.8.1
Buffering und Batch-Processing
43.8.2
Index-Optimierung
43.8.3
Resource-Management
43.9
Integration mit externen Systemen
43.9.1
SIEM-Integration
43.9.2
Cloud-Provider-Integration
43.9.3
Data Lake Integration
43.10
Kosten-Management
43.10.1
Intelligentes Log-Sampling
43.10.2
Storage-Cost-Optimierung
43.10.3
Cost-Attribution
44
EFK-Stack (Elasticsearch, Fluentd, Kibana)
44.1
Architektonische Integration des EFK-Stacks
44.1.1
Komponenten-Interaktion
44.1.2
Operator-basiertes Deployment
44.2
Elasticsearch-Integration und Index-Management
44.2.1
Cluster-Konfiguration
44.2.2
Index-Management-Strategien
44.2.3
Shard-Management
44.3
Fluentd-Konfiguration und Log-Processing
44.3.1
Input-Plugin-Konfiguration
44.3.2
Filter-Processing-Pipelines
44.3.3
Output-Plugin-Konfiguration
44.3.4
Buffer-Management-Strategien
44.4
Kibana-Visualisierung und Dashboard-Management
44.4.1
Index-Pattern-Konfiguration
44.4.2
Discovery-Interface-Nutzung
44.4.3
Visualization-Komponenten
44.4.4
Dashboard-Komposition
44.5
Log-Daten-Verarbeitung und -Anreicherung
44.5.1
Log-Normalisierung
44.5.2
Geo-Location-Anreicherung
44.5.3
User-Agent-Parsing
44.6
Performance-Optimierung
44.6.1
Elasticsearch-Performance-Tuning
44.6.2
Fluentd-Performance-Optimierung
44.6.3
Storage-Optimierung
44.7
Sicherheits-Integration
44.7.1
Elasticsearch-Sicherheitskonfiguration
44.7.2
RBAC für Log-Zugriff
44.7.3
Log-Daten-Maskierung
44.8
Alerting und Automatisierte Antworten
44.8.1
Elasticsearch Watcher
44.8.2
Anomalie-Erkennung
44.9
Multi-Cluster-Integration
44.9.1
Cross-Cluster-Log-Aggregation
44.9.2
Federated Search
45
Troubleshooting und Debugging
45.1
Grundlagen des System-Debugging
45.1.1
Debugging-Ebenen in OpenShift
45.1.2
State-Reconciliation-Analyse
45.2
Systematische Troubleshooting-Methodologien
45.2.1
Top-Down-Debugging
45.2.2
Bottom-Up-Debugging
45.2.3
Divide-and-Conquer-Strategien
45.3
Live-Debugging und Interaktive Diagnose
45.3.1
Pod-Exec-Fähigkeiten
45.3.2
Debug-Container-Injection
45.3.3
Port-Forwarding für Debugging
45.3.4
Container-Image-Debugging
45.4
Log-basierte Troubleshooting-Strategien
45.4.1
Log-Korrelations-Techniken
45.4.2
Error-Pattern-Erkennung
45.4.3
Log-Aggregation und Filterung
45.4.4
Timeline-basierte Log-Analyse
45.5
Metriken-basierte Problem-Erkennung
45.5.1
Performance-Anomalie-Erkennung
45.5.2
Resource-Sättigung-Analyse
45.6
Netzwerk-Debugging und Konnektivitäts-Analyse
45.6.1
Service-Discovery-Debugging
45.6.2
Network-Policy-Debugging
45.6.3
Traffic-Flow-Analyse
45.6.4
Load-Balancer-Debugging
45.7
Resource-Constraint-Debugging
45.7.1
Memory-Leak-Erkennung
45.7.2
CPU-Profiling-Integration
45.7.3
Storage-I/O-Analyse
45.8
Anwendungsspezifische Debugging-Techniken
45.8.1
Multi-Container-Pod-Debugging
45.8.2
Init-Container-Debugging
45.8.3
Environment-Variable-Debugging
45.9
Automatisierte Debugging-Tools
45.9.1
Health-Check-Automatisierung
45.9.2
Diagnostic-Data-Collection
45.10
Debugging-Tool-Integration
45.10.1
kubectl/oc-Integration
45.10.2
Performance-Profiling-Integration
45.10.3
Third-Party-Tool-Integration
45.11
Incident-Response und Kollaboration
45.11.1
Incident-Response-Workflow
45.11.2
Knowledge-Base-Integration
46
OpenShift Best Practices
46.1
Architektonische Designprinzipien
46.1.1
Unveränderliche Infrastruktur
46.1.2
Microservice-Architektur
46.1.3
Infrastructure as Code
46.2
Ressourcen-Management und Optimierung
46.2.1
Resource Requests und Limits
46.2.2
Quality of Service-Klassen
46.2.3
Autoscaling-Konfiguration
46.2.4
Node-Ressourcenplanung
46.3
Sicherheitshärtung und Compliance
46.3.1
Prinzip der minimalen Berechtigung
46.3.2
Netzwerk-Segmentierung
46.3.3
Image-Sicherheitspraktiken
46.4
Deployment-Strategien und Release-Management
46.4.1
Blue-Green-Deployments
46.4.2
Health Checks
46.4.3
Rolling Updates
46.4.4
Canary-Deployments
46.5
Monitoring und Observability
46.5.1
Die drei Säulen der Observability
46.5.2
SLI/SLO-Definition
46.5.3
Alert-Management
46.6
Configuration Management und GitOps
46.6.1
GitOps-Workflow
46.6.2
Environment-Konsistenz
46.6.3
Secret-Management
46.7
High Availability und Disaster Recovery
46.7.1
Multi-Zone-Deployment
46.7.2
Backup-Strategien
46.7.3
Disaster Recovery Testing
46.8
Performance-Optimierung
46.8.1
Container-Image-Optimierung
46.8.2
Application Performance Monitoring
46.8.3
Ressourcennutzungsoptimierung
46.9
Betriebsexzellenz
46.9.1
Change Management
46.9.2
Incident Response
46.9.3
Continuous Improvement
46.9.4
Dokumentationsstandards
46.10
Team-Zusammenarbeit und Skill-Entwicklung
46.10.1
Cross-funktionale Teams
46.10.2
Kontinuierliches Lernen
46.10.3
Wissensaustausch
46.11
Spezielle Überlegungen für Single-Node-Umgebungen
46.11.1
Entwicklungsumgebungsoptimierung
46.11.2
Schnelle Iterations-Workflows
46.11.3
Vereinfachte Sicherheitsmodelle
46.12
Automatisierung und Tool-Integration
46.12.1
CI/CD-Pipeline-Optimierung
46.12.2
Infrastructure-Automatisierung
46.12.3
Tool-Chain-Integration
47
Häufige Fehler und deren Lösung
47.1
Image-bezogene Probleme
47.1.1
ImagePullBackOff-Fehler
47.1.2
Tag-Probleme und Image-Versioning
47.1.3
Sicherheitslücken in Base-Images
47.2
Ressourcen-Allokation und Scheduling-Probleme
47.2.1
Pods im Pending-Status
47.2.2
OOMKilled-Container
47.2.3
CPU-Throttling
47.3
Netzwerk-Konnektivität und Service-Discovery
47.3.1
DNS-Auflösungsprobleme
47.3.2
Network Policy Blockierungen
47.3.3
Route-Konfigurationsprobleme
47.4
Storage-Integration und Persistierung
47.4.1
PVC im Pending-Status
47.4.2
Volume-Mount-Fehler
47.4.3
Storage-Performance-Probleme
47.5
Authentifizierung und Autorisierung
47.5.1
RBAC-Berechtigungsfehler
47.5.2
Service Account-Probleme
47.6
Anwendungslebenszyklus und Deployment-Probleme
47.6.1
Rolling Update-Failures
47.6.2
Init-Container-Fehler
47.6.3
ConfigMap und Secret-Mount-Probleme
47.7
Performance-Verschlechterung und Skalierungsprobleme
47.7.1
Memory-Leaks
47.7.2
Datenbankverbindungsprobleme
47.7.3
Auto-Scaling-Oszillation
47.8
Monitoring und Alerting-Konfigurationsfehler
47.8.1
False-Positive-Alerts
47.8.2
Fehlende kritische Alerts
47.9
Operator und Custom Resource-Probleme
47.9.1
CRD-Versionskonflikte
47.9.2
Reconciliation-Loop-Probleme
47.10
Troubleshooting-Methodik
47.10.1
Systematische Problemuntersuchung
47.10.2
Root-Cause-Analyse
47.10.3
Präventive Maßnahmen
47.11
Self-Healing und Automatisierung
47.11.1
Automatisierte Problemerkennung
47.11.2
Self-Healing-Mechanismen
47.11.3
Predictive Problem Prevention
48
Performance-Optimierung
48.1
Grundlagen der Performance-Optimierung
48.1.1
Performance-Budget-Management
48.1.2
Kontinuierliches Performance-Testing
48.2
Anwendungsebenen-Performance-Optimierung
48.2.1
Code-Optimierungsstrategien
48.2.2
Memory-Management-Optimierung
48.2.3
Datenbank-Query-Optimierung
48.2.4
Caching-Strategien
48.3
Container-Performance-Tuning
48.3.1
Container-Resource-Right-Sizing
48.3.2
Container-Startup-Zeit-Optimierung
48.3.3
Runtime-Performance-Tuning
48.4
Cluster-Ebenen-Performance-Enhancement
48.4.1
Node-Resource-Optimierung
48.4.2
Scheduler-Performance-Optimierung
48.4.3
etcd-Performance-Tuning
48.4.4
API-Server-Performance-Enhancement
48.5
Netzwerk-Performance-Optimierung
48.5.1
Service-Mesh-Performance-Tuning
48.5.2
CNI-Plugin-Optimierung
48.5.3
Load-Balancer-Optimierung
48.5.4
DNS-Performance-Enhancement
48.6
Storage-Performance-Enhancement
48.6.1
Storage-Backend-Auswahl
48.6.2
File-System-Tuning
48.6.3
Volume-Performance-Monitoring
48.7
Skalierungs-Performance und Auto-Scaling-Optimierung
48.7.1
Horizontal Pod Autoscaler-Tuning
48.7.2
Vertical Pod Autoscaler-Konfiguration
48.7.3
Custom Metrics-Skalierung
48.8
Monitoring-Performance und Observability-Effizienz
48.8.1
Metriken-Sammlung-Optimierung
48.8.2
Log-Processing-Performance-Tuning
48.8.3
Dashboard-Performance-Enhancement
48.9
Memory-Management und Garbage-Collection-Optimierung
48.9.1
JVM-Tuning für Java-Anwendungen
48.9.2
Container-Memory-Limit-Optimierung
48.9.3
Memory-Leak-Detection
48.10
CPU-Performance und Processing-Optimierung
48.10.1
CPU-Affinity-Konfiguration
48.10.2
NUMA-Topologie-Awareness
48.10.3
Concurrent-Processing-Optimierung
48.11
Single-Node-Performance-Optimierung
48.11.1
Resource-Contention-Minimierung
48.11.2
Local-Storage-Performance-Optimierung
48.11.3
System-Resource-Reservation
48.12
Automatisierte Performance-Optimierung
48.12.1
Performance-Profiling-Automatisierung
48.12.2
Self-Tuning-Systeme
48.12.3
Adaptive Ressourcen-Management
48.12.4
Predictive Performance-Skalierung
49
Wartung und Updates
49.1
Grundlagen des Platform-Lifecycle-Management
49.1.1
Versionierungs-Schema
49.1.2
Update-Channel-Management
49.1.3
Cluster Version Operator (CVO)
49.2
Sicherheits-Patch-Management
49.2.1
Security-Update-Priorisierung
49.2.2
Vulnerability-Assessment-Integration
49.2.3
Emergency-Patch-Procedures
49.3
Rolling-Update-Strategien
49.3.1
Control Plane Updates
49.3.2
Worker Node Updates
49.3.3
Operator-Update-Management
49.4
Pre-Update-Validierung und Testing
49.4.1
Compatibility-Testing
49.4.2
Backup-Verifikation
49.4.3
Performance-Baseline-Etablierung
49.5
Post-Update-Validierung
49.5.1
Health-Check-Automatisierung
49.5.2
Performance-Regressions-Testing
49.5.3
Anwendungsfunktionalitätstests
49.6
Rollback-Strategien
49.6.1
Automatisierte Rollback-Trigger
49.6.2
Point-in-Time-Recovery
49.7
Präventive Wartung
49.7.1
Resource-Cleanup-Automatisierung
49.7.2
Certificate-Renewal-Management
49.7.3
Log-Rotation und Archive-Management
49.8
Kapazitätsplanung und Growth-Management
49.8.1
Resource-Growth-Forecasting
49.8.2
Kapazitäts-Alerting
49.9
Monitoring-Integration
49.9.1
Platform-Health-Dashboards
49.9.2
Predictive Maintenance Analytics
49.10
Single-Node-Wartung
49.10.1
Resource-bewusste Wartung
49.10.2
Vereinfachte Update-Verfahren
49.11
Compliance und Audit-Integration
49.11.1
Maintenance-Audit-Trails
49.11.2
Change-Management-Integration
49.12
Performance-Impact-Minimierung
49.12.1
Wartungsfenster-Optimierung
49.12.2
Service-Verfügbarkeits-Wartung
49.12.3
Performance-Impact-Monitoring