用client-go来控制deployment资源的生命周期（client-go操作k8s资源）

Go client for Kubernetes.

https://github.com/kubernetes/client-go

代码如下：

https://github.com/kubernetes/client-go/blob/master/examples/create-update-delete-deployment/main.go

deployment

package main

import (
        "bufio"
        "context"
        "flag"
        "fmt"
        "os"
        "path/filepath"

        appsv1 "k8s.io/api/apps/v1"
        apiv1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/tools/clientcmd"
        "k8s.io/client-go/util/homedir"
        "k8s.io/client-go/util/retry"
)

func main() {
        var kubeconfig, namespace, name *string
        if home := homedir.HomeDir(); home != "" {
                kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
        } else {
                kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
        }

        namespace = flag.String("namespace", "default", "namespace to use")
        name = flag.String("name", "demo-deployment", "name of the deployment")
        flag.Parse()

        config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
        if err != nil {
                panic(err)
        }
        clientset, err := kubernetes.NewForConfig(config)
        if err != nil {
                panic(err)
        }

        deploymentsClient := clientset.AppsV1().Deployments(*namespace)

        deployment := &appsv1.Deployment{
                ObjectMeta: metav1.ObjectMeta{
                        Name: *name,
                },
                Spec: appsv1.DeploymentSpec{
                        Replicas: int32Ptr(2),
                        Selector: &metav1.LabelSelector{
                                MatchLabels: map[string]string{
                                        "app": "demo",
                                },
                        },
                        Template: apiv1.PodTemplateSpec{
                                ObjectMeta: metav1.ObjectMeta{
                                        Labels: map[string]string{
                                                "app": "demo",
                                        },
                                },
                                Spec: apiv1.PodSpec{
                                        Containers: []apiv1.Container{
                                                {
                                                        Name:  "web",
                                                        Image: "registry.cn-beijing.aliyuncs.com/bogeit/nginx:1.19.8",
                                                        Ports: []apiv1.ContainerPort{
                                                                {
                                                                        Name:          "http",
                                                                        Protocol:      apiv1.ProtocolTCP,
                                                                        ContainerPort: 80,
                                                                },
                                                        },
                                                },
                                        },
                                },
                        },
                },
        }

        // Create Deployment
        fmt.Println("Creating deployment...")
        result, err := deploymentsClient.Create(context.TODO(), deployment, metav1.CreateOptions{})
        if err != nil {
                panic(err)
        }
        fmt.Printf("Created deployment %q.\n", result.GetObjectMeta().GetName())

        // Update Deployment
        prompt()
        fmt.Println("Updating deployment...")

        retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
                result, getErr := deploymentsClient.Get(context.TODO(), *name, metav1.GetOptions{})
                if getErr != nil {
                        panic(fmt.Errorf("Failed to get latest version of Deployment: %v", getErr))
                }

                result.Spec.Replicas = int32Ptr(1)                                                                     // reduce replica count
                result.Spec.Template.Spec.Containers[0].Image = "registry.cn-beijing.aliyuncs.com/bogeit/nginx:1.25.5" // change nginx version
                _, updateErr := deploymentsClient.Update(context.TODO(), result, metav1.UpdateOptions{})
                return updateErr
        })
        if retryErr != nil {
                panic(fmt.Errorf("Update failed: %v", retryErr))
        }
        fmt.Println("Updated deployment...")

        // List Deployments
        prompt()
        fmt.Printf("Listing deployments in namespace %q:\n", *namespace)
        list, err := deploymentsClient.List(context.TODO(), metav1.ListOptions{})
        if err != nil {
                panic(err)
        }
        for _, d := range list.Items {
                fmt.Printf(" * %s (%d replicas)\n", d.Name, *d.Spec.Replicas)
        }

        // Delete Deployment
        prompt()
        fmt.Println("Deleting deployment...")
        deletePolicy := metav1.DeletePropagationForeground
        if err := deploymentsClient.Delete(context.TODO(), *name, metav1.DeleteOptions{
                PropagationPolicy: &deletePolicy,
        }); err != nil {
                panic(err)
        }
        fmt.Println("Deleted deployment.")
}

func prompt() {
        fmt.Printf("-> Press Return key to continue.")
        scanner := bufio.NewScanner(os.Stdin)
        for scanner.Scan() {
                break
        }
        if err := scanner.Err(); err != nil {
                panic(err)
        }
        fmt.Println()
}

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

daemonset

package main

import (
    "bufio"
    "context"
    "flag"
    "fmt"
    "os"
    "path/filepath"

    appsv1 "k8s.io/api/apps/v1"
    apiv1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "k8s.io/client-go/util/retry"
)

func main() {
    var kubeconfig, namespace, name *string
    if home := homedir.HomeDir(); home != "" {
        kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
    }

    namespace = flag.String("namespace", "default", "namespace to use")
    name = flag.String("name", "demo-daemonset", "name of the daemonset")
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
    if err != nil {
        panic(err)
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        panic(err)
    }

    daemonsetsClient := clientset.AppsV1().DaemonSets(*namespace)

    daemonset := &appsv1.DaemonSet{
        ObjectMeta: metav1.ObjectMeta{
            Name: *name,
        },
        Spec: appsv1.DaemonSetSpec{
            Selector: &metav1.LabelSelector{
                MatchLabels: map[string]string{
                    "app": "demo",
                },
            },
            Template: apiv1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{
                    Labels: map[string]string{
                        "app": "demo",
                    },
                },
                Spec: apiv1.PodSpec{
                    Containers: []apiv1.Container{
                        {
                            Name:  "web",
                            Image: "registry.cn-beijing.aliyuncs.com/bogeit/nginx:1.19.8",
                            Ports: []apiv1.ContainerPort{
                                {
                                    Name:          "http",
                                    Protocol:      apiv1.ProtocolTCP,
                                    ContainerPort: 80,
                                },
                            },
                        },
                    },
                },
            },
        },
    }

    // Create DaemonSet
    fmt.Println("Creating daemonset...")
    result, err := daemonsetsClient.Create(context.TODO(), daemonset, metav1.CreateOptions{})
    if err != nil {
        panic(err)
    }
    fmt.Printf("Created daemonset %q.\n", result.GetObjectMeta().GetName())

    prompt()

    fmt.Println("Updating daemonset...")
    retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
        result, getErr := daemonsetsClient.Get(context.TODO(), *name, metav1.GetOptions{})
        if getErr != nil {
            panic(fmt.Errorf("Failed to get latest version of Daemonsets: %v", getErr))
        }

        result.Spec.Template.Spec.Containers[0].Image = "registry.cn-beijing.aliyuncs.com/bogeit/nginx:1.25.5"
        _, updateErr := daemonsetsClient.Update(context.TODO(), result, metav1.UpdateOptions{})
        return updateErr
    })
    if retryErr != nil {
        panic(fmt.Errorf("Update failed: %v", retryErr))
    }
    fmt.Println("Updated daemonsets...")

    prompt()
    fmt.Printf("Listing daemonsets in %q namespace...\n", *namespace)
    list, err := daemonsetsClient.List(context.TODO(), metav1.ListOptions{})
    if err != nil {
        panic(err)
    }
    for _, d := range list.Items {
        fmt.Printf(" * %s \n", d.Name)
    }

    prompt()
    fmt.Println("Deleting daemonset...")
    deletePolicy := metav1.DeletePropagationForeground
    if err := daemonsetsClient.Delete(context.TODO(), *name, metav1.DeleteOptions{
        PropagationPolicy: &deletePolicy,
    }); err != nil {
        panic(err)
    }
    fmt.Println("Deleted daemonset.")

}

func prompt() {
    fmt.Printf("-> Press Return key to continue.")
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        break
    }

    if err := scanner.Err(); err != nil {
        panic(err)
    }
    fmt.Println()
}