Deployer FastAPI sur Supabase

Pourquoi Deployer FastAPI sur Supabase ?

L'approche de deployment moderne dans le développement web met l'accent sur la simplicité, la rapidité et la scalabilité. Lorsqu'il s'agit d'appliquer ces principes au développement d'applications API avec FastAPI, le choix du service d'hébergement devient crucial.

Supabase est une plateforme de base de données SQL et NoSQL open source qui offre un environnement complet pour le développement et la déploiement des applications. Il combine les avantages d'une base de données relationnelle (PostgreSQL) avec ceux d'une base de données orientée document (GraphQL), tout en offrant une interface simple et intuitive.

En déployant FastAPI sur Supabase, vous pouvez tirer parti des fonctionnalités avancées de la plateforme sans avoir à gérer les infrastructures complexes. Cela permet un développement plus rapide, une maintenance facilitée et une mise à l'échelle efficace, tout en conservant le contrôle total sur votre code.

Un cas d'usage concret serait un service d'API pour une application de gestion des tâches personnelles (Todolist). Avec FastAPI, vous pouvez créer rapidement et facilement les endpoints nécessaires pour gérer les tâches, tandis que Supabase vous permettra de stocker ces données de manière sécurisée et scalable.

Prerequis

Avant de commencer ce tutoriel, assurez-vous d'avoir les éléments suivants :

• Un compte Supabase : Vous pouvez créer un compte gratuit sur https://supabase.io/
• Python 3.7 ou version ultérieure
• pip (le gestionnaire de paquets Python)
• Un éditeur de code (VSCode, PyCharm, etc.)

Concepts fondamentaux

Supabase : Une plateforme complète pour le développement et le déploiement des applications

Supabase fournit une interface utilisateur intuitive pour la création et la gestion des bases de données. Elle offre également des fonctionnalités avancées telles que les triggers SQL, les webhooks et l'authentification, tout en étant extensible via les extensions PostgreSQL.

FastAPI : Un framework asynchrone pour créer des APIs rapides et efficaces

FastAPI est un framework moderne pour le développement d'applications API. Il utilise le type de données statique pour générer automatiquement la documentation interactive et l'interface utilisateur Swagger, ce qui rend le développement plus rapide et la maintenance facilitée.

Middleware : Filtres entre les requêtes et les réponses

Le middleware est une fonction qui reçoit une requête et une réponse et peut modifier ces valeurs avant qu elles ne soient traitées. Cela peut être utilisé pour effectuer des tâches telles que l'authentification, la journalisation et le traitement des erreurs.

State : Stockage de l'état de l'application

Le state est un objet qui stocke les données courantes de l'application. Il peut être utilisé pour partager des informations entre les endpoints et pour gérer le contexte de l'application.

Mise en pratique : Projet fil rouge

Dans cette section, nous allons créer un mini-projet complet et réaliste, une API de gestion des tâches personnelles (Todolist). Ce projet comprendra les fonctionnalités suivantes :

1. Création d'une tâche
2. Affichage de toutes les tâches
3. Mise à jour d'une tâche
4. Suppression d'une tâche

Étape 1 : Créer un nouveau projet FastAPI

Commencez par créer un nouveau répertoire pour votre projet et initialisez un environnement virtuel.

mkdir fastapi-todolist
cd fastapi-todolist
python -m venv venv
source venv/bin/activate  # Sous Windows utilisez `venv\Scripts\activate`

Installez FastAPI et Uvicorn (un serveur ASGI).

pip install fastapi uvicorn

Étape 2 : Créer les fichiers du projet

Créez les fichiers suivants :

• main.py : Le fichier principal de l'application.
• .env : Fichier pour stocker les variables d'environnement.

touch main.py .env

Étape 3 : Configurer le fichier .env

Ajoutez la clé secrète pour l'authentification JWT dans le fichier .env.

SECRET_KEY=your_secret_key_here
ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=30

Étape 4 : Créer les endpoints de l'API

Ajoutez le code suivant au fichier main.py pour créer les endpoints.

from fastapi import FastAPI, HTTPException, Depends, status
from pydantic import BaseModel
from datetime import datetime, timedelta
from jose import JWTError, jwt
import os

## Initialisation de l'application FastAPI
app = FastAPI()

## Modèle Pydantic pour les tâches
class Task(BaseModel):
    id: int = None
    title: str
    description: str = None
    completed: bool = False

## Mock de la base de données
tasks_db = []

## Variables d'environnement
SECRET_KEY = os.getenv('SECRET_KEY')
ALGORITHM = os.getenv('ALGORITHM')
ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv('ACCESS_TOKEN_EXPIRE_MINUTES'))

## Fonction pour générer un token JWT
def create_access_token(data: dict, expires_delta: timedelta):
    to_encode = data.copy()
    expire = datetime.utcnow() + expires_delta
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

## Fonction pour vérifier le token JWT
def verify_token(token: str):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise HTTPException(status_code=400, detail="Token incorrect")
    except JWTError:
        raise HTTPException(status_code=400, detail="Token incorrect")

## Endpoint pour créer une tâche
@app.post("/tasks/", response_model=Task)
async def create_task(task: Task):
    task.id = len(tasks_db) + 1
    tasks_db.append(task.dict())
    return task

## Endpoint pour afficher toutes les tâches
@app.get("/tasks/", response_model=list[Task])
async def get_tasks():
    return tasks_db

## Endpoint pour mettre à jour une tâche
@app.put("/tasks/{task_id}", response_model=Task)
async def update_task(task_id: int, task: Task):
    if task_id < 1 or task_id > len(tasks_db):
        raise HTTPException(status_code=404, detail="Tâche non trouvée")
    tasks_db[task_id - 1].update(task.dict())
    return tasks_db[task_id - 1]

## Endpoint pour supprimer une tâche
@app.delete("/tasks/{task_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_task(task_id: int):
    if task_id < 1 or task_id > len(tasks_db):
        raise HTTPException(status_code=404, detail="Tâche non trouvée")
    del tasks_db[task_id - 1]

Étape 5 : Exécuter l'application

Pour exécuter l'application, utilisez la commande suivante.

uvicorn main:app --reload

Accédez à http://127.0.0.1:8000/docs pour voir la documentation interactive de l'API et tester les endpoints.

Erreurs frequentes et debugging

Erreur 1 : Depends non reconnu

## ❌ Mauvais
from fastapi import Depends

@app.get("/tasks/")
async def get_tasks(task_id: int = Depends()):
    return tasks_db[task_id - 1]

Correction :

## ✅ Correct
from fastapi import Depends

@app.get("/tasks/")
async def get_tasks():
    return tasks_db

Erreur 2 : JWTError lors de la vérification du token

## ❌ Mauvais
try:
    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
except JWTError:
    raise HTTPException(status_code=400, detail="Token incorrect")

Correction :

## ✅ Correct
try:
    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
except JWTError:
    raise HTTPException(status_code=400, detail="Token incorrect")

Erreur 3 : HTTPException non géré

## ❌ Mauvais
if task_id < 1 or task_id > len(tasks_db):
    raise HTTPException(status_code=404, detail="Tâche non trouvée")

Correction :

## ✅ Correct
if task_id < 1 or task_id > len(tasks_db):
    raise HTTPException(status_code=404, detail="Tâche non trouvée")

Pour aller plus loin

Piste 1 : Ajouter une authentification JWT pour sécuriser les endpoints

Supabase offre une fonctionnalité d'authentification basée sur le token JWT. Vous pouvez intégrer cette fonctionnalité dans votre API pour protéger les endpoints.

• Documentation de Supabase sur l'authentification

Piste 2 : Utiliser des webhooks pour notifier les changements

Supabase offre la possibilité d'utiliser des webhooks pour notifier les changements dans la base de données. Vous pouvez configurer des webhooks pour envoyer des notifications chaque fois qu'une tâche est ajoutée, mise à jour ou supprimée.

• Documentation de Supabase sur les webhooks

Piste 3 : Déployer l'application sur une plateforme cloud

Vous pouvez déployer votre application FastAPI sur diverses plateformes cloud, telles que AWS, Google Cloud ou Azure. Supabase offre également un service d'hébergement pour les applications basées sur PostgreSQL.

• Documentation de Supabase sur le déploiement

Défi pratique

Développez une API de blog simple qui permet aux utilisateurs de créer, lire, mettre à jour et supprimer des articles. Utilisez FastAPI pour la création de l'API et Supabase pour le stockage des données.

• Créer un modèle Pydantic pour les articles.
• Implémenter les endpoints pour créer, lire, mettre à jour et supprimer des articles.
• Ajouter une authentification JWT pour protéger les endpoints sensibles.