what are the top design principles that you pay attention to while building any microservice?

Microservice Compages and its 10 Near Important Blueprint Patterns

Microservice Architecture, Database per Microservice, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalize Configuration, Consumer-Driven Contract Testing

Paradigm by msandersmusic from Pixabay

Tackling complexity in big Software Systems was ever a daunting job since the early on days of Software development (1960's). Over the years, Software Engineers and Architects made many attempts to tackle the complexities of Software Systems: Modularity and Data Hiding by David Parnas (1972), Separation of Concern by Edsger Westward. Dijkstra (1974) , Service Oriented Architecture (1998).

All of them used the historic period-old and proven technique to tackle the complexity of a large system: divide and conquer. Since the 2010s, those techniques proved bereft to tackle the complexities of Spider web-Calibration applications or modern large-calibration Enterprise applications. As a result, Architects and Engineers developed a new approach to tackle the complexity of Software Systems in modern times: Microservice Compages. It also uses the same old "Carve up and Conquer" technique, admitting in a novel manner.

Software Design Patterns are general, reusable solutions to the commonly occurring problem in Software Design. Blueprint Patterns help u.s. share a common vocabulary and utilise a boxing-tested solution instead of reinventing the bicycle. In a previous commodity: Effective Microservices: 10 All-time Practices, I have described a prepare of best practices to develop Constructive Microservices. Here, I volition depict a prepare of Design Patterns to help y'all implement those best practices. If you are new to Microservice Architecture, then no worries, I will introduce yous to Microservice Compages.

By reading this article, y'all will learn:

• Microservice Architecture
• Advantages of Microservice Compages
• Disadvantages of Microservice Architecture
• When to utilize Microservice Architecture
• The Most important Microservice Compages Design Patterns, including their advantages, disadvantages, utilize cases, Context, Tech Stack instance, and useful resources.

Delight note that most of the Design Patterns of this listing have several contexts and can be used in non-Microservice Architecture. But I will depict them in the context of Microservice Architecture.

Microservice Compages

I have covered Microservice Architecture in details in my previous Blog Posts: Microservice Architecture: A brief overview and why you should use it in your next project and Is Modular Monolithic Software Architecture Really Dead? . If you are interested, then you can read them to accept a deeper look.

What is a Microservice Architecture. There are many definitions of Microservice Architecture. Here is my definition:

Microservice Compages is about splitting a large, complex systems vertically (per functional or business requirements) into smaller sub-systems which are processes (hence independently deployable) and these sub-systems communicates with each other via lightweight, language-agnostic network calls either synchronous (e.g. Residual, gRPC) or asynchronous (via Messaging) mode.

Hither is the Component View of a Business organisation Web Application with Microservice Architecture:

Microservice Architecture past Doc Kamaruzzaman

Of import Characteristics of Microservice Architecture:

• The whole application is split into separate processes where each procedure can contain multiple internal modules.
• Contrary to Modular Monoliths or SOA, a Microservice application is divide vertically (co-ordinate to business organization capability or domains)
• The Microservice boundary is external. As a outcome, Microservices communicates with each other via network calls (RPC or bulletin).
• As Microservices are independent processes, they can be deployed independently.
• They communicate in a lightweight way and don't need any smart Advice channel.

Advantages of Microservice Architecture:

• Better development scaling.
• College development velocity.
• Supports iterative or incremental modernization.
• Take reward of the mod Software Development Ecosystem (Deject, Containers, DevOps, Serverless).
• Supports horizontal scaling and granular scaling.
• It puts low cognitive complexity on the programmer's caput thanks to its smaller size.

Disadvantages of Microservice Compages:

• A higher number of Moving parts (Services, Databases, Processes, Containers, Frameworks).
• Complexity moves from Lawmaking to the Infrastructure.
• The proliferation of RPC calls and network traffic.
• Managing the security of the complete system is challenging.
• Designing the entire system is harder.
• Innovate complexities of Distributed Systems.

When to use Microservice Architecture:

• Spider web-Scale Application development.
• Enterprise Application development when multiple teams work on the application.
• Long-term gain is preferred over brusque-term gain.
• The team has Software Architects or Senior Engineers capable of designing Microservice Compages.

Design Patterns for Microservice Architecture

Database per Microservice

One time a company replaces the large monolithic system with many smaller microservices, the nearly important decision it faces is regarding the Database. In a monolithic compages, a large, central database is used. Many architects favor keeping the database as it is, even when they movement to microservice compages. While it gives some short-term do good, information technology is an anti-pattern, specially in a large-scale system, equally the microservices will be tightly coupled in the database layer. The whole object of moving to microservice will fail (e.g., team empowerment, independent development).

A better approach is to provide every Microservice its ain Data store, so that at that place is no strong-coupling betwixt services in the database layer. Hither I am using the term database to show a logical separation of data, i.e., the Microservices can share the same physical database, but they should use separate Schema/collection/tabular array. It will as well ensure that the Microservices are correctly segregated according to the Domain-Driven-Design.

Database per Microservice by Md Kamaruzzaman

Pros

• Consummate ownership of Information to a Service.
• Loose coupling amidst teams developing the services.

Cons

• Sharing data among services becomes challenging.
• Giving application-wide ACID transactional guarantee becomes a lot harder.
• Decomposing the Monolith database to smaller parts demand conscientious design and is a challenging job.

When to employ Database per Microservice

• In big-calibration enterprise applications.
• When the team needs complete ownership of their Microservices for evolution scaling and development velocity.

When not to apply Database per Microservice

• In minor-calibration applications.
• If ane team develops all the Microservices.

Enabling Engineering Examples

All SQL, NoSQL databases offer logical separation of data (e.g., divide tables, collections, schemas, databases).

Further Reading

Effect Sourcing

In a Microservice Architecture, especially with Database per Microservice, the Microservices need to commutation data. For resilient, highly scalable, and fault-tolerant systems, they should communicate asynchronously by exchanging Events. In such a example, you may want to have Atomic operations, east.g., update the Database and send the message. If you have SQL databases and desire to have distributed transactions for a high volume of data, y'all cannot use the two-phase locking (2PL) as it does not calibration. If yous use NoSQL Databases and desire to have a distributed transaction, you cannot use 2PL as many NoSQL databases exercise not back up 2-phase locking.

In such scenarios, employ Event based Architecture with Event Sourcing. In traditional databases, the Business Entity with the current "state" is directly stored. In Effect Sourcing, any state-irresolute issue or other significant events are stored instead of the entities. It ways the modifications of a Concern Entity is saved as a series of immutable events. The State of a Business entity is deducted by reprocessing all the Events of that Business entity at a given time. Because data is stored as a series of events rather than via direct updates to data stores, various services tin replay events from the event store to compute the appropriate state of their corresponding data stores.

Event Sourcing past Md Kamaruzzaman

Pros

• Provide atomicity to highly scalable systems.
• Automatic history of the entities, including time travel functionality.
• Loosely coupled and event-driven Microservices.

Cons

• Reading entities from the Event store becomes challenging and usually demand an additional data store (CQRS pattern)
• The overall complexity of the system increases and usually need Domain-Driven Blueprint.
• The system needs to handle duplicate events (idempotent) or missing events.
• Migrating the Schema of events becomes challenging.

When to use Event Sourcing

• Highly scalable transactional systems with SQL Databases.
• Transactional systems with NoSQL Databases.
• Highly scalable and resilient Microservice Architecture.
• Typical Message Driven or Event-Driven systems (e-commerce, booking, and reservation systems).

When not to apply Event Sourcing

• Lowly scalable transactional systems with SQL Databases.
• In elementary Microservice Architecture where Microservices tin commutation data synchronously (due east.g., via API).

Enabling Technology Examples

Consequence Store: EventStoreDB, Apache Kafka, Confluent Cloud, AWS Kinesis, Azure Event Hub, GCP Pub/Sub, Azure Cosmos DB, MongoDB, Cassandra. Amazon DynamoDB,

Frameworks: Lagom, Akka, Spring, akkatecture, Axon, Eventuate

Further Reading

Command Query Responsibility Segregation (CQRS)

If we use Event Sourcing, so reading data from the Upshot Shop becomes challenging. To fetch an entity from the Data store, we demand to process all the entity events. Too, sometimes we accept different consistency and throughput requirements for reading and write operations.

In such apply cases, nosotros can apply the CQRS design. In the CQRS blueprint, the system'due south information modification office (Command) is separated from the data read (Query) part. CQRS pattern has two forms: elementary and avant-garde, which pb to some confusion among the software engineers.

In its simple form, distinct entity or ORM models are used for Reading and Write, as shown below:

CQRS (uncomplicated) by Medico Kamaruzzaman

Information technology helps to enforce the Single Responsibleness Principle and Separation of Business organisation, which pb to a cleaner design.

In its advanced class, different data stores are used for reading and write operations. The advanced CQRS is used with Issue Sourcing. Depending on the use case, different types of Write Data Store and Read Data store are used. The Write Data Store is the "System of Records," i.e., the entire system'southward golden source.

CQRS (advanced) past Md Kamaruzzaman

For the Read-heavy applications or Microservice Compages, OLTP database (any SQL or NoSQL database offering ACID transaction guarantee) or Distributed Messaging Platform is used as Write Store. For the Write-heavy applications (high write scalability and throughput), a horizontally write-scalable database is used (public cloud global Databases). The normalized data is saved in the Write Data Store.

NoSQL Database optimized for searching (e.grand., Apache Solr, Elasticsearch) or reading (Key-Value data store, Document Data Store) is used as Read Store. In many cases, read-scalable SQL databases are used where SQL query is desired. The denormalized and optimized data is saved in the Read Store.

Data is copied from the Write shop to the read store asynchronously. As a result, the Read Store lags the Write store and is Eventual Consistent.

Pros

• Faster reading of information in Upshot-driven Microservices.
• High availability of the information.
• Read and write systems tin scale independently.

Cons

• Read information store is weakly consistent (eventual consistency)
• The overall complexity of the organization increases. Cargo culting CQRS can significantly jeopardize the complete project.

When to use CQRS

• In highly scalable Microservice Architecture where consequence sourcing is used.
• In a complex domain model where reading data needs query into multiple Data Store.
• In systems where read and write operations accept a dissimilar load.

When not to apply CQRS

• In Microservice Architecture, where the volume of events is insignificant, taking the Result Store snapshot to compute the Entity country is a better pick.
• In systems where read and write operations have a similar load.

Enabling Technology Examples

Write Store: EventStoreDB, Apache Kafka, Confluent Cloud, AWS Kinesis, Azure Consequence Hub, GCP Pub/Sub, Azure Cosmos DB, MongoDB, Cassandra. Amazon DynamoDB

Read Shop: Elastic Search, Solr, Cloud Spanner, Amazon Aurora, Azure Cosmos DB, Neo4j

Frameworks: Lagom, Akka, Spring, akkatecture, Axon, Eventuate

Farther Reading

Saga

If you use Microservice Architecture with Database per Microservice, then managing consistency via distributed transactions is challenging. You cannot apply the traditional Ii-phase commit protocol as it either does not calibration (SQL Databases) or is non supported (many NoSQL Databases).

You lot can use the Saga design for distributed transactions in Microservice Architecture. Saga is an old pattern adult in 1987 every bit a conceptual culling for long-running database transactions in SQL databases. But a modern variation of this design works amazingly for the distributed transaction too. Saga pattern is a local transaction sequence where each transaction updates information in the Data Store within a single Microservice and publishes an Issue or Message. The first transaction in a saga is initiated by an external request (Result or Action). In one case the local transaction is complete (information is stored in Information Shop, and message or event is published), the published message/event triggers the adjacent local transaction in the Saga.

Saga by Md Kamaruzzaman

If the local transaction fails, Saga executes a series of compensating transactions that undo the preceding local transactions' changes.

There are mainly ii variations of Saga transactions co-ordinations:

• Choreography: Decentralised co-ordinations where each Microservice produces and listen to other Microservice'southward events/messages and decides if an action should be taken or not.
• Orchestration: Centralised co-ordinations where an Orchestrator tells the participating Microservices which local transaction needs to exist executed.

Pros

• Provide consistency via transactions in a highly scalable or loosely coupled, result-driven Microservice Compages.
• Provide consistency via transactions in Microservice Compages where NoSQL databases without 2PC support are used.

Cons

• Demand to handle transient failures and should provide idempotency.
• Hard to debug, and the complication grows as the number of Microservices increase.

When to utilise Saga

• In highly scalable, loosely coupled Microservice Compages where event sourcing is used.
• In systems where distributed NoSQL databases are used.

When not to use Saga

• Lowly scalable transactional systems with SQL Databases.
• In systems where circadian dependency exists amongst services.

Enabling Applied science Examples

Axon, Eventuate, Narayana

Farther Reading

Backends for Frontends (BFF)

In modern business application developments and especially in Microservice Compages, the Frontend and the Backend applications are decoupled and separate Services. They are connected via API or GraphQL. If the awarding also has a Mobile App client, then using the same backend Microservice for both the Web and the Mobile customer becomes problematic. The Mobile client's API requirements are usually different from Web client as they have different screen size, display, performance, energy source, and network bandwidth.

Backends for Frontends pattern could be used in scenarios where each UI gets a split backend customized for the specific UI. It also provides other advantages, like acting as a Facade for downstream Microservices, thus reducing the chatty communication between the UI and downstream Microservices. Likewise, in a highly secured scenario where downstream Microservices are deployed in a DMZ network, the BFF's are used to provide higher security.

Backends for Frontends by Dr. Kamaruzzaman

Pros

• Separation of Concern between the BFF'south. We tin can optimize them for a specific UI.
• Provide college security.
• Provide less chatty communication between the UI'southward and downstream Microservices.

Cons

• Code duplication among BFF's.
• The proliferation of BFF'due south in case many other UI's are used (due east.g., Smart Television, Spider web, Mobile, Desktop).
• Demand conscientious design and implementation every bit BFF's should non contain any business organization logic and should but contain client-specific logic and behavior.

When to use Backends for Frontends

• If the awarding has multiple UIs with different API requirements.
• If an extra layer is needed between the UI and Downstream Microservices for Security reasons.
• If Micro-frontends are used in UI evolution.

When non to use Backends for Frontends

• If the application has multiple UI, but they consume the aforementioned API.
• If Cadre Microservices are not deployed in DMZ.

Enabling Technology Examples

Any Backend frameworks (Node.js, Spring, Django, Laravel, Flask, Play, …..) supports it.

Further Reading

API Gateway

In Microservice Architecture, the UI unremarkably connects with multiple Microservices. If the Microservices are finely grained (FaaS), the Client may need to connect with lots of Microservices, which becomes communicative and challenging. Also, the services, including their APIs, tin evolve. Large enterprises will like to have other cross-cutting concerns (SSL termination, hallmark, authorization, throttling, logging, etc.).

I possible fashion to solve these issues is to employ API Gateway. API Gateway sits between the Client APP and the Backend Microservices and acts as a facade. It can work as a reverse proxy, routing the Client request to the appropriate Backend Microservice. It can also back up the client request's fanning-out to multiple Microservices and and so return the aggregated responses to the Client. It additionally supports essential cross-cutting concerns.

API Gateway by Dr. Kamaruzzaman

Pros

• Offer loose coupling betwixt Frontend and backend Microservices.
• Reduce the number of round trip calls between Client and Microservices.
• Loftier security via SSL termination, Authentication, and Authorization.
• Centrally managed cross-cutting concerns, e.g., Logging and Monitoring, Throttling, Load balancing.

Cons

• Can lead to a unmarried point of failure in Microservice Compages.
• Increased latency due to the actress network telephone call.
• If it is not scaled, they tin hands become the bottleneck to the whole Enterprise.
• Additional maintenance and development cost.

When to employ API Gateway

• In circuitous Microservice Architecture, information technology is about mandatory.
• In big Corporations, API Gateway is compulsory to centralize security and cantankerous-cut concerns.

When not to utilize API Gateway

• In private projects or small companies where security and fundamental management is not the highest priority.
• If the number of Microservices is fairly small-scale.

Enabling Technology Examples

Amazon API Gateway, Azure API Management, Apigee, Kong, WSO2 API Manager

Further Reading

Strangler

If nosotros want to use Microservice Architecture in a brownfield project, we need to drift legacy or existing Monolithic applications to Microservices. Moving an existing, large, in-production Monolithic applications to Microservices is quite challenging equally it may disrupt the application'due south availability.

One solution is to utilise the Strangler blueprint. Strangler pattern means incrementally migrating a Monolithic application to Microservice Architecture past gradually replacing specific functionality with new Microservices. Too, new functionalities are just added in Microservices, bypassing the legacy Monolithic awarding. A Facade (API Gateway) is and then configured to route the requests betwixt the legacy Monolith and Microservices. One time the functionality is migrated from the Monolith to Microservices, the Facade and so intercepts the client asking and route to the new Microservices. In one case all the legacy monolith's functionalities are migrated, the legacy Monolithic application is "strangled," i.east., decommissioned.

Strangler by Md Kamaruzzaman

Pros

• Condom migration of Monolithic application to Microservices.
• The migration and new functionality development tin go in parallel.
• The migration process can have its ain footstep.

Cons

• Sharing Information Store between the existing Monolith and new Microservices becomes challenging.
• Calculation a Facade (API Gateway) volition increment the system latency.
• End-to-finish testing becomes hard.

When to use Strangler

• Incremental migration of a large Backend Monolithic application to Microservices.

When not to use Strangler

• If the Backend Monolith is small, then wholesale replacement is a better option.
• If the client asking to the legacy Monolithic application cannot be intercepted.

Enabling Technology

Backend application frameworks with API Gateway.

Further Reading

Circuit Billow

In Microservice Architecture, where the Microservices communicates Synchronously, a Microservice ordinarily calls other services to fulfill business requirements. Call to some other service can fail due to transient faults (slow network connection, timeouts, or temporal unavailability). In such cases, retrying calls can solve ready the issue. Still, if there is a astringent consequence (complete failure of the Microservice), then the Microservice is unavailable for a longer time. Retrying is pointless and wastes precious resources (thread is blocked, waste matter of CPU cycles) in such scenarios. Also, the failure of one service might lead to cascading failures throughout the application. In such scenarios, fail immediately is a better approach.

The Circuit Breaker pattern can come to the rescue for such use cases. A Microservice should request some other Microservice via a proxy that works similarly to an Electrical Circuit Billow. The proxy should count the number of recent failures that have occurred and utilise it to determine whether to let the operation to go along or simply return an exception immediately.

Circuit Billow by Md Kamaruzzaman

The Circuit Billow can have the following iii states:

• Closed: The Circuit Breaker routs requests to the Microservice and counts the number of failures in a given menstruation of fourth dimension. If the number of failures in a certain catamenia of time exceeds a threshold, it then trips and goes to Open Land.
• Open: Request from the Microservice fails immediately, and an exception is returned. Later on a timeout, the Circuit Billow goes to a Half-Open state.
• One-half-Open: Only a express number of requests from the Microservice are allowed to pass through and invoke the operation. If these requests are successful, the circuit billow goes to a Closed state. If any asking fails, the Circuit Breaker goes to Open up land.

Pros

• Ameliorate the fault-tolerance and resilience of the Microservice Compages.
• Stops the cascading of failure to other Microservices.

Cons

• Need sophisticated Exception treatment.
• Logging and Monitoring.
• Should support manual reset.

When to utilize Circuit Billow

• In tightly coupled Microservice Architecture where Microservices communicates Synchronously.
• If i Microservice has a dependency on multiple other Microservices.

When not to utilize Circuit Breaker

• Loosely coupled, event-driven Microservice Compages.
• If a Microservice has no dependency on other Microservices.

Enabling Engineering

API Gateway, Service Mesh, various Circuit Breaker Libraries (Hystrix, Reselience4J, Polly.

Further Reading

Externalized Configuration

Every business organisation Application has many configuration parameters for various Infrastructure (due east.g., Database, Network, connected Service addresses, credentials, document path). Also, in an enterprise surroundings, the application is normally deployed in diverse runtimes (Local, Dev, Prod). I fashion to attain this is via the Internal Configuration, which is a fatal bad practice. It tin can lead to astringent security adventure as product credentials can hands be compromised. Also, whatsoever change in configuration parameter needs to rebuild the Application. This is even more critical in Microservice Architecture as we potentially accept hundreds of services.

The better approach is to externalize all the Configurations. As a result, the build procedure is separated from the runtime environment. Also, it minimizes the security gamble as the Production configuration file is simply used during runtime or via environment variables.

Pros

• Product configurations are not part of the Codebase and thus minimize security vulnerability.
• Configuration parameters can be changed without a new build.

Cons

• We need to choose a framework that supports the Externalized Configuration.

When to use Externalized Configuration

• Any serious production application must use Externalized Configuration.

When non to apply Externalized Configuration

• In proof of concept development.

Enabling Technology

Almost all enterprise-form, modern frameworks support Externalized Configuration.

Farther Reading

Consumer-Driven Contract Testing

In Microservice Architecture, in that location are many Microservices often developed by dissever teams. These microservices work together to fulfill a business organisation requirement (e.grand., customer request) and communicate with each other Synchronously or Asynchronously. Integration testing of a Consumer Microservice is challenging. Ordinarily, TestDouble is used in such scenarios for a faster and cheaper test run. But TestDouble often does not represent the real Provider Microservice. Also, if the Provider Microservice changes its API or Bulletin, then TestDouble fails to acknowledge that. The other option is to make cease-to-finish testing. While end-to-cease testing is mandatory earlier production, information technology is brittle, wearisome, expensive, and is no replacement for Integration testing (Test Pyramid).

Consumer-Driven contract testing can help us in this regard. Hither, the Consumer Microservice possessor team write a test suite containing its Request and expected Response (for Synchronous advice) or expected letters (for Asynchronous communication) for a item Provider Microservice. These exam suites are called explicit Contracts. For a Provider Microservice, all the Contract test suites of its Consumers are added in its automated test. When the automated test for a item Provider Microservice is performed, it runs its own tests and the Contracts and verifies the Contract. In such a way, the contract test tin can help maintain the integrity of the Microservice Communication in an automated manner.

Pros

• If the Provider changes the API or Message unexpectedly, it is found apart in a brusk time.
• Less surprise and more robustness, especially an enterprise application containing lots of Microservices.
• Improved team autonomy.

Cons

• Demand extra work to develop and integrate Contract tests in Provider Microservice as they may use completely different test tools.
• If the Contract examination does not match real Service consumption, information technology may lead to production failure.

When to apply Consumer-Driven Contract Testing

• In large-scale enterprise business applications, where typically, different teams develop different services.

When non to use Consumer-Driven Contract Testing

• Relative simpler, smaller applications where one squad develops all the Microservices.
• If the Provider Microservices are relatively stable and not under active development.

Enabling Technology

Pact, Postman, Leap Deject Contract

Further Reading

Conclusion

In the modern large-scale enterprise Software evolution, Microservice Compages can help development scaling with many long-term benefits. But Microservice Architecture is no Silver Bullet that can be used in every use case. If it is used in the incorrect type of application, Microservice Architecture can requite more than pains as gains. The development team that wants to adopt Microservice Compages should follow a prepare of best practices and use a set of reusable, boxing-hardened design patterns.

The most vital design pattern in Microservice Architecture is the Database per Microservice. Implementing this design pattern is challenging and needs several other closely related design patterns (Event Sourcing, CQRS, Saga). In typical business applications with multiple Clients (Web, Mobile, Desktop, Smart Devices), the communications between Client and Microservices can be chatty and may require Central command with added Security. The design patterns Backends for Frontends and API Gateway are very useful in such scenarios. Also, the Circuit Breaker pattern can greatly aid to handle error scenarios in such applications. Migrating legacy Monolithic application to Microservices is quite challenging, and the Strangler blueprint can help the migration. The Consumer-Driven Contract Examination is an instrumental pattern for the Integration Testing of Microservices. At the same fourth dimension, Externalize Configuration is a mandatory pattern in whatever modern awarding development.

This listing is not all-inclusive, and depending on your use instance, you may need other blueprint patterns. But this list will give you an fantabulous introduction to Microservice Architecture Design Patterns.

Similar Articles

mccarthyowery1942.blogspot.com

Source: https://towardsdatascience.com/microservice-architecture-and-its-10-most-important-design-patterns-824952d7fa41

Share this post