Deployment und Bereitstellung

In dieser Lerneinheit erwirbst du grundlegendes Wissen über verschiedene Deploymentverfahren und deren praktische Anwendung in der Softwareentwicklung. Du lernst die wichtigsten Techniken und Best Practices kennen, um Software sicher und zuverlässig von der Entwicklungs- in die Produktionsumgebung zu überführen. Dabei erfährst du, welche Strategien sich für unterschiedliche Anwendungsfälle eignen und wie du typische Risiken beim Deployment minimieren kannst.

Einführung

Du hast eine neue Version deiner Anwendung entwickelt. Tests laufen erfolgreich, das Team ist bereit – und jetzt kommt die kritische Frage:

Wie bringst du die neue Version in die Produktionsumgebung, ohne dass deine Nutzer Ausfälle erleben oder auf Fehler stoßen?

Riskantes manuelles Deployment vs. kontrolliertes Deployment mit Strategie — Bildrechte: Ausbildung-in-der-IT.de (KI-unterstützt)

Ein falscher Deployment-Schritt kann zu Downtime führen, Daten gefährden oder Nutzer frustrieren. Die richtige Deployment-Strategie minimiert Risiken, ermöglicht schnelle Rollbacks und sorgt für einen reibungslosen Übergang.

In dieser Lerneinheit lernst du die wichtigsten Deployment-Verfahren, Konfigurationsmanagement-Tools und moderne Technologien wie Docker und Kubernetes kennen, die dir helfen, Software sicher und zuverlässig bereitzustellen.

Lernziele

Nach dieser Lerneinheit kannst du:

• die wichtigsten Deployment-Verfahren (Rolling Update, Blue-Green, Canary) erklären und ihre Vor- und Nachteile bewerten
• Konfigurationsmanagement-Tools wie Ansible, Puppet und Chef unterscheiden und für verschiedene Szenarien auswählen
• die Grundlagen von Containerisierung mit Docker verstehen und Dockerfiles lesen
• die Rolle von Kubernetes bei der Container-Orchestrierung erklären und wichtige Konzepte wie Pods, Services und Deployments anwenden
• Infrastructure as Code (IaC) als Konzept beschreiben und Grundprinzipien wie Idempotenz und Versionskontrolle einordnen

Überleitung

Um sicher von der Entwicklung zur Produktion zu kommen, brauchst du bewährte Strategien und Tools.

Beginnen wir mit den Deployment-Verfahren, die dir helfen, neue Versionen kontrolliert auszurollen.

Was sind Deploymentverfahren?

Deploymentverfahren sind Techniken, um Software sicher von der Entwicklung in die Produktionsumgebung zu bringen. Jedes Verfahren hat spezifische Stärken und eignet sich für unterschiedliche Szenarien.

Die wichtigsten Ziele:

• Verfügbarkeit maximieren: Die Anwendung bleibt während des Deployments erreichbar
• Risiken minimieren: Fehler werden früh erkannt und können schnell behoben werden
• Schnelle Rollbacks: Bei Problemen kann zur vorherigen Version zurückgekehrt werden

Die drei häufigsten Verfahren sind Rolling Update, Blue-Green-Deployment und Canary-Release.

Rolling Update: Schrittweises Ausrollen

Beim Rolling Update wird die neue Version schrittweise ausgerollt. Einzelne Instanzen werden nacheinander aktualisiert, bis alle auf der neuen Version laufen.

Vorteile:

• Minimale Downtime, da immer Instanzen verfügbar bleiben
• Einfacher Rollback möglich, da nicht alle Instanzen gleichzeitig betroffen sind

Nachteile:

• Inkonsistenzen während des Deployments: Alte und neue Version laufen parallel
• Komplexe Datenmigrationen können schwierig sein

Typische Einsatzszenarien: Microservices mit mehreren Instanzen, Webanwendungen mit Lastverteilung

Blue-Green-Deployment: Parallele Umgebungen

Beim Blue-Green-Deployment existieren zwei identische Produktionsumgebungen: Blue (aktuell aktiv) und Green (neue Version). Nach erfolgreichem Test wird der Traffic von Blue auf Green umgeschaltet.

Vorteile:

• Fast keine Downtime durch sofortigen Switch
• Einfacher Rollback durch Zurückschalten auf Blue

Nachteile:

• Doppelte Ressourcen erforderlich (höhere Kosten)
• Datensynchronisation zwischen Umgebungen kann komplex sein

Typische Einsatzszenarien: Kritische Anwendungen mit Zero-Downtime-Anforderung, große Releases mit umfangreichen Änderungen

Canary-Release: Gradueller Rollout

Beim Canary-Release wird die neue Version zunächst nur einem kleinen Teil der Nutzer zur Verfügung gestellt (die “Kanarienvögel”). Basierend auf Feedback und Monitoring wird entschieden, ob der Rollout fortgesetzt oder gestoppt wird.

Vorteile:

• Risikominimierung durch begrenzte Nutzergruppe
• Frühzeitige Fehlererkennung vor vollständigem Rollout

Nachteile:

• Komplexere Traffic-Steuerung erforderlich
• Auswahl einer repräsentativen Testgruppe kann schwierig sein

Typische Einsatzszenarien: Neue Features testen, A/B-Testing, graduelle Migration kritischer Systeme

Was ist Konfigurationsmanagement?

Konfigurationsmanagement automatisiert die Verwaltung und Konfiguration von IT-Infrastruktur. Statt jedes System manuell einzurichten, definierst du die gewünschte Konfiguration in Code und lässt Tools die Umsetzung übernehmen.

Zentrale Vorteile:

• Automatisierung: Einmal definieren, beliebig oft ausrollen
• Konsistenz: Alle Systeme haben dieselbe Konfiguration
• Wiederholbarkeit: Infrastruktur kann jederzeit neu aufgebaut werden
• Versionskontrolle: Änderungen sind nachvollziehbar und reversibel

Die drei populärsten Tools sind Ansible, Puppet und Chef.

Ansible: Einfach und agentenlos

Ansible ist bekannt für seine einfache Syntax und Agentenlosigkeit (keine Software-Installation auf Zielsystemen erforderlich). Konfigurationen werden in YAML-Playbooks geschrieben.

- hosts: webserver
  tasks:
    - name: Ensure Apache is installed
      yum:
        name: httpd
        state: present

Erklärung des Codes

Wie funktioniert das? Das Playbook definiert, dass auf den Hosts der Gruppe webserver eine Aufgabe ausgeführt wird. Die Aufgabe prüft, ob das Paket httpd (Apache Webserver) installiert ist (state: present).

Was passiert konkret? Ansible verbindet sich per SSH zu den Servern, prüft den aktuellen Zustand und installiert Apache nur, wenn es noch nicht vorhanden ist.

Warum ist das wichtig? Idempotenz: Mehrfaches Ausführen verändert nichts, wenn Apache bereits installiert ist. Das macht Ansible sicher und vorhersagbar.

Puppet: Zentral und deklarativ

Puppet arbeitet mit einer Client-Server-Architektur. Agents auf den verwalteten Systemen synchronisieren sich regelmäßig mit dem Master-Server. Konfigurationen werden in einer deklarativen Sprache geschrieben.

package { "httpd":
  ensure => installed,
}
 
service { "httpd":
  ensure => running,
  enable => true,
  require => Package["httpd"],
}

Erklärung des Codes

Wie funktioniert das? Die erste Ressource (package) stellt sicher, dass httpd installiert ist. Die zweite Ressource (service) sorgt dafür, dass der Service läuft (ensure => running) und beim Systemstart aktiviert wird (enable => true).

Was bedeutet require? Diese Abhängigkeit stellt sicher, dass das Paket installiert ist, bevor der Service gestartet wird.

Warum Puppet? Ideal für große Umgebungen mit strengen Compliance-Anforderungen, da zentral verwaltbar und auditierbar.

Chef: Flexibel mit Ruby-DSL

Chef nutzt eine auf Ruby basierende DSL (Domain-Specific Language) und arbeitet mit Konzepten wie Cookbooks (Sammlungen von Konfigurationen) und Recipes (einzelne Konfigurationsschritte).

package "httpd" do
  action :install
end
 
service "httpd" do
  action [:enable, :start]
end

Erklärung des Codes

Wie funktioniert das? Das erste Recipe installiert das Paket httpd. Das zweite Recipe aktiviert den Service und startet ihn.

Was bedeutet :enable und :start? :enable sorgt dafür, dass der Service beim Booten startet, :start startet ihn sofort.

Warum Chef? Besonders beliebt bei Entwicklern, die Ruby beherrschen und flexible, programmierbare Konfigurationen bevorzugen.

Tool-Vergleich: Ansible, Puppet, Chef

Welches Tool ist nun das richtige für dein Projekt? Die Wahl hängt von deinen spezifischen Anforderungen und der Umgebung ab.

Kriterium	Ansible	Puppet	Chef
Architektur	Agentenlos (SSH)	Client-Server (Agents)	Client-Server (Agents)
Sprache	YAML (deklarativ)	Puppet DSL (deklarativ)	Ruby DSL (prozedural)
Lernkurve	Einfach	Mittel	Steil (Ruby-Kenntnisse nötig)
Idempotenz	Ja	Ja	Ja
Best für	Schnelle Setups, Ad-hoc-Tasks	Große Umgebungen, Compliance	Entwickler mit Ruby-Kenntnissen
Community	Sehr groß	Groß	Mittel

Fazit: Die Wahl hängt von deinen Anforderungen ab. Ansible ist am einfachsten für den Einstieg, Puppet ideal für große Infrastrukturen mit strengen Regeln, Chef bietet maximale Flexibilität für erfahrene Entwickler.

⏳ Lädt Dataview-Inhalt...

Was ist Containerisierung?

Containerisierung verpackt Anwendungen und ihre Abhängigkeiten in isolierte Einheiten, die überall laufen können. Ein Container enthält alles, was die Software braucht: Code, Laufzeitumgebung, Systembibliotheken und Einstellungen.

Vorteile:

• Konsistenz: “Es läuft auf meinem Rechner” gehört der Vergangenheit an
• Isolation: Container beeinflussen sich nicht gegenseitig
• Portabilität: Läuft auf jedem System mit Container-Runtime
• Ressourceneffizienz: Leichtgewichtiger als virtuelle Maschinen

Docker ist das populärste Containerisierungs-Tool und hat sich als De-facto-Standard etabliert.

Docker: Images und Container

In Docker gibt es zwei zentrale Konzepte:

Docker Image:

Ein Image ist eine schreibgeschützte Vorlage, die alles enthält, was zum Ausführen einer Anwendung nötig ist. Es funktioniert wie ein Bauplan.

Docker Container:

Ein Container ist eine laufende Instanz eines Images. Wenn du ein Image startest, wird ein Container erzeugt. Container sind isoliert, leichtgewichtig und kurzlebig.

Analogie: Ein Image ist wie ein Rezept, ein Container ist das fertige Gericht, das du servierst.

Wichtig: Mehrere Container können vom selben Image gestartet werden, aber jeder Container läuft unabhängig.

Dockerfile: Container-Bauplan

Ein Dockerfile ist eine Textdatei mit Anweisungen, wie Docker ein Image erstellen soll. Schauen wir uns ein Beispiel an:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Erklärung des Codes

Wie funktioniert das? Das Dockerfile definiert Schritt für Schritt, wie das Image gebaut wird. Jede Zeile ist eine Anweisung an Docker.

Was passiert konkret?

• FROM python:3.12-slim: Basis-Image mit Python 3.12 (schlanke Version)
• WORKDIR /app: Arbeitsverzeichnis im Container setzen
• COPY requirements.txt .: Abhängigkeiten-Datei ins Image kopieren
• RUN pip install -r requirements.txt: Python-Pakete installieren
• COPY . .: Restlichen Code kopieren
• CMD ["python", "app.py"]: Startbefehl für den Container

Warum ist das wichtig? Das Dockerfile macht das Image reproduzierbar. Jeder kann dasselbe Image bauen und erhält exakt das gleiche Ergebnis.

Was ist Kubernetes?

Kubernetes (K8s) ist eine Open-Source-Plattform zur Orchestrierung von Containern. Während Docker Container erstellt und ausführt, kümmert sich Kubernetes um die Verwaltung vieler Container auf mehreren Servern:

• Skalierung: Automatisches Hinzufügen/Entfernen von Containern bei Last
• Selbstheilung: Neustart fehlgeschlagener Container
• Load Balancing: Verteilung des Traffics auf Container
• Rollouts/Rollbacks: Gesteuerte Updates mit Rückfall-Optionen

Kubernetes ist der De-facto-Standard für Container-Orchestrierung in der Cloud und On-Premises.

Kubernetes: Pods und Deployments

In Kubernetes sind Pods die kleinste Einheit – ein Pod enthält einen oder mehrere Container, die zusammen laufen.

Ein Deployment beschreibt den gewünschten Zustand deiner Anwendung:

• Wie viele Pod-Replicas sollen laufen?
• Welches Container-Image wird verwendet?
• Welche Update-Strategie gilt (Rolling Update, Recreate)?

Kubernetes sorgt automatisch dafür, dass der Ist-Zustand dem Soll-Zustand entspricht. Fällt ein Pod aus, startet Kubernetes automatisch einen neuen.

Kubernetes: Services und Ingress

Container in Kubernetes sind flüchtig – sie können jederzeit neu starten und neue IP-Adressen bekommen. Services lösen dieses Problem:

Service: Stabile Netzwerk-Adresse für eine Gruppe von Pods. Der Service leitet Traffic automatisch an verfügbare Pods weiter (Load Balancing).

Ingress: Regelt den externen Zugriff auf Services von außerhalb des Clusters. Ingress kann:

• HTTP(S)-Routing nach Pfaden/Domains
• SSL/TLS-Terminierung
• Load Balancing über mehrere Services

Kubernetes YAML: Deployment-Beispiel

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: myapp:1.0
        ports:
        - containerPort: 8080

Erklärung der Konfiguration

Wie: YAML-Manifest definiert ein Deployment mit 3 Replicas eines Containers. Was: replicas: 3 = 3 Pods, image: myapp:1.0 = Container-Image, containerPort: 8080 = Exposed Port. Edge Cases: Bei Image-Fehler bleibt alter Pod aktiv (Rolling Update). Warum: Deklarative Konfiguration = Kubernetes hält automatisch 3 Pods am Leben.

Was ist Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) bedeutet, dass du deine gesamte IT-Infrastruktur (Server, Netzwerke, Datenbanken) als Code beschreibst, statt sie manuell zu konfigurieren.

Vorteile:

• Wiederholbar: Infrastruktur kann jederzeit identisch neu erstellt werden
• Versioniert: Änderungen werden in Git nachvollziehbar
• Automatisiert: Kein manuelles Klicken in Cloud-Konsolen
• Konsistent: Gleiche Umgebung in Dev, Test, Produktion

Beliebte Tools: Terraform, AWS CloudFormation, Ansible

IaC: Grundprinzipien und Best Practices

Grundprinzipien von IaC:

1. Idempotenz: Mehrfaches Ausführen führt zum gleichen Ergebnis
2. Versionskontrolle: Infrastruktur-Code gehört in Git
3. Modularität: Wiederverwendbare Module statt Duplikate
4. Deklarativ: Beschreibe Was du willst, nicht Wie

Best Practices:

• Klare Dokumentation und Kommentare im Code
• Automatisiertes Testing der Infrastruktur-Änderungen
• Trennung von Umgebungen (Dev, Staging, Production)
• Secrets nie im Code, sondern in Vaults/Umgebungsvariablen

Terraform: IaC-Tool im Überblick

Terraform ist ein beliebtes IaC-Tool von HashiCorp. Du beschreibst deine Infrastruktur in HCL-Syntax (HashiCorp Configuration Language):

resource "aws_instance" "webserver" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
 
  tags = {
    Name = "WebServer"
  }
}

Terraform unterstützt viele Cloud-Provider (AWS, Azure, GCP) und On-Premises-Systeme.

Hinweis: In Lektion 8 (Praxisprojekt) wirst du Terraform hands-on anwenden.

⏳ Lädt Dataview-Inhalt...

Zusammenfassung und Ausblick

Zusammenfassung

Deploymentverfahren für sichere Software-Releases

In dieser Lerneinheit hast du die wichtigsten Deployment-Strategien kennengelernt:

• Rolling Update: Schrittweises Ausrollen mit minimaler Downtime. Einzelne Instanzen werden nacheinander aktualisiert, was einfache Rollbacks ermöglicht, aber Inkonsistenzen während des Deployments verursachen kann.
• Blue-Green-Deployment: Parallele Umgebungen (Blue und Green) für fast sofortigen Switch. Erfordert doppelte Ressourcen, bietet aber maximale Sicherheit durch einfachen Rollback.
• Canary-Release: Gradueller Rollout an eine kleine Nutzergruppe zur Risikominimierung. Ermöglicht frühzeitige Fehlererkennung, bevor die neue Version vollständig ausgerollt wird.

Konfigurationsmanagement und Automatisierung

Ansible, Puppet und Chef automatisieren die Verwaltung von IT-Infrastruktur:

• Ansible ist agentenlos und nutzt YAML-Playbooks. Ideal für schnelle Setups und Teams, die Einfachheit schätzen.
• Puppet arbeitet mit Client-Server-Architektur und deklarativer Sprache. Perfekt für große Umgebungen mit strengen Compliance-Anforderungen.
• Chef basiert auf Ruby-DSL und bietet maximale Flexibilität für Entwickler mit Programmierkenntnissen.

Alle drei Tools setzen auf Idempotenz: Mehrfaches Ausführen führt zum gleichen Ergebnis ohne ungewollte Seiteneffekte.

Containerisierung mit Docker und Kubernetes

Docker verpackt Anwendungen in Container mit allen Abhängigkeiten. Ein Dockerfile definiert, wie ein Image gebaut wird:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Kubernetes orchestriert Container in Clustern:

• Pods sind die kleinste Einheit und enthalten einen oder mehrere Container.
• Deployments beschreiben den gewünschten Zustand. Kubernetes sorgt automatisch für Skalierung und Selbstheilung.
• Services bieten stabile Netzwerk-Adressen für Pods.
• Ingress regelt den externen Zugriff auf Services.

Infrastructure as Code (IaC)

Infrastructure as Code behandelt Infrastruktur als versionierten Code. Die vier Grundprinzipien:

• Idempotenz: Wiederholte Ausführung führt zum gleichen Ergebnis
• Versionskontrolle: Änderungen sind nachvollziehbar
• Modularität: Wiederverwendbare Module
• Deklarativ: Beschreibe Was, nicht Wie

Terraform ist ein populäres IaC-Tool, das viele Cloud-Provider unterstützt und Infrastruktur über HCL-Syntax definiert.

Ausblick:

In der nächsten Lerneinheit erfährst du, wie du Build- und Release-Prozesse absicherst. Du lernst, wie Secrets Management, Dependency Checking und digitale Signaturen für sichere Deployments sorgen.

---