In recent years, there’s been quite a buzz around so-called microservices, also known as microservices architecture. And this truly doesn’t come as a surprise. With software applications becoming increasingly complex, they have also become bulkier and more difficult to manage, update, and maintain. Microservices architecture is a relatively new software development approach that addresses this problem by splitting up complex software into independent building blocks or services. These modular services can be deployed and managed individually, making large applications more robust to change.
Microservices as an architectural style dates back to 2005 when Peter Rodgers, the originator of Resource Oriented Computing, first coined the term “Micro-Web-Services”. In an attempt to create a more flexible and service-oriented software architecture, he successfully outlined the principles of a well-designed microservices platform. Two years later, software architect Juval Löwy expanded on the idea of a granular use of services and inspired several expert-led case studies with promising outcomes. Today, microservices architecture is not only considered a hot topic but the future of efficient software development and maintenance.
Microservices architecture describes a particular style in which software applications are designed. In contrast to traditional architectural styles that aim to build a software like a single unit, microservices architecture is based on a modular approach. Thus, applications are developed as suites consisting of multiple microservices that can be independently deployed and managed. But what are microservices exactly? Even though there is no clear definition for microservices per se, there are certain characteristics that are associated with this revolutionary software development approach.
One of the main characteristics is the way the architectural style componentizes a complex application. The software is broken down into multiple components that are built as independently replaceable and upgradeable services. These services can be defined as processes that often communicate over a network using protocols that are technology-agnostic. Microservices are also built to suit business capabilities. And since they are decentralized and small in size, they offer a lot of flexibility when it comes to programming languages, hardware, and software environment.
The idea of loosely coupled services that are highly maintainable and testable sounds intriguing to companies that face IT challenges due to complex applications. But before uprooting the system in place, it is vital to understand how microservices actually work. In order to create a functioning modular architecture, a business needs to first identify its capabilities and define the services that will run independently from each another. A microservice architecture diagram is needed to expose dependencies that would inhibit the flexibility of each service. It is critical to ensure that an error in an individual part wouldn’t impact the whole system.
But even though microservices are designed to work independently, they sometimes still have dependencies on other microservices and need to communicate with each other. This communication occurs through the use of APIs (Application Programming Interfaces); synchronous or asynchronous protocols like HTTP/REST or AMQP. Ideally, each microservice has its own database in order to decentralize responsibility and manage updates individually. When using the “Database per Service” pattern, a saga, which is a transaction that spans multiple services, is put in place in order to maintain data consistency.
However, it is not uncommon that each microservice develops more and more service dependencies over time. This is a normal occurrence once services begin to grow and start affecting the number of instances, locations, and protocols. API gateways help avoid problems that arise from these changes. And this is how it works: An API gateway takes all API requests and then routes every single one to the most appropriate microservice. It also invokes backend services and aggregates the results to identify the best path. It serves as the entry point for every request, organizes all input, and creates a simplified user experience.
There are a number of benefits microservices can offer a company. After all, big data applications are all the rage and call for a software architecture that best suits the needs of business operations, the developing team, and end-user. The ten main advantages of a microservices architecture are outlined below:
Switching from traditional software architecture to a new architectural style can seem intimidating at first. However, since microservices architecture has already been tried and tested by other companies – more concrete examples later on – there are some best practices that have emerged over the past decade or so.
But before getting started, it’s important to remember that each microservice can be developed in a different programming language and technology. Thus, the technology for implanting individual services is far less important than the overarching technologies for integration and communication.
Getting on the same page: When transitioning to a microservices architecture, every team involved needs to be thoroughly prepared. Ultimately, this architectural style is not just about splitting up one big application, but it entails a shift in company culture and mentality. Each team needs to be truly independent and at the same time, communication standards, shared API documentation, and logging formats are absolutely essential for successful execution.
Defining the target architecture: Microservices architecture is designed to make a company’s software landscape less complex. But if it isn’t designed or managed properly, it can create more complexity or even chaos. Before starting out with microservices, it’s crucial to define what the target architecture should look like. Eliminating contradicting dependencies and making sure data remains consistent across all microservices is key. A network upgrade might be necessary to avoid traffic between the services.
Never stop monitoring: Breaking up one large application into multiple individual applications means that each and every single one of them produces a large number of logs that need to be analyzed. That’s why it’s important to draw out a clear-cut plan for monitoring the individual microservices on a regular basis through response time or service error notifications. Dashboards, logs as well as monitoring and cloud intelligence tools facilitate these tasks and create a much-needed overview.
In 2009, tech giant Netflix pioneered microservices architecture by breaking away from a traditional monolith architecture. In fact, this was one of the deciding factors that paved the way for the platform’s phenomenal growth: Microservices minimized the risk of server outages and allowed developers to fix small components of code without affecting the frontend interface. So it really isn’t surprising that other companies followed Netflix’ lead:
20 Key Questions a Microservice Catalog Answers
Download this LeanIX poster to see the 20 key questions a microservice catalog can answer.
Microservices – the good, the not so good, and the ugly
Live Recording - EA Connect Day 2020
Ramesh Nagamalli - Senior Key Expert - Siemens
Microservices @ LeanIX - then, now and tomorrow
Live Recording - EA Connect Day 2020
Per Bernhardt - Staff Software Engineer - LeanIX
How NÜRNBERGER Established Transparency Across its Microservice Landscape
“The transparency created by Microservice Intelligence helps us to efficiently implement our cloud migration strategy.”
Even though microservices architecture and service-oriented architecture (SOA) have some things in common, there are quite a few differences in the architectural pattern and approach. Both microservices and SOA use services as architectural elements that communicate through protocols over a network. However, while data storage is shared among all services in SOA, each service has its own database in the microservices approach. Microservices are also significantly smaller in size and scope and are independently deployable. In SOA, the enterprise service bus (ESP) that provides point-to-point connections between services could potentially cause an entire system failure. However, it’s important to note that SOA can also be designed in a monolith pattern.
Monolithic architecture can be considered the counterpart to microservices architecture. It is the most traditional approach in software development where an application is designed as one single unit vs. loosely coupled units, the main characteristic of microservices architecture. A monolithic software consists of one database, a user interface, and a server-side application, and is therefore a single logical executable. This also means that one failure can affect the entire system and development teams need to deploy a new version of the server-side application whenever alterations are made. Microservices eradicate these problems by being small, functional stand-alone applications that can be managed and updated independently.
When talking about microservices, it’s only a matter of time until APIs are mentioned. But what are APIs exactly and how do they differ from microservices? API stands for application programming interface and can be seen as a contract of actions that are requested from a particular service. Microservices architecture on the other hand is a software development technique while a microservice can be defined as a small self-contained application. APIs are an important portion of a microservices architecture. They allow the different services to communicate with each other through standardized protocols as well as direct interaction with the service itself.
While the governance of monolithic systems is centralized, microservices governance is completely decentralized and therefore needs proper governance mechanisms. Thus, many companies use the open-source container-orchestration system Kubernetes for hosting their microservice-based implementation.
Originally designed by Google, it was built to provide a flexible platform and CI tools for efficient microservices governance. But what does that look like in practice? Kubernetes enables users to containerize applications so they can integrate them into a cluster environment. One container comprises all the packages that are necessary for running a service. That way, microservices are much easier to configure, scale, and deploy.
There are many reasons why more and more companies see the need to switch over to a microservices architecture. One of them is directly linked to the uncoupling of services by resorting to cloud service providers. And not to forget, the difficulties of maintaining an ever-growing monolithic software bears debilitating risks and can significantly hamper business growth and success. However, it is important to remember that a transition to microservices needs to be well-thought-out. After all, a successful execution doesn’t lie in every single service but the overarching technologies and tools that are used for governance, integration, and communication.
Learn more about
20 essential questions that a microservice catalog can answer.
Cataloging microservices helps DevOps teams to visualize their microservice landscape including details on ownership, dependencies, and business context.
Here are 20 essential questions that a microservice catalog can answer.
Learn more about a microservice catalog.
What are examples of Microservices?
What is the difference between API and Microservices?