Learning Management System - Microservices Architecture

🏗️ Architecture Overview

This project implements a comprehensive Learning Management System (LMS) using a microservices architecture with Spring Boot 3, WebFlux, PostgreSQL, Redis, RabbitMQ, and Kubernetes deployment.

🎯 Services Architecture

Core Business Services

User Service (Port: 8081) - User management, authentication, profiles
Course Service (Port: 8082) - Course content, modules, lessons
Enrollment Service (Port: 8083) - Student enrollments, progress tracking
Assessment Service (Port: 8084) - Quizzes, assignments, grading
Notification Service (Port: 8085) - Email, push notifications

Infrastructure Services

API Gateway (Port: 8080) - Spring Cloud Gateway for routing
Config Server (Port: 8888) - Centralized configuration
Discovery Server (Port: 8761) - Eureka service registry

🛠️ Technology Stack

Framework: Spring Boot 3.2.0
Reactive: Spring WebFlux
Database: PostgreSQL with R2DBC
Caching: Redis
Message Broker: RabbitMQ
Service Discovery: Eureka
API Gateway: Spring Cloud Gateway
Security: JWT + OAuth2
Containerization: Docker
Orchestration: Kubernetes
Monitoring: Prometheus + Grafana

🗄️ Database Design

Each service has its own PostgreSQL database following the database-per-service pattern:

User Service Database

- users (id, username, email, password_hash, first_name, last_name, role, status)
- user_profiles (id, user_id, bio, avatar_url, phone, preferences)

Course Service Database

- courses (id, title, description, instructor_id, category_id, level, price)
- course_modules (id, course_id, title, description, order_index)
- lessons (id, module_id, title, content, video_url, duration_minutes)
- course_categories (id, name, description, parent_id)

Enrollment Service Database

- enrollments (id, student_id, course_id, enrollment_date, progress_percentage)
- lesson_progress (id, enrollment_id, lesson_id, completed_at, time_spent)
- learning_paths (id, name, description, created_by)

Assessment Service Database

- assessments (id, course_id, title, type, max_score, time_limit)
- assessment_questions (id, assessment_id, question_text, question_type, points)
- assessment_submissions (id, assessment_id, student_id, score, status)

Notification Service Database

- notifications (id, recipient_id, type, message, status, sent_at)
- notification_templates (id, name, type, subject, body, variables)
- notification_preferences (id, user_id, email_enabled, push_enabled)

🔌 API Endpoints

User Service (`/api/v1/users`)

POST / - Create user
GET /{id} - Get user by ID
PUT /{id} - Update user
DELETE /{id} - Delete user
GET /search - Search users
PATCH /{id}/status - Update user status

Course Service (`/api/v1/courses`)

GET / - List courses
POST / - Create course
GET /{id} - Get course details
GET /{id}/modules - Get course modules
POST /{id}/modules - Add course module

Enrollment Service (`/api/v1/enrollments`)

POST / - Enroll student
GET /student/{id} - Get student enrollments
PUT /{id}/progress - Update progress
GET /analytics/{courseId} - Get enrollment analytics

Assessment Service (`/api/v1/assessments`)

GET /course/{courseId} - Get course assessments
POST / - Create assessment
POST /{id}/submit - Submit assessment
GET /submissions/student/{id} - Get student submissions

Notification Service (`/api/v1/notifications`)

POST /send - Send notification
GET /user/{userId} - Get user notifications
PUT /{id}/read - Mark as read
POST /bulk-send - Send bulk notifications

🎭 Event-Driven Architecture

Published Events

User Events: user.created, user.updated, user.deleted, user.status.changed
Course Events: course.created, course.published, course.updated
Enrollment Events: enrollment.created, enrollment.completed, progress.updated
Assessment Events: assessment.submitted, assessment.graded

Event Flow Examples

User Registration → user.created → notification-service (welcome email)
Course Published → course.published → notification-service (notify enrolled students)
Assessment Submitted → assessment.submitted → notification-service (notify instructor)

🔐 Security Architecture

JWT Authentication Flow

User authenticates via API Gateway
JWT token issued with user claims and roles
Each service validates JWT independently
Role-based access control (RBAC) enforced

Roles & Permissions

STUDENT: View courses, enroll, submit assessments, track progress
INSTRUCTOR: Create courses, grade assessments, view student progress
ADMIN: Full system access, user management, analytics

🚀 Getting Started

Prerequisites

Java 17+
Docker & Docker Compose
Maven 3.8+
Kubernetes (optional, for production deployment)

Development Setup

# Clone the repository
git clone <repository-url>
cd lms-services

# Start infrastructure services
docker-compose up -d postgres-users postgres-courses postgres-enrollments postgres-assessments postgres-notifications redis rabbitmq

# Start discovery server
cd discovery-service && mvn spring-boot:run

# Start config server
cd config-service && mvn spring-boot:run

# Start individual services
cd user-service && mvn spring-boot:run
cd course-service && mvn spring-boot:run
cd enrollment-service && mvn spring-boot:run
cd assessment-service && mvn spring-boot:run
cd notification-service && mvn spring-boot:run

# Start API Gateway
cd gateway-service && mvn spring-boot:run

Docker Deployment

# Build and start all services
docker-compose up --build

# View logs
docker-compose logs -f user-service

# Scale services
docker-compose up --scale user-service=3

Kubernetes Deployment

# Apply database configurations
kubectl apply -f kubernetes/postgres/

# Apply infrastructure services
kubectl apply -f kubernetes/infrastructure/

# Apply business services
kubectl apply -f kubernetes/services/

# Check deployment status
kubectl get pods -l app=user-service

📊 Monitoring & Observability

Health Checks

All services expose health endpoints at /actuator/health

Metrics

Prometheus: Metrics collection (port 9090)
Grafana: Visualization dashboards (port 3000)
Custom Metrics: Business metrics for each service

Distributed Tracing

Spring Cloud Sleuth: Request tracing
Jaeger: Trace visualization
Correlation IDs: End-to-end request tracking

Logging

Structured JSON logging
Centralized log aggregation
Request/response logging with correlation IDs

🧪 Testing Strategy

Unit Tests

# Run unit tests for all services
mvn test

# Generate coverage report
mvn jacoco:report

Integration Tests

# Run integration tests with testcontainers
mvn verify -P integration-tests

Contract Tests

Consumer-driven contract testing with Pact
API contract validation
Cross-service communication testing

📈 Performance & Scalability

Caching Strategy

User Sessions: Redis-based session storage
Course Catalog: Cached with TTL
Assessment Results: Cached for quick retrieval
Cache Invalidation: Event-driven cache updates

Database Optimization

Connection pooling with HikariCP
Read replicas for read-heavy operations
Database indexes for performance
Partitioning for large tables

Horizontal Scaling

Stateless service design
Load balancing with Spring Cloud Gateway
Auto-scaling with Kubernetes HPA
Circuit breaker pattern for resilience

🔄 CI/CD Pipeline

GitLab CI/CD Example

stages:
  - test
  - build
  - deploy

test:
  script:
    - mvn test
    - mvn verify -P integration-tests

build:
  script:
    - docker build -t lms/user-service .
    - docker push lms/user-service

deploy:
  script:
    - kubectl apply -f kubernetes/

🚀 Production Considerations

Environment Configuration

Separate configurations for dev/staging/prod
Secret management with Kubernetes secrets
Environment-specific database configurations

Security Hardening

TLS/SSL encryption
Network policies
Vulnerability scanning
Security headers

Backup & Recovery

Automated database backups
Point-in-time recovery
Disaster recovery procedures
Data retention policies

📚 API Documentation

Interactive API documentation is available via Swagger UI:

User Service: http://localhost:8081/swagger-ui.html
Course Service: http://localhost:8082/swagger-ui.html
Assessment Service: http://localhost:8084/swagger-ui.html

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

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

🆘 Support

For support and questions:

Create an issue in the repository
Contact the development team
Check the documentation wiki

Happy Learning! 🎓

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
.idea		.idea
course-service		course-service
enrollment-service		enrollment-service
kubernetes		kubernetes
scripts		scripts
user-service		user-service
websocket-service/src/main/java/com/lms/websocket		websocket-service/src/main/java/com/lms/websocket
API_DOCUMENTATION.md		API_DOCUMENTATION.md
DATABASE_SETUP.md		DATABASE_SETUP.md
IMPLEMENTATION_COMPLETE.md		IMPLEMENTATION_COMPLETE.md
LMS_API_DOCUMENTATION.md		LMS_API_DOCUMENTATION.md
LMS_ARCHITECTURE.md		LMS_ARCHITECTURE.md
LMS_ARCHITECTURE_SUMMARY.md		LMS_ARCHITECTURE_SUMMARY.md
LOCAL_DEVELOPMENT.md		LOCAL_DEVELOPMENT.md
QUICK_START.md		QUICK_START.md
README.md		README.md
TASKS_COMPLETED.md		TASKS_COMPLETED.md
docker-compose.infrastructure.yml		docker-compose.infrastructure.yml
docker-compose.minimal.yml		docker-compose.minimal.yml
docker-compose.yml		docker-compose.yml
query		query
start-lms-local.bat		start-lms-local.bat
start-lms.bat		start-lms.bat
start-lms.sh		start-lms.sh

venkatesh-i2i/lms-codebase

Folders and files

Latest commit

History

Repository files navigation