Vinayak Technosolution | Enterprise Technology Solutions

Introduction

Microservices architecture has revolutionized how we build and scale modern applications. This architectural style structures an application as a collection of loosely coupled, independently deployable services. Each service is focused on a specific business capability and communicates through well-defined APIs.

Key Characteristics

•
Decentralized data management
•
Independent deployment and scaling
•
Technology heterogeneity
•
Business domain-oriented
•
Resilient and fault-tolerant

Monolithic vs Microservices

Monolithic Architecture

• Single codebase
• Shared database
• Tightly coupled components
• Simpler development workflow
• Limited technology choices
• Challenging to scale specific components
• Slower development in large teams

Microservices Architecture

• Multiple codebases
• Distributed databases
• Loosely coupled services
• Complex deployment pipeline
• Technology flexibility
• Independent scaling
• Faster parallel development

Core Concepts

Service Design Principles

Single Responsibility
Each service should handle one business capability
Domain-Driven Design
Services aligned with business domains
Data Autonomy
Each service owns and manages its data

Communication Patterns

Synchronous

• REST APIs
• gRPC
• GraphQL

Asynchronous

• Message queues
• Event streaming
• Pub/Sub patterns

Challenges and Solutions

Common Challenges

Data Consistency

Solution: Saga pattern, Event Sourcing

Service Discovery

Solution: Service registry, Load balancing

Fault Tolerance

Solution: Circuit breakers, Fallbacks

Monitoring

Solution: Distributed tracing, Centralized logging

Step-by-Step Implementation Guide

Let's build a basic e-commerce microservices system. We'll implement three core services: Products, Orders, and Users.

1. Project Structure

e-commerce/
├── services/
│   ├── product-service/
│   │   ├── src/
│   │   │   ├── models/
│   │   │   ├── routes/
│   │   │   └── index.js
│   │   ├── Dockerfile
│   │   └── package.json
│   ├── order-service/
│   └── user-service/
├── gateway/
└── docker-compose.yml

2. Product Service Implementation

First, let's implement the Product service with MongoDB:

Product Model

// services/product-service/src/models/product.js
const mongoose = require('mongoose');

const productSchema = new mongoose.Schema({
  name: { type: String, required: true },
  description: String,
  price: { type: Number, required: true },
  stock: { type: Number, required: true, min: 0 },
  category: String,
  createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Product', productSchema);

Product Routes

// services/product-service/src/routes/products.js
const express = require('express');
const router = express.Router();
const Product = require('../models/product');

// Create product
router.post('/', async (req, res) => {
  try {
    const product = new Product(req.body);
    await product.save();
    res.status(201).json(product);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

// Get all products
router.get('/', async (req, res) => {
  try {
    const products = await Product.find();
    res.json(products);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Get product by ID
router.get('/:id', async (req, res) => {
  try {
    const product = await Product.findById(req.params.id);
    if (!product) {
      return res.status(404).json({ error: 'Product not found' });
    }
    res.json(product);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Update stock
router.patch('/:id/stock', async (req, res) => {
  try {
    const { adjustment } = req.body;
    const product = await Product.findById(req.params.id);
    
    if (!product) {
      return res.status(404).json({ error: 'Product not found' });
    }

    if (product.stock + adjustment < 0) {
      return res.status(400).json({ error: 'Insufficient stock' });
    }

    product.stock += adjustment;
    await product.save();
    res.json(product);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

module.exports = router;

3. Service Configuration

Docker Configuration

# services/product-service/Dockerfile
FROM node:16-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

# docker-compose.yml
version: '3.8'
services:
  product-service:
    build: ./services/product-service
    ports:
      - "3001:3000"
    environment:
      - MONGODB_URI=mongodb://mongodb:27017/products
    depends_on:
      - mongodb

  mongodb:
    image: mongo:5.0
    volumes:
      - mongodb_data:/data/db

volumes:
  mongodb_data:

4. Testing the Service

# Start the services
docker-compose up -d

# Create a product
curl -X POST http://localhost:3001/products \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Smartphone",
    "price": 699.99,
    "stock": 100,
    "description": "Latest model smartphone"
  }'

# Get all products
curl http://localhost:3001/products

# Update stock
curl -X PATCH http://localhost:3001/products/[product-id]/stock \
  -H "Content-Type: application/json" \
  -d '{
    "adjustment": -1
  }'

5. Order Service Implementation

Next, let's implement the Order service that communicates with the Product service:

Order Model

// services/order-service/src/models/order.js
const mongoose = require('mongoose');

const orderItemSchema = new mongoose.Schema({
  productId: { type: String, required: true },
  quantity: { type: Number, required: true },
  price: { type: Number, required: true }
});

const orderSchema = new mongoose.Schema({
  userId: { type: String, required: true },
  items: [orderItemSchema],
  totalAmount: { type: Number, required: true },
  status: {
    type: String,
    enum: ['pending', 'confirmed', 'shipped', 'delivered'],
    default: 'pending'
  },
  createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Order', orderSchema);

Order Service Implementation

// services/order-service/src/index.js
const express = require('express');
const mongoose = require('mongoose');
const axios = require('axios');
const Order = require('./models/order');

const app = express();
app.use(express.json());

const PRODUCT_SERVICE_URL = process.env.PRODUCT_SERVICE_URL || 'http://product-service:3000';

// Create order
app.post('/orders', async (req, res) => {
  try {
    const { userId, items } = req.body;
    
    // Validate and get product details
    let totalAmount = 0;
    const validatedItems = await Promise.all(
      items.map(async (item) => {
        const productResponse = await axios.get(
          `${PRODUCT_SERVICE_URL}/products/${item.productId}`
        );
        
        const product = productResponse.data;
        if (item.quantity > product.stock) {
          throw new Error(`Insufficient stock for product ${product.name}`);
        }
        
        totalAmount += product.price * item.quantity;
        return {
          ...item,
          price: product.price
        };
      })
    );

    // Create order
    const order = new Order({
      userId,
      items: validatedItems,
      totalAmount
    });
    
    await order.save();

    // Update product stock
    await Promise.all(
      items.map(item =>
        axios.patch(
          `${PRODUCT_SERVICE_URL}/products/${item.productId}/stock`,
          { adjustment: -item.quantity }
        )
      )
    );

    res.status(201).json(order);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

// Get user's orders
app.get('/users/:userId/orders', async (req, res) => {
  try {
    const orders = await Order.find({ userId: req.params.userId });
    res.json(orders);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

mongoose.connect('mongodb://order-db:27017/order-service')
  .then(() => {
    app.listen(3001, () => {
      console.log('Order service running on port 3001');
    });
  });

6. API Gateway Implementation

Finally, let's implement the API Gateway to handle routing and authentication:

Gateway Service

// gateway/src/index.js
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const jwt = require('jsonwebtoken');

const app = express();
const PORT = process.env.PORT || 3000;

// Authentication middleware
const authMiddleware = (req, res, next) => {
  try {
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) {
      return res.status(401).json({ error: 'Authentication required' });
    }

    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

// Service routes
const routes = {
  products: {
    target: 'http://product-service:3000',
    pathRewrite: {
      '^/api/products': '/products'
    }
  },
  orders: {
    target: 'http://order-service:3001',
    pathRewrite: {
      '^/api/orders': '/orders'
    }
  }
};

// Configure routes with authentication
Object.entries(routes).forEach(([path, config]) => {
  app.use(
    `/api/${path}`,
    authMiddleware,
    createProxyMiddleware({
      target: config.target,
      pathRewrite: config.pathRewrite,
      changeOrigin: true
    })
  );
});

app.listen(PORT, () => {
  console.log(`API Gateway running on port ${PORT}`);
});

Updated Docker Configuration

# docker-compose.yml
version: '3.8'
services:
  gateway:
    build: ./gateway
    ports:
      - "3000:3000"
    environment:
      - JWT_SECRET=your-secret-key
    depends_on:
      - product-service
      - order-service

  product-service:
    build: ./services/product-service
    environment:
      - MONGODB_URI=mongodb://product-db:27017/products
    depends_on:
      - product-db

  order-service:
    build: ./services/order-service
    environment:
      - MONGODB_URI=mongodb://order-db:27017/orders
      - PRODUCT_SERVICE_URL=http://product-service:3000
    depends_on:
      - order-db
      - product-service

  product-db:
    image: mongo:5.0
    volumes:
      - product-data:/data/db

  order-db:
    image: mongo:5.0
    volumes:
      - order-data:/data/db

volumes:
  product-data:
  order-data:

Testing the Complete System

# Start all services
docker-compose up -d

# Create a product through gateway
curl -X POST http://localhost:3000/api/products \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Smartphone",
    "price": 699.99,
    "stock": 100
  }'

# Create an order
curl -X POST http://localhost:3000/api/orders \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -d '{
    "userId": "user123",
    "items": [
      {
        "productId": "product-id",
        "quantity": 1
      }
    ]
  }'

Conclusion

Microservices architecture offers powerful benefits for building scalable, maintainable applications. While it introduces complexity, careful planning and proper implementation can help teams succeed with this architecture.

Key Takeaways

•
Start with clear service boundaries based on business domains
•
Choose appropriate technologies for each service
•
Implement proper monitoring and observability from the start
•
Consider security at every layer of the architecture

Contents

Microservices ArchitectureBuilding Scalable Systems