Anleitung: Manuelles Deployment einer Python-Anwendung auf einem Produktionsserver

Diese Anleitung beschreibt den manuellen Prozess, wie Sie Ihre containerisierte Python-Backend-Anwendung auf einem einzelnen Linux-Produktionsserver bereitstellen und aktualisieren können. Dieser Ansatz ist ideal für den Einstieg oder kleinere Projekte, bevor Sie zu einem vollautomatisierten CI/CD-System übergehen.

1. Einleitung

Im Hauptleitfaden haben wir gelernt, wie man eine Python-Anwendung containerisiert und in eine Container Registry (wie Gitea) pusht. Diese Anleitung führt Sie durch die Schritte, um das so erstellte und bereitgestellte Image auf einem dedizierten Server zum Laufen zu bringen und bei Bedarf zu aktualisieren.

2. Voraussetzungen

Produktionsserver: Ein Linux-basierter Server (physisch, VM oder VPS), zu dem Sie SSH-Zugang haben.
Docker und Docker Compose: Auf Ihrem Produktionsserver installiert.
Gitea Container Registry (oder andere Registry): Ihre Python-Anwendung muss als Docker-Image mit einem passenden Tag (z.B. your_gitea_domain_or_ip:port/your_user/your_repo:production-v1.0.0) in einer zugänglichen Registry vorhanden sein.
SSH-Client: Auf Ihrem lokalen Rechner, um sich mit dem Server zu verbinden.

3. Server-Setup (einmalig)

Diese Schritte müssen nur einmal auf Ihrem Produktionsserver durchgeführt werden.

Verbinden Sie sich per SSH mit Ihrem Produktionsserver:
```
ssh user@your_production_server_ip
```
(Ersetzen Sie user und your_production_server_ip durch Ihre tatsächlichen Daten.)
Installieren Sie Docker und Docker Compose: Befolgen Sie die offiziellen Anleitungen für Ihr Linux-System.
- Docker Engine Installationsanleitung
- Docker Compose Installationsanleitung
Melden Sie sich bei Ihrer Container Registry an: Damit Docker Images von Ihrer privaten Registry ziehen kann, müssen Sie sich einmalig authentifizieren.
```
docker login your_gitea_domain_or_ip:port
```
Geben Sie Ihren Gitea-Benutzernamen und Ihr Passwort ein, wenn Sie dazu aufgefordert werden. Für Cloud-Registries wie AWS ECR oder GCR gibt es möglicherweise spezielle Login-Befehle (siehe deren Dokumentation).
Erstellen Sie ein Verzeichnis für Ihre Anwendung:
```
mkdir ~/app-deployment
cd ~/app-deployment
```
In diesem Verzeichnis legen Sie Ihre Deployment-Konfiguration ab.

Erstellen Sie die docker-compose.prod.yml: Diese Datei definiert, wie Ihre Anwendung auf dem Produktionsserver gestartet werden soll. Nutzen Sie nano oder vi auf dem Server.

nano docker-compose.prod.yml

Fügen Sie den folgenden Inhalt ein (passen Sie die Werte an):

version: '3.8'

services:
  app:
    image: your_gitea_domain_or_ip:port/your_gitea_user/your_repo:production-v1.0.0 # <--- ANPASSEN! Das Image aus deiner Registry
    container_name: my_python_app_prod
    restart: always # Stellt sicher, dass der Container bei Neustart des Servers oder Crash automatisch startet
    environment:
      # --- PRODUKTIONS-UMGEBUNGSVARIABLEN HIER ANPASSEN ---
      - DATABASE_URL=postgres://produser:prodpass@your_prod_db_host:5432/prod_db
      - DEBUG=False
      - SOME_API_KEY=YOUR_ACTUAL_PROD_API_KEY
      # ----------------------------------------------------
    ports:
      - "80:8000" # Exponiere Port 80 des Hosts zu Port 8000 des Containers (Standard HTTP-Port)
    # --- OPTIONAL: Integration in externen Traefik ---
    # Wenn Sie einen zentralen Traefik als Reverse Proxy auf diesem Server nutzen,
    # kommentieren Sie die folgenden Zeilen ein und passen Sie sie an:
    # labels:
    #   - "traefik.enable=true"
    #   - "traefik.http.routers.my-app-prod.rule=Host(`your-prod-domain.com`)" # <--- ANPASSEN!
    #   - "traefik.http.routers.my-app-prod.entrypoints=web"
    #   - "traefik.http.services.my-app-prod.loadbalancer.server.port=8000"
    # networks:
    #   - web # Dieses Netzwerk muss von Ihrer Traefik-Instanz bereitgestellt werden (external: true in Ihrer App-compose)
# --- ENDE OPTIONAL Traefik ---

# --- OPTIONAL: Externes Traefik-Netzwerk deklarieren ---
# Nur nötig, wenn Sie die optionalen Traefik-Labels verwenden
# networks:
#   web:
#     external: true

WICHTIG: Passen Sie den image-Pfad und -Tag sowie die environment-Variablen an Ihre tatsächlichen Produktionswerte an. Wenn Sie Traefik nutzen, kommentieren Sie die entsprechenden Abschnitte ein und passen Sie diese ebenfalls an.

4. Erstes Deployment

Nachdem das Server-Setup abgeschlossen ist, können Sie Ihre Anwendung zum ersten Mal starten.

Navigieren Sie auf dem Server zum Deployment-Verzeichnis:
```
cd ~/app-deployment
```
Laden Sie das Image herunter und starten Sie die Anwendung:
```
docker-compose -f docker-compose.prod.yml pull # Lädt das spezifische Image von der Registry herunter
docker-compose -f docker-compose.prod.yml up -d # Startet die Anwendung im Hintergrund
```
Ihre Anwendung sollte nun unter der konfigurierten Adresse/Port erreichbar sein (z.B. http://your_production_server_ip oder http://your-prod-domain.com).

5. Anwendung aktualisieren

Wenn Sie Änderungen an Ihrer Anwendung vornehmen:

Entwickeln und Testen lokal: Nehmen Sie Änderungen an Ihrem Code vor, testen Sie diese lokal mit make up oder make run.
Neues Image bauen und pushen: Nach erfolgreicher lokaler Entwicklung und Tests, erstellen Sie ein neues Image und pushen es in Ihre Gitea-Registry (idealerweise mit einem neuen, eindeutigen Tag wie production-v1.0.1):
```
# Im lokalen Projektverzeichnis:
make build TAG=production-v1.0.1
make push TAG=production-v1.0.1 REGISTRY=your_gitea_domain_or_ip:port/your_gitea_user/your_repo
```
Deployment auf dem Produktionsserver:
- Verbinden Sie sich per SSH mit Ihrem Produktionsserver.
- Navigieren Sie zum Deployment-Verzeichnis:
```
cd ~/app-deployment
```
- Aktualisieren Sie den image-Tag in Ihrer docker-compose.prod.yml auf die neue Versionsnummer (z.B. von production-v1.0.0 auf production-v1.0.1).
```
nano docker-compose.prod.yml
# Ändern Sie den Image-Tag und speichern Sie.
```
- Laden Sie das neue Image herunter und aktualisieren Sie die Anwendung:
```
docker-compose -f docker-compose.prod.yml pull
docker-compose -f docker-compose.prod.yml up -d --remove-orphans
```
  Docker Compose wird erkennen, dass sich das Image geändert hat, und den alten Container durch den neuen ersetzen (Rolling Update).

6. Wichtige Überlegungen

Umgebungsvariablen: Verwenden Sie immer Umgebungsvariablen (environment: in docker-compose.prod.yml) für sensible Daten und konfigurationsspezifische Werte. Speichern Sie diese niemals direkt im Image.
Restart Policy: restart: always stellt sicher, dass Ihre Anwendung nach einem Serverneustart oder einem Crash des Containers automatisch wieder startet.
Port-Mapping: Achten Sie darauf, dass der Host-Port, den Sie in ports: definieren, auf dem Server frei ist.
Automatisierung (CI/CD): Dieser manuelle Prozess ist ein guter Start. Der nächste logische Schritt ist die Automatisierung dieser Schritte mit einem CI/CD-System (wie Gitea Actions), um den Deployment-Prozess noch effizienter und fehlerfreier zu gestalten.

Diese Anleitung sollte Ihnen einen klaren Pfad für das manuelle Deployment und die Aktualisierung Ihrer containerisierten Python-Anwendung auf einem Produktionsserver aufzeigen.

7.8 KiB Raw Permalink Blame History