Microservices Architecture

# A simple microservice using Flask
from flask import Flask, jsonify, request
import requests
import os

app = Flask(__name__)

# Each service has its own configuration
INVENTORY_SERVICE_URL = os.getenv("INVENTORY_URL", "http://inventory-service:5001")
PAYMENT_SERVICE_URL = os.getenv("PAYMENT_URL", "http://payment-service:5002")

class OrderService:
    def create_order(self, user_id, items):
        # Step 1: Check inventory (synchronous call)
        inventory_resp = requests.post(
            f"{INVENTORY_SERVICE_URL}/check",
            json={"items": items}
        )
        if not inventory_resp.json()["available"]:
            return {"error": "Items not available"}, 400

        # Step 2: Process payment (synchronous call)
        total = sum(item["price"] * item["qty"] for item in items)
        payment_resp = requests.post(
            f"{PAYMENT_SERVICE_URL}/charge",
            json={"user_id": user_id, "amount": total}
        )
        if payment_resp.status_code != 200:
            return {"error": "Payment failed"}, 402

        # Step 3: Create order record
        order = {
            "user_id": user_id,
            "items": items,
            "total": total,
            "status": "confirmed"
        }
        return order, 201

order_svc = OrderService()

@app.route("/orders", methods=["POST"])
def create_order():
    data = request.get_json()
    result, status = order_svc.create_order(data["user_id"], data["items"])
    return jsonify(result), status

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

# Saga Orchestrator for Order Processing
from enum import Enum
from dataclasses import dataclass
from typing import List, Callable

class SagaStatus(Enum):
    PENDING = "pending"
    COMPLETED = "completed"
    COMPENSATING = "compensating"
    FAILED = "failed"

@dataclass
class SagaStep:
    name: str
    action: Callable       # The forward action
    compensate: Callable   # The rollback action

class SagaOrchestrator:
    def __init__(self, steps: List[SagaStep]):
        self.steps = steps
        self.completed_steps = []
        self.status = SagaStatus.PENDING

    def execute(self, context: dict) -> dict:
        """Execute all saga steps in order."""
        for step in self.steps:
            try:
                print(f"Executing: {step.name}")
                result = step.action(context)
                context.update(result or {})
                self.completed_steps.append(step)
            except Exception as e:
                print(f"Failed at: {step.name} - {e}")
                self._compensate(context)
                return {"status": "failed", "failed_at": step.name}

        self.status = SagaStatus.COMPLETED
        return {"status": "completed", "context": context}

    def _compensate(self, context: dict):
        """Roll back completed steps in reverse order."""
        self.status = SagaStatus.COMPENSATING
        for step in reversed(self.completed_steps):
            try:
                print(f"Compensating: {step.name}")
                step.compensate(context)
            except Exception as e:
                print(f"Compensation failed: {step.name} - {e}")
        self.status = SagaStatus.FAILED

# Example usage: Order processing saga
def reserve_inventory(ctx):
    print(f"  Reserving items: {ctx['items']}")
    return {"reservation_id": "RSV-001"}

def release_inventory(ctx):
    print(f"  Releasing reservation: {ctx['reservation_id']}")

def process_payment(ctx):
    print(f"  Charging ${ctx['total']}")
    return {"payment_id": "PAY-001"}

def refund_payment(ctx):
    print(f"  Refunding payment: {ctx['payment_id']}")

def confirm_order(ctx):
    print(f"  Order confirmed!")
    return {"order_id": "ORD-001"}

def cancel_order(ctx):
    print(f"  Cancelling order: {ctx.get('order_id')}")

saga = SagaOrchestrator([
    SagaStep("Reserve Inventory", reserve_inventory, release_inventory),
    SagaStep("Process Payment", process_payment, refund_payment),
    SagaStep("Confirm Order", confirm_order, cancel_order),
])

result = saga.execute({"items": ["widget"], "total": 29.99})
print(result)

# Run the full microservices stack locally
version: "3.8"

services:
  api-gateway:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - order-service
      - inventory-service
      - payment-service

  order-service:
    build: ./services/orders
    environment:
      - INVENTORY_URL=http://inventory-service:5001
      - PAYMENT_URL=http://payment-service:5002
      - DATABASE_URL=postgres://orders_db:5432/orders
    depends_on:
      - orders-db
      - rabbitmq

  inventory-service:
    build: ./services/inventory
    environment:
      - DATABASE_URL=postgres://inventory_db:5432/inventory
    depends_on:
      - inventory-db

  payment-service:
    build: ./services/payments
    environment:
      - DATABASE_URL=postgres://payments_db:5432/payments
      - STRIPE_KEY=${STRIPE_KEY}
    depends_on:
      - payments-db

  # Each service gets its own database
  orders-db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: orders
    volumes:
      - orders_data:/var/lib/postgresql/data

  inventory-db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: inventory
    volumes:
      - inventory_data:/var/lib/postgresql/data

  payments-db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: payments
    volumes:
      - payments_data:/var/lib/postgresql/data

  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "15672:15672"

volumes:
  orders_data:
  inventory_data:
  payments_data: