Microservices Architecture: Complete Guide to Service-Oriented Design Patterns

Microservices architecture has revolutionized how we build and deploy modern applications. This service-oriented design pattern breaks down monolithic applications into smaller, independent services that communicate through well-defined APIs. Understanding microservices is crucial for building scalable, maintainable, and resilient systems in today’s cloud-native world.

Table of Contents

What is Microservices Architecture?

Microservices architecture is a software development approach that structures an application as a collection of loosely coupled, independently deployable services. Each service is responsible for a specific business capability and can be developed, deployed, and scaled independently.

Core Characteristics of Microservices

Single Responsibility: Each service handles one business domain
Independence: Services can be developed and deployed separately
Decentralization: No central governing authority
Failure Isolation: One service failure doesn’t bring down the entire system
Technology Agnostic: Different services can use different technologies

Microservices vs Monolithic Architecture

To understand microservices better, let’s compare them with traditional monolithic architecture:

Aspect	Monolithic	Microservices
Deployment	Single deployment unit	Independent deployments
Scaling	Scale entire application	Scale individual services
Technology Stack	Single technology	Multiple technologies possible
Development Team	Large team on one codebase	Small teams per service
Fault Tolerance	Single point of failure	Isolated failures
Data Management	Shared database	Database per service

Service-Oriented Design Principles

1. Domain-Driven Design (DDD)

Microservices should align with business domains and capabilities. This principle ensures that each service has a clear purpose and responsibility.

2. Database Per Service Pattern

Each microservice should have its own database to ensure loose coupling and data autonomy. This prevents services from directly accessing other services’ data.

// User Service - Handles user data
class UserService {
  constructor(userDatabase) {
    this.db = userDatabase;
  }
  
  async createUser(userData) {
    return await this.db.users.create(userData);
  }
  
  async getUserById(userId) {
    return await this.db.users.findById(userId);
  }
}

// Order Service - Handles order data
class OrderService {
  constructor(orderDatabase, userServiceClient) {
    this.db = orderDatabase;
    this.userService = userServiceClient;
  }
  
  async createOrder(orderData) {
    // Validate user exists via API call
    const user = await this.userService.getUser(orderData.userId);
    if (!user) throw new Error('User not found');
    
    return await this.db.orders.create(orderData);
  }
}

3. API Gateway Pattern

An API Gateway acts as a single entry point for all client requests, routing them to appropriate microservices and handling cross-cutting concerns.

// API Gateway Configuration
const gateway = {
  routes: [
    {
      path: '/api/users/*',
      service: 'user-service',
      url: 'http://user-service:3001'
    },
    {
      path: '/api/orders/*',
      service: 'order-service',
      url: 'http://order-service:3002'
    },
    {
      path: '/api/payments/*',
      service: 'payment-service',
      url: 'http://payment-service:3003'
    }
  ],
  
  middleware: [
    'authentication',
    'rateLimiting',
    'logging',
    'cors'
  ]
};

Communication Patterns in Microservices

Synchronous Communication

Direct service-to-service communication using HTTP/REST APIs or gRPC.

// REST API Communication
class OrderService {
  async processOrder(orderData) {
    try {
      // Call Payment Service
      const paymentResponse = await fetch(`${PAYMENT_SERVICE_URL}/api/payments`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          amount: orderData.total,
          userId: orderData.userId
        })
      });
      
      if (!paymentResponse.ok) {
        throw new Error('Payment failed');
      }
      
      // Call Inventory Service
      const inventoryResponse = await fetch(`${INVENTORY_SERVICE_URL}/api/inventory/reserve`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          items: orderData.items
        })
      });
      
      if (!inventoryResponse.ok) {
        // Compensate payment
        await this.refundPayment(paymentResponse.data.paymentId);
        throw new Error('Inventory reservation failed');
      }
      
      return await this.createOrder(orderData);
    } catch (error) {
      console.error('Order processing failed:', error);
      throw error;
    }
  }
}

Asynchronous Communication

Event-driven communication using message queues and event buses for better decoupling.

// Event-Driven Communication Example
const EventEmitter = require('events');

class OrderService extends EventEmitter {
  async createOrder(orderData) {
    const order = await this.db.orders.create(orderData);
    
    // Emit event instead of direct API calls
    this.emit('orderCreated', {
      orderId: order.id,
      userId: order.userId,
      items: order.items,
      total: order.total,
      timestamp: new Date()
    });
    
    return order;
  }
}

class PaymentService extends EventEmitter {
  constructor() {
    super();
    this.setupEventListeners();
  }
  
  setupEventListeners() {
    this.on('orderCreated', async (orderData) => {
      try {
        const payment = await this.processPayment(orderData);
        this.emit('paymentProcessed', {
          orderId: orderData.orderId,
          paymentId: payment.id,
          status: 'success'
        });
      } catch (error) {
        this.emit('paymentFailed', {
          orderId: orderData.orderId,
          error: error.message
        });
      }
    });
  }
}

Data Management in Microservices

Database Per Service

Each microservice manages its own data through a private database, ensuring data autonomy and service independence.

-- User Service Database
CREATE TABLE users (
  id UUID PRIMARY KEY,
  email VARCHAR(255) UNIQUE NOT NULL,
  username VARCHAR(100) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Order Service Database  
CREATE TABLE orders (
  id UUID PRIMARY KEY,
  user_id UUID NOT NULL, -- Reference to user, not foreign key
  status VARCHAR(50) NOT NULL,
  total_amount DECIMAL(10,2) NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE order_items (
  id UUID PRIMARY KEY,
  order_id UUID REFERENCES orders(id),
  product_id UUID NOT NULL, -- Reference to product service
  quantity INTEGER NOT NULL,
  price DECIMAL(10,2) NOT NULL
);

Saga Pattern for Distributed Transactions

Since we can’t use traditional ACID transactions across services, we implement the Saga pattern for managing distributed transactions.

// Saga Orchestrator Pattern
class OrderSaga {
  constructor(services) {
    this.userService = services.userService;
    this.inventoryService = services.inventoryService;
    this.paymentService = services.paymentService;
    this.orderService = services.orderService;
  }
  
  async processOrder(orderData) {
    const sagaTransaction = {
      id: generateId(),
      steps: [],
      status: 'started'
    };
    
    try {
      // Step 1: Validate User
      const user = await this.userService.getUser(orderData.userId);
      sagaTransaction.steps.push({ step: 'userValidation', status: 'completed' });
      
      // Step 2: Reserve Inventory
      const reservation = await this.inventoryService.reserveItems(orderData.items);
      sagaTransaction.steps.push({ 
        step: 'inventoryReservation', 
        status: 'completed',
        compensationData: { reservationId: reservation.id }
      });
      
      // Step 3: Process Payment
      const payment = await this.paymentService.processPayment({
        amount: orderData.total,
        userId: orderData.userId
      });
      sagaTransaction.steps.push({ 
        step: 'paymentProcessing', 
        status: 'completed',
        compensationData: { paymentId: payment.id }
      });
      
      // Step 4: Create Order
      const order = await this.orderService.createOrder(orderData);
      sagaTransaction.status = 'completed';
      
      return order;
      
    } catch (error) {
      // Compensate all completed steps
      await this.compensate(sagaTransaction);
      throw error;
    }
  }
  
  async compensate(sagaTransaction) {
    const completedSteps = sagaTransaction.steps
      .filter(step => step.status === 'completed')
      .reverse(); // Compensate in reverse order
    
    for (const step of completedSteps) {
      try {
        switch (step.step) {
          case 'inventoryReservation':
            await this.inventoryService.releaseReservation(
              step.compensationData.reservationId
            );
            break;
          case 'paymentProcessing':
            await this.paymentService.refundPayment(
              step.compensationData.paymentId
            );
            break;
        }
      } catch (compensationError) {
        console.error(`Compensation failed for step ${step.step}:`, compensationError);
        // Log for manual intervention
      }
    }
  }
}

Service Discovery and Load Balancing

In a microservices environment, services need to discover and communicate with each other dynamically.

// Service Registry Implementation
class ServiceRegistry {
  constructor() {
    this.services = new Map();
  }
  
  register(serviceName, serviceInstance) {
    if (!this.services.has(serviceName)) {
      this.services.set(serviceName, []);
    }
    
    const instances = this.services.get(serviceName);
    const existingIndex = instances.findIndex(
      instance => instance.id === serviceInstance.id
    );
    
    if (existingIndex >= 0) {
      instances[existingIndex] = serviceInstance;
    } else {
      instances.push(serviceInstance);
    }
    
    console.log(`Registered ${serviceName} instance:`, serviceInstance);
  }
  
  discover(serviceName) {
    const instances = this.services.get(serviceName) || [];
    return instances.filter(instance => instance.status === 'healthy');
  }
  
  // Round-robin load balancing
  getNextInstance(serviceName) {
    const instances = this.discover(serviceName);
    if (instances.length === 0) {
      throw new Error(`No healthy instances found for ${serviceName}`);
    }
    
    if (!this.roundRobinIndex) {
      this.roundRobinIndex = new Map();
    }
    
    const currentIndex = this.roundRobinIndex.get(serviceName) || 0;
    const nextIndex = (currentIndex + 1) % instances.length;
    this.roundRobinIndex.set(serviceName, nextIndex);
    
    return instances[nextIndex];
  }
}

// Service Instance
class ServiceInstance {
  constructor(serviceName, host, port) {
    this.id = `${serviceName}-${Date.now()}`;
    this.serviceName = serviceName;
    this.host = host;
    this.port = port;
    this.status = 'healthy';
    this.registeredAt = new Date();
  }
  
  getUrl() {
    return `http://${this.host}:${this.port}`;
  }
}

// Usage
const registry = new ServiceRegistry();

// Register services
registry.register('user-service', new ServiceInstance('user-service', 'localhost', 3001));
registry.register('user-service', new ServiceInstance('user-service', 'localhost', 3002));
registry.register('order-service', new ServiceInstance('order-service', 'localhost', 3003));

// Discover and use services
const userServiceInstance = registry.getNextInstance('user-service');
const userServiceUrl = userServiceInstance.getUrl();

Monitoring and Observability

Monitoring microservices requires comprehensive observability across distributed systems.

Health Checks

// Health Check Implementation
class HealthChecker {
  constructor() {
    this.checks = new Map();
  }
  
  addCheck(name, checkFunction) {
    this.checks.set(name, checkFunction);
  }
  
  async performHealthCheck() {
    const results = {
      status: 'healthy',
      timestamp: new Date().toISOString(),
      checks: {}
    };
    
    for (const [name, checkFunction] of this.checks) {
      try {
        const startTime = Date.now();
        await checkFunction();
        results.checks[name] = {
          status: 'healthy',
          responseTime: Date.now() - startTime
        };
      } catch (error) {
        results.checks[name] = {
          status: 'unhealthy',
          error: error.message
        };
        results.status = 'unhealthy';
      }
    }
    
    return results;
  }
}

// Usage in a service
const healthChecker = new HealthChecker();

healthChecker.addCheck('database', async () => {
  await database.ping();
});

healthChecker.addCheck('redis', async () => {
  await redis.ping();
});

healthChecker.addCheck('external-api', async () => {
  const response = await fetch('https://external-api.com/health');
  if (!response.ok) throw new Error('External API unhealthy');
});

// Express endpoint
app.get('/health', async (req, res) => {
  const health = await healthChecker.performHealthCheck();
  const statusCode = health.status === 'healthy' ? 200 : 503;
  res.status(statusCode).json(health);
});

Distributed Tracing

// Simple distributed tracing implementation
class TracingService {
  constructor() {
    this.traces = new Map();
  }
  
  startTrace(traceId = generateId()) {
    const trace = {
      traceId,
      spans: [],
      startTime: Date.now()
    };
    this.traces.set(traceId, trace);
    return traceId;
  }
  
  addSpan(traceId, serviceName, operationName, metadata = {}) {
    const trace = this.traces.get(traceId);
    if (!trace) return;
    
    const span = {
      spanId: generateId(),
      serviceName,
      operationName,
      startTime: Date.now(),
      metadata
    };
    
    trace.spans.push(span);
    return span.spanId;
  }
  
  endSpan(traceId, spanId, status = 'success', error = null) {
    const trace = this.traces.get(traceId);
    if (!trace) return;
    
    const span = trace.spans.find(s => s.spanId === spanId);
    if (span) {
      span.endTime = Date.now();
      span.duration = span.endTime - span.startTime;
      span.status = status;
      if (error) span.error = error;
    }
  }
  
  getTrace(traceId) {
    return this.traces.get(traceId);
  }
}

// Middleware for Express
function tracingMiddleware(req, res, next) {
  const traceId = req.headers['x-trace-id'] || tracer.startTrace();
  const spanId = tracer.addSpan(traceId, process.env.SERVICE_NAME, req.path);
  
  req.traceId = traceId;
  req.spanId = spanId;
  
  res.on('finish', () => {
    tracer.endSpan(traceId, spanId, res.statusCode < 400 ? 'success' : 'error');
  });
  
  next();
}

Security in Microservices

JWT-based Authentication

// JWT Authentication Service
const jwt = require('jsonwebtoken');

class AuthService {
  constructor(secretKey) {
    this.secretKey = secretKey;
  }
  
  generateToken(user) {
    return jwt.sign(
      {
        userId: user.id,
        email: user.email,
        roles: user.roles
      },
      this.secretKey,
      { expiresIn: '1h' }
    );
  }
  
  verifyToken(token) {
    try {
      return jwt.verify(token, this.secretKey);
    } catch (error) {
      throw new Error('Invalid token');
    }
  }
  
  // Middleware for protecting routes
  authenticate(req, res, next) {
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({ error: 'No token provided' });
    }
    
    const token = authHeader.substring(7);
    try {
      const decoded = this.verifyToken(token);
      req.user = decoded;
      next();
    } catch (error) {
      res.status(401).json({ error: 'Invalid token' });
    }
  }
  
  // Authorization middleware
  authorize(roles) {
    return (req, res, next) => {
      if (!req.user) {
        return res.status(401).json({ error: 'Not authenticated' });
      }
      
      const userRoles = req.user.roles || [];
      const hasPermission = roles.some(role => userRoles.includes(role));
      
      if (!hasPermission) {
        return res.status(403).json({ error: 'Insufficient permissions' });
      }
      
      next();
    };
  }
}

Deployment Strategies

Docker Containerization

# Dockerfile for a Node.js microservice
FROM node:16-alpine

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy source code
COPY src/ ./src/

# Create non-root user
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001
USER nodejs

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

# Start the service
CMD ["node", "src/index.js"]

Docker Compose for Local Development

# docker-compose.yml
version: '3.8'

services:
  api-gateway:
    build: ./api-gateway
    ports:
      - "3000:3000"
    environment:
      - USER_SERVICE_URL=http://user-service:3001
      - ORDER_SERVICE_URL=http://order-service:3002
    depends_on:
      - user-service
      - order-service

  user-service:
    build: ./user-service
    ports:
      - "3001:3001"
    environment:
      - DATABASE_URL=postgresql://postgres:password@user-db:5432/users
    depends_on:
      - user-db

  order-service:
    build: ./order-service
    ports:
      - "3002:3002"
    environment:
      - DATABASE_URL=postgresql://postgres:password@order-db:5432/orders
      - REDIS_URL=redis://redis:6379
    depends_on:
      - order-db
      - redis

  user-db:
    image: postgres:13
    environment:
      - POSTGRES_DB=users
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - user_data:/var/lib/postgresql/data

  order-db:
    image: postgres:13
    environment:
      - POSTGRES_DB=orders
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - order_data:/var/lib/postgresql/data

  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"

volumes:
  user_data:
  order_data:

Testing Microservices

Unit Testing

// Unit test for UserService
const UserService = require('../src/services/UserService');
const mockDatabase = require('../mocks/database');

describe('UserService', () => {
  let userService;
  
  beforeEach(() => {
    userService = new UserService(mockDatabase);
  });
  
  describe('createUser', () => {
    it('should create a user with valid data', async () => {
      const userData = {
        email: '[email protected]',
        username: 'testuser',
        password: 'password123'
      };
      
      mockDatabase.users.create.mockResolvedValue({
        id: 'user-123',
        ...userData,
        createdAt: new Date()
      });
      
      const result = await userService.createUser(userData);
      
      expect(result.id).toBe('user-123');
      expect(result.email).toBe(userData.email);
      expect(mockDatabase.users.create).toHaveBeenCalledWith(userData);
    });
    
    it('should throw error for duplicate email', async () => {
      const userData = {
        email: '[email protected]',
        username: 'testuser',
        password: 'password123'
      };
      
      mockDatabase.users.create.mockRejectedValue(
        new Error('Email already exists')
      );
      
      await expect(userService.createUser(userData))
        .rejects.toThrow('Email already exists');
    });
  });
});

Integration Testing

// Integration test for Order API
const request = require('supertest');
const app = require('../src/app');
const database = require('../src/database');

describe('Order API Integration', () => {
  let authToken;
  
  beforeAll(async () => {
    // Setup test database
    await database.migrate.latest();
    await database.seed.run();
    
    // Get auth token
    const loginResponse = await request(app)
      .post('/api/auth/login')
      .send({ email: '[email protected]', password: 'password' });
    
    authToken = loginResponse.body.token;
  });
  
  afterAll(async () => {
    await database.destroy();
  });
  
  describe('POST /api/orders', () => {
    it('should create order with valid data', async () => {
      const orderData = {
        items: [
          { productId: 'prod-1', quantity: 2, price: 29.99 },
          { productId: 'prod-2', quantity: 1, price: 49.99 }
        ]
      };
      
      const response = await request(app)
        .post('/api/orders')
        .set('Authorization', `Bearer ${authToken}`)
        .send(orderData)
        .expect(201);
      
      expect(response.body.id).toBeDefined();
      expect(response.body.status).toBe('pending');
      expect(response.body.total).toBe(109.97);
    });
    
    it('should return 401 without auth token', async () => {
      const orderData = { items: [] };
      
      await request(app)
        .post('/api/orders')
        .send(orderData)
        .expect(401);
    });
  });
});

Best Practices and Common Patterns

Circuit Breaker Pattern

// Circuit Breaker Implementation
class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 5;
    this.resetTimeout = options.resetTimeout || 60000;
    this.monitoringPeriod = options.monitoringPeriod || 10000;
    
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.failureCount = 0;
    this.lastFailureTime = null;
    this.successCount = 0;
  }
  
  async call(operation) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime >= this.resetTimeout) {
        this.state = 'HALF_OPEN';
        this.successCount = 0;
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  onSuccess() {
    this.failureCount = 0;
    
    if (this.state === 'HALF_OPEN') {
      this.successCount++;
      if (this.successCount >= 3) { // 3 successful calls to close
        this.state = 'CLOSED';
      }
    }
  }
  
  onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
    }
  }
  
  getState() {
    return {
      state: this.state,
      failureCount: this.failureCount,
      lastFailureTime: this.lastFailureTime
    };
  }
}

// Usage
const paymentServiceBreaker = new CircuitBreaker({
  failureThreshold: 3,
  resetTimeout: 30000
});

async function processPayment(paymentData) {
  try {
    return await paymentServiceBreaker.call(async () => {
      const response = await fetch(`${PAYMENT_SERVICE_URL}/api/payments`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(paymentData)
      });
      
      if (!response.ok) {
        throw new Error(`Payment service error: ${response.status}`);
      }
      
      return response.json();
    });
  } catch (error) {
    console.error('Payment processing failed:', error.message);
    throw error;
  }
}

Bulkhead Pattern

// Resource Isolation using Bulkhead Pattern
class ResourcePool {
  constructor(name, maxSize) {
    this.name = name;
    this.maxSize = maxSize;
    this.activeConnections = 0;
    this.waitingQueue = [];
  }
  
  async acquire() {
    return new Promise((resolve, reject) => {
      if (this.activeConnections < this.maxSize) {
        this.activeConnections++;
        resolve(this.createResource());
      } else {
        this.waitingQueue.push({ resolve, reject });
      }
    });
  }
  
  release() {
    this.activeConnections--;
    
    if (this.waitingQueue.length > 0) {
      const { resolve } = this.waitingQueue.shift();
      this.activeConnections++;
      resolve(this.createResource());
    }
  }
  
  createResource() {
    return {
      release: () => this.release()
    };
  }
  
  getStats() {
    return {
      name: this.name,
      active: this.activeConnections,
      waiting: this.waitingQueue.length,
      maxSize: this.maxSize
    };
  }
}

// Service with isolated resource pools
class OrderService {
  constructor() {
    // Separate pools for different operations
    this.paymentPool = new ResourcePool('payment', 5);
    this.inventoryPool = new ResourcePool('inventory', 10);
    this.emailPool = new ResourcePool('email', 3);
  }
  
  async processOrder(orderData) {
    const operations = [];
    
    // Process payment with dedicated pool
    operations.push(this.processPaymentWithPool(orderData));
    
    // Check inventory with dedicated pool
    operations.push(this.checkInventoryWithPool(orderData));
    
    // Send confirmation with dedicated pool
    operations.push(this.sendConfirmationWithPool(orderData));
    
    return Promise.all(operations);
  }
  
  async processPaymentWithPool(orderData) {
    const resource = await this.paymentPool.acquire();
    try {
      return await this.callPaymentService(orderData);
    } finally {
      resource.release();
    }
  }
  
  async checkInventoryWithPool(orderData) {
    const resource = await this.inventoryPool.acquire();
    try {
      return await this.callInventoryService(orderData);
    } finally {
      resource.release();
    }
  }
  
  async sendConfirmationWithPool(orderData) {
    const resource = await this.emailPool.acquire();
    try {
      return await this.sendEmail(orderData);
    } finally {
      resource.release();
    }
  }
}

Performance Optimization

Caching Strategies

// Multi-level caching implementation
class CacheService {
  constructor() {
    this.memoryCache = new Map();
    this.redisClient = require('redis').createClient();
  }
  
  async get(key) {
    // Level 1: Memory cache
    if (this.memoryCache.has(key)) {
      const item = this.memoryCache.get(key);
      if (item.expiry > Date.now()) {
        return item.value;
      } else {
        this.memoryCache.delete(key);
      }
    }
    
    // Level 2: Redis cache
    try {
      const redisValue = await this.redisClient.get(key);
      if (redisValue) {
        const parsed = JSON.parse(redisValue);
        // Store in memory cache for faster access
        this.memoryCache.set(key, {
          value: parsed,
          expiry: Date.now() + 300000 // 5 minutes
        });
        return parsed;
      }
    } catch (error) {
      console.error('Redis cache error:', error);
    }
    
    return null;
  }
  
  async set(key, value, ttl = 3600) {
    // Store in memory cache
    this.memoryCache.set(key, {
      value,
      expiry: Date.now() + Math.min(ttl * 1000, 300000) // Max 5 minutes in memory
    });
    
    // Store in Redis
    try {
      await this.redisClient.setex(key, ttl, JSON.stringify(value));
    } catch (error) {
      console.error('Redis cache error:', error);
    }
  }
  
  async invalidate(pattern) {
    // Clear from memory cache
    for (const key of this.memoryCache.keys()) {
      if (key.includes(pattern)) {
        this.memoryCache.delete(key);
      }
    }
    
    // Clear from Redis
    try {
      const keys = await this.redisClient.keys(`*${pattern}*`);
      if (keys.length > 0) {
        await this.redisClient.del(keys);
      }
    } catch (error) {
      console.error('Redis cache invalidation error:', error);
    }
  }
}

// Usage in service
class ProductService {
  constructor(database, cache) {
    this.db = database;
    this.cache = cache;
  }
  
  async getProduct(productId) {
    const cacheKey = `product:${productId}`;
    
    // Try cache first
    let product = await this.cache.get(cacheKey);
    if (product) {
      return product;
    }
    
    // Fallback to database
    product = await this.db.products.findById(productId);
    if (product) {
      // Cache for 1 hour
      await this.cache.set(cacheKey, product, 3600);
    }
    
    return product;
  }
  
  async updateProduct(productId, updateData) {
    const product = await this.db.products.update(productId, updateData);
    
    // Invalidate cache
    await this.cache.invalidate(`product:${productId}`);
    
    return product;
  }
}

Conclusion

Microservices architecture offers significant benefits for building scalable, maintainable, and resilient systems, but it also introduces complexity that must be carefully managed. The key to successful microservices implementation lies in:

Proper service boundaries: Using domain-driven design principles
Communication patterns: Choosing between synchronous and asynchronous approaches
Data management: Implementing database per service and saga patterns
Observability: Comprehensive monitoring, logging, and tracing
Resilience: Circuit breakers, bulkheads, and retry mechanisms
Security: Proper authentication, authorization, and communication encryption

Start with a well-structured monolith and gradually extract services as your understanding of the domain evolves. Remember that microservices are a means to an end, not an end in themselves. Focus on delivering business value while building systems that can evolve with your organization’s needs.