01-client-go

光之使者  金牌会员 | 2024-7-28 02:37:10 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 957|帖子 957|积分 2871

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
想学习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企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

光之使者

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表