# Python in der Praxis

Quelle: https://inf.zone/extras/python-praxis/

**Wozu das Ganze?**

Im Kurs laufen Ihre Python- und Flask-Programme in der vorbereiteten CS50-Umgebung (Codespace oder Dev Container), in der alles schon installiert ist. Wenn Sie ein Projekt, etwa Ihr Abschlussprojekt, auf dem eigenen Rechner weiterentwickeln oder im Internet veröffentlichen wollen, müssen Sie sich selbst um Bibliotheken, Server und Sicherheit kümmern. Diese Seite zeigt die üblichen Werkzeuge dafür. Sie geht über den Stoff der Vorlesung hinaus.

> [!WARNING]
> Diese Seite ist ein **Entwurf** und wird noch erweitert. Wenn Sie Fehler finden, Ergänzungen vorschlagen möchten oder Fragen haben, melden Sie sich gerne bei uns!

> [!NOTE]
> **Hinweis zu genannten Diensten und Produkten**
> 
> Die auf dieser Seite genannten Firmen, Dienste und Produkte stellen **keine Empfehlung** dar. Es handelt sich lediglich um Beispiele zur Veranschaulichung. Es gibt zahlreiche weitere Angebote auf dem Markt, die für Ihre Zwecke ebenso oder besser geeignet sein können. Wir empfehlen, vor der Nutzung eines Dienstes die aktuellen Konditionen, Datenschutzbestimmungen und Bewertungen selbst zu prüfen.

## Virtuelle Umgebungen

Wenn Sie Python-Projekte auf Ihrem eigenen Rechner entwickeln, sollten Sie für jedes Projekt eine **virtuelle Umgebung** (Virtual Environment) verwenden. Warum?

- Verschiedene Projekte benötigen oft unterschiedliche Versionen derselben Bibliothek
- Ohne virtuelle Umgebungen installieren Sie alles „global“ – das führt schnell zu Konflikten
- Mit virtuellen Umgebungen hat jedes Projekt seine eigene, isolierte Sammlung von Bibliotheken

### venv (in Python eingebaut)

Python bringt das Modul `venv` bereits mit. Die folgenden Befehle geben Sie im Terminal ein, und zwar im Ordner Ihres Projekts (in VS Code: Menü „Terminal“ → „New Terminal“). Wählen Sie Ihr System:

**Linux/macOS:**

```bash
# Virtuelle Umgebung erstellen (einmal pro Projekt)
python3 -m venv .venv

# Aktivieren (in jedem neuen Terminal)
source .venv/bin/activate

# Pakete installieren – sie landen nur in dieser Umgebung
pip install flask

# Deaktivieren
deactivate
```

**Windows (PowerShell):**

```powershell
# Virtuelle Umgebung erstellen (einmal pro Projekt)
python -m venv .venv

# Aktivieren (in jedem neuen Terminal)
.venv\Scripts\Activate.ps1

# Pakete installieren – sie landen nur in dieser Umgebung
pip install flask

# Deaktivieren
deactivate
```

Meldet PowerShell beim Aktivieren, dass das Ausführen von Skripten deaktiviert ist, erlauben Sie es einmalig für Ihr Benutzerkonto mit `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`. Heißt der Befehl bei Ihnen nicht `python`, versuchen Sie `py`.

**Windows (CMD):**

```bat
:: Virtuelle Umgebung erstellen (einmal pro Projekt)
python -m venv .venv

:: Aktivieren (in jedem neuen Terminal)
.venv\Scripts\activate.bat

:: Pakete installieren – sie landen nur in dieser Umgebung
pip install flask

:: Deaktivieren
deactivate
```

Heißt der Befehl bei Ihnen nicht `python`, versuchen Sie `py`.

Ob die Umgebung aktiv ist, sehen Sie an der Eingabeaufforderung: Vor ihr steht dann `(.venv)`.

Der Ordner `.venv` enthält eine Kopie des Python-Interpreters und alle installierten Pakete. Er sollte **nicht** ins Git-Repository eingecheckt werden (in `.gitignore` eintragen).

### uv (moderner und schneller)

[uv](https://github.com/astral-sh/uv) ist ein modernes Tool, das `pip` und `venv` ersetzt und deutlich schneller ist:

> [!CAUTION]
> **Nie wahllos Skripte aus dem Internet laden und ausführen.** Eine Zeile wie diese lädt ein Programm aus dem Internet und reicht es sofort zum Ausführen weiter (`| bash`, `| iex`), mit allen Rechten Ihres Benutzerkontos und ohne dass Sie es vorher sehen. Wer Ihnen so eine Zeile unterschiebt, kann damit Ihre Dateien löschen, Passwörter mitlesen oder Schadsoftware einrichten. Führen Sie sie deshalb nur aus, wenn Sie der Quelle vertrauen, und genau so, wie sie dort steht: von dieser Seite (Adressen auf `inf.zone`) oder von der offiziellen Seite des Programms. Zeilen aus Foren, Chats, E-Mails, Videos oder von einer KI führen Sie nie ungeprüft aus.

```bash
# uv installieren (einmalig)
# macOS/Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows:
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

# Neues Projekt erstellen
uv init mein-projekt
cd mein-projekt

# Paket hinzufügen (erstellt automatisch virtuelle Umgebung)
uv add flask

# Programm ausführen
uv run python app.py

# Oder: Flask starten
uv run flask run
```

uv verwaltet die virtuelle Umgebung automatisch und speichert die Abhängigkeiten in einer `pyproject.toml`-Datei.

## Dependencies verwalten

Damit andere Personen (oder Sie selbst auf einem anderen Rechner) Ihr Projekt ausführen können, müssen die benötigten Bibliotheken dokumentiert werden.

### requirements.txt (klassisch)

Die einfachste Methode ist eine `requirements.txt`-Datei:

```
Flask==3.0.0
requests==2.31.0
```

Installation aller Abhängigkeiten:

```bash
pip install -r requirements.txt
```

Aktuelle Versionen Ihrer installierten Pakete in eine Datei schreiben:

```bash
pip freeze > requirements.txt
```

### pyproject.toml (modern)

Modernere Projekte verwenden `pyproject.toml`:

```toml
[project]
name = "mein-projekt"
version = "0.1.0"
dependencies = [
    "flask>=3.0.0",
    "requests>=2.31.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=7.0.0",
]
```

## Flask für Produktion

Der eingebaute Flask-Entwicklungsserver (`flask run`) ist **nicht für den Produktivbetrieb geeignet**:

- Er verarbeitet nur eine Anfrage gleichzeitig
- Er ist nicht auf Sicherheit optimiert
- Er ist langsam

Für echte Webanwendungen benötigen Sie einen WSGI-Application-Server.

### Gunicorn

[Gunicorn](https://gunicorn.org/) ist ein beliebter WSGI-Server für Linux/macOS:

```bash
# Installation
pip install gunicorn

# Flask-App starten (4 Worker-Prozesse)
gunicorn -w 4 app:app
```

Die Angabe `app:app` bedeutet: In der Datei `app.py` die Variable `app` (Ihre Flask-Anwendung) starten.

### Reverse Proxy mit nginx

In der Produktion stellt man Gunicorn typischerweise hinter einen Reverse Proxy wie [nginx](https://nginx.org/):

```
Internet → nginx (Port 80/443) → Gunicorn (Port 8000) → Flask-App
```

nginx übernimmt:
- **HTTPS/TLS-Verschlüsselung** – Gunicorn spricht nur HTTP
- **Statische Dateien** – CSS, JavaScript, Bilder werden direkt ausgeliefert
- **Load Balancing** – Anfragen auf mehrere Gunicorn-Instanzen verteilen
- **Caching** – Häufig angeforderte Inhalte zwischenspeichern

Eine einfache nginx-Konfiguration:

```nginx
server {
    listen 80;
    server_name meine-app.de;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /static {
        alias /pfad/zu/meiner/app/static;
    }
}
```

## Hosting im Internet

Es gibt verschiedene Möglichkeiten, eine Flask-App im Internet zu hosten:

### Platform-as-a-Service (PaaS)

Diese Dienste kümmern sich um Server, Deployment und Skalierung:

| Dienst | Kostenloses Tier | Besonderheiten |
|--------|------------------|----------------|
| [Render](https://render.com/) | Ja (mit Einschränkungen) | Einfaches Deployment via Git |
| [Railway](https://railway.app/) | $5 Startguthaben | Sehr entwicklerfreundlich |
| [Fly.io](https://fly.io/) | Ja (begrenzte Ressourcen) | Container-basiert, weltweit verteilt |
| [PythonAnywhere](https://www.pythonanywhere.com/) | Ja | Speziell für Python, sehr einfach |
| [Heroku](https://www.heroku.com/) | Nein (früher ja) | Klassiker, aber nicht mehr kostenlos |

### Beispiel: Deployment auf Render

1. Erstellen Sie eine Datei `render.yaml` im Projektverzeichnis:

```yaml
services:
  - type: web
    name: meine-flask-app
    env: python
    buildCommand: pip install -r requirements.txt
    startCommand: gunicorn app:app
```

2. Pushen Sie Ihr Projekt zu GitHub
3. Verbinden Sie das Repository auf [render.com](https://render.com/)
4. Render baut und deployt Ihre App automatisch

### Eigener Server (VPS)

Für mehr Kontrolle können Sie einen Virtual Private Server (VPS) mieten:

- [Hetzner](https://www.hetzner.com/) – Günstig, deutsche Server
- [DigitalOcean](https://www.digitalocean.com/) – Gute Dokumentation
- [Linode](https://www.linode.com/) – Solide Option

Auf einem VPS müssen Sie alles selbst einrichten: Linux, Python, Gunicorn, nginx, Firewall, SSL-Zertifikate, Updates, Backups …

### HTTPS mit Let's Encrypt

Für HTTPS-Verschlüsselung können Sie kostenlose Zertifikate von [Let's Encrypt](https://letsencrypt.org/) verwenden. Das Tool [Certbot](https://certbot.eff.org/) automatisiert die Einrichtung:

```bash
# Certbot installieren (Ubuntu/Debian)
sudo apt install certbot python3-certbot-nginx

# Zertifikat erstellen und nginx automatisch konfigurieren
sudo certbot --nginx -d meine-app.de
```

Certbot erneuert die Zertifikate automatisch vor Ablauf.

## Checkliste für Produktion

Bevor Sie eine Flask-App öffentlich zugänglich machen:

- [ ] **Debug-Modus deaktivieren** – `FLASK_DEBUG=0` oder `app.run(debug=False)`
- [ ] **Secret Key setzen** – Zufälligen, geheimen Schlüssel für Sessions verwenden
- [ ] **HTTPS aktivieren** – Niemals Passwörter über unverschlüsselte Verbindungen
- [ ] **Eingaben validieren** – Niemals Benutzereingaben vertrauen
- [ ] **SQL-Injection verhindern** – Prepared Statements verwenden (wenn Sie eine DB nutzen)
- [ ] **Fehlerseiten anpassen** – Keine Stack Traces an Benutzer zeigen
- [ ] **Logging einrichten** – Fehler protokollieren für Debugging
- [ ] **Backups** – Regelmäßige Backups der Datenbank/Dateien

## Weiterführende Ressourcen

- [Flask Deployment Documentation](https://flask.palletsprojects.com/en/stable/deploying/)
- [The Twelve-Factor App](https://12factor.net/) – Best Practices für Web-Apps
- [Real Python: Flask Deployment](https://realpython.com/flask-by-example-part-1-project-setup/)
- [DigitalOcean Tutorials](https://www.digitalocean.com/community/tutorials) – Viele gute Server-Anleitungen