4 min read

Microservices Architecture

Photo of Assaf Koren
October 13, 2019Assaf Koren


Cover Image for Microservices Architecture

What Are Microservices?

Microservices are the secret ingredients that allow the DevOp teams to be disruptive, agile, and nimble. The thing is, they are small, easy-to-test, independently run units that perform a certain function that together create flexible and resilient architecture that is easy to upgrade at any given time.

As it was brilliantly stated in Solutions Review, “Microservices can be defined more by the characteristics of the method of developing software applications, sort of similar to the way you identify black holes in space; by the behavior of the objects around it”.

Kong Yang, Head Geek at SolarWinds, described the microservices less poetically, but evenly effectively as “a method of developing software applications which are made up of independently deployable, modular services. Each microservice runs a unique process and communicates through a well-defined, lightweight mechanism, such as a container, to serve a business goal.”

So, in plain English, microservices offer us a new way of creating applications, where the whole process is broken down into putting together autonomous services without linking them to specific coding languages. This allows their redeployment in different contexts, updating the whole architecture in real-time, or creating new ones, thus keeping the DevOps cost management well-balanced. Now, why this smooth cohesion in architecture matters?

Playing Lego: Flexibility and Scalability

Let’s imagine you need to build a spaceship for the kid and you have 2 options: to use the Legos or to carve it out of a wood log. With Legos, you have individual blocks that are already there for you to make whatever you want, in the shape that you need, and use the different colors for that. With a wood log, the options are scarce, and if you need to upgrade your spaceship by carving it more, you may as well end up with a boat.

Another plus of using Legos is that after the kid is bored playing with it, you can disassemble it and reassemble the blocks into whatever else you may desire, whereas the wooden toy is purpose-built, and will remain as it is.

Microservices, like Legos, are specialized building blocks—individual pieces with individual functionalities. And, like Legos, microservices are scalable—they can be combined, typically via APIs, to build something bigger. Additionally, each single microservice component can be scaled independently, so if you need additional file transfer capability, you can simply scale the file transfer microservice.

However, there is one area of a microservices architecture where the Lego analogy fails.

If you take away a ground piece from your Lego tower, the whole structure could fall. That’s what’s commonly known as a single point of failure. Unlike Lego, microservices has no such flaw. With a microservices architecture, if you take away a single piece (i.e. when one service crashes), the entire structure continues to function, and even though the microservices are open to interacting with each other, they cannot be modified by the services they connect to. As Sam Guckenheimer says, because each microservice is implemented and versioned independently, microservices architecture prevents a possibility of a single point of failure by guaranteeing that issues in one service cannot crash or otherwise impact other parts of an application.

A DevOps Love Story

So, this is all well and good, but you may be asking yourself, where exactly does DevOps come into this? Well, to answer your question, the Lego-ness of microservices means that it is extremely easy to build an app out of them, which means you reduce cost and reduce time, comparing to doing it in a traditional, monolithic manner. This agility makes microservices essential to the continuous integration and continuous delivery mindsets that are at the core of DevOps.

Now, I know that some would say that microservices are not a magic pill. And I agree. I’ve seen it first-hand where an organization deployed OpenShift and then locked it down to only run “Java” applications. They thought developers were too stupid to learn Kubernetes and incapable of handling WebSphere configurations. As a result? Absence of cloud microservices automation, running app-building business in an out-dated way, and belated cost management solutions that undermined the company’s market performance. Was it really the developers’ fault? I don’t think so.

I am not here to tell that microservices solve every current issue with software development. On the contrary, creating your first microservice architecture application is going to be difficult, take long, and you better expect struggles. But this is exactly the reason why you should work with tools like Simloud that will handle all these complexities for you!

With Simloud, you could have an up and running fully architected microservice environment that supports centralized logging, centralized monitoring, CI/CD, Vault, and much more in a few hours. Because your ability to adapt fast is a key to success.

Save time, costs, and headaches.

Your simple, all-in-one solution for easy cloud creation and microservice architecture management.