Kubernetes custom controller 작성해보기

curl -L -o kubebuilder "https://go.kubebuilder.io/dl/latest/$(go env GOOS)/$(go env GOARCH)"\n
chmod +x kubebuilder && mv kubebuilder /usr/local/bin/
kubebuilder init --domain study.jayground8
kubebuilder create api --group cnat --version v1alpha1 --kind At

const (
	PhasePending = "PENDING"
	PhaseRunning = "RUNNING"
	PhaseDone    = "DONE"
)

type AtSpec struct {
	Schedule string `json:"schedule,omitempty"`
	Command  string `json:"command,omitempty"`
}

type AtStatus struct {
	Phase string `json:"phase,omitempty"`
}

---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.12.0
  name: ats.cnat.study.jayground8
spec:
  group: cnat.study.jayground8
  names:
    kind: At
    listKind: AtList
    plural: ats
    singular: at
  scope: Namespaced
  versions:
    - name: v1alpha1
      schema:
        openAPIV3Schema:
          description: At is the Schema for the ats API
          properties:
            apiVersion:
              type: string
            kind:
              type: string
            metadata:
              type: object
            spec:
              properties:
                command:
                  type: string
                schedule:
                  type: string
              type: object
            status:
              properties:
                phase:
                  type: string
              type: object
          type: object
      served: true
      storage: true
      subresources:
        status: {}

// AtSpec defines the desired state of At
type AtSpec struct {
	// +kubebuilder:validation:Required
	Schedule string `json:"schedule"`
	// +kubebuilder:validation:Required
	Command  string `json:"command"`
}

spec:
  description: AtSpec defines the desired state of At
  properties:
    command:
      type: string
    schedule:
      type: string
  required:
    - command
    - schedule
  type: object

apiVersion: cnat.study.jayground8/v1alpha1
kind: At
metadata:
  labels:
    controller-tools.k8s.io: '1.0'
  name: example-at
spec:
  schedule: '2023-07-14T10:12:00Z'

// AtSpec defines the desired state of At
type AtSpec struct {
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern=`^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d`
	Schedule string `json:"schedule"`
	// +kubebuilder:validation:Required
	Command  string `json:"command"`
}

$ kubectl get ats
NAME         AGE
example-at   4s

//+kubebuilder:printcolumn:name="schedule",type=string,JSONPath=`.spec.schedule`
//+kubebuilder:printcolumn:name="command",type=string,JSONPath=`.spec.command`
//+kubebuilder:printcolumn:name="phase",type=string,JSONPath=`.status.phase`

// At is the Schema for the ats API
type At struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   AtSpec   `json:"spec,omitempty"`
	Status AtStatus `json:"status,omitempty"`
}

$ kubectl get ats
NAME         SCHEDULE               COMMAND    PHASE
example-at   2023-07-14T10:12:00Z   echo YAY   DONE

//+kubebuilder:subresource:status

- apiGroups:
    - cnat.study.jayground8
  resources:
    - ats/status
  verbs:
    - get
    - patch
    - update

err := controllerutil.SetControllerReference(instance, pod, r.Scheme)

err = r.Status().Update(context.TODO(), instance)

package controller

import (
	"context"
	"strings"
	"time"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/types"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
	logf "sigs.k8s.io/controller-runtime/pkg/log"
	"sigs.k8s.io/controller-runtime/pkg/reconcile"

	cnatv1alpha1 "my_controller/api/v1alpha1"
)

var globalLog = logf.Log.WithName("global")

// AtReconciler reconciles a At object
type AtReconciler struct {
	client.Client
	Scheme *runtime.Scheme
}

//+kubebuilder:rbac:groups="",resources=pods,verbs=get;list;create;watch;
//+kubebuilder:rbac:groups=cnat.study.jayground8,resources=ats,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=cnat.study.jayground8,resources=ats/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=cnat.study.jayground8,resources=ats/finalizers,verbs=update

// Reconcile is part of the main kubernetes reconciliation loop which aims to
// move the current state of the cluster closer to the desired state.
// TODO(user): Modify the Reconcile function to compare the state specified by
// the At object against the actual cluster state, and then
// perform operations to make the cluster state reflect the state specified by
// the user.
//
// For more details, check Reconcile and its Result here:
// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.15.0/pkg/reconcile
func (r *AtReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	reqLogger := globalLog.WithValues("namespace", req.Namespace, "at", req.Name)
	reqLogger.Info("=== Reconciling At")
	// TODO(user): your logic here
	instance := &cnatv1alpha1.At{}
	err := r.Get(context.TODO(), req.NamespacedName, instance)
	if err != nil {
		if errors.IsNotFound(err) {
			return reconcile.Result{}, nil
		}
		return reconcile.Result{}, err
	}

	if instance.Status.Phase == "" {
		instance.Status.Phase = cnatv1alpha1.PhasePending
	}

	switch instance.Status.Phase {
	case cnatv1alpha1.PhasePending:
		d, err := timeUntilSchedule(instance.Spec.Schedule)
		if err != nil {
			return reconcile.Result{}, err
		}
		if d > 0 {
			return reconcile.Result{RequeueAfter: d}, nil
		}
		instance.Status.Phase = cnatv1alpha1.PhaseRunning
	case cnatv1alpha1.PhaseRunning:
		pod := newPodForCR(instance)
		err := controllerutil.SetControllerReference(instance, pod, r.Scheme)
		if err != nil {
			return reconcile.Result{}, err
		}
		found := &corev1.Pod{}
		nsName := types.NamespacedName{Name: pod.Name, Namespace: pod.Namespace}
		err = r.Get(context.TODO(), nsName, found)
		if err != nil && errors.IsNotFound(err) {
			err = r.Create(context.TODO(), pod)
			if err != nil {
				return reconcile.Result{}, err
			}
		} else if err != nil {
			return reconcile.Result{}, err
		} else if found.Status.Phase == corev1.PodFailed || found.Status.Phase == corev1.PodSucceeded {
			instance.Status.Phase = cnatv1alpha1.PhaseDone
		} else {
			return reconcile.Result{}, nil
		}
	case cnatv1alpha1.PhaseDone:
		return reconcile.Result{}, nil
	default:
		return reconcile.Result{}, nil
	}

	err = r.Status().Update(context.TODO(), instance)
	if err != nil {
		return reconcile.Result{}, nil
	}

	return reconcile.Result{}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *AtReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&cnatv1alpha1.At{}).
		Complete(r)
}

func timeUntilSchedule(schedule string) (time.Duration, error) {
	now := time.Now().UTC()
	layout := "2006-01-02T15:04:05Z"
	s, err := time.Parse(layout, schedule)
	if err != nil {
		return time.Duration(0), err
	}
	return s.Sub(now), nil
}

func newPodForCR(cr *cnatv1alpha1.At) *corev1.Pod {
	labels := map[string]string{
		"app": cr.Name,
	}
	return &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      cr.Name + "-pod",
			Namespace: cr.Namespace,
			Labels:    labels,
		},
		Spec: corev1.PodSpec{
			Containers: []corev1.Container{
				{
					Name:    "busybox",
					Image:   "busybox",
					Command: strings.Split(cr.Spec.Command, " "),
				},
			},
			RestartPolicy: corev1.RestartPolicyOnFailure,
		},
	}
}

make docker-build IMG=controller:latest
minikube image load controller:latest

image: controller:latest
imagePullPolicy: Never

make deploy

//+kubebuilder:rbac:groups="",resources=pods,verbs=get;list;create;watch;

kubectl apply -f config/crd/samples/cnat.study.jayground8_ats.yaml