Héberger Flask sur un VPS avec Gunicorn et Nginx

Si un outil d’IA a généré une application Flask, le fait qu’elle réponde avec flask run sur votre ordinateur ne signifie pas qu’elle est prête pour le trafic public. Flask est une application WSGI : en production, il faut un serveur WSGI, un proxy HTTP et une configuration sûre. Le VPS est autogéré : vous avez accès au système pour installer cette pile et vous restez responsable des mises à jour, de la sécurité, des sauvegardes et de la restauration.

Ce guide utilise Debian ou Ubuntu, Gunicorn et Nginx. Les noms hello, app et create_app sont des exemples : remplacez-les par les modules et objets de votre dépôt. N’exécutez ni le serveur de développement ni le débogueur Flask en production.

1. Repérez l’application à exécuter

Cherchez requirements.txt ou pyproject.toml, le module d’entrée et, le cas échéant, une fabrique d’application comme create_app(). Notez la version de Python et les services externes requis : base de données, stockage, tâches, courriel ou API. Vérifiez également si le projet comprend un frontend Node distinct ; Gunicorn exécute le backend Flask, mais ne construit pas ce frontend.

Testez les routes, formulaires, téléversements et appels externes en local. Dans le code généré par IA, recherchez debug=True, les identifiants enregistrés dans Git et la configuration qui ne fonctionne qu’avec localhost. Adaptez la suite si les dépendances ou les services de votre application diffèrent.

2. Préparez le VPS et un compte de service

Choisissez un VPS Hostbrid avec Debian ou Ubuntu compatible avec la version de Python du projet. Connectez-vous en SSH, appliquez les mises à jour et n’ouvrez que les ports nécessaires. Créez un compte de service au lieu d’exécuter l’application en tant que root :

sudo apt update
sudo apt install git python3-venv nginx
sudo adduser --system --group --home /srv/flaskapp flaskapp

Clonez le dépôt dans /srv/flaskapp/current. Pour un dépôt privé, utilisez une clé de déploiement en lecture seule et protégez sa clé privée. Créez un environnement virtuel et installez les versions fixées par le projet :

sudo -u flaskapp python3 -m venv /srv/flaskapp/venv
sudo -u flaskapp /srv/flaskapp/venv/bin/pip install -r /srv/flaskapp/current/requirements.txt

Déclarez gunicorn comme dépendance de production. N’installez pas les paquets de l’application dans le Python global du système.

3. Configurez l’environnement de production

Conservez les variables de production hors de Git, dans un fichier à accès restreint comme /etc/flaskapp.env. Flask ne transforme pas automatiquement chaque variable d’environnement en paramètre de l’application : votre code doit la lire. Générez une SECRET_KEY unique, configurez les identifiants de base de données et les clés d’API, et ne réutilisez pas les valeurs de développement. N’incluez aucun secret dans le JavaScript du navigateur, le HTML, les images ou les journaux.

Désactivez le mode debug et limitez les noms d’hôte acceptés. Avec Flask 3.1 ou une version ultérieure, vérifiez TRUSTED_HOSTS ; avec une autre version, examinez les protections équivalentes disponibles. Les noms des paramètres et leur chargement dépendent du code de l’application.

Faites une sauvegarde avant de modifier des données. Si l’application utilise SQLite, vérifiez l’emplacement du fichier et les droits d’écriture. Pour davantage de trafic ou plusieurs processus, évaluez une base de données adaptée et documentez la restauration. Séparez les fichiers téléversés par les utilisateurs du code et définissez leur rétention et leurs sauvegardes.

4. Lancez Flask avec Gunicorn et systemd

Testez d’abord l’import de l’application. Gunicorn attend le format module:objet : une instance Flask peut être hello:app, et une fabrique hello:create_app(). Remplacez l’exemple par le vrai point d’entrée du projet :

cd /srv/flaskapp/current
sudo -u flaskapp /srv/flaskapp/venv/bin/gunicorn --bind 127.0.0.1:8000 'hello:create_app()'

Après validation, utilisez systemd pour démarrer le processus au démarrage du VPS et le relancer après un échec. Enregistrez cette unité dans /etc/systemd/system/flaskapp.service :

[Unit]
Description=Flask application
After=network.target

[Service]
User=flaskapp
Group=flaskapp
WorkingDirectory=/srv/flaskapp/current
EnvironmentFile=/etc/flaskapp.env
ExecStart=/srv/flaskapp/venv/bin/gunicorn --bind 127.0.0.1:8000 'hello:create_app()'
Restart=on-failure

[Install]
WantedBy=multi-user.target

Adaptez le module WSGI et vérifiez que systemd peut lire le fichier d’environnement sans le rendre accessible aux autres utilisateurs. Exécutez ensuite sudo systemctl daemon-reload, sudo systemctl enable --now flaskapp, puis consultez sudo systemctl status flaskapp et journalctl -u flaskapp. Laissez Gunicorn lié à 127.0.0.1 ; si Nginx se trouve devant, ne l’exposez pas directement à Internet.

5. Configurez Nginx, le domaine et HTTPS

Ce bloc Nginx de départ transmet les requêtes à Gunicorn. Remplacez le domaine et vérifiez le port d’écoute de l’application :

server {
    listen 80;
    server_name example.com www.example.com;

    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;
    }
}

Enregistrez-le dans le répertoire de configuration des sites de votre distribution, activez-le, vérifiez avec sudo nginx -t et rechargez Nginx. Faites pointer le domaine vers le VPS, autorisez le trafic web nécessaire et émettez un certificat TLS selon la méthode prise en charge par votre système. Redirigez HTTP vers HTTPS avant d’accepter des identifiants ou des données sensibles.

Si Flask doit connaître le protocole ou l’adresse d’origine, configurez ProxyFix uniquement si les requêtes passent réellement par le proxy que vous contrôlez, et indiquez le nombre exact de proxies. Faire confiance aux en-têtes transférés sans limiter cette chaîne permettrait à un client de falsifier des valeurs.

6. Testez le parcours et préparez l’exploitation

Depuis l’extérieur du VPS, testez la page d’accueil, les routes internes, les formulaires, la connexion, les fichiers statiques et les téléversements. Redémarrez le service et vérifiez qu’il revient. Consultez les journaux pour repérer erreurs et secrets exposés ; confirmez que la base de données et les fichiers peuvent être restaurés. Si l’application utilise des tâches en arrière-plan, configurez et surveillez ces processus séparément.

Cette méthode convient à une application Flask que vous administrez sur Linux. Hostbrid fournit un VPS avec accès root ; vous installez et exploitez Python, Flask, Gunicorn, Nginx, HTTPS, le pare-feu et les sauvegardes. Comparez les offres VPS et les tarifs actuels à l’utilisation mesurée du CPU, de la mémoire et du disque.

Références d’implémentation : documentation officielle de Flask sur le déploiement en production, Gunicorn, Nginx et ProxyFix.