Veröffentlicht am

Kubernetes für Bildungseinrichtungen: JupyterHub und Moodle

Teilen:
Authors

Kubernetes fuer Bildungseinrichtungen: Container-Orchestrierung an Hochschulen und Schulen

TL;DR

  • JupyterHub auf Kubernetes skaliert automatisch von 20 auf 2.000 gleichzeitige Nutzer -- ideal fuer Vorlesungen und Uebungsbetrieb.
  • Moodle und andere LMS-Plattformen laufen stabiler und wartungsaermer auf Containern als auf klassischen LAMP-Stacks.
  • Multi-Tenancy pro Fakultaet oder Fachbereich schuetzt Budgets und isoliert Workloads sauber ueber Namespaces.
  • Spot-Instanzen und Cluster-Autoscaler senken die Cloud-Kosten um 40-60 % gegenueber statisch provisionierten VMs.
  • Forschungscluster mit GPU-Workloads (ML, Simulationen) profitieren von Kubernetes-nativer Ressourcenverwaltung.

Ausgangslage: IT-Herausforderungen im Bildungsbereich

Hochschulen und grosse Schultraeger stehen vor einem Dilemma: Die Anforderungen an die IT steigen -- digitale Lehre, Forschungsdatenmanagement, hybride Lernformate -- waehrend die Budgets knapp bleiben und IT-Fachkraefte schwer zu finden sind.

Typische Schmerzpunkte:

  • Semesterstart-Peaks: Tausende Studierende greifen gleichzeitig auf JupyterHub, Moodle oder Laborumgebungen zu. Statisch provisionierte Server kollabieren.
  • Heterogene Anforderungen: Die Informatik braucht GPU-Nodes, die Geisteswissenschaften ein stabiles LMS, die Verwaltung ein ERP-System. Alles auf getrennter Infrastruktur.
  • Forschungsprojekte: Zeitlich begrenzte Cluster fuer ML-Training, Simulationen oder Datenanalyse. Nach Projektende werden die Ressourcen nicht freigegeben.
  • Wartungsaufwand: Dutzende VMs mit unterschiedlichen Betriebssystemen und Konfigurationen. Updates dauern Wochen.

Kubernetes loest diese Probleme durch eine einheitliche Plattform, die Workloads automatisch skaliert, Ressourcen effizient verteilt und ueber deklarative Konfiguration wartbar bleibt.

JupyterHub auf Kubernetes: Der wichtigste Use Case

JupyterHub ist das zentrale Werkzeug fuer datengetriebene Lehre in MINT-Faechern. Die offizielle Helm Chart Zero to JupyterHub macht den Betrieb auf Kubernetes zum Standard-Setup.

Installation mit Helm

# Helm Repo hinzufuegen
helm repo add jupyterhub https://hub.jupyter.org/helm-chart/
helm repo update

# JupyterHub installieren
helm upgrade --install jhub jupyterhub/jupyterhub \
  --namespace jupyterhub \
  --create-namespace \
  --version 4.0.0 \
  --values jupyterhub-values.yaml

Konfiguration fuer den Lehrbetrieb

# jupyterhub-values.yaml
proxy:
  service:
    type: ClusterIP
  https:
    enabled: true

hub:
  config:
    Authenticator:
      admin_users:
        - prof.mueller
        - prof.schmidt
    GenericOAuthenticator:
      client_id: jupyterhub
      authorize_url: https://sso.hochschule.de/auth/realms/hochschule/protocol/openid-connect/auth
      token_url: https://sso.hochschule.de/auth/realms/hochschule/protocol/openid-connect/token
      userdata_url: https://sso.hochschule.de/auth/realms/hochschule/protocol/openid-connect/userinfo
      scope:
        - openid
        - profile
        - email

singleuser:
  image:
    name: registry.hochschule.de/jupyter/datascience
    tag: "2026.1"
  memory:
    limit: 4G
    guarantee: 1G
  cpu:
    limit: 2
    guarantee: 0.5
  storage:
    capacity: 10Gi
    dynamic:
      storageClass: managed-nfs
  profileList:
    - display_name: "Standard (Python, R)"
      description: "Fuer Uebungen und Hausaufgaben"
      default: true
    - display_name: "Data Science (GPU)"
      description: "Mit GPU-Zugriff fuer ML-Kurse"
      kubespawner_override:
        extra_resource_limits:
          nvidia.com/gpu: "1"
        node_selector:
          gpu-type: nvidia-t4

scheduling:
  userScheduler:
    enabled: true
  userPlaceholder:
    enabled: true
    replicas: 5

cull:
  enabled: true
  timeout: 3600
  every: 300

Wichtige Details:

  • SSO-Integration: Studierende melden sich ueber das hochschuleigene Identity Management an (Shibboleth oder Keycloak). Keine separaten Accounts noetig.
  • Profile: Verschiedene Umgebungen fuer unterschiedliche Kurse. Data-Science-Kurse bekommen GPU-Zugriff, Grundkurse arbeiten CPU-only.
  • Culling: Inaktive Notebooks werden nach 60 Minuten automatisch gestoppt. Das spart Ressourcen und verhindert, dass vergessene Sessions den Cluster belasten.
  • Placeholder Pods: 5 leere Pods halten Ressourcen vor, damit die naechsten 5 Studierenden sofort starten koennen, ohne auf Node-Scaling zu warten.

Moodle auf Kubernetes

Moodle ist das meistgenutzte LMS an europaeischen Hochschulen. Der Betrieb auf Kubernetes bietet gegenueber dem klassischen LAMP-Stack erhebliche Vorteile.

Deployment-Konfiguration

apiVersion: apps/v1
kind: Deployment
metadata:
  name: moodle
  namespace: lms
spec:
  replicas: 3
  selector:
    matchLabels:
      app: moodle
  template:
    metadata:
      labels:
        app: moodle
    spec:
      containers:
      - name: moodle
        image: registry.hochschule.de/lms/moodle:4.5.2
        ports:
        - containerPort: 8080
        env:
        - name: MOODLE_DATABASE_HOST
          value: "mariadb.lms.svc.cluster.local"
        - name: MOODLE_DATABASE_NAME
          value: "moodle"
        - name: MOODLE_DATABASE_USER
          valueFrom:
            secretKeyRef:
              name: moodle-db-credentials
              key: username
        - name: MOODLE_DATABASE_PASSWORD
          valueFrom:
            secretKeyRef:
              name: moodle-db-credentials
              key: password
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "2"
            memory: "4Gi"
        volumeMounts:
        - name: moodle-data
          mountPath: /bitnami/moodle
      volumes:
      - name: moodle-data
        persistentVolumeClaim:
          claimName: moodle-data-pvc
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: moodle-hpa
  namespace: lms
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: moodle
  minReplicas: 3
  maxReplicas: 15
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60

Mit dem HPA skaliert Moodle automatisch hoch, wenn hunderte Studierende gleichzeitig Pruefungen ablegen. Auf einem klassischen LAMP-Stack waere das ein manueller Eingriff -- oder ein Ausfall.

Multi-Tenancy fuer Fakultaeten

Jede Fakultaet oder jeder Fachbereich erhaelt einen eigenen Namespace mit Budget-Begrenzung. So wird verhindert, dass ein einzelnes Forschungsprojekt den gesamten Cluster belegt. Details zur Umsetzung unter Kubernetes Multi-Tenancy in regulierten Umgebungen.

apiVersion: v1
kind: Namespace
metadata:
  name: fakultaet-informatik
  labels:
    fakultaet: informatik
    budget-owner: dekanat-informatik
---
apiVersion: v1
kind: ResourceQuota
metadata:
  name: informatik-quota
  namespace: fakultaet-informatik
spec:
  hard:
    requests.cpu: "64"
    requests.memory: "128Gi"
    limits.cpu: "128"
    limits.memory: "256Gi"
    requests.nvidia.com/gpu: "4"
    persistentvolumeclaims: "50"
    pods: "200"

Kostenverteilung mit Labels

# Kosten pro Fakultaet auswerten (mit kubecost oder opencost)
kubectl get pods --all-namespaces \
  -l fakultaet=informatik \
  -o custom-columns=\
"NAMESPACE:.metadata.namespace,\
POD:.metadata.name,\
CPU_REQ:.spec.containers[*].resources.requests.cpu,\
MEM_REQ:.spec.containers[*].resources.requests.memory"

Fuer eine detaillierte Kostenanalyse mit OpenCost oder Kubecost siehe Kubernetes Kosten-Optimierung: Praxis-Guide.

Forschungscluster: GPU-Workloads und HPC

Forschungsteams benoetigen temporaer grosse Rechenkapazitaeten -- etwa fuer ML-Training, Stroemungssimulationen oder Genomanalysen. Kubernetes kann diese Workloads als Jobs oder CronJobs ausfuehren und die Ressourcen danach automatisch freigeben.

ML-Training Job

apiVersion: batch/v1
kind: Job
metadata:
  name: nlp-training-run-042
  namespace: fakultaet-informatik
  labels:
    projekt: nlp-forschung
    betreuer: prof-weber
spec:
  backoffLimit: 2
  activeDeadlineSeconds: 86400
  template:
    spec:
      restartPolicy: Never
      nodeSelector:
        gpu-type: nvidia-a100
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"
      containers:
      - name: training
        image: registry.hochschule.de/research/nlp-trainer:0.9.3
        resources:
          requests:
            cpu: "8"
            memory: "32Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "16"
            memory: "64Gi"
            nvidia.com/gpu: "2"
        volumeMounts:
        - name: datasets
          mountPath: /data
        - name: results
          mountPath: /output
      volumes:
      - name: datasets
        persistentVolumeClaim:
          claimName: shared-datasets
      - name: results
        persistentVolumeClaim:
          claimName: nlp-results

Fuer den Aufbau dedizierter GPU-Cluster siehe GPU-Cluster mit Kubernetes.

Studentische Laborumgebungen

Fuer Informatik-Praktika und DevOps-Kurse koennen Studierende eigene Mini-Cluster als Namespaces erhalten. Ein Self-Service-Portal erstellt auf Knopfdruck eine isolierte Umgebung mit vorkonfigurierten Tools. Einen praktischen Einstieg bietet Kubernetes Hands-on: Erste Schritte.

# Namespace fuer Studierenden anlegen
kubectl create namespace student-max-mustermann

# Resource Quota setzen (begrenzt auf Laborbedarf)
kubectl apply -n student-max-mustermann -f - <<EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: student-quota
spec:
  hard:
    requests.cpu: "2"
    requests.memory: "4Gi"
    limits.cpu: "4"
    limits.memory: "8Gi"
    pods: "10"
    services: "3"
EOF

# RBAC: Studierender darf nur im eigenen Namespace arbeiten
kubectl apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: student-admin
  namespace: student-max-mustermann
subjects:
- kind: User
  name: max.mustermann@hochschule.de
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: edit
  apiGroup: rbac.authorization.k8s.io
EOF

Kostenmanagement

Bildungseinrichtungen arbeiten mit festen Jahresbudgets. Die folgenden Massnahmen halten die Kosten planbar:

MassnahmeEinsparungAufwand
Cluster-Autoscaler (Nodes nachts herunterfahren)30-40 %gering
Spot-Instanzen fuer Batch-Jobs40-60 %mittel
Pod-Culling (inaktive JupyterHub-Sessions)20-30 %gering
Resource Quotas pro Fakultaetverhindert Kostenexplosiongering
Shared Storage (NFS/Ceph) statt Block pro Pod15-25 %mittel

Ein typischer Hochschul-Cluster mit 200-500 aktiven Nutzern kostet in der Cloud 2.000-5.000 EUR pro Monat. On-premise fallen Hardwarekosten von 30.000-80.000 EUR an, die sich ueber 3-5 Jahre amortisieren.

Typische Stolpersteine

Storage-Planung: JupyterHub erzeugt pro Nutzer ein PersistentVolume. Bei 2.000 Studierenden sind das 2.000 PVs. Planen Sie die Storage-Kapazitaet entsprechend und nutzen Sie dynamische Provisioner.

Semesterstart-Peaks: In der ersten Vorlesungswoche greifen alle Studierenden gleichzeitig zu. Placeholder Pods und vorgewarmte Nodes verhindern lange Wartezeiten.

Rechte-Eskalation: Studierende experimentieren. Pod Security Standards und Network Policies sind Pflicht, damit ein neugieriger Student nicht den gesamten Cluster kompromittiert.

Datenschutz: Forschungsdaten koennen personenbezogen sein (Umfragen, medizinische Daten). Namespace-Isolation und Encryption at Rest sind keine Option, sondern Voraussetzung.

Fazit

Kubernetes ist fuer Bildungseinrichtungen eine Plattform, die heterogene Anforderungen -- Lehre, Forschung, Verwaltung -- auf einer einheitlichen Infrastruktur zusammenfuehrt. Die Kombination aus JupyterHub fuer die Lehre, GPU-Jobs fuer die Forschung und stabilen LMS-Deployments fuer den Alltag macht den Cluster zur zentralen IT-Ressource. Mit Spot-Instanzen, Autoscaling und konsequentem Resource Management bleiben die Kosten auch bei knappen Budgets planbar.

Wenn Sie Unterstuetzung beim Aufbau einer Kubernetes-Plattform fuer Ihre Hochschule oder Ihren Schultraeger brauchen -- von der Architekturberatung bis zur JupyterHub-Installation -- sprechen Sie uns an unter /kontakt.

Diskutieren auf Twitter

Kubernetes-Beratung gesucht?

Wir helfen deutschen Unternehmen bei der Kubernetes-Implementierung, Migration und Optimierung. DSGVO-konform und praxiserprobt.

Termin buchenKontakt aufnehmen

📖 Verwandte Artikel

Weitere interessante Beiträge zu ähnlichen Themen

Alle Artikel durchsuchen