使用 kubebuilder 开发 Operator

kubebuilder init --domain virtuallain.com

kubebuilder create api --group myapp --version v1 --kind Redis

tree -F .
.
├── Dockerfile
├── Makefile
├── PROJECT
├── README.md
├── api/
│   └── v1/
│       ├── groupversion_info.go
│       ├── redis_types.go
│       └── zz_generated.deepcopy.go
├── bin/
│   ├── controller-gen*
├── config/
│   ├── crd/
│   │   ├── bases/
│   │   │   └── myapp.virtuallain.com_redis.yaml
│   │   ├── kustomization.yaml
│   │   ├── kustomizeconfig.yaml
│   │   └── patches/
│   │       ├── cainjection_in_redis.yaml
│   │       └── webhook_in_redis.yaml
│   ├── default/
│   │   ├── kustomization.yaml
│   │   ├── manager_auth_proxy_patch.yaml
│   │   └── manager_config_patch.yaml
│   ├── manager/
│   │   ├── kustomization.yaml
│   │   └── manager.yaml
│   ├── prometheus/
│   │   ├── kustomization.yaml
│   │   └── monitor.yaml
│   ├── rbac/
│   │   ├── auth_proxy_client_clusterrole.yaml
│   │   ├── auth_proxy_role.yaml
│   │   ├── auth_proxy_role_binding.yaml
│   │   ├── auth_proxy_service.yaml
│   │   ├── kustomization.yaml
│   │   ├── leader_election_role.yaml
│   │   ├── leader_election_role_binding.yaml
│   │   ├── redis_editor_role.yaml
│   │   ├── redis_viewer_role.yaml
│   │   ├── role.yaml
│   │   ├── role_binding.yaml
│   │   └── service_account.yaml
│   └── samples/
│       └── myapp_v1_redis.yaml
├── controllers/
│   ├── redis_controller.go
│   └── suite_test.go
├── go.mod
├── go.sum
├── hack/
│   └── boilerplate.go.txt
├── main.go

// RedisSpec defines the desired state of Redis
type RedisSpec struct {
    //+kubebuilder:validation:Minimum:=81
    //+kubebuilder:validation:Maximum=30000
    Port int `json:"port,omitempty"`
    
    //+kubebuilder:validation:Minimum:=1
    //+kubebuilder:validation:Maximum=100
    Replicas int `json:"replicas,omitempty"`
}

make install
make uninstall

kubectl get crd | grep redis

func (r *RedisReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    redis := &myappv1.Redis{}
    if err := r.Get(ctx, req.NamespacedName, redis); err != nil {
        return ctrl.Result{RequeueAfter: time.Second * 5}, err
    }
    
    fmt.Println("得到对象", redis.Spec)
}

make run

apiVersion: myapp.virtuallain.com/v1
kind: Redis
metadata:
  name: myredis
  namespace: default
spec:
  port: 2000

ENV GOPROXY=https://goproxy.io

make docker build

make deploy IMG=<some-registry>/<project-name>:tag

func (r *RedisReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	_ = log.FromContext(ctx)

	redis := &myappv1.Redis{}
	if err := r.Get(ctx, req.NamespacedName, redis); err != nil {
		return ctrl.Result{}, nil
	}
    
    // 资源存在finalizers，删除时会增加DeletionTimestamp字段，只有当finalizers清空时才会真的删除
	if !redis.DeletionTimestamp.IsZero() {
		return ctrl.Result{}, helper.ClearRedis(r.Client, ctx, redis)	// 清理资源
	}

	edited := false
	podNames := helper.GetRedisPodNames(redis)
	diff := len(redis.Finalizers) - len(podNames) // 实际副本数量 - 期望副本数量
	if diff > 0 {                                 // 收缩副本
		if err := helper.RmIfSurplus(r.Client, ctx, redis, podNames); err != nil {
			return ctrl.Result{}, err
		}
		edited = true
	}

	// 创建副本
	for _, podName := range podNames {
		createPod, err := helper.CreateRedis(r.Client, ctx, redis, podName, r.Scheme)
		if err != nil {
			return ctrl.Result{}, err
		}

		// pod创建成功且redis资源的finalizers列表不包含新创建的pod名称
		if createPod != "" && !controllerutil.ContainsFinalizer(redis, createPod) {
			redis.Finalizers = append(redis.Finalizers, createPod) // 追加pod
			edited = true
		}
	}

	if edited {
		err := r.Client.Update(ctx, redis) // 更新redis的Finalizers列表
		return ctrl.Result{}, err
	}

	return ctrl.Result{}, nil
}

// GetRedisPodNames 根据副本数生成pod名称
func GetRedisPodNames(redis *v1.Redis) []string {
	podNames := make([]string, redis.Spec.Replicas)

	for i := 0; i < redis.Spec.Replicas; i++ {
		podNames[i] = fmt.Sprintf("%s-%d", redis.Name, i)
	}

	return podNames
}

// ExistPod 判断pod是否存在
func ExistPod(client client.Client, ctx context.Context, podName string, redis *v1.Redis) bool {
	err := client.Get(ctx, types.NamespacedName{Namespace: redis.Namespace, Name: podName}, &corev1.Pod{})

	return err == nil
}

// CreateRedis 创建redis
func CreateRedis(client client.Client, ctx context.Context, redis *v1.Redis, podName string, schema *runtime.Scheme) (string, error) {
	if ExistPod(client, ctx, podName, redis) {
		return "", nil
	}

	pod := &corev1.Pod{}
	pod.Namespace = redis.Namespace
	pod.Name = podName
	pod.Spec.Containers = []corev1.Container{
		{
			Name:            podName,
			Image:           "redis:5-alpine",
			ImagePullPolicy: corev1.PullIfNotPresent,
			Ports: []corev1.ContainerPort{
				{
					ContainerPort: int32(redis.Spec.Port),
				},
			},
		},
	}

	// 设置pod的ownReference为redis资源，删除redis资源时会删除关联的pod
	if err := controllerutil.SetOwnerReference(redis, pod, schema); err != nil {
		return "", err
	}

	return podName, client.Create(ctx, pod)
}

// RmIfSurplus 收缩副本
func RmIfSurplus(client client.Client, ctx context.Context, redis *v1.Redis, podNames []string) error {
	rmPods := redis.Finalizers[len(podNames):]
	for _, rmPod := range rmPods {
		err := client.Delete(ctx, &corev1.Pod{
			ObjectMeta: metav1.ObjectMeta{
				Name:      rmPod,
				Namespace: redis.Namespace,
			},
		})

		if err != nil {
			return err
		}
	}

	redis.Finalizers = podNames // 更新finalizers
	return nil
}

// ClearRedis 清理关联pod
func ClearRedis(client client.Client, ctx context.Context, redis *v1.Redis) error {
	/*
	// pod设置了ownReference后，就可以不用手动清理pod了
	podList := redis.Finalizers

	for _, podName := range podList {
		pod := &corev1.Pod{
			ObjectMeta: metav1.ObjectMeta{
				Name:      podName,
				Namespace: redis.Namespace,
			},
		}
		if err := client.Delete(ctx, pod); err != nil {
			return err
		}
	}*/

	redis.Finalizers = []string{}	// 将finalizers设置为空，否则无法删除该CR
	return client.Update(ctx, redis)
}

// 监听删除pod
func (r *RedisReconciler) rmPodHandler(event event.DeleteEvent, limitingInterface workqueue.RateLimitingInterface) {
	for _, ref := range event.Object.GetOwnerReferences() {
		if ref.Kind == "Redis" && ref.APIVersion == "myapp.virtuallain.com/v1" {
			// 重建pod
			limitingInterface.Add(reconcile.Request{ // 重新入列 触发reconcile
				NamespacedName: types.NamespacedName{
					Namespace: event.Object.GetNamespace(),
					Name:      ref.Name,
				},
			})
		}
	}
}

// SetupWithManager sets up the controller with the Manager.
func (r *RedisReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&myappv1.Redis{}).
		Watches(&source.Kind{	// 增加watch
			Type: &corev1.Pod{},
		}, handler.Funcs{DeleteFunc: r.rmPodHandler}).
		Complete(r)
}

// controllers/redis_controller.go

type RedisReconciler struct {
        client.Client
        Scheme      *runtime.Scheme
        EventRecord record.EventRecorder
}

func (r *RedisReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	// ...
	r.EventRecord.Event(redis, corev1.EventTypeNormal, "Upgrade", "副本收缩")
}

// main.go

if err = (&controllers.RedisReconciler{
	Client:        mgr.GetClient(),
	Scheme:        mgr.GetScheme(),
	EventRecorder: mgr.GetEventRecorderFor("Redis"),
}).SetupWithManager(mgr); err != nil {
	setupLog.Error(err, "unable to create controller", "controller", "Redis")
	os.Exit(1)
}

// api/v1/redis_types.go

type RedisStatus struct {
	Replicas int `json:"replicas"`
}

// 下面两个注释对应的是 kubectl get Redis 看到的状态  
//+kubebuilder:printcolumn:JSONPath=".status.replicas",name=replicas,type=integer
//+kubebuilder:printcolumn:JSONPath=".metadata.creationTimestamp",name=AGE,type=date
type Redis struct {
	// ...
}

// controllers/redis_controller.go

func (r *RedisReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	// ...
	redis.Status.Replicas = len(redis.Finalizers)
	if err := r.Status().Update(ctx, redis) {	// 更新status
		return ctrl.Result{}, err
	}
}