Example for create object from file via dynamic API about client-go-examples HOT 5 CLOSED

package main

import (
	"context"
	"flag"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"github.com/thanos-io/thanos/pkg/errors"
	apiv1 "k8s.io/api/core/v1"
	apiErrors "k8s.io/apimachinery/pkg/api/errors"
	"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/schema"
	"k8s.io/apimachinery/pkg/util/yaml"
	"k8s.io/client-go/dynamic"
	"k8s.io/client-go/tools/clientcmd"
	"k8s.io/client-go/util/homedir"
)

func kind2Resource(group, version, kind string) (gvr schema.GroupVersionResource, err error) {
	// https://www.cnblogs.com/zhangmingcheng/p/16128224.html
	// https://iximiuz.com/en/posts/kubernetes-api-structure-and-terminology/
	// https://github.com/kubernetes/kubernetes/issues/18622
	// kubectl api-resources
	gvk := schema.GroupVersionKind{Group: group, Version: version, Kind: kind}
	gvr, _ = meta.UnsafeGuessKindToResource(gvk)
	//fmt.Printf("%s %s %s -> %+v\n", group, version, kind, gvr)
	return
}

func isClusterWideResource(resource string) bool {
	if strings.HasPrefix(resource, "cluster") || resource == "customresourcedefinitions" || resource == "namespaces" {
		return true
	}
	return false
}

func createObject(client dynamic.Interface, fp string) (err error) {
	fmt.Printf("Reading %s\n", fp)
	// YAML -> Unstructured (through JSON)
	var yConfigMap, jConfigMap []byte
	if yConfigMap, err = os.ReadFile(fp); err != nil {
		err = errors.Wrapf(err, "os.ReadFile failed")
		return
	}
	jConfigMap, err = yaml.ToJSON(yConfigMap)
	if err != nil {
		err = errors.Wrapf(err, "yaml.ToJSON failed")
		return
	}

	var object runtime.Object
	object, err = runtime.Decode(unstructured.UnstructuredJSONScheme, jConfigMap)
	if err != nil {
		err = errors.Wrapf(err, "runtime.Decode failed")
		return
	}

	var uConfigMaps []unstructured.Unstructured
	switch t := object.(type) {
	case *unstructured.Unstructured:
		uConfigMaps = append(uConfigMaps, *t)
	case *unstructured.UnstructuredList:
		uConfigMaps = t.Items
	default:
		err = errors.Wrapf(err, "unstructured.Unstructured or unstructured.UnstructuredList expected")
		return
	}
	for _, uConfigMap := range uConfigMaps {
		var apiVersion, kind, namespace string
		apiVersion = uConfigMap.GetAPIVersion()
		kind = uConfigMap.GetKind()
		gv, _ := schema.ParseGroupVersion(apiVersion)
		var gvr schema.GroupVersionResource
		if gvr, err = kind2Resource(gv.Group, gv.Version, kind); err != nil {
			return
		}
		if isClusterWideResource(gvr.Resource) {
			_, err = client.Resource(gvr).Create(context.TODO(), &uConfigMap, metav1.CreateOptions{})
		} else {
			namespace = uConfigMap.GetNamespace()
			if namespace == "" {
				namespace = apiv1.NamespaceDefault
			}
			_, err = client.Resource(gvr).Namespace(namespace).Create(context.TODO(), &uConfigMap, metav1.CreateOptions{})
		}
		if err != nil {
			if apiErrors.IsAlreadyExists(err) {
				err = nil
				fmt.Printf("Object already exist: namespace %s, name %s, resource %s\n", namespace, uConfigMap.GetName(), gvr.Resource)
				return
			} else {
				err = errors.Wrapf(err, "client.Resource.Namespace.Create %+v failed", gvr)
				return
			}
		}
		fmt.Printf("Created object: namespace %s, name %s, resource %s\n", namespace, uConfigMap.GetName(), gvr.Resource)
	}
	return
}

func main() {
	// Initialize client
	var kubeconfig *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")
	}
	pth := flag.String("f", ".", "path of manifest file or directory")
	flag.Parse()

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

	// Get manifest list
	var fi fs.FileInfo
	if fi, err = os.Stat(*pth); err != nil {
		panic(err)
	}
	var fps []string
	if fi.IsDir() {
		var des []fs.DirEntry
		if des, err = os.ReadDir(*pth); err != nil {
			panic(err)
		}
		for _, de := range des {
			if de.IsDir() {
				continue
			}
			fn := de.Name()
			ext := filepath.Ext(fn)
			if ext != ".yaml" && ext != "yml" {
				continue
			}
			fps = append(fps, filepath.Join(*pth, fn))
		}
		sort.Strings(fps)
	} else {
		fps = append(fps, *pth)
	}

	// Create resource for each manifest
	for _, fp := range fps {
		if err = createObject(client, fp); err != nil {
			fmt.Println(err)
		}
	}
}