bongoDev

Kubernetes is an API-driven control system for running workloads. You declare the desired state; controllers continuously compare that desired state with the observed state and act to reduce the difference.

The architecture at a glance

Text

Engineer / CI/CD
      |
      | kubectl / API client
      v
+------------------------------+
|        CONTROL PLANE         |
|                              |
|  kube-apiserver              |
|       |                      |
|       +----> etcd            |
|       |                      |
|       +----> kube-scheduler  |
|       |                      |
|       +----> controllers     |
+------------------------------+
              |
              | desired state / assignments
              v
+------------------------------------------+
|                WORKER NODE               |
|                                          |
|  kubelet ---> container runtime ---> Pod |
|  networking / Service implementation     |
+------------------------------------------+

Control plane

The control plane manages overall cluster state:

Component	What it does
`kube-apiserver`	Exposes the Kubernetes HTTP API and is the front door to cluster state
`etcd`	Stores Kubernetes API data as a consistent key-value store
`kube-scheduler`	Chooses a suitable Node for unscheduled Pods
`kube-controller-manager`	Runs reconciliation controllers
`cloud-controller-manager`	Optional integration point for supported cloud-provider functions

Worker node

A worker node runs workloads and normally includes:

kubelet — ensures assigned Pods and containers are running
container runtime — actually creates/runs containers
network implementation — connects Pods and implements cluster networking
kube-proxy or an alternative Service implementation — handles Service traffic rules in many clusters

A Deployment request from start to finish

Suppose you apply a Deployment:

Bash

kubectl apply -f deployment.yaml

A simplified flow is:

kubectl sends an API request to the API server.
Authentication, authorization and admission checks occur.
The desired object is persisted in cluster state.
Controllers notice that desired replicas do not exist and create lower-level objects.
The scheduler sees unscheduled Pods and selects Nodes.
The kubelet on each selected Node observes the assigned Pod.
The kubelet asks the container runtime to create containers.
Networking and storage integrations prepare what the Pod needs.
Status flows back through the API.

That observe → compare → reconcile loop is the heart of Kubernetes.

First architecture commands

Bash

kubectl cluster-info

Shows important cluster endpoints known to your current context.

Bash

kubectl get nodes -o wide

Lists Nodes and useful placement/network information.

Bash

kubectl get pods -A -o wide

Lists Pods across namespaces and shows where each Pod is running.

Bash

kubectl get --raw='/readyz?verbose'

Where permitted, queries API-server readiness details directly through the Kubernetes API.