What Is Cloud-Native Development, And Why You Should Care

When people talk about cloud computing, it is important to differentiate between where applications “live” and how they are built. In this post, I will focus on the latter, i.e. what characterizes software designed from the ground up to take full advantage of the cloud computing model.

On the most basic level, cloud can be thought of as Infrastructure-as-a-service (IaaS): on-demand, self-service, subscription-based provisioning of elastic compute, storage, and network resources. 

However, cloud-native application development goes beyond time and cost savings potential of IaaS. Ultimately, the promise of cloud native has to do with business agility: the ability to deliver and evolve technology at the speed of business. 

Some of the terms often associated with cloud native development include microservices, containers, dynamic orchestration, immutable infrastructure, and comprehensive automation through DevOps.  

Microservices

Microservices is an architectural approach in which applications are designed as suites of independently deployable services: small, loosely-coupled, narrow-purpose applications. This paradigm is most often contrasted with monolithic applications that are built as a single unit. 

While monolithic applications can be successful, application development teams increasingly struggle with them, especially in the context of the cloud. For example, in terms scalability, you can only scale the entire monolith as one unit, as opposed to a single component that is experiencing the most stress. Also, a change made to a small part of a monolith requires the entire system to be rebuilt and deployed. Once the system reaches a certain size, building, testing, and deploying a monolith often becomes very complicated, slow and costly. 

With microservices, you can change your applications component by component. Each microservice can be owned by a small team, and can be upgraded and deployed (or rolled back) independently, without impacting other parts of the system. This provides the business with a greater ability to roll out new digital offerings quickly, resulting in better time to market.

Containerization 

Containerization is a modern virtualization approach that involves packaging up software code and all its dependencies so that it can run uniformly and consistently on any infrastructure. Because containers are essentially small and lightweight virtual machines, they allow for more efficient utilization of the underlying infrastructure. You could say that containers and microservices are almost made for each other. Together, they bring multiple benefits such as portability, cost efficiency, greater flexibility with automation, reproducibility, scalability, and security.  

Dynamic management and orchestration 

Containerized applications are typically dynamically managed and orchestrated by specialized software. Functions like triggering the startup or shutdown of a container, sharing all required configuration parameters, balancing the load between the containers, or passing authentication secrets between containers are usually controlled and automated using container orchestration software such as Kubernetes, Amazon’s ECS, or Apache Mesos. 

Immutable infrastructure

Cloud-native virtualization (and especially containers) enable a powerful approach to managing production workloads called immutable infrastructure. In this paradigm, production servers are never changed in place after they are deployed. Rather, if a system component needs to be fixed or modified in any way, new servers (or containers) are built from a common image with the appropriate changes, and replace the old instances.

This is often illustrated by the pets vs. cattle metaphor. 

In the on premise world, servers are treated like pets: there is a specific named physical machine that receives a great deal of care and attention. Similarly to how families respond when a beloved pet gets sick, if anything happens to the precious server, everybody feels it; it needs to be fixed, or patched, or to receive some sort of workaround to enable it to continue functioning. Over time, these servers become more and more unique and brittle, i.e. new changes or fixes are increasingly likely to cause unexpected problems. 

Immutable infrastructure, on the other hand, can help ensure the stability and transparency of the system configuration and reliable, repeatable deployments. In this approach, servers and containers are treated much more like cattle. When an instance becomes problematic, rather than giving it personalized treatment, you “take it out the back and shoot it”, i.e. shut it down and replace it with an instance cloned from a properly fixed and tested common image. 

DevOps and Automation 

DevOps is a set of practices that bridge the gap between software development and operations. Teams that practice DevOps achieve agility by adhering to the Continuous Delivery (CD) model, where incremental changes and updates to the software systems are continually deployed to production with a great degree of automation and repeatability. Mature DevOps organizations heavily automate routine operational tasks, such as application health checks, monitoring, alerting, and security, and standardize environments across the lifecycle of their systems. The return on the investment in DevOps and automation comes in the form of stability, security, repeatability, and greater speed of change: the more you are able to make changes to your software safely and reliably, the greater the frequency with which you will do it!        

Why should you care?  

Why should business leaders care about cloud in general, and cloud native software development in particular? 

It is my firm belief that being cloud native is no longer exclusively for the Netflixes and the Googles of this world. Cloud native practices and principles (such as highly componentized microservices architectures, with small development teams that iterate on components independently, coupled with robust automation and DevOps practices) enable companies to deliver and evolve their software systems at the speed of business. 

This agility is the principal way to manage risk and capture market opportunities through technology. 

And these things are not really optional for any business.