Interacting with the Kubernetes API: From kubectl to Custom Clients

Kubernetes is like the brain of your cloud-native applications, managing everything from deploying workloads to keeping them healthy. But how does it actually work behind the scenes? That’s where the Kubernetes API Server comes in!

If you’ve ever run kubectl get pods, congratulations—you’ve already used the API server! But there’s a whole world beyond just kubectl—from direct API calls to writing custom clients and controllers. Let’s dive in and explore how you can talk to Kubernetes like a pro!

🤖 Meet the Kubernetes API Server

The Kubernetes API Server (kube-apiserver) is the gateway to all things Kubernetes. It’s like the receptionist at a busy office—handling requests, checking permissions, and making sure everything runs smoothly.

Here’s what happens when you interact with Kubernetes:

1. You make a request (e.g., create a pod, list services).
2. The API Server checks permissions (using authentication and authorization).
3. It validates and processes the request (possibly modifying it via admission controllers).
4. The new state is stored in etcd (the brain of Kubernetes!).
5. Controllers and schedulers react to ensure everything is running as expected.

Everything in Kubernetes is an API call under the hood — so mastering the API is key!

🛠️ Talking to Kubernetes with kubectl

The simplest way to interact with the Kubernetes API is via kubectl. It's a friendly wrapper around API requests. Let’s see some fun tricks!

Get Raw API Data

kubectl get pods -o json

This is just a fancy way of saying “Hey Kubernetes, show me everything about my pods” in JSON format.

Explore API Endpoints

Want to see what resources are available? Try this:

kubectl api-resources

You’ll get a list of all the things Kubernetes can manage — from pods to secrets to custom resources!

Making Direct API Calls

If you’re feeling adventurous, try accessing the API directly:

kubectl proxy --port=8080
curl http://localhost:8080/api/v1/nodes

This bypasses kubectl and talks to Kubernetes raw and unfiltered.

👨‍💻 Building Your Own Kubernetes API Client

Want to go beyond kubectl? Let’s build a custom Go client to interact with Kubernetes directly!

Install client-go

First, install the official Kubernetes Go client:

go get k8s.io/client-go@latest

Connecting to Your Cluster

Here’s a simple Go program that lists all pods in the default namespace:

package main

import (
 "context"
 "fmt"
 "k8s.io/client-go/kubernetes"
 "k8s.io/client-go/rest"
 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {
 config, err := rest.InClusterConfig()
 if err != nil {
  panic(err.Error())
 }

 clientset, err := kubernetes.NewForConfig(config)
 if err != nil {
  panic(err.Error())
 }

 pods, err := clientset.CoreV1().Pods("default").List(context.TODO(), metav1.ListOptions{})
 if err != nil {
  panic(err.Error())
 }

 for _, pod := range pods.Items {
  fmt.Println("Pod Name:", pod.Name)
 }
}

This will list all pods in your cluster programmatically. Now, you’re officially a Kubernetes hacker! 🚀

🌟 Advanced Fun: Custom Controllers and CRDs

Want to teach Kubernetes new tricks? You can create your own Custom Resource Definitions (CRDs) and build controllers to manage them automatically.

Example: Creating a New Custom Resource

Define a new Widget resource:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: widgets.example.com
spec:
  group: example.com
  names:
    kind: Widget
    plural: widgets
  scope: Namespaced
  versions:
  - name: v1
    served: true
    storage: true

Now Kubernetes knows what a Widget is! Next, let’s create a controller to manage them.

Running the Custom Controller

Once your custom controller is running, you can interact with it just like built-in Kubernetes resources!

Create a Widget Instance

kubectl apply -f widget-crd.yaml
kubectl apply -f example-widget.yaml

Check the Custom Resource

kubectl get widgets

Describe a Specific Widget

kubectl describe widget example-widget

Your controller will make sure your widgets are always in the desired state, just like how Kubernetes keeps pods running.

🚀 Wrapping Up

Mastering the Kubernetes API unlocks endless possibilities. Whether you’re:

• Using kubectl for quick commands,
• Writing scripts that make direct API calls,
• Building custom clients , or
• Creating custom controllers to extend Kubernetes itself…

…you now have the skills to talk to Kubernetes like a pro!

🔗 Want more Kubernetes fun? Follow me for more DevOps & Cloud insights! 🚀