Microservices: Strategies Defining Architecture and Decomposition Approaches

Table of contents

How to Create Architecture for Microservices?

Creating an architecture for microservices involves a series of detailed steps to ensure a scalable, maintainable, and efficient system. Developing an architecture is an iterative process that requires a strong foundation, clear planning, and continuous adaptation. By following below detailed steps, you can create a robust and scalable microservices architecture tailored to your business needs.

1) Define Business Requirements

  • Identify business capabilities.
  • Determine key functional and non-functional requirements.
  • Understand the problems you’re solving and the expected outcomes.

2) Identify Microservices Boundaries

  • Use Domain-Driven Design (DDD) principles to segregate the system into bounded contexts.
  • Define microservices around business capabilities.
  • Ensure each has a single responsibility and can operate independently.

3) Choose the Right Tech Stack

  • Decide on programming languages, frameworks, and databases.
  • Consider using lightweight frameworks such as Spring Boot for Java web application development services or Express for Node.js for individual microservices.
  • Decide on database types (SQL, NoSQL) based on service needs.

4) Design Architecture

  • Plan for synchronous (HTTP, gRPC) and asynchronous (message brokers like Kafka or RabbitMQ) communication.
  • Design for fault tolerance and resilience using patterns like Circuit Breaker and Bulkhead.
  • Implement API Gateway to route requests and handle cross-cutting concerns.

5) Plan for Data Management

  • Design databases, adhering to the Database per Service pattern to ensure loose coupling.
  • Implement data management patterns like Saga for distributed transactions and API Composition or CQRS (Command Query Responsibility Segregation) for data querying.

6) Implement Security Measures

  • Secure inter-service communication with protocols like TLS.
  • Implement identity and access management (OAuth 2.0, JWT).
  • Secure your API Gateway with rate limiting and authentication.

7) Set Up Development Environment

  • Use Docker containers to ensure consistency across development, testing, and production environments.
  • Adopt an orchestration tool like Kubernetes for managing containerized services.

8) Develop and Deploy Microservices

  • Develop microservices based on the defined tech stack and business capabilities.
  • Employ continuous integration/continuous delivery (CI/CD) pipelines for automatic testing and deployment.
  • Utilize configuration management and service discovery tools for configurations and dynamic service discovery.

9) Implement Observability

  • Integrate logging, monitoring, and tracing tools (e.g., ELK Stack, Prometheus, Grafana, Zipkin) to observe system behavior and debug issues.
  • Establish metrics and alerts for system health and performance monitoring.

10) Plan for Scalability and Maintenance

  • Design microservices for horizontal scalability.
  • Implement auto-scaling based on load.
  • Regularly update and maintain, ensuring backward compatibility and minimal downtime during deployments.

11) Focus on Continuous Improvement

  • Incorporate feedback loops for consistently refining services.
  • Stay agile and adaptive to changing business requirements.

12) Documentation and Team Communication

  • Document architecture decisions, APIs, and protocols.
  • Ensure clear communication among development teams to maintain coherence and consistency across services.

Architecture for Microservices

Strategies for Microservices Architecture

Microservice architecture is a design approach that structures an application as a collection of loosely coupled services, which implement business capabilities. The primary strategies revolve around ensuring these services are autonomous, scalable, resilient, and manageable. Let’s delve into these strategies with real-time examples:

1. Decomposition by Business Capability

Breaking down the application into microservices based on business functionality.

Example: Within an e-commerce platform, distinct microservices could handle user management, product catalog management, order processing, payment handling, and inventory management autonomously.

2. Database Per Service

Each microservice has its database to ensure loose coupling and data independence.

Example: The order processing of an e-commerce platform has its database, separate from the product catalog’s database, allowing for independent scaling and development.

3. API Gateway

A single entry point for all clients, routing requests to the appropriate microservices and aggregating results.

Example: Netflix uses Zuul as its API Gateway to route requests like user profiles, recommendations, and content streaming.

4. Inter-Service Communication

Microservices communicate with each other through well-defined APIs. This can be synchronous (HTTP/REST, gRPC) or asynchronous (Event-driven using message brokers like Apache Kafka or RabbitMQ).

Example: In a delivery tracking system, the order service publishes an event to Kafka whenever an order is placed, which can be consumed by the delivery service to initiate the delivery process.

5. Service Discovery

Microservices can dynamically discover each other, facilitating flexible and resilient communication.

Example: Netflix Eureka is used for service discovery, enabling microservices to find and communicate with each other without hard-coded locations.

6. Circuit Breakers

Prevent failure in one microservice from cascading to others.

Example: Hystrix (deprecated, but the concept still relevant) was used for circuit breaking, such as when a dependency is slow or failing, calls to it are halted to maintain system stability.

7. Centralized Configuration

Externalizing configuration in a central service for easy changes without redeploying.

Example: Spring Cloud Config provides centralized configuration for managing application settings.

8. Containerization and Orchestration

Using containers (e.g., Docker) for deployment and orchestration tools (e.g., Kubernetes) for managing microservice lifecycles.

Example: Spotify runs thousands of microservices in Docker containers managed by Helios, their orchestration platform, to ensure availability and scalability.

9. Monitoring and Logging

Implementing comprehensive monitoring and logging to trace problems and maintain service health.

Example: Uber uses Jaeger for distributed tracing to monitor and troubleshoot microservices interactions.

10. Security

Implementing security at multiple layers, including authentication, authorization, and secure communication.

Example: Financial services implement OAuth2 and JWT tokens for securing endpoints and ensuring only authorized users can access services.

By strategically adopting these principles, organizations can build resilient, scalable, and maintainable microservices architectures that cater to modern software development and delivery requirements.

Decomposition Approaches for Designing Microservices Architecture

The decomposition approach for transitioning to a target microservices architecture involves breaking down a monolithic application into smaller, independently deployable services. This process is critical for organizations looking to enhance the scalability, flexibility, and resilience of their systems.

Understanding Decomposition

1) Identify Decomposition Criteria:

Decomposition criteria are based on business capabilities, domain-driven design (DDD), and bounded contexts. The aim is to define microservices around business functionalities or domains, ensuring that each service handles a specific business function.

2) Analyze Existing System:

Before decomposition, it’s essential to thoroughly analyze the existing monolithic application to understand its architecture, dependencies, and how different functionalities are intertwined. This step helps in identifying potential services.

3) Define Service Boundaries:

Using insights from DDD, define clear boundaries for each microservice. These boundaries ensure that each microservice is loosely coupled but highly cohesive within its realm of responsibility.

4) Plan Data Decomposition:

Since each microservice will manage its database, it’s important to plan the decomposition of data. This involves identifying data that is exclusively used by a particular service and separating it from shared data.

5) Design Communication Mechanisms:

Microservices interact with each other using lightweight communication protocols. It’s crucial to design the communication mechanisms, whether synchronous RESTful APIs or asynchronous messaging systems like Apache Kafka.

Decomposition Process Steps

Step 1: Start with a monolithic application for microservices architecture.

Step 2: Identify and isolate the domain or business functionality that can autonomously serve a specific purpose, e.g., User Management, Order Management, Inventory, etc.

Step 3: Create an independent service for the isolated domain, ensuring it has its database and API for communication.

Step 4: Repeat the process for other functionalities identified as potential microservices.

Step 5: Implement API Gateways and Service Discovery to manage communication and service orchestration.

Step 6: Continuously iterate, refining services, and their interactions as the system evolves.

Real-Time Example: E-Commerce Platform Decomposition

E-Commerce Platform Decomposition

In this real-time example, the e-commerce platform successfully transitions to a microservices architecture, leading to improved scalability, faster feature development, and enhanced overall system resilience.

  • Background

An E-Commerce platform running on a monolithic architecture experiences scalability issues, slow feature rollouts, and difficulties in maintenance.

  • Identify Business Domains

The team identifies core domains such as User Management, Product Catalog, Order Processing, Inventory, and Payment Processing.

  • Isolate Services

Each domain is isolated into a standalone service. For instance, the Product Catalog service is responsible for managing product listings, descriptions, and prices.

  • Define Boundaries and Data

Boundaries for each service are defined, ensuring that they can operate independently. Separate databases are set up for each service to manage its data.

  • Implement Communication

RESTful APIs are used for synchronous communication between services like User Management and Order Processing. An event-driven approach using Apache Kafka is implemented for asynchronous tasks such as updating the Inventory service after an order is placed.

  • Refine and Iterate

The platform evolves into a fully-fledged microservices architecture, with continuous refinement of services and communication patterns.

Framework Agnostics Microservices Architecture:

Framework Agnostics Microservices Architecture

When architecting a microservices architecture that is framework-agnostic, several key strategies need to be implemented to ensure a robust, scalable, and maintainable system. Here are essential strategies to consider:

  1. Define Clear Service Boundaries

Identify and isolate business functionality into separate services based on business capabilities or domains. This helps in achieving a high level of modularity and makes services easier to develop, deploy, and maintain.

  1. Adopt Domain-Driven Design (DDD)

Utilize DDD principles to model your services around the business domain. This approach helps in understanding the problem domain and designing that align closely with business requirements.

  1. Design for Failure

Assume that components can fail at any time. Implement strategies such as circuit breakers, timeouts, and retries to handle failures gracefully. Designing for failure also means ensuring that your services are stateless where possible and can recover quickly from crashes.

  1. Decentralize Everything

Decentralize data management by allowing each microservice to own its domain data and logic. This approach, known as database per service, ensures loose coupling and high cohesion. Decentralize governance by empowering teams to make decisions regarding the development and deployment of their services.

  1. Implement API Gateways

Use API gateways to centralize common functionalities such as authentication, authorization, and rate limiting. API gateways also abstract the complexity of the microservices landscape from clients.

  1. Communication Strategies

Select appropriate communication protocols (HTTP REST, gRPC, AMQP, etc.) based on the use case. Implement asynchronous messaging or event-driven architectures for services that require high scalability and loose coupling.

  1. Ensure Security

Implement strong security practices at all layers, including secure communication (TLS), authentication, authorization, and secret management. Consider adopting an Identity and Access Management (IAM) solution for centralizing user and service authentication.

  1. Implement Observability

Instrument your services with logging, monitoring, and tracing capabilities. Adopt tools and practices that provide insights into the health and performance of your services, facilitating quick detection and resolution of issues.

  1. Focus on DevOps Practices

Incorporate Continuous Integration (CI) and Continuous Deployment (CD) practices to automate the testing and deployment of microservices architecture development services. Leverage containerization and orchestration tools (e.g., Docker, Kubernetes) for consistent deployment and scaling.

  1. Plan for Scalability and Resiliency

Design your services and infrastructure to handle varying loads gracefully. Implement load balancing, auto-scaling, and design your data storage for scalability.

  1. Iterate and Automate

Microservices architectures evolve over time. Regularly review and refactor services based on emerging requirements and technical advancements. Encourage continuous learning and experimentation within teams.

Asynchronous Microservices Vs Event-based Vs IoT-oriented Microservices

The process of decomposing a monolithic application into microservices is a critical step in building scalable, maintainable, and resilient software architectures. The decomposition approach varies significantly depending on the nature of the system being designed, particularly when comparing asynchronous, event-based, and IoT-based microservices. Each has its unique requirements and challenges that influence the decomposition strategy.

Asynchronous Microservices

Asynchronous microservices communicate without waiting for a response, allowing for high levels of decoupling and scalability.

  • Domain-Driven Design (DDD): Identifying bounded contexts within the domain to define boundaries. This ensures each service is aligned with a specific business capability.
  • Decompose by Business Capability: Services are decomposed based on individual business functions, allowing for independent scaling and development.
  • API Gateway: Aggregates responses from multiple services, facilitating asynchronous communication through message queues or event streams.
  • Eventual Consistency: Emphasizing a system design that tolerates eventual consistency to enhance scalability and resilience.

Event-Driven Microservices

Event-Driven Microservices Architecture

Image Source

Event-driven microservices communicate by producing and consuming events, making the system highly responsive and loosely coupled.

  • Event Storming: A collaborative modeling technique to identify domain events, commands, and aggregates that help in defining service boundaries.
  • Message Broker: Incorporating a central message broker (e.g., Kafka, RabbitMQ) that decouples service-to-service communication.
  • Event Sourcing and CQRS: Applying Event Sourcing and Command Query Responsibility Segregation (CQRS) patterns to manage data consistency and improve system scalability.
  • Decompose by Subdomain: Breaking down the system based on subdomains identified during the event storming process, ensuring services are cohesive and maintain a single responsibility.

IoT-Based Microservices

IoT-based microservices interact with a wide range of devices and sensors, requiring a focus on real-time data processing and device management.

  • Decompose by IoT Devices: Services are structured around the “things” or devices, managing their state, connectivity, and data processing.
  • Edge Computing: Deploying services closer to the source of data (edge devices) for real-time processing and reduced latency.
  • Data Stream Processing: Implementing stream processing frameworks (e.g., Apache Flink, Spark Streaming) to handle large volumes of data generated by devices.
  • Protocol Adaptation: Designing services to accommodate various communication protocols used by devices (MQTT, CoAP, etc.), ensuring seamless integration.

Distributed Transactions and Centralized Configuration Architecture

In the context of event-based and IoT microservices architectures using Spring Boot, managing distributed transactions and centralized configurations are pivotal aspects to ensure consistency, reliability, and flexibility.

Distributed Transactions

Distributed transactions span across multiple services and resources, which is commonplace in microservices architectures, especially in IoT scenarios where transactions might affect multiple services.

  1. Challenges: The main challenges with distributed transactions include ensuring data consistency across services, managing atomicity, and dealing with partial failures.
  2. Eventual Consistency and Compensation: Instead of traditional ACID transactions, microservices often rely on eventual consistency. You can achieve this through compensation mechanisms where if part of the transaction fails, compensating transactions are initiated to revert the initial operation.
  3. Saga Pattern: The saga pattern is a sequence of local transactions where each transaction updates data within a single service. Upon failure, sagas execute compensating transactions to ensure consistency. Sagas can be orchestrated (where a central coordinator manages the saga steps) or choreographed (where each service produces and listens to events, managing its transactions).
  4. Implementing in Spring Boot: For implementing distributed transactions, you might not find out-of-the-box support in Spring Boot. However, you can use Spring Cloud Stream for event-driven communication and Spring Kafka or RabbitMQ for messaging. By creating domain events and publishing them to a message broker, each service can handle its transactions and listen for events from other services.

Centralized Configuration

In a microservices architecture, particularly with IoT applications, maintaining a centralized configuration is crucial for managing service configurations without the need to redeploy or restart services upon configuration changes.

  1. Spring Cloud Config: Spring Cloud Config provides server-side and client-side support for externalizing and managing centralized configurations. The Config Server connects to a version control system (like Git) to store the configuration properties. On the client side, Spring Boot applications can access these configurations at runtime.
  2. Dynamic Configuration Updates: For IoT and event-based systems where conditions might frequently change, it’s advantageous to use Spring Cloud Bus and Spring Cloud Config to propagate configuration changes dynamically. Spring Cloud Bus links the nodes of a distributed system with a lightweight message broker (e.g., RabbitMQ or Kafka), enabling the refreshing of configurations without the need for restarts.
  3. Security: Securing configuration data, especially in IoT environments, is vital. Spring Cloud Config supports encrypting property values in the configuration repository, which Spring Boot services can decrypt at runtime.

In summary, effectively managing distributed transactions in IoT and event-based microservices architectures involves adopting patterns like sagas for eventual consistency. For centralized configuration, leveraging Spring Cloud Config with Spring Cloud Bus ensures dynamic, secure configuration management across services.

Decomposition Strategies Example with E-Commerce Application

To understand the event-based architecture in the context of an eCommerce application’s order management system, let’s consider a hypothetical online store, “GlobeMart,” which uses microservices for different aspects of its operation, like inventory control, order management, payment processing, and shipping.

Example with E-Commerce application

System Overview

  • Inventory Service: Manages stock levels of products.
  • Order Service: Handles customer orders.
  • Payment Service: Processes payments.
  • Shipping Service: Manages the dispatch of orders to customers.

Using Event-Driven Architecture

In an event-driven architecture, these services communicate through events. An event is a change in state or an update, such as “Item Ordered” or “Payment Processed”. Events are published to a central communication hub, often a message broker like Apache Kafka or RabbitMQ, which then distributes the events to interested services (subscribers).

Step-by-Step Process

  1. Customer Places an Order:

A customer orders 2 items from GlobeMart. The Order Service creates a new order, marking it as “Pending”, and publishes an “Order Created” event.

  1. Inventory and Payment Processing:

The Inventory Service monitors and responds to events indicating the creation of orders. Upon receipt, it verifies stock levels and, if sufficient, reserves the stock and publishes an “Inventory Confirmed” event. The Payment Service is designed to monitor and respond to events notifying the creation of orders. It initiates the payment process. Once successful, it publishes a “Payment Successful” event.

  1. Order Finalization and Shipping:

The Order Service listens for both “Inventory Confirmed” and “Payment Successful” events for the same order. Once both are received, it updates the order status to “Confirmed” and publishes an “Order Confirmed” event. The Shipping Service listens for “Order Confirmed” events. Upon receiving one, it arranges for the item to be shipped to the customer and, once dispatched, publishes an “Item Shipped” event.

Why Event-Driven?

Event-driven architectures offer great flexibility and scalability for microservices architectures, such as those used in eCommerce applications. However, they also require careful design to manage complexity and ensure system reliability.

  • Decoupling: Services operate independently, reducing dependencies. Changes in one service don’t require changes in others.
  • Scalability: Services can scale independently, handling more or fewer events as demand changes.
  • Resilience: The system can better handle partial failures. If the Payment Service is down, the order can still be created in the “Pending” state, and the payment can be processed once the service is back.


  • Complexity: Managing events and understanding the flow can become complex in larger systems.
  • Event Consistency: Ensuring the consistency and order of events can be challenging, especially in systems with many services.

Frequently Asked Questions (FAQs)

1) How to architect Microservices?

Ans: To architect microservices, begin by defining clear boundaries and responsibilities for each service. Utilize technologies like RESTful APIs or messaging queues for communication. Implement fault tolerance and scalability measures such as containerization and load balancing. Lastly, prioritize continuous integration and deployment for efficient development and deployment cycles.

2) What are strategies for architecting Microservices?

Ans: Strategies for architecting microservices encompass delineating precise service boundaries, leveraging communication protocols such as REST or messaging queues, integrating fault tolerance mechanisms, and emphasizing continuous integration to streamline development workflows

3) What is the decomposition strategy for building microservices architecture?

Ans: Begin by identifying the functionalities of the monolithic application that can be broken down into separate services. Define clear boundaries, ensuring they have distinct responsibilities and do not overlap. Utilize domain-driven design principles to organize microservices based on business domains or subdomains. Implement communication mechanisms such as RESTful APIs or message queues to facilitate interaction between microservices.

Read more on related Insights