当你在使用代码操作k8s时，有没有觉得总要写很多代码，才能获取到一个资源，并且要处理底层的集群连接、client等一系列的东西。那么有没有一种简单的办法，毕竟我只是想读取一下集群内的Pod或者什么其他资源而已啊。

为了解决这个问题，我们使用 kom
https://github.com/weibaohui/kom，这是一个k8s的操作类库，golang编写，使用简单。

在 Kubernetes 中，`Deployment` 是一种常见的控制器，负责管理一组副本的 Pod，确保这些 Pod 处于期望的状态。

通过 Go 客户端库和 `kom` 工具集，我们可以轻松地操作 Kubernetes 中的资源，包括创建、查询、更新、删除以及监听资源变更等。

本文将详细讲解如何使用 `kom` 对 `Deployment` 资源进行操作。

连接k8s集群

kom.Clusters().RegisterByPathWithID("/Users/kom/.kube/config", "docker-desktop")

#### 1. 定义一个 `Deployment` 对象

首先，创建一个 `Deployment` 对象，并设置相关参数。你可以通过 Go 语言中的结构体来定义它的元数据和规格。

var item v1.Deployment
item = v1.Deployment{
    ObjectMeta: metav1.ObjectMeta{
        Name:      "nginx",
        Namespace: "default",
    },
    Spec: v1.DeploymentSpec{
        Template: corev1.PodTemplateSpec{
            Spec: corev1.PodSpec{
                Containers: []corev1.Container{
                    {Name: "test", Image: "nginx:1.14.2"},
                },
            },
        },
    },
}

2. 创建资源

通过 `kom` 库，你可以轻松地在 Kubernetes 集群中创建一个 `Deployment` 资源。

err := kom.DefaultCluster().Resource(&item).Create(&item).Error
if err != nil {
    fmt.Printf("Error creating deployment: %v", err)
}

3. 查询资源

你可以通过 `Get` 方法获取特定的 `Deployment` 资源，例如查询 `default` 命名空间中的 `nginx` 部署：

err := kom.DefaultCluster().Resource(&item).Namespace("default").Name("nginx").Get(&item).Error
if err != nil {
    fmt.Printf("Error retrieving deployment: %v", err)
}

4. 查询资源列表

你还可以查询命名空间中的所有 `Deployment` 资源，或者通过标签进行过滤。例如，查询 `default` 命名空间下所有标签为 `app=nginx` 的 `Deployment`：

err := kom.DefaultCluster().Resource(&item).Namespace("default").List(&items, metav1.ListOptions{LabelSelector: "app=nginx"}).Error
if err != nil {
    fmt.Printf("Error listing deployments: %v", err)
}

通过字段选择器，你也可以按照指定的字段来筛选资源。例如，查询名为 `test-deploy` 的 `Deployment`：

err := kom.DefaultCluster().Resource(&item).Namespace("default").List(&items, metav1.ListOptions{FieldSelector: "metadata.name=test-deploy"}).Error
if err != nil {
    fmt.Printf("Error listing deployments: %v", err)
}

5. 更新资源

更新资源的常见场景之一是修改 `Deployment` 的注解。假设我们需要为名为 `nginx` 的 `Deployment` 增加一个注解：

err := kom.DefaultCluster().Resource(&item).Namespace("default").Name("nginx").Get(&item).Error
if err != nil {
    fmt.Printf("Error retrieving deployment for update: %v", err)
}
if item.Spec.Template.Annotations == nil {
    item.Spec.Template.Annotations = map[string]string{}
}
item.Spec.Template.Annotations["kom.kubernetes.io/restartedAt"] = time.Now().Format(time.RFC3339)
err = kom.DefaultCluster().Resource(&item).Update(&item).Error
if err != nil {
    fmt.Printf("Error updating deployment: %v", err)
}

6. 使用 Patch 更新资源

有时，直接修改资源较为繁琐，这时可以使用 `Patch` 方法来部分更新资源。例如，我们想给 `nginx` 部署添加一个标签，并设置副本数为 5：

patchData := `{
    "spec": {
        "replicas": 5
    },
    "metadata": {
        "labels": {
            "new-label": "new-value"
        }
    }
}`
err := kom.DefaultCluster().Resource(&item).Patch(&item, types.MergePatchType, patchData).Error
if err != nil {
    fmt.Printf("Error patching deployment: %v", err)
}

7. 删除资源

删除 `Deployment` 资源同样简单，只需要调用 `Delete` 方法：

err := kom.DefaultCluster().Resource(&item).Namespace("default").Name("nginx").Delete().Error
if err != nil {
    fmt.Printf("Error deleting deployment: %v", err)
}

8. 获取通用类型资源

对于 Kubernetes 中的内置类型或自定义资源定义 (CRD)，你可以通过指定资源的 `GroupVersionKind` (GVK) 来获取资源。例如，获取 `Event` 类型的资源：

var list []corev1.Event
err := kom.DefaultCluster().GVK("events.k8s.io", "v1", "Event").Namespace("default").List(&list).Error
if err != nil {
    fmt.Printf("Error listing events: %v", err)
}

9. Watch 资源变更

`Watch` 方法可以用来监听资源的实时变更，适用于处理需要实时反应的场景。例如，监听 `default` 命名空间下 `Pod` 资源的变动：

var watcher watch.Interface
var pod corev1.Pod
err := kom.DefaultCluster().Resource(&pod).Namespace("default").Watch(&watcher).Error
if err != nil {
    fmt.Printf("Error creating watcher: %v", err)
    return
}
go func() {
    defer watcher.Stop()

    for event := range watcher.ResultChan() {
        err := kom.DefaultCluster().Tools().ConvertRuntimeObjectToTypedObject(event.Object, &pod)
        if err != nil {
            fmt.Printf("Error converting event object: %v", err)
            return
        }
        switch event.Type {
        case watch.Added:
            fmt.Printf("Added Pod [ %s/%s ]\n", pod.Namespace, pod.Name)
        case watch.Modified:
            fmt.Printf("Modified Pod [ %s/%s ]\n", pod.Namespace, pod.Name)
        case watch.Deleted:
            fmt.Printf("Deleted Pod [ %s/%s ]\n", pod.Namespace, pod.Name)
        }
    }
}()

对比

我们来看下，如果不使用kom，我们如何来操作Deployment资源

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"time"

	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
)

func main() {
	// 加载 kubeconfig
	kubeconfig := flag.String("kubeconfig", "/path/to/your/kubeconfig", "absolute path to the kubeconfig file")
	flag.Parse()
	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
	if err != nil {
		log.Fatalf("Failed to build kubeconfig: %v", err)
	}

	// 创建 Kubernetes 客户端
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		log.Fatalf("Failed to create clientset: %v", err)
	}

	// Namespace 定义
	namespace := "default"

	// 示例操作
	ctx := context.TODO()

	// 创建 Deployment
	createDeployment(ctx, clientset, namespace)

	// 获取 Deployment
	getDeployment(ctx, clientset, namespace, "example-deployment")

	// 更新 Deployment
	updateDeployment(ctx, clientset, namespace, "example-deployment")

	// Patch Deployment
	patchDeployment(ctx, clientset, namespace, "example-deployment")

	// 列出 Deployments
	listDeployments(ctx, clientset, namespace)
}

func createDeployment(ctx context.Context, clientset *kubernetes.Clientset, namespace string) {
	deployment := &appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name: "example-deployment",
		},
		Spec: appsv1.DeploymentSpec{
			Replicas: int32Ptr(3),
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{
					"app": "example",
				},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"app": "example",
					},
				},
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:  "nginx",
							Image: "nginx:1.21",
							Ports: []corev1.ContainerPort{
								{
									ContainerPort: 80,
								},
							},
						},
					},
				},
			},
		},
	}

	_, err := clientset.AppsV1().Deployments(namespace).Create(ctx, deployment, metav1.CreateOptions{})
	if err != nil {
		log.Fatalf("Failed to create deployment: %v", err)
	}
	fmt.Println("Deployment created successfully!")
}

func getDeployment(ctx context.Context, clientset *kubernetes.Clientset, namespace, name string) {
	deployment, err := clientset.AppsV1().Deployments(namespace).Get(ctx, name, metav1.GetOptions{})
	if err != nil {
		log.Fatalf("Failed to get deployment: %v", err)
	}
	fmt.Printf("Deployment retrieved: %s with %d replicas\n", deployment.Name, *deployment.Spec.Replicas)
}

func updateDeployment(ctx context.Context, clientset *kubernetes.Clientset, namespace, name string) {
	deployment, err := clientset.AppsV1().Deployments(namespace).Get(ctx, name, metav1.GetOptions{})
	if err != nil {
		log.Fatalf("Failed to get deployment for update: %v", err)
	}

	// 修改副本数
	newReplicas := int32(5)
	deployment.Spec.Replicas = &newReplicas

	_, err = clientset.AppsV1().Deployments(namespace).Update(ctx, deployment, metav1.UpdateOptions{})
	if err != nil {
		log.Fatalf("Failed to update deployment: %v", err)
	}
	fmt.Println("Deployment updated successfully!")
}

func patchDeployment(ctx context.Context, clientset *kubernetes.Clientset, namespace, name string) {
	patchData := map[string]interface{}{
		"spec": map[string]interface{}{
			"replicas": 2,
		},
	}
	patchBytes, _ := json.Marshal(patchData)

	_, err := clientset.AppsV1().Deployments(namespace).Patch(ctx, name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{})
	if err != nil {
		log.Fatalf("Failed to patch deployment: %v", err)
	}
	fmt.Println("Deployment patched successfully!")
}

func listDeployments(ctx context.Context, clientset *kubernetes.Clientset, namespace string) {
	deployments, err := clientset.AppsV1().Deployments(namespace).List(ctx, metav1.ListOptions{})
	if err != nil {
		log.Fatalf("Failed to list deployments: %v", err)
	}
	fmt.Println("Deployments in namespace:", namespace)
	for _, d := range deployments.Items {
		fmt.Printf("- %s (replicas: %d)\n", d.Name, *d.Spec.Replicas)
	}
}

func int32Ptr(i int32) *int32 { return &i }

那么这么写的问题在于，如果你需要操作多个 Kubernetes 资源类型（如 Deployment、Ingress、Service 等），你可能会发现每个资源类型的操作都需要写一套相似的代码，主要是：

创建资源：每个资源类型有自己特定的 Spec 和 Meta 信息。

获取资源：每个资源类型有自己的获取方法。

更新、删除资源：这些操作的代码也是基于资源类型的差异化进行的。

然而，使用kom，则可以避免处理这些具体类型的资源直接的差异信息。