What are microservices and what are its advantages?
A microservice is an autonomous software unit, designed to perform a specific function. They are like small pieces in a complex puzzle, each fulfilling a specific role, but all working together to create a complete picture.
Normally, when a company develops its first platform, it begins building on a monolithic architecture where all the company's services are interconnected. Features such as user management, commerce, content, search, and inventory all live on a single platform.
This approach is usually effective and straightforward for small and medium-sized enterprises. Initially, it allows the technical and operational teams to quickly and easily meet most of the business requirements.
However, as the company grows and its needs increase, this architecture becomes unsustainable. If the company needs to scale a service, it will be forced to scale the entire structure. Similarly, if changes are required in a specific service, the technical team must coordinate to make those modifications without affecting the whole system.
An architecture based on microservices can solve most of these problems.
What is a microservice?
Microservices are a type of software architecture that separates all the services of an application into small and independent modules.
Instead of having a highly coupled architecture where all services reside in a single application, it is possible to build an architecture in which each service is a separate component.
The functionalities of a platform, such as content management, user administration, order handling, payments, inventory, or search, can be decomposed into separate services. Each of these services can be developed, deployed, updated, and scaled individually without impacting the rest of the structure.
Being separate modules, the teams can work independently and in parallel to build, implement, and optimize each of the services.
Likewise, each microservice can be built with different technologies. For example, Java can be used for a service that requires high performance, Python for a service that requires complex data analysis, and Node.js for a service that requires fast user interaction. This way, an application can access the best tools for each of its functionalities.
Characteristics of microservices
We have already defined what microservices are, now let's explain their characteristics:
Autonomous and independent: the services that make up a microservice architecture can be developed, deployed, operated, and scaled without affecting the functioning of other services. Moreover, these do not need to share any of their code or implementations with other services.
Specialized: each service is designed for a set of capabilities and focuses on solving a specific problem.
Simplified: in terms of managing large enterprise applications.
Scalable: each microservice can adapt to the number of users using them without affecting the rest.
Differences between monolithic architecture and microservices
What are the differences between a monolithic architecture and one composed of microservices? We have already seen what a microservice architecture consists of, however, monolithic architecture involves a large, tightly-coupled application that runs as a single service. This means that if an application process experiences a surge in demand, the entire application must be scaled.
Maintenance or improvement of a monolithic structure becomes complex as the codebase grows, limiting the experimentation of new services. Besides, it increases the risk of application availability.
On the side of microservice architecture, we have seen that a program can be created with independent components that run a single process as an independent service, and as these communicate through a well-defined interface using APIs.
Monolith | Microservices |
|---|---|
Efficient in small and medium-sized applications | Efficient in large or enterprise applications |
As the application grows, management becomes more complex | Allows managing large applications in a simpler way |
Easy to distribute and install as it is a single package | More complex to deploy, each service must be installed separately |
Teams work within the same source code and must coordinate to avoid conflicts | Teams work in parallel and independently on different parts of an application |
The architecture is simple, all the code is in a single codebase | The architecture is complex, the code is distributed among several services |
Generally built under a single technology stack | Can be built from different technologies |
Functions as an "all-in-one" solution | Each service provides specific functionality |
Scaling a service requires scaling the entire structure | Each microservice can be scaled independently |
Microservices Communication
Each microservice has its own database and communicates with the rest using lightweight mechanisms, usually using a REST API, that is, through HTTP code (a message that a site's server sends to the browser to indicate whether a request can be fulfilled or not).
Synchronous: the exchange of information is done in real time and both microservices must be available simultaneously.
Asynchronous: allows communication even if the microservices are not available simultaneously. Also, it does not present a blockage in case one of the two microservices is saturated.
Microservices Components
The main components of a Microservices Architecture are:
Central configuration server: allows managing the configuration of all microservices from a single place. This facilitates the process of changing and updating the configuration without having to modify each microservice individually.
Service Discovery: is a system that helps microservices locate each other on the network. It is essential to ensure effective communication and cooperation between microservices.
Load Balancing: this component distributes incoming requests between different instances of a microservice. This improves efficiency and resilience by avoiding overloading a single one.
Circuit Breaker: is a design pattern that helps prevent the propagation of failures between microservices. When a failure is detected, the Circuit Breaker "opens" to stop calls to that service, thus preventing the failure from spreading.
Service Edge (or API Gateway): acts as a single point of entry to the application, routing requests to the appropriate microservice.
Centralized Logging: Since microservices can be distributed across different machines or even different geographical locations, it is important to have a centralized system to collect and analyze logs.
Authorization server: functions to implement the security layer.
Monitoring: allows keeping track of the status and performance of the microservices. This is crucial to detect and solve problems quickly and effectively.
Orchestration: coordinates interactions between microservices, especially when a task requires the cooperation of several.
Service Mesh: this component manages the communication between microservices. It can provide features such as load balancing, traffic routing, service discovery, and communication security.
Companies that use Microservices
Ebay, Amazon, and MercadoLibre are some of the companies that have large-scale applications and have decided to invest in the evolution towards microservices, where the maintenance and scalability of their products is much simpler, effective, and faster.
The most well-known example is Netflix, which uses a little over 700 microservices to control each of the many parts that make up its entire service: one microservice stores all the series that the user watches, another for payment, another provides the user's device with the videos they want to watch, another stores the viewing history, another uses recommendation algorithms, another provides names and images of movies, among many others.
Benefits of Microservices
To conclude, we must talk about one more topic, what are the benefits of using microservices:
Simple implementation: they allow continuous integration, which facilitates testing new ideas and reverting them if something doesn't work. The low cost of errors allows experimentation, facilitates code updating, and speeds up the time to market for new features.
Reusable code: a service written for a certain function can be used as a building block for another feature. This allows an application to bootstrap itself, as developers can create new capabilities without having to write code from scratch.
Flexible scaling: each service can scale independently to meet the demand for the feature it supports. This allows to adapt to infrastructure needs, precisely measure the cost of a feature, and maintain availability if a service experiences a surge in demand.
Agility: work teams can work in a small and well-understood context, so it becomes a more independent and faster way. This shortens the development cycle times.
Resilience: service independence increases the resilience of an application to errors. With microservices, if there is an error in the entire service, applications handle it by degrading the functionality without blocking the entire application.
Technological freedom: this architecture does not follow a "one size fits all" approach. This allows choosing the best tool to solve specific problems.
Now you know the essentials to create your app or program with microservices. Are you ready? Remember that this also depends on your needs and the service you offer.
