Microservices

Microservices is an architecture where an application is divided into small, independent services that communicate over a network. Instead of one tightly coupled codebase, each service handles a specific function and can be developed and deployed separately.

• Can be written in a variety of programming languages, and frameworks, and each service acts as a mini-application on its own.
• A small, loosely coupled service that is designed to perform a specific business function and each microservice can be developed, deployed, and scaled independently.

Example: An e-commerce platform like Amazon can be built using microservices, where separate services handle product catalog, user authentication, cart, payments, and order management. Each service works independently and communicates over APIs.

Real world Applications

Microservices architecture is widely used in modern applications where scalability, flexibility, and independent service management are important.

• Amazon: Initially a monolithic app, Amazon uses microservices early on, breaking its platform into smaller components. This shift allowed for individual feature updates, greatly enhancing functionality.
• Banking & FinTech: Independent services for accounts, transactions, fraud detection, and customer support, ensuring high security, reliability, and compliance with financial regulations.
• Netflix: After facing service outages while transitioning to a movie-streaming service in 2007, Netflix adopted a microservices architecture. This change improved reliability and performance.
• Social media platforms: Microservices for feed, chat, notifications, and user profiles, enabling high scalability and real-time interactions for millions of users.
• Healthcare systems: Patient records, appointment scheduling, billing, and reporting as separate services, improving data management, scalability, and system reliability.
• Uber: By switching from a monolithic structure to microservices, Uber operations were become smoother, resulting in increased webpage views and search efficiency

Working

The working of microservices architecture focuses on dividing the application into small, independent services that collaborate to perform different business functions.

• Each microservice handles a particular business feature, like user authentication or product management, allowing for specialized development.
• Services interact via APIs, facilitating standardized information exchange and integration.
• Each service runs independently and communicates with other services through lightweight protocols such as HTTP or messaging systems.
• Requests from users are routed to the appropriate microservice, which processes the request and may interact with other services or databases to return the response.

Components

Main components of microservices architecture include:

1. Microservices

Microservices are independent, loosely coupled services designed around specific business functions.

• Handle a single, well-defined capability.
• Can be developed and deployed independently.

2. API Gateway

The API Gateway serves as a centralized entry point for all external client requests.

• Manages request routing and authentication
• Forwards requests to appropriate microservices

3. Service Registry and Discovery

Service Registry and Discovery keeps track of available services and their locations.

• Stores service network addresses.
• Enables dynamic inter-service communication.

4. Load Balancer

A Load Balancer distributes incoming traffic across service instances.

• Improves availability and reliability.
• Prevents service overload.

5. Deployment & Infrastructure (Tools/Support Layer)

Technologies like Docker (Containerization) and Kubernetes are used to package, deploy, and manage microservices efficiently.

• Docker encapsulates services consistently
• Kubernetes manages scaling and orchestration

6. Event Bus / Message Broker

An Event Bus or Message Broker enables asynchronous communication between services.

• Supports publish–subscribe messaging
• Decouples service interactions

7. Database per Microservice

In the Database per Microservice pattern, each microservice owns and manages its own dedicated database to maintain data autonomy.

• Ensures data isolation and loose coupling between services.
• Enables independent scaling and technology choices per service.

8. Caching

Caching improves performance by storing frequently accessed data closer to services.

• Reduces database load
• Decreases response latency

9. Fault Tolerance and Resilience

Fault tolerance and resilience mechanisms enable the system to continue functioning even when some components fail.

• Uses techniques such as circuit breakers, retries, and fallbacks.
• Maintains overall system stability and availability.

Design Patterns for Microservices Architecture

Below are the main design pattern of microservices:

1. API Gateway Pattern

API Gateway pattern simplifies the client’s experience by hiding the complexities of multiple services behind one interface. It can also handle tasks like authentication, logging, and rate limiting, making it a crucial part of microservices architecture.

2. Service Registry Pattern

Service Registery pattern is like a phone book for microservices. It maintains a list of all active services and their locations (network addresses). When a service starts, it registers itself with the registry.

Other services can then look up the registry to find and communicate with it. This dynamic discovery enables flexibility and helps services interact without hardcoding their locations.

3. Circuit Breaker Pattern

In circuit breaker pattern If a service fails repeatedly, the circuit breaker trips, preventing further requests to that service. After a timeout period, it allows limited requests to test if the service is back online. This reduces the load on failing services and enhances system resilience.

4. Saga Pattern

Saga pattern is useful for managing complex business processes that span multiple services. Instead of treating the process as a single transaction, the saga breaks it down into smaller steps, each handled by different services.

If one step fails, compensating actions are taken to reverse the previous steps. This way, you maintain data consistency across the system, even in the face of failures.

5. Event Sourcing Pattern

In Event Sourcing Pattern, Each event describes a change that occurred, allowing services to reconstruct the current state by replaying the event history. This provides a clear audit trail and simplifies data recovery in case of errors.

6. Strangler Pattern

Strangler pattern allows for a gradual transition from a monolithic application to microservices. New features are developed as microservices while the old system remains in use.

Over time, as more functionality is moved to microservices, the old system is gradually "strangled" until it can be fully retired. This approach minimizes risk and allows for a smoother migration.

7. Bulkhead Pattern

Similar to compartments in a ship, the bulkhead pattern isolates different services to prevent failures from affecting the entire system.

If one service encounters an issue, it won’t compromise others. By creating boundaries, this pattern enhances the resilience of the system, ensuring that a failure in one area doesn’t lead to a total system breakdown.

8. API Composition Pattern

When you need to gather data from multiple microservices, the API composition pattern helps you do so efficiently.

A separate service (the composition service) collects responses from various services and combines them into a single response for the client. This reduces the need for clients to make multiple requests and simplifies their interaction with the system.

9. CQRS Design Pattern

CQRS Design Pattern divides the way data is handled into two parts: commands and queries. Commands are used to change data, like creating or updating records, while queries are used just to fetch data. This separation allows you to tailor each part for its specific purpose.

Real-World Example of Microservices

nderstand the Microservices using the real-world example of Amazon E-Commerce Application:

Amazon’s online store runs on many small, specialized microservices, each handling a specific task. Working together, they create a smooth shopping experience.

The microservices involved in Amazon E-commerce Application:

• User Service: Handles user accounts and preferences, making sure each person has a personalized experience.
• Search Service: Helps users find products quickly by organizing and indexing product information.
• Catalog Service: Manages the product listings, ensuring all details are accurate and easy to access.
• Cart Service: Lets users add, remove, or change items in their shopping cart before checking out.
• Wishlist Service: Allows users to save items for later, helping them keep track of products they want.
• Order Taking Service: Processes customer orders, checking availability and validating details.
• Order Processing Service: Oversees the entire fulfillment process, working with inventory and shipping to get orders delivered.
• Payment Service: Manages secure transactions and keeps track of payment details.
• Logistics Service: Coordinates everything related to delivery, including shipping costs and tracking.
• Warehouse Service: Keeps an eye on inventory levels and helps with restocking when needed.
• Notification Service: Sends updates to users about their orders and any special offers.
• Recommendation Service: Suggests products to users based on their browsing and purchase history

Migrating from Monolithic to Microservices Architecture

Below are the main the key steps to migrate from a monolithic to microservices architecture:

• Step 1: Begin by evaluating your current monolithic application. Identify its components and determine which parts can be shifted to microservices.
• Step 2: Break down the monolith into specific business functions. Each microservice should represent a distinct capability that aligns with your business needs.
• Step 3: Implement the Strangler Pattern to gradually replace parts of the monolithic application with microservices. This method allows for a smooth migration without a complete transition at once.
• Step 4: Establish clear APIs and contracts for your microservices. This ensures they can communicate effectively and interact seamlessly.
• Step 5: Create Continuous Integration and Continuous Deployment (CI/CD) pipelines. This automates testing and deployment, enabling faster and more reliable releases.
• Step 6: Introduce mechanisms for service discovery so that microservices can dynamically locate and communicate with each other, enhancing flexibility.
• Step 7: Set up centralized logging and monitoring tools. This provides insights into the performance of your microservices, helping to identify and resolve issues quickly.
• Step 8: Ensure consistent management of cross-cutting concerns, such as security and authentication, across all microservices to maintain system integrity.
• Step 9: Take an iterative approach to your microservices architecture. Continuously refine and expand your services based on feedback and changing requirements

Challenges

While microservices provide many benefits, they also introduce certain complexities that organizations must manage carefully.

• Managing service communication, network latency, and data consistency can be difficult.
• Decomposing an app into microservices adds complexity in development, testing and deployment.
• Network communication can lead to higher latency and complicates error handling.
• Maintaining consistent data across services is challenging, and distributed transactions can be complex.

Microservices Vs Monolithic Architecture

Below is a tabular comparison between microservices and monolithic architecture across various aspects: