Erbis stands with Ukraine

How to utilize a microservices architecture in cloud apps

Cloud-native architecture

Use microservices + cloud pair to develop a highly scalable and easy deployable app.

With cloud applications, you don’t have to set up on-premises IT infrastructure but can utilize the ready-made environment offered by a cloud provider. This approach is highly convenient, which is why the demand for cloud services is increasing, and the number of cloud applications is growing daily.

Cloud infrastructure is very flexible because you can use the IT resources on-demand. In this respect, it makes a perfect match with microservices application architecture. The latter consists of small and easily replaceable modules, so you can add or remove some using the necessary cloud tools as per project needs. Today, microservices architecture is very popular for new apps. But does it suit your software project? Let’s find out.


Today, many companies adhere to the Lean Startup philosophy and enter the market with a minimum viable product (MVP). Then, as the product evolves, companies watch users’ moods and behavior patterns to respond quickly to their actual needs. In addition, to sustain intense competition and not lose customers, organizations try to avoid downtimes and system failures. At the same time, they look for ways to quickly increase functionality and make changes to existing features according to the current market needs.

The task becomes quite challenging because companies need to immediately receive additional IT resources when the service load grows, while not overpaying during user activity decay. Consequently, they look for enterprise architecture patterns that could support stable app operation while allowing effortless scalability and revamping of features. 

Microservices architecture perfectly solves these challenges. It allows developers to create and update parts of the application independently, for example, updating a single block while leaving the rest unchanged. This is the main difference between microservices architecture and a  monolithic structure, where reassembly of the whole app is usually required every time a change is made. 

Monolith vs. microservices
Monolith vs. microservices

Microservices architecture is cloud-native architecture because you can easily add or remove app components using cloud resources on-demand. There is no doubt that microservices bring many benefits to companies and facilitate developers’ work. But like any other thing, they also have some drawbacks, which we will consider further.


Cloud microservices are not a one-size-fits-all solution. While they are ideal for big projects with high technology change requirements, they may not be suitable for small apps or apps with zero scalability needs. In any case, the program architecture choice should always be determined by the project’s nature. So, when deciding for or against microservices, you need to consider their pros and cons.


Easy development. Writing and maintaining small microservices components is much easier than writing and maintaining a large project. This is because each system component has one function, and you do not need to rebuild the entire application to make changes to this component.

Team independence. In large companies, different services can be owned by different teams and the microservice architecture allows them to operate autonomously. Although the teams still need to coordinate their work with each other, they have more freedom to make decisions regarding their product’s development.

Free choice of technologies. For each microservice, you can select a separate tech stack: programming language, libraries, utilities, etc. This approach may be beneficial for specific tasks when, for example, you need to utilize a well-developed library written in Python as a single microservice within your Java project.

Uninterrupted operation. Microservices development makes it easy to add new services or to disable old ones – this does not affect the system’s operation as a whole. You can also update services one by one, usually without slowing down the system and affecting users.

Strong fault isolation. Normally, when one of the modules fails or breaks, the rest continue to work. By contrast, it is impossible with a monolithic architecture, where the crash of one module can destroy the system as a whole.


Complex inter-service communication. There are no universally accepted communication standards between microservices. Therefore, you need to set the data exchange format for each pair of services and make sure the data is transmitted safely.

Challenging debugging. An application may consist of dozens, or even hundreds, of microservices each with a massive number of logs. If a problem occurs, tracing the source of the issue becomes a challenging task.

Time-consuming integration testing. Compared to monolithic software, integration testing of a microservice app becomes more complex. QA engineers need to make sure that all units interact as they should and no glitches occur during their communication.

Increased control over API. Microservices interact with each other and external apps through APIs (application programming interfaces). While changes in the service itself do not affect the app operation, the changes in the API may lead to serious problems if backward compatibility is not provided.

Bigger resource consumption. The more microservices you create, the more resources you need to maintain them. No matter if you run the app on-premises or in the cloud, you will need to pay for extra tools and services.


A microservice is a small program responsible for a particular part of the software’s functionality. This program needs a specific environment to work: an operating system, libraries, utilities, etc. 

If you deploy all microservices on a single server, you will not achieve the required isolation level. In this case, there will be a high risk of system failure because a problem in one microservice could lead to the entire program crash. By contrast, you will achieve maximum isolation by deploying each microservice on a separate server, but resource consumption will be highly irrational.

With that in mind, the perfect solution for microservices is a containerized application architecture. It allows you to pack functional software components into separate blocks – containers. Each container has the necessary environment to run the microservice. Thus, multiple microservices can operate autonomously on a single server yet connect with each other through a special API.

Microservices in containers
Microservices in containers

As of today, the most common containerization technology is Docker. It allows you to quickly deploy any number of containerized instances and scale them up or down as per the project needs. However, if you have a large app with hundreds of microservices, manually managing them will be extremely difficult. This is when Kubernetes comes to the rescue, providing you with an efficient tool for container orchestration. 

Kubernetes is an automatic system for managing containers and monitoring their state. With its help, you can deploy microservices in a cloud-native environment and quickly respond to failures in certain nodes. Furthermore, considering that Kubernetes is supported by major cloud providers – GKE, AWS, and Azure – you can run your microservices wherever you like, adhering to the best practices of microservice deployment patterns.

Kubernetes manages containers
Kubernetes manages containers


Microservices architecture is an efficient approach to implementing an agile app, but it is not a one-size-fits-all solution. Some apps with small requirements for scalability do not need a spread of microservices but are not suited to a monolithic structure. In this case, a modulithic architecture serves as a perfect solution. Unlike microservices, moduliths are placed in a single environment. Being, to some extent, isolated from each other they are, however, not as autonomous as microservices. For example, you cannot deploy, restart, or scale them independently of the entire app.

At Erbis, we choose modulithic architecture for projects or parts of the code where there is no need to interact with external services. As opposed to microservices, it allows us to remove the need to use 

  • timeouts

  • enhanced asynchrony

  • repeated requests

Thus, by choosing modular architecture, we can achieve high application performance with less effort. And in combination with microservices, we create the most flexible solution for enterprise needs.


The microservice reference architecture allows you to gradually develop large-scale apps, first launching MVP and then increasing functionality by adding new features. It is most efficient in the cloud, where you can scale your project up and down thanks to easy access to the necessary IT resources.

The most efficient way to deploy a microservice application in the cloud is to pack it in containers. Containerization technology provides an isolated environment for each service while allowing them to communicate through the API.

Like any solution, microservices and cloud have their pros and cons. However, when chosen for the right project, they open ample opportunities allowing quick deployment, effortless scaling, and continuous services delivery.

October 29, 2021