Why Kubernetes Is the Backbone of Modern Cloud‑Native Architecture

Kubernetes Overview

Kubernetes (K8s) is an open‑source container orchestration platform that automates deployment, scaling, and management of containerized applications across multiple hosts.

Key Characteristics

Portable: supports public cloud, private cloud, hybrid cloud, and multi‑cloud environments.

Extensible: modular, plug‑in capable, mountable, and composable.

Automated: automatic deployment, restart, replication, and scaling.

Typical Use Cases

Small‑to‑medium enterprises use Kubernetes to build automated operation platforms that handle application deployment, version planning, updates, and maintenance, thereby reducing operational cost and increasing efficiency. Large internet companies use it to automate deployment and monitoring of thousands of services, avoiding manual installation on ever‑growing server fleets.

Resource Utilization Example

Assume a server with 2 CPU and 4 GB RAM handling 200 concurrent requests:

150 static requests, each consuming ~2 MB → 300 MB.

50 dynamic requests, each consuming ~10 MB → 500 MB.

Total memory usage ≈ 800 MB, which in a memory‑only estimate could support ~800 QPS. A conservative figure of 300 QPS accounts for response‑time and CPU context‑switch overhead.

Containerization allows multiple services to run in isolated containers on the same host, improving overall resource utilization.

Evolution of Service Deployment

Physical machines: applications installed via scripts or plugins, tightly bound to the OS, making upgrades and rollbacks difficult.

Virtual machines: provide isolation but consume more resources and reduce portability.

Containers: lightweight, isolated file systems, fast deployment, and easy migration across clouds and OS versions.

Challenges Addressed by Kubernetes

Horizontal scaling of services.

Failure detection and automatic recovery of containers.

Zero‑downtime version updates.

Monitoring of container health and metrics.

Scheduling and creation of containers based on resource policies.

Ensuring data security and isolation.

Cloud and Kubernetes Relationship

Cloud: a network of services built from many containers.

Kubernetes: the management layer that orchestrates those containers.

Cloud Architecture Layers

IaaS (Infrastructure as a Service): users rent virtual machines without managing underlying network, DNS, storage, or hardware.

PaaS (Platform as a Service): providers offer managed services such as MySQL, Redis, MQ, Elasticsearch.

SaaS (Software as a Service): end‑user applications (e.g., DingTalk, finance tools) are fully managed by providers.

Serverless: abstracts away servers entirely; users consume functions or services without provisioning servers.

Cloud‑Native Principles

Containerization: all services run inside containers.

Microservices: applications are decomposed into independent services.

CI/CD: continuous integration and delivery pipelines.

DevOps: tight integration of development and operations.

Kubernetes History

Kubernetes was developed by Google in Go, inspired by its internal Borg system, to provide a comprehensive solution for container scheduling, service discovery, and dynamic scaling.

Cluster Structure

A Kubernetes cluster consists of a single master node and multiple worker nodes.

Master Node Components

API Server: the gateway for all commands and the central point of contact for the control plane.

Scheduler: assigns workloads to appropriate nodes based on resource requirements and policies.

Controller Manager: maintains the desired state of resources (CRUD operations).

etcd: a distributed key‑value store that persists cluster state, resource objects, and service registration information.

Worker Node Components

Docker (or another OCI‑compatible runtime): executes containers.

kubelet: runs on each node, watches the API server for pod specifications and ensures the containers are started and healthy.

kube‑proxy: implements network rules for service load‑balancing across pods.

Fluentd: collects and forwards logs from the node.

Pod: the smallest deployable unit; a pod may contain one or more tightly coupled containers that share networking and storage.

Architecture Recap

Kubernetes manages containers indirectly via Pods.

One master controls a set of worker nodes.

The master handles scheduling, API serving, controller logic, and state storage; it does not run user containers.

Pods run on worker nodes; each pod can host multiple containers.

kubelet maintains the lifecycle of pods on its node, while kube‑proxy provides intra‑cluster load balancing.

Source: https://blog.csdn.net/qq_43280818/article/details/106648372