145 lines
7.8 KiB
Markdown
145 lines
7.8 KiB
Markdown
# 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.
|
|
|
|
1. **Verbinden Sie sich per SSH mit Ihrem Produktionsserver:**
|
|
```bash
|
|
ssh user@your_production_server_ip
|
|
```
|
|
(Ersetzen Sie `user` und `your_production_server_ip` durch Ihre tatsächlichen Daten.)
|
|
|
|
2. **Installieren Sie Docker und Docker Compose:**
|
|
Befolgen Sie die offiziellen Anleitungen für Ihr Linux-System.
|
|
* [Docker Engine Installationsanleitung](https://docs.docker.com/engine/install/)
|
|
* [Docker Compose Installationsanleitung](https://docs.docker.com/compose/install/)
|
|
|
|
3. **Melden Sie sich bei Ihrer Container Registry an:**
|
|
Damit Docker Images von Ihrer privaten Registry ziehen kann, müssen Sie sich einmalig authentifizieren.
|
|
```bash
|
|
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).
|
|
|
|
4. **Erstellen Sie ein Verzeichnis für Ihre Anwendung:**
|
|
```bash
|
|
mkdir ~/app-deployment
|
|
cd ~/app-deployment
|
|
```
|
|
In diesem Verzeichnis legen Sie Ihre Deployment-Konfiguration ab.
|
|
|
|
5. **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.
|
|
```bash
|
|
nano docker-compose.prod.yml
|
|
```
|
|
Fügen Sie den folgenden Inhalt ein (passen Sie die Werte an):
|
|
|
|
```yaml
|
|
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.
|
|
|
|
1. **Navigieren Sie auf dem Server zum Deployment-Verzeichnis:**
|
|
```bash
|
|
cd ~/app-deployment
|
|
```
|
|
2. **Laden Sie das Image herunter und starten Sie die Anwendung:**
|
|
```bash
|
|
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:
|
|
|
|
1. **Entwickeln und Testen lokal:**
|
|
Nehmen Sie Änderungen an Ihrem Code vor, testen Sie diese lokal mit `make up` oder `make run`.
|
|
|
|
2. **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`):
|
|
```bash
|
|
# 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
|
|
```
|
|
|
|
3. **Deployment auf dem Produktionsserver:**
|
|
* **Verbinden Sie sich per SSH mit Ihrem Produktionsserver.**
|
|
* **Navigieren Sie zum Deployment-Verzeichnis:**
|
|
```bash
|
|
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`).
|
|
```bash
|
|
nano docker-compose.prod.yml
|
|
# Ändern Sie den Image-Tag und speichern Sie.
|
|
```
|
|
* **Laden Sie das neue Image herunter und aktualisieren Sie die Anwendung:**
|
|
```bash
|
|
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.
|