Cloud Native Approach For Software Engineering. Part 1 - Cloud Native Apps.

This the 1st part of the two-part series talking about Cloud Native Apps and Containerization.

In recent days you would have heard people talking about building cloud native applications and if you were a bit more curious about it then you would have even heard of CNCF (Cloud Native Computing Foundation) certifications. So what exactly is this Cloud Native approach, you ask? Well, let's go through it.

In the heritage world, we have huge monolithic apps and in the new world, we have microservices living on the cloud. The below diagram shows the stack of our cloud native apps:

In the Cloud Infrastructure layer, we have public, private and enterprise hybrid infrastructure that cloud native apps apply to hybrid and multi-cloud situations.

Then, there is the Scheduling and Orchestration layer which has control planes such as Kubernetes.

On top of that lies the Data Services layer. This layer is all about backing services and databases. This layer also allows us to connect other 3rd party services which are on different cloud systems or even On-Premise. It includes all 3rd party REST, GraphQL and SOAP APIs.

This is stacked upon by Application Runtime layer which was traditionally known as Middlewares and finally we have our sweet spot where our cloud native apps sit, the Application Code layer. The apps for cloud native approach are built and delivered very differently when compared to our traditional monolithic applications.

In recent days, this solution stack is being refactored at the bottom layers which is making the stack to have a low centre of gravity. What this does is that it frees up the application code layer for innovation.

So the key benefits of this approach are:

• Innovation
• Agility
• Commoditization

The appropriate use cases for the above stack is almost everything, which means that this stack is suitable for everything that is cloud based. Everything that lives on the cloud should have a cloud native design and approach. This means that our application code should be instrumented with things like standardized logging, standardized events and being able to match those logging and events to a standard catalogue that multiple microservices and cloud native apps can use. The last thing we want our development squads to do is to figure out what their log and event messages should be. 

To sum it all up, the cloud native approach is all about enterprise engineering at scale.

This concept shall lead to a better understanding of containerization which will be discussed in the next part of this article series.

Read part 2 here.

See you then.