Cloud-Native Architecture: Patterns and Practices for Scalable Systems

// Example: Event-driven microservice with AWS EventBridge and Lambda
// Publisher Service
import { EventBridge } from '@aws-sdk/client-eventbridge';

const eventBridge = new EventBridge({ region: 'us-east-1' });

export const publishOrderCreated = async (orderData) => {
  const event = {
    Source: 'order-service',
    DetailType: 'OrderCreated',
    Detail: JSON.stringify({
      orderId: orderData.id,
      userId: orderData.userId,
      amount: orderData.amount,
      items: orderData.items,
      timestamp: new Date().toISOString(),
    }),
    EventBusName: 'application-events',
  };

  await eventBridge.putEvents({ Entries: [event] });
  console.log('Order created event published:', orderData.id);
};

// Subscriber Service (Lambda)
export const handler = async (event) => {
  const orderEvent = JSON.parse(event.detail);

  // Process order (inventory, payment, notifications, etc.)
  await updateInventory(orderEvent.items);
  await processPayment(orderEvent.userId, orderEvent.amount);
  await sendNotification(orderEvent.userId, orderEvent.orderId);

  return { statusCode: 200, body: 'Order processed' };
};

// Example: Circuit breaker pattern with Node.js
import CircuitBreaker from 'opossum';

// Define the function to protect
const callExternalAPI = async (url) => {
  const response = await fetch(url);
  if (!response.ok) throw new Error('API call failed');
  return response.json();
};

// Create circuit breaker
const breaker = new CircuitBreaker(callExternalAPI, {
  timeout: 3000, // 3 seconds
  errorThresholdPercentage: 50,
  resetTimeout: 30000, // 30 seconds
});

// Fallback function
breaker.fallback(() => ({
  error: 'Service temporarily unavailable',
  cached: true,
}));

// Event handlers
breaker.on('open', () => console.log('Circuit breaker opened'));
breaker.on('halfOpen', () => console.log('Circuit breaker half-open'));
breaker.on('close', () => console.log('Circuit breaker closed'));

// Use the protected function
export const fetchData = async (url) => {
  try {
    return await breaker.fire(url);
  } catch (error) {
    console.error('Circuit breaker error:', error);
    throw error;
  }
};