If you want to learn AI infrastructure in 2026,
This is for you ๐
When it comes to running AI/ML workloads on Kubernetes, Kubeflow is the foundation platform.
When the project started, it was primarily built as an MLOps platform for Kubernetes to build and manage traditional ML pipelines.
Fast forward to 2026 and the platform has changed a lot.
It is no longer just an MLOps platform.
It has become a cloud-native AI platform for building and operating GenAI, LLMOps, Agentic AI, distributed AI training, and fine-tuning foundation models.
In our newsletter, we covered the following.
- Understand the Kubeflow stack
- Learn how Kubeflow Pipelines work
- Explore the KFP architecture and execution flow
- Creating a KFP pipeline from scratch on Kubernetes
- A look into Cloudflareโs in-house MLOps platform
and more..
๐ฅ๐ฒ๐ฎ๐ฑ ๐ถ๐ ๐๐ฒ๐ฟ๐ฒ: https://t.co/HICjMzsnWJ
โป๏ธ If you find it useful, share it with fellow DevOps and Cloud Engineers.
#devops #MLOps #kubernetes
๐๐จ๐๐๐ฅ๐ก๐๐ง๐๐ฆ ๐ช๐ข๐ฅ๐๐๐ฅ ๐ก๐ข๐๐๐ฆ ๐๐ซ๐ฃ๐๐๐๐ก๐๐.
Think of a Kubernetes Worker Node like a fully equipped kitchen in a large restaurant.
The Control Plane manages the restaurant, but the kitchen is where the actual work happens. Similarly, Worker Nodes are the machines responsible for running your applications inside a Kubernetes cluster.
Here's how each component works.
๐ช๐ผ๐ฟ๐ธ๐ฒ๐ฟ ๐ก๐ผ๐ฑ๐ฒ = โThe kitchenโ
A Worker Node is a physical or virtual machine that runs application workloads. It provides CPU, memory, networking, and storage resources required to run Pods.
๐๐๐ฏ๐ฒ๐น๐ฒ๐ = โThe kitchen supervisorโ
Kubelet runs on every Worker Node. It communicates with the API Server and ensures that the Pods assigned to its node are running as expected.
๐๐ผ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฟ ๐ฅ๐๐ป๐๐ถ๐บ๐ฒ = โThe cooking equipmentโ
The container runtime is responsible for running containers inside Pods. Examples include containerd and CRI-O.
๐๐๐ฏ๐ฒ-๐ฝ๐ฟ๐ผ๐ ๐ = โThe traffic coordinatorโ
Kube-proxy maintains network rules that enable communication between Services and their backend Pods. It helps route traffic to the appropriate application instances.
๐ฃ๐ผ๐ฑ๐ = โThe individual kitchen stationsโ
Pods are the smallest deployable units in Kubernetes. Each Pod contains one or more containers that share networking and can share storage resources.
๐๐ผ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฟ๐ = โThe actual cooking activitiesโ
Containers package applications with their dependencies and run inside Pods. They execute the workloads that your users interact with.
๐ฉ๐ผ๐น๐๐บ๐ฒ๐ = โThe storage shelvesโ
Volumes provide storage to containers inside Pods. They allow applications to access shared or persistent data, depending on the volume type.
๐ก๐ผ๐ฑ๐ฒ ๐ฅ๐ฒ๐๐ผ๐๐ฟ๐ฐ๐ฒ๐ = โThe kitchen's available capacityโ
Every Worker Node has limited CPU, memory, and storage. Kubernetes uses resource requests and limits to help allocate resources and manage workloads.
The simple mental model:
โ Worker Node: Provides the machine that runs applications.
โ Kubelet: Ensures assigned Pods are running.
โ Container Runtime: Runs containers.
โ Kube-proxy: Helps manage Service networking.
โ Pods: Host application containers.
โ Volumes: Provide storage.
โ Node Resources: Supply CPU and memory.
๐๐ผ๐ ๐ฑ๐ผ๐ฒ ๐ถ๐ ๐ฎ๐น๐น ๐๐ผ๐ฟ๐ธ ๐๐ผ๐ด๐ฒ๐๐ต๐ฒ๐ฟ?
The Control Plane schedules a Pod onto a suitable Worker Node.
Kubelet receives the assignment.
Kubelet instructs the container runtime to create and run the containers.
Containers start executing your application.
Networking components enable communication with other workloads and Services.
Kubelet continuously monitors the Pods and reports their status to the Control Plane.
The key idea: The Control Plane makes decisions, while Worker Nodes execute workloads.
Without Worker Nodes, Kubernetes would have nowhere to run your applications.
๐๐ฟ๐ฎ๐ฏ ๐๐ต๐ฒ ๐๐๐ฏ๐ฒ๐ฟ๐ป๐ฒ๐๐ฒ๐ ๐ฒ๐ฏ๐ผ๐ผ๐ธ โ https://t.co/1JQaCCc17i
What else would you add?
โโ
Repost to help others learn Kubernetes.
Follow me ( @e_opore ) to improve at AI and system design.
Jensen drove supply chain brilliantly at Nvidia, but many of those deals were a handshake with Jensen, not a written contract.
Without Jensen, at least some of those critical deals will be lost.
New instructor-led course: Building GPU Platforms on Kubernetes
From Kubernetes fundamentals to GPU allocation, sharing, isolation, and efficiency, including NVIDIA Kubernetes Engine (NVKE)
https://t.co/AaTff62XTa
Kubernetes Operators can help you wrangle complex applications.
They let you manage external systems like everything else in the cluster.
In this handbook, @karan_6864 goes over how to create operators to automate tasks in Kubernetes apps.
https://t.co/exYNDFln4a
Anatomy of an AI Agent: Understanding the 5 Key Components
An AI Agent is more than just an LLM. It's a combination of intelligence, knowledge, tools, and execution.
Here's how the main components work together:
1๏ธโฃ LLM = The Brain
Reads, writes, reasons, and makes decisions.
2๏ธโฃ RAG = Brain + Library
Retrieves relevant information from external knowledge sources before generating answers.
3๏ธโฃ MCP = The Nervous System
Connects AI models with external tools, applications, and data through a standardized protocol.
4๏ธโฃ Skills = Muscle Memory
Reusable instructions and workflows that help an agent perform tasks consistently.
5๏ธโฃ AI Agent = Brain + Hands
Combines reasoning, planning, and tools to execute tasks autonomously.
The Big Picture:
LLM provides intelligence.
RAG provides knowledge.
MCP provides connectivity.
Skills provide reusable capabilities.
AI Agents bring everything together to get work done.
Want to Learn More? Explore These AI Courses from CLCODING:
1. IBM RAG and Agentic AI Professional Certificate
Learn RAG, LangChain, LangGraph, CrewAI, MCP, vector databases, and multi-agent systems.
https://t.co/YNzp0HsD5J
2. Agentic AI Foundations: Build RAG & MCP Chatbots
Learn AI agents, embeddings, RAG pipelines, MCP, tool calling, and chatbot development.
https://t.co/8Y7yoVy02G
Explore more AI, Python, and Data Science learning resources:
Kubernetes User Namespaces โก
It is a security feature that maps user and group IDs inside a container to a different set of IDs on the host (Rootless Isolation)
Here is the key idea.
A process running as root (UID 0) inside the container runs as an unprivileged user (eg, UID 100000) on the host.
Without user namespaces, when a container runs as root, it uses the same root identity as the host.
So if an attacker breaks out of the container, they get full host privileges.
We have published a hands-on guide covering the following.
- What are User Namespaces
- How the kernel does the root-to-non-root user mapping
- What changes when you set hostUsers: false
- Limiting host UID ranges using /etc/subuid file
- Hands-on deployment to understand User Namespace
- User Namespace limitations
๐ฅ๐ฒ๐ฎ๐ฑ ๐ถ๐ ๐๐ฒ๐ฟ๐ฒ: https://t.co/F6HmkliHvS
Have you tried this feature yet?
โป๏ธ PS: Repost and share this with the community!
#devops #kubernetes
๐๐ผ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฟ๐ ๐๐ ๐ฉ๐ถ๐ฟ๐๐๐ฎ๐น ๐ ๐ฎ๐ฐ๐ต๐ถ๐ป๐ฒ๐ ๐๐ ๐ฆ๐ฎ๐ป๐ฑ๐ฏ๐ผ๐ ๐ฒ๐.
Do you know the differences?
A ๐ฐ๐ผ๐ป๐๐ฎ๐ถ๐ป๐ฒ๐ฟ isolates processes on a shared kernel. Namespaces control what each process can see, and cgroups control what resources it can use. They start fast and pack densely on one host.
For stronger isolation, ๐๐ถ๐ฟ๐๐๐ฎ๐น ๐บ๐ฎ๐ฐ๐ต๐ถ๐ป๐ฒ๐ run their own operating systems. A hypervisor gives each VM virtual hardware and a separate guest kernel, creating a stronger boundary between workloads.
When the code itself canโt be trusted, thatโs where ๐๐ฎ๐ป๐ฑ๐ฏ๐ผ๐ ๐ถ๐ป๐ด comes in. Sandboxes restrict what code can access, such as system calls, network connections, and files. Often built on containers or lightweight VMs, they can use technologies like gVisor, Firecracker, or seccomp filters.
Containers isolate processes. VMs isolate operating systems. Sandboxes restrict what untrusted code can access.
But when the code comes from an AI agent, containing the run is only half of it.
The agent's output still has to land somewhere: the company's codebase, its live product. A sandbox limits what code can touch while it runs, not what ships afterwards.
So the boundary has two parts: an isolated place for the agent to work, and a review step before changes reach production. Replit runs agents in isolated cloud environments, away from employee laptops. For work on an existing company codebase, agents turn their work into proposed changes for engineering to review.
The agent proposes the change. Engineering decides what ships.
๐ฆ๐ฒ๐ฒ ๐ต๐ผ๐ ๐ฅ๐ฒ๐ฝ๐น๐ถ๐ ๐ฟ๐๐ป๐ ๐ฎ๐ด๐ฒ๐ป๐๐ ๐ณ๐ผ๐ฟ ๐ฐ๐ผ๐บ๐ฝ๐ฎ๐ป๐ถ๐ฒ๐ โ https://t.co/Q3hwKAwPRy
What else would you add?
โโ
โป๏ธ Repost to help others learn and grow.
๐ Thanks to @Replit for sponsoring this post.
โ Follow me ( Nikki Siapno ) to improve at system design and AI.
๐ ๐๐ฃ ๐๐ ๐ฅ๐๐ ๐๐ ๐๐ ๐๐ด๐ฒ๐ป๐๐.
๐ ๐๐ฃ ๐ถ๐ ๐๐ต๐ฒ ๐ฐ๐ผ๐ป๐ป๐ฒ๐ฐ๐๐ถ๐ผ๐ป ๐น๐ฎ๐๐ฒ๐ฟ. It gives AI systems a standard way to connect to external systems and capabilities. MCP servers expose tools for querying databases, calling APIs, or taking actions, without requiring custom integrations for every client. But it handles connectivity, not retrieval.
That's where ๐ฅ๐๐ comes in. It searches your docs at query time, pulling relevant chunks into the prompt so answers can draw from your data. Keeping it current means updating an index, not retraining the model. In a basic RAG pipeline, the flow is straightforward: retrieve, then answer.
Now with ๐๐ ๐๐ด๐ฒ๐ป๐๐, the model runs in a loop: plan a step, call a tool, read the result, repeat until the goal is met. That handles multi-step tasks, at the cost of more latency, tokens, and failure points.
So the choice comes down to the gap you're closing: access to systems, knowledge from your data, or action over many steps.
But executing a task successfully doesn't necessarily mean it's still the right task.
Priorities shift, budgets change, and teams move between projects. Both humans and AI agents can keep executing work that no longer aligns with the bigger plan.
The problem is that strategy, capacity, spend, and execution data often live in different systems. By the time a quarterly review reveals the gap between plan and reality, time and budget have already been spent.
Catching that drift early means continuously connecting what was planned with the work actually happening, across both human teams and AI agents.
Tempo Loop brings together time, capacity, spend, and execution data in one unified view across human and AI-agent work.
It answers a simple question without chasing status updates: Are we still working on the right things?
When something drifts, Loop identifies the gap, recommends corrective actions with tradeoff context, and orchestrates approved changes back into the systems teams already use, like Jira.
๐๐ด๐ฒ๐ป๐๐ ๐น๐ผ๐ผ๐ฝ ๐ผ๐ป ๐๐ฎ๐๐ธ๐. ๐ง๐ต๐ถ๐ ๐ผ๐ป๐ฒ ๐น๐ผ๐ผ๐ฝ๐ ๐ผ๐ป ๐ฝ๐ฟ๐ถ๐ผ๐ฟ๐ถ๐๐ถ๐ฒ๐.
๐ฆ๐ฒ๐ฒ ๐ต๐ผ๐ ๐ง๐ฒ๐บ๐ฝ๐ผ ๐๐ผ๐ผ๐ฝ ๐๐ผ๐ฟ๐ธ๐ โ https://t.co/gG53bFKIYa
What else would you add?
โโ
โป๏ธ Repost to help others learn AI.
๐ Thanks to @TempoHQ for sponsoring this post.
โ Follow me ( Nikki Siapno ) to improve at AI and system design.
GPU scheduling in Kubernetes is becoming an important skill now.
Here is why ๐
Most organizations are either experimenting or running ML workloads in Kubernetes.
As Devops engineers you should know how to set up and manage GPU resources.
We have created a simple guide on setting up GPU node using NVIDIA GPU Operator
By the end of this blog, you will have a clear understanding of:
- Need for GPU operator on Kubernetes
- Setting up NVIDIA GPU Operator on a Kubernetes cluster
- Verify if Kubernetes detects GPUs
- How to deploy a real GPU-based workload to validate the full stack.
To be honest, it is not as complicated as it sounds once you understand the basics.
Even if you dont have access to GPU's, just go through the content to have an understanding on how it works.
๐ฅ๐ฒ๐ฎ๐ฑ ๐ถ๐ ๐ต๐ฒ๐ฟ๐ฒ: https://t.co/nTPpIb0rtW
#devops #mlops
Introducing Claude Fable 5.2 and Claude Mythos 5.2, designed to tackle the most daunting technical challenges.
Theyโre capable collaborators on ambitious projects in many fields, and show improvements in areas like coding, reasoning, and vision.
Deploying Pods is one skill. Understanding Kubernetes networking in production takes these 15. ๐
๐๐ฎ๐๐๐ซ๐ง๐๐ญ๐๐ฌ ๐๐๐ญ๐ฐ๐จ๐ซ๐ค๐ข๐ง๐ : ๐๐ ๐๐ซ๐จ๐๐ฎ๐๐ญ๐ข๐จ๐ง ๐๐ค๐ข๐ฅ๐ฅ๐ฌ ๐๐๐ฒ๐จ๐ง๐ ๐๐๐ฌ๐ข๐ ๐๐๐
1. ๐๐๐ & ๐๐๐๐
Understand how Pods receive interfaces, IP addresses, and routes. Diagnose IP exhaustion and failed network setup.
2. ๐๐จ๐-๐ญ๐จ-๐๐จ๐ ๐๐จ๐ฎ๐ญ๐ข๐ง๐
Trace same-node and cross-node traffic. Know whether your cluster uses an overlay or directly routed Pod IPs.
3. ๐๐๐
Understand logical switches, routers, ACLs, and load balancers in clusters using OVN.
4. ๐๐ฉ๐๐ง ๐ฏ๐๐ฐ๐ข๐ญ๐๐ก (๐๐๐)
Inspect bridges, ports, tunnels, and flows. Connect OVNโs logical configuration to actual packet forwarding.
5. ๐๐๐ ๐๐จ๐ฎ๐ญ๐ข๐ง๐
Map Pod CIDRs, node subnets, route tables, and cloud firewalls. Always verify the return path.
6. ๐๐๐ซ๐ฏ๐ข๐๐ ๐๐๐๐ฌ
Understand how a ClusterIP reaches backend Pods. Identify which component implements Service forwarding in your cluster.
7. ๐๐๐ซ๐ฏ๐ข๐๐ ๐๐จ๐๐ ๐๐๐ฅ๐๐ง๐๐ข๐ง๐
Learn your actual dataplane: kube-proxy or a CNI-provided implementation. Troubleshoot backend selection and connection persistence.
8. ๐๐ง๐๐ฉ๐จ๐ข๐ง๐ญ๐๐ฅ๐ข๐๐๐ฌ
Check backend IPs, ports, and readiness conditions. A Service can exist while having no eligible backends.
9. ๐๐๐๐
Understand when source addresses change. Track the IP external systems actually see.
10. ๐๐๐๐
Trace destination translation from a Service address to a backend. Verify ๐๐๐๐, ๐๐๐๐๐๐๐ฟ๐๐๐, and application listeners.
11. ๐๐ ๐ซ๐๐ฌ๐ฌ ๐๐๐ญ๐๐ฐ๐๐ฒ๐ฌ
Use implementation-specific egress controls for predictable outbound IPs. Test failover, routing, and external allowlists.
12. ๐๐๐ญ๐ฐ๐จ๐ซ๐ค ๐๐จ๐ฅ๐ข๐๐ข๐๐ฌ
Start with default deny, then allow required traffic. Check both source egress and destination ingress, including DNS.
13. ๐๐ฑ๐ญ๐๐ซ๐ง๐๐ฅ ๐๐ซ๐๐๐๐ข๐ & ๐๐จ๐ฎ๐ซ๐๐ ๐๐
Understand LoadBalancer, NodePort, and ๐๐ก๐๐๐๐๐๐๐๐๐๐๐๐๐๐ฟ๐๐๐๐๐ข. Test source-IP preservation and nodes without local backends.
14. ๐๐๐ & ๐๐๐
Debug name resolution separately from connectivity. Check tunnel overhead when small requests work but larger transfers stall.
15. ๐๐๐๐ค๐๐ญ-๐๐๐ฏ๐๐ฅ ๐๐ซ๐จ๐ฎ๐๐ฅ๐๐ฌ๐ก๐จ๐จ๐ญ๐ข๐ง๐
Combine ๐๐๐๐๐๐๐, route inspection, conntrack, and dataplane tools. Find exactly where packets disappear.
Practice tracing two paths:
Pod โ Service โ backend Pod
Pod โ egress path โ external API โ return path
Bookmark this for your next networking incident or platform engineering interview. ๐
Deleting a pod โ stopping it instantly
Here is the hidden shutdown flow Kubernetes follows๐
- The API server sends a deletion event.
- Kubernetes executes the PreStop hook if any exists.
- kubelet sends a SIGTERM signal to the container's main process (PID 1).
- Applications have 30 seconds by default to handle the signal and shut down gracefully.
- If the application process does not exit within the grace period, Kubernetes sends a SIGKILL signal to terminate the pod.
๐ก๐ผ๐๐ฒ: Kubernetes does not give extra time for the PreStop hook. If your pod has a 30-second grace period, the PreStop hook and your appโs shutdown process must both finish within those same 30 seconds.
We covered the following in detail in our newsletter edition.
- What are SIGTERM and SIGKILL
- How Kubernetes handles SIGTERM and SIGKILL
- How applications can handle SIGTERM for graceful shutdown
- The role of PreStop hooks and why it matters
- The link between SIGTERM and container PID 1
โ ๐ฅ๐ฒ๐ฎ๐ฑ ๐ถ๐ ๐๐ฒ๐ฟ๐ฒ: https://t.co/jGjVUm0aSa
Over to youโฆ
Have you written any custom logic to handle SIGTERM?
#devops #kubernetes