Реализация операторов Kubernetes

func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    // Получаем объект RedisCluster
    redisCluster := &cachev1.RedisCluster{}
    if err := r.Get(ctx, req.NamespacedName, redisCluster); err != nil {
        // Проверка на случай, если ресурс был удалён
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    
    // Проверяем, существует ли развёрнутый StatefulSet
    statefulSet := &appsv1.StatefulSet{}
    err := r.Get(ctx, types.NamespacedName{Name: redisCluster.Name, Namespace: redisCluster.Namespace}, statefulSet)
    
    // Если не существует - создаём
    if errors.IsNotFound(err) {
        statefulSet := constructRedisStatefulSet(redisCluster)
        if err := r.Create(ctx, statefulSet); err != nil {
            return ctrl.Result{}, err
        }
        return ctrl.Result{Requeue: true}, nil
    } else if err != nil {
        return ctrl.Result{}, err
    }
    
    // Проверяем, необходимо ли обновление
    if statefulSet.Spec.Replicas != &redisCluster.Spec.Size {
        *statefulSet.Spec.Replicas = redisCluster.Spec.Size
        if err := r.Update(ctx, statefulSet); err != nil {
            return ctrl.Result{}, err
        }
        return ctrl.Result{Requeue: true}, nil
    }
    
    // Обновляем статус RedisCluster
    if err := r.updateRedisClusterStatus(ctx, redisCluster, statefulSet); err != nil {
        return ctrl.Result{}, err
    }
    
    return ctrl.Result{}, nil
}

if redisCluster.ObjectMeta.DeletionTimestamp.IsZero() {
    // Ресурс не помечен на удаление, добавляем финализатор если его нет
    if !containsString(redisCluster.ObjectMeta.Finalizers, finalizerName) {
        redisCluster.ObjectMeta.Finalizers = append(redisCluster.ObjectMeta.Finalizers, finalizerName)
        if err := r.Update(ctx, redisCluster); err != nil {
            return ctrl.Result{}, err
        }
    }
} else {
    // Ресурс помечен на удаление, обрабатываем финализатор
    if containsString(redisCluster.ObjectMeta.Finalizers, finalizerName) {
        // Выполняем логику очистки (бэкап, освобождение ресурсов и т.д.)
        // ...
        
        // Удаляем финализатор
        redisCluster.ObjectMeta.Finalizers = removeString(redisCluster.ObjectMeta.Finalizers, finalizerName)
        if err := r.Update(ctx, redisCluster); err != nil {
            return ctrl.Result{}, err
        }
    }
}

// Пример создания нового проекта с Kubebuilder
// kubebuilder init --domain example.com --repo github.com/example/redis-operator
 
// Создание API и контроллера
// kubebuilder create api --group cache --version v1 --kind RedisCluster

type WebAppSpec struct {
    // Size определяет количество реплик
    Size int32 `json:"size"`
    
    // Image определяет образ контейнера
    Image string `json:"image"`
    
    // Port определяет порт приложения
    Port int32 `json:"port"`
}
 
type WebAppStatus struct {
    // Nodes содержит имена подов
    Nodes []string `json:"nodes"`
    
    // URL для доступа к приложению
    URL string `json:"url"`
}

func (r *WebAppReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    log := r.Log.WithValues("webapp", req.NamespacedName)
    
    // Получаем объект WebApp
    webapp := &appsv1.WebApp{}
    if err := r.Get(ctx, req.NamespacedName, webapp); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    
    // Логика управления Deployment
    deployment := &appsv1.Deployment{}
    err := r.Get(ctx, types.NamespacedName{Name: webapp.Name, Namespace: webapp.Namespace}, deployment)
    
    if errors.IsNotFound(err) {
        // Создаём новый Deployment
        dep := r.deploymentForWebApp(webapp)
        if err := r.Create(ctx, dep); err != nil {
            log.Error(err, "Failed to create Deployment")
            return ctrl.Result{}, err
        }
        return ctrl.Result{Requeue: true}, nil
    } else if err != nil {
        log.Error(err, "Failed to get Deployment")
        return ctrl.Result{}, err
    }
    
    // Проверяем необходимость обновления размера
    size := webapp.Spec.Size
    if *deployment.Spec.Replicas != size {
        deployment.Spec.Replicas = &size
        if err := r.Update(ctx, deployment); err != nil {
            log.Error(err, "Failed to update Deployment size")
            return ctrl.Result{}, err
        }
        return ctrl.Result{Requeue: true}, nil
    }
    
    // Создаём или проверяем Service
    service := &corev1.Service{}
    err = r.Get(ctx, types.NamespacedName{Name: webapp.Name, Namespace: webapp.Namespace}, service)
    
    if errors.IsNotFound(err) {
        svc := r.serviceForWebApp(webapp)
        if err := r.Create(ctx, svc); err != nil {
            log.Error(err, "Failed to create Service")
            return ctrl.Result{}, err
        }
        return ctrl.Result{Requeue: true}, nil
    } else if err != nil {
        log.Error(err, "Failed to get Service")
        return ctrl.Result{}, err
    }
    
    // Обновляем статус
    if err := r.updateWebAppStatus(ctx, webapp); err != nil {
        log.Error(err, "Failed to update WebApp status")
        return ctrl.Result{}, err
    }
    
    return ctrl.Result{}, nil
}

func (r *WebAppReconciler) deploymentForWebApp(webapp *appsv1.WebApp) *appsv1beta1.Deployment {
    labels := map[string]string{"app": webapp.Name}
    replicas := webapp.Spec.Size
    
    dep := &appsv1beta1.Deployment{
        ObjectMeta: metav1.ObjectMeta{
            Name:      webapp.Name,
            Namespace: webapp.Namespace,
        },
        Spec: appsv1beta1.DeploymentSpec{
            Replicas: &replicas,
            Selector: &metav1.LabelSelector{
                MatchLabels: labels,
            },
            Template: corev1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{
                    Labels: labels,
                },
                Spec: corev1.PodSpec{
                    Containers: []corev1.Container{{
                        Image: webapp.Spec.Image,
                        Name:  "webapp",
                        Ports: []corev1.ContainerPort{{
                            ContainerPort: webapp.Spec.Port,
                            Name:          "http",
                        }},
                    }},
                },
            },
        },
    }
    
    // Устанавливаем WebApp как владельца Deployment
    ctrl.SetControllerReference(webapp, dep, r.Scheme)
    return dep
}