The Benefits of Containers for Microservices: Here's What You Need to Know2022-09-19 11:19:52
Our DevOps team leader, Mateusz, promised to address a burning subject: microservices and containers. Here is his viewpoint.
According to Statista, in 2021, 85% of large organizations admitted that they use microservices, and 14% confirmed plans to introduce them in the future.
But before I jump into discussing it in detail, I'd like to refer to the concept of quality – where it stems from and why it's so important.
When creating applications or infrastructures, our goal needs to be crystal clear. We're well beyond the beginning of the digital age, now is the moment to polish up the resources and put them in the proper order to maximise their value.
The idea of quality has many definitions, but which one will be most suitable in this case? Let me leave this question open, but hopefully, my text will inspire you to define your concept of technical quality.
Zooming in on microservices and containers
Containers and microservices are two methods that enable companies to create and deliver applications more efficiently.
I won’t talk at length about why you need it. Suffice to say that modern customers expect your application to deliver top service but also high availability and security. If you can’t do that, you can be sure your competitors will.
Both microservices and containers help teams design and adopt apps with the speed, quality, and flexibility expected in the increasingly competitive landscape.
They are different technologies that don’t have to be used together, but they often are. So let’s now break down how they work and what advantages they bring to your business.
The moment to break with the monolith
2013 was a year to remember. This was when the term “microservices architecture” got on everyone’s lips, and its popularity has since grown at an astonishing rate.
Before that, most applications were monolithic designs in which the entire application ran as a single unit and, in most cases, as a single process.
I still sometimes recall the pain of having to reinstall everything just to introduce a small change in the application. Or the sheer lack of tooling for scaling individual system components in response to changing traffic.
The whole process of change management and new version releases was a pain for many people working on the project. One of the lowest points I remember was when a mistake in one minor element of the monolith disabled all users from using the application. Also, I’ve heard that implementing microservices via a strangler pattern is perhaps the most popular way, but this is another topic, which I will write soon.
From what I have seen, more than 90% of clients are happy about implementing microservices at their businesses. However, as with everything, every solution has pros and cons, and I will try to outline them.
The main advantage of microservices
While dismantling the monolith sounds straightforward initially, I must openly say that you need much more expertise to achieve that.
There is a real risk of delays in deploying the application’s updated versions on the new infrastructure and microservice architecture. The task is more complex than it sounds, so it may also increase your running costs.
However, the benefits of microservices far outweigh the risks. You successfully reduce the failure point by dividing your application into smaller chunks. Of course, some dependencies still stay, but you can avoid a situation in which a minor part can make the entire system unavailable.
Implementing every application element independently is crucial, as this enables you to use newer technologies on individual sites. Furthermore, you can test and check everything separately, so different teams can share the responsibility for various application components.
So when you’re sold on the idea of microservices, I’m almost sure that you will come across the concept of containers.
The benefits of containers for microservices
Containers are the most popular way to implement a microservices architecture, and this is for several reasons.
Containerisation became popular in the mid-2010s with the introduction of Docker and Kubernetes, which provided the much-needed tooling for creating and managing applications
The main benefit of containers is their efficiency. They enable running apps, directly sharing resources with the OS of the server that hosts them. This feature of containers drives overheads down and adds to the fact that they are faster to start than VMs.
Moreover, containers provide isolation for each containerised application or microservice, significantly reducing the risk that a potential security vulnerability spreads.
They are also great for service discovery, as they simplify the location and communication of microservices when they all run in containers managed on the same platform. This factor helps to design and build a reliable network architecture.
And along very similar lines, containers make it easier to orchestrate microservices. Thanks to orchestration, you can treat each element separately, scale it, adjust performance as required, and set appropriate health checks.
On top of all this, you can add automation that brings the component up and, for example, use the blue-green deployment approach.
Add a layer of 24/7 monitoring on top of that, and that’s it! Assuming that your configuration is correct, you can now have an automated and secure system, with the failure point reduced to the single-component level. You also get the possibility to roll back to the previous versions if necessary.
Although it sounds simple, this is a complex process, so enlisting experienced cloud infrastructure design consultants will greatly help.
Microservices architecture is still a relatively new trend that reigns supreme in the industry. The cooperation between software developers and DevOps means that you can bring ambitious and challenging projects to life – the only limit is your imagination.
It begs the question: so what’s next? With so many specialists working with all the containers and microservices technologies, I hope we will keep on going and pushing the envelope.
There are still way too many monolith designs that would benefit from containers and microservices – so let’s do it!
About the author: Mateusz Grządzielski, almost 10 years of experience in IT. He’s worked at all tech support positions – from a specialist to a team leader now.
At Tenesys, he is in charge of the DevOps Engineers team, focusing on clients’ projects and the whole team’s good vibe. Besides from the IT side, Mateusz is studying at Poznan Economic University and leading his own business.