Cloud-Native Architecture Principles

1Traditional Application
2    ↓
3Minimal Changes
4    ↓
5Runs in Cloud VM
6(Same architecture, just different hosting)

1Microservices
2    ↓
3Containerized
4    ↓
5Orchestrated (K8s)
6    ↓
7Auto-scaling, Self-healing
8(Architected for cloud from ground up)

1┌─────────────────────────────────┐
2│   Monolithic Application        │
3│  ┌─────────────────────────┐   │
4│  │  Frontend               │   │
5│  │  Product Catalog        │   │
6│  │  Shopping Cart          │   │
7│  │  Payment Processing     │   │
8│  │  User Management        │   │
9│  └─────────────────────────┘   │
10│  Deployed on Single Server      │
11└─────────────────────────────────┘

1┌────────────┐  ┌────────────┐  ┌────────────┐
2│  Frontend  │  │  Products  │  │   Cart     │
3│  Service   │  │  Service   │  │  Service   │
4│ (Container)│  │(Container) │  │(Container) │
5└────────────┘  └────────────┘  └────────────┘
6      ↓              ↓               ↓
7┌────────────┐  ┌────────────┐  ┌────────────┐
8│  Payment   │  │   Users    │  │  Orders    │
9│  Service   │  │  Service   │  │  Service   │
10│ (Container)│  │(Container) │  │(Container) │
11└────────────┘  └────────────┘  └────────────┘
12        ↓
13   Orchestrated by Kubernetes
14   Auto-scaling, Self-healing

1// Traditional approach - bigger machine
2const server = {
3  cpu: '4 cores → 16 cores',
4  ram: '8GB → 64GB',
5  cost: 'Expensive, has limits'
6};
7
8// Problem: Eventually hit ceiling
9// Single point of failure

1// Cloud-native approach - more machines
2const cluster = {
3  instances: '1 server → 100 servers',
4  automatic: 'Based on load',
5  cost: 'Pay as you grow'
6};
7
8// Benefit: Nearly unlimited scaling
9// No single point of failure

1// ❌ BAD - Stateful service
2class UserService {
3  private userSessions = new Map(); // State stored in memory
4
5  async login(user) {
6    this.userSessions.set(user.id, user.sessionData);
7    return user;
8  }
9
10  async getSession(userId) {
11    return this.userSessions.get(userId); // Won't work across instances!
12  }
13}
14
15// ✅ GOOD - Stateless service
16class UserService {
17  constructor(private redis: Redis) {} // External state store
18
19  async login(user) {
20    await this.redis.set(`session:${user.id}`, user.sessionData);
21    return user;
22  }
23
24  async getSession(userId) {
25    return await this.redis.get(`session:${userId}`); // Works across all instances!
26  }
27}

1User Request
2     ↓
3┌────────────────┐
4│ Load Balancer  │
5└────────────────┘
6     ↓   ↓   ↓
7  ┌──┴───┴───┴──┐
8  │ │  │  │  │  │
9  S  S  S  S  S  S  ← Service Instances
10  1  2  3  4  5  6

1# Kubernetes Horizontal Pod Autoscaler
2apiVersion: autoscaling/v2
3kind: HorizontalPodAutoscaler
4metadata:
5  name: web-app-scaler
6spec:
7  scaleTargetRef:
8    apiVersion: apps/v1
9    kind: Deployment
10    name: web-app
11  minReplicas: 2
12  maxReplicas: 50
13  metrics:
14  - type: Resource
15    resource:
16      name: cpu
17      target:
18        type: Utilization
19        averageUtilization: 70
20  - type: Resource
21    resource:
22      name: memory
23      target:
24        type: Utilization
25        averageUtilization: 80

1// Traditional: Assume everything works
2async function getUser(id) {
3  const user = await database.query('SELECT * FROM users WHERE id = ?', [id]);
4  return user;
5}
6// Problem: What if database is down?
7
8// Cloud-Native: Assume things will fail
9async function getUser(id) {
10  try {
11    // Try primary database
12    return await withRetry(() =>
13      database.query('SELECT * FROM users WHERE id = ?', [id]),
14      { maxRetries: 3, backoff: 'exponential' }
15    );
16  } catch (primaryError) {
17    console.error('Primary DB failed:', primaryError);
18
19    try {
20      // Fallback to cache
21      const cached = await redis.get(`user:${id}`);
22      if (cached) return JSON.parse(cached);
23    } catch (cacheError) {
24      console.error('Cache failed:', cacheError);
25    }
26
27    try {
28      // Final fallback to read replica
29      return await readReplica.query('SELECT * FROM users WHERE id = ?', [id]);
30    } catch (replicaError) {
31      // Return degraded response
32      return { id, error: 'User data temporarily unavailable' };
33    }
34  }
35}

1class CircuitBreaker {
2  constructor(threshold = 5, timeout = 60000) {
3    this.failureCount = 0;
4    this.threshold = threshold;
5    this.timeout = timeout;
6    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
7    this.nextAttempt = Date.now();
8  }
9
10  async execute(operation) {
11    if (this.state === 'OPEN') {
12      if (Date.now() < this.nextAttempt) {
13        throw new Error('Circuit breaker is OPEN');
14      }
15      this.state = 'HALF_OPEN';
16    }
17
18    try {
19      const result = await operation();
20      this.onSuccess();
21      return result;
22    } catch (error) {
23      this.onFailure();
24      throw error;
25    }
26  }
27
28  onSuccess() {
29    this.failureCount = 0;
30    this.state = 'CLOSED';
31  }
32
33  onFailure() {
34    this.failureCount++;
35    if (this.failureCount >= this.threshold) {
36      this.state = 'OPEN';
37      this.nextAttempt = Date.now() + this.timeout;
38    }
39  }
40}
41
42// Usage
43const breaker = new CircuitBreaker();
44const result = await breaker.execute(() =>
45  fetch('https://external-api.com/data')
46);

1// Liveness probe - is the application running?
2app.get('/health/live', (req, res) => {
3  res.status(200).json({ status: 'alive' });
4});
5
6// Readiness probe - is the application ready to serve traffic?
7app.get('/health/ready', async (req, res) => {
8  const checks = {
9    database: await checkDatabase(),
10    redis: await checkRedis(),
11    externalAPI: await checkExternalAPI()
12  };
13
14  const allHealthy = Object.values(checks).every(check => check === true);
15
16  res.status(allHealthy ? 200 : 503).json({
17    status: allHealthy ? 'ready' : 'not ready',
18    checks
19  });
20});

1async function getProductRecommendations(userId) {
2  try {
3    // Try ML-powered recommendations
4    return await aiService.getRecommendations(userId);
5  } catch (error) {
6    console.warn('AI service unavailable, using fallback');
7
8    try {
9      // Fallback to simple popularity-based
10      return await getPopularProducts();
11    } catch (fallbackError) {
12      // Final fallback - empty array
13      return [];
14    }
15  }
16}
17// User still gets a working page, just with degraded features

1// Structured logging with context
2import winston from 'winston';
3
4const logger = winston.createLogger({
5  format: winston.format.combine(
6    winston.format.timestamp(),
7    winston.format.json()
8  ),
9  transports: [
10    new winston.transports.Console(),
11    new winston.transports.File({ filename: 'app.log' })
12  ]
13});
14
15// Add request context to all logs
16app.use((req, res, next) => {
17  req.logger = logger.child({
18    requestId: req.id,
19    userId: req.user?.id,
20    path: req.path,
21    method: req.method
22  });
23  next();
24});
25
26// Use throughout application
27app.post('/api/orders', async (req, res) => {
28  req.logger.info('Creating order', {
29    items: req.body.items.length,
30    total: req.body.total
31  });
32
33  try {
34    const order = await createOrder(req.body);
35    req.logger.info('Order created successfully', { orderId: order.id });
36    res.json(order);
37  } catch (error) {
38    req.logger.error('Order creation failed', {
39      error: error.message,
40      stack: error.stack
41    });
42    res.status(500).json({ error: 'Order creation failed' });
43  }
44});

1import { Counter, Histogram, Gauge } from 'prom-client';
2
3// Track request counts
4const httpRequestsTotal = new Counter({
5  name: 'http_requests_total',
6  help: 'Total number of HTTP requests',
7  labelNames: ['method', 'route', 'status']
8});
9
10// Track request duration
11const httpRequestDuration = new Histogram({
12  name: 'http_request_duration_seconds',
13  help: 'HTTP request duration in seconds',
14  labelNames: ['method', 'route'],
15  buckets: [0.1, 0.5, 1, 2, 5]
16});
17
18// Track active connections
19const activeConnections = new Gauge({
20  name: 'active_connections',
21  help: 'Number of active connections'
22});
23
24// Middleware to collect metrics
25app.use((req, res, next) => {
26  const start = Date.now();
27
28  activeConnections.inc();
29
30  res.on('finish', () => {
31    const duration = (Date.now() - start) / 1000;
32
33    httpRequestsTotal.inc({
34      method: req.method,
35      route: req.route?.path || req.path,
36      status: res.statusCode
37    });
38
39    httpRequestDuration.observe({
40      method: req.method,
41      route: req.route?.path || req.path
42    }, duration);
43
44    activeConnections.dec();
45  });
46
47  next();
48});
49
50// Expose metrics endpoint
51app.get('/metrics', async (req, res) => {
52  res.set('Content-Type', register.contentType);
53  res.end(await register.metrics());
54});

1import { trace, context, SpanStatusCode } from '@opentelemetry/api';
2
3const tracer = trace.getTracer('my-service');
4
5async function processOrder(order) {
6  // Create a span for this operation
7  return await tracer.startActiveSpan('processOrder', async (span) => {
8    span.setAttribute('order.id', order.id);
9    span.setAttribute('order.total', order.total);
10
11    try {
12      // Validate inventory
13      await tracer.startActiveSpan('validateInventory', async (inventorySpan) => {
14        await inventoryService.validate(order.items);
15        inventorySpan.end();
16      });
17
18      // Process payment
19      await tracer.startActiveSpan('processPayment', async (paymentSpan) => {
20        const payment = await paymentService.charge(order.total);
21        paymentSpan.setAttribute('payment.id', payment.id);
22        paymentSpan.end();
23      });
24
25      // Create shipment
26      await tracer.startActiveSpan('createShipment', async (shipmentSpan) => {
27        const shipment = await shippingService.create(order);
28        shipmentSpan.setAttribute('shipment.id', shipment.id);
29        shipmentSpan.end();
30      });
31
32      span.setStatus({ code: SpanStatusCode.OK });
33      return { success: true, orderId: order.id };
34    } catch (error) {
35      span.setStatus({
36        code: SpanStatusCode.ERROR,
37        message: error.message
38      });
39      span.recordException(error);
40      throw error;
41    } finally {
42      span.end();
43    }
44  });
45}

1// ❌ BAD - In-memory cache shared across requests
2const cache = new Map();
3
4app.get('/users/:id', async (req, res) => {
5  if (cache.has(req.params.id)) {
6    return res.json(cache.get(req.params.id));
7  }
8
9  const user = await db.getUser(req.params.id);
10  cache.set(req.params.id, user);
11  res.json(user);
12});
13// Problem: Each instance has different cache - inconsistent results!
14
15// ✅ GOOD - External cache service
16app.get('/users/:id', async (req, res) => {
17  const cached = await redis.get(`user:${req.params.id}`);
18  if (cached) {
19    return res.json(JSON.parse(cached));
20  }
21
22  const user = await db.getUser(req.params.id);
23  await redis.setex(`user:${req.params.id}`, 3600, JSON.stringify(user));
24  res.json(user);
25});

1// ❌ BAD - Hardcoded values
2const config = {
3  databaseUrl: 'postgres://localhost:5432/mydb',
4  apiKey: 'sk-1234567890',
5  maxConnections: 10
6};
7
8// ✅ GOOD - Environment-based configuration
9const config = {
10  databaseUrl: process.env.DATABASE_URL,
11  apiKey: process.env.API_KEY,
12  maxConnections: parseInt(process.env.MAX_CONNECTIONS || '10')
13};

1// ❌ BAD - Everything in one codebase
2app.post('/users', createUser);
3app.post('/products', createProduct);
4app.post('/orders', createOrder);
5app.post('/payments', processPayment);
6// Problem: One bug requires redeploying entire system
7
8// ✅ GOOD - Separate services
9// users-service.js
10app.post('/users', createUser);
11
12// products-service.js
13app.post('/products', createProduct);
14
15// orders-service.js
16app.post('/orders', createOrder);
17
18// payments-service.js
19app.post('/payments', processPayment);
20// Each can be deployed independently

1// ❌ BAD - Assuming success
2async function sendEmail(user, subject, body) {
3  await emailService.send(user.email, subject, body);
4  return { success: true };
5}
6// Problem: What if email service is down?
7
8// ✅ GOOD - Handle failures gracefully
9async function sendEmail(user, subject, body) {
10  try {
11    await emailService.send(user.email, subject, body);
12    return { success: true };
13  } catch (error) {
14    // Log the failure
15    logger.error('Email sending failed', { error, user: user.id });
16
17    // Queue for retry
18    await messageQueue.add('email-retry', {
19      user: user.id,
20      subject,
21      body,
22      attempt: 1
23    });
24
25    return {
26      success: false,
27      queued: true,
28      message: 'Email queued for delivery'
29    };
30  }
31}

1// ❌ BAD - Synchronous chain
2async function createOrder(order) {
3  await inventoryService.reserve(order.items);
4  await paymentService.charge(order.payment);
5  await shippingService.schedule(order.address);
6  await emailService.sendConfirmation(order.email);
7  return order;
8}
9// Problem: If email service is slow, entire order process is slow
10
11// ✅ GOOD - Asynchronous processing
12async function createOrder(order) {
13  // Critical path only
14  await inventoryService.reserve(order.items);
15  await paymentService.charge(order.payment);
16
17  // Async tasks via message queue
18  await queue.add('schedule-shipping', { orderId: order.id });
19  await queue.add('send-confirmation', { orderId: order.id });
20
21  return order;
22}