Microservices Fundamentals

ecommerce-monolith/
├── app.py                  # All logic in one app
├── models/
│   ├── user.py
│   ├── product.py
│   ├── order.py
│   └── payment.py
├── database/
│   └── single_database.db  # One database for everything
└── templates/

// Order Service
const express = require('express');
const axios = require('axios');

app.post('/orders', async (req, res) => {
    const order = req.body;

    try {
        // Call Payment Service via HTTP
        const payment = await axios.post(
            'http://payment-service:5002/payments',
            {
                orderId: order.id,
                amount: order.total
            }
        );

        if (payment.data.status === 'success') {
            // Save order to database
            await saveOrder(order);
            res.json({ status: 'confirmed' });
        }
    } catch (error) {
        res.status(500).json({ error: 'Payment failed' });
    }
});

from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import List, Optional
import httpx
from datetime import datetime

app = FastAPI(title="Order Service", version="1.0.0")

# Data models
class OrderItem(BaseModel):
    product_id: int
    quantity: int
    price: float

class Order(BaseModel):
    order_id: Optional[int] = None
    customer_id: int
    items: List[OrderItem]
    total_amount: float
    status: str = "pending"
    created_at: Optional[datetime] = None

# Service-to-service communication
async def verify_inventory(product_id: int, quantity: int) -> bool:
    """Call Inventory Service to verify stock"""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"http://inventory-service:8001/verify",
            json={"product_id": product_id, "quantity": quantity}
        )
        return response.json()["available"]

async def process_payment(amount: float, customer_id: int) -> bool:
    """Call Payment Service to process payment"""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"http://payment-service:8002/charge",
            json={"amount": amount, "customer_id": customer_id}
        )
        return response.status_code == 200

@app.post("/orders", response_model=Order, status_code=201)
async def create_order(order: Order):
    """Create a new order with inventory and payment validation"""

    # Step 1: Verify inventory for all items
    for item in order.items:
        available = await verify_inventory(item.product_id, item.quantity)
        if not available:
            raise HTTPException(
                status_code=400,
                detail=f"Product {item.product_id} not available"
            )

    # Step 2: Process payment
    payment_success = await process_payment(order.total_amount, order.customer_id)
    if not payment_success:
        raise HTTPException(status_code=402, detail="Payment failed")

    # Step 3: Save order to database
    order.order_id = save_to_database(order)
    order.status = "confirmed"
    order.created_at = datetime.now()

    return order

@app.get("/orders/{order_id}", response_model=Order)
async def get_order(order_id: int):
    """Retrieve an order by ID"""
    order = fetch_from_database(order_id)
    if not order:
        raise HTTPException(status_code=404, detail="Order not found")
    return order

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Autowired
    private RestTemplate restTemplate;

    // Create new user
    @Transactional
    public User createUser(UserDTO userDTO) {
        // Validate email uniqueness
        if (userRepository.existsByEmail(userDTO.getEmail())) {
            throw new DuplicateEmailException("Email already exists");
        }

        // Create user entity
        User user = new User();
        user.setEmail(userDTO.getEmail());
        user.setPassword(passwordEncoder.encode(userDTO.getPassword()));
        user.setCreatedAt(LocalDateTime.now());

        // Save to database
        User savedUser = userRepository.save(user);

        // Notify other services (asynchronous)
        notifyUserCreated(savedUser);

        return savedUser;
    }

    // Call Notification Service
    private void notifyUserCreated(User user) {
        String notificationServiceUrl = "http://notification-service:8003/notifications";

        NotificationRequest request = NotificationRequest.builder()
            .userId(user.getId())
            .type("WELCOME_EMAIL")
            .email(user.getEmail())
            .build();

        // Non-blocking call
        CompletableFuture.runAsync(() -> {
            try {
                restTemplate.postForEntity(notificationServiceUrl, request, Void.class);
            } catch (Exception e) {
                logger.error("Failed to send notification", e);
                // Service continues even if notification fails
            }
        });
    }
}