- Overview
- 🏗️ Architecture
- 🔧 Microservices
- 🛠️ Technologies & Patterns
- 🚀 Getting Started
- 📊 Monitoring & Observability
- 🔄 CI/CD & Deployment
- 🌐 API Documentation
- 🏆 Key Features
Akeed is a comprehensive, enterprise-grade job platform built using modern microservices architecture. This project demonstrates advanced software engineering practices, scalable system design, and production-ready deployment strategies. The platform handles job postings, user management, applications, search functionality, and real-time notifications.
- Job Posting & Management: Recruiters can create, manage, and boost job posts
- User Profiles: Comprehensive user profiles with skills, experience, and education
- Application System: Complete job application workflow with status tracking
- Advanced Search: Multi-strategy search with filtering, location-based, and recent searches
- Real-time Notifications: Event-driven notification system using message queues
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ API Gateway │ │ Load Balancer │ │ Monitoring │
│ (Port 8089) │ │ │ │ (Grafana) │
└─────────┬───────┘ └─────────────────┘ └─────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Service Mesh │
├─────────────┬─────────────┬─────────────┬─────────────┬─────────┤
│UserService │PostService │AppService │SearchService│NotifSvc │
│(Port 8084) │(Port 8082) │(Port 8080) │(Port 8083) │(8081) │
│PostgreSQL │MongoDB │PostgreSQL │PostgreSQL │MongoDB │
└─────────────┴─────────────┴─────────────┴─────────────┴─────────┘
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Redis │ │ RabbitMQ │ │ Databases │
│ (Caching) │ │ (Messaging) │ │ (Persistence) │
└─────────────────┘ └─────────────────┘ └─────────────────┘
- Synchronous: REST APIs with OpenFeign clients for inter-service communication
- Asynchronous: RabbitMQ for event-driven messaging and notifications
- Caching: Redis for performance optimization and session management
- API Gateway: Centralized routing, load balancing, and cross-cutting concerns
Technology Stack: Spring Boot, PostgreSQL, Redis, RabbitMQ
- User Management: Registration, authentication, profile management
- Recruiter Profiles: Company information, job posting permissions
- User Types: Job seekers and recruiters with role-based access
- Data Models: Users, Recruiters, Education, Work Experience, Blocked Users
- Caching: Redis for user session and profile caching
- Patterns: Repository pattern, Service layer architecture
Technology Stack: Spring Boot, MongoDB, Redis, RabbitMQ
- Job Post Management: CRUD operations for job postings
- Post Status: Active, Archived, Deleted states with lifecycle management
- Post Boosting: Premium job post promotion feature
- Media Support: Multiple media URLs and post types
- Observer Pattern: Real-time notifications for post events
- Builder Pattern: Complex post object construction
- Caching: Redis for frequently accessed posts
Technology Stack: Spring Boot, PostgreSQL, Redis, RabbitMQ
- Application Workflow: Complete job application lifecycle
- Status Tracking: Pending, Accepted, Rejected, Withdrawn states
- Command Pattern: Encapsulated application operations
- Feign Integration: Communication with Post Service for job details
- Event Publishing: RabbitMQ notifications for application events
- Audit Logging: Comprehensive application history tracking
Technology Stack: Spring Boot, PostgreSQL, Redis, OpenFeign
- Strategy Pattern: Multiple search algorithms (Filter, Location, Recent, Post, User)
- Advanced Filtering: Skills, location, employment type, industry filters
- Search History: User search tracking and recent searches
- Cross-Service Search: Federated search across posts and users
- Caching: Redis for search result optimization
- Performance: Optimized queries with database indexing
Technology Stack: Spring Boot, MongoDB, RabbitMQ
- Event-Driven: RabbitMQ consumer for real-time notifications
- Command Pattern: Encapsulated notification operations
- Observer Pattern: Notification lifecycle event handling
- Notification Types: Job applications, post updates, system alerts
- Status Management: Read/Unread notification states
- Scalable Design: Asynchronous processing for high throughput
Technology Stack: Spring Cloud Gateway
- Centralized Routing: Single entry point for all client requests
- Load Balancing: Intelligent request distribution
- Cross-Cutting Concerns: Authentication, logging, rate limiting
- Service Discovery: Dynamic service registration and discovery
- Microservices Pattern: Distributed system architecture
- API Gateway Pattern: Centralized request routing
- Database per Service: Data isolation and independence
- Event Sourcing: RabbitMQ for event-driven communication
- CQRS: Command Query Responsibility Segregation
- Observer Pattern: Real-time event notifications
- Strategy Pattern: Multiple search algorithms
- Command Pattern: Encapsulated business operations
- Builder Pattern: Complex object construction
- Repository Pattern: Data access abstraction
- Factory Pattern: Service and command creation
- Backend Framework: Spring Boot 3.4.5, Spring Cloud 2024.0.1
- Programming Language: Java 23
- Databases: PostgreSQL (ACID compliance), MongoDB (Document storage)
- Caching: Redis (In-memory data structure store)
- Message Queue: RabbitMQ (Asynchronous messaging)
- Service Communication: OpenFeign (Declarative REST clients)
- Containerization: Docker & Docker Compose
- Orchestration: Kubernetes with custom deployments
- Monitoring: Grafana, Loki, Promtail (Observability stack)
- Build Tool: Maven
- API Documentation: RESTful APIs with comprehensive endpoints
- Caching Strategy: Multi-level caching with Redis
- Error Handling: Comprehensive exception management
- Logging: Structured logging with Logback and Loki integration
- Health Checks: Spring Actuator endpoints
- Metrics: Prometheus metrics collection
- Configuration Management: Externalized configuration
- Security: Role-based access control
- Java 23+
- Docker & Docker Compose
- Maven 3.8+
- Kubernetes (optional, for K8s deployment)
# Clone the repository
git clone <repository-url>
cd FinalProject-33-BarmagTouny
# Start all services with dependencies
docker-compose up -d
# Start with monitoring stack
docker-compose -f docker-compose.yaml -f docker-compose-monitoring.yml up -d# Create namespace
kubectl apply -f K8s/namespace.yaml
# Deploy databases
kubectl apply -f K8s/postgres/
kubectl apply -f K8s/mongo/
kubectl apply -f K8s/redis/
kubectl apply -f K8s/rabbitmq/
# Deploy microservices
kubectl apply -f K8s/user-service/
kubectl apply -f K8s/post-service/
kubectl apply -f K8s/app-service/
kubectl apply -f K8s/search-service/
kubectl apply -f K8s/notification-service/
kubectl apply -f K8s/apigateway/# Build all services
mvn clean install
# Start infrastructure services
docker-compose up postgres mongo redis rabbitmq -d
# Run services individually
cd UserService && mvn spring-boot:run
cd PostService && mvn spring-boot:run
cd AppService && mvn spring-boot:run
cd SearchService && mvn spring-boot:run
cd NotificationService && mvn spring-boot:run
cd gateway && mvn spring-boot:run- Grafana (Port 3000): Visualization and dashboards
- Loki (Port 3100): Log aggregation and querying
- Promtail: Log collection and forwarding
- Redis Insight (Port 5540): Redis monitoring
- Mongo Express (Port 9000): MongoDB administration
- RabbitMQ Management (Port 15672): Message queue monitoring
- Service health and uptime
- Request/response times
- Database connection pools
- Cache hit/miss ratios
- Message queue throughput
- Error rates and exceptions
- Structured Logging: JSON format with correlation IDs
- Centralized Logs: Loki aggregation across all services
- Log Levels: Configurable logging levels per service
- Audit Trails: Comprehensive business operation logging
- Multi-stage Builds: Optimized Docker images
- Health Checks: Container health monitoring
- Resource Limits: Memory and CPU constraints
- Security: Non-root user execution
- Deployments: Rolling updates and rollbacks
- Services: Load balancing and service discovery
- ConfigMaps: Environment-specific configuration
- Secrets: Secure credential management
- Namespaces: Environment isolation
- Health Probes: Liveness and readiness checks
GET /api/users/{id} - Get user profile
POST /api/users - Create user
PUT /api/users/{id} - Update user
DELETE /api/users/{id} - Delete user
GET /api/users/{id}/applications - Get user applications
GET /api/posts - Get all posts
POST /api/posts - Create post
GET /api/posts/{id} - Get post by ID
PUT /api/posts/{id}/boost - Boost post
PUT /api/posts/{id}/archive - Archive post
DELETE /api/posts/{id} - Delete post
GET /api/applications - Get all applications
POST /api/applications - Submit application
GET /api/applications/{id} - Get application details
PUT /api/applications/{id}/status - Update application status
POST /api/search - General search
POST /api/search/filter - Filtered search
POST /api/search/location - Location-based search
POST /api/search/recent - Recent searches
GET /notifications/by/{userId} - Get user notifications
POST /notifications - Create notification
PUT /notifications/{id} - Update notification
DELETE /notifications/{id} - Delete notification
- Multi-tenant Architecture: Support for multiple organizations
- Role-based Access: Job seekers and recruiters with different permissions
- Advanced Search: AI-powered search with multiple strategies
- Real-time Notifications: Instant updates for applications and posts
- Post Management: Complete lifecycle management with boosting
- Application Tracking: End-to-end application workflow
- User Profiles: Comprehensive professional profiles
- Microservices Architecture: Scalable, maintainable service design
- Event-Driven Communication: Asynchronous messaging with RabbitMQ
- Polyglot Persistence: PostgreSQL and MongoDB for optimal data storage
- Caching Strategy: Redis for performance optimization
- Service Discovery: Dynamic service registration and discovery
- Circuit Breaker: Fault tolerance and resilience patterns
- Distributed Tracing: Request correlation across services
- Comprehensive Monitoring: Full observability stack
- Containerization: Docker containers for all services
- Orchestration: Kubernetes deployment configurations
- Infrastructure as Code: Declarative infrastructure management
- Monitoring & Alerting: Grafana dashboards and alerting
- Log Aggregation: Centralized logging with Loki
- Health Checks: Comprehensive service health monitoring
- Auto-scaling: Kubernetes horizontal pod autoscaling
This project demonstrates enterprise-level software development practices including:
- Clean Architecture principles
- SOLID design principles
- Domain-Driven Design (DDD)
- Test-Driven Development (TDD)
- Continuous Integration/Continuous Deployment (CI/CD)
- Infrastructure as Code (IaC)
- Observability and monitoring best practices
For questions about this project's architecture, implementation details, or technical decisions, please feel free to reach out.
Built with ❤️ using modern enterprise technologies and best practices