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 in die Lage versetzt, 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 – das 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 mit dem Installationsprozess beginnen, 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 Serverumgebung gibt. Shared-Hosting-Pläne beschränken häufig 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 Ihren Anforderungen 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 Ihre Flask-App über eine Domäne statt über eine rohe IP-Adresse öffentlich zugänglich machen möchten, sollten Sie eine über Domain Registration registrieren, bevor Sie beginnen.

2. Verbindung zu Ihrem Server via 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

Vor der Installation von Paketen 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. Flask installieren

Schritt 1: pip installieren

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: Ein Projektverzeichnis erstellen

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

mkdir my_flaskapp
cd my_flaskapp

Schritt 3: Eine virtuelle Umgebung einrichten

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

Ihre Terminal-Eingabeaufforderung ändert sich, um anzuzeigen, dass die virtuelle Umgebung aktiv ist, und zeigt typischerweise (venv) am Anfang der Zeile an.

Schritt 4: Flask installieren

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-Erklärung:

• 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 erreichbar:

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. Flask in einer Produktionsumgebung mit Gunicorn bereitstellen

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

Schritt 1: Gunicorn installieren

Installieren Sie Gunicorn mit Ihrer noch aktiven virtuellen Umgebung:

pip install gunicorn

Schritt 2: Ihre Anwendung mit Gunicorn ausführen

Starten Sie Ihre Flask-App mit Gunicorn und binden Sie sie an localhost auf Port 8000:

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 zur Verarbeitung gleichzeitiger Anfragen. Eine häufige Formel ist (2 × CPU cores) + 1.

Schritt 3: Gunicorn als Systemd-Service ausführen (empfohlen)

Um sicherzustellen, dass Gunicorn beim Neustart des Servers 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 Serverbenutzernamen. 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. Nginx als Reverse Proxy konfigurieren

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

Schritt 1: Nginx installieren

sudo apt install nginx -y

Schritt 2: Nginx-Konfigurationsdatei erstellen

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: Konfiguration aktivieren

Erstellen Sie einen symbolischen Link, um die Website 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 jetzt unter http://your_domain_or_ip auf Port 80 erreichbar.

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 erwerben.

Certbot installieren und ein kostenloses SSL-Zertifikat erhalten

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 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 den Datenverkehr 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

12. Zusammenfassung und nächste Schritte

Die Bereitstellung einer Flask-Anwendung auf einem Hosting-Server umfasst mehrere miteinander verbundene Schritte: Einrichtung einer sauberen Serverumgebung, Installation von Python und Flask in einer virtuellen Umgebung, Konfiguration von Gunicorn als produktiven WSGI-Server und Platzierung von Nginx davor als Reverse Proxy. Das Hinzufügen von SSL-Verschlüsselung rundet eine sichere, produktionsreife Bereitstellung ab.

Hier ist eine kurze Zusammenfassung des vollständigen Deployment-Stacks:

• Flask — Python Web-Framework
• Gunicorn — Produktiver WSGI-Server
• Nginx — Reverse Proxy und Static-File-Server
• SSL/TLS — HTTPS-Verschlüsselung
• Systemd — Prozessverwaltung und automatischer Neustart

Für das beste Flask-Hosting-Erlebnis benötigen Sie eine Serverumgebung, die Ihnen vollständigen Root-Zugriff und zuverlässige Leistung bietet. AlexHost’s VPS Hosting Pläne sind eine ausgezeichnete Wahl und bieten SSD-Speicher, dedizierte Ressourcen und vollständigen SSH-Zugriff. Wenn Sie noch mehr Leistung für Anwendungen mit hohem Traffic benötigen, erkunden Sie unsere Dedicated Servers für maximale Leistung und Isolation.

Wenn Sie mehrere Web-Projekte verwalten und eine Control-Panel-Oberfläche bevorzugen, erwägen Sie unsere VPS mit cPanel Option, die die Serververwaltung vereinfacht und Ihnen gleichzeitig die Flexibilität gibt, Python-Anwendungen auszuführen.

Durch Befolgung dieser Anleitung ist Ihre Flask-Anwendung nun ordnungsgemäß konfiguriert, gesichert und bereit, echte Benutzer in einer Produktionsumgebung zu bedienen. Halten Sie Ihre Abhängigkeiten regelmäßig aktualisiert, überwachen Sie Ihre Anwendungsprotokolle und implementieren Sie ordnungsgemäße Backup-Strategien, um eine gesunde, langfristig laufende Bereitstellung zu gewährleisten.