What is Kubernetes? A Developer Guide

Imagine running a huge, state-of-the-art data center that runs hundreds of applications simultaneously, each consisting of dozens of containers. One container is down and you need to start a new one instantly. The load has increased by 10 times - you need to automatically add the server. Update version – no user should notice downtime. It’s all in different clouds and data centers.

In 2014, Google opened the source code Kubernetes (K8s). Today it is the industry standard for container orchestration.

## 1. History and Why Kubernetes Won

Before Kubernetes, there were other orchestras: Mesos, Docker Swarm, Nomad. Google has managed billions of containers inside the company for decades using its Borg system. Kubernetes is an open version of Borg ideas + community experience.

By 2026, Kubernetes had become a de facto standard. Almost all major clouds offer managed Kubernetes (GKE, EKS, AKS, Yandex K8s, VK Cloud, Sber Cloud). Even small teams use it for complex projects.

## 2. The basic idea of Kubernetes

Kubernetes is a **declarative orchestration platform. You describe the Desired State in YAML files, and Kubernetes is constantly trying to bring the real state to the desired state.

It’s like a thermostat in your home: you set a temperature of 22°C, and the system decides when to turn on the heating or air conditioning.

## 3. Kubernetes architecture (deeper than usually told)

Control Plane (control plane) - the "brain" of the cluster

• API Server is the central point of communication (all kubectl commands go here).
• etcd is a distributed storage of all cluster data (it is very important to do backups etcd!).
• **Scheduler decides which Node to run the new Pod.
• Controller Manager – monitors controllers (Deployment Controller, ReplicaSet Controller, etc.).
• Cloud Controller Manager – communicates with the cloud (AWS, Yandex, etc.).

**Worker Nodes:

• **Kubelet is the agent that runs and monitors Pods.
• Kube-proxy is responsible for networking and service discovery.
• Container Runtime (containerd, CRI-O – Docker is no longer used directly).

## 4. Main Kubernetes objects (with nuances)

Pod

• The smallest deployable unit.
• Can contain 1 or more containers (sidecar pattern: envoy, fluentbit, istio-proxy).
• Pods are ephemeral—they can die and be recreated.
• Important nuance: Pods have their IP inside the cluster, but this IP is unstable.

Workload Controllers

• Deployment - for stateless applications (web servers, APIs). Supports rolling updates, rollback.
• StatefulSet - for stateful applications (Databases, Redis, Kafka). Guarantees the order of creation/deletion and stable names (myapp-0, myapp-1).
• DaemonSet - runs one Pod on each Node (logging, monitoring agents).
• Job/CronJob for one-time and periodic tasks.

Service

Types of Service:

• *ClusterIP - only within the cluster.
• **NodePort opens the port on all Nodes.
• *LoadBalancer creates an external balancer in the cloud.
• ExternalName - DNS alias.

Headless Service is a special type for StatefulSet (required for direct access to specific feeds).

Ingress

Level 7 (HTTP). Allows you to configure routing by domain, path, TLS termination. Popular implementations: Nginx Ingress, Traefik, Contour, Istio Gateway.

## 5. Data storage in Kubernetes

• emptyDir - Temporary storage within the Pod.
• hostPath - Node disc binding (not recommended in production).
• PersistentVolume (PV) + PersistentVolumeClaim (PVC) - abstraction over storage (Ceph, Longhorn, cloud drives).
• StorageClass - Templates for automatic PV creation.

Important point: Use Local Persistent Volumes only if you understand the risks, or modern distributed storage solutions (Longhorn, Rook+Ceph).

## 6. Configurations and secrets

• ConfigMap for insensitive settings.
• Secret - for passwords, tokens, certificates. Base64 is the default, but you can enable encryption at rest.
• External Secrets Operator is the best approach in 2026: pulling secrets from HashiCorp Vault, AWS Secrets Manager, Yandex Lockbox.

## 7. Network on Kubernetes

Networking is one of the most difficult parts:

• CNI (Container Network Interface): Calico, Cilium (highly recommended in 2026), Flannel.
• Network Policies - Firewall between pods (who can communicate with whom).
• Service Mesh (Istio, Linkerd, Cilium Service Mesh) is an advanced level: traffic management, mTLS, observability, fault injection.

## 8. Scaling

• Horizontal Pod Autoscaler (HPA) - by CPU, memory, custom metrics.
• Vertical Pod Autoscaler (VPA).
• *Cluster Autoscaler adds/removes Nodes.
• KEDA - event-driven autoscaling (very powerful for queues, Kafka, RabbitMQ).

## 9. Security (a very important section)

• RBAC (Role-Based Access Control) - Strictly configure the rights.
• Pod Security Standards (Restricted, Baseline, Privileged).
• *Network Policies is required in production.
• Image scanning (Trivy, Grype).
• Runtime security (Falco).
• OPA/Gatekeeper - Politics as code.
• Service Account Tokens, IRSA (AWS), Workload Identity.

** Best practice**: Never run a production cluster with --allow-privileged and minimum rights.

## 10. GitOps and Modern Workflow

In 2026, almost all serious teams use GitOps:

• ArgoCD or Flux.
• The entire state of the cluster is stored in Git.
• Changes via Pull Request → Automatic Apply.

## 11. Monitoring and Observability

• Prometheus + Grafana (or VictoriaMetrics).
• Loki / Tempo for logs and trays.
• OpenTelemetry as a standard.
• Alertmanager + OnCall.

## 12. When to Use Kubernetes (Realistically)

It is worth using if:

• More than 5-7 microservices.
• High availability requirements (99.9%+).
• Frequent deployments (several times a day).
• Team > 5 developers.
• Multi-regional or multi-cluster deployment is required.

You shouldn't if:

• Simple site / bot / monolith.
• Small team.
• Budget is limited (managed Kubernetes costs money).

## 13. Popular Tools 2026

• kubectl + k9s (terminal UI).
• Lens/Kubernetes Dashboard.
• Helm (or plain YAML + Kustomize).
• Terraform/Crossplane for infrastructure.
• ArgoCD, Flux, Tekton, Jenkins X.

## 14. A simple but real example of Deployment + Service

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-v2
spec:
  replicas: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 25%
      maxSurge: 25%
  template:
    spec:
      containers:
      - name: api
        image: vibecode/api:2.4.1
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "800m"
            memory: "1.5Gi"
        livenessProbe:
          httpGet:
            path: /healthz
            port: 3000

## Conclusion

Kubernetes is a powerful but complex platform. It offers incredible flexibility and reliability, but it requires serious investment in knowledge and infrastructure.

Having mastered Kubernetes, you move to a whole new level as a developer and architect. Even if you don’t manage huge clusters, understanding the principles (declarative, reconciliation loop, self-healing) will greatly improve your thinking.

Recommendation for study:

1. Minikube or kind.
2. Official tutorials + Kubernetes The Hard Way.
3. Launch your first production-like cluster on 3-5 nodes.
4. Learn Cilium, ArgoCD, Helm.

If you have a specific scenario (bots, AI services, high load) – write in the comments, I will help to adapt the recommendations for your task.

Good luck with Kubernetes! This is one of the most valuable skills of a modern developer in 2026.