What is Kubernetes and what are its core concepts?

Question

Accepted Answer

**Kubernetes (K8s)** is the dominant **container orchestration** platform — it automates deploying, scaling, and managing containerized applications across a cluster of machines. Understanding its core concepts (pods, deployments, services, etc.) is important for running containers at scale.

## What Kubernetes does

```text
Kubernetes manages containers across a CLUSTER of nodes (machines), providing:
  → SCHEDULING (place containers on nodes), SELF-HEALING (restart failed containers),
    SCALING (up/down, auto), ROLLING UPDATES/rollbacks, SERVICE DISCOVERY,
    LOAD BALANCING, CONFIG/SECRET management, STORAGE orchestration
→ DECLARATIVE: you describe the DESIRED STATE; K8s continuously makes reality match it.
```

## Core concepts

```text
POD       → the smallest deployable unit: one (or a few tightly-coupled) containers
            sharing network/storage. K8s schedules pods (not bare containers).
DEPLOYMENT→ declares desired pods (replicas) for a stateless app; manages rollouts,
            scaling, self-healing (recreates pods to match the desired count).
SERVICE   → a stable network endpoint + load balancing for a set of pods (pods are
            ephemeral with changing IPs; a Service gives a stable name/IP).
INGRESS   → routes external HTTP(S) traffic to services (with rules, TLS).
CONFIGMAP / SECRET → inject configuration / sensitive data into pods.
NAMESPACE → virtual cluster partitioning (isolate environments/teams).
NODE      → a worker machine; the CONTROL PLANE manages the cluster.
```

## The declarative model

```yaml
# describe DESIRED state in YAML; K8s makes it so (and keeps it so)
apiVersion: apps/v1
kind: Deployment
spec:
  replicas: 3                  # "I want 3 instances" → K8s ensures 3 are always running
  # if a pod dies, K8s creates a new one; if a node fails, pods move
```

## Why it matters

Understanding Kubernetes and its core concepts is important senior-level knowledge for **running containerized applications at scale**, as Kubernetes is the dominant, industry-standard orchestration platform that underpins much of modern cloud-native deployment.

Understanding **what Kubernetes does** — automating scheduling, self-healing, scaling, rolling updates, service discovery, and load balancing across a cluster, all through a **declarative model** where you describe the desired state and Kubernetes continuously makes reality match it — captures the powerful operational capabilities it provides and its fundamental approach.

Understanding the **core concepts** is essential for working with Kubernetes: **pods** (the smallest deployable unit, wrapping containers), **deployments** (declaring desired replicas and managing rollouts, scaling, and self-healing for stateless apps), **services** (providing stable network endpoints and load balancing for ephemeral pods — solving the problem that pod IPs change), **ingress** (routing external traffic), **ConfigMaps/Secrets** (injecting configuration and sensitive data), and **namespaces** (partitioning the cluster) — these are the building blocks of any Kubernetes application.

The **declarative model** (specifying desired state like "3 replicas" and letting Kubernetes maintain it, recreating failed pods automatically) is a key conceptual shift that enables self-healing and reliable operations.

Since Kubernetes is the de facto standard for container orchestration (used pervasively for cloud-native applications at scale), and since understanding its core concepts and declarative model is foundational for deploying and managing containers in modern production environments, understanding Kubernetes basics is important senior-level knowledge — increasingly essential for modern infrastructure roles, framing how containerized applications are run reliably at scale and providing the conceptual foundation for working with the orchestration platform that dominates cloud-native deployment.