Wie man Flask auf Hosting installiert: Eine vollständige Schritt-für-Schritt-Anleitung

Flask ist ein leichtes, flexibles Web-Framework für Python, das Entwickler befähigt, Web-Anwendungen schnell und effizient zu erstellen und bereitzustellen. Egal ob Sie ein persönliches Projekt, eine REST API oder einen vollständigen Web-Service starten – zu wissen, wie man Flask in einer Hosting-Umgebung korrekt installiert und konfiguriert, ist eine wesentliche Fähigkeit. Dieser umfassende Leitfaden führt Sie durch jeden Schritt – von der Server-Einrichtung bis zur Produktionsbereitstellung mit Gunicorn und Nginx.

1. Voraussetzungen

Bevor Sie in den Installationsprozess eintauchen, stellen Sie sicher, dass Sie Folgendes haben:

Hosting-Umgebung, die Python unterstützt

Sie benötigen einen Hosting-Service, der Ihnen vollständige Kontrolle über Ihre Server-Umgebung gibt. Shared-Hosting-Pläne beschränken oft die Python-Ausführung, daher wird für Flask-Bereitstellungen ein VPS Hosting-Plan oder ein Dedicated Server dringend empfohlen. Diese Optionen geben Ihnen Root-Zugriff, vollständige Paketverwaltungsfunktionen und die Flexibilität, Ihren Stack genau nach Bedarf zu konfigurieren.

SSH-Zugriff

Sie benötigen SSH-Zugriff, um sich mit Ihrem Remote-Server zu verbinden und Befehle auszuführen. Die meisten Linux-basierten VPS- und Dedicated-Server-Umgebungen unterstützen dies standardmäßig.

Python installiert

Python 3.8 oder höher wird empfohlen. Die meisten modernen Hosting-Umgebungen haben Python vorinstalliert, aber wir werden dies während der Einrichtung überprüfen.

Optional: Ein Domänenname

Wenn Sie planen, Ihre Flask-App über eine Domäne statt über eine rohe IP-Adresse öffentlich zugänglich zu machen, erwägen Sie, eine über Domain Registration zu registrieren, bevor Sie beginnen.

2. Verbindung zu Ihrem Server über SSH

Öffnen Sie Ihr Terminal (Linux/macOS) oder einen SSH-Client wie PuTTY (Windows) und verbinden Sie sich mit Ihrem Server:

ssh username@your_server_ip

Ersetzen Sie username durch Ihren tatsächlichen Server-Benutzernamen und your_server_ip durch die öffentliche IP-Adresse Ihres Servers.

Überprüfen Sie nach der Verbindung, ob Python 3 verfügbar ist:

python3 --version

Sie sollten eine Ausgabe ähnlich wie Python 3.10.x sehen. Wenn Python nicht installiert ist, fahren Sie mit der Installation fort:

sudo apt install python3

3. Aktualisierung Ihres Servers

Bevor Sie Pakete installieren, ist es Best Practice, die Paketliste Ihres Systems zu aktualisieren und vorhandene Pakete auf ihre neuesten Versionen zu aktualisieren:

sudo apt update
sudo apt upgrade -y

Dies stellt sicher, dass Sie mit den stabilsten und sichersten Versionen aller Abhängigkeiten arbeiten.

4. Installation von Flask

Schritt 1: Installieren Sie pip

pip ist Pythons Paketmanager und ist erforderlich, um Flask und andere Python-Bibliotheken zu installieren. Installieren Sie es, falls es nicht bereits vorhanden ist:

sudo apt install python3-pip -y

Überprüfen Sie die Installation:

pip3 --version

Schritt 2: Erstellen Sie ein Projektverzeichnis

Organisieren Sie Ihre Anwendung, indem Sie ein dediziertes Verzeichnis erstellen:

mkdir my_flaskapp
cd my_flaskapp

Schritt 3: Richten Sie eine virtuelle Umgebung ein

Die Verwendung einer virtuellen Umgebung isoliert die Abhängigkeiten Ihres Projekts von der globalen Python-Installation, verhindert Versionskonflikte und hält Ihren Server sauber:

sudo apt install python3-venv -y
python3 -m venv venv

Aktivieren Sie die virtuelle Umgebung:

source venv/bin/activate

Ihr Terminal-Prompt ändert sich, um anzuzeigen, dass die virtuelle Umgebung aktiv ist, typischerweise mit (venv) am Anfang der Zeile.

Schritt 4: Installieren Sie Flask

Installieren Sie Flask mit pip, wenn die virtuelle Umgebung aktiviert ist:

pip install Flask

Bestätigen Sie die Installation:

flask --version

Sie sollten die Flask-Version zusammen mit den Python- und Werkzeug-Versionen sehen.

5. Erstellen einer einfachen Flask-Anwendung

Schritt 1: Erstellen Sie die Anwendungsdatei

Erstellen Sie eine neue Datei namens app.py in Ihrem Projektverzeichnis:

nano app.py

Schritt 2: Schreiben Sie Ihre Flask-Anwendung

Fügen Sie den folgenden minimalen Flask-Anwendungscode hinzu:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, World! Flask is running successfully."

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Code-Aufschlüsselung:

• Flask(__name__) — Erstellt eine neue Flask-Anwendungsinstanz.
• @app.route('/') — Definiert eine URL-Route für die Startseite.
• app.run(host='0.0.0.0', port=5000) — Startet den Entwicklungsserver und macht ihn auf allen Netzwerkschnittstellen auf Port 5000 zugänglich.

Schritt 3: Speichern und Beenden

Drücken Sie CTRL + X, dann Y, und drücken Sie Enter, um die Datei zu speichern und den Nano-Editor zu beenden.

6. Ausführung Ihrer Flask-Anwendung im Entwicklungsmodus

Starten Sie den Flask-Entwicklungsserver, um Ihre Anwendung zu testen:

python app.py

Ihre Anwendung ist nun in einem Webbrowser unter folgender Adresse zugänglich:

http://your_server_ip:5000

> Wichtig: Der integrierte Flask-Entwicklungsserver ist nicht für die Produktionsnutzung geeignet. Er ist Single-threaded, nicht für Leistung optimiert und verfügt nicht über kritische Sicherheitsfunktionen. Verwenden Sie immer einen produktionsreifen WSGI-Server für Live-Bereitstellungen.

7. Bereitstellung von Flask in einer Produktionsumgebung mit Gunicorn

Für Produktionsbereitstellungen ist Gunicorn (Green Unicorn) der am häufigsten verwendete Python WSGI HTTP-Server. Er verarbeitet mehrere gleichzeitige Anfragen effizient und integriert sich nahtlos mit Nginx.

Schritt 1: Installieren Sie Gunicorn

Installieren Sie Gunicorn mit Ihrer aktiven virtuellen Umgebung:

pip install gunicorn

Schritt 2: Führen Sie Ihre Anwendung mit Gunicorn aus

Starten Sie Ihre Flask-App mit Gunicorn, indem Sie sie an Localhost auf Port 8000 binden:

gunicorn app:app -b 127.0.0.1:8000 --workers 3

Parametererklärung:

• app:app — Bezieht sich auf das app-Objekt in der app.py-Datei.
• -b 127.0.0.1:8000 — Bindet Gunicorn an Localhost auf Port 8000 (Nginx verarbeitet externen Traffic).
• --workers 3 — Erzeugt 3 Worker-Prozesse, um gleichzeitige Anfragen zu verarbeiten. Eine häufige Formel ist (2 × CPU cores) + 1.

Schritt 3: Führen Sie Gunicorn als Systemd-Service aus (empfohlen)

Um sicherzustellen, dass Gunicorn beim Server-Neustart automatisch startet, erstellen Sie eine Systemd-Service-Datei:

sudo nano /etc/systemd/system/my_flaskapp.service

Fügen Sie die folgende Konfiguration hinzu:

[Unit]
Description=Gunicorn instance to serve my_flaskapp
After=network.target

[Service]
User=your_username
Group=www-data
WorkingDirectory=/home/your_username/my_flaskapp
Environment="PATH=/home/your_username/my_flaskapp/venv/bin"
ExecStart=/home/your_username/my_flaskapp/venv/bin/gunicorn app:app -b 127.0.0.1:8000 --workers 3

[Install]
WantedBy=multi-user.target

Ersetzen Sie your_username durch Ihren tatsächlichen Server-Benutzernamen. Aktivieren und starten Sie dann den Service:

sudo systemctl daemon-reload
sudo systemctl start my_flaskapp
sudo systemctl enable my_flaskapp

Überprüfen Sie den Service-Status:

sudo systemctl status my_flaskapp

8. Konfigurieren von Nginx als Reverse Proxy

Nginx fungiert als Reverse Proxy, sitzt vor Gunicorn und verarbeitet den gesamten eingehenden HTTP/HTTPS-Traffic. Dieses Setup verbessert die Leistung, ermöglicht SSL-Terminierung und ermöglicht es Ihnen, statische Dateien effizient bereitzustellen.

Schritt 1: Installieren Sie Nginx

sudo apt install nginx -y

Schritt 2: Erstellen Sie eine Nginx-Konfigurationsdatei

Erstellen Sie einen neuen Server-Block für Ihre Flask-Anwendung:

sudo nano /etc/nginx/sites-available/my_flaskapp

Fügen Sie die folgende Konfiguration hinzu:

server {
    listen 80;
    server_name your_domain_or_ip;  # Replace with your domain or server IP

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /static {
        alias /home/your_username/my_flaskapp/static;
        expires 30d;
    }
}

Schritt 3: Aktivieren Sie die Konfiguration

Erstellen Sie einen symbolischen Link, um die Site zu aktivieren und die Nginx-Konfiguration zu testen:

sudo ln -s /etc/nginx/sites-available/my_flaskapp /etc/nginx/sites-enabled
sudo nginx -t

Wenn der Test syntax is ok und test is successful zurückgibt, starten Sie Nginx neu:

sudo systemctl restart nginx

Ihre Flask-Anwendung ist nun unter http://your_domain_or_ip auf Port 80 zugänglich.

9. Sicherung Ihrer Flask-Anwendung mit SSL/HTTPS

Das Ausführen Ihrer Anwendung über HTTPS ist nicht mehr optional – es ist eine grundlegende Anforderung für Sicherheit, Benutzervertrauen und SEO-Rankings. Sie können ein kostenloses SSL-Zertifikat mit Certbot und Let’s Encrypt erhalten und installieren, oder ein Premium-Zertifikat über SSL Certificates für erweiterte Validierung und Garantieabdeckung kaufen.

Installieren Sie Certbot und erhalten Sie ein kostenloses SSL-Zertifikat

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d your_domain.com -d www.your_domain.com

Certbot wird Ihre Nginx-Konfiguration automatisch ändern, um HTTPS zu aktivieren und die automatische Zertifikatverlängerung einzurichten.

Überprüfen Sie, ob die automatische Verlängerung konfiguriert ist:

sudo certbot renew --dry-run

10. Firewall-Konfiguration

Stellen Sie sicher, dass die Firewall Ihres Servers Traffic auf den erforderlichen Ports zulässt:

sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
sudo ufw status

Nginx Full öffnet sowohl Port 80 (HTTP) als auch Port 443 (HTTPS).

11. Fehlerbehebung bei häufigen Problemen