November 5, 2019 Cloud-Native Application: A Simple Definition
Cloud-Native Application : A Simple Definition
“The move from mainframes to PCs completely changed the way we think about building applications. Client/server changed it again. Mobile, again. The move to containers and Cloud-Native apps is on the same scale.” — Greg DeMichillie, Google
This article will introduce the basics of cloud-native applications. The reader will learn how to implement cloud-native applications.
Cloud-native is about building software applications using microservice architecture. The applications will be executed in a container and can be deployed on the cloud using the container. The cloud type can be public, private or a hybrid. Cloud-nativity accelerates the deployment and improves the software delivery process.
“Cloud-native is an approach to building and running applications that fully exploit the advantages of the cloud computing model.”
Source: What are Cloud-Native Applications? – Pivotal
Cloud-native architecture has application definition, development, orchestration, management, runtime execution, provisioning and infrastructure layers. The application definition and deployment layers have components related to composition, delivery, development, operational tooling, continuous integration, continuous delivery, image registry, image repository, governance, and operations model. The orchestration and management layers consists of observability, orchestration, coordination, and service management components. The runtime layer has modules related to resource management, cloud-native network, cloud-native data, and container services. The provisioning layer has features such as operating system management, secure images, host-level DevOps deployment tools, and provisioning. The infrastructure layer will have the cloud or bare metal server nodes.
Cloud-Native Computing Foundation was formed to make cloud-native computing popular and successful. They are using an open-source software to create cloud-native applications. Cloud-Native application bundle is another initiative to create a package format specification. Netflix was the pioneer in creating the cloud-native tool.
Now let us look at the cloud-native design principles, which are listed below:
- Services should be designed as loosely coupled microservices
- The application should be developed with best of breed technology stacks
- The application architecture should be using APIs for interaction and collaboration
- The architecture should be stateless and massively scalable.
- Resiliency is an important factor to be considered for architecture.
“Anything that can fail will fail” – Murphy’s Law
Failures occur during the execution of applications in a distributed environment. The failures can be related to network outages and planned disruptions. Resiliency factors in the architecture can help handle and recover from failure with the key attributes of high availability and disaster recovery.
We briefly touched upon the concept of a container. The key principle behind this concept is to package the application software into a single unit. The package can consist of an application, application server and a python virtual machine. This container can be run in any virtual environment. Having a containerized application helps in making it independent of the deployment system. The same container can be used for developing, testing and production environments. You can have more than one instance of the container to handle horizontal scalability.
Let’s start looking at a popular container docker. You can start with the free community edition of docker.
- You need to set up docker to run the below commands. You can download from this link.
The first step to check your docker installation is to run the hello-world docker image. The hello- world docker image is already created and available at the docker hub.
docker run hello-world
Docker client tries to pull the hello-world image from the developer machine. The docker client contacts the docker daemon running on the docker hub. The daemon picks the hello-world image and creates a new container. This container is sent to the developer machine to be executed. The message from the new container is displayed in the output below.
In the next part of the series, we will look at topics such as cloud-native building blocks, patterns, twelve-factor apps, data management and migration from monolithic to cloud-native applications