What are Microservices?

Microservices are an architectural approach to developing software applications as a collection of small, independent services that communicate with each other over a network.

• Instead of building a monolithic application where all the functionality is tightly integrated into a single codebase, microservices break down the application into smaller, loosely coupled services.
• 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.

How do Microservices work?

• 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.
• Different technologies can be used for each service, enabling teams to select the best tools for their needs.
• Microservices can be updated independently, reducing risks during changes and enhancing system resilience.

Main components of Microservices Architecture

Main components of microservices architecture include:

• Microservices: Small, loosely coupled services that handle specific business functions, each focusing on a distinct capability.
• API Gateway: Acts as a central entry point for external clients also they manage requests, authentication and route the requests to the appropriate microservice.
• Service Registry and Discovery: Keeps track of the locations and addresses of all microservices, enabling them to locate and communicate with each other dynamically.
• Load Balancer: Distributes incoming traffic across multiple service instances and prevent any of the microservice from being overwhelmed.
• Containerization: Docker encapsulate microservices and their dependencies and orchestration tools like Kubernetes manage their deployment and scaling.
• Event Bus/Message Broker: Facilitates communication between microservices, allowing pub/sub asynchronous interaction of events between components/microservices.
• Database per Microservice: Each microservice usually has its own database, promoting data autonomy and allowing for independent management and scaling.
• Caching: Cache stores frequently accessed data close to the microservice which improved performance by reducing the repetitive queries.
• Fault Tolerance and Resilience Components: Components like circuit breakers and retry mechanisms ensure that the system can handle failures gracefully, maintaining overall functionality.

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

Let's understand the Miscroservices 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.

Below are 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

How to migrate 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

Applications of Microservices

• E-commerce platforms: Separate services for inventory, payments, orders, and user management.
• Banking & FinTech: Independent services for accounts, transactions, fraud detection, and customer support.
• Streaming services (e.g. Netflix, Spotify): Services for user profiles, recommendations, content delivery, and billing.
• Travel & Booking systems: Services for flights, hotels, payments, and notifications.
• Healthcare systems: Patient records, appointment scheduling, billing, and reporting as separate services.
• Social media platforms: Microservices for feed, chat, notifications, and user profiles.

Benefits and Challenges of using Microservices Architecture

Benefits of Using Microservices Architecture

• Teams can work on different microservices simultaneously.
• Issues in one service do not impact others, enhancing reliability.
• Each service can be scaled based on its specific needs.
• The system can quickly adapt to changing workloads.
• Teams can choose the best tech stack for each microservice.
• Small, cross-functional teams work independently.

Challenges of using Microservices Architecture

• 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:

What are Microservices?

Visit Course