Python or Kubernetes First: What Beginners Should Learn

# Python — automate a deployment
# This is what DevOps engineers write to control Kubernetes.

from kubernetes import client, config
import time

# Load kubeconfig (from ~/.kube/config or in-cluster)
config.load_kube_config()

# Create the API clients
apps_v1 = client.AppsV1Api()
core_v1 = client.CoreV1Api()

# Deploy an updated image
deployment_name = "my-app"
namespace = "default"
new_image = "my-app:1.2.3"

patch = {
    "spec": {
        "template": {
            "spec": {
                "containers": [{
                    "name": "my-app",
                    "image": new_image,
                }]
            }
        }
    }
}

apps_v1.patch_namespaced_deployment(
    name=deployment_name,
    namespace=namespace,
    body=patch,
)
print(f"Patched {deployment_name} with image {new_image}")

# Wait for the rollout to finish
for _ in range(30):
    d = apps_v1.read_namespaced_deployment(deployment_name, namespace)
    if d.status.ready_replicas == d.spec.replicas:
        print("Rollout complete")
        break
    time.sleep(5)
else:
    print("Rollout did not finish in 150s")

# What this does:
# - Talks to the Kubernetes API programmatically
# - Patches a deployment with a new image
# - Polls until the rollout is complete
#
# Why this matters:
# Every Kubernetes tool you use — kubectl, ArgoCD, Helm —
# is doing exactly this under the hood. Writing it yourself
# is how you understand what the tools are actually doing.
#
# Notice: this is Python controlling Kubernetes. Not the
# other way around. That's the direction of the dependency.

# Python — a custom Kubernetes operator
# The clearest example of why Python comes first.

import kopf
import kubernetes
from kubernetes import client

# A "Memcached" operator — creates a deployment with the
# right number of replicas whenever the Memcached resource changes.

@kopf.on.create("example.com", "v1", "memcacheds")
def create_fn(spec, name, namespace, **kwargs):
    size = spec.get("replicas", 1)

    # Build a simple deployment spec
    deployment = client.V1Deployment(
        metadata=client.V1ObjectMeta(name=name, namespace=namespace),
        spec=client.V1DeploymentSpec(
            replicas=size,
            selector=client.V1LabelSelector(
                match_labels={"app": name}
            ),
            template=client.V1PodTemplateSpec(
                metadata=client.V1ObjectMeta(labels={"app": name}),
                spec=client.V1PodSpec(
                    containers=[
                        client.V1Container(
                            name="memcached",
                            image="memcached:1.6",
                            ports=[client.V1ContainerPort(container_port=11211)],
                        )
                    ]
                ),
            ),
        ),
    )

    api = client.AppsV1Api()
    api.create_namespaced_deployment(namespace=namespace, body=deployment)

    return {"message": f"Created memcached deployment with {size} replicas"}

# What this does:
# - Registers a custom Kubernetes resource type (Memcached)
# - When someone creates one, this Python function runs
# - It creates the underlying Deployment automatically
#
# Why this is the killer example:
# You cannot write a Kubernetes operator without a
# programming language. Operators are how Kubernetes
# is extended — and Python (via kopf) is one of the
# easiest languages to write them in.
#
# Kubernetes is the platform. Python is how you extend it.

# Kubernetes — the YAML it actually runs.
# The same thing the operator above creates, written as YAML.
# This is what most people learn first — but it does not scale
# without Python.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: memcached
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: memcached
  template:
    metadata:
      labels:
        app: memcached
    spec:
      containers:
        - name: memcached
          image: memcached:1.6
          ports:
            - containerPort: 11211

# Run it with:
#   kubectl apply -f deployment.yaml
#
# This is the "hello world" of Kubernetes. Every beginner
# learns this first — and for good reason, it teaches the
# concept in isolation.
#
# But the limits appear quickly:
# - Deploying to 20 environments? You need a script.
# - Scaling based on custom metrics? You need a controller.
# - Rolling back based on health signals? You need automation.
# - Creating deployments from a custom resource? You need an operator.
#
# All of those require code — and in the Python ecosystem,
# that code is written in Python.

# So the sequence is:
#   1. Understand what a container is (Docker)
#   2. Apply a YAML file (kubectl)
#   3. Automate repetitive kubectl work (Python)
#   4. Extend Kubernetes itself (Python operators)
#
# Python is present from step 3 onward. It is not optional.