Code snippets — Microservices Architecture Patterns

snippet-2.go

type OrderSaga struct{}

func (s *OrderSaga) Execute(orderID string) error {
    steps := []SagaStep{
        {Execute: paymentService.Charge,    Compensate: paymentService.Refund},
        {Execute: inventoryService.Reserve, Compensate: inventoryService.Release},
        {Execute: shippingService.Schedule, Compensate: shippingService.Cancel},
    }

    var completed []SagaStep
    for _, step := range steps {
        if err := step.Execute(orderID); err != nil {
            // Rollback in reverse order
            for i := len(completed) - 1; i >= 0; i-- {
                completed[i].Compensate(orderID)
            }
            return err
        }
        completed = append(completed, step)
    }
    return nil
}

snippet-2.txt

Client → Order Service → [HTTP] → Inventory Service → [HTTP] → Payment Service

snippet-3.go

type CircuitBreaker struct {
    failures   int
    threshold  int
    lastFailed time.Time
    timeout    time.Duration
    state      string // "closed", "open", "half-open"
}

func (cb *CircuitBreaker) Call(fn func() error) error {
    if cb.state == "open" {
        if time.Since(cb.lastFailed) < cb.timeout {
            return errors.New("circuit breaker open")
        }
        cb.state = "half-open"
    }

    err := fn()
    if err != nil {
        cb.failures++
        cb.lastFailed = time.Now()
        if cb.failures >= cb.threshold {
            cb.state = "open"
        }
        return err
    }

    cb.failures = 0
    cb.state = "closed"
    return nil
}

snippet-3.txt

Order Service → [Kafka] → Payment Service
                       → Inventory Service
                       → Notification Service

snippet-4.txt

                    ┌─────────────────┐
Clients ──────────→ │   API Gateway   │
                    └────────┬────────┘
                             │
              ┌──────────────┼──────────────┐
              ↓              ↓              ↓
        user-service   order-service  product-service

snippet-5.txt

1. Order Service: Creates order → publishes "order.created"
2. Payment Service: Charges card → publishes "payment.processed"
                    (if fails) → publishes "payment.failed"
3. Inventory Service: Reserves stock → publishes "stock.reserved"
                       (if fails) → publishes "stock.insufficient"
4. Order Service:
   - On "payment.failed" → cancels order
   - On "stock.insufficient" → refunds payment, cancels order

snippet.go

// Producer
func PlaceOrder(order Order) error {
    if err := db.Save(order); err != nil {
        return err
    }

    event := OrderPlacedEvent{
        OrderID:   order.ID,
        UserID:    order.UserID,
        Items:     order.Items,
        Total:     order.Total,
        Timestamp: time.Now(),
    }

    return kafka.Publish("orders.placed", event)
}

// Consumer (in payment-service)
func HandleOrderPlaced(event OrderPlacedEvent) error {
    return paymentService.ChargeUser(event.UserID, event.Total, event.OrderID)
}

snippet.txt

# Bad (technical layers)
frontend-service
business-logic-service
database-service

# Good (business capabilities)
user-service
payment-service
notification-service
inventory-service
order-service