04-Deployment挂载configmap、pvc、host path

合集 - 【应用卷】----------------------------(9)

1.go调用docker远程API（二）-docker API 的容器操作2023-04-032.go docker API（一）-docker开放远程AIP、链接docker API，镜像操作2023-03-303.01-链接k8s集群、node节点操作2022-10-144.02-Namespace操作2022-10-185.03-Deployment操作2022-10-22

6.04-Deployment挂载configmap、pvc、host path2023-05-05

7.04-Service操作2022-10-268.05-ConfigMap操作2022-10-279.06-PVC操作2023-05-23

收起

@

目录

• 1. 定义需要的结构体
• 2. 创建deployment的函数
• 3. 定义一个解释器

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
}

---