20 Hauptfunktionen der Web-Konsole

Die OpenShift Web-Konsole vereint umfassende Cluster-Verwaltungsfunktionen in einer einheitlichen grafischen Benutzeroberfläche. Diese Funktionsvielfalt erstreckt sich von grundlegender Ressourcenverwaltung bis hin zu fortgeschrittenen DevOps-Workflows und ermöglicht effiziente Cluster-Administration ohne Kommandozeilen-Kenntnisse.

20.1 Dashboard und Cluster-Übersicht

Das zentrale Dashboard liefert aggregierte Cluster-Metriken und Statusinformationen in Form von Widgets und grafischen Darstellungen. Diese Übersichtsfunktion ermöglicht schnelle Bewertung der Cluster-Gesundheit und Identifikation von Performance-Problemen.

Diagramm: Web-Konsole Funktionsübersicht

20.1.1 Home Dashboard Komponenten

Widget Information Anwendung
Cluster Overview Node-Status, Pod-Anzahl, Storage-Nutzung Schneller Gesundheitscheck
Top Consumers CPU/Memory-intensivste Pods/Projekte Performance-Analyse
Capacity Planning Ressourcen-Trends und -Prognosen Kapazitätsplanung
Recent Events Cluster-Events der letzten Stunden Problem-Identifikation
Inventory Ressourcen-Aufschlüsselung nach Typ Bestandsübersicht

20.1.2 Dashboard-Personalisierung

Widget-Management: 1. Customize Dashboard (Zahnrad-Icon) klicken 2. Widgets hinzufügen/entfernen nach Bedarf 3. Widget-Reihenfolge per Drag & Drop anpassen 4. Zeiträume konfigurieren für Metrik-Widgets

Häufig genutzte Dashboard-Konfigurationen: - Developer-Focus: Application Health, Build Status, Deployment-Trends - Administrator-Focus: Node Health, Resource Quotas, Security Alerts - Operations-Focus: Performance Metrics, Capacity Utilization, Error Rates

20.2 Projektmanagement

Die Projektverwaltungsfunktionen ermöglichen Erstellung, Konfiguration und Löschung von OpenShift-Projekten über intuitive grafische Interfaces.

20.2.1 Projekt erstellen und konfigurieren

Neues Projekt erstellen: 1. Home → Projects navigieren 2. Create Project Button klicken 3. Projekt-Details eingeben: - Name: Eindeutiger Projektname (nur Kleinbuchstaben, Zahlen, Bindestriche) - Display Name: Benutzerfreundlicher Name - Description: Projektbeschreibung 4. Create bestätigen

Projekt-Konfiguration:

# Beispiel-Projektkonfiguration über YAML-Editor
apiVersion: project.openshift.io/v1
kind: Project
metadata:
  name: web-application
  annotations:
    openshift.io/description: "Web Application Development Project"
    openshift.io/display-name: "Web App Development"
  labels:
    team: frontend-developers
    environment: development

20.2.2 Resource Quotas und Limits

Resource Quotas über Web-Konsole setzen: 1. Administration → ResourceQuotas navigieren 2. Create ResourceQuota klicken 3. Limits konfigurieren: - CPU-Requests/Limits - Memory-Requests/Limits - Storage-Requests - Pod-Anzahl

Resource-Typ Beispiel-Limit Zweck
CPU Requests 4 cores Garantierte CPU-Zuteilung
Memory Requests 8 GB Garantierter RAM
Storage Requests 100 GB Persistent Volume-Kapazität
Pod Limits 50 Maximale Pod-Anzahl

20.2.3 Team-Collaboration

Benutzer zu Projekt hinzufügen: 1. Project → RoleBindings navigieren 2. Create Binding klicken 3. Role auswählen: admin, edit, view 4. Subject definieren: User, Group, oder ServiceAccount 5. Create bestätigen

Standard-Rollen: - admin: Vollzugriff auf Projekt-Ressourcen - edit: Lesen/Schreiben von Anwendungsressourcen - view: Nur-Lese-Zugriff auf Ressourcen

20.3 Anwendungsdeployment

Die Web-Konsole bietet mehrere Wege für Anwendungsdeployment, von einfachen Git-Repositories bis zu komplexen Multi-Container-Anwendungen.

20.3.1 Source-to-Image (S2I) Deployment

Git-Repository direkt deployen: 1. +Add → Import from Git wählen 2. Git Repo URL eingeben: https://github.com/openshift/nodejs-ex.git 3. Builder Image wird automatisch erkannt (Node.js) 4. Application Name: nodejs-sample-app 5. Name: nodejs-ex 6. Advanced Options erweitern bei Bedarf: - Environment Variables - Build Configuration - Deployment Configuration - Scaling Options 7. Create klicken

Deployment-Workflow verfolgen: - Topology-View: Visualisiert Build- und Deployment-Progress - Builds-Section: Zeigt Build-Logs und -Status - Events: Zeigt Deployment-Events und Fehlermeldungen

20.3.2 Container Image Deployment

Externe Container Images deployen: 1. +Add → Container Image wählen 2. Image Name eingeben: registry.redhat.io/ubi8/httpd-24 3. Application Details konfigurieren 4. Runtime Icon auswählen für Topology-Darstellung 5. Create bestätigen

20.3.3 Helm Charts

Helm Chart-Installation: 1. +Add → Helm Chart wählen 2. Chart Repository durchsuchen 3. Chart auswählen (z.B. PostgreSQL, Redis) 4. Configuration Values anpassen 5. Install klicken

20.4 Build und Pipeline-Management

Die Web-Konsole integriert Tekton Pipelines für CI/CD-Workflows und bietet grafische Pipeline-Editoren.

20.4.1 Build-Konfiguration

Build-Status überwachen: - Builds → BuildConfigs: Alle Build-Konfigurationen anzeigen - Build-History: Vergangene Builds und deren Status - Build-Logs: Detaillierte Build-Ausgaben

Build-Trigger konfigurieren: 1. BuildConfig auswählen 2. YAML-Tab → Triggers-Section 3. Webhook-URLs für Git-Integration kopieren 4. GitHub/GitLab-Webhook mit URL konfigurieren

20.4.2 Tekton Pipelines

Pipeline erstellen: 1. Pipelines → Create Pipeline klicken 2. Pipeline Builder verwenden oder YAML-Editor 3. Tasks definieren: - git-clone - build-image - deploy-application 4. Pipeline-Runs starten und überwachen

Pipeline-Visualisierung:

Git Clone → Build Image → Test → Deploy → Integration Tests
    ↓           ↓         ↓       ↓            ↓
  Success    Success   Failed   Skipped     Skipped

20.5 Monitoring und Observability

Die Web-Konsole integriert Prometheus-basierte Metriken und bietet umfassende Monitoring-Capabilities.

20.5.1 Observe-Dashboard

Verfügbare Monitoring-Bereiche: - Dashboards: Vordefinierte Grafana-Dashboards - Metrics: Prometheus-Query-Interface - Alerts: Alert-Rules und aktive Alerts - Events: Cluster-weite Events und Korrelationen

20.5.2 Custom Dashboards

Dashboard erstellen: 1. Observe → Dashboards → Create Dashboard 2. Panels hinzufügen: - Graph Panel: Zeitreihen-Metriken - Singlestat Panel: Einzelwerte - Table Panel: Tabellarische Daten 3. Prometheus-Queries definieren: ```promql # CPU-Nutzung pro Pod rate(container_cpu_usage_seconds_total[5m])

# Memory-Nutzung container_memory_usage_bytes / container_spec_memory_limit_bytes * 100 ```

20.5.3 Alerting

Alert-Rules konfigurieren: 1. Observe → Alerting → Create Alert Rule 2. Prometheus-Query für Alert-Bedingung 3. Thresholds und Duration festlegen 4. Notification-Channels konfigurieren

Beispiel-Alert:

# Hohe Pod-Memory-Nutzung
expr: (container_memory_usage_bytes / container_spec_memory_limit_bytes) > 0.9
for: 5m
labels:
  severity: warning
annotations:
  summary: "High memory usage detected"

20.6 Networking und Service-Management

Die Web-Konsole bietet intuitive Tools für Service-Discovery und Netzwerk-Konfiguration.

20.6.1 Service-Verwaltung

Service erstellen: 1. Networking → Services → Create Service 2. Service-Typ wählen: ClusterIP, NodePort, LoadBalancer 3. Port-Mapping konfigurieren: - Port: Externer Port (80) - Target Port: Container-Port (8080) - Protocol: TCP/UDP 4. Selector definieren: Labels für Pod-Auswahl

20.6.2 Route-Management

HTTP-Route erstellen: 1. Networking → Routes → Create Route 2. Service auswählen aus Dropdown 3. Hostname definieren: myapp.apps.cluster.example.com 4. Path-Routing konfigurieren bei Bedarf 5. TLS-Settings: - Edge Termination: TLS am Router terminieren - Passthrough: End-to-End-Verschlüsselung - Re-encrypt: Router-zu-Pod-Verschlüsselung

20.6.3 Network Policies

Micro-Segmentierung konfigurieren: 1. Networking → NetworkPolicies → Create NetworkPolicy 2. Pod-Selector: Welche Pods sind betroffen 3. Ingress-Rules: Eingehender Traffic 4. Egress-Rules: Ausgehender Traffic

Beispiel-NetworkPolicy (Default Deny):

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

20.7 Storage-Management

Die Web-Konsole vereinfacht komplexe Storage-Konzepte durch grafische Interfaces.

20.7.1 Persistent Volume Claims

PVC erstellen: 1. Storage → PersistentVolumeClaims → Create PVC 2. Storage Class wählen 3. Access Mode definieren: - ReadWriteOnce: Single-Node Read/Write - ReadOnlyMany: Multi-Node Read-Only - ReadWriteMany: Multi-Node Read/Write 4. Size angeben (z.B. 10Gi)

20.7.2 Volume-Snapshots

Snapshot erstellen: 1. Storage → VolumeSnapshots → Create VolumeSnapshot 2. Source PVC auswählen 3. Snapshot-Name vergeben 4. Create bestätigen

Snapshot wiederherstellen: 1. Neue PVC erstellen 2. Data Source: VolumeSnapshot auswählen 3. Snapshot-Name angeben

20.8 Security und Compliance

Die Web-Konsole bietet umfangreiche Sicherheitsfunktionen für Enterprise-Anforderungen.

20.8.1 Security Context Constraints (SCCs)

SCC-Management: 1. Administration → SecurityContextConstraints 2. Verfügbare SCCs: restricted, anyuid, privileged, etc. 3. Custom SCC erstellen bei speziellen Anforderungen

SCC Sicherheitslevel Anwendungsbereich
restricted Sehr hoch Standard-Anwendungen
anyuid Mittel Legacy-Anwendungen
privileged Niedrig System-Services

20.8.2 Certificate Management

TLS-Zertifikate verwalten: 1. Workloads → Secrets → Create Secret 2. Secret Type: TLS 3. Certificate und Private Key hochladen 4. Secret in Route verwenden für HTTPS

20.8.3 RBAC-Verwaltung

Rollen und Berechtigungen: 1. Administration → Roles für Cluster-weite Rollen 2. Project → RoleBindings für Projekt-spezifische Berechtigungen 3. Custom Roles für spezielle Anwendungsfälle erstellen

20.9 Multi-Cluster-Management

Für Organisationen mit mehreren OpenShift-Clustern bietet die Web-Konsole zentrale Verwaltungsfeatures.

20.9.1 Advanced Cluster Management (ACM)

Cluster-Fleet-Management: - Cluster-Übersicht: Status aller verwalteten Cluster - Policy-Management: Governance-Policies für alle Cluster - Application-Lifecycle: Multi-Cluster-Application-Deployment

20.9.2 Cluster-übergreifende Features

GitOps-Integration: - ArgoCD-Integration für Application-Delivery - Config-Management über Git-Repositories - Multi-Environment-Promotion (Dev → Test → Prod)

Die Web-Konsole macht OpenShift-Management zugänglich für verschiedene Nutzergruppen und reduziert die Notwendigkeit für tiefgreifende Kubernetes-Kenntnisse. Die grafischen Interfaces abstrahieren Komplexität, ohne dabei Funktionalität zu opfern, und ermöglichen effiziente Cluster-Verwaltung für sowohl Einzelpersonen als auch große Teams.