find ./ -mtime 0 #返回最近24小时内修改过的文件。
find ./ -mtime 1 #返回的是前48~24小时修改过的文件,注意不是48小时以内修改过的文件。
find . -name '*.php' -mmin -30 #查找最近30分钟修改的当前目录下的.php文件
find . -name '*.inc' -mtime 0 -ls #查找最近24小时修改的当前目录下的.php文件，并列出详细信息

// src/builtin/builtin.go

type error interface {
    Error() string
}

err1 := errors.New("abcde")
err2 := fmt.Errorf("math: square root of negative number %g", x)

go get k8s.io/client-go@latest

go get k8s.io/client-go@v0.20.4

package main

import (
    "fmt"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
	"k8s.io/client-go/dynamic"    
    "log"
    "os"
    "path/filepath"
)

// 从文件 ~/.kube/config 中构造config
func getConfigFromFile() (*restclient.Config, error){
    kubeconfig := filepath.Join(os.Getenv("HOME"), ".kube", "config")
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatal(err)
    }
    
    return config, err
}

const (
	// High enough QPS to fit all expected use cases.
	DefaultQPS = 1e6
	// High enough Burst to fit all expected use cases.
	DefaultBurst = 1e6

)

// 从数据库存储的多集群信息，包括masterIP，kubeconfig和元数据信息中初始化，参考了[k8s多集群go-client实现](https://blog.csdn.net/weixin_43908373/article/details/95618989)

func InitClient(clusterName string) (*kubernetes.Clientset, *rest.Config, dynamic.Interface, error) {
	//数据库取出集群信息
	master, kubeconfig, err := GetClusterInfo(clusterName)
	if err != nil {
		logs.Error("get db for cluster kubeconfig error. %v ", err)
		return nil, nil, err
	}
	kubeconfigJson, err := yaml.YAMLToJSON([]byte(kubeconfig))
	if err != nil {
		logs.Error("yaml to json err")
	}
	configV1 := clientcmdapiv1.Config{}
	err = json.Unmarshal(kubeconfigJson, &configV1)
	if err != nil {
		logs.Error("json unmarshal kubeconfig error. %v ", err)
		return nil, nil, err
	}
	// 切换匹配的版本
	configObject, err := clientcmdlatest.Scheme.ConvertToVersion(&configV1, clientcmdapi.SchemeGroupVersion)
	if err != nil {
		logs.Error("ConvertToVersion error. %v ", err)
		return nil, nil, err
	}
	configInternal := configObject.(*clientcmdapi.Config)

	// 实例化配置信息
	clientConfig, err := clientcmd.NewDefaultClientConfig(*configInternal, &clientcmd.ConfigOverrides{
		ClusterDefaults: clientcmdapi.Cluster{Server: master},
	}).ClientConfig()

	if err != nil {
		logs.Error("build client config error. %v ", err)
		return nil, nil, err
	}
	clientConfig.QPS = defaultQPS
	clientConfig.Burst = defaultBurst
	
	// 实例化客户端
	clientSet, err := kubernetes.NewForConfig(clientConfig)

	if err != nil {
		logs.Error("(%s) kubernetes.NewForConfig(%v) error.%v", master, err, clientConfig)
		return nil, nil, err
	}
	
	dynamicClient, err := dynamic.NewForConfig(config)
	if err != nil {
		logrus.Error(err)
		return nil, nil, err
	}

	return clientSet, clientConfig, dynamicClient, nil
}

config, err := getConfig()

clientset, err := kubernetes.NewForConfig(config)
// 获取node 列表 
nodes, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
// 更新
_, err = a.client.CoreV1().Nodes().Update(context.TODO(), newNode, metav1.UpdateOptions{})
// 发送patch 指令更新
patchTemplate := map[string]interface{}{
		"metadata": map[string]interface{}{
			"labels": map[string]interface{}{
				labelkey: labelvaule,
			},
		},
	}
patchdata, _ := json.Marshal(patchTemplate)
_, err := clientset.CoreV1().Nodes().Patch(ctx, Nodes[i].Name, types.StrategicMergePatchType, patchdata, metav1.PatchOptions{})

nsSpec := &v1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: ns}}
_, err := clientset.Core().Namespaces().Create(nsSpec)

    data := make(map[string][]byte)
    data["user"] = []byte("admin")
    data["password"] = []byte("password")

    // https://godoc.org/k8s.io/api/core/v1
    // https://godoc.org/k8s.io/client-go/kubernetes/typed/core/v1#SecretInterface
    secrets, err := clientset.CoreV1().Secrets("default").Create(&v1.Secret{
            TypeMeta: metav1.TypeMeta{
                    Kind: "Secret",
            },
            ObjectMeta: metav1.ObjectMeta{
                    Name: "generic-secret",
                    Namespace: "default",
            },
            Data: data,
    })

pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
services, err := clientset.CoreV1().Services("").List(metav1.ListOptions{})
serviceAccounts, err := clientset.CoreV1().ServiceAccounts("").List(metav1.ListOptions{})
deployments, err := clientset.AppsV1().Deployments("").List(metav1.ListOptions{})
pvs, err := clientset.CoreV1().PersistentVolumes().List(metav1.ListOptions{})
pvcs, err := clientset.CoreV1().PersistentVolumeClaims("").List(metav1.ListOptions{})
namespaces, err := clientset.CoreV1().Namespaces().List(metav1.ListOptions{})
ingresses, err := clientset.ExtensionsV1beta1().Ingresses("").List(metav1.ListOptions{})
secrets, err := clientset.CoreV1().Secrets("").List(metav1.ListOptions{})
configMaps, err := clientset.CoreV1().ConfigMaps("").List(metav1.ListOptions{})
ingress, err := clientset.ExtensionsV1beta1().Ingresses("jx").Get("docker-registry", metav1.GetOptions{})

    config, err := getConfig()
    dynamicClient, err := dynamic.NewForConfig(config)
	if err != nil {
		logrus.Error(err)
		return nil, nil, err
	}

	gvr := getGVR("kyverno.io", "v1", "clusterpolicies")

	list, err := dynamicClient.Resource(gvr).List(metav1.ListOptions{})

	if err != nil {
		logrus.Error(err)
		return
	}
	

// getGVR :- gets GroupVersionResource for dynamic client
func getGVR(group, version, resource string) schema.GroupVersionResource {
	return schema.GroupVersionResource{Group: group, Version: version, Resource: resource}
}

package main

import (
	"fmt"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/discovery"
	"k8s.io/client-go/tools/clientcmd"
)

func main()  {
	config, err := clientcmd.BuildConfigFromFlags("","/root/.kube/config")
	if err != nil {
		panic(err.Error())
	}

	discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	_, APIResourceList, err := discoveryClient.ServerGroupsAndResources()
	if err != nil {
		panic(err.Error())
	}
	for _, list := range APIResourceList {
		gv, err := schema.ParseGroupVersion(list.GroupVersion)
		if err != nil {
			panic(err.Error())
		}
		for _, resource := range list.APIResources {
			fmt.Printf("name: %v, group: %v, version %v\n", resource.Name, gv.Group, gv.Version)
		}
	}
}

// 通过informer 获取node 列表
factory := informers.NewSharedInformerFactory(clientset, 30*time.Second)
nodeInformer := factory.Core().V1().Nodes()
go nodeInformer.Informer().Run(stopCh)
if !cache.WaitForCacheSync(stopCh, nodeInformer.Informer().HasSynced) {
    runtime.HandleError(fmt.Errorf("Timed out waiting for caches to sync"))
    return
}
nodes, err := nodeInformer.Lister().List(labels.NewSelector())

pwd, err := os.Getwd()

filepathNames, err := filepath.Glob(filepath.Join(pwd,"*"))

filepath.Walk(pwd,func(path string, info os.FileInfo, err error) error{
		fmt.Println(path) //打印path信息
		fmt.Println(info.Name()) //打印文件或目录名
		return nil
	})

export GOPROXY=https://goproxy.cn

go mod download    下载依赖的module到本地cache（默认为$GOPATH/pkg/mod目录）
go mod edit        编辑go.mod文件
go mod graph       打印模块依赖图
go mod init        初始化当前文件夹, 创建go.mod文件
go mod tidy        增加缺少的module，删除无用的module
go mod vendor      将依赖复制到vendor下
go mod verify      校验依赖
go mod why         解释为什么需要依赖

replace (
    golang.org/x/crypto v0.0.0-20180820150726-614d502a4dac => github.com/golang/crypto v0.0.0-20180820150726-614d502a4dac
    golang.org/x/net v0.0.0-20180821023952-922f4815f713 => github.com/golang/net v0.0.0-20180826012351-8a410e7b638d
    golang.org/x/text v0.3.0 => github.com/golang/text v0.3.0
)

$ go mod init appname // 初始化当前文件夹, 创建go.mod文件
$ go mod tidy // 增加缺少的module，删除无用的module

go build

$ go mod vendor // 把原有 vendor 目录里的内容，reset成当前程序所需的依赖包，然后复制到原有vendor目录下
$ go build -mod=vendor // 使用 vendor 进行build

go list // 当前目录引用的包
go list -m all // 本机引用的包

go help list // 查看go list 的详细说明

$ go get -u github.com/spf13/cobra/cobra

$ cobra init --pkg-name appname

$ cobra add eula
$ cobra add kazuha

kelu.org/apptest

go mod init kelu.org/apptest
go mod tidy

go build

./apptest
./apptest eula
./apptest kazuha

ls -alh kelu*

Run: func(cmd *cobra.Command, args []string) {
    fmt.Println("cobra demo program") // 在这里实现
},

var cmdTimes = &cobra.Command{
    Use: …
    Short: …
    Long: …
    Args: cobra.MinimumNArgs(1),
    Run: …
}

cmd.SetHelpCommand(cmd *Command)
cmd.SetHelpFunc(f func(*Command, []string))
cmd.SetHelpTemplate(s string)

cmd.SetUsageFunc(f func(*Command) error)
cmd.SetUsageTemplate(s string)

var rootCmd = &cobra.Command{
    Use:   "cobrademo",
    Short: "sparkdev's cobra demo",
    Long: "the demo show how to use cobra package",
    PersistentPreRun: func(cmd *cobra.Command, args []string) {
        fmt.Printf("Inside rootCmd PersistentPreRun with args: %v\n", args)
    },
    PreRun: func(cmd *cobra.Command, args []string) {
        fmt.Printf("Inside rootCmd PreRun with args: %v\n", args)
    },
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Printf("cobra demo program, with args: %v\n", args)
    },
    PostRun: func(cmd *cobra.Command, args []string) {
        fmt.Printf("Inside rootCmd PostRun with args: %v\n", args)
    },
    PersistentPostRun: func(cmd *cobra.Command, args []string) {
        fmt.Printf("Inside rootCmd PersistentPostRun with args: %v\n", args)
    },
}

package cmd

import (
	"fmt"
	"strings"

	"github.com/spf13/cobra"
)

// kazuhaCmd represents the kazuha command
var kazuhaCmd = &cobra.Command{
	Use:   "kazuha",
	Short: "A brief description of your command",
	Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("kazuha args:" + strings.Join(args, " "))
	},
}

var times int
var kaedeharaCmd = &cobra.Command{
	Use:   "kaedehara",
	Short: "kaedehara 楓原",
	Long:  `kaedehara 楓原万叶`,
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		for i := 0; i < times; i++ {
			fmt.Println("kaedehara args:" + strings.Join(args, " "))
		}
	},
}

func init() {
	rootCmd.AddCommand(kazuhaCmd)
	kaedeharaCmd.Flags().IntVarP(&times, "times", "t", 1, "times loop for input")
	kazuhaCmd.AddCommand(kaedeharaCmd)

	// Here you will define your flags and configuration settings.

	// Cobra supports Persistent Flags which will work for this command
	// and all subcommands, e.g.:
	// kazuhaCmd.PersistentFlags().String("foo", "", "A help for foo")

	// Cobra supports local flags which will only run when this command
	// is called directly, e.g.:
	// kazuhaCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}