新增namespace查询、创建、删除、修改功能

controllers/kubernetes/namespace.go

@@ -0,0 +1,75 @@
+package kubernetes
+
+import (
+	"genbu/common/global"
+	mod "genbu/models/kubernetes"
+	service "genbu/service/kubernetes"
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+// 获取命名空间
+func GetK8sNameSpaceList(ctx *gin.Context) {
+	clusterID := ctx.Param("cid")
+	res, err := service.NewK8sInterface().GetK8sNameSpaceList(clusterID)
+	if err != nil {
+		global.ReturnContext(ctx).Failed("failed", err.Error())
+		return
+	}
+	//global.ReturnContext(ctx).Failed("failed", err.Error())
+	global.ReturnContext(ctx).Successful("success", res)
+}
+
+// 创建命名空间
+func CreateK8sNameSpace(ctx *gin.Context) {
+	cid := ctx.Param("cid")
+	params := new(mod.NameSpace)
+	if err := ctx.ShouldBindJSON(&params); err != nil {
+		global.ReturnContext(ctx).Failed("failed", err.Error())
+		return
+	}
+	ns, err := service.NewK8sInterface().CreateK8sNameSpace(cid, params.NameSpace)
+	if err != nil {
+		global.ReturnContext(ctx).Failed("failed", err.Error())
+	} else {
+		global.ReturnContext(ctx).Successful("success", map[string]interface{}{
+			"name":        ns.Name,
+			"create_time": ns.CreationTimestamp.Format(time.DateTime),
+		})
+
+	}
+
+}
+
+// 删除ns
+func DeleteNamespace(ctx *gin.Context) {
+	params := new(mod.NameSpace)
+	cid := ctx.Param("cid")
+	if err := ctx.ShouldBindJSON(&params); err != nil {
+		global.ReturnContext(ctx).Failed("failed", "请传入必传参数")
+		return
+	}
+	s, err := service.NewK8sInterface().DeleteNamespace(cid, params.NameSpace)
+	if err != nil {
+		global.ReturnContext(ctx).Failed("failed", err.Error())
+		return
+	}
+	global.ReturnContext(ctx).Successful("success", s)
+}
+
+// 更新ns
+func UpdateNamespace(ctx *gin.Context) {
+	params := new(mod.UpdateNameSpace)
+	cid := ctx.Param("cid")
+	if err := ctx.ShouldBindJSON(&params); err != nil {
+		global.ReturnContext(ctx).Failed("failed", "请传入必填参数name")
+		return
+	}
+	ns, err := service.NewK8sInterface().UpdateNamespace(cid, params.NameSpaceName, params.Annotations, params.Labels)
+	if err != nil {
+		global.ReturnContext(ctx).Failed("failed", err.Error())
+		return
+	}
+	global.ReturnContext(ctx).Successful("success", ns)
+
+}

go.mod

@@ -1,6 +1,8 @@
 module genbu
 
-go 1.17
+go 1.21
+
+toolchain go1.21.3
 
 require (
 	github.com/appleboy/gin-jwt/v2 v2.9.1

models/kubernetes/configs.go

@@ -51,3 +51,13 @@ type CreateConfigMap struct {
 	Text          string `json:"text" binding:"required"`           // ConfigMap类容
 	NameSpace     string `json:"namespace"`                         // 命名空间的名称
 }
+
+type NameSpace struct {
+	NameSpace string `json:"name" binding:"required"`
+}
+type UpdateNameSpace struct {
+	NameSpaceName string `json:"name" binding:"required"`
+	//Status        string `json:"status" `
+	Annotations string `json:"annotations"`
+	Labels      string `json:"labels"`
+}

routers/kubernetes/namespace.go

@@ -0,0 +1,18 @@
+package kubernetes
+
+import (
+	"genbu/controllers/kubernetes"
+	"github.com/gin-gonic/gin"
+)
+
+func InitNameSpaceRouters(r *gin.RouterGroup) gin.IRoutes {
+	r = r.Group("/kubernetes/:cid")
+	{
+		r.GET("/namespace/getNameSpaceList", kubernetes.GetK8sNameSpaceList)
+		r.POST("/namespace/createNameSpace", kubernetes.CreateK8sNameSpace)
+		r.POST("/namespace/deleteNameSpace", kubernetes.DeleteNamespace)
+		r.POST("/namespace/updateNameSpace", kubernetes.UpdateNamespace)
+
+	}
+	return r
+}

routers/routers.go

@@ -69,6 +69,7 @@ func BaseRouters() *gin.Engine {
 		kubernetes.InitConfigRouters(PrivateGroup)
 		kubernetes.InitNodeRouters(PrivateGroup)
 		kubernetes.InitSecretRouters(PrivateGroup)
+		kubernetes.InitNameSpaceRouters(PrivateGroup)
 	}
 	r.NoRoute(func(ctx *gin.Context) {
 		global.ReturnContext(ctx).Failed("fail", "该接口未开放")

service/kubernetes/interface.go

@@ -33,6 +33,10 @@ type InterfaceK8s interface {
 	DeleteK8sSecret(cid, NameSpace string, ConfigMapName []map[string]string) error
 	DeleteK8sSecrets(cid, NameSpace string) error
 	UpdateK8sSecret(cid, NameSpace, SecretName, Text string) (*v1.Secret, error)
+	GetK8sNameSpaceList(cid string) ([]map[string]interface{}, error)
+	CreateK8sNameSpace(cid, Namespace string) (*corev1.Namespace, error)
+	DeleteNamespace(cid, Namespace string) (string, error)
+	UpdateNamespace(cid, NameSpaceName, Annotations, Labels string) (*v1.Namespace, error)
 }
 
 type k8sCluster struct{}

service/kubernetes/namespace.go

@@ -0,0 +1,135 @@
+package kubernetes
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"genbu/common/global"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	"time"
+)
+
+// 获取ns信息
+func (k *k8sCluster) GetK8sNameSpaceList(cid string) (restful []map[string]interface{}, err error) {
+	clientSetAny, found := global.ClientSetCache.Get(cid)
+	if !found {
+		global.TPLogger.Error("当前集群不存在：", err)
+		return nil, errors.New("当前集群不存在")
+	}
+	clientSet := clientSetAny.(*kubernetes.Clientset)
+	// 获取config
+	var (
+		ctx    context.Context
+		cancel context.CancelFunc
+	)
+
+	ctx, cancel = context.WithTimeout(context.TODO(), time.Second*2)
+	defer cancel()
+	//nodeList, err := clientSet.CoreV1().Nodes().List(ctx, metav1.ListOptions{})
+	nameSpaceList, err := clientSet.CoreV1().Namespaces().List(ctx, metav1.ListOptions{})
+	if err != nil {
+
+		global.TPLogger.Error("获取namespace失败：", err)
+		return nil, errors.New("获取namespace失败")
+	}
+	//for _, item := range nameSpaceList.Items {
+	//	fmt.Println(item.Name)
+	//}
+	restful = []map[string]interface{}{}
+	for _, item := range nameSpaceList.Items {
+		restful = append(restful, map[string]interface{}{
+			"name":            item.Name,
+			"api_version":     item.APIVersion,
+			"resourceVersion": item.ResourceVersion,
+			"kind":            item.Kind,
+			//"namespace":       item.Namespace,
+			"create_time": item.CreationTimestamp.Format(time.DateTime), // 格式化成：2006-01-02 15:04:05
+			"labels":      item.Labels,
+			"status":      item.Status.Phase,
+		})
+	}
+	return restful, nil
+
+}
+
+// 新增ns
+func (k *k8sCluster) CreateK8sNameSpace(cid, Namespace string) (*corev1.Namespace, error) {
+	clientSetAny, found := global.ClientSetCache.Get(cid)
+	if !found {
+		global.TPLogger.Error("当前集群不存在：", errors.New(""))
+		return nil, errors.New("当前集群不存在")
+	}
+	clientSet := clientSetAny.(*kubernetes.Clientset)
+	namespace := corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: Namespace}}
+	ns, err := clientSet.CoreV1().Namespaces().Create(context.Background(), &namespace, metav1.CreateOptions{})
+	if err != nil {
+		global.TPLogger.Error("创建namespace失败：", err)
+		return nil, err
+	} else {
+
+		return ns, nil
+	}
+
+}
+
+// 删除ns
+func (k *k8sCluster) DeleteNamespace(cid, namespace string) (string, error) {
+	clientSetAny, found := global.ClientSetCache.Get(cid)
+	if !found {
+		global.TPLogger.Error("当前集群不存在：", errors.New(""))
+		return "", errors.New("当前集群不存在")
+	}
+	clientSet := clientSetAny.(*kubernetes.Clientset)
+	err := clientSet.CoreV1().Namespaces().Delete(context.Background(), namespace, metav1.DeleteOptions{})
+	if err != nil {
+		global.TPLogger.Error("删除Namespace:%s失败：", namespace, err)
+		return "", errors.New("Namespace删除失败")
+	}
+
+	return "namespace删除成功", nil
+}
+
+// 更新ns
+func (k *k8sCluster) UpdateNamespace(cid, NameSpaceName, Annotations, Labels string) (*corev1.Namespace, error) {
+	clientSetAny, found := global.ClientSetCache.Get(cid)
+
+	if !found {
+		global.TPLogger.Error("当前集群不存在：", errors.New(""))
+		return nil, errors.New("当前集群不存在")
+	}
+	clientSet := clientSetAny.(*kubernetes.Clientset)
+	namespace := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: NameSpaceName,
+		},
+	}
+	//if Status != "" {
+	//	namespace.Status.Phase = corev1.NamespacePhase(Status)
+	//}
+	if Annotations != "" {
+		if namespace.Annotations == nil {
+			namespace.Annotations = make(map[string]string)
+		}
+		namespace.Annotations["annotations"] = Annotations
+	}
+	if Labels != "" {
+		if namespace.Labels == nil {
+			namespace.Labels = make(map[string]string)
+		}
+		namespace.Labels["labels"] = Labels
+	}
+	_, err := json.Marshal(namespace)
+	if err != nil {
+		global.TPLogger.Error("解析失败", err.Error())
+		return nil, errors.New("解析失败")
+	}
+	update, err := clientSet.CoreV1().Namespaces().Update(context.Background(), namespace, metav1.UpdateOptions{})
+	if err != nil {
+		global.TPLogger.Error("namespace更新失败: ", err)
+		return nil, errors.New("namespace更新失败")
+	} else {
+		return update, nil
+	}
+}