1. 定义需要的结构体

定义一个便于理解的结构体作为传参。

import (
    "github.com/toolkits/pkg/logger"
    coreV1 "k8s.io/api/core/v1"
    "strings"
)

type CreateDeploymentRequest struct {
    NamespaceName       string               `json:"namespace_name"`
    DeploymentName      string               `json:"deployment_name"`
    Image               string               `json:"image"`
    PortsNum            []int32              `json:"ports_num"`
    Replicas            int32                `json:"replicas"`
    MountConfigmapInfos []MountConfigmapInfo `json:"mount_configmap_infos"`
    MountPvcInfos       []MountPvcInfo       `json:"mount_pvc_infos"`
    HostPathInfos       []HostPathInfo       `json:"host_path_infos"`
}

type MountConfigmapInfo struct {
    FileName      string `json:"file_name"`
    MountPath     string `json:"mount_path"`
    ConfigmapName string `json:"configmap_name"`
}

type MountPvcInfo struct {
    MountPath string `json:"mount_path"`
    PvcName   string `json:"pvc_name"`
}

type HostPathInfo struct {
    MountPathIn  string `json:"mount_path_in"`
    MountPathOut string `json:"mount_path_out"`
    Tag          string `json:"tag"`
}

2. 创建deployment的函数

创建一个函数，接收前边的传参，调用client-go创建deployment。

import (
    "context"
    "fmt"
    appsV1 "k8s.io/api/apps/v1"
    coreV1 "k8s.io/api/core/v1"
    metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
)
func CreateDeployment(clientSet *kubernetes.Clientset, request CreateDeploymentRequest) (deploymentInfo *appsV1.Deployment, err error) {

    containerPort := explainPort(request.PortsNum)
    //这个结构和原生k8s启动deployment的yml文件结构完全一样，对着写就好
    deployment := &appsV1.Deployment{
        ObjectMeta: metaV1.ObjectMeta{
            Name: request.DeploymentName,
        },
        Spec: appsV1.DeploymentSpec{
            Replicas: &request.Replicas,
            Selector: &metaV1.LabelSelector{
                MatchLabels: map[string]string{
                    "app": request.DeploymentName,
                },
            },
            Template: coreV1.PodTemplateSpec{
                ObjectMeta: metaV1.ObjectMeta{
                    Labels: map[string]string{
                        "app": request.DeploymentName,
                    },
                },
                Spec: coreV1.PodSpec{
                    Containers: []coreV1.Container{
                        {
                            Name:  request.DeploymentName,
                            Image: request.Image,
                            Ports: containerPort,
                        },
                    },
                },
            },
        },
    }
    //调用解释器（之后定义）
    volumeMounts, volumes := explainVolumeMounts(request.MountConfigmapInfos, request.MountPvcInfos, request.HostPathInfos)
    //将解释结果赋给deployment
    deployment.Spec.Template.Spec.Volumes = volumes
    deployment.Spec.Template.Spec.Containers[0].VolumeMounts = volumeMounts
    
    //创建deployment
    deploymentInfo, err = clientSet.AppsV1().Deployments(request.NamespaceName).Create(context.TODO(), deployment, metaV1.CreateOptions{})
    if err != nil {
        return deploymentInfo, err
    }
    return deploymentInfo, nil
}

3. 定义一个解释器

传入的参数和client-go创建deployment需要的参数之间需要一个解释器来解释。我们创建这个解释器：

//定义一个总的解释器，调用各子解释器
func explainVolumeMounts(mountConfigmapInfos []MountConfigmapInfo, mountPvcInfos []MountPvcInfo, hostPathInfos []HostPathInfo) (volumeMounts []coreV1.VolumeMount, volumes []coreV1.Volume) {

    //解释configmap
    if len(mountConfigmapInfos) != 0 {
        volumeMounts1, volumes1 := explainConfigmap(mountConfigmapInfos)
        volumeMounts = append(volumeMounts, volumeMounts1...)
        volumes = append(volumes, volumes1...)
    }

    //解释目录挂载PVC
    if len(mountPvcInfos) != 0 {
        volumeMounts2, volumes2 := explainPvc(mountPvcInfos)
        volumeMounts = append(volumeMounts, volumeMounts2...)
        volumes = append(volumes, volumes2...)
    }

    //解释挂载本机目录
    if len(hostPathInfos) != 0 {
        volumeMounts3, volumes3 := explainHostPath(hostPathInfos)
        volumeMounts = append(volumeMounts, volumeMounts3...)
        volumes = append(volumes, volumes3...)
    }

    return volumeMounts, volumes
}

//定义configmap的解释器
func explainConfigmap(mountConfigmapInfos []MountConfigmapInfo) (volumeMounts []coreV1.VolumeMount, volumes []coreV1.Volume) {
    for _, mountInfo := range mountConfigmapInfos {
        //拼接 volumeMount.Name
        volumeMountNameSuffix := strings.Split(mountInfo.FileName, ".")[0]
        volumeMountName := mountInfo.ConfigmapName + volumeMountNameSuffix
        logger.Info(volumeMountName)
        //给volumeMount赋值
        volumeMount := coreV1.VolumeMount{
            Name:      volumeMountName,
            MountPath: mountInfo.MountPath + "/" + mountInfo.FileName,
            SubPath:   mountInfo.FileName,
        }
        volumeMounts = append(volumeMounts, volumeMount)

        //给volume赋值
        volume := coreV1.Volume{
            Name: volumeMountName,
            VolumeSource: coreV1.VolumeSource{
                ConfigMap: &coreV1.ConfigMapVolumeSource{
                    LocalObjectReference: coreV1.LocalObjectReference{
                        Name: mountInfo.ConfigmapName,
                    },
                },
            },
        }
        volumes = append(volumes, volume)
    }
    return volumeMounts, volumes
}

//定义pvc的解释器
func explainPvc(mountPvcInfos []MountPvcInfo) (volumeMounts []coreV1.VolumeMount, volumes []coreV1.Volume) {
    for _, mountInfo := range mountPvcInfos {
        //拼接 volumeMount.Name
        volumeMountName := mountInfo.PvcName
        logger.Info(volumeMountName)
        //给volumeMount赋值
        volumeMount := coreV1.VolumeMount{
            Name:      volumeMountName,
            MountPath: mountInfo.MountPath,
        }
        volumeMounts = append(volumeMounts, volumeMount)

        //给volume赋值
        volume := coreV1.Volume{
            Name: volumeMountName,
            VolumeSource: coreV1.VolumeSource{
                PersistentVolumeClaim: &coreV1.PersistentVolumeClaimVolumeSource{
                    ClaimName: mountInfo.PvcName,
                },
            },
        }
        volumes = append(volumes, volume)
    }
    return volumeMounts, volumes
}

//定义hostpath的解释器
func explainHostPath(hostPathInfo []HostPathInfo) (volumeMounts []coreV1.VolumeMount, volumes []coreV1.Volume) {
    for _, mountInfo := range hostPathInfo {
        //拼接 volumeMount.Name
        volumeMountName := mountInfo.Tag
        logger.Info(volumeMountName)
        //给volumeMount赋值
        volumeMount := coreV1.VolumeMount{
            Name:      volumeMountName,
            MountPath: mountInfo.MountPathIn,
        }
        volumeMounts = append(volumeMounts, volumeMount)

        //给volume赋值
        volume := coreV1.Volume{
            Name: volumeMountName,
            VolumeSource: coreV1.VolumeSource{
                HostPath: &coreV1.HostPathVolumeSource{
                    Path: mountInfo.MountPathOut,
                },
            },
        }
        volumes = append(volumes, volume)
    }
    return volumeMounts, volumes
}