Héberger FastAPI sur un VPS avec Uvicorn et Nginx

Une API qui répond sur localhost n’est pas encore publiée pour vos utilisateurs. FastAPI utilise ASGI et a besoin d’un serveur compatible comme Uvicorn, d’un gestionnaire de processus pour rester actif et d’une route HTTPS publique. Un VPS vous permet d’installer et de contrôler ces éléments ; les mises à jour, les clés, le pare-feu, les données et la récupération restent à votre charge.

Ce guide utilise Debian ou Ubuntu, Uvicorn, systemd et Nginx. app.main et l’objet app sont des exemples : adaptez l’import à votre dépôt. Si le projet comprend également un frontend, une base de données, une file de tâches ou des tâches planifiées, planifiez et testez chaque service séparément.

1. Repérez l’objet ASGI à exécuter

Cherchez requirements.txt ou pyproject.toml, la version de Python requise et l’endroit où le projet crée FastAPI(). L’application peut être exposée sous main:app, app.main:app ou un autre chemin d’import. Si elle utilise une fabrique qui retourne l’application, Uvicorn accepte aussi --factory ; vérifiez son nom et sa signature avant de l’utiliser.

Lancez l’API en local et testez de vraies routes, l’authentification, les téléversements, les erreurs et les dépendances externes. Dans le code généré par IA, repérez les identifiants enregistrés dans Git, les clés susceptibles d’atterrir dans le JavaScript du navigateur, un CORS trop large et les réglages qui ne fonctionnent qu’avec localhost. Décidez si /docs, /redoc et /openapi.json doivent être publics dans votre cas.

2. Préparez Python sur un VPS

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 sans privilèges administrateur et un environnement virtuel :

sudo apt update
sudo apt install git python3-venv nginx
sudo adduser --system --group --home /srv/fastapi fastapi
sudo -u fastapi python3 -m venv /srv/fastapi/venv

Clonez le projet dans /srv/fastapi/current et protégez les identifiants d’accès au dépôt privé. Installez les dépendances déclarées par l’application dans l’environnement virtuel :

sudo -u fastapi /srv/fastapi/venv/bin/pip install -r /srv/fastapi/current/requirements.txt

Vérifiez qu’Uvicorn est une dépendance de production ; certains projets le déclarent déjà, d’autres doivent l’ajouter. N’installez pas l’application dans le Python global du système.

3. Séparez secrets et configuration

Conservez les variables de production hors de Git dans un fichier à accès restreint, par exemple /etc/fastapi.env. Votre application doit les lire explicitement. Utilisez de nouvelles valeurs de production pour la base de données, l’authentification, les services de courriel et les API externes. Ne publiez jamais un .env, une clé privée ou un jeton dans le frontend, le dépôt ou les journaux.

Si un navigateur appelle l’API depuis un autre domaine, configurez CORS avec les origines exactes dont le site a besoin. N’utilisez pas de joker sans en comprendre l’effet : avec des identifiants, FastAPI exige des origines, méthodes et en-têtes explicites. CORS est une règle du navigateur ; elle ne remplace pas l’authentification et ne limite pas les clients serveur à serveur.

Si l’API conserve des données, identifiez leur emplacement et les droits d’écriture. Sauvegardez-les avant une migration de schéma et documentez la restauration. Séparez les fichiers téléversés du code et choisissez les métriques, journaux et données personnelles à conserver.

4. Gardez Uvicorn actif

Testez d’abord le véritable chemin d’import. Cet exemple charge app depuis app/main.py et écoute uniquement sur loopback afin que le trafic public passe par Nginx :

cd /srv/fastapi/current
sudo -u fastapi /srv/fastapi/venv/bin/uvicorn app.main:app --host 127.0.0.1 --port 8000

Pour une fabrique compatible, adaptez le chemin et ajoutez --factory. Commencez avec un processus et mesurez l’utilisation. Plusieurs workers peuvent exploiter davantage de cœurs, mais chaque processus a généralement besoin de sa propre mémoire ; ne copiez pas un nombre universel sans mesurer l’API et la taille du VPS.

Après validation, créez /etc/systemd/system/fastapi.service pour lancer Uvicorn au démarrage et le relancer après un échec :

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

[Service]
User=fastapi
Group=fastapi
WorkingDirectory=/srv/fastapi/current
EnvironmentFile=/etc/fastapi.env
ExecStart=/srv/fastapi/venv/bin/uvicorn app.main:app --host 127.0.0.1 --port 8000 --proxy-headers --forwarded-allow-ips=127.0.0.1
Restart=on-failure

[Install]
WantedBy=multi-user.target

Adaptez l’import, vérifiez les droits du fichier d’environnement, puis exécutez sudo systemctl daemon-reload et sudo systemctl enable --now fastapi. Consultez sudo systemctl status fastapi, journalctl -u fastapi et envoyez une requête locale à http://127.0.0.1:8000/. Uvicorn ne doit faire confiance qu’aux en-têtes transférés par le proxy que vous contrôlez.

5. Placez Nginx et HTTPS devant l’API

Configurez Nginx pour recevoir les requêtes et les transmettre au processus local. Remplacez le domaine et conservez la route / attendue par l’API :

server {
    listen 80;
    server_name api.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;
    }
}

Activez le site et validez-le avec sudo nginx -t avant le rechargement. Faites pointer le DNS vers le VPS, autorisez le trafic web nécessaire et configurez un certificat TLS. Redirigez HTTP vers HTTPS. Si vous utilisez WebSockets ou de gros téléversements, définissez et testez ces limites explicitement.

FastAPI génère une documentation OpenAPI et peut la servir sur /docs et /redoc. Examinez son contenu et la politique d’accès ; vous pouvez désactiver ces routes dans la configuration de l’application si elles ne doivent pas être publiques. Cacher la documentation ne sécurise pas l’API : chaque route a toujours besoin de contrôles d’accès.

6. Testez l’API et sa restauration

Depuis une autre machine, testez le domaine, HTTPS, l’authentification, CORS depuis le frontend, les erreurs, les limites de téléversement et les dépendances. Redémarrez systemd et confirmez que l’API revient. Consultez les journaux sans afficher de secrets ni de corps de requête sensible. Automatisez les sauvegardes de la base et des fichiers puis testez une restauration. Si vous lancez des migrations ou tâches au démarrage, contrôlez leur ordre pour éviter plusieurs exécutions simultanées.

Ce déploiement est autogéré : Hostbrid fournit le VPS avec accès root, mais vous installez et maintenez Python, FastAPI, Uvicorn, Nginx, HTTPS, les mises à jour, le pare-feu et les sauvegardes. Comparez les tailles VPS et les tarifs actuels à l’utilisation mesurée de l’API, de ses workers et des services associés.

Sources officielles : FastAPI sur le déploiement, les concepts, les workers, CORS, Uvicorn derrière un proxy et le proxy inverse Nginx.