17370845950

使用client-go可实现Go程序对Kubernetes资源的全生命周期管理，包括通过kubeconfig或ServiceAccount初始化客户端，创建Deployment和Service资源，以及利用Informer监听资源事件，核心在于正确构造API对象并处理权限与命名空间。

在Golang中实现Kubernetes服务部署，核心是通过官方提供的 client-go 库与Kubernetes API Server进行交互。你可以使用它创建、更新、删除Deployment、Service、ConfigMap等资源。以下是常用方法的汇总和实践指导。

1. 使用 client-go 操作 Kubernetes 资源

client-go 是 Kubernetes 官方 Go 客户端库，支持 declarative 和 imperative 方式管理资源。

go get k8s.io/client-go@latest
go get k8s.io/apimachinery@latest

从 kubeconfig 或集群内 ServiceAccount 自动加载配置。

package main

import (
    "context"
    "fmt"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/rest"
    "path/filepath"
    "os"
)

func getKubeConfig() (*rest.Config, error) {
    // 如果在集群外运行，使用本地 kubeconfig
    if home := homeDir(); home != "" {
        return clientcmd.BuildConfigFromFlags("", filepath.Join(home, ".kube", "config"))
    }
    // 在集群内运行时，使用 ServiceAccount 自动挂载的 token
    return rest.InClusterConfig()
}

func homeDir() string {
    if h := os.Getenv("HOME"); h != "" {
        return h
    }
    return os.Getenv("USERPROFILE")
}

2. 创建 Deployment 示例

使用 client-go 创建一个 Nginx Deployment。

import (
    appsv1 "k8s.io/api/apps/v1"
    v1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

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

    _, err := clientset.AppsV1().Deployments("default").Create(
        context.TODO(),
        deployment,
        metav1.CreateOptions{},
    )
    return err
}

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

3. 创建对应的 Service 暴露服务

为 Deployment 创建 LoadBalancer 类型的 Service。

func createService(clientset *kubernetes.Clientset) error {
    service := &v1.Service{
        ObjectMeta: metav1.ObjectMeta{
            Name: "nginx-service",
        },
        Spec: v1.ServiceSpec{
            Selector: map[string]string{"app": "nginx"},
            Ports: []v1.ServicePort{
                {
                    Protocol:   v1.ProtocolTCP,
                    Port:       80,
                    TargetPort: intstr.FromInt(80),
                },
            },
            Type: v1.ServiceTypeLoadBalancer,
        },
    }

    _, err := clientset.CoreV1().Services("default").Create(
        context.TODO(),
        service,
        metav1.CreateOptions{},
    )
    return err
}

4. 监听资源事件（Informer 机制）

使用 Informer 高效监听 Deployment 变化，避免轮询。

import (
    "k8s.io/client-go/informers"
    "time"
)

func watchDeployment(clientset *kubernetes.Clientset) {
    factory := informers.NewSharedInformerFactory(clientset, time.Minute*30)
    informer := factory.Apps().V1().Deployments().Informer()

    stopCh := make(chan struct{})
    defer close(stopCh)

    informer.AddEventHandler(&cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            fmt.Println("Deployment added:", obj)
        },
        UpdateFunc: func(old, new interface{}) {
            fmt.Println("Deployment updated")
        },
        DeleteFunc: func(obj interface{}) {
            fmt.Println("Deployment deleted")
        },
    })

    go informer.Run(stopCh)
    if !cache.WaitForCacheSync(stopCh, informer.HasSynced) {
        panic("Failed to sync cache")
    }

    select {} // 长时间运行
}

基本上就这些。通过 client-go，你可以在 Golang 程序中完全控制 Kubernetes 资源的生命周期。关键点在于正确初始化客户端、构造符合 API 的对象结构，并处理好命名空间与权限（RBAC）。实际项目中建议封装通用操作函数，提高复用性。