01-client-go

想学习K8S源码，可以加 ：mkjnnm
1、先容

client-go 是用来和 k8s 集群交互的go语言客户端库，地点为：https://github.com/kubernetes/client-go client-go 的版本有两种标识方式：

• v0.x.y (For each v1.x.y Kubernetes release, the major version (first digit) would remain 0)
  
• kubernetes-1.x.y
  

ps: k8s 发布v1.30.0 版本时，client-go 会同步发布两个版本 v0.30.0 (保举利用)和 kubernetes-1.30.0
如果你想利用最新版本的客户端库，你可以运行如下下令：
go get k8s.io/client-go@latest
如果你想利用特定版本，保举利用如下下令：
go get k8s.io/client-go@v0.20.4
2、目录布局

client-go 包罗以下几部门：

• The kubernetes package contains the clientset to access Kubernetes API.
  
• The discovery package is used to discover APIs supported by a Kubernetes API server.
  
• The dynamic package contains a dynamic client that can perform generic operations on arbitrary Kubernetes API objects.
  
• The plugin/pkg/client/auth packages contain optional authentication plugins for obtaining credentials from external sources.
  
• The transport package is used to set up auth and start a connection.
  
• The tools/cache package is useful for writing controllers.
  

3、利用

1.初始化

• 集群内初始化
  
• 集群外初始化
  

如果你的应用跑在集群中的pod上，保举利用集群内初始化，否则利用集群外初始化。

1. // 集群外初始化 client
2. // 需要集群的 kubeconfig 配置文件
3. func main() {
4.         var kubeconfig *string
5.         if home := homedir.HomeDir(); home != "" {
6.                 kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
7.         } else {
8.                 kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
9.         }
10.         flag.Parse()
12.         // use the current context in kubeconfig
13.         config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
14.         if err != nil {
15.                 panic(err.Error())
16.         }
18.         // create the clientset
19.         clientset, err := kubernetes.NewForConfig(config)
20.         if err != nil {
21.                 panic(err.Error())
22.         }
23. }

复制代码

2. 列出集群内pod资源

1. pods, err := clientset.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{})
2.                 if err != nil {
3.                         panic(err.Error())
4.                 }
5.                 fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))

复制代码

上述代码在client-
go仓库下examples目录
你可以运行该代码：

1. cd out-of-cluster-client-configuration
2. go build -o app .
3. ./app -kubeconfig=/path/to/xxx

复制代码

3. deployment资源CRUD - typed (clientset)方式

以下代码创建一个有2个副本数的deployment，然后更新副本数为1，升级nginx镜像版本，最后删除

1.         deploymentsClient := clientset.AppsV1().Deployments(apiv1.NamespaceDefault)
3.         deployment := &appsv1.Deployment{
4.                 ObjectMeta: metav1.ObjectMeta{
5.                         Name: "demo-deployment",
6.                 },
7.                 Spec: appsv1.DeploymentSpec{
8.                         Replicas: int32Ptr(2),
9.                         Selector: &metav1.LabelSelector{
10.                                 MatchLabels: map[string]string{
11.                                         "app": "demo",
12.                                 },
13.                         },
14.                         Template: apiv1.PodTemplateSpec{
15.                                 ObjectMeta: metav1.ObjectMeta{
16.                                         Labels: map[string]string{
17.                                                 "app": "demo",
18.                                         },
19.                                 },
20.                                 Spec: apiv1.PodSpec{
21.                                         Containers: []apiv1.Container{
22.                                                 {
23.                                                         Name:  "web",
24.                                                         Image: "nginx:1.12",
25.                                                         Ports: []apiv1.ContainerPort{
26.                                                                 {
27.                                                                         Name:          "http",
28.                                                                         Protocol:      apiv1.ProtocolTCP,
29.                                                                         ContainerPort: 80,
30.                                                                 },
31.                                                         },
32.                                                 },
33.                                         },
34.                                 },
35.                         },
36.                 },
37.         }
39.         // Create Deployment
40.         fmt.Println("Creating deployment...")
41.         result, err := deploymentsClient.Create(context.TODO(), deployment, metav1.CreateOptions{})
42.         if err != nil {
43.                 panic(err)
44.         }
45.         fmt.Printf("Created deployment %q.\n", result.GetObjectMeta().GetName())
47.         // Update Deployment
48.         prompt()
49.         fmt.Println("Updating deployment...")
50.         //    You have two options to Update() this Deployment:
51.         //
52.         //    1. Modify the "deployment" variable and call: Update(deployment).
53.         //       This works like the "kubectl replace" command and it overwrites/loses changes
54.         //       made by other clients between you Create() and Update() the object.
55.         //    2. Modify the "result" returned by Get() and retry Update(result) until
56.         //       you no longer get a conflict error. This way, you can preserve changes made
57.         //       by other clients between Create() and Update(). This is implemented below
58.         //                         using the retry utility package included with client-go. (RECOMMENDED)
59.         //
60.         // More Info:
61.         // https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
63.         retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
64.                 // Retrieve the latest version of Deployment before attempting update
65.                 // RetryOnConflict uses exponential backoff to avoid exhausting the apiserver
66.                 result, getErr := deploymentsClient.Get(context.TODO(), "demo-deployment", metav1.GetOptions{})
67.                 if getErr != nil {
68.                         panic(fmt.Errorf("Failed to get latest version of Deployment: %v", getErr))
69.                 }
71.                 result.Spec.Replicas = int32Ptr(1)                           // reduce replica count
72.                 result.Spec.Template.Spec.Containers[0].Image = "nginx:1.13" // change nginx version
73.                 _, updateErr := deploymentsClient.Update(context.TODO(), result, metav1.UpdateOptions{})
74.                 return updateErr
75.         })
76.         if retryErr != nil {
77.                 panic(fmt.Errorf("Update failed: %v", retryErr))
78.         }
79.         fmt.Println("Updated deployment...")
81.         // List Deployments
82.         prompt()
83.         fmt.Printf("Listing deployments in namespace %q:\n", apiv1.NamespaceDefault)
84.         list, err := deploymentsClient.List(context.TODO(), metav1.ListOptions{})
85.         if err != nil {
86.                 panic(err)
87.         }
88.         for _, d := range list.Items {
89.                 fmt.Printf(" * %s (%d replicas)\n", d.Name, *d.Spec.Replicas)
90.         }
92.         // Delete Deployment
93.         prompt()
94.         fmt.Println("Deleting deployment...")
95.         deletePolicy := metav1.DeletePropagationForeground
96.         if err := deploymentsClient.Delete(context.TODO(), "demo-deployment", metav1.DeleteOptions{
97.                 PropagationPolicy: &deletePolicy,
98.         }); err != nil {
99.                 panic(err)
100.         }
101.         fmt.Println("Deleted deployment.")
102. }
104. func prompt() {
105.         fmt.Printf("-> Press Return key to continue.")
106.         scanner := bufio.NewScanner(os.Stdin)
107.         for scanner.Scan() {
108.                 break
109.         }
110.         if err := scanner.Err(); err != nil {
111.                 panic(err)
112.         }
113.         fmt.Println()
114. }
116. func int32Ptr(i int32) *int32 { return &i }

复制代码

4.deployment资源CRUD - dynamic方式

利用typed方式创建资源固然方便，但是必要事先利用client-gen天生且会与某个特定版本耦合，不敷通用，所以我们可以利用 unstructured.Unstructured 来表现集群中恣意对象。

1.         client, err := dynamic.NewForConfig(config)
2.         if err != nil {
3.                 panic(err)
4.         }
5.        
6.         deploymentRes := schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}
8.         deployment := &unstructured.Unstructured{
9.                 Object: map[string]interface{}{
10.                         "apiVersion": "apps/v1",
11.                         "kind":       "Deployment",
12.                         "metadata": map[string]interface{}{
13.                                 "name": "demo-deployment",
14.                         },
15.                         "spec": map[string]interface{}{
16.                                 "replicas": 2,
17.                                 "selector": map[string]interface{}{
18.                                         "matchLabels": map[string]interface{}{
19.                                                 "app": "demo",
20.                                         },
21.                                 },
22.                                 "template": map[string]interface{}{
23.                                         "metadata": map[string]interface{}{
24.                                                 "labels": map[string]interface{}{
25.                                                         "app": "demo",
26.                                                 },
27.                                         },
29.                                         "spec": map[string]interface{}{
30.                                                 "containers": []map[string]interface{}{
31.                                                         {
32.                                                                 "name":  "web",
33.                                                                 "image": "nginx:1.12",
34.                                                                 "ports": []map[string]interface{}{
35.                                                                         {
36.                                                                                 "name":          "http",
37.                                                                                 "protocol":      "TCP",
38.                                                                                 "containerPort": 80,
39.                                                                         },
40.                                                                 },
41.                                                         },
42.                                                 },
43.                                         },
44.                                 },
45.                         },
46.                 },
47.         }
49.         // Create Deployment
50.         fmt.Println("Creating deployment...")
51.         result, err := client.Resource(deploymentRes).Namespace(apiv1.NamespaceDefault).Create(context.TODO(), deployment, metav1.CreateOptions{})
52.         if err != nil {
53.                 panic(err)
54.         }
55.         fmt.Printf("Created deployment %q.\n", result.GetName())

复制代码

5. discoveryClient

3-4末节我们学习了 typed client 和 dynamic client ，这两个client利用来操作集群中资源，比如创建 deployment，删除pod。discovery client 差别，他是用来发现服务端支持的组、版本、资源类型：

1. // Package discovery provides ways to discover server-supported
2. // API groups, versions and resources.

复制代码

我们可以查询服务端支持的组与版本、某个组的资源列表

1. func main() {
2.         var kubeconfig *string
3.         if home := homedir.HomeDir(); home != "" {
4.                 kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
5.         } else {
6.                 kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
7.         }
8.         flag.Parse()
10.         // use the current context in kubeconfig
11.         config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
12.         if err != nil {
13.                 panic(err.Error())
14.         }
16.         // *查询服务端支持的组列表
17.         discoveryClient := discovery.NewDiscoveryClientForConfigOrDie(config)
18.         gs, err := discoveryClient.ServerGroups()
19.         if err != nil {
20.                 panic(err.Error())
21.         }
22.         spew.Dump(gs.Groups)
23.        
24.         // *查询core/v1 组下的资源列表
25.         rs, err := discoveryClient.ServerResourcesForGroupVersion("v1")
26.         if err != nil {
27.                 panic(err.Error())
28.         }
29.         for _, r := range rs.APIResources {
30.                 fmt.Println(r.Name)
31.         }
33. }
35. // 输出支持的组列表
36. /*
37. (v1.APIGroup) &APIGroup{Name:apps,Versions:[]GroupVersionForDiscovery{GroupVersionForDiscovery{GroupVersion:apps/v1,Version:v1,},},PreferredVersion:GroupVersionForDiscovery{GroupVersion:apps/v1,Version:v1,},ServerAddressByClientCIDRs:[]ServerAddressByClientCIDR{},},
38. (v1.APIGroup) &APIGroup{Name:events.k8s.io,Versions:[]GroupVersionForDiscovery{GroupVersionForDiscovery{GroupVersion:events.k8s.io/v1,Version:v1,},},PreferredVersion:GroupVersionForDiscovery{GroupVersion:events.k8s.io/v1,Version:v1,},ServerAddressByClientCIDRs:[]ServerAddressByClientCIDR{},},
39. ...
40. */
42. // 输出core/v1组下的资源列表
43. /*
44. pods/status
45. podtemplates
46. replicationcontrollers
47. replicationcontrollers/scale
48. replicationcontrollers/status
49. resourcequotas
50. resourcequotas/status
51. secrets
52. serviceaccounts
53. ...
54. */

复制代码

6. restClient

上面三种客户端都是基于 restClient 封装的，restClient 是 client-go 最底子的客户端，对http request 举行了封装，更加灵活，一般我们用不到。

1. // 根据配置信息构建restClient实例
2.         restClient, err := rest.RESTClientFor(config)
4.         if err!=nil {
5.                 panic(err.Error())
6.         }
8.         // 保存pod结果的数据结构实例
9.         result := &corev1.PodList{}
11.         //  指定namespace
12.         namespace := "kube-system"
13.         // 设置请求参数，然后发起请求
14.         // GET请求
15.         err = restClient.Get().
16.                 //  指定namespace，参考path : /api/v1/namespaces/{namespace}/pods
17.                 Namespace(namespace).
18.                 // 查找多个pod，参考path : /api/v1/namespaces/{namespace}/pods
19.                 Resource("pods").
20.                 // 指定大小限制和序列化工具
21.                 VersionedParams(&metav1.ListOptions{Limit:100}, scheme.ParameterCodec).
22.                 // 请求
23.                 Do(context.TODO()).
24.                 // 结果存入result
25.                 Into(result)

复制代码

4、范围

利用 client 操作集群中资源会导致频繁的轮询，k8s client-go 包提供了更加高效的方式：informer 。
informer 提供了一种机制来监视 Kubernetes 集群内资源的变化并做出反应。它使开辟职员能够接收有关各种 Kubernetes 对象（比方 Pod、服务、部署等）状态的实时更新。
Informer 将集群中的资源缓存在当地来减少频繁的API调用，提高性能并优化资源利用率。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。