API CRUD Spring Boot - MongoDB & JWT(Lets-play)

Une API REST complète avec authentification JWT, gestion des rôles (USER/ADMIN) et opérations CRUD sur les entités Users et Products.

🔧 Technologies utilisées

• Framework: Spring Boot 3.4.5
• Base de données: MongoDB
• Authentification: JWT (JSON Web Token)
• Sécurité: Spring Security
• Validation: Spring Validation
• Build: Maven
• Java: 17
• Rate Limiting: Bucket4j
• SSL: HTTPS avec certificat PKCS12
• Conteneurisation: Docker & Docker Compose

📋 Prérequis

• Java 17+
• Maven 3.6+
• Docker & Docker Compose (recommandé)
• Un outil de test API (Postman, curl, etc.)

⚙️ Configuration de l'environnement

1. Base de données MongoDB avec Docker

Le projet inclut un fichier docker-compose.yaml pour faciliter le déploiement de MongoDB :

# Démarrer MongoDB et Mongo Express avec Docker Compose
docker-compose up -d

Cette commande démarre :

• MongoDB sur le port 27017
• Mongo Express (interface web) sur le port 8081

Accès à Mongo Express

• URL: http://localhost:8081
• Identifiants: root / rootpassword

2. Configuration SSL et HTTPS

L'API utilise HTTPS avec redirection automatique HTTP → HTTPS :

• Port HTTPS : 8443 (principal)
• Port HTTP : 8080 (redirection automatique vers HTTPS)

Un certificat keystore.p12 est requis dans le répertoire src/main/resources/.

3. Variables d'environnement

Modifiez application.properties selon votre configuration :

# Base de données MongoDB
spring.data.mongodb.uri=mongodb://root:rootpassword@localhost:27017/letsplay?authSource=admin
spring.data.mongodb.database=letsplay

# Serveur HTTPS
server.port=8443
server.ssl.enabled=true
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=admin123

# JWT Secret (à modifier en production)
jwt.secret=votre_secret_jwt_ici

🚀 Installation et démarrage

Méthode 1 : Avec Docker (Recommandée)

1. Cloner le projet

git clone https://learn.zone01dakar.sn/git/preydedy/lets-play
cd letsplay

2. Démarrer MongoDB

docker-compose up -d

3. Installer les dépendances et démarrer l'application

mvn clean install
mvn spring-boot:run

Méthode 2 : Installation manuelle

1. Installer MongoDB localement
2. Configurer les paramètres de connexion
3. Démarrer l'application

L'API sera accessible sur : https://localhost:8443/api

Les requêtes HTTP sur le port 8080 seront automatiquement redirigées vers HTTPS (port 8443).

🔐 Système d'authentification et sécurité

Initialisation automatique de l'administrateur

Au démarrage de l'application, un compte administrateur par défaut est créé automatiquement :

{
  "name": "adminroot",
  "email": "admin@root.com",
  "password": "test123",
  "role": "ADMIN"
}

⚠️ Important : Changez ce mot de passe en production !

Protection Rate Limiting

L'API inclut une protection contre les attaques par force brute :

• Endpoint protégé : /api/auth/login
• Limite : 5 tentatives par minute par adresse IP
• Réponse : Code 429 "Trop de tentatives. Réessayez plus tard."

Configuration CORS

CORS configuré pour accepter les requêtes depuis http://localhost:4200 (frontend Angular).

Structure du JWT

Le token JWT contient les informations suivantes :

• ID utilisateur
• Email
• Rôle (USER/ADMIN)
• Date d'expiration

Utilisation

1. Inscription/Connexion pour obtenir un token
2. Inclure le token dans l'en-tête Authorization: Bearer <token> pour les endpoints protégés

📚 Documentation des endpoints

🔑 Authentification (/api/auth)

Inscription

POST /api/auth/register
Content-Type: application/json

{
  "name": "John Doe",
  "email": "john@example.com", 
  "password": "motdepasse123",
  "role": "USER"
}

Réponse (201 Created):

{
  "id": "60f7b3b3b3b3b3b3b3b3b3b3",
  "name": "John Doe",
  "email": "john@example.com",
  "role": "USER"
}

Connexion

POST /api/auth/login
Content-Type: application/json

{
  "email": "john@example.com",
  "password": "motdepasse123"
}

Réponse (200 OK):

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

👥 Gestion des utilisateurs (/api/users)

Récupérer un utilisateur par ID

GET /api/users/{id}
Authorization: Bearer <token>

Autorisations: Propriétaire ou ADMIN

Réponse (200 OK):

{
  "id": "60f7b3b3b3b3b3b3b3b3b3b3",
  "name": "John Doe",
  "email": "john@example.com",
  "role": "USER"
}

Modifier un utilisateur

PUT /api/users/{id}
Authorization: Bearer <token>
Content-Type: application/json

{
  "name": "John Smith",
  "email": "johnsmith@example.com",
  "password": "nouveaumotdepasse123"
}

Autorisations: Propriétaire ou ADMIN

🛍️ Gestion des produits (/api/products)

Lister tous les produits

GET /api/products

Autorisations: Public (aucune authentification requise)

Réponse (200 OK):

[
  {
    "id": "60f7b3b3b3b3b3b3b3b3b3b3",
    "name": "Produit 1",
    "description": "Description du produit 1",
    "price": 29.99,
    "userId": "60f7b3b3b3b3b3b3b3b3b3b3"
  }
]

Récupérer un produit par ID

GET /api/products/{id}

Autorisations: Public

Créer un produit

POST /api/products
Authorization: Bearer <token>
Content-Type: application/json

{
  "name": "Nouveau produit",
  "description": "Description du nouveau produit",
  "price": 49.99
}

Autorisations: USER ou ADMIN

Réponse (200 OK):

{
  "id": "60f7b3b3b3b3b3b3b3b3b3b3",
  "name": "Nouveau produit",
  "description": "Description du nouveau produit", 
  "price": 49.99,
  "userId": "60f7b3b3b3b3b3b3b3b3b3b3"
}

Modifier un produit

PUT /api/products/{id}
Authorization: Bearer <token>
Content-Type: application/json

{
  "name": "Produit modifié",
  "description": "Description modifiée",
  "price": 59.99
}

Autorisations: Propriétaire du produit ou ADMIN

🔧 Administration (/api/admin)

Toutes les routes administratives nécessitent le rôle ADMIN

Lister tous les utilisateurs

GET /api/admin/users
Authorization: Bearer <token>

Supprimer un utilisateur

DELETE /api/admin/users/{id}
Authorization: Bearer <token>

Réponse: 204 No Content

Supprimer un produit

DELETE /api/admin/products/{id}
Authorization: Bearer <token>

Réponse: 204 No Content

🔒 Sécurité et autorisations

Matrice des autorisations

Endpoint	Public	USER	ADMIN	Propriétaire
GET /products	✅	✅	✅	✅
GET /products/{id}	✅	✅	✅	✅
POST /products	❌	✅	✅	-
PUT /products/{id}	❌	❌	✅	✅
GET /users/{id}	❌	❌	✅	✅
PUT /users/{id}	❌	❌	✅	✅
GET /admin/users	❌	❌	✅	-
DELETE /admin/users/{id}	❌	❌	✅	-
DELETE /admin/products/{id}	❌	❌	✅	-

Fonctionnalités de sécurité

• Rate Limiting: Protection contre les attaques par déni de service (5 req/min sur login)
• Redirection HTTPS: Toutes les requêtes HTTP sont automatiquement redirigées vers HTTPS
• Validation des données: Sanitisation des entrées utilisateur
• Chiffrement des mots de passe: BCrypt
• HTTPS: Communication sécurisée avec certificat PKCS12
• JWT: Tokens sécurisés avec expiration
• CORS: Configuration sécurisée pour les appels cross-origin

📝 Modèles de données

User

{
  "id": "string",
  "name": "string",
  "email": "string",
  "password": "string (chiffré)",
  "role": "USER|ADMIN"
}

Product

{
  "id": "string", 
  "name": "string",
  "description": "string",
  "price": "number",
  "userId": "string"
}

❌ Gestion des erreurs

Gestionnaire global d'exceptions

L'API utilise un GlobalExceptionHandler qui gère automatiquement :

• Validation : MethodArgumentNotValidException → 400 Bad Request
• Authentification : UsernameNotFoundException, BadCredentialsException, JwtException → 401 Unauthorized
• Autorisation : AccessDeniedException → 403 Forbidden
• Ressource non trouvée : NoHandlerFoundException, ResourceNotFoundException → 404 Not Found
• Conflits : EmailAlreadyUsedException → 409 Conflict
• Mots de passe faibles : PasswordTooWeakException, InvalidException → 400 Bad Request
• Erreurs génériques : Exception → 500 Internal Server Error

Codes de réponse HTTP

• 200: Succès
• 201: Créé avec succès
• 204: Suppression réussie
• 400: Données invalides
• 401: Non authentifié
• 403: Accès refusé
• 404: Ressource non trouvée
• 409: Conflit (ex: email déjà utilisé)
• 429: Trop de requêtes (Rate limiting)
• 500: Erreur serveur

Format des erreurs

{
  "status": 400,
  "error": "Bad Request",
  "message": "Description de l'erreur",
  "path": "/api/endpoint"
}

Erreurs courantes

• Email déjà utilisé: EmailAlreadyUsedException
• Mot de passe trop faible: PasswordTooWeakException
• Ressource non trouvée: ResourceNotFoundException
• ID invalide: InvalidException
• Token JWT invalide: JwtException
• Trop de tentatives de connexion: Rate limiting (429)

🧪 Tests avec Postman

Une collection Postman est fournie : CRUD_API_JWT_Postman_Collection.json

Variables d'environnement Postman

{
  "base_url": "https://localhost:8443/api",
  "jwt_token": "{{token_obtenu_lors_du_login}}",
  "user_id": "{{id_utilisateur}}",
  "product_id": "{{id_produit}}"
}

Workflow de test

1. Connexion administrateur avec les identifiants par défaut
2. Inscription d'un nouvel utilisateur
3. Connexion pour obtenir le token JWT
4. Créer des produits avec le token
5. Tester les différents endpoints selon les rôles
6. Tester le rate limiting sur /api/auth/login

🐳 Déploiement avec Docker

Configuration Docker Compose

Le projet inclut un docker-compose.yaml qui configure :

services:
  mongo:
    image: mongo:latest
    ports: ["27017:27017"]
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: rootpassword
    volumes:
      - mongo_data:/data/db

  mongo-express:
    image: mongo-express
    ports: ["8081:8081"]
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: root
      ME_CONFIG_MONGODB_ADMINPASSWORD: rootpassword

Commandes Docker utiles

# Démarrer les services
docker-compose up -d

# Arrêter les services
docker-compose down

# Voir les logs
docker-compose logs -f

# Supprimer les volumes (attention : perte de données)
docker-compose down -v

🛠️ Développement

Structure du projet

src/main/java/com/example/letsplay/
├── controller/          # Contrôleurs REST
├── dto/                # Objets de transfert de données  
├── exception/          # Gestion des exceptions
├── model/             # Entités MongoDB
├── repository/        # Repositories MongoDB
├── security/          # Configuration sécurité & JWT
├── service/           # Logique métier
└── AdminInitializer.java  # Initialisation admin

Configuration de sécurité

La classe SecurityConfig configure :

• Filtres JWT : Authentification par token
• Autorisations : Règles d'accès par rôle
• CORS : Configuration cross-origin
• Providers : Authentification et encodage des mots de passe

Ajout de nouvelles fonctionnalités

1. Créer les DTOs appropriés
2. Ajouter les validations nécessaires
3. Implémenter la logique dans les services
4. Créer les endpoints dans les contrôleurs
5. Configurer les autorisations dans SecurityConfig
6. Ajouter la gestion d'erreurs dans GlobalExceptionHandler
7. Ajouter les tests correspondants

🔄 Validation des données

Règles de validation

Utilisateurs:

• Nom : obligatoire, non vide
• Email : format valide, unique, 5-50 caractères
• Mot de passe : minimum 6 caractères
• Rôle : "USER" ou "ADMIN"

Produits:

• Nom : obligatoire, non vide
• Description : obligatoire, non vide
• Prix : positif, minimum 0

Sécurité des données

• Sanitisation: Protection contre l'injection MongoDB
• Anti-XSS: Filtrage des scripts malveillants
• Longueur: Limitation à 255 caractères par champ
• Rate Limiting: Protection contre les attaques par force brute

📞 Support et débogage

Logs utiles

• Initialisation admin : "✅ Admin user created"
• Rate limiting : "Trop de tentatives. Réessayez plus tard."
• Redirection HTTPS : Vérifiez les logs Tomcat

Problèmes courants

1. Certificat SSL manquant : Vérifiez keystore.p12 dans resources/
2. MongoDB inaccessible : Vérifiez Docker Compose
3. Rate limiting déclenché : Attendez 1 minute entre les tentatives
4. CORS bloqué : Vérifiez l'origine dans SecurityConfig

Pour toute question ou problème :

1. Vérifiez les logs de l'application
2. Consultez la documentation des erreurs
3. Testez avec la collection Postman fournie
4. Vérifiez l'état des conteneurs Docker

🔐 Sécurité en production

⚠️ Important avant la mise en production :

1. Changez le secret JWT dans application.properties
2. Changez le mot de passe admin par défaut
3. Utilisez des certificats SSL valides (Let's Encrypt)
4. Configurez MongoDB avec authentification forte
5. Activez les logs de sécurité et monitoring
6. Configurez un reverse proxy (Nginx/Apache)
7. Mettez en place un monitoring des performances
8. Configurez des sauvegardes MongoDB automatiques
9. Ajustez les limites de rate limiting selon vos besoins
10. Utilisez des variables d'environnement pour les secrets

Variables d'environnement pour la production

JWT_SECRET=your_super_secure_jwt_secret_here
MONGO_URI=mongodb://user:password@localhost:27017/letsplay
SSL_KEYSTORE_PASSWORD=your_keystore_password
ADMIN_DEFAULT_PASSWORD=your_secure_admin_password

License

This project is licensed under the MIT License - see the LICENSE file for details.

Author

• preydedy