Microservices

Another thing that's become very popular is something called microservices. Microservices really allows us to break up our application into a much more manageable, much more scalable solution.

Deployment models

Now, it really doesn't matter what our deployment model is. We could have bare metal, we could have hypervisors, we could have containers, we could have serverless. We could have any of these deployment models but still be able to do microservices. However, some of these technologies have really compelled, or propelled, microservices to the next level. Something like container services really lends itself to being able to do these microservices.

Monolithic versus microservices

So what are microservices? Well, what is the antithesis of microservices? The antithesis of microservices would be monolithic. Monolithic just means that we have this huge program, all one code base. Maybe it's millions of lines of code that we have to go through to program this, and that can be problematic, because that's a lot to do. And then when we deploy it, we have to deploy all these lines of code. When we check it in and check it out, there can be contention issues. It just creates a lot of problems when we're trying to manage all of this code. And also, when it's being processed on the servers, it can cause problems as well.

So what we do instead is we break this code into smaller components and run it as individual services. We break the code down into these microservices, and then these microservices all talk with each other when they want something to be done. What happens is we break apart the processing, we break apart all of the code development. That just makes things really easy to manage all around.

What it looks like from an infrastructure standpoint

Let's say we have an app that's running on this phone, and if we have this monolithic design, maybe the app then communicates to a user interface. So it connects into this user interface, and that application does some sort of transmitting and transmits data. It does a receive data. It does some sort of maintenance tasks that are on here. It does this series of services kind of built in, or functions built in, with this one program. Now, the problem is, if it goes down, or maybe we need more processing power from a transmission unit or more processing power from a receiving unit — it's not very dynamic, it doesn't change with our needs.

So now let's look at what it would look like with microservices. This same app then connects to the front-end UI, and then that UI can deliver those services to that phone. And then what it will do is, if we are receiving something, that UI will go and do the receiving service and communicate with the receiving service. And then maybe it needs to do transmission, so then it does the transmitting. And then we just spin up more containers — let's say these are containers — we just spin up more containers if we have more needs for certain services. It makes it very scalable. Not only that, but we have this maintenance task that we can just turn into a script and run it serverless.

So what it does is it breaks apart this application into a lot of different services, and then we manage each of those services separately, making this much more dynamic in the way that we can monitor and track and program and develop. It just makes it much easier.

Microservices isn't the answer to everything

Now, microservices isn't the answer to everything. It does make things a little more complicated. There's more communication that's going on, so there's more chances for security issues. So it's not the solution for everything, and if you need performance, there might be better performance out of the monolithic, depending on what you're trying to do.

So it's not the solution for everything, but it is a route that many developers have been going for the last 10 years. They have been moving towards this microservices in order to better manage the programs that they're developing.