Kubernetes on Anish Bista

Manifestation to Reality: Representing Nepal in CNCF Golden Kubestronaut Map

Tue, 29 Sep 2026 15:15:33 +0000

In this blog, I will share my Golden Kubestronaut journey, how I became the first and youngest Golden Kubestronaut from Nepal, what motivated me to pursue this path, and what it actually takes to earn the title.

Golden Kubestronaut: Basic Anatomy of the Program#

Golden Kubestronauts are individuals who have passed all 16 CNCF certifications, covering the full breadth of the cloud-native ecosystem. It is the highest recognition in the CNCF certification journey and reflects deep, hands-on expertise. You can find more details here

The Case of the Phantom Webhook Timeout: How a Floating IP blocked entire Nutanix Kubernetes Platform Deployment

Fri, 10 Jul 2026 17:38:23 +0000

While bootstrapping a Nutanix Kubernetes Platform (NKP) 2.18 management cluster on AHV, the entire deployment ground to a halt at the very first component install. nkp create capi-components never got past cert-manager and because everything downstream (cluster-api-operator, and the rest of the cluster bootstrap) depends on that step, the whole cluster build was blocked.

The error itself gave almost no clue as to why:

Post "https://cert-manager-webhook.cert-manager.svc:443/mutate?timeout=30s":
 context deadline exceeded (Client.Timeout exceeded while awaiting headers)

This kept repeating for 30+ minutes straight in the kube-apiserver logs, not a one-off startup race, but a persistent failure. The cert-manager Helm release sat stuck in pending-install. Reinstalling it manually made pods look healthy for a moment, but the next webhook-dependent step failed identically. Something below the application layer was broken.

How Rancher Saved Us During an OS Upgrade in an Air-Gapped Environment

Sun, 24 May 2026 05:02:05 +0000

Disclaimer: I am not an advocate of Rancher. Since it is open source, I hope sharing this won’t create any issues.

The Setup

We had a running RKE1 clusters in an air-gapped environment (I know it’s EOL, but it’s the customer’s choice). We were in a pre-production environment with two clusters, each an HA setup with 3 masters and 15 workers. Both clusters were, luckily, imported into Rancher.

What Happened

Don’t Make Your Users Wait: Parallelism in Kubernetes Operators

Sun, 17 May 2026 05:03:52 +0000

Note: This is hand written blog and further refractored but not an AI Slop.

The Restaurant Example#

Now, here is the story. Let’s say you are in a restaurant which has only one counter to take the order and each order is taking 1 minute to finish. Let’s say there are 50 people in the queue. Now, the 50th person who is in the queue at 10:00 AM needs to wait till 10:50 AM for his order to be picked. Now, this is what it feels like as a customer who is very hungry :) and I can’t wait for so long, right.

How We Migrated from Ingress Nginx to Traefik Ingress Controller

Wed, 04 Mar 2026 07:44:59 +0000

Note: This is a hand-written blog. In this blog, I am going to walk you through how we migrated from the ingress-nginx controller to the Traefik ingress controller. Let’s get started, I will try to keep it concise and short.

Those who don’t know: ingress-nginx is going to retirement , so I am sure the majority of organizations are affected. Before that, I would like to take a moment to thank all the maintainers and contributors who have made public traffic management great over the last 10 years. Everything eventually reaches its end of life, but with every ending comes new innovation and adoption.

Event-Driven Design: The Core Principle Behind Kubernetes Architecture

Sat, 24 Jan 2026 15:56:13 +0000

Note: This is a handwritten blog. In this blog, we should explore the event where the architecture of Kubernetes is discussed. It will be very short.

As you know, Kubernetes follows an event-driven architecture. The Kubernetes control plane heavily consumes events. But most distributed systems follow RPCs to trigger behavior, but Kubernetes does not.

Reason behind why Kubernetes is not built using RPCs:

Tight coupling: RPCs create strong dependencies between components. In Kubernetes, control plane components must remain loosely coupled to evolve and scale independently.
Poor failure handling: RPCs expect the caller and callee to be alive at the same time. In a distributed system like Kubernetes, transient failures are common and break this assumption.
Scalability limits: Synchronous RPC calls don’t scale well when thousands of objects and controllers are involved. They can easily become bottlenecks.

Let’s understand this scenario with one simple example. When you create a Deployment, the following happens:

Kubernetes Informers: No more load to API Server

Tue, 20 Jan 2026 15:05:49 +0000

Note: This is hand written blog. Since, many folks want to contribute to the CNCF project and most of the project are operator based. So, it is very important to understand the internal concept of Kubernetes. In this blog we will be starting with Kubernetes informer and I will try my best to continue this series further.

If you are working with Kubernetes development, custom controller then you might be aware about Kubernetes Informer. Informer is a component that watches the API server for resource changes and keeps a local cache in sync, triggering events when objects are added, updated, or delete

My Kubestronaut Journey: How I became Youngest Kubestronaut from Nepal ?

Sat, 17 Jan 2026 04:03:26 +0000

Well, it’s quite late, and it has already been more than 6 months since I achieved the Kubestronaut title. In this blog, I am going to share my experience, a guide, and how I managed to achieve it while I was still in college.

The journey started back in October 2024. I was already learning Kubernetes. Initially, I was planning to take the AWS Cloud Practitioner exam, but later I skipped that cause I was totally useless and decided to go for the CKA (Certified Kubernetes Administrator).

What is the most powerful feature of Kubernetes ?

Fri, 16 Jan 2026 07:26:14 +0000

Note: This is hand written blog. In this blog, we gonna discuss about that feature which become one of the main reason behind the success of Kubernetes.

Let’s start with a bit of history. Before Docker and Kubernetes, Google had been running an containers and orchestration system called Borg internally for so many years. Docker changed the way software is built. So, Googlers definitely had the confidence that something called Kubernetes was going to create a lot of impact in the upcoming decade and I would say google was right.

Platform Engineering: How to build green Kubernetes Platform for your business ?

Sun, 11 Jan 2026 15:34:12 +0000

Note: This is hand written blog . In this blog I will walk through the guide that help to reduce a lots of pain in your infra setup with Kubernetes.

Let’s understand the problem statement at first. So, development team come up with the bunch of application repo and your task is to deploy that application to Kubernetes but it should be very automated and production ready along with Observability setup. In this blog we gonna discuss about tooling and approach that we will use to build our platform on the top of the Kubernetes. Let’s go through it step by step ….

Kagent: Agentic AI for Cloud-Native Operations

Fri, 26 Sep 2025 00:00:00 +0000

Introduction#

The world of Site Reliability Engineering (SRE) and cloud-native operations is undergoing a fundamental paradigm shift. Traditional manual and static automation methods can no longer keep pace with the accelerating complexity and scale of modern Kubernetes environments. Across the industry, we’re seeing an explosion of new approaches: from AI copilots like ChatGPT MCP, to orchestration frameworks like LangChain, to adaptive observability and remediation platforms. Together, they signal a move toward a more intelligent, autonomous ecosystem.

Choosing the Best Kubernetes API Gateway: comparing Kong, Envoy, and kgateway

Thu, 24 Jul 2025 00:00:00 +0000

API Gateways in Kubernetes: A Quick Glimpse#

Think of your Kubernetes cluster as a busy city. Microservices are like the traffic moving through it. To avoid chaos and ensure everything runs smoothly, you need something to control and guide the flow. That’s where an API Gateway comes in. It acts like the city’s main traffic controller, managing where each request goes, ensuring security, balancing the load, and keeping the system organized.

eBPF-Based Network Observability: Exploring Cilium Hubble and Alternatives

Wed, 22 Jan 2025 00:00:00 +0000

eBPF (Extended Berkeley Packet Filter) is a revolutionary Linux kernel technology that allows safe, efficient, and dynamic execution of custom programs directly within the kernel. By leveraging eBPF, modern observability tools can monitor and analyze system behavior without the overhead or risks associated with traditional instrumentation methods.

Why eBPF?#

Low Overhead: eBPF runs directly in the kernel, minimizing the performance impact on the system while providing high-fidelity insights.
Dynamic Instrumentation: Modify monitoring and tracing logic without rebooting or recompiling the kernel.
Deep Visibility: Monitor system calls, network traffic, and process behavior in real time.

This technology has become the cornerstone of cloud-native observability and security, offering unparalleled insights into workloads and infrastructure. Cilium Hubble builds upon eBPF to deliver an exceptional observability solution tailored for Kubernetes environments.

Top Open Source Logging Tools for Cloud Native Observability

Tue, 07 Jan 2025 00:00:00 +0000

Top open source logging tools for cloud native observability#

In the age of cloud native applications and microservices, systems are no longer monolithic but are composed of countless interconnected components working in tandem. This complexity brings a new challenge: how do you ensure everything runs smoothly when a single failure could ripple through an entire ecosystem? Traditional monitoring tools often fall short in such dynamic environments, which is where observability comes in.

Scaling Applications in Kubernetes: A Guide to HPA, VPA, and KEDA for Production Workloads

Mon, 09 Dec 2024 00:00:00 +0000

Introduction#

In today’s fast-paced digital world, where user demands fluctuate unpredictably, ensuring your applications perform optimally is a challenge. Kubernetes provides a powerful framework for scaling applications dynamically, but selecting the right scaling strategy is crucial. Whether it’s responding to peak traffic or reducing costs during idle periods, scaling enhances performance, ensures reliability, and optimizes resource utilization.

In this guide, we’ll dive into three essential scaling mechanisms in Kubernetes: Horizontal Pod Autoscaler (HPA), Vertical Pod Autoscaler (VPA), and KEDA (Kubernetes Event-Driven Autoscaling), with practical use cases and step-by-step implementation. Let’s begin by exploring why scaling is essential for cloud infrastructure.