Aller au contenu
DevSecOps Logo DevSecOps
Docs
Blog
Blog

Démarrage de mon projet LMS avec une approche API First

Il y a quelques jours, j’ai eu une idée : Créer un Learning Management System (LMS) basique pour améliorer votre expérience d’apprentissage sur le site. C’est un gros projet, mais je suis prêt à relever le défi !

Les choix technologiques pour mon projet LMS

Avant de commencer à coder, j’ai pris un moment pour réfléchir aux technologies et outils qui allaient m’accompagner dans cette aventure. Un projet comme un Learning Management System (LMS) ne se limite pas à une simple application : c’est un écosystème. En adoptant une approche API First, je veux capitaliser sur les ressources déjà disponibles, tout en choisissant des outils fiables et bien documentés pour construire une base évolutive. Voici les choix qui guideront le développement de mon projet.

L’un des avantages de mon projet, c’est que je peux réutiliser de nombreux cours déjà disponibles ici, comme :

  • Python et programmation asynchrone : Je peux m’appuyer sur les bases que j’ai déjà explorées pour concevoir un backend fluide et performant.
  • Connexion et OpenAPI : Ces outils permettent de structurer l’API dès le départ et de garantir une documentation claire et maintenable.
  • Astro : Ce framework vont simplifier la création de l’interface tout en garantissant un design moderne et rapide à mettre en œuvre.

En capitalisant sur ces briques, je m’assure que mon LMS repose sur des outils éprouvés, tout en maximisant ma productivité.

Python : une base solide pour le backend

Je suis convaincu que Python est le choix idéal pour mon projet LMS. Sa simplicité, sa richesse en bibliothèques et son support natif pour l’asynchronisme en font un allié précieux. Voici pourquoi :

  • Programmation orientée objet (POO) : Elle permet de structurer proprement le code et de modéliser les concepts du LMS (comme les utilisateurs, cours, inscriptions) en classes.
  • Asyncio et frameworks asynchrones : Python offre des solutions performantes pour construire des applications web modernes grâce à ses fonctionnalités async/await.

Connexion : la puissance d’OpenAPI avec Python

Pour concevoir une API robuste et documentée, Connexion est mon choix. Voici ce qui m’a séduit :

  • Simplicité d’intégration : Connexion s’appuie sur un fichier OpenAPI pour générer automatiquement les routes et la documentation. Cela réduit les erreurs et facilite la collaboration.
  • Support asynchrone : En mode async, Connexion s’intègre parfaitement avec des serveurs ASGI comme Uvicorn, garantissant des performances modernes.
  • API centrée sur OpenAPI : Avec Connexion, je peux définir les endpoints avant de coder leur logique, ce qui colle parfaitement avec l’approche API First.

SQLite : un backend léger et évolutif

Pour gérer les données, je commence avec SQLite. Pourquoi ? Parce qu’il est léger, rapide à mettre en place, et parfait pour prototyper. Avec SQLAlchemy, je garde la flexibilité nécessaire pour migrer vers une base de données plus robuste comme PostgreSQL lorsque le projet grandira. Voici mes arguments :

  • Simplicité : Une base SQLite se crée en un fichier, sans configuration complexe.
  • Évolutivité avec SQLAlchemy : SQLAlchemy permet de travailler avec SQLite, PostgreSQL ou d’autres moteurs sans changer beaucoup de code.
  • Adapté aux tests : SQLite est idéal pour les tests locaux grâce à sa portabilité.

Astro et DaisyUI : une UI moderne et esthétique

Côté interface utilisateur, je vais capitaliser sur Astro, un framework moderne pour construire des sites rapides et dynamiques. En complément, DaisyUI, une bibliothèque basée sur Tailwind CSS, me permettra de concevoir des interfaces élégantes et accessibles.

  • Astro :
    • Parfait pour une application statique ou hybride.
    • Compatible avec de nombreux frameworks comme React ou Vue pour les composants interactifs.
    • Génère des pages ultra-rapides, idéales pour un LMS où la performance compte.
  • DaisyUI :
    • Une extension de Tailwind CSS qui fournit des composants prêts à l’emploi : boutons, cartes, barres de navigation, etc.
    • Un design cohérent sans réinventer la roue à chaque élément.
    • Personnalisable pour adapter l’interface au branding du projet.

Et ensuite ?

Ces choix technologiques posent une base solide. L’architecture est modulaire : si je veux remplacer SQLite par PostgreSQL, ajouter un système d’authentification JWT ou connecter une application mobile, tout est déjà pensé pour rester évolutif. Grâce à l’approche API First, chaque composant est indépendant et peut évoluer séparément.

Allez, c’est parti pour l’aventure ! 😊

Création du projet

Maintenant que j’ai défini mes choix technologiques, je vais créer la structure de mon projet LMS. Je vais commencer par mettre en place l’API avec Connexion et OpenAPI. Voici les étapes à suivre :

1. Configuration de l’environnement

Nous utilisons uv, un gestionnaire de paquets Python, pour installer et gérer les dépendances de notre projet. Si ce n’est pas déjà fait, installez uv :

Terminal window
pip install uv

Ensuite, initialisons notre projet :

Terminal window
mkdir lms-api
cd lms-api
uv init

Cela génère un fichier pyproject.toml, qui servira à gérer nos dépendances et la configuration du projet.

2. Création de la structure du projet

Voici la structure de fichiers et dossiers que nous allons utiliser pour le projet :

Terminal window
tree lms-api


├── app/
│   ├── models/
│   │   └── __init__.py
│   ├── routes/
│   │   ├── __init__.py
│   │   └── health.py
│   ├── utils/
│   │   └── __init__.py
│   ├── __init__.py
│   └── openapi.yaml
├── alembic/
│   └── (dossier de gestion des migrations)
├── main.py
├── pyproject.toml
└── README.md

Créons cette structure avec les commandes suivantes :

Terminal window
mkdir -p app/models app/routes app/utils
touch app/__init__.py app/models/__init__.py app/routes/__init__.py app/utils/__init__.py
touch main.py app/models/base.py app/routes/health.py
touch app/openapi.yaml

Voyons en détail le rôle de chaque fichier et dossier :

Fichier main.py

C’est le point d’entrée de notre application. Il initialise Connexion, charge la spécification OpenAPI et démarre le serveur.

Voici le contenu de main.py :

from connexion import AsyncApp
from pathlib import Path
import asyncio


app = AsyncApp(__name__)
app.add_api(
    "app/openapi.yaml",
    arguments={"title": "LMS API"},
    options={"swagger_ui": True},
)


async def init_and_run():
    app.run(f"{Path(__file__).stem}:app")


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Dossier app/models

Ce dossier contiendra les modèles de données SQLAlchemy.

Dossier app/routes

Ce dossier contient les fichiers qui gèrent les endpoints de notre API. Chaque fichier correspond à une ressource ou une fonctionnalité.

  • health.py : endpoint de vérification de l’état de l’API.

Exemple pour health.py :

def health_check():
    return {"status": "healthy"}, 200

Dossier app/utils

Contiendra les utilitaires partagés dans l’application.

Fichier openapi.yaml

C’est ici que nous définissons les spécifications OpenAPI de notre API. Chaque endpoint, ses paramètres et ses réponses y sont documentés.

Exemple de spécification pour l’endpoint /health :

openapi: 3.0.0
info:
  title: LMS API
  version: 1.0.0
paths:
  /health:
    get:
      summary: Health check
      operationId: app.routes.health.health_check
      responses:
        200:
          description: API is healthy

3. Installation des dépendances

Installons les bibliothèques nécessaires à notre API :

Terminal window
uv add "connexion[swagger-ui,uvicorn]"

4. Premier test de l’API

Lançons notre application avec la commande suivante :

Terminal window
uv run main.py

Accédez à http://localhost:8000/ui ↗ pour afficher l’interface Swagger UI et vérifier que l’endpoint /health fonctionne correctement. Ou avec curl :

Terminal window
curl -X GET http://localhost:8000/health


{"status": "healthy"}

Conclusion

Nous avons maintenant une base solide pour notre projet LMS. La prochaine étape sera de connecter la base de données avec SQLAlchemy, de définir nos modèles et d’ajouter des migrations avec Alembic. Mais avant cela, je vais les documenter. À bientôt pour la suite de l’aventure !

Eh, il faudrait que je pense à trouver un nom pour mon LMS… 🤔 Laissez-moi des propositions dans le post Linkedin ↗.