Microservices Best Practices¶

Overview¶

This guide covers comprehensive best practices and patterns for building, deploying, and maintaining microservices architecture.

Prerequisites¶

Basic understanding of microservices architecture
Knowledge of distributed systems
Familiarity with cloud platforms
Understanding of DevOps practices

Learning Objectives¶

Understand microservices best practices
Learn design patterns
Master operational practices
Implement security measures
Handle scalability and resilience

Design Principles¶

Single Responsibility¶

Each service should have a single responsibility and should be focused on a specific business capability.

@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentClient paymentClient;

    // Focus only on order-related operations
    public Order createOrder(OrderRequest request) {
        // Order creation logic
    }

    public Order updateOrder(String orderId, OrderUpdateRequest request) {
        // Order update logic
    }
}

API First Design¶

Design APIs before implementation using OpenAPI/Swagger specifications.

openapi: 3.0.0
info:
  title: Order Service API
  version: 1.0.0
paths:
  /orders:
    post:
      summary: Create a new order
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/OrderRequest'
      responses:
        '201':
          description: Order created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Order'

Service Organization¶

Project Structure¶

order-service/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/company/order/
│   │   │       ├── config/
│   │   │       ├── controller/
│   │   │       ├── domain/
│   │   │       ├── repository/
│   │   │       ├── service/
│   │   │       └── client/
│   │   └── resources/
│   └── test/
├── Dockerfile
├── pom.xml
└── README.md

Service Registry¶

@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

Data Management¶

Database Per Service¶

Each service should have its own database to ensure loose coupling.

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/orderdb
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: none

Event Sourcing¶

@Service
public class OrderEventService {
    private final EventStore eventStore;

    public void createOrder(OrderCreatedEvent event) {
        eventStore.save(event);
        // Additional processing
    }

    public Order reconstructOrder(String orderId) {
        List<Event> events = eventStore.getEvents(orderId);
        return Order.replay(events);
    }
}

Communication Patterns¶

Asynchronous Communication¶

@Service
public class OrderProcessor {
    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;

    public void processOrder(Order order) {
        OrderEvent event = new OrderEvent(order);
        kafkaTemplate.send("order-events", event);
    }
}

Circuit Breaker¶

@Service
public class PaymentService {
    @CircuitBreaker(name = "payment", fallbackMethod = "fallbackPayment")
    public Payment processPayment(PaymentRequest request) {
        return paymentClient.processPayment(request);
    }

    public Payment fallbackPayment(PaymentRequest request, Exception ex) {
        return new Payment(PaymentStatus.PENDING);
    }
}

Operational Excellence¶

Health Checks¶

@Component
public class OrderServiceHealthIndicator implements HealthIndicator {
    private final OrderRepository orderRepository;

    @Override
    public Health health() {
        try {
            orderRepository.count();
            return Health.up().build();
        } catch (Exception ex) {
            return Health.down()
                .withException(ex)
                .build();
        }
    }
}

Monitoring and Metrics¶

@Component
public class OrderMetrics {
    private final MeterRegistry registry;

    public void recordOrderProcessingTime(long timeInMs) {
        registry.timer("order.processing.time")
            .record(timeInMs, TimeUnit.MILLISECONDS);
    }

    public void incrementOrderCounter() {
        registry.counter("order.created").increment();
    }
}

Best Practices Summary¶

1. Service Design¶

Keep services small and focused
Design for failure
Use API-first approach
Implement proper validation
Use proper error handling

2. Data Management¶

Use database per service
Implement eventual consistency
Handle distributed transactions
Use proper caching strategies
Implement data backup and recovery

3. Security¶

Implement authentication and authorization
Use HTTPS everywhere
Secure sensitive data
Implement rate limiting
Regular security audits

4. DevOps¶

Automate deployment process
Implement CI/CD
Use container orchestration
Monitor service health
Implement proper logging

5. Testing¶

Write comprehensive tests
Implement contract testing
Perform load testing
Test failure scenarios
Automate testing process

Implementation Examples¶

Complete Service Implementation¶

@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    private final OrderRepository orderRepository;
    private final PaymentClient paymentClient;
    private final OrderMetrics metrics;

    @Transactional
    public Order createOrder(OrderRequest request) {
        long startTime = System.currentTimeMillis();
        try {
            // Validate request
            validateRequest(request);

            // Create order
            Order order = new Order(request);
            order = orderRepository.save(order);

            // Process payment
            Payment payment = processPayment(order);
            order.setPaymentStatus(payment.getStatus());

            // Update metrics
            metrics.incrementOrderCounter();

            return order;
        } finally {
            metrics.recordOrderProcessingTime(
                System.currentTimeMillis() - startTime);
        }
    }

    @CircuitBreaker(name = "payment")
    private Payment processPayment(Order order) {
        return paymentClient.processPayment(
            new PaymentRequest(order));
    }
}

Configuration Management¶

spring:
  application:
    name: order-service
  cloud:
    config:
      uri: http://config-server:8888
      fail-fast: true
  datasource:
    url: jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  kafka:
    bootstrap-servers: ${KAFKA_SERVERS}
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  metrics:
    tags:
      application: ${spring.application.name}

resilience4j:
  circuitbreaker:
    instances:
      payment:
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 5000

Common Pitfalls to Avoid¶

Too fine-grained services
Synchronous communication overuse
Shared databases
Lack of monitoring
Poor error handling
Insufficient testing
Missing security measures
Inadequate documentation

Resources for Further Learning¶

Practice Exercises¶

Design a microservice architecture
Implement service discovery
Set up monitoring and alerting
Implement circuit breakers
Create deployment pipelines