← Zurück zum Blog
8 Min. LesezeitDE

Von 24 Containern zu Kubernetes:
eine echte AWS-Migration als Fallstudie

Eine praxisnahe Aufschlüsselung, wie ich eine produktive CX-Plattform mit 24 nur lose verwalteten Containern auf ein solides Kubernetes-Setup in AWS umgestellt habe – mit den konkreten Abwägungen, den Zahlen und dem, was ich heute anders machen würde.

KubernetesAWSDevOpsGitLab CI/CDHashiCorp VaultFallstudie

Die Ausgangslage

Ich bin Abdelhamid NOIRA, DevOps-Ingenieur mit Sitz in Casablanca, Marokko. Im Rahmen eines Einsatzes bei der Tersea Groupe habe ich an Deskea gearbeitet, ihrer KI-gestützten Omnichannel-Plattform für das Kundenerlebnis. Die Anwendung lief bereits produktiv und verarbeitete echten Traffic – doch ihre Infrastruktur bestand aus 24 Containern, die größtenteils von Hand ausgerollt und verwaltet wurden, ohne eine Orchestrierungsschicht, die sie zusammenhielt.

Das ist ein typischer Zustand für ein wachsendes Produkt: containerisiert, weil früh jemand erkannt hatte, dass Docker die richtige Entscheidung war, aber nie weitergegangen zur echten Orchestrierung. Skalieren hieß, sich per SSH auf Maschinen einzuloggen. Deployments hießen, Container manuell neu zu starten. Es gab kein einheitliches Secret-Management, keinen Blue-Green-Rollout und keine echte Observability jenseits einfacher Verfügbarkeitschecks.

Warum ausgerechnet Kubernetes

Kubernetes ist für 24 Container nicht immer die richtige Antwort – viele Teams betreiben diese Größenordnung problemlos mit ECS oder einem gut organisierten Compose-Setup. Hier war es sinnvoll, weil die Produkt-Roadmap eine Multi-Region-Expansion vorsah und das Team ein einheitliches Deployment-Modell über alle Umgebungen hinweg wollte (Staging, Produktion und später eine zweite AWS-Region). Diese Anforderungen – deklarative Rollouts, Umgebungsparität und horizontale Skalierung bei Bedarf – sind genau das, wofür Kubernetes gebaut wurde.

AWS (EKS)
Verwaltete Control Plane – keine Zeit mehr damit verbringen, etcd oder den API-Server von Hand zu betreiben
Helm
Jeder Service als Chart verpackt und gemeinsam mit dem Anwendungscode versioniert
GitLab CI/CD
Vollautomatische Pipelines: Build, Test, Scan, Deployment – ohne manuelle Schritte
HashiCorp Vault
Zentrales Secret-Management, das fest eingetragene Env-Dateien ersetzt
Prometheus & Grafana
Echte Cluster- und Anwendungsmetriken statt einfacher Verfügbarkeitschecks
Ansible
Rollenbasiertes Provisioning für alles außerhalb des Clusters selbst

Der Migrationsansatz

Ich habe nicht alle 24 Container auf einmal verschoben. Jeder Service wurde einzeln migriert, beginnend mit den risikoärmsten, zustandslosen – interne APIs ohne direkten Kundentraffic – bevor ich irgendetwas anfasste, das kundennah war. Jeder Service erhielt sein eigenes Helm-Chart, und Secrets, die zuvor in Klartext-Umgebungsdateien lagen, wurden in Vault verschoben und zur Laufzeit injiziert.

Für die Rollouts richtete ich Blue-Green-Deployments für die Services mit dem meisten Traffic und Canary-Releases für alle anderen ein, abgesichert durch die GitLab-CI/CD-Pipeline. So konnte ein fehlerhaftes Deployment automatisch erkannt und zurückgerollt werden, bevor es den Großteil des Traffics erreichte – statt eines kompletten Ausfalls, während jemand einen Container von Hand zurücksetzt.

Ansible übernahm das, was nicht in den Cluster gehörte – etwa DNS-Einträge, IAM-Rollen und die Bootstrap-Konfiguration neuer Umgebungen –, sodass das gesamte Provisioning, Cluster und umgebende Infrastruktur gleichermaßen, reproduzierbar blieb und nicht mehr in den Köpfen einzelner Personen steckte.

Die Ergebnisse

15 %
Geringere Infrastrukturkosten
Durch passend dimensionierte Node-Pools und Autoscaling statt statischer Überprovisionierung
10 %
Bessere Performance
Durch saubere Resource-Requests/-Limits und horizontales Pod-Autoscaling
99,9 %
Verfügbarkeit
Blue-Green- und Canary-Rollouts fangen fehlerhafte Deployments ab, bevor sie sich ausbreiten

Keine dieser Zahlen stammt aus einer einzelnen großen Änderung – sie entstanden durch die Summe kleiner, richtiger Standardeinstellungen: Container, die nur die CPU und den Speicher anfordern, die sie wirklich nutzen; ein Cluster-Autoscaler, der Nodes je nach realer Nachfrage hinzufügt und entfernt; und eine Deployment-Pipeline, die den sicheren Weg zugleich zum schnellsten Weg macht.

Was ich anders machen würde

Observability früher einführen
Prometheus und Grafana kamen mitten in der Migration dazu. Rückblickend hätten echte Metriken ab dem ersten Tag den Vorher-nachher-Vergleich – und das Kostenargument gegenüber den Stakeholdern – deutlich klarer gemacht.
Namespace-Isolation von Anfang an
Die ersten Services teilten sich länger einen Namespace, als sie sollten. Eine frühere Aufteilung nach Team oder Service-Grenze hätte das RBAC vereinfacht und die spätere Multi-Region-Trennung erleichtert.
Den Vault-Migrationspfad dokumentieren
Secrets aus den Env-Dateien herauszuholen war richtig, aber der Prozess wurde erst aufgeschrieben, nachdem er zweimal durchgeführt worden war. Ein kurzes Runbook hätte echte Zeit gespart.

Fazit

24 von Hand verwaltete Container nach Kubernetes zu migrieren, hatte nichts damit zu tun, einer Modetechnologie hinterherzulaufen – es ging darum, manuelle, fehleranfällige Abläufe durch etwas Deklaratives und Wiederholbares zu ersetzen. Die Kosten- und Performancegewinne waren real, aber der größere Erfolg war betrieblicher Natur: Deployments wurden Routine statt Risiko, und das Team musste nicht mehr wissen, auf welchem konkreten Server ein bestimmter Service gerade lief.

Wenn Sie eine Plattform ähnlicher Größe auf nicht orchestrierten Containern betreiben und überlegen, ob sich Kubernetes bei dieser Komplexität lohnt, lautet die ehrliche Antwort: Es kommt darauf an, wohin sich Ihr Produkt entwickelt. Stehen Konsistenz über mehrere Umgebungen, Autoscaling und sicherere Rollouts tatsächlich auf Ihrer Roadmap, amortisiert sich die Migration schnell. Wenn nicht, ist es womöglich nur zusätzlicher Betriebsaufwand.