只想简单操作 Kubernetes 资源?用 Go 一招搞定，快试试 kom!
当你在使用代码操作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，则可以避免处理这些具体类型的资源直接的差异信息。
总结
通过 `kom` 库，我们可以方便地在 Go 中对 Kubernetes 资源进行操作，包括创建、查询、更新、删除以及监听资源变更等。通过这些操作，开发者可以更高效地与 Kubernetes 集群交互，管理部署过程。
引用
https://github.com/weibaohui/k8m
https://github.com/weibaohui/kom