Skip to content

EmanElsayed2002/eCommerce-Microservice

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

12 Commits
eCommerce
eCommerce
 
 
README.md
README.md
 
 

Repository files navigation

🏪 eCommerce Microservices - Complete Project Overview

🎯 Project Introduction

This is a complete eCommerce microservices application built with .NET 9.0 and Docker. The project demonstrates modern microservices architecture patterns including:

  • Service-Oriented Architecture (SOA)
  • API Gateway Pattern (Ocelot)
  • Identity and Access Management (Duende IdentityServer)
  • Message Queue Communication (RabbitMQ)
  • Reverse Proxy (Nginx with HTTPS)
  • Multi-Database Strategy (MySQL, PostgreSQL, MongoDB)
  • Containerization (Docker & Docker Compose)

Business Domain

An eCommerce platform where users can:

  • Register and authenticate
  • Browse and manage products
  • Create and manage orders
  • View order history

🛠️ Technology Stack

Backend Framework

  • .NET 9.0 - Latest .NET framework
  • ASP.NET Core Web API - RESTful API framework
  • C# - Primary programming language

Microservices & Gateway

  • Ocelot - API Gateway for routing and aggregation
  • Duende IdentityServer - Identity and Access Management (OAuth 2.0 / OpenID Connect)

Databases

  • MySQL 8.4 - Product Service (Relational data)
  • PostgreSQL 16 - User Service (Relational data)
  • MongoDB 7.0 - Order Service (Document database)

Message Queue

  • RabbitMQ 3.13 - Asynchronous inter-service communication

Infrastructure

  • Docker - Containerization
  • Docker Compose - Multi-container orchestration
  • Nginx - Reverse proxy with HTTPS support

Libraries & Tools

  • Entity Framework Core - ORM for MySQL (Product Service)
  • Dapper - Lightweight ORM for PostgreSQL (User Service)
  • MongoDB.Driver - MongoDB client (Order Service)
  • FluentValidation - Input validation
  • AutoMapper - Object mapping
  • Serilog - Structured logging

🏗️ Architecture Overview

High-Level Architecture

┌─────────────────────────────────────────────────────────────┐
│                        CLIENT LAYER                         │
│              (Browser, Mobile App, Postman)                 │
└───────────────────────────┬─────────────────────────────────┘
                            │ HTTPS/HTTP
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    REVERSE PROXY LAYER                      │
│                      Nginx (Port 443/80)                    │
│              - SSL/TLS Termination                          │
│              - Load Balancing                               │
│              - Request Routing                              │
└───────────────────────────┬─────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    API GATEWAY LAYER                        │
│                    Ocelot (Port 8010)                       │
│              - Request Routing                              │
│              - Authentication/Authorization                 │
│              - Rate Limiting                                │
│              - Request Aggregation                          │
└──────┬───────────────┬───────────────┬──────────────────────┘
       │               │               │
       ▼               ▼               ▼
┌──────────────┐ ┌──────────────┐  ┌──────────────┐
│ USER SERVICE │ │PRODUCT SERVICE│ │ORDER SERVICE │
│  (Port 7155) │ │  (Port 7252) │  │  (Port 7080) │
└──────┬───────┘ └──────┬───────┘  └──────┬───────┘
       │                │                 │
       ▼                ▼                 ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ PostgreSQL   │ │    MySQL     │ │   MongoDB    │
│  (Port 5432) │ │  (Port 3306) │ │  (Port 27017)│
└──────────────┘ └──────────────┘ └──────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    IDENTITY SERVER                          │
│              Duende IdentityServer (Port 9009)              │
│              - OAuth 2.0 / OpenID Connect                   │
│              - JWT Token Issuance                           │
│              - User Authentication                          │
└───────────────────────────┬─────────────────────────────────┘
                            │
                            ▼
                    ┌──────────────┐
                    │ PostgreSQL   │
                    │  (Users DB)  │
                    └──────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    MESSAGE QUEUE                            │
│                    RabbitMQ (Port 5672)                     │
│              - Event-Driven Communication                   │
│              - Async Processing                             │
└─────────────────────────────────────────────────────────────┘

Architecture Patterns Used

  1. API Gateway Pattern

    • Single entry point for all client requests
    • Centralized authentication/authorization
    • Request routing and aggregation

  2. Microservices Pattern

    • Each service is independently deployable
    • Service-specific databases
    • Loose coupling between services

  3. Database per Service Pattern

    • Each microservice has its own database
    • No shared database dependencies
    • Service autonomy

  4. Service Discovery

    • Docker service names for internal communication
    • Environment variables for service URLs

  5. Event-Driven Architecture

    • RabbitMQ for asynchronous communication
    • Decoupled service interactions

  6. Reverse Proxy Pattern

    • Nginx as entry point
    • SSL/TLS termination
    • Load balancing capability

🔧 Microservices Breakdown

1. User Service (eCommerce.UserService)

Purpose: User management and authentication

Technology:

  • .NET 9.0 Web API
  • PostgreSQL 16
  • Dapper (Data Access)
  • Duende IdentityServer (Token Integration)

Responsibilities:

  • User registration
  • User login
  • User profile management
  • Integration with Identity Server for token generation

Database: PostgreSQL (ecommerce_users_db)

  • Table: Users (UserId, Email, Password, Name, Gender)

Ports:

  • External: 7155
  • Internal (Docker): 8090

API Endpoints:

  • POST /api/User/Register - Register new user
  • POST /api/User/Login - Login and get token
  • GET /api/User/{id} - Get user by ID (Protected)

2. Product Service (eCommerce.ProductService)

Purpose: Product catalog management

Technology:

  • .NET 9.0 Web API
  • MySQL 8.4
  • Entity Framework Core
  • RabbitMQ (Event Publishing)

Responsibilities:

  • Product CRUD operations
  • Product search and filtering
  • Product inventory management
  • Event publishing for order processing

Database: MySQL (ecommerce_products_db)

  • Table: Products (ID, Name, Category, Price, Quantity, ImagePath)

Ports:

  • External: 7252
  • Internal (Docker): 8080

API Endpoints:

  • GET /api/products - Get all products (Protected)
  • GET /api/products/search/product-id/{productId} - Search by ID (Public)
  • POST /api/products - Create product (Protected)
  • PUT /api/products - Update product (Protected)
  • DELETE /api/products/{ProductId} - Delete product (Protected)

3. Order Service (eCommerce.OrderService)

Purpose: Order management and processing

Technology:

  • .NET 9.0 Web API
  • MongoDB 7.0
  • MongoDB.Driver
  • RabbitMQ (Event Consumption)
  • HTTP Client (Service-to-Service calls)

Responsibilities:

  • Order creation and management
  • Order history retrieval
  • Order search (by User, Product, Order ID)
  • Integration with User and Product services
  • Event consumption from RabbitMQ

Database: MongoDB (OrdersDatabase)

  • Collection: Order (Document-based)

Ports:

  • External: 7080
  • Internal (Docker): 8100

API Endpoints:

  • GET /api/Orders - Get all orders (Protected)
  • POST /api/Orders - Create order (Protected)
  • GET /api/Orders/search/orderid/{orderID} - Search by Order ID (Protected)
  • GET /api/Orders/search/productid/{productID} - Search by Product ID (Protected)
  • GET /api/Orders/search/userid/{userID} - Search by User ID (Protected)
  • PUT /api/Orders/{orderID} - Update order (Protected)
  • DELETE /api/Orders/{orderID} - Delete order (Protected)

4. Identity Service (eCommerce.IdentityService)

Purpose: Authentication and authorization

Technology:

  • Duende IdentityServer
  • .NET 9.0
  • PostgreSQL (User validation)

Responsibilities:

  • OAuth 2.0 / OpenID Connect implementation
  • JWT token issuance
  • User credential validation
  • Client and scope management

Database: PostgreSQL (ecommerce_users_db)

  • Validates users against Users table

Ports:

  • External: 9009
  • Internal (Docker): 8080

Endpoints:

  • POST /connect/token - Token endpoint (OAuth 2.0)
  • GET /.well-known/openid-configuration - Discovery document
  • GET / - Identity Server UI

Grant Types:

  • Resource Owner Password Credentials (for user login)
  • Client Credentials (for service-to-service)

5. API Gateway (APIGateway)

Purpose: Single entry point for all client requests

Technology:

  • Ocelot
  • .NET 9.0
  • JWT Bearer Authentication

Responsibilities:

  • Request routing to appropriate microservices
  • Authentication/Authorization enforcement
  • Request aggregation
  • Rate limiting (configurable)
  • Request/Response transformation

Ports:

  • External: 8010
  • Internal (Docker): 8001

Configuration: ocelot.json

  • Defines routes, authentication, and downstream services

6. Nginx (Reverse Proxy)

Purpose: Entry point with HTTPS support

Technology:

  • Nginx Alpine
  • SSL/TLS certificates

Responsibilities:

  • SSL/TLS termination
  • HTTP to HTTPS redirection
  • Load balancing (future)
  • Request forwarding to API Gateway and Identity Server

Ports:

  • HTTP: 80
  • HTTPS: 443

Domains:

  • api-local.ecommerce.com - API Gateway
  • id-local.ecommerce.com - Identity Server

✨ Key Features

1. Authentication & Authorization

  • ✅ OAuth 2.0 / OpenID Connect
  • ✅ JWT token-based authentication
  • ✅ Scope-based authorization
  • ✅ Token validation at API Gateway and microservices
  • ✅ Resource Owner Password Credentials grant
  • ✅ Client Credentials grant for service-to-service

2. Security

  • ✅ HTTPS support via Nginx
  • ✅ SSL/TLS certificates
  • ✅ Password hashing (should be implemented)
  • ✅ Token expiration (1 hour)
  • ✅ Defense in depth (Gateway + Service validation)

3. Scalability

  • ✅ Microservices architecture (independent scaling)
  • ✅ Stateless services
  • ✅ Database per service
  • ✅ Message queue for async processing

4. Resilience

  • ✅ Health checks for all services
  • ✅ Docker service dependencies
  • ✅ Error handling middleware
  • ✅ Structured logging

5. Developer Experience

  • ✅ Swagger/OpenAPI documentation
  • ✅ Docker Compose for easy setup
  • ✅ Environment-based configuration
  • ✅ Hot reload support (development)

📁 Project Structure

eCommerce/
├── APIGateway/                    # API Gateway (Ocelot)
│   ├── APIGateway.csproj
│   ├── Program.cs
│   ├── ocelot.json               # Gateway routing config
│   ├── Dockerfile
│   └── nginx/                    # Nginx configuration
│       ├── nginx.local.conf
│       ├── id-local.conf        # SSL certificate config
│       ├── certs/               # SSL certificates
│       └── private/             # Private keys
│
├── eCommerce.IdentityService/    # Identity Server
│   └── Shop.Identity/
│       ├── Shop.Identity.csproj
│       ├── Program.cs
│       ├── Config.cs            # Clients, Scopes, Resources
│       ├── HostingExtensions.cs # Service configuration
│       ├── Services/
│       │   └── UserService.cs  # User validation
│       ├── Validators/
│       │   └── ResourceOwnerPasswordValidator.cs
│       └── Dockerfile
│
├── eCommerce.UserService/        # User Microservice
│   ├── eCommerce.Domain/        # Domain layer
│   │   ├── DbContext/
│   │   └── Repository/
│   ├── eCommerce.Core/          # Business logic
│   │   ├── Service/
│   │   │   ├── UserService.cs
│   │   │   └── IdentityService.cs  # Identity Server client
│   │   ├── Repository/
│   │   ├── DTOs/
│   │   └── Validator/
│   └── eCommerce.UserService/   # API layer
│       ├── Program.cs
│       └── Dockerfile
│
├── eCommerce.ProductService/     # Product Microservice
│   ├── eCommerce.Domain/        # Domain layer
│   │   ├── DbContext/
│   │   ├── Models/
│   │   └── Repository/
│   ├── eCommerce.Core/          # Business logic
│   │   ├── Service/
│   │   ├── DTOs/
│   │   └── Validator/
│   └── eCommerce.ProductService/ # API layer
│       ├── Program.cs
│       ├── Controllers/
│       └── Dockerfile
│
├── eCommerce.OrderService/       # Order Microservice
│   ├── eCommerce.Domain/        # Domain layer
│   │   ├── Entities/
│   │   └── Repository/
│   ├── eCommerce.Core/          # Business logic
│   │   ├── Service/
│   │   ├── HttpClient/         # Service-to-service calls
│   │   ├── RabbitMQ/           # Message queue
│   │   ├── DTOs/
│   │   └── Validator/
│   └── eCommerce.OrderService/ # API layer
│       ├── Program.cs
│       ├── Controllers/
│       └── Dockerfile
│
├── eCommerce.Shared/             # Shared libraries
│   └── eCommerce.Shared/
│       ├── DTOs/               # Shared data transfer objects
│       ├── Enums/
│       └── Errors/
│
├── docker-compose.yaml          # Docker orchestration
├── init-mysql.sql              # MySQL initialization
├── init-postgres.sql           # PostgreSQL initialization
└── eCommerce.slnx              # Solution file

🎯 Use Cases

1. User Registration Flow

Client → Nginx → API Gateway → User Service → PostgreSQL
                                    ↓
                            Identity Server (for future token)

2. User Login Flow

Client → Nginx → API Gateway → User Service → PostgreSQL
                                    ↓
                            Identity Server → Returns JWT Token

3. Product Management Flow

Client → Nginx → API Gateway (validates token) → Product Service → MySQL
                                                      ↓
                                                 RabbitMQ (events)

4. Order Creation Flow

Client → Nginx → API Gateway (validates token) → Order Service
                                                      ↓
                                    ┌─────────────────┴─────────────────┐
                                    ↓                                     ↓
                            Product Service                        User Service
                            (verify product)                       (verify user)
                                    ↓                                     ↓
                            ┌────────┴────────┐
                            ↓                 ↓
                        MongoDB          RabbitMQ
                    (save order)      (publish events)

📊 Data Flow

Request Flow

  1. Client sends HTTP/HTTPS request
  2. Nginx terminates SSL and forwards to API Gateway
  3. API Gateway validates authentication (if required)
  4. API Gateway routes to appropriate microservice
  5. Microservice processes request and queries database
  6. Microservice returns response
  7. API Gateway aggregates/transforms response
  8. Nginx returns response to client

Authentication Flow

  1. Client sends login request
  2. User Service validates credentials
  3. User Service calls Identity Server
  4. Identity Server validates user and issues JWT token
  5. Token returned to client
  6. Client uses token for subsequent requests
  7. API Gateway validates token on each request
  8. Microservices also validate token (defense in depth)

🔐 Security Architecture

Authentication Layers

  1. Nginx Layer - SSL/TLS termination
  2. API Gateway Layer - Token validation, scope checking
  3. Microservice Layer - Token validation, user context

Token Flow

Identity Server → Issues JWT Token
       ↓
Client stores token
       ↓
Client sends token in Authorization header
       ↓
API Gateway validates token
       ↓
Microservice validates token
       ↓
Request processed

📈 Scalability Considerations

Horizontal Scaling

  • Each microservice can be scaled independently
  • Stateless services allow multiple instances
  • Load balancer can distribute requests

Database Scaling

  • Each service has its own database
  • Can scale databases independently
  • Read replicas can be added

Message Queue

  • RabbitMQ handles async processing
  • Decouples services
  • Enables event-driven scaling

🚀 Deployment

Development

  • Docker Compose for local development
  • All services run in containers
  • Hot reload support

Production (Recommended)

  • Kubernetes for orchestration
  • Separate database instances
  • SSL certificates from CA
  • Monitoring and logging
  • CI/CD pipeline

📚 Documentation Files

This project includes comprehensive documentation:

  1. PROJECT_OVERVIEW.md (this file) - High-level overview
  2. ARCHITECTURE_DETAILED.md - Detailed architecture explanation
  3. IMPLEMENTATION_FROM_SCRATCH.md - Step-by-step implementation guide
  4. COMPONENT_DOCUMENTATION.md - Each component explained
  5. API_DOCUMENTATION.md - Complete API reference
  6. DEPLOYMENT_GUIDE.md - Docker and deployment instructions
  7. DATABASE_SCHEMA.md - Database schemas
  8. NGINX_CONFIGURATION_GUIDE.md - Nginx setup
  9. IDENTITY_SERVER_GUIDE.md - Identity Server configuration

✅ Summary

This is a production-ready microservices architecture demonstrating:

  • ✅ Modern .NET 9.0 development
  • ✅ Microservices best practices
  • ✅ Secure authentication/authorization
  • ✅ Multi-database strategy
  • ✅ Containerization with Docker
  • ✅ API Gateway pattern
  • ✅ Event-driven communication
  • ✅ HTTPS/SSL support

Perfect for:

  • Learning microservices architecture
  • Building scalable eCommerce platforms
  • Understanding OAuth 2.0 / OpenID Connect
  • Docker and containerization
  • API Gateway patterns

Next Steps:

  • Read IMPLEMENTATION_FROM_SCRATCH.md to build this from scratch
  • Read COMPONENT_DOCUMENTATION.md for detailed component explanations
  • Read API_DOCUMENTATION.md for API usage

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages