Microservices Patterns

Microservices Patterns Skill

Overview

This skill provides comprehensive microservices architecture patterns including service discovery, circuit breakers, event-driven architecture, saga patterns, API gateways, and distributed data management.

Quick Start

Microservices Checklist

• Service boundaries clearly defined
• Database per service
• API Gateway for external communication
• Async messaging between services
• Circuit breakers for resilience
• Distributed tracing implemented
• Centralized logging
• Health checks and monitoring

Communication Patterns

Synchronous (REST/gRPC):

• Simple request/response
• Tight coupling
• Blocking
• Use for: Queries, simple operations

Asynchronous (Message Queue):

• Event-driven
• Loose coupling
• Non-blocking
• Use for: Commands, long operations, event sourcing

Core Patterns

API Gateway

# Kong Gateway configuration
services:
  - name: user-service
    url: http://user-service:8080
    routes:
      - name: user-routes
        paths:
          - /api/users
    plugins:
      - name: rate-limiting
        config:
          minute: 100
      - name: jwt
      - name: cors

Circuit Breaker

from circuitbreaker import circuit
import requests

@circuit(failure_threshold=5, recovery_timeout=30, expected_exception=requests.RequestException)
def call_external_service():
    response = requests.get('http://external-service/api')
    return response.json()

# Usage
try:
    result = call_external_service()
except circuitbreaker.CircuitBreakerError:
    # Circuit is open, use fallback
    result = fallback_data()

Service Discovery

# Consul service registration
service:
  name: order-service
  tags:
    - orders
    - v1
  port: 8080
  check:
    http: http://localhost:8080/health
    interval: 10s

Saga Pattern

# Choreography-based saga
class OrderSaga:
    def __init__(self, event_bus):
        self.event_bus = event_bus
    
    def start_order(self, order_data):
        # Step 1: Create order (pending)
        order = create_pending_order(order_data)
        
        # Step 2: Reserve inventory
        self.event_bus.publish('InventoryReservationRequested', {
            'order_id': order.id,
            'items': order.items
        })
    
    def on_inventory_reserved(self, event):
        # Step 3: Process payment
        self.event_bus.publish('PaymentRequested', {
            'order_id': event.order_id,
            'amount': event.total
        })
    
    def on_payment_completed(self, event):
        # Step 4: Complete order
        complete_order(event.order_id)
        self.event_bus.publish('OrderCompleted', {
            'order_id': event.order_id
        })
    
    def on_inventory_failed(self, event):
        # Compensate: Cancel order
        cancel_order(event.order_id)

Detailed References

See comprehensive guides in references/:

• Service Communication - REST, gRPC, GraphQL, message queues
• Resilience Patterns - Circuit breakers, retries, bulkhead, timeouts
• Event-Driven Architecture - Event sourcing, CQRS, saga patterns
• Data Management - Database per service, distributed transactions, eventual consistency

When to Use This Skill

Use this skill when:

• Decomposing monolith into microservices
• Designing service boundaries and APIs
• Implementing inter-service communication
• Managing distributed data consistency
• Building resilient service architectures
• Setting up service discovery and load balancing
• Implementing API gateways
• Handling distributed transactions

Related Skills

• @kubernetes-patterns - Container orchestration for microservices
• @docker-patterns - Containerization
• @api-rest-design - API design for services
• @observability-monitoring - Distributed tracing and monitoring
• @security-best-practices - Service-to-service security
• @performance-optimization - Service performance

Converted and distributed by TomeVault — claim your Tome and manage your conversions.