Wat is Kubernetes en wat zijn de kernconcepten ervan?

Question

Accepted Answer

**Kubernetes (K8s)** is het dominante **container orchestration**-platform — het automatiseert het implementeren, schalen en beheren van containerized applicaties over een cluster van machines. Het begrijpen van de kernconcepten (pods, deployments, services, enz.) is belangrijk voor het uitvoeren van containers op schaal.

## Wat Kubernetes doet

```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.
```

## Kernconcepten

```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.
```

## Het declaratieve 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
```

## Waarom het belangrijk is

Het begrijpen van Kubernetes en de kernconcepten ervan is belangrijke kennis op seniorevel voor **het uitvoeren van containerized applicaties op schaal**, omdat Kubernetes het dominante, industriestandaard orchestration-platform is dat veel van de moderne cloud-native implementatie ondersteunt.

Het begrijpen van **wat Kubernetes doet** — het automatiseren van scheduling, self-healing, schaling, rolling updates, service discovery en load balancing over een cluster, allemaal via een **declaratief model** waarin je de gewenste status beschrijft en Kubernetes zorgt er voortdurend voor dat de werkelijkheid dit aansluit — legt vast wat voor krachtige operationele mogelijkheden het biedt en wat de fundamentele aanpak is.

Het begrijpen van de **kernconcepten** is essentieel voor het werken met Kubernetes: **pods** (de kleinste deployable unit, omvang van containers), **deployments** (declareren van gewenste replicas en beheren van rollouts, schaling en self-healing voor stateless apps), **services** (bieden van stabiele netwerk-eindpunten en load balancing voor kortstondige pods — oplossing van het probleem dat pod IP-adressen veranderen), **ingress** (routering van extern verkeer), **ConfigMaps/Secrets** (injectie van configuratie en gevoelige data), en **namespaces** (partitionering van de cluster) — dit zijn de bouwstenen van elke Kubernetes-applicatie.

Het **declaratieve model** (het opgeven van gewenste status zoals "3 replicas" en Kubernetes laten zorgen voor het handhaven ervan, automatisch mislukte pods opnieuw aanmaken) is een belangrijk conceptueel verschuiving dat self-healing en betrouwbare operaties mogelijk maakt.

Aangezien Kubernetes de facto standaard is voor container orchestration (veel gebruikt voor cloud-native applicaties op schaal), en aangezien het begrijpen van de kernconcepten en het declaratieve model fundamenteel is voor het implementeren en beheren van containers in moderne productieomgevingen, is het begrijpen van de Kubernetes-basisprincipes belangrijke kennis op seniorevel — steeds essentiëler voor moderne infrastructuurrollen, die bepalen hoe containerized applicaties betrouwbaar op schaal worden uitgevoerd en die het conceptuele fundament bieden voor het werken met het orchestration-platform dat cloud-native implementatie domineert.