What Is Cloud Native? A Deep Dive into CNCF, Kubernetes, Docker, and Modern Architecture

Entering the Second Half of Cloud Computing

We have entered the second half of cloud computing; instead of debating whether to move to the cloud, we now discuss how to do it to fully realize its value, integrate it with various business scenarios, empower technology for enterprises, and reduce IT deployment costs.

What Is Cloud Native?

Until the arrival of "cloud native," no one knew the answer. The definition is not unified, but we can use the CNCF (Cloud Native Computing Foundation) definition.

CNCF (Cloud Native Computing Foundation) was founded on December 11, 2015, under the Linux Foundation. It cultivates and maintains a vendor‑neutral open‑source ecosystem to promote cloud‑native technologies and is the most influential organization in the cloud‑native field.

Historical Background

To understand cloud native, we need to go back 16 years to Cgroups (control groups). In 2004, Google began using container technology and released Cgroups in 2006, originally called Process Container. The goal was to provide OS‑level resource limits, priority control, auditing, and process management similar to virtualization. In 2006 the Process Container entered the Linux kernel mainline.

Because the term "container" had many meanings in the Linux kernel, it was later renamed Control Groups (Cgroups).

In 2013 Docker was released, and in 2014 the Kubernetes project was released.

Containers made it easy to manage applications, and Kubernetes was created to orchestrate them.

In 2015 Google, Red Hat, Microsoft and other cloud vendors jointly founded CNCF. At its inception CNCF had 22 founding members, and Kubernetes became the first CNCF‑hosted project.

CNCF’s Definition of Cloud Native

Cloud‑native technologies help organizations build and run elastic applications in public, private, and hybrid clouds. Representative technologies include containers, service mesh, microservices, immutable infrastructure, and declarative APIs.

These technologies enable fault‑tolerant, easy‑to‑manage, loosely‑coupled systems. Combined with reliable automation, they allow engineers to make frequent, predictable, and significant changes to systems.

Alternative Definitions

Matt Stine of Pivotal first introduced the term in 2013. In his 2015 book he defined cloud‑native architecture with the 12‑factor app, microservices, API‑centric collaboration, and resilience. In 2017 he refined it to six traits: modularity, observability, deployability, testability, replaceability, and manageability. Pivotal’s website summarizes cloud native as DevOps + continuous delivery + microservices + containers.

Core Technology: Containers

Generally, "container" refers to Linux containers (LXC). Red Hat defines a container as a set of processes isolated from the rest of the system, with all required files provided by an image, making it portable and consistent across development, testing, and production.

Containers provide process‑level isolation, allowing resources to be divided into isolated groups, solving conflicts such as running different applications on the same OS.

Major container technologies include Docker, LXD, and rkt.

Docker

Docker originated from the company dotCloud (founded in 2010). It simplified and standardized container technology, creating the Docker image format. Docker images package the entire OS file system and application dependencies, enabling "one‑click, run‑anywhere" deployment, faster builds, and consistent environments across development, testing, and production.

Docker is an open‑source container engine for building, publishing, and running distributed applications. It is the foundation for platforms such as Kubernetes, OpenShift V3, Flynn, and Deis.

Kubernetes

Kubernetes (K8s) is considered the cornerstone of cloud native. It originated from Google’s internal Borg system, was open‑sourced in June 2014, and later donated to CNCF in 2015 as its first project.

A Kubernetes cluster consists of a Master node (control plane) and multiple Worker Nodes.

Master : controls the cluster and creates jobs.

Node : executes tasks assigned by the Master.

Pod : a group of one or more containers deployed as a single unit on a node, sharing IP, IPC, hostname, and other resources.

ReplicationController : ensures a specified number of pod replicas are running.

Service : abstracts a set of pods, providing stable network endpoints and load‑balancing.

Kubelet : runs on each node, ensuring containers are started and healthy.

kubectl : command‑line tool for interacting with the Kubernetes API.

Microservices

Microservices are small, independently deployable services that implement a specific business capability. They enable teams to develop, test, and scale each service independently, unlike monolithic architectures where the entire application must be scaled as a whole.

Benefits include faster iteration, independent scaling (e.g., payment service may need 20 instances, user service 30, product service 10), and better alignment with agile development.

Service Mesh

A service mesh is an infrastructure layer that handles service‑to‑service communication. It provides features such as traffic management, observability, and security. Istio, backed by Google, IBM, and Lyft, is the most well‑known service mesh and integrates tightly with Kubernetes.

Immutable Infrastructure

Traditional mutable infrastructure allows servers to be modified after deployment, leading to configuration drift, unreproducible states, and operational risk. Immutable infrastructure treats servers as immutable after provisioning; any change results in a new server instance. This improves consistency, reliability, and simplifies deployments.

Declarative APIs

Declarative programming describes the desired state of the system, and the system works to achieve that state, whereas imperative programming issues explicit commands (e.g., "run container", "stop container"). Kubernetes uses a declarative API model.

Summary of Core Technologies

Kubernetes is the foundation of the cloud‑native ecosystem.

Containers (e.g., Docker) are the underlying engine.

Microservices pair naturally with Docker.

Service Mesh (e.g., Istio) extends Kubernetes to manage inter‑service traffic.

Immutable Infrastructure provides a stable base for modern operations.

Declarative APIs are the way to interact with Kubernetes.

Value of Cloud‑Native Applications

1) Rapid Iteration : Agile, reusable components such as containers enable fast, repeatable delivery across multiple clouds.

2) Automated Deployment : Cloud‑native pipelines automate the entire delivery process, eliminating manual, error‑prone steps.

3) Independent Efficiency : Microservices allow independent scaling and development, reducing communication overhead and increasing team efficiency.

Conclusion

Cloud native is the next big wave after the era of cloud computing. Embracing cloud native is a gradual process: reject it, understand it, adopt it, and follow it. The ecosystem, led by CNCF, provides a complete lifecycle—from deployment platforms to logging, service mesh, discovery, tracing, monitoring, and security—enabling truly portable, scalable, and resilient applications.

References

Kubernetes 是什么？ – Linux中国

Kubernetes 与云原生应用概览 – 宋净超

云原生的不同解释及正确含义 – 倚天码农

10分钟看懂 Docker 和 K8S – 鲜枣课堂

CNCF 官方大使张磊：什么是云原生？