Kubernetes for DevOps Engineers: Mastering Modern Patterns

With Kubernetes v1.35 (released Dec 17, 2025) deprecating cgroups v1 and the community Ingress-NGINX project entering its final sunset phase, the standard “happy path” for developers has fundamentally changed. These aren’t minor footnotes; they are architectural pivots that shift how services are exposed, secured, and scaled.

This guide equips you with a modern Kubernetes setup using Minikube and explores what these changes mean for your development pipeline. Whether you’re refactoring legacy manifests or preparing for Gateway API adoption, this article helps you move with the Kubernetes project — not behind it.

Kubernetes: Orchestration With Real-World Constraints

Kubernetes continues to define modern application delivery through declarative automation, but beneath the abstractions are opinionated patterns evolving with each release. As of v1.35, the platform prioritizes simplicity, observability, and runtime standardization.

Core primitives you must now architect with:

• Pods: Container execution boundary (now exclusively on cgroup v2).
• Deployments: Rolling lifecycle management.
• Gateway API: The extensible, role-oriented standard for ingress (replacing Ingress controllers).
• Custom Resources: API extensibility for repeatable workflows.

Quickstart on Kubernetes: A Future-Ready Lab

Spinning up a Kubernetes cluster locally isn’t just for beginners. It’s your safest space to explore breaking changes and next-generation features before introducing them into CI/CD pipelines.

Step 1: Install Tooling

Use Homebrew to install the CLI components:

brew install kubectl minikube

Step 2: Start Minikube With Modern Defaults

We’ll launch Minikube with Cilium (eBPF networking) and the Gateway API enabled, ensuring we aren’t testing on deprecated IPVS or iptables modes.

minikube start \  --cni=cilium \  --addons=gateway-api \  --container-runtime=containerd \  --kubernetes-version=v1.35.0

⚠️ Ensure your Minikube binary is updated to the latest version to support v1.35+ options.

Step 3: Deploy a Workload (The Correct Way)

We’ll use Kubernetes’ own test image, agnhost. Note: it requires a subcommand to start the HTTP server.

kubectl create deployment echo-server \  --image=registry.k8s.io/e2e-test-images/agnhost:2.40 \  --replicas=1 \  -- /agnhost netexec --http-port=8080

Step 4: Expose via Gateway API (Not NodePort)

Instead of using kubectl expose, we’ll define an HTTPRoute to use Gateway API routing the modern way.

Create a file named route.yaml with the following contents:

apiVersion: gateway.networking.k8s.io/v1 kind: HTTPRoute metadata:  name: echo-route spec:  parentRefs:  - name: api-gateway    sectionName: http  rules:  - matches:    - path:        type: PathPrefix        value: /echo    backendRefs:    - name: echo-server      port: 8080

Apply it:

kubectl apply -f route.yaml

Get the Gateway IP:

kubectl get gateway api-gateway -o jsonpath='{.status.addresses[0].value}'

You can now curl the Gateway IP at /echo to reach your service.

This setup gives you hands-on exposure to the real mechanics: L7 routing without legacy Ingress controller overhead.

What Kubernetes v1.31 to v1.35 Tells Us About the Future

Kubernetes isn’t just versioning — it’s refactoring itself in place. These releases deliver clues about what developers should prioritize next.

1. Ingress-NGINX (Community) Is Winding Down

With the community-maintained kubernetes/ingress-nginx project entering sunset (EOL March 2026), reliance on it is now technical debt. The ecosystem is standardizing on the Gateway API.

Visual comparison:

2. Runtime Architecture Has Matured

• cgroups v1 is dead: v1.35 kubelets will fail to start on legacy Linux nodes. Ensure your base OS uses systemd with cgroup v2.
• IPVS deprecated: nftables is the new preferred backend for kube-proxy, offering better performance at scale.
• containerd 2.0: With containerd 1.x reaching EOL, pipelines must validate against 2.0 schemas.

3. Observability and Resilience Are First Class

Tracing for the kubelet and API server is now GA. You no longer need sidecars just to understand why a Pod is slow to start; the signals are native to the control plane.

Kubelet restart behavior has improved to retain Pod readiness state and reduce flapping during node maintenance.

In-place Pod vertical scaling (GA): You can now update CPU and memory requests on running Pods without recreating them, enabling more elastic, cost-efficient workloads.

Final Thoughts: Code Like You Operate It

Kubernetes v1.35 isn’t just another minor bump — it’s a modernization cliff.

• If you’re still using Ingress objects: plan your migration to Gateway API before 2026.
• If you manage nodes: audit your Linux kernel versions for cgroup v2 support.
• If you’re stuck on older container runtimes: test against containerd 2.0 now, not later. 

The way forward is clear:

• Don’t wait for deprecation warnings to break your pipeline.
• Adopt modern primitives and prepare your manifests accordingly.
• Use tools like Minikube not for “Hello World” demos, but to validate future-facing practices.

Kubernetes isn’t waiting. Your manifests shouldn’t either.

Sources: Based on Kubernetes release notes and changelogs from v1.31 through v1.35. See the Kubernetes blog for official references.