Le déploiement d'une application FastAPI sur un serveur privé virtuel (VPS) implique plusieurs étapes afin de garantir son fonctionnement efficace, sécurisé et fiable. Ce guide vous accompagnera tout au long du processus en utilisant Gunicorn comme serveur d'application et Nginx comme proxy inverse, tout en sécurisant votre application avec HTTPS à l'aide de Certbot. Les instructions s'appliquent principalement aux systèmes basés sur Ubuntu.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants : * Une application FastAPI prête à être déployée, y compris un fichier requirements.txt répertoriant toutes ses dépendances. * Un VPS fonctionnant sous Ubuntu (ou une autre distribution basée sur Debian). * Un accès SSH à votre VPS. * Un nom de domaine enregistré pointant vers l'adresse IP de votre VPS (facultatif, mais fortement recommandé pour HTTPS).

1. Connectez-vous à votre VPS et mettez à jour le système

Commencez par vous connecter à votre VPS via SSH et mettez à jour la liste des paquets de votre système.

ssh votre_nom_d'utilisateur@votre_ip_vps
sudo apt update && sudo apt upgrade -y

2. Installez Python, Pip et l'environnement virtuel

Installez Python 3, pip (l'installateur de paquets Python) et le module venv pour créer des environnements virtuels.

sudo apt install python3 python3-pip python3-venv -y

3. Clonez votre application FastAPI

Accédez à un répertoire approprié (par exemple, /var/www/) et clonez votre application FastAPI à partir de votre système de contrôle de version (par exemple, Git).

sudo mkdir -p /var/www/your_fastapi_app cd /var/www/your_fastapi_app
sudo git clone <your_repository_url> .

Remarque : remplacez votre_application_fastapi et l'URL Git par les détails de votre projet.

Pour des raisons de sécurité, il est recommandé de créer un utilisateur non root dédié à votre application.

sudo adduser votre_utilisateur_application sudo usermod -aG sudo votre_utilisateur_application
sudo chown -R votre_utilisateur_application:votre_utilisateur_application /var/www/nom_de_votre_projet_fastapi 

Ensuite, passez à ce nouvel utilisateur :

su - votre_utilisateur_application cd /var/www/votre_nom_de_projet_fastapi 

4. Configurez un environnement virtuel et installez les dépendances

Créez un environnement virtuel Python pour votre projet et installez les dépendances de votre application, notamment FastAPI, Gunicorn et Uvicorn.

python3 -m venv venv source venv/bin/activate
pip install -r requirements.txt
pip install gunicorn "uvicorn[standard]" fastapi

Si vous ne disposez pas d'un fichier requirements.txt, vous pouvez en créer un à l'aide de la commande pip freeze > requirements.txt dans votre environnement de développement local.

5. Testez votre application FastAPI (localement sur VPS)

Avant de configurer Gunicorn et Nginx, testez si votre application FastAPI fonctionne correctement à l'aide d'Uvicorn.

uvicorn main:app --host 0.0.0.0 --port 8000 

Remplacez main:app par le nom réel du module et de l'instance de l'application FastAPI (par exemple, your_app_folder.main:app). Vous devriez pouvoir accéder à votre application à l'adresse http://your_vps_ip:8000. Appuyez sur Ctrl+C pour arrêter le serveur.

6. Configurer Gunicorn

Gunicorn agira comme serveur d'application, gérant les workers Uvicorn pour traiter les requêtes.

Créer un fichier de configuration Gunicorn (facultatif mais recommandé)

Créez un fichier nommé gunicorn_conf.py dans le répertoire de votre projet.

nano gunicorn_conf.py 

Ajoutez le contenu suivant :

bind = "127.0.0.1:8000"
workers = 4 # Ajustez en fonction de vos cœurs de processeur (2 à 4 workers par cœur est une recommandation courante) worker_class = "uvicorn.workers.UvicornWorker" 

La valeur workers peut être ajustée ; une recommandation courante est (2 * CPU_CORES) + 1.

Tester Gunicorn

Exécutez Gunicorn avec votre application FastAPI pour vous assurer qu'elle démarre correctement.

gunicorn -c gunicorn_conf.py main:app 

Encore une fois, remplacez main:app par le point d'entrée de votre application.

7. Créer un service Systemd pour Gunicorn

Pour vous assurer que votre application démarre automatiquement au démarrage et peut être gérée facilement, créez un service systemd.

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

Ajoutez le contenu suivant, en remplaçant les espaces réservés par vos valeurs réelles :

[Unit] Description=Instance Gunicorn pour servir votre application FastAPI
Après=network.target [Service] Utilisateur=your_app_user
Groupe=your_app_user Répertoire de travail=/var/www/your_fastapi_project_name
ExecStart=/var/www/your_fastapi_project_name/venv/bin/gunicorn -c /var/www/your_fastapi_project_name/gunicorn_conf.py main:app
Restart=always PrivateTmp=true [Install]
WantedBy=multi-user.target 

Explication des champs : * User et Group : l'utilisateur et le groupe non root que vous avez créés pour votre application. * WorkingDirectory : le chemin absolu vers le répertoire de votre projet FastAPI. * ExecStart : la commande pour démarrer Gunicorn, pointant vers l'exécutable Gunicorn de votre environnement virtuel, votre fichier de configuration et le point d'entrée de votre application. * Restart=always : garantit le redémarrage du service en cas de plantage.

Rechargez systemd, démarrez le service et activez-le pour qu'il s'exécute au démarrage.

sudo systemctl daemon-reload sudo systemctl start your_fastapi_app
sudo systemctl enable your_fastapi_app 

Vérifiez l'état et les journaux pour vous assurer qu'il fonctionne sans erreur.

sudo systemctl status your_fastapi_app
sudo journalctl -u your_fastapi_app -f 

8. Configurer Nginx en tant que proxy inverse

Nginx agira en tant que proxy inverse, transmettant les requêtes à votre application Gunicorn et gérant les fichiers statiques et SSL.

Installer Nginx

sudo apt install nginx -y 

Créer un fichier de configuration Nginx

Créez un nouveau fichier de configuration de bloc de serveur Nginx pour votre application.

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

Ajoutez le contenu suivant, en remplaçant votre_domaine.com par votre nom de domaine réel et /var/www/votre_nom_de_projet_fastapi par le chemin d'accès à votre projet :

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

 emplacement / {  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;
 }  # Facultatif : servir les fichiers statiques directement via Nginx
 # location /static/ {  # alias /var/www/your_fastapi_project_name/static/;  # }
} 

Activer la configuration Nginx

Créez un lien symbolique pour activer la configuration et tester Nginx afin de détecter d'éventuelles erreurs de syntaxe.

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

Si le test est concluant, redémarrez Nginx.

sudo systemctl restart nginx 

9. Configurer le pare-feu (UFW)

Si vous avez activé un pare-feu (par exemple, UFW), vous devez autoriser le trafic sur les ports 80 (HTTP) et 443 (HTTPS).

sudo ufw allow 'Nginx Full' sudo ufw enable 

10. Sécurisez votre site avec HTTPS à l'aide de Certbot (Let's Encrypt)

Il est fortement recommandé de sécuriser votre application avec HTTPS. Certbot automatise le processus d'obtention et de configuration des certificats SSL auprès de Let's Encrypt.

Installer Certbot

sudo apt install certbot python3-certbot-nginx -y 

Obtenir et installer le certificat SSL

sudo certbot --nginx -d votre_domaine.com -d www.your_domain.com

Suivez les instructions. Certbot modifiera automatiquement votre configuration Nginx et configurera le renouvellement automatique.

11. Vérifiez votre déploiement

Votre application FastAPI devrait désormais être accessible via votre nom de domaine en utilisant HTTPS. Ouvrez un navigateur web et accédez à https://your_domain.com.

Conseils de dépannage

• Vérifiez les journaux Gunicorn : sudo journalctl -u your_fastapi_app -f
• Vérifiez les journaux d'erreurs Nginx : sudo tail -f /var/log/nginx/error.log
• Vérifiez les journaux d'accès Nginx : sudo tail -f /var/log/nginx/access.log
• Vérifiez la configuration Nginx : sudo nginx -t
• Assurez-vous que les permissions de fichiers sont correctes pour le répertoire de votre projet et l'environnement virtuel.
• Problèmes de pare-feu : Vérifiez les règles UFW.

En suivant ces étapes, vous disposerez d'une application FastAPI prête à l'emploi déployée sur votre VPS avec Nginx, Gunicorn et HTTPS.