Microservices

Ebooks

System Design

Flow

sequenceDiagram
    participant Client
    participant AuthService
    participant CustomerService
    participant ProductService
    participant OrderService
    participant PaymentService
    participant Kafka

    Client->>AuthService: POST /auth
    AuthService-->>Client: JWT

    Client->>CustomerService: POST /customers
    CustomerService-->>Client: Customer Created

    Client->>ProductService: POST /products
    ProductService-->>Client: Product Created

    Client->>OrderService: POST /orders
    OrderService-->>Client: Order Created
    OrderService->>Kafka: OrderEvent Published

    Kafka-->>PaymentService: OrderEvent Consumed
    Note right of PaymentService: Payment Created

    Client->>PaymentService: PUT /payments/order/{orderId}/status/{status}
    PaymentService-->>Client: Payment Status Updated
    PaymentService->>Kafka: PaymentEvent Published

    Kafka-->>OrderService: PaymentEvent Consumed
    Note right of OrderService: Status Updated

Loading

Architecture, Design and Principles

• Screaming Architecture
• Clean Architecture
• Event-Driven Architecture
• Clean Code
• Domain-Driven Design
• SOLID Principles
• Separation of Concerns
• Common Closure Principle
• Common Reuse Principle
• Test Pyramid

Patterns

• Ambassador Pattern
• Circuit Breaker Pattern
• Mediator Pattern
• Outbox Pattern
• Result Pattern
• Retry Pattern
• Strategy Pattern

Technologies and Tools

• Java
• Spring Boot
• Kong
• Keycloak
• OAuth2
• JWT
• Kafka
• MongoDB
• Debezium
• Redis
• Elastic
• Swagger
• Testcontainers
• Docker
• Kubernetes

Docker

docker compose up --detach --build --remove-orphans

Starter

Install Into Local Maven Repository: mvn clean install

Tools

• Kong: http://localhost:8002

• Keycloak: http://localhost:8005 Username: admin Password: password

• Kafka: http://localhost:9000

• Mongo: http://localhost:27018

• Redis: http://localhost:6380

• Logs: http://localhost:5601/app/management/data/index_management/data_streams

• APM: http://localhost:5601/app/apm/services

Services

AuthService

Localhost: http://localhost:8010

Docker: http://localhost:9010

Kong: http://localhost:8000/authservice

Method	Endpoint	Description
	/auth	Get
	/auth	Auth
	/users	Save
	/users/{id}	Delete

ConfigurationService

Localhost: http://localhost:8015

Docker: http://localhost:9015

Kong: http://localhost:8000/configurationservice

Method	Endpoint	Description
	/configurations	List
	/configurations/{id}	Get
	/configurations	Create
	/configurations/{id}	Delete
	/configurations/{id}/value/{value}	Update Value
	/configurations/broadcast	Broadcast

CustomerService

Localhost: http://localhost:8020

Docker: http://localhost:9020

Kong: http://localhost:8000/customerservice

Method	Endpoint	Description
	/customers	List
	/customers/{id}	Get
	/customers	Create
	/customers/{id}	Update
	/customers/{id}	Delete

ProductService

Localhost: http://localhost:8025

Docker: http://localhost:9025

Kong: http://localhost:8000/productservice

Method	Endpoint	Description
	/products	List
	/products/{id}	Get
	/products	Create
	/products/{id}	Update
	/products/{id}	Delete

OrderService

Localhost: http://localhost:8030

Docker: http://localhost:9030

Kong: http://localhost:8000/orderservice

Method	Endpoint	Description
	/orders	List
	/orders/{id}	Get
	/orders	Create

PaymentService

Localhost: http://localhost:8035

Docker: http://localhost:9035

Kong: http://localhost:8000/paymentservice

Meth od	Endpoint	Description
	/payments	List
	/payments/{id}	Get
	/payments/order/{orderId}	Get By Order Id
	/payments/order/{orderId}/status/{status}	Update Status

Examples

Cache

@Service
public class ProductService {
    @Cacheable(value = "products")
    public List<Product> get() {
        return repository.findAll();
    }

    @Cacheable(value = "products", key = "#id")
    public Optional<Product> get(final UUID id) {
        return repository.findById(id);
    }

    @CachePut(value = "products", key = "#product.id")
    public Product save(final Product product) {
        return repository.save(product);
    }

    @CacheEvict(value = "products", key = "#id")
    public void delete(final UUID id) {
        repository.deleteById(id);
    }

    @CacheEvict(value = "products", allEntries = true)
    public void delete() {
        repository.deleteAll();
    }
}

Kafka

echo KEY:{"Key":"KEY"} | docker exec -i kafka /opt/kafka/bin/kafka-console-producer.sh --bootstrap-server localhost:9094 --topic TOPIC --reader-property parse.key=true --reader-property key.separator=":"

docker exec -i kafka /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9094 --topic TOPIC --from-beginning --formatter-property print.key=true --formatter-property key.separator=: