Pourquoi Déployer FastAPI sur Vercel ?
Deployer FastAPI sur Vercel est une option intéressante pour les développeurs qui cherchent des solutions modernes et évolutives pour leur application. L'application de FastAPI peut être déployée facilement sur Vercel grâce à ses capacités en hébergement serverless et son support natif pour les applications Python.
Un cas d'utilisation concret est le développement d'une API web complexe qui nécessite une grande scalabilité et une haute performance. En déployant FastAPI sur Vercel, vous pouvez profiter de la flexibilité des fonctions serverless tout en conservant les avantages de l'architecture web moderne.
Prerequis
- Connaissance approfondie de Python
- Familiarité avec FastAPI
- Compréhension des bases du système d'hébergement Vercel
- Installation de Node.js (pour l'installation et la gestion de dépendances)
- Installation de Git (pour le contrôle de version)
Concepts fondamentaux
1. Fonction Serverless
La fonction serverless est un modèle d'exécution où les applications sont exécutées sur des serveurs qui ne nécessitent pas une présence continue. Vercel utilise cette technologie pour permettre aux développeurs de déployer leurs applications sans se soucier de la gestion du déploiement et de l'échelle.
## Exemple d'une fonction serverless en Python avec FastAPI
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Bienvenue sur le serveur Vercel!"}
2. Déploiement Continuous Integration / Continuous Deployment (CI/CD)
CI/CD est un processus de développement logiciel qui permet aux développeurs d'automatiser les tests et la délivrance des applications. Avec Vercel, chaque commit sur le dépôt Git déclenche automatiquement une nouvelle build et déploiement de l'application.
3. Variables d'environnement
Les variables d'environnement sont utilisées pour stocker des informations sensibles ou configurer les paramètres de l'application sans les hard coder dans le code source. Vercel permet la définition et l'utilisation de ces variables facilement.
## Utilisation de variables d'environnement en FastAPI
from fastapi import FastAPI, Depends
import os
app = FastAPI()
def get_db():
db_url = os.getenv("DATABASE_URL")
return db_url
@app.get("/db-url")
async def read_db_url(db_url=Depends(get_db)):
return {"database_url": db_url}
Mise en pratique : Projet fil rouge
1. Création du projet
## Initialisation d'un nouveau projet FastAPI
mkdir fastapi-vercel
cd fastapi-vercel
python -m venv venv
source venv/bin/activate # Sous Windows, utilisez `venv\Scripts\activate`
pip install fastapi uvicorn
2. Création du fichier main.py
## main.py
from fastapi import FastAPI, Depends
from pydantic import BaseModel
import os
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
def get_db():
db_url = os.getenv("DATABASE_URL")
return db_url
@app.post("/items/")
async def create_item(item: Item, db_url=Depends(get_db)):
# Simuler l'insertion de l'item dans la base de données
item_id = len(items) + 1
items[item_id] = {"id": item_id, **item.dict()}
return {"item_id": item_id}
3. Création du fichier requirements.txt
## requirements.txt
fastapi==0.86.2
uvicorn==0.17.4
python-dotenv==0.21.1
pydantic==1.9.1
4. Installation des dépendances
pip install -r requirements.txt
5. Lancement de l'application local
## Lancer l'application FastAPI avec Uvicorn
uvicorn main:app --reload
6. Création du fichier vercel.json
{
"version": 2,
"routes": [
{
"src": "/(.*)",
"dest": "/"
}
],
"functions": {
"main.py": {
"runtime": "python3.8"
}
}
}
7. Création du fichier package.json (pour les dépendances NPM)
{
"name": "fastapi-vercel",
"version": "1.0.0",
"dependencies": {
"fastapi": "^0.86.2"
}
}
8. Initialisation du dépôt Git
## Initialisation du dépôt Git et ajout des fichiers
git init
git add .
git commit -m "Initial commit"
9. Déploiement sur Vercel
- Connectez-vous à votre compte Vercel.
- Créez un nouveau projet et sélectionnez le dépôt Git où se trouve votre projet FastAPI.
- Sélectionnez la branche
mainou celle que vous souhaitez déployer. - Configurez les variables d'environnement nécessaires si nécessaire (par exemple,
DATABASE_URL). - Démarrez le déploiement.
Erreurs fréquentes et debugging
1. ModuleNotFoundError
Erreur :
ModuleNotFoundError: No module named 'uvicorn'
Code incorrect :
## main.py
from fastapi import FastAPI
app = FastAPI()
Code correct :
## main.py
from fastapi import FastAPI
import uvicorn
app = FastAPI()
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)
2. SyntaxError: invalid syntax
Erreur :
SyntaxError: invalid syntax
Code incorrect :
## main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Bienvenue sur le serveur Vercel!"
Code correct :
## main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Bienvenue sur le serveur Vercel!"}
3. RuntimeError: No module named 'pydantic'
Erreur :
RuntimeError: No module named 'pydantic'
Code incorrect :
## main.py
from fastapi import FastAPI
app = FastAPI()
Code correct :
## main.py
from fastapi import FastAPI
import pydantic
app = FastAPI()
Pour aller plus loin
1. Intégration avec une base de données
2. Ajout d'authentification et de sécurité
Authentification JWT avec FastAPI
3. Optimisation des performances
Performance optimisée avec FastAPI et Uvicorn
Défi pratique :
- Créer une API de blog : Utilisez FastAPI pour créer une application simple de gestion de blogs, permettant d'ajouter, lire, mettre à jour et supprimer des articles.
- Intégrer un système de commentaires : Ajoutez la possibilité de commenter les articles et afficher les commentaires associés à chaque article.
En suivant ce tutoriel, vous aurez une compréhension approfondie de la façon de déployer une application FastAPI sur Vercel. Vous serez prêt à développer et déployer vos propres applications FastAPI en utilisant cette plateforme puissante et flexible.