golang简易实现 k8s 的yaml上传并应用示例方案

更新时间：2023年07月31日 09:36:36 作者：锅包肉

这篇文章主要为大家介绍了golang简易实现 k8s 的yaml上传并应用示例方案,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

plan A：调用 os模块

调用 os模块 system的 kubectl apply -f xx.yaml

package main
import (
    "bytes"
    "io/ioutil"
    "net/http"
    "os"
    "os/exec"
    _ "path/filepath"
    "github.com/gin-gonic/gin"
    _ "gopkg.in/yaml.v3"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)
type YAML struct {
    Content string `gorm:"type:text"`
}
func main() {
    // 初始化数据库
    dsn := "root:xixu@tcp(10.23.18x.x1:3306)/texxt?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic(any("Failed to connect database"))
    }
    db.AutoMigrate(&YAML{})
    // 初始化 Gin 路由
    r := gin.Default()
    r.LoadHTMLGlob("./temp/*")
    r.GET("/upload", func(c *gin.Context) {
        c.HTML(http.StatusOK, "upload.html", gin.H{
            "mess": "mess",
        })
    })
    r.POST("/upload", func(c *gin.Context) {
        // 从 HTTP 请求中读取 YAML 文件内容
        file, err := c.FormFile("yaml")
        if err != nil {
            c.String(http.StatusBadRequest, "Bad request")
            return
        }
        f, err := file.Open()
        if err != nil {
            c.String(http.StatusBadRequest, "Bad request")
            return
        }
        defer f.Close()
        content, err := ioutil.ReadAll(f)
        if err != nil {
            c.String(http.StatusBadRequest, "Bad request")
            return
        }
        // 将 YAML 文件内容存储到数据库中
        yaml := YAML{Content: string(content)}
        db.Create(&yaml)
        // 应用 YAML 文件内容到 Kubernetes 集群中
        cmd := exec.Command("kubectl", "apply", "-f", "-")
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        cmd.Stdin = bytes.NewBufferString(yaml.Content)
        err = cmd.Run()
        if err != nil {
            c.String(http.StatusInternalServerError, "Internal server error")
            return
        }
        c.String(http.StatusOK, "YAML file uploaded successfully")
    })
    r.Run(":8080")
}

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <title>上传文件示例</title>
</head>
<body>
<form action="/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="yaml">
    <input type="submit" value="上传">
</form>
</body>
</html>

plan B：dynamic.NewForConfig 函数创建 Kubernetes 客户端对象

我们使用 dynamic.NewForConfig 函数创建 Kubernetes 客户端对象。然后，我们读取 YAML 文件并将其转换为 Unstructured 对象。最后，我们使用 dynamic.Resource 函数来获取对应于 YAML 文件中资源类型的 Kubernetes 资源客户端，并使用 Create 或 Update 方法将资源对象应用到 Kubernetes 中

package main
import (
    "bytes"
    "context"
    "fmt"
    "io/ioutil"
    "k8s.io/apimachinery/pkg/api/meta"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/serializer/yaml"
    yamlutil "k8s.io/apimachinery/pkg/util/yaml"
    "k8s.io/client-go/dynamic"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/restmapper"
    "k8s.io/client-go/tools/clientcmd"
    "log"
    "net/http"
    "os/user"
    _ "path/filepath"
    "github.com/gin-gonic/gin"
    _ "gopkg.in/yaml.v3"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)
type YAML1 struct {
    Content string `gorm:"type:text"`
}
func main() {
    // 初始化数据库
    dsn := "root:xiaoxhu@tcp(10.2x.1x.1x:330x)/txst?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic(any("Failed to connect database"))
    }
    db.AutoMigrate(&YAML1{})
    // 初始化 Gin 路由
    r := gin.Default()
    r.LoadHTMLGlob("./temp/*")
    r.GET("/upload", func(c *gin.Context) {
        c.HTML(http.StatusOK, "upload.html", gin.H{
            "mess": "mess",
        })
    })
    r.POST("/upload", func(c *gin.Context) {
        // 从 HTTP 请求中读取 YAML 文件内容
        file, err := c.FormFile("yaml")
        if err != nil {
            c.String(http.StatusBadRequest, "Bad request")
            return
        }
        f, err := file.Open()
        if err != nil {
            c.String(http.StatusBadRequest, "Bad request")
            return
        }
        defer f.Close()
        content, err := ioutil.ReadAll(f)
        if err != nil {
            c.String(http.StatusBadRequest, "Bad request")
            return
        }
        // 将 YAML 文件内容存储到数据库中
        yaml := YAML1{Content: string(content)}
        db.Create(&yaml)
        // 应用 YAML 文件内容到 Kubernetes 集群中
        err = ApplyYaml(content)
        if err != nil {
            c.String(http.StatusInternalServerError, "Internal server error")
            return
        }
        c.String(http.StatusOK, "YAML file uploaded successfully")
    })
    r.Run(":8080")
}
func ApplyYaml(filebytes []byte) error{
    home := GetHomePath()
    nameSpace := "default"
    k8sConfig, err := clientcmd.BuildConfigFromFlags("", fmt.Sprintf("%s/.kube/config", home))  // 使用 kubectl 默认配置 ~/.kube/config
    if err != nil {
        fmt.Printf("%v",err)
        return err
    }
    // 创建一个k8s客户端
    clientSet, err := kubernetes.NewForConfig(k8sConfig)
    if err != nil {
        fmt.Printf("%v",err)
        return err
    }
    dd, err := dynamic.NewForConfig(k8sConfig)
    if err != nil {
        log.Fatal(err)
    }
    decoder := yamlutil.NewYAMLOrJSONDecoder(bytes.NewReader(filebytes), 100)
    for {
        var rawObj runtime.RawExtension
        if err = decoder.Decode(&rawObj); err != nil {
            break
        }
        obj, gvk, err := yaml.NewDecodingSerializer(unstructured.UnstructuredJSONScheme).Decode(rawObj.Raw, nil, nil)
        unstructuredMap, err := runtime.DefaultUnstructuredConverter.ToUnstructured(obj)
        if err != nil {
            log.Fatal(err)
        }
        unstructuredObj := &unstructured.Unstructured{ Object: unstructuredMap}
        gr, err := restmapper.GetAPIGroupResources(clientSet.Discovery())
        if err != nil {
            log.Fatal(err)
        }
        mapper := restmapper.NewDiscoveryRESTMapper(gr)
        mapping, err := mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
        if err != nil {
            log.Fatal(err)
        }
        var dri dynamic.ResourceInterface
        if mapping.Scope.Name() == meta.RESTScopeNameNamespace {
            if unstructuredObj.GetNamespace() == "" {
                unstructuredObj.SetNamespace(nameSpace)
            }
            dri = dd.Resource(mapping.Resource).Namespace(unstructuredObj.GetNamespace())
        } else {
            dri = dd.Resource(mapping.Resource)
        }
        obj2, err := dri.Create(context.Background(), unstructuredObj, metav1.CreateOptions{ })
        if  err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%s/%s created", obj2.GetKind(), obj2.GetName())
    }
    return nil
}
func GetHomePath() string {
    u , err := user.Current()
    if err == nil {
        return u.HomeDir
    }
    return ""
}

以上就是golang简易实现 k8s 的yaml上传并应用示例方案的详细内容，更多关于golang k8s上传yaml的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

基于Go语言实现简单的计算器
这篇文章主要为大家详细介绍了如何基于Go语言实现简单的计算器,文中的示例代码讲解详细,具有一定的学习价值,感兴趣的小伙伴可以跟随小编一起了解一下
2023-10-10
golang中bufio.SplitFunc的深入理解
这篇文章主要给大家介绍了关于golang中bufio.SplitFunc的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用golang具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2018-10-10
golang开发安装go-torch火焰图操作步骤
这篇文章主要为大家介绍了golang开发安装go-torch火焰图操作步骤
2021-11-11
Go类型断言提取测试接口值动态类型及静态转换确保类型接口编译安全
这篇文章主要为大家介绍了Go类型断言提取测试接口值动态类型及静态转换确保类型实现特定接口的编译时安全性详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-10-10
Golang实现DFA算法对敏感词过滤功能
DFA算法是确定性有限自动机,其特征是,有一个有限状态集合和一些从一个状态通向另一个状态的边,每条边上标记有一个符号,通俗的讲DFA算法就是把你要匹配的做成一颗字典树,然后对你输入的内容进行匹配的过程,本文将利用DFA算法实现敏感词过滤,需要的可以参考一下
2023-10-10
Go并发控制Channel使用场景分析
使用channel来控制子协程的优点是实现简单，缺点是当需要大量创建协程时就需要有相同数量的channel，而且对于子协程继续派生出来的协程不方便控制
2021-07-07
GO语言make()分配用法实例
这篇文章主要介绍了GO语言make()分配用法,实例分析了make()的功能及使用技巧,需要的朋友可以参考下
2015-02-02
Go语言之结构体与方法
这篇文章主要介绍了Go语言之结构体与方法，结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。下面我们就一起来学习什么是Go语言之结构体
2021-10-10
golang实现循环队列的示例代码
循环队列是一种使用固定大小的数组来实现队列的数据结构,本文主要介绍了golang实现循环队列的示例代码,具有一定的参考价值,感兴趣的可以了解一下
2024-07-07
一文带你了解Golang中select的实现原理
select是go提供的一种跟并发相关的语法，非常有用。本文将介绍 Go 语言中的 select 的实现原理，包括 select 的结构和常见问题、编译期间的多种优化以及运行时的执行过程
2023-02-02