Operator 是 CoreOS 推出的旨在简化复杂有状态应用管理，它是一个感知应用状态的控制器，通过扩展 Kubernetes API 来自动创建、管理和配置应用实例。 Operator 基于 CRD 扩展资源对象，并通过控制器来保证应用处于预期状态。

  • 通过 Kubernetes API 观察集群的当前状态；

  • 分析当前状态与期望状态的差别；

  • 调用k8s API消除这些差别。

为什么使用crd

Kubernetes 目前已经成为了集群调度领域最炙手可热的开源项目之一 。其内置的 controller一般可以满足大多数使用场景，但对于很多定制化需求，其表达能力还是有限的。因此 Kubernetes 支持 Custom Resource Definition，也就是我们一直提到的 CRD。通过这一特性，用户可以自己定义资源类型，Kubernetes 会将其视为资源的一种，对其提供像内置资源对象一样的支持，这样的实现更加原生。CRD可以大大提高 Kubernetes 的扩展能力 ，以更原生的方式实现定制化要求。

operator设计初衷

我们在管理应用时，会遇到无状态和有状态的应用。管理无状态的应用是相对来说比较简单的，但是有状态的应用则比较复杂。Operator 的设计旨在简化复杂有状态应用管理，其通过CRD扩展 Kubernetes API 来自动创建、管理和配置应用实例。其本质上是针对特定的场景去做有状态服务，或者说针对复杂应用场景去简化其运维管理的工具。

Operator以deployment的形式部署到K8S中。部署完这个Operator之后，想要部署一个集群，其实很方便。因为不需要再去管理这个集群的配置信息了，只需要创建一个CRD，指定创建多少个节点，需要什么版本，Operator会监听该资源对象，创建出符合配置要求的集群，从而大大简化运维的难度和成本。

开发不同中间件operator流程大体相同，下面以redis operator进行说明：

首先准备

  • 需要一个资源对象定义（CRD）yaml，operator代码中会根据该yaml去组装并创建CRD。

     

  1. apiVersion: /v1beta1

  2. kind: CustomResourceDefinition

  3. metadata:

  4. name: redisclusters.redis.middleware.hc.cn

  5. spec:

  6. group: redis.middleware.hc.cn

  7. version: v1alpha1

  8. scope: Namespaced

  9. names:

  10. kind: RedisCluster

  11. singular: rediscluster

  12. listKind: RedisClusterList

  13. plural: redisclusters

  14. shortNames:

  15. - rec

后面创建的该CRD类型的资源对象（CR），其kind为该yaml描述中spec.names.kind的值。CR相当于CRD的具体实现。（不同的operator，CRD、CR定义不同）；

  • 准备一个CR yaml文件，后面operator代码要根据该yaml结构在types.go中定义结构体。redis的CR yaml如下。operator最终会监听该CR，解析里面定义的节点数、版本号等参数，驱动做一些事情。

     

  1. apiVersion: redis.middleware.hc.cn/v1alpha1

  2. kind: RedisCluster

  3. metadata:

  4. name: example000-redis-cluster

  5. namespace: kube-system

  6. spec:

  7. # 代表redis集群的个数

  8. replicas: 7

  9. # 代表是否进入维修状态

  10. pause: true

  11. # 是否删除crd以及redis集群

  12. finalizers: foreground

  13. # 镜像地址

  14. repository: library/redis

  15. # 镜像版本，便于后续多版本特化支持

  16. version: 3.2.8

  17. #redis集群升级策略

  18. updateStrategy:

  19. # 升级类型为AutoReceive（自动分配,不用AssignStrategies）, AssignReceive（指定值分配，需要用AssignStrategies）

  20. type: AssignReceive

  21. pipeline: "100"

  22. assignStrategies:

  23. -

  24. slots: 2000

  25. fromReplicas: nodeId1

  26. -

  27. # 从nodeId3,nodeId4一共分配1000个卡槽

  28. slots: 1000

  29. # 多个nodeId用逗号分隔

  30. fromReplicas: nodeId3,nodeId4

  31. # redis 实例配置详情

  32. pod:

  33. # 标签管理：map[string][string]

  34. - labels:

  35. key: value

  36. # 备注管理：map[string][string]

  37. annotations:

  38. key: value

  39. # 环境变量管理

  40. env:

  41. - name: tony

  42. value: aa

  43. - name: MAXMEMORY

  44. value: 2gb

  45. # 亲和性管理

  46. affinity:

  47. nodeAffinity:

  48. requiredDuringSchedulingIgnoredDuringExecution:

  49. nodeSelectorTerms:

  50. - matchExpressions:

  51. - key: HC_Status

  52. operator: In

  53. values:

  54. - C

  55. podAntiAffinity: {}

  56. # 资源管理

  57. resources:

  58. limits:

  59. #cpu, memory, storage,ephemeral-storage

  60. cpu: "2"

  61. memory: 4Gi

  62. requests:

  63. cpu: "1"

  64. memory: 2Gi

  65. #statefulset更新模式

  66. updateStrategy:

  67. type: RollingUpdate

  68. # 支持挂载形式： hostPath(不需要persistentVolumeClaimName)，nfs(需要persistentVolumeClaimName)

  69. volumes:

  70. type: nfs

  71. persistentVolumeClaimName: pvcName

  72. # 配置文件模板名

  73. configmap: name

  74. # 监控镜像

  75. monitorImage: string

  76. # 初始化镜像

  77. initImage: string

  78. # 中间件容器镜像

  79. middlewareImage: string

  80.  

  81. status:

  82. #当前statefulset replicas情况

  83. replicas: 6

  84. # 集群阶段,None,Creating,Running,Failed,Scaling

  85. # None 或 “”， 就是代表该CRD刚创建

  86. # Creating 代表等待redis资源对象创建完毕（operator 发现CRD创建，创建资源对象，更新状态）

  87. # Running 代表已进行初始化操作（在Creating之后，发现实例起来完毕，初始化操作）

  88. # Failed 代表着某异常故障

  89. # ---------------------

  90. # Scaling 代表着实例不一致(用户修改实例，operator发现实例不一致，更新statefulset，更新状态)

  91. # Upgrading 代表着升级中

  92. # ---------------------

  93. phase: Creating

  94. # 异常问题解释

  95. reason: "异常问题"

  96. conditions:

  97. - name: redis-cluster-0

  98. instance: 10.168.78.90:6379

  99. type: master

  100. masterNodeId: allkk111snknkcs

  101. nodeId: allkk111snknkcs

  102. domainName: redis-cluster-0.redis-cluster.kube-system.svc.cluster.local

  103. slots: 1024-2048

  104. hostname: docker-vm-3

  105. hostIP: 192.168.26.122

  106. # true or flase

  107. status: "True"

  108. reason: xxxx

  109. message: xxxx

  110. lastTransitionTime: 2019-03-25T03:10:29Z

代码生成

主要生成符合k8s风格的代码：

  • 生成风格统一的DeepCopy（CustomResources必须实现runtime.Object接口——必须实现DeepCopy方法）；

  • clientset（自定义资源对象的客户端）；

  • listers（用来提供对于 GET/List 资源对象的请求提供只读缓存层）；

  • informers（List/Get 资源对象，还可以监听事件并触发回调函数。

结构体定义到 $ProjectName/pkg/apis/{中间件名称}/{版本号}/types.go里：

手把手教你编写一个operator在中间件容器化中的实践_operator

types.go中结构体定义根据上面准备的CR yaml定义。如下，其中需要注意的是，必须要给结构体加以下两个注解：

  • // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object注解表示：为该类型生成 func (t* T) DeepCopy() *T方法。API类型都需要实现深拷贝；

  • // +genclient注解表示为当前类型生成客户端。

     手把手教你编写一个operator在中间件容器化中的实践_operator_02

3、编写$ProjectName/pkg/apis/{中间件名称}/{版本号}/doc.go，其中定义全局tag：// +k8s:deepcopy-gen=package，表示为包中任何类型生成深拷贝方法。package指定版本。

4、编写$ProjectName/pkg/apis/{中间件名称}/{版本号}/register.go，通过scheme注册自定义CR类型，这样当和API Server通信的时候就能够处理该类型；（不同operator需要修改SchemeGroupVersion的Group和Version以及addKnownTypes中注册的结构体）

  1. package v1alpha1

  2.  

  3. import (

  4. "harmonycloud.cn/middleware-operator-manager/pkg/apis/redis"

  5. v1 "k8s.io/apimachinery/pkg/apis/meta/v1"

  6. "k8s.io/apimachinery/pkg/runtime"

  7. "k8s.io/apimachinery/pkg/runtime/schema"

  8. )

  9.  

  10. // SchemeGroupVersion is group version used to register these objects

  11. var SchemeGroupVersion = schema.GroupVersion {Group: redis.GroupName, Version: "v1alpha1"}

  12.  

  13. // Kind takes an unqualified kind and returns back a Group qualified GroupKind

  14. func Kind(kind string) schema.GroupKind {

  15. return SchemeGroupVersion.WithKind(kind).GroupKind()

  16. }

  17.  

  18. // Resource takes an unqualified resource and returns a Group qualified GroupResource

  19. func Resource(resource string) schema.GroupResource {

  20. return SchemeGroupVersion.WithResource(resource).GroupResource()

  21. }

  22.  

  23. var (

  24. SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)

  25. AddToScheme = SchemeBuilder.AddToScheme

  26. )

  27.  

  28. //注册CR对象

  29. // Adds the list of known types to Scheme.

  30. func addKnownTypes(scheme *runtime.Scheme) error {

  31. scheme.AddKnownTypes(SchemeGroupVersion,

  32. &RedisCluster{},

  33. &RedisClusterList{},

  34. )

  35. v1.AddToGroupVersion(scheme, SchemeGroupVersion)

  36. return nil

  37. }

5、编写$ProjectName/pkg/apis/{中间件名称}/register.go，其中定义了上一步用到的GroupName；

6、使用kubernetes提供的code-generator代码生成器工具，根据定义好的CR结构体对象生成风格统一的DeepCopy（CustomResources必须实现runtime.Object接口——必须实现DeepCopy方法）、clientset（自定义资源对象的客户端）、listers（用来提供对于 GET/List 资源对象的请求提供只读缓存层）、informers（List/Get 资源对象，还可以监听事件并触发回调函数）代码。

code-generator地址如下，下载后放到$GOPATH/src/k8s.io/目录下：

https:///kubernetes/code-generator

然后执行以下命令，harmonycloud.cn/middleware-operator-manager/pkg/clients表示最终生成的clientset、informers、listers代码目录，最后的redis:v1alpha1需要改成{中间件名称}:{版本}

  1. ./ all "harmonycloud.cn/middleware-operator-manager/pkg/clients" "harmonycloud.cn/middleware-operator-manager/pkg/apis" "redis:v1alpha1"

执行后将生成以下代码：手把手教你编写一个operator在中间件容器化中的实践_operator_03

生成代码时可能遇到的坑，请参考：

k8s自定义资源类型代码自动生成：https://www.jianshu.com/p/cbeb513250d0

参考：

通过自定义资源扩展Kubernetes：

https://blog.gmem.cc/extend-kubernetes-with-custom-resources

Extending Kubernetes: Create Controllers for Core and Custom Resources

https://www.jianshu.com/p/dcfe6eac4152

 

operator主流程代码开发

手把手教你编写一个operator在中间件容器化中的实践_operator_04

首先operator的入口为operator-manager.go里的main函数。

  1. package main

  2.  

  3. import (

  4. "fmt"

  5. "/spf13/pflag"

  6. "harmonycloud.cn/middleware-operator-manager/cmd/operator-manager/app"

  7. "harmonycloud.cn/middleware-operator-manager/cmd/operator-manager/app/options"

  8. "k8s.io/apiserver/pkg/util/flag"

  9. "k8s.io/apiserver/pkg/util/logs"

  10. "k8s.io/kubernetes/pkg/version/verflag"

  11. "os"

  12. )

  13.  

  14. func main() {

  15. //参数初始化配置

  16. s := options.NewOMServer()

  17. s.AddFlags(pflag.CommandLine, app.KnownOperators())

  18.  

  19. flag.InitFlags()

  20. //日志初始化

  21. logs.InitLogs()

  22. defer logs.FlushLogs()

  23.  

  24. verflag.PrintAndExitIfRequested()

  25. //进行operator初始化

  26. if err := app.Run(s); err != nil {

  27. fmt.Fprintf(os.Stderr, "%v\n", err)

  28. os.Exit(1)

  29. }

  30. }

main函数中首先进行对参数的初始化，其中主要包括：operator多实例时的选主配置；事件同步时间；集群创建、升级超时时间；是否启用leader功能；是否开启pprof分析功能等，代码在options.go中。

app.Run(s)根据参数配置进行operator初始化：

  • 首先根据参数配置，构建默认客户端（操作k8s已有资源对象）、leader选举客户端、操作扩展资源客户端等；

  • 之后创建CRD资源对象定义，后续创建的CR对象都是该CRD的实例；

  • 注册健康检查接口、根据启动参数配置决定是否开启pprof分析接口功能；

  • 创建recorder，主要用于记录events（k8s资源），用于操作审计；

  • 定义Run函数，进行启动operator，选举结果的leader执行该函数；

  • 判断是否开启leader选举功能；

  • 创建leader选举的资源锁，目前资源锁实现了configmaps和endpoints方式，具体代码在client-go下，默认使用endpoints方式；

  • 启动leader选举机制，争抢到锁，选举为leader的实例执行OnStartedLeading，即上面定义的Run函数；失去锁的实例执行OnStoppedLeading函数。

     

  1. // Run runs the OMServer. This should never exit.

  2. func Run(s *options.OperatorManagerServer) error {

  3. // To help debugging, immediately log version

  4. glog.Infof("Version: %+v", version.Get())

  5.  

  6. //根据参数配置，构建默认客户端（操作k8s已有资源对象）、leader选举客户端、操作扩展资源客户端等

  7. kubeClient, leaderElectionClient, extensionCRClient, kubeconfig, err := createClients(s)

  8.  

  9. if err != nil {

  10. return err

  11. }

  12.  

  13. //根据提前准备好的CRD yaml文件，构建并创建CRD

  14. err = CreateRedisClusterCRD(extensionCRClient)

  15. if err != nil {

  16. if errors.IsAlreadyExists(err) {

  17. glog.Infof("redis cluster crd is already created.")

  18. } else {

  19. fmt.Fprint(os.Stderr, err)

  20. return err

  21. }

  22. }

  23.  

  24. //注册健康检查接口、根据启动参数配置决定是否开启pprof分析接口功能

  25. go startHTTP(s)

  26.  

  27. //创建recorder，主要用于记录events（k8s资源）

  28. recorder := createRecorder(kubeClient)

  29.  

  30. //定义Run函数，进行启动operator，选举结果的leader执行该函数

  31. run := func(stop <-chan struct{}) {

  32. operatorClientBuilder := operator.SimpleOperatorClientBuilder{

  33. ClientConfig: kubeconfig,

  34. }

  35.  

  36. rootClientBuilder := controller.SimpleControllerClientBuilder{

  37. ClientConfig: kubeconfig,

  38. }

  39.  

  40. otx, err := CreateOperatorContext(s, kubeconfig, operatorClientBuilder, rootClientBuilder, stop)

  41. if err != nil {

  42. glog.Fatalf("error building controller context: %v", err)

  43. }

  44.  

  45. otx.InformerFactory = informers.NewSharedInformerFactory(kubeClient, time.Duration(s.ResyncPeriod)*time.Second)

  46.  

  47. if err := StartOperators(otx, NewOperatorInitializers()); err != nil {

  48. glog.Fatalf("error starting operators: %v", err)

  49. }

  50.  

  51. otx.RedisInformerFactory.Start(otx.Stop)

  52. otx.InformerFactory.Start(otx.Stop)

  53. close(otx.InformersStarted)

  54.  

  55. select {}

  56. }

  57.  

  58. //判断是否开启leader选举功能

  59. if !s.LeaderElection.LeaderElect {

  60. run(nil)

  61. panic("unreachable")

  62. }

  63.  

  64. id, err := os.Hostname()

  65. if err != nil {

  66. return err

  67. }

  68.  

  69. //创建leader选举的资源锁，目前资源锁实现了configmaps和endpoints方式，具体代码在client-go下，默认使用endpoints方式

  70. rl, err := resourcelock.New(s.LeaderElection.ResourceLock,

  71. "kube-system",

  72. "middleware-operator-manager",

  73. leaderElectionClient.CoreV1(),

  74. resourcelock.ResourceLockConfig{

  75. Identity: id,

  76. EventRecorder: recorder,

  77. })

  78. if err != nil {

  79. glog.Fatalf("error creating lock: %v", err)

  80. }

  81.  

  82. //启动leader选举机制，争抢到锁，选举为leader的实例执行OnStartedLeading，即上面定义的Run函数；失去锁的实例执行OnStoppedLeading函数

  83. leaderelection.RunOrDie(leaderelection.LeaderElectionConfig{

  84. Lock: rl,

  85. LeaseDuration: s.LeaderElection.LeaseDuration.Duration,

  86. RenewDeadline: s.LeaderElection.RenewDeadline.Duration,

  87. RetryPeriod: s.LeaderElection.RetryPeriod.Duration,

  88. Callbacks: leaderelection.LeaderCallbacks{

  89. OnStartedLeading: run,

  90. OnStoppedLeading: func() {

  91. glog.Fatalf("leaderelection lost")

  92. },

  93. },

  94. })

  95. panic("unreachable")

  96. }

CreateRedisClusterCRD方法根据上面准备的CRD yaml文件构建并创建CRD，只有创建了该CRD，redisCluster资源对象才可以被创建。

  1. func CreateRedisClusterCRD(extensionCRClient *extensionsclient.Clientset) error {

  2. //TODO add CustomResourceValidation due to guarantee redis operator work normally,k8s1.12

  3. crd := &v1beta1.CustomResourceDefinition{

  4. ObjectMeta: metav1.ObjectMeta{

  5. Name: "redisclusters." + v1alpha1.SchemeGroupVersion.Group,

  6. },

  7. Spec: v1beta1.CustomResourceDefinitionSpec{

  8. Group: v1alpha1.SchemeGroupVersion.Group,

  9. Version: v1alpha1.SchemeGroupVersion.Version,

  10. Scope: v1beta1.NamespaceScoped,

  11. Names: v1beta1.CustomResourceDefinitionNames{

  12. Kind: "RedisCluster",

  13. ListKind: "RedisClusterList",

  14. Plural: "redisclusters",

  15. Singular: "rediscluster",

  16. ShortNames: []string{"rec"},

  17. },

  18. },

  19. }

  20. _, err := extensionCRClient.ApiextensionsV1beta1().CustomResourceDefinitions().Create(crd)

  21. return err

  22. }

CR的apiVersion为CRD的spec.Group/spec.Version即生成代码时register.go中的GroupName和doc.go中的版本号：

  1. apiVersion: redis.middleware.hc.cn/v1alpha1

  2. kind: RedisCluster

  3. metadata:

  4. name: example000-redis-cluster

  5. namespace: kube-system

Run函数中主要创建context对象，context里包含启动参数options，kubeconfig配置、RedisInformerFactory（监听CR变化）、InformerFactory（监听statefulsetset变化）等，进行启动operator、启动informer。

  1. run := func(stop <-chan struct{}) {

  2. operatorClientBuilder := operator.SimpleOperatorClientBuilder{

  3. ClientConfig: kubeconfig,

  4. }

  5.  

  6. rootClientBuilder := controller.SimpleControllerClientBuilder{

  7. ClientConfig: kubeconfig,

  8. }

  9. //创建context对象，context里包含启动参数options，kubeconfig配置、RedisInformerFactory（监听CR变化）、InformerFactory（监听statefulsetset变化）等

  10. otx, err := CreateOperatorContext(s, kubeconfig, operatorClientBuilder, rootClientBuilder, stop)

  11. if err != nil {

  12. glog.Fatalf("error building controller context: %v", err)

  13. }

  14.  

  15. //创建InformerFactory

  16. otx.InformerFactory = informers.NewSharedInformerFactory(kubeClient, time.Duration(s.ResyncPeriod)*time.Second)

  17.  

  18. //启动operator，NewOperatorInitializers()中定义了启动哪些operator

  19. if err := StartOperators(otx, NewOperatorInitializers()); err != nil {

  20. glog.Fatalf("error starting operators: %v", err)

  21. }

  22. //启动RedisInformerFactory

  23. otx.RedisInformerFactory.Start(otx.Stop)

  24. //启动InformerFactory

  25. otx.InformerFactory.Start(otx.Stop)

  26. close(otx.InformersStarted)

  27. //阻塞

  28. select {}

  29. }

NewOperatorInitializers()中定义了启动哪些operator（新加operator直接在该方法中加）：

  1. func NewOperatorInitializers() map[string]InitFunc {

  2. controllers := map[string]InitFunc{}

  3. controllers["rediscluster"] = startRedisClusterController

  4.  

  5. return controllers

  6. }

CreateOperatorContext函数里根据代码生成器生成的redis客户端versionedClient创建了RedisInformerFactory；（根据不同operator生成不同的客户端，这里需要修改client_builder.go中ClientOrDie的返回值类型），最终创建context对象。

  1. func CreateOperatorContext(s *options.OperatorManagerServer, kubeConfig *restclient.Config, operatorClientBuilder operator.OperatorClientBuilder, rootClientBuilder controller.ControllerClientBuilder, stop <-chan struct{}) (OperatorContext, error) {

  2. versionedClient := operatorClientBuilder.ClientOrDie("middleware-shared-informers")

  3. sharedInformers := redisInformerFactory.NewSharedInformerFactory(versionedClient, time.Duration(s.ResyncPeriod)*time.Second)

  4.  

  5. /*availableResources, err := GetAvailableResources(rootClientBuilder)

  6.     if err != nil {

  7. return OperatorContext{}, err

  8. }*/

  9.  

  10. otx := OperatorContext{

  11. kubeConfig: kubeConfig,

  12. OperatorClientBuilder: operatorClientBuilder,

  13. DefaultClientBuilder: rootClientBuilder,

  14. RedisInformerFactory: sharedInformers,

  15. Options: *s,

  16. //AvailableResources: availableResources,

  17. Stop: stop,

  18. InformersStarted: make(chan struct{}),

  19. }

  20. return otx, nil

  21. }

StartOperators函数启动所有NewOperatorInitializers中定义的operator，执行startRedisClusterController函数。（不同operator执行不同的启动函数）。

startRedisClusterController定义在extensions.go中，用于创建operator、启动worker协程从队列中取出（用于处理informer监听变化的资源对象）进行业务逻辑处理。（新增operator需要在extensions.go中增加对应的start函数）

  1. func startRedisClusterController(otx OperatorContext) (bool, error) {

  2. //创建redisOperator

  3. rco, err := redis.NewRedisClusterOperator(

  4. //注册RedisInformer回调函数

  5. ().V1alpha1().RedisClusters(),

  6. //注册statefulsetInformer回调函数

  7. otx.InformerFactory.Apps().V1().StatefulSets(),

  8. //默认客户端，用于操作k8s自身资源对象

  9. otx.DefaultClientBuilder.ClientOrDie("default-kube-client"),

  10. //代码生成器生成的客户端，用于操作CR

  11. otx.OperatorClientBuilder.ClientOrDie("rediscluster-operator"),

  12. //kubeconfig配置

  13. otx.kubeConfig,

  14. //启动参数配置

  15. otx.Options,

  16. )

  17. if err != nil {

  18. return true, fmt.Errorf("error creating rediscluster operator: %v", err)

  19. }

  20. //启动ConcurrentRedisClusterSyncs个worker协程处理变化的资源对象

  21. go rco.Run(int(otx.Options.ConcurrentRedisClusterSyncs), otx.Stop)

  22. return true, nil

  23. }

NewRedisClusterOperator方法如下，主要创建该operator的结构体，队列，redisInformer注册回调函数，statefulsetInformer回调函数的注册。（不同的operator，需要不同的Informer、处理业务逻辑的方法）

  1. func NewRedisClusterOperator(redisInformer custominfomer.RedisClusterInformer, stsInformer appsinformers.StatefulSetInformer, kubeClient clientset.Interface, customCRDClient customclient.Interface, kubeConfig *rest.Config, options options.OperatorManagerServer) (*RedisClusterOperator, error) {

  2. //创建该operator的recorder，记录events

  3. eventBroadcaster := record.NewBroadcaster()

  4. eventBroadcaster.StartLogging(glog.Infof)

  5. eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: v1core.New(kubeClient.CoreV1().RESTClient()).Events("")})

  6. //创建该operator的结构体

  7. rco := &RedisClusterOperator{

  8. options: &options,

  9. kubeConfig: kubeConfig,

  10. defaultClient: kubeClient,

  11. //extensionCRClient: extensionCRClient,

  12. customCRDClient: customCRDClient,

  13. eventRecorder: eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "operator-manager"}),

  14. queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "rediscluster"),

  15. }

  16.  

  17. //redisInformer注册回调函数，当informer监听到redis CR资源变化时，调用对应AddFunc、UpdateFunc、DeleteFunc回调函数将CR资源放到queue中

  18. redisInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{

  19. AddFunc: rco.addRedisCluster,

  20. UpdateFunc: rco.updateRedisCluster,

  21. // This will enter the sync loop and no-op, because the RedisCluster has been deleted from the store.

  22. DeleteFunc: rco.deleteRedisCluster,

  23. })

  24.  

  25. //定义最终处理业务逻辑的函数

  26. rco.syncHandler = rco.syncRedisCluster

  27. rco.enqueueRedisCluster = rco.enqueue

  28.  

  29. rco.redisClusterInformer = redisInformer.Informer()

  30. //redisInformer是否已经开始同步事件变化

  31. rco.redisClusterListerSynced = rco.redisClusterInformer.HasSynced

  32. //lister提供操作informer中缓存的变化的资源接口

  33. rco.redisClusterLister = redisInformer.Lister()

  34.  

  35. //statefulsetInformer注册回调函数，当informer监听到statefulset资源变化时，调用对应AddFunc、UpdateFunc、DeleteFunc回调函数将redis实例的statefulset加入到queue中

  36. stsInformer.Informer().AddEventHandler(

  37. cache.ResourceEventHandlerFuncs{

  38. AddFunc: rco.addStatefulSet,

  39. UpdateFunc: func(old, cur interface{}) {

  40. oldSts := old.(*appsv1.StatefulSet)

  41. curSts := cur.(*appsv1.StatefulSet)

  42. if oldSts.Status.Replicas != curSts.Status.Replicas {

  43. glog.V(4).Infof("Observed updated replica count for StatefulSet: %v, %d->%d", , oldSts.Status.Replicas, curSts.Status.Replicas)

  44. }

  45. rco.updateStatefulSet(oldSts, curSts)

  46. },

  47. DeleteFunc: rco.deleteStatefulSet,

  48. },

  49. )

  50. rco.stsLister = stsInformer.Lister()

  51. //statefulsetInformer是否已经开始同步事件变化

  52. rco.stsListerSynced = stsInformer.Informer().HasSynced

  53.  

  54. return rco, nil

  55. }

Run函数中等待redis CR资源、statefulset资源对象同步，然后启动指定个数worker，并永久阻塞，直到stopCh被close（不同operator需要修改rco.redisClusterListerSynced为对应的ListerSynced）

  1. func (rco *RedisClusterOperator) Run(workers int, stopCh <-chan struct{}) {

  2. defer utilruntime.HandleCrash()

  3. defer rco.queue.ShutDown()

  4.  

  5. glog.Infof("Starting rediscluster operator")

  6. defer glog.Infof("Shutting down rediscluster operator")

  7.  

  8. //等待redis CR资源、statefulset资源对象同步。

  9. if !controller.WaitForCacheSync("rediscluster", stopCh, rco.redisClusterListerSynced, rco.stsListerSynced) {

  10. return

  11. }

  12.  

  13. //循环启动指定个数worker，并永久阻塞，直到stopCh被close

  14. for i := 0; i < workers; i++ {

  15. go wait.Until(rco.worker, time.Second, stopCh)

  16. }

  17.  

  18. <-stopCh

  19. }

worker方法死循环rco.processNextWorkItem()在队列Operator中定义的queue中取出变化的资源去处理（不同operator有不同的业务处理逻辑）

  1. func (rco *RedisClusterOperator) worker() {

  2. for rco.processNextWorkItem() {

  3. }

  4. }

从informer监听到资源对象变化，回调函数将资源对象key（namespace/name）放到queue中，到worker取出queue中的key去做处理，处理完成后Done掉key流程图如下：

手把手教你编写一个operator在中间件容器化中的实践_operator_05

回调函数将资源对象的key加入到queue中，worker从queue中取出key去处理业务，此时key会被放到processing集合中，表示该key正在被处理。worker处理key时如果遇到错误，该key会根据重试次数是否大于最大重试次数被加入到rateLimited（可以限制添加到queue中速度，最终还会被加入到queue）。worker处理key成功后，Forget(key)表示从rateLimited中清除，Done(key)表示key处理完毕，从processing集合中删除。该代码如下：

  1. func (rco *RedisClusterOperator) processNextWorkItem() bool {

  2. key, quit := rco.queue.Get()

  3.  

  4. if quit {

  5. return false

  6. }

  7.  

  8. // Done marks item as done processing, and if it has been marked as dirty again

  9. // while it was being processed, it will be re-added to the queue for

  10. // re-processing.

  11. defer rco.queue.Done(key)

  12.  

  13. err := rco.syncHandler(key.(string))

  14. //加入到rateLimited中、forget(key)

  15. rco.handleErr(err, key)

  16.  

  17. //处理key，主业务逻辑

  18. go rco.syncHandler(key.(string))

  19.  

  20. return true

  21. }

开发注意事项

  •  

    开启worker时，调用cache.WaitForCacheSync等待缓存开始同步。

    手把手教你编写一个operator在中间件容器化中的实践_operator_06

     

  •  

    不要改变原始对象（从lister中取出的对象），而要使用DeepCopy，因为缓存在informer之间共享。

    手把手教你编写一个operator在中间件容器化中的实践_operator_07

     

  •  

    根据CRD构建Statefulset时，给Statefulset加OwnerReferences，这样在删除CRD的时候，可以设置是否级联删除statefulset。

    手把手教你编写一个operator在中间件容器化中的实践_operator_08

     

参考：

k8s垃圾收集：https://kubernetes.io/zh/docs/concepts/workloads/controllers/garbage-collection/

 

调试

本地用IDE--goland调试代码时，配置如下：手把手教你编写一个operator在中间件容器化中的实践_operator_09

Run kind：选File；

Files：指定main函数所在文件的全路径；

Output directory：指定编译后输出的二进制文件位置。可输入。（默认输出exe格式windows可执行文件）

Run after build：勾选后，编译完成后运行。

Go tool arguments：填写-i（用于增量编译提速）。

Program arguments：用于指定程序启动参数：

  1. --kubeconfig=D:\SoftwareAndProgram\program\Go\Development\src\harmonycloud.cn\middleware-operator-manager\artifacts\config60 --v=5

--kubeconfig指定kubeconfig文件所在全路径（即k8s集群master节点的/root/.kube/config），其指定k8s集群apiserver地址已经访问时的证书信息。手把手教你编写一个operator在中间件容器化中的实践_operator_10

--v指定glog日志级别，--v=5表示只输出info小于5和error、warn日志。

  1. glog.V(4).Infof("Adding RedisCluster %s", )

  2. glog.Warningf("-----------redisCluster: %#v--", redisCluster)

  3. glog.Errorf(err.Error())

镜像制作

编译前提

提前安装好go语言开发环境，正确设置GOROOT和GOPATH环境变量，要求go1.8.3版本以上

编译二进制

将 middleware-operator-manager放在 $GOPATH/src/harmonycloud.cn/目录下，进入到 $GOPATH/src/harmonycloud.cn/middleware-operator-manager/cmd/operator-manager目录， 最终要生成linux的可执行文件：

  • 如果是在windows上编译：

打开cmd窗口，进入以上目录后，执行以下命令：

  1. set GOOS=linux

  2. go build -a -o operator-manager

 

  • 如果是在linux上编译：

执行以下命令：

  1. go build -a -o operator-manager

等待编译完成，最终在当前目录下生成operator-manager可执行文件

镜像制作

$GOPATH/src/harmonycloud.cn/middleware-operator-manager/artifacts目录下有Dockerfile文件，基础镜像为busybox

  1. FROM busybox

  2.  

  3. ADD operator-manager /usr/bin/

  4. RUN chmod +x /usr/bin/operator-manager

同级目录下有operator-manager deployment描述文件operator-manager.yaml:

  1. apiVersion: extensions/v1beta1

  2. kind: Deployment

  3. metadata:

  4. generation: 2

  5. labels:

  6. app: operator-manager

  7. name: operator-manager

  8. namespace: kube-system

  9. spec:

  10. replicas: 2

  11. selector:

  12. matchLabels:

  13. app: operator-manager

  14. strategy:

  15. rollingUpdate:

  16. maxSurge: 1

  17. maxUnavailable: 1

  18. type: RollingUpdate

  19. template:

  20. metadata:

  21. creationTimestamp: null

  22. labels:

  23. app: operator-manager

  24. spec:

  25. containers:

  26. - command:

  27. - operator-manager

  28. - --v=5

  29. - --leader-elect=true

  30. image: 192.168.26.46/k8s-deploy/operator-manager:v1

  31. resources:

  32. limits:

  33. cpu: 500m

  34. memory: 512Mi

  35. requests:

  36. cpu: 200m

  37. memory: 512Mi

  38. imagePullPolicy: Always

  39. name: operator-manager

  40. terminationMessagePath: /dev/termination-log

  41. terminationMessagePolicy: File

  42. dnsPolicy: ClusterFirst

  43. restartPolicy: Always

  44. schedulerName: default-scheduler

  45. securityContext: {}

  46. terminationGracePeriodSeconds: 30

同级目录下有脚本，指定了docker镜像仓库地址为192.168.26.46

  1. #!/bin/bash

  2.  

  3. docker build -f ./Dockerfile -t operator-manager:v1 .

  4. docker tag operator-manager:v1 192.168.26.46/k8s-deploy/operator-manager:v1

  5. docker push 192.168.26.46/k8s-deploy/operator-manager:v1

  6. kubectl apply -f operator-manager.yaml

执行该脚本即可以将operator-manager二进制打成镜像并推送到192.168.26.46仓库的k8s-deploy项目下： 同时执行了

  1. kubectl apply -f operator-manager.yaml

命令创建了operator-manager的deployment对象，完成了部署。

operator高可用

用k8s组件中leader选举机制实现redis operator组件的高可用，即正常情况下redis operator组件的多个副本只有一个是处于业务逻辑运行状态，其它副本则不断的尝试去获取锁，去竞争leader，直到自己成为leader。如果正在运行的leader因某种原因导致当前进程退出，或者锁丢失，则由其它副本去竞争新的leader，获取leader继而执行业务逻辑。

启动两个operator-manager实例：手把手教你编写一个operator在中间件容器化中的实践_operator_11

可以看到只有一个实例operator-manager-86d785b5fc-m5rgh在同步事件，处理业务：手把手教你编写一个operator在中间件容器化中的实践_operator_12

operator-manager-86d785b5fc-sszj2实例一直在竞争尝试获取锁：手把手教你编写一个operator在中间件容器化中的实践_operator_13

删除掉正在同步事件的实例operator-manager-86d785b5fc-m5rgh：手把手教你编写一个operator在中间件容器化中的实践_operator_14

实例operator-manager-86d785b5fc-sszj2竞争获取到锁，开始处理业务逻辑：

手把手教你编写一个operator在中间件容器化中的实践_operator_15故可以通过反亲和性防止两个operator-manager实例调度到同一主机上，达到主备高可用。

 

 

手把手教你编写一个operator在中间件容器化中的实践_operator_16