Cloud-Native Architecture

A cloud-native architecture is one in which an application has been designed specifically for cloud deployment (contrast to “lift-and-shift”, where applications are moved to the cloud unchanged.)

Cloud-native architectures are those that take advantage of the things that cloud platforms do well. For example, it is easy to scale out a cloud-based application by simply adding more server nodes, as well as to scale back down if the scale-up was due to a temporary spike in demand (for example, a retailer’s website on Black Friday or Cyber Monday). So cloud-native applications should provide horizontal scaling capability, and not be monolithic apps that are deployed on a single server. This is done in part by adopting a microservices architecture, where the app is decomposed into small functional pieces that can be deployed independently and connected via stable, clearly defined APIs.   

Similarly, once an application is scaled out and deployed across multiple nodes, it is of course desirable that the system be resilient to failures affecting one or a small number of nodes. So a cloud-native application should be designed to continue to perform in the event of a node outage and to recover gracefully from failures. 

Developing capabilities such as horizontal scalability and fault tolerance is tough to do from scratch, but these features are a key component of containerization platforms such as Docker; this is why many companies will move to a containerized platform as part of any migration to the cloud, and why the adoption of a container-based architecture is considered synonymous with being cloud-native.  A container orchestration framework like Kubernetes (which is the basis of packaged stacks like Red Hat OpenShift) to manage the deployment of containers.

A container-based architecture takes the application that is to be deployed and bundles it together with all of its dependencies into an image that includes everything needed to run the app — language runtimes, software libraries, and the application code itself. This image is then stored in a centralized repository (public or private), and deploying the app is then done through simple tools that copy the image to the target system, create a container for it to run in (which provides isolation from other containerized apps that may run on the same physical server), and makes connections as needed to resources such as network ports.

While there isn’t a universally agreed-upon set of criteria to define a cloud-native application, most sources agree that an application that has been decomposed into a set of microservices, with these microservices deployed via containers, qualifies as cloud-native. Having a continuous integration/continuous deployment framework that allows the container images to be updated and deployed regularly in accordance with agile software development practices is another characteristic that is commonly associated with cloud-native architecture.

Related Topics

Microservices

Microservices Architecture