Microservices Architecture Cheat Sheet

// Service A calls Service B
const response = await fetch('http://service-b/api/endpoint');
const data = await response.json();

// Service A publishes event
await messageQueue.publish('order.created', { orderId: '123' });
 
// Service B subscribes
messageQueue.subscribe('order.created', async (event) => {
 await processOrder(event.orderId);
});

// Define proto
service UserService {
 rpc GetUser (UserRequest) returns (UserResponse);
}
 
// Client
const response = await client.getUser({ id: '123' });

class CircuitBreaker {
 state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
 failures = 0;
 threshold = 5;
 
 async call(fn: Function

async function retry(fn: Function, maxRetries = 3) {
 for (let i = 0; i < maxRetries; i++) {
  try {
   return await fn

async function withTimeout(fn: Function, ms = 5000) {
 return Promise.race([
  fn(),
  new Promise((_, reject) =>
   setTimeout(() 

async function getUser(id: string) {
 try {
  return await fetchFromService(id);
 } catch (error) {
  return getCachedUser(id); // Fallback
 }
}

Client → API Gateway → [Services]
 
API Gateway:
- Routing
- Authentication
- Rate limiting
- Request/response transformation
- Load balancing

// Express.js example
import { createProxyMiddleware } from 'http-proxy-middleware';
 
app.use('/api/users', createProxyMiddleware({
 target: 'http://user-service:3000',
 changeOrigin: true
}));
 
app.use('/api/orders'

const registry = {
 'user-service': 'http://user-service:3000',
 'order-service': 'http://order-service:3001'
};
 
const url = registry['user-service'];
const response = await fetch(`${url

apiVersion: v1
kind: Service
metadata:
 name: user-service
spec:
 selector:
  app: user
 ports:
  - port: 80
   targetPort: 3000

User Service  → PostgreSQL
Order Service  → MongoDB
Payment Service → PostgreSQL

async function orderSaga(order) {
 try {
  // Step 1: Create order
  const orderId = await orderService.create(order);
 
  try {
   // Step 2: Process payment
   await paymentService.

// Store events
const events = [
 { type: 'OrderCreated', orderId: '123', amount: 100 },
 { type: 'PaymentProcessed', orderId: '123' },
 { type: 'OrderShipped', orderId: '123' }
];
 

// Write model
class OrderCommandService {
 async createOrder(data) {
  const order = await this.db.insert(data);
  await this.eventBus.publish('order.created', order);

// Generate trace ID
const traceId = generateUUID();
 
// Pass to downstream services
await fetch('http://service-b/api/endpoint', {
 headers: {
  'X-Trace-Id': traceId
 }
});
 
// Log with trace ID
logger.info('Order created'

logger.info('User logged in', {
 userId: user.id,
 timestamp: new Date(),
 service: 'auth-service',
 traceId: req.headers['x-trace-id']
});

app.get('/health', async (req, res) => {
 const health = {
  status: 'healthy',
  timestamp: new Date(),
  checks: {
   database: 

Blue (old) → 100% traffic
Green (new) → 0% traffic
 
Deploy Green → Test
 
Switch traffic:
Blue → 0%
Green → 100%

v1.0 → 90% traffic
v2.0 → 10% traffic (canary)
 
If metrics good:
v1.0 → 50%
v2.0 → 50%
 
Then:
v1.0 → 0%
v2.0 → 100%

3 instances:
1. Update instance 1 → wait
2. Update instance 2 → wait
3. Update instance 3 → done

// API Gateway validates JWT
app.use(async (req, res, next) => {
 const token = req.headers.authorization?.split(' ')[1];
 
 try {

// Use mTLS or service tokens
const response = await fetch('http://service-b/api/endpoint', {
 headers: {
  'Authorization': `Bearer ${serviceToken}`,
  'X-Service-Name': 'service-a'
 }
});

1. Identify module to extract
2. Build microservice alongside monolith
3. Route some traffic to new service
4. Gradually increase traffic
5. Remove code from monolith
6. Repeat for next module

Monolith (100%) → Monolith (90%) + Service A (10%)
        → Monolith (50%) + Service A (50%)
        → Monolith (0%) + Service A (100%)