Cloud-Native Architecture Patterns: A Comprehensive Guide

Cloud-native architecture has revolutionized how we design, build, and deploy modern applications. This comprehensive guide explores essential patterns, implementation strategies, and best practices for creating robust cloud-native systems.

$1

$1

``mermaid

graph TD

A[API Gateway] --> B[Auth Service]

A --> C[User Service]

A --> D[Product Service]

A --> E[Order Service]

D --> F[(Product DB)]

E --> G[(Order DB)]

C --> H[(User DB)]

`

$1

`mermaid

graph LR

A[Event Producer] --> B[Event Bus]

B --> C[Consumer 1]

B --> D[Consumer 2]

B --> E[Consumer 3]

C --> F[State Store 1]

D --> G[State Store 2]

`

$1

$1

`typescript

// api-gateway.ts

import express from 'express';

import { createProxyMiddleware } from 'http-proxy-middleware';

const app = express();

// Service registry

const services = {

auth: 'http://auth-service:3001',

users: 'http://user-service:3002',

products: 'http://product-service:3003',

orders: 'http://order-service:3004'

};

// Authentication middleware

const authMiddleware = async (req: any, res: any, next: any) => {

try {

const token = req.headers.authorization;

if (!token) {

return res.status(401).json({ error: 'Unauthorized' });

}

// Validate token

const response = await fetch(${services.auth}/validate, {

headers: { Authorization: token }

});

if (!response.ok) {

return res.status(401).json({ error: 'Invalid token' });

}

next();

} catch (error) {

res.status(500).json({ error: 'Internal server error' });

}

};

// Route configurations

app.use('/auth', createProxyMiddleware({

target: services.auth,

changeOrigin: true

}));

app.use('/users', authMiddleware, createProxyMiddleware({

target: services.users,

changeOrigin: true

}));

app.use('/products', authMiddleware, createProxyMiddleware({

target: services.products,

changeOrigin: true

}));

app.use('/orders', authMiddleware, createProxyMiddleware({

target: services.orders,

changeOrigin: true

}));

app.listen(3000, () => {

console.log('API Gateway running on port 3000');

});

`

$1

`typescript

// event-store.ts

interface Event {

id: string;

type: string;

data: any;

timestamp: Date;

aggregateId: string;

version: number;

}

class EventStore {

private events: Event[] = [];

private eventHandlers: Map = new Map();

async saveEvent(event: Event): Promise {

this.events.push(event);

await this.publishEvent(event);

}

async getEvents(aggregateId: string): Promise {

return this.events.filter(event => event.aggregateId === aggregateId);

}

subscribe(eventType: string, handler: Function): void {

const handlers = this.eventHandlers.get(eventType) || [];

handlers.push(handler);

this.eventHandlers.set(eventType, handlers);

}

private async publishEvent(event: Event): Promise {

const handlers = this.eventHandlers.get(event.type) || [];

await Promise.all(handlers.map(handler => handler(event)));

}

}

`

$1

$1

`typescript

// cqrs-example.ts

interface Command {

type: string;

payload: any;

}

interface Query {

type: string;

parameters: any;

}

class OrderCommandHandler {

async handle(command: Command): Promise {

switch (command.type) {

case 'CREATE_ORDER':

await this.createOrder(command.payload);

break;

case 'UPDATE_ORDER':

await this.updateOrder(command.payload);

break;

default:

throw new Error(Unknown command type: ${command.type});

}

}

private async createOrder(payload: any): Promise {

// Implementation

}

private async updateOrder(payload: any): Promise {

// Implementation

}

}

class OrderQueryHandler {

async handle(query: Query): Promise {

switch (query.type) {

case 'GET_ORDER':

return this.getOrder(query.parameters);

case 'LIST_ORDERS':

return this.listOrders(query.parameters);

default:

throw new Error(Unknown query type: ${query.type});

}

}

private async getOrder(parameters: any): Promise {

// Implementation

}

private async listOrders(parameters: any): Promise {

// Implementation

}

}

`

$1

`typescript

// circuit-breaker.ts

enum CircuitState {

CLOSED,

OPEN,

HALF_OPEN

}

class CircuitBreaker {

private state: CircuitState = CircuitState.CLOSED;

private failureCount: number = 0;

private lastFailureTime: number = 0;

private readonly failureThreshold: number;

private readonly resetTimeout: number;

constructor(failureThreshold: number = 5, resetTimeout: number = 60000) {

this.failureThreshold = failureThreshold;

this.resetTimeout = resetTimeout;

}

async execute(operation: () => Promise): Promise {

if (this.state === CircuitState.OPEN) {

if (Date.now() - this.lastFailureTime >= this.resetTimeout) {

this.state = CircuitState.HALF_OPEN;

} else {

throw new Error('Circuit breaker is OPEN');

}

}

try {

const result = await operation();

this.onSuccess();

return result;

} catch (error) {

this.onFailure();

throw error;

}

}

private onSuccess(): void {

this.failureCount = 0;

this.state = CircuitState.CLOSED;

}

private onFailure(): void {

this.failureCount++;

this.lastFailureTime = Date.now();

if (this.failureCount >= this.failureThreshold) {

this.state = CircuitState.OPEN;

}

}

}

`

$1

$1

`typescript

// retry-pattern.ts

interface RetryOptions {

maxAttempts: number;

delay: number;

backoffMultiplier: number;

}

async function retry(

operation: () => Promise,

options: RetryOptions

): Promise {

let lastError: Error;

let attempt = 1;

let delay = options.delay;

while (attempt <= options.maxAttempts) {

try {

return await operation();

} catch (error) {

lastError = error;

console.log(Attempt ${attempt} failed. Retrying in ${delay}ms...);

await new Promise(resolve => setTimeout(resolve, delay));

delay *= options.backoffMultiplier;

attempt++;

}

}

throw new Error(Operation failed after ${options.maxAttempts} attempts: ${lastError.message});

}

`

$1

`typescript

// bulkhead-pattern.ts

class BulkheadExecutor {

private semaphore: number;

private queue: Array<() => Promise> = [];

private executing: number = 0;

constructor(private maxConcurrent: number) {

this.semaphore = maxConcurrent;

}

async execute(operation: () => Promise): Promise {

if (this.executing >= this.maxConcurrent) {

await new Promise(resolve => this.queue.push(resolve));

}

this.executing++;

try {

return await operation();

} finally {

this.executing--;

if (this.queue.length > 0) {

const next = this.queue.shift();

next?.();

}

}

}

}

`

$1

$1

`yaml

sidecar-example.yaml

`

$1

`yaml

ambassador-example.yaml

`

$1

$1

`typescript

// health-check.ts

interface HealthCheck {

name: string;

check: () => Promise;

}

class HealthMonitor {

private checks: HealthCheck[] = [];

addCheck(check: HealthCheck): void {

this.checks.push(check);

}

async performHealthCheck(): Promise<{

status: string;

checks: { [key: string]: boolean };

}> {

const results: { [key: string]: boolean } = {};

let overallStatus = 'healthy';

for (const check of this.checks) {

try {

results[check.name] = await check.check();

if (!results[check.name]) {

overallStatus = 'unhealthy';

}

} catch (error) {

results[check.name] = false;

overallStatus = 'unhealthy';

}

}

return {

status: overallStatus,

checks: results

};

}

}

`

$1

`typescript

// metrics-collector.ts

class MetricsCollector {

private metrics: Map = new Map();

private histograms: Map = new Map();

incrementCounter(name: string): void {

const current = this.metrics.get(name) || 0;

this.metrics.set(name, current + 1);

}

recordValue(name: string, value: number): void {

const values = this.histograms.get(name) || [];

values.push(value);

this.histograms.set(name, values);

}

getMetrics(): object {

const result: { [key: string]: any } = {};

this.metrics.forEach((value, key) => {

result[key] = value;

});

this.histograms.forEach((values, key) => {

result[key] = {

count: values.length,

avg: values.reduce((a, b) => a + b, 0) / values.length,

max: Math.max(...values),

min: Math.min(...values)

};

});

return result;

}

}

``

$1

1. Design Principles

- Loose coupling

- High cohesion

- Single responsibility

- Immutability

- Idempotency

2. Implementation Guidelines

- API-first design

- Infrastructure as code

- Automated testing

- Continuous deployment

- Security by design

3. Operational Considerations

- Monitoring strategy

- Logging standards

- Alerting policies

- Capacity planning

- Disaster recovery

$1

Cloud-native architecture patterns provide a robust foundation for building modern, scalable, and resilient applications. By implementing these patterns thoughtfully and following best practices, you can create systems that are maintainable, scalable, and reliable in production environments.