Cloud Parts

Kubernetes

The standard open-source orchestrator: declare the containers you want, and controllers keep the cluster matching it.

What it is
Container orchestration
Type
Open source
Made by
Cloud Native Computing Foundation
License
Apache 2.0
Facts checked
5 October 2026
Website Source code

What it is

A Kubernetes cluster has a control plane (an API server backed by the etcd key-value store, a scheduler and a set of controllers) and worker nodes, each running an agent called the kubelet. You submit objects to the API, such as a Deployment that asks for three replicas of a Pod. The scheduler picks a node with enough free CPU and memory for each Pod, the kubelet starts its containers, and controllers keep comparing what exists with what you asked for, replacing Pods that crash or whose node disappears.

Google open-sourced Kubernetes in 2014, and it is now run by the CNCF. Its real difference from simpler orchestrators is the API itself: everything (load-balanced Services, config, secrets, storage volumes, batch Jobs) is a declarative object, and you can add your own object types with controllers that manage them. That is why databases, autoscalers and deploy tools ship as Kubernetes “operators”, and why every major cloud sells a managed version (EKS, GKE, AKS).

Why teams pick it

  • Self-healing, rolling updates and rollbacks, service discovery and bin packing built in
  • Runs the same way on every cloud and on your own hardware
  • Extensible API: custom resources and operators let other tools plug in as first-class objects
  • Designed for clusters of up to 5,000 nodes and 150,000 Pods

Watch out for

  • Many moving parts: networking, ingress, storage, upgrades and RBAC all need expertise
  • The control plane and per-node agents cost money and attention even for a tiny app
  • It doesn’t add or remove machines on its own; you need a node autoscaler such as Karpenter
  • Containers on a node share its kernel, so mixing untrusted tenants needs extra sandboxing, such as gVisor or Kata Containers through a RuntimeClass

The Kubernetes family

14 technologies built from or on Kubernetes

Distributions

K3sOpen sourceA certified Kubernetes distribution in one small binary, built for edge, IoT and other places where a full cluster is too heavy, with SQLite or embedded etcd for state.MicroK8sOpen sourceCanonical’s Kubernetes in one snap package: installs with one command on Linux, forms a highly available cluster by itself at three nodes, and adds features as addons.Red Hat OpenShiftCommercialRed Hat’s Kubernetes platform: Kubernetes plus its own OS, operators that install and upgrade everything, and stricter security defaults, sold by subscription.RKE2Open sourceSUSE’s security-focused Kubernetes distribution: one binary per node, hardened defaults, FIPS-validated crypto and close alignment with upstream.Talos LinuxOpen sourceA Linux distribution that only runs Kubernetes: immutable, minimal, with no shell or SSH, and managed entirely through an API.

Alternatives

What all container orchestration have in common →
HashiCorp NomadCommercialA scheduler in one binary that places containers, plain executables, Java apps and VMs across a cluster.

How it fits with other technologies

What uses Kubernetes

A Deployment that keeps three replicas running · yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 3
  selector:
    matchLabels: { app: api }
  template:
    metadata:
      labels: { app: api }
    spec:
      containers:
        - name: api
          image: registry.example.com/api:1.4.2
          resources:
            requests: { cpu: 250m, memory: 512Mi }

See it in a real stack

Web app on Kubernetes →
Live model
What you’re watchingRequests are spread across the pods. Each pod asks Redis first; hits come straight back, misses go on to PostgreSQL. Every 12 seconds one pod is taken down and the load balancer routes around it while Kubernetes replaces it.

Worth exploring

Slides· September 2025How and Why Datadog moved from cloud-managed to self-managed PostgresNick Canzoneri, Datadog, at PGConf NYC 2025Slides from a talk on why a company running hundreds of Postgres clusters across several clouds left managed services for its own Postgres platform on Kubernetes, how it moved a whole region, and what got better and worse. The stack is Patroni (with ZooKeeper for leader election), WAL-G backups, a Helm chart rather than an operator, and Temporal workflows for automation. Useful before you weigh RDS-style convenience against running Postgres yourself.
Article· August 2025lambda to eks pod migrationAWS re:Post community questionA short Q&A on what replaces Lambda’s built-in triggers, SQS polling and scaling when functions move to EKS pods. The useful answer points to KEDA (with Karpenter) for scaling pods on queue depth; the longer answer is an unreviewed AI-generated checklist from AWS’s own assistant, so treat it as a starting list, not guidance.
Article· January 2025How to create Kubernetes Jobs from AWS LambdaCloudfleetA tutorial for a Lambda function (a Bash custom runtime that downloads kubectl on start) that runs kubectl commands against a cluster, used here to launch a Kubernetes Job in response to an event. It is written for Cloudfleet’s own managed Kubernetes and its CLI, so the authentication steps need changing for other clusters, and passing raw kubectl arguments in an event is fine for a demo but too permissive for production.
Article· November 2024Kubernetes for databases: weighing the pros and consKate Obiidykhata, Percona, on the CNCF blog (first published on The New Stack)A short, high-level overview of why companies move databases onto Kubernetes (one platform across clouds and data centres, self-service, scaling, built-in failover) and the three ways to get there: a cloud DBaaS, a private DBaaS product, or an internal platform built from operators and monitoring. There is no technical depth or data. It is a CNCF member post by a Percona employee and ends by recommending Percona Everest, so read it as a vendor’s framing of the choice.
Article· August 2023Using Kubernetes with AWS Lambda: Scaling Up Your Serverless ApplicationsRohit Ghumare, LumigoA vendor blog post whose concrete part is a walkthrough of creating a Lambda function from an EKS cluster with the AWS Controllers for Kubernetes (ACK) Lambda controller, closely following AWS’s own 2022 tutorial. The benefits section is vague and blurs what Kubernetes and Lambda each do, and the post ends with a pitch for Lumigo’s observability product.
Article· March 2023The Great Lambda Migration to Kubernetes Jobs: a Journey in Three PartsLiav Yona, InfoQA first-person account of how Firefly moved event-driven work off Lambda (after hitting the 15-minute timeout), briefly onto ECS, and finally onto Kubernetes Jobs on EKS, with practical notes on reusing container images, swapping an IAM trust policy for EKS OIDC, moving environment variables into ConfigMaps and a blue/green cutover. It is one company’s story with few numbers, and the author’s employer sells infrastructure-as-code tooling, which colours the emphasis on IaC.
Article· August 2022Deploying AWS Lambda functions using AWS Controllers for Kubernetes (ACK)Rajdeep Saha, AWS Compute BlogAWS’s step-by-step tutorial for managing Lambda functions as Kubernetes custom resources: install the ACK Lambda controller in EKS, give it IAM permissions through IRSA, then kubectl apply a Function manifest that points at code in S3. It explains why you might (one GitOps and RBAC model for pods and functions) but, being AWS’s own post, not the drawbacks.
Article· May 2021Spice up Your Kubernetes Environment with AWS LambdaLiav Yona, MediumShows how a Lambda function triggered by SQS or SNS can forward events to an internal (ClusterIP) service in EKS through the Kubernetes API server’s service proxy, using IAM-to-RBAC mapping instead of exposing an endpoint, with code on GitHub. A clever pattern, but written for 2021-era EKS: it maps the IAM role through the aws-auth ConfigMap, and it routes application traffic through the cluster’s control plane.
Article· February 2021Alternative to AWS lambda serverless concept in Kubernetes?Stack Overflow question by ajsgA team running everything on Kubernetes asks how to get Lambda-style, per-request scaling for loading AI models from S3. The 2021 answers name Knative, KFServing (now KServe) and Kubeless (since archived), which makes it a quick snapshot of the options rather than an up-to-date guide.
Article· October 2020Is there a way to containerized a normal AWS Lambda function?Stack Overflow question by Sivvie LimA newcomer asks how to move an SNS-triggered Lambda function into a container on EKS. The answers, from October 2020, point to the lambci/docker-lambda images (since deprecated in favour of AWS’s official Lambda base images) and to Knative; read it mainly for the question, which is a common one, rather than for current tooling.
ArticleKubernetes in a microVMsmol machines docsThe vendor’s own guide to two ways of combining Kubernetes with microVMs: a containerd shim and RuntimeClass that start each pod as its own VM (marked experimental, with its known blockers listed), or a whole k3s cluster, through k3d, inside one VM. Useful for the concrete details, such as per-pod overhead, the /dev/kmsg device the kubelet needs and why Docker’s storage must sit on ext4, but written to sell smolvm.
ArticleUsing Lambda with KubernetesAWS Lambda Developer GuideAWS’s short docs page on managing Lambda functions through the Kubernetes API, with either AWS Controllers for Kubernetes (ACK) or Crossplane, and the use cases for each (reusing RBAC and IAM roles for service accounts, GitOps, tag policies). It covers provisioning only: the functions still run on Lambda, not in your cluster.
All resources →
Where it came from2013–2026

Google had started experimenting with containers more than a decade earlier to squeeze more work out of its servers, and ran them across huge clusters with an internal system called Borg and later its successor, Omega. Outside, Docker had just made containers easy to build and run on one machine in 2013, but there was no common way to run them across a fleet of machines. Meanwhile customers of Google Compute Engine were paying for a lot of CPUs with “extremely low” utilisation, because they were running whole VMs.

In summer 2013 Craig McLuckie, Joe Beda and Brendan Burns pitched Urs Hölzle, Google’s head of technical infrastructure, on a container manager for everyone else, built on Borg and Omega’s lessons; Eric Brewer helped win approval. Its codename, Project Seven of Nine, a nod to Borg via Star Trek, is why the Kubernetes logo has seven sides. The first commit landed on June 6, 2014, and the project was unveiled at DockerCon that month. Version 1.0 shipped on July 21, 2015, and Google worked with the Linux Foundation to create the Cloud Native Computing Foundation, with Kubernetes as its founding project.

Kubernetes became the common layer for running containers: Microsoft and AWS announced managed versions in 2017, and an ecosystem of tools is built on its API. It even outgrew Docker, dropping its built-in Docker support in version 1.24 (2022).

Why it’s built this way

Declare the desired state; controllers converge on it
You store what you want, and independent controllers keep comparing it with what exists. They react to the current state rather than to individual events, so a missed message or crashed component heals itself on the next pass.
Every Pod gets its own IP address
When apps share a machine’s IP they must coordinate ports, which the docs call “very difficult to do at scale”. One IP per Pod lets every app use the port it expects, at the cost of more networking work.
Built-in features use the same API as add-ons
Kubernetes exposes the same interfaces it uses itself, so custom resources and controllers (“operators”) can teach it about databases or certificates as if they were native objects.
Open source, then a neutral foundation
The founders wanted instant feedback and engineers from businesses that would actually deploy containers. Handing it to the CNCF in 2015 put it under neutral governance rather than Google’s alone.

Timeline

  1. 2013

    McLuckie, Beda and Burns pitch the project inside Google

  2. 2014

    First commit on June 6; unveiled at DockerCon

  3. 2015

    Version 1.0 on July 21; donated to the newly formed CNCF

  4. 2017

    Microsoft (AKS) and AWS (EKS) announce managed Kubernetes

  5. 2022

    Version 1.24 removes the built-in Docker shim

  6. 2026

    Version 1.37 released in August

Sources8 · facts checked 5 October 2026

Improve this page on GitHub