An approach to software engineering that is more than the sum of its parts, microservices are modular and easy to build and maintain.
Microservices is a way of building software that sees an application created as a collection of individual services. A microservices architecture is fundamentally modular - it breaks down applications into small component functions which are built and managed individually. This is in direct contrast to monolithic architectures, where software is created as one large, complex service.
A good example of microservices in context is a consumer website with different functions such as search, payment and user login. With a microservices approach, these component parts are all built independently. Each service fulfils a single purpose, and they all communicate with each other to provide a unified experience for the end user.
There are several benefits to microservices.
Firstly, the focus on keeping microservices small increases technical agility. Necessary upgrades as part of maintenance or the adoption of new tools and languages can be done in a careful, piecemeal way, rather than risking the stability of the entire system. Developers can use specialised tools to build each component, and if an issue arises in one area it does not affect the others. What's more, it's much easier to scale a service up or down if certain aspects of the application experience a spike in demand.
Finally, microservices architectures are much more flexible than their monolithic counterparts. Individual services communicate with each other in well defined ways, making it easy to add new functions in line with changes to business aims. This could be creating a whole new service internally or connecting to external partners.
It’s worth noting that a microservices approach often involves increased complexity around deployment and testing, with more analysis needed to correctly identify individual business functions. It’s therefore ideal for larger or longer term enterprise solutions.
The benefits of Microservices
- individual component parts are easier to build, test and maintain
- one service per business function
- services communicate with each other via APIs
- if one service experiences an issue it does not affect others
- scale individual services to meet demand
- modular architecture supports agility