Cours
Introduction à MongoDB en Python
3 h
24.4K
Le générateur d’applications full-stack FastAPI, React, MongoDB (FARM) est un outil puissant conçu pour accélérer la création d’applications web prêtes pour la production. En intégrant FastAPI pour le back-end, React pour le front-end et MongoDB comme base NoSQL scalable, le générateur FARM permet aux développeurs Python de mettre en place rapidement des applications robustes avec un minimum de configuration. Idéal si vous souhaitez vous concentrer sur les fonctionnalités plutôt que sur l’assemblage du code standard.
Cet article présente le générateur FARM, détaille ses principales fonctionnalités, propose des instructions d’installation pas à pas et les illustre avec un exemple concret : une application de gestion de tâches. Notre objectif : montrer comment ce générateur simplifie le développement full-stack et aide les développeurs Python à créer des applications évolutives et prêtes pour la production.
Besoin d’une piqûre de rappel sur MongoDB ? Consultez le cours de DataCamp Introduction to MongoDB in Python.
Qu’est-ce que le générateur d’applications FastAPI ?
Le générateur FARM automatise la création d’une pile applicative complète avec les composants suivants :
- Configuration full-stack : génère un back-end FastAPI, un front-end React et une base MongoDB, le tout intégré pour un développement rapide.
- Authentification préconfigurée : inclut OAuth2 avec JWT, l’authentification par lien magique et la gestion des cookies pour un accès utilisateur sécurisé. OAuth2 avec JWT fonctionne comme un « pass VIP » sécurisé (jeton JWT) que vous obtenez après connexion pour accéder aux zones privées.
- Intégration Docker Compose : fournit des fichiers Docker Compose préconfigurés pour un développement et des tests locaux simplifiés.
- Outils opérationnels : intègre Celery pour le traitement asynchrone des tâches, Traefik pour l’équilibrage de charge et GitHub Actions pour le CI/CD, afin de garantir un environnement prêt pour la production.
La liste complète des fonctionnalités est disponible sur le repo GitHub.
Bénéfices pour les développeurs
Le générateur FARM offre des avantages majeurs :
- Gain de temps : élimine les tâches de configuration répétitives (authentification, connexion à la base, etc.) pour vous permettre de coder immédiatement.
- Bonnes pratiques : garantit une structure de projet scalable, sécurisée et maintenable, conforme aux standards du secteur.
- Flexibilité : fournit une base personnalisable que vous pouvez étendre selon les besoins de votre projet.
Comment exécuter le générateur d’applications FastAPI pour MongoDB
Pour illustrer les capacités du générateur, nous allons configurer un projet d’exemple. Les instructions supposent que vous avez installé Python 3.8+, Node.js, Docker et Docker Compose.
Instructions d’installation pas à pas
Pour démontrer les capacités du générateur, nous allons créer un projet d’exemple nommé task-manager. Assurez-vous d’avoir installé les prérequis suivants :
- Python 3.11+ : idéalement 3.12, vérifié avec python3.12 --version.
- Node.js : pour le front-end React.
- Docker Desktop : pour un développement en conteneurs.
- MongoDB : installation locale (par exemple via Homebrew avec brew install mongodb-community@7.0) ou MongoDB Atlas (utilisez une URI de connexion du type mongodb+srv://:@cluster0.mongodb.net/?retryWrites=true&w=majority).
- Cookiecutter : pour générer le modèle de projet.
- Hatch : pour la gestion des dépendances.
- MongoDB Compass (optionnel) : pour visualiser la base de données.
Avant de continuer, créez un environnement virtuel avec /usr/local/bin/python3.12 -m venv task-manager-venv et activez-le avec source task-manager-venv/bin/activate.
- Installez la bibliothèque cookiecutter :
pip install cookiecutter - Générez le projet : utilisez le générateur FARM pour créer un projet :
cookiecutter https://github.com/mongodb-labs/full-stack-fastapi-mongodb --no-input project_name="task-manager"
cd task-manager- Installez MongoDB localement ou utilisez MongoDB Atlas :
brew tap mongodb/brew
brew install mongodb-community@7.0
brew services start mongodb-community@7.0Pour Atlas, inscrivez-vous, créez un cluster gratuit et récupérez une chaîne de connexion (par ex. mongodb+srv://:@cluster0.mongodb.net/?retryWrites=true&w=majority) à utiliser dans votre fichier .env.
- Configurez les variables d’environnement :
Copiez et éditez le fichier .env :
cp .env.example .env
nano .envMettez à jour avec votre URI MongoDB, le nom de base et les secrets :
MONGODB_URI=mongodb://localhost:27017
MONGO_DATABASE=task_manager
SECRET_KEY=your-secret-key
FIRST_SUPERUSER=admin@task-manager.com
FIRST_SUPERUSER_PASSWORD=changethis- Construisez et exécutez avec Docker Compose :
Assurez-vous que Docker Desktop est lancé, puis :
docker compose build --no-cache- docker compose up -d
- Accédez à l’application :
- Front-end : http://localhost:3000
- Back-end : http://localhost/api/v1
- Swagger UI : http://localhost/docs (documentation API interactive)
- ReDoc : http://localhost/redoc
- Flower : http://localhost:5555 (monitoring Celery)
- Traefik UI : http://localhost:8090 (tableau de bord de routage)
- Connectez-vous avec admin@task-manager.com (mot de passe : changethis).
- Testez l’authentification : utilisez Swagger UI (/docs) pour tester les endpoints /auth/login ou /auth/magic-link.
- Mettez en place le CI/CD : poussez vers GitHub pour déclencher les workflows GitHub Actions inclus.
Explorer la structure du projet full-stack généré
Quand vous utilisez le générateur FARM, il construit un projet task-manager parfaitement organisé. Imaginez une maison préfabriquée où chaque pièce a son rôle :
- backend/ : c’est la cuisine où fonctionne le back-end FastAPI. On y trouve des dossiers comme app/ (pour le code de votre API) et conf/ (pour les paramètres) pour gérer tâches et données.
- frontend/ : c’est le salon où les utilisateurs voient votre site, propulsé par Next.js/React. Le dossier app/ contient les pages (par ex. about, TaskList) avec des fichiers comme layout.tsx (le cadre de page) et page.tsx (le contenu). Le dossier public/ stocke, entre autres, l’icône du site.
- Autres fichiers : vous trouverez
docker-compose.yml(pour tout lancer avec Docker),.env(vos paramètres sensibles) et.github/workflows/(pour les tests automatisés lors du partage de votre code).
Cette configuration est prête à évoluer, et le générateur ajoute des outils pratiques pour faciliter le développement !
Ce que vous pouvez faire avec les fonctionnalités du générateur
Le générateur FARM embarque des outils très utiles pour créer toutes sortes de projets. Voici un aperçu simple de ce qu’ils font et de la manière dont ils vous aident :
Intégration Docker Compose : optimisée pour le développement local
- À quoi ça sert : Docker Compose est comme un bouton magique qui installe et exécute tout votre projet (back-end, front-end, base) en une commande. Il utilise des conteneurs pour isoler les composants et simplifier les tests en local.
- En quoi c’est utile : vous pouvez démarrer l’app task-manager avec
docker compose up -det l’arrêter avecdocker compose down. Idéal pour expérimenter sans perturber votre machine. Vérifiez l’état avecdocker compose ps— si tout est « Up », vous êtes prêt !
Exemple : après configuration, exécutez simplement :
cd task-manager
docker compose up -dOuvrez http://localhost:3000 pour voir le front-end ; tout tourne en local !
Système d’authentification intégré
- À quoi ça sert : ajoute un système de connexion avec comptes utilisateurs, incluant un super-utilisateur par défaut (par ex.
admin@task-manager.comavec le mot de passechangethis). Il s’appuie sur OAuth2 avec des jetons JWT (codes de connexion sécurisés) et des liens magiques (liens envoyés par e-mail pour se connecter). - En quoi c’est utile : vous pouvez permettre aux utilisateurs de s’inscrire, de se connecter ou d’utiliser un lien magique. Testez-le sur http://localhost/docs dans Swagger UI — cherchez
/api/v1/login/oauthpour simuler une connexion. Parfait pour des apps privées, comme une liste de tâches personnelle.
Exemple : connectez-vous avec l’utilisateur par défaut :
- Allez sur http://localhost/docs.
- Trouvez
/api/v1/login/oauth, saisissezadmin@task-manager.comet le mot de passe indiqué, puis cliquez sur « Execute ». Vous recevrez un jeton JWT pour accéder aux pages privées !
L’API du gestionnaire de tâches
Démo pour l’API OAuth
Réponse de l’API OAuth
Fonctionnalités du back-end FastAPI
Voyons de plus près les fonctionnalités clés du back-end propulsé par FastAPI et comment il simplifie les opérations sur la base, la conception d’API et la montée en charge.
- MongoDB Motor : le moteur qui communique très rapidement avec votre base MongoDB, même sous forte charge.
- MongoDB ODMantic : un assistant qui facilite l’enregistrement et la recherche de données dans MongoDB, comme ranger vos tâches dans des boîtes bien ordonnées.
- Prise en charge CRUD : CRUD signifie create, read, update, delete. Des outils prêts à l’emploi pour ajouter, consulter, modifier ou supprimer des données (comme des tâches) sans repartir de zéro.
- Conforme aux standards : suit des normes comme OpenAPI et JSON Schema, ce qui rend votre API claire et interopérable.
- En quoi c’est utile : vous pouvez construire rapidement un back-end pour stocker des tâches. Le générateur prépare le terrain ; vous n’avez plus qu’à ajouter vos idées (nouvelles fonctionnalités de tâches) en vous appuyant sur le code fourni.
Exemple : ajoutez un visualiseur rapide de tâches dans backend/app/api/tasks.py :
from fastapi import APIRouter, Depends
from odmantic import AIOEngine, Model
from motor.motor_asyncio import AsyncIOMotorClient
router = APIRouter(prefix="/tasks", tags=["tasks"])
class Task(Model):
title: str
async def get_db():
client = AsyncIOMotorClient("mongodb://localhost:27017")
return AIOEngine(client, database="task_manager")
@router.get("/") # View all tasks
async def get_tasks(db: AIOEngine = Depends(get_db)):
return await db.find(Task)Testez sur http://localhost/api/v1/tasks après reconstruction avec docker compose up --build.
Front-end Next.js/React
Le front-end React est l’interface avec laquelle vos utilisateurs interagissent. Voyons sa structure et les outils inclus pour créer des pages soignées et réactives.
- Autorisation via middleware : un portier qui vérifie la connexion avant d’afficher certaines pages (par ex. seuls les utilisateurs connectés voient /TaskList).
- Validation de formulaires avec React Hook Form : garantit que les formulaires (comme l’ajout de tâche) sont correctement renseignés, pour éviter les enregistrements vides.
- Gestion d’état avec Redux : suit l’état (par ex. tâches sélectionnées) pour un affichage fluide, même avec beaucoup de données.
- CSS et composants avec TailwindCSS, HeroIcons et HeadlessUI : des briques de design prêtes à l’emploi. TailwindCSS pour le style, HeroIcons pour des icônes soignées, HeadlessUI pour des boutons et menus efficaces.
- En quoi c’est utile : vous créez facilement une page de tâches esthétique avec des formulaires pratiques et un accès sécurisé. Le générateur pose les bases graphiques pour que vous puissiez vous concentrer sur les fonctionnalités.
Exemple : ajoutez un formulaire simple de tâche dans frontend/app/TaskList/page.tsx :
import { useState } from 'react';
export default function TaskList() {
const [task, setTask] = useState({ title: '' });
const handleSubmit = (e: React.FormEvent) => {
e.preventDefault();
fetch('http://localhost/api/v1/tasks', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(task),
});
setTask({ title: '' });
};
return (
<div className="container mx-auto p-4">
<h1 className="text-2xl font-bold">Add Task</h1>
<form onSubmit={handleSubmit}>
<input
className="border p-2"
value={task.title}
onChange={e => setTask({ title: e.target.value })}
placeholder="Task name"
/>
<button className="bg-blue-500 text-white p-2" type="submit">Add</button>
</form>
</div>
);
}Rendez-vous sur http://localhost:3000/TaskList pour ajouter une tâche.
Faites évoluer votre gestionnaire de tâches
Le générateur constitue un excellent point de départ pour un gestionnaire de tâches. Par exemple, vous pouvez :
- Ajouter un bouton pour marquer les tâches comme terminées via les outils CRUD.
- Utiliser l’authentification pour garder votre liste de tâches privée.
- Styliser l’interface avec TailwindCSS pour un rendu impeccable.
- Configurer Celery pour envoyer des rappels de tâches par e-mail.
Autres pistes à explorer
Avec ces fonctionnalités, vous pouvez aller bien au-delà d’un gestionnaire de tâches :
- Blog ou site web : stockez les articles dans MongoDB, exposez-les avec FastAPI et concevez un site attrayant avec Next.js.
- Boutique en ligne : enregistrez les produits dans MongoDB, traitez les commandes avec Celery et créez une vitrine avec Next.js.
- Mises à jour en direct : affichez des informations en temps réel (score de match, etc.) grâce à MongoDB, aux capacités temps réel de FastAPI et à un tableau de bord Next.js.
Conclusion
Le générateur d’applications FARM simplifie le développement full-stack en fournissant une pile préconfigurée et prête pour la production, intégrant FastAPI, React et MongoDB. L’automatisation des tâches d’initialisation, l’adhésion aux bonnes pratiques et une architecture flexible en font un outil précieux pour les développeurs Python. Que vous construisiez un gestionnaire de tâches ou une application web complexe, le générateur FARM accélère vos développements et garantit l’évolutivité. Essayez-le dès aujourd’hui en suivant les étapes d’installation, et explorez la documentation complète sur le dépôt GitHub pour en exploiter tout le potentiel !
Pour aller plus loin, consultez ces ressources utiles :
- Dépôt officiel : parcourez le code source, lisez la documentation complète, suivez les mises à jour ou contribuez.
- Documentation FastAPI : découvrez les fonctionnalités de FastAPI et comment il propulse le back-end.
- Introduction to FastAPI Course : créez des API robustes et prêtes pour la production avec FastAPI, en maîtrisant les opérations HTTP, la validation et l’exécution asynchrone pour bâtir des pipelines data et ML efficaces.
