Cloud Native

What is Cloud Native? How is it different from Cloud Computing? Should we go Cloud Native?

Let's take a closer look.

The term "Cloud Native" seemed to first appeared around 10 years ago when Netflix discussed their web-scale application architecture at a 2013 AWS re:Invent talk. At that time, the meaning of the term was likely different than it is today. However, one thing remains the same:

There were no clear definitions for it then, and there still are not any clear definitions now. It means different things to different people.

In this article, we provide our interpretation of the term "Cloud Native" and discuss why and when it is important.

What is Cloud Native?

To start, what are the promises of Cloud Native?

Cloud Native is a blueprint for building web-scale applications on the cloud that are more available and scalable.

It promises increased agility to ship new features quickly without compromising availability, making it quicker to respond to changing customer demands.

Before we dive into how Cloud Native fulfills these promises, let's first understand what its close-cousin, Cloud Computing, is. In its most basic form, Cloud Computing is running applications on computing resources managed by cloud providers, without having to purchase and manage hardware ourselves. Migrating an existing monolithic application from on-premises to the cloud is a great start. It frees the team from managing hardware infrastructure. It is fast to provision new computing resources, and scaling up is effortless. However, simply running an application on the cloud does not make it Cloud Native. For an application to be considered Cloud Native, there are at least 4 pillars to consider.

The first pillar is the Application Architecture.

Cloud-native applications are made up of multiple small, interdependent services called microservices. Traditionally, developers built monolithic applications with a single binary containing all the required functionalities. It was difficult to develop, test, and deploy a monolithic application quickly. It was also challenging to scale a monolithic application. By using the cloud-native approach, developers break the functionalities of a large application into smaller microservices. These services are designed to be small, allowing teams to take ownership of their own services and deploy and scale them independently on their own timeline. These microservices are loosely coupled. They communicate with each other via well-defined APIs.

For example, an e-commerce application might be composed of a shopping cart service which talks to a payment service and an inventory service.

Containers Container Orchestration

The second pillar is containers and container orchestration.

Cloud native applications are packaged in containers. Containers are lightweight components that contain everything needed to run a microservice in any environment.

Container orchestration is an essential component for large cloud-native applications. As the number of microservices grows, container orchestration manages the large number of containers so all the microservices can run smoothly as a single unified application.

A popular container orchestration platform is Kubernetes. It oversees and controls where containers run, detects and repairs failures, and balances load between microservices.

Development Process

The third pillar is the development process.

Cloud native applications are built using a microservices architecture. Different services are developed, deployed, and scaled independently of each other. This requires a high level of collaboration between development and operations teams, as well as a significant investment in automation for the development and deployment process. This is where DevOps comes into play. DevOps is a development practice that emphasizes collaboration, communication, and automation between development and operations teams to deliver cloud-native applications quickly and reliably.

A critical component of DevOps is CI/CD. It enables teams to automate the software development and deployment process, making it faster and more reliable.

The Continuous Integration part of CI/CD refers to the practice of regularly merging code changes into a shared repository and running automated tests to ensure that the code is working as expected.

The Continuous Delivery part of CI/CD refers to the practice of automating the deployment of the software to production environments, often through the use of automated deployment pipelines.

The last pillar is the Adoption of Cloud Native Open Standards.

As the Cloud Native ecosystem matures, critical components become standardized and best practices become widely available. Being cloud native means leveraging these standardized components as building blocks and following these best practices as they become available.

Let's walk through some well-known standards and projects behind those standards.

We already mentioned Kubernetes. It is a widely-known orchestration project.

Distributed tracing is an essential component of observability. It tracks requests as they propagate through a maze of microservices.

Some well-known projects are Jaeger, Zipkin and OpenTelemetry. Service mesh is a core infrastructure layer for managing service-to-service communication between microservices. Istio and Linkerd are some examples.

By leveraging open standards, it frees developers from having to worry about common functionalities like logging, tracing, and service discovery. This allows developers to focus on what matters, which is their own microservice applications.

Where Should We Adopt Cloud Native

So, when should we adopt a Cloud Native strategy? The answer is - it depends.

If the application is small and relatively simple, a Cloud Native approach may not be necessary and a traditional monolithic architecture or a simpler deployment model may suffice.

However, for larger and more complex applications, Cloud Native can offer a wide range of benefits, such as increased scalability, availability, and faster development cycles. Ultimately, the decision to adopt a Cloud Native strategy should be based on a careful evaluation of the application's requirements and the organization's resources.

When done right, a Cloud Native approach can help organizations build and deploy applications that are more reliable, scalable, and resilient in a shorter amount of time. If you like our videos, you may like our system design newsletter as well.