# 下载最新二进制安装包
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

# 验证包哈希值
curl -LO "https://dl.k8s.io/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"

echo "$(cat kubectl.sha256)  kubectl" | sha256sum --check

# 如果输出如下标识验证通过
kubectl: OK

# 安装
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

# 测试
kubectl version --client --output=yaml

# 安装minikube
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo install minikube-linux-amd64 /usr/local/bin/minikube

# 启动k8s集群
minikube start

# 停止集群
minikube stop

# 删除所有minikube集群信息
minikube delete --all

# download kubebuilder and install locally.
curl -L -o kubebuilder https://go.kubebuilder.io/dl/latest/$(go env GOOS)/$(go env GOARCH)
chmod +x kubebuilder && mv kubebuilder /usr/local/bin/

# 创建项目目录
mkdir <YOUR_PROJECT_NAME>
cd <YOUR_PROJECT_NAME>

# create project
kubebuilder init --plugins go/v3 --domain <YOUR_DOMAIN> --owner "realjf" --repo github.com/<YOUR_ACCOUNT>/<YOUR_PROJECT_NAME>

Writing kustomize manifests for you to edit...
Writing scaffold for you to edit...
Get controller runtime:
$ go get sigs.k8s.io/[email protected]
Update dependencies:
$ go mod tidy
Next: define a resource with:
$ kubebuilder create api

var (
 scheme   = runtime.NewScheme()
 setupLog = ctrl.Log.WithName("setup")
)

func init() {
 utilruntime.Must(clientgoscheme.AddToScheme(scheme))

 //+kubebuilder:scaffold:scheme
}

var namespaces []string // list of namespaces

mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
  Scheme:                 scheme,
  NewCache:               cache.MultiNamespacedCacheBuilder(namespaces),
  MetricsBindAddress:     metricsAddr,
  Port:                   9443,
  HealthProbeBindAddress: probeAddr,
  LeaderElection:         enableLeaderElection,
  LeaderElectionID:       "3ee42630.realjf.io",
  // LeaderElectionReleaseOnCancel defines if the leader should step down voluntarily
  // when the Manager ends. This requires the binary to immediately end when the
  // Manager is stopped, otherwise, this setting is unsafe. Setting this significantly
  // speeds up voluntary leader transitions as the new leader don't have to wait
  // LeaseDuration time first.
  //
  // In the default scaffold provided, the program ends immediately after
  // the manager stops, so would be fine to enable this option. However,
  // if you are doing or is intended to do any operation such as perform cleanups
  // after the manager stops then its usage might be unsafe.
  // LeaderElectionReleaseOnCancel: true,
 })

kubebuilder create api --group api --version v1alpha1 --kind CronJob

Create Resource [y/n]
y
Create Controller [y/n]
y
Writing kustomize manifests for you to edit...
Writing scaffold for you to edit...
api/v1alpha1/cronjob_types.go
controllers/cronjob_controller.go
Update dependencies:
$ go mod tidy
Running make:
$ make generate
mkdir -p /home/realjf/go/src/k8s-operator/bin
test -s /home/realjf/go/src/k8s-operator/bin/controller-gen && /home/realjf/go/src/k8s-operator/bin/controller-gen --version | grep -q v0.11.1 || \
GOBIN=/home/realjf/go/src/k8s-operator/bin go install sigs.k8s.io/controller-tools/cmd/[email protected]
go: downloading sigs.k8s.io/controller-tools v0.11.1
go: downloading github.com/spf13/cobra v1.6.1
go: downloading golang.org/x/tools v0.4.0
go: downloading github.com/fatih/color v1.13.0
go: downloading github.com/gobuffalo/flect v0.3.0
go: downloading k8s.io/utils v0.0.0-20221107191617-1a15be271d1d
go: downloading golang.org/x/net v0.4.0
go: downloading github.com/mattn/go-colorable v0.1.9
go: downloading golang.org/x/mod v0.7.0
/home/realjf/go/src/k8s-operator/bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."
Next: implement your new API and generate the manifests (e.g. CRDs,CRs) with:
$ make manifests

//+kubebuilder:object:root=true
//+kubebuilder:subresource:status

import (
 apiv1alpha1 "k8s.io/api/batch/v1"
 corev1 "k8s.io/api/core/v1"
 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// CronJobSpec defines the desired state of CronJob
type CronJobSpec struct {
 //+kubebuilder:validation:MinLength=0

 // The schedule in Cron format
 Schedule string `json:"schedule"`

 //+kubebuilder:validation:Minimum=0

 // Optional deadline in seconds for starting the job if it misses scheduled
 // time for any reason
 // +optional
 StartingDeadlineSeconds *int64 `json:"startingDeadlineSeconds,omitempty"`

 // Specifies how to treat concurrent executions of a Job
 // Valid values are:
 // - "Allow" (default): allows CronJobs to run concurrently
 // - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yes
 // - "Replace": cancels currently running job and replaces it with a new one
 // +optional
 ConcurrencyPolicy ConcurrencyPolicy `json:"concurrencyPolicy,omitempty"`

 // This flag tells the controller to suspend subsequent executions, it does
 // not apply to already started executions. Defaults to false.
 // +optional
 Suspend *bool `json:"suspend,omitempty"`

 // Specifies the job that will be created when executing a CronJob
 JobTemplate apiv1alpha1.JobTemplateSpec `json:"jobTemplate"`

 //+kubebuilder:validation:Minimum=0

 // The number of successful finished jobs to retain.
 // This is a pointer to distinguish between explicit zero and not specified.
 // +optional
 SuccessfulJobsHistoryLimit *int32 `json:"successfulJobsHistoryLimit,omitempty"`

 //+kubebuilder:validation:Minimum=0

 // The number of failed finished jobs to retain.
 // This is a pointer to distinguish between explicit zero and not specified.
 // +optional
 FailedJobsHistoryLimit *int32 `json:"failedJobsHistoryLimit,omitempty"`
}

type ConcurrencyPolicy string

const (
 // AllowConcurrent allows CronJobs to run concurrently.
 AllowConcurrent ConcurrencyPolicy = "Allow"

 // ForbidConcurrent forbids concurrent runs, skipping next run if previous
 // hasn't finished yet.
 ForbidConcurrent ConcurrencyPolicy = "Forbid"

 // ReplaceConcurrent cancels currently running job and replaces it with a new one.
 ReplaceConcurrent ConcurrencyPolicy = "Replace"
)

// CronJobStatus defines the observed state of CronJob
type CronJobStatus struct {
 // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
 // Important: Run "make" to regenerate code after modifying this file

 // A list of pointers to currently running jobs
 // +optional
 Active []corev1.ObjectReference `json:"active,omitempty"`

 // Information when was the last time the job was successfully scheduled.
 // +optional
 LastScheduleTime *metav1.Time `json:"lastScheduleTime,omitempty"`
}

//+kubebuilder:rbac:groups=api.realjf.io,resources=cronjobs,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=api.realjf.io,resources=cronjobs/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=api.realjf.io,resources=cronjobs/finalizers,verbs=update

make manifests

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

 // TODO(user): your logic here

 return ctrl.Result{}, nil
}

func (r *CronJobReconciler) SetupWithManager(mgr ctrl.Manager) error {
 return ctrl.NewControllerManagedBy(mgr).
  For(&apiv1alpha1.CronJob{}).
  Complete(r)
}

import (
    "context"
    "fmt"
    "sort"
    "time"

    "github.com/robfig/cron"
    kbatch "k8s.io/api/batch/v1"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
    ref "k8s.io/client-go/tools/reference"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/log"

    apiv1alpha1 "github.com/realjf/k8s-operator/api/v1alpha1"
)

// CronJobReconciler reconciles a CronJob object
type CronJobReconciler struct {
    client.Client
    Scheme *runtime.Scheme
    Clock
}

type realClock struct{}

func (_ realClock) Now() time.Time { return time.Now() }

// clock knows how to get the current time.
// It can be used to fake out timing for testing.
type Clock interface {
    Now() time.Time
}

//+kubebuilder:rbac:groups=api.realjf.io,resources=cronjobs,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=api.realjf.io,resources=cronjobs/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=api.realjf.io,resources=cronjobs/finalizers,verbs=update
//+kubebuilder:rbac:groups=api,resources=jobs,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=api,resources=jobs/status,verbs=get

var (
 scheduledTimeAnnotation = "api.realjf.io/scheduled-at"
)

// 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 CronJob 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/[email protected]/pkg/reconcile
func (r *CronJobReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 log := log.FromContext(ctx)

    var cronJob apiv1alpha1.CronJob
    if err := r.Get(ctx, req.NamespacedName, &cronJob); err != nil {
        log.Error(err, "unable to fetch CronJob")
        // we'll ignore not-found errors, since they can't be fixed by an immediate
        // requeue (we'll need to wait for a new notification), and we can get them
        // on deleted requests.
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

var childJobs kbatch.JobList
    if err := r.List(ctx, &childJobs, client.InNamespace(req.Namespace), client.MatchingFields{jobOwnerKey: req.Name}); err != nil {
        log.Error(err, "unable to list child Jobs")
        return ctrl.Result{}, err
    }

// find the active list of jobs
 var activeJobs []*kbatch.Job
 var successfulJobs []*kbatch.Job
 var failedJobs []*kbatch.Job
 var mostRecentTime *time.Time // find the last run so we can update the status

 isJobFinished := func(job *kbatch.Job) (bool, kbatch.JobConditionType) {
  for _, c := range job.Status.Conditions {
   if (c.Type == kbatch.JobComplete || c.Type == kbatch.JobFailed) && c.Status == corev1.ConditionTrue {
    return true, c.Type
   }
  }

  return false, ""
 }

 getScheduledTimeForJob := func(job *kbatch.Job) (*time.Time, error) {
  timeRaw := job.Annotations[scheduledTimeAnnotation]
  if len(timeRaw) == 0 {
   return nil, nil
  }

  timeParsed, err := time.Parse(time.RFC3339, timeRaw)
  if err != nil {
   return nil, err
  }
  return &timeParsed, nil
 }
 for i, job := range childJobs.Items {
  _, finishedType := isJobFinished(&job)
  switch finishedType {
  case "": // ongoing
   activeJobs = append(activeJobs, &childJobs.Items[i])
  case kbatch.JobFailed:
   failedJobs = append(failedJobs, &childJobs.Items[i])
  case kbatch.JobComplete:
   successfulJobs = append(successfulJobs, &childJobs.Items[i])
  }

  // We'll store the launch time in an annotation, so we'll reconstitute that from
  // the active jobs themselves.
  scheduledTimeForJob, err := getScheduledTimeForJob(&job)
  if err != nil {
   log.Error(err, "unable to parse schedule time for child job", "job", &job)
   continue
  }
  if scheduledTimeForJob != nil {
   if mostRecentTime == nil {
    mostRecentTime = scheduledTimeForJob
   } else if mostRecentTime.Before(*scheduledTimeForJob) {
    mostRecentTime = scheduledTimeForJob
   }
  }
 }

 if mostRecentTime != nil {
  cronJob.Status.LastScheduleTime = &metav1.Time{Time: *mostRecentTime}
 } else {
  cronJob.Status.LastScheduleTime = nil
 }
 cronJob.Status.Active = nil
 for _, activeJob := range activeJobs {
  jobRef, err := ref.GetReference(r.Scheme, activeJob)
  if err != nil {
   log.Error(err, "unable to make reference to active job", "job", activeJob)
   continue
  }
  cronJob.Status.Active = append(cronJob.Status.Active, *jobRef)
 }

log.V(1).Info("job count", "active jobs", len(activeJobs), "successful jobs", len(successfulJobs), "failed jobs", len(failedJobs))

if err := r.Status().Update(ctx, &cronJob); err != nil {
        log.Error(err, "unable to update CronJob status")
        return ctrl.Result{}, err
    }

// NB: deleting these are "best effort" -- if we fail on a particular one,
    // we won't requeue just to finish the deleting.
    if cronJob.Spec.FailedJobsHistoryLimit != nil {
        sort.Slice(failedJobs, func(i, j int) bool {
            if failedJobs[i].Status.StartTime == nil {
                return failedJobs[j].Status.StartTime != nil
            }
            return failedJobs[i].Status.StartTime.Before(failedJobs[j].Status.StartTime)
        })
        for i, job := range failedJobs {
            if int32(i) >= int32(len(failedJobs))-*cronJob.Spec.FailedJobsHistoryLimit {
                break
            }
            if err := r.Delete(ctx, job, client.PropagationPolicy(metav1.DeletePropagationBackground)); client.IgnoreNotFound(err) != nil {
                log.Error(err, "unable to delete old failed job", "job", job)
            } else {
                log.V(0).Info("deleted old failed job", "job", job)
            }
        }
    }

    if cronJob.Spec.SuccessfulJobsHistoryLimit != nil {
        sort.Slice(successfulJobs, func(i, j int) bool {
            if successfulJobs[i].Status.StartTime == nil {
                return successfulJobs[j].Status.StartTime != nil
            }
            return successfulJobs[i].Status.StartTime.Before(successfulJobs[j].Status.StartTime)
        })
        for i, job := range successfulJobs {
            if int32(i) >= int32(len(successfulJobs))-*cronJob.Spec.SuccessfulJobsHistoryLimit {
                break
            }
            if err := r.Delete(ctx, job, client.PropagationPolicy(metav1.DeletePropagationBackground)); (err) != nil {
                log.Error(err, "unable to delete old successful job", "job", job)
            } else {
                log.V(0).Info("deleted old successful job", "job", job)
            }
        }
    }

if cronJob.Spec.Suspend != nil && *cronJob.Spec.Suspend {
        log.V(1).Info("cronjob suspended, skipping")
        return ctrl.Result{}, nil
    }

getNextSchedule := func(cronJob *apiv1alpha1.CronJob, now time.Time) (lastMissed time.Time, next time.Time, err error) {
        sched, err := cron.ParseStandard(cronJob.Spec.Schedule)
        if err != nil {
            return time.Time{}, time.Time{}, fmt.Errorf("Unparseable schedule %q: %v", cronJob.Spec.Schedule, err)
        }

        // for optimization purposes, cheat a bit and start from our last observed run time
        // we could reconstitute this here, but there's not much point, since we've
        // just updated it.
        var earliestTime time.Time
        if cronJob.Status.LastScheduleTime != nil {
            earliestTime = cronJob.Status.LastScheduleTime.Time
        } else {
            earliestTime = cronJob.ObjectMeta.CreationTimestamp.Time
        }
        if cronJob.Spec.StartingDeadlineSeconds != nil {
            // controller is not going to schedule anything below this point
            schedulingDeadline := now.Add(-time.Second * time.Duration(*cronJob.Spec.StartingDeadlineSeconds))

            if schedulingDeadline.After(earliestTime) {
                earliestTime = schedulingDeadline
            }
        }
        if earliestTime.After(now) {
            return time.Time{}, sched.Next(now), nil
        }

        starts := 0
        for t := sched.Next(earliestTime); !t.After(now); t = sched.Next(t) {
            lastMissed = t
            // An object might miss several starts. For example, if
            // controller gets wedged on Friday at 5:01pm when everyone has
            // gone home, and someone comes in on Tuesday AM and discovers
            // the problem and restarts the controller, then all the hourly
            // jobs, more than 80 of them for one hourly scheduledJob, should
            // all start running with no further intervention (if the scheduledJob
            // allows concurrency and late starts).
            //
            // However, if there is a bug somewhere, or incorrect clock
            // on controller's server or apiservers (for setting creationTimestamp)
            // then there could be so many missed start times (it could be off
            // by decades or more), that it would eat up all the CPU and memory
            // of this controller. In that case, we want to not try to list
            // all the missed start times.
            starts++
            if starts > 100 {
                // We can't get the most recent times so just return an empty slice
                return time.Time{}, time.Time{}, fmt.Errorf("Too many missed start times (> 100). Set or decrease .spec.startingDeadlineSeconds or check clock skew.")
            }
        }
        return lastMissed, sched.Next(now), nil
    }

    // figure out the next times that we need to create
    // jobs at (or anything we missed).
    missedRun, nextRun, err := getNextSchedule(&cronJob, r.Now())
    if err != nil {
        log.Error(err, "unable to figure out CronJob schedule")
        // we don't really care about requeuing until we get an update that
        // fixes the schedule, so don't return an error
        return ctrl.Result{}, nil
    }

scheduledResult := ctrl.Result{RequeueAfter: nextRun.Sub(r.Now())} // save this so we can re-use it elsewhere
log = log.WithValues("now", r.Now(), "next run", nextRun)

if missedRun.IsZero() {
        log.V(1).Info("no upcoming scheduled times, sleeping until next")
        return scheduledResult, nil
    }

    // make sure we're not too late to start the run
    log = log.WithValues("current run", missedRun)
    tooLate := false
    if cronJob.Spec.StartingDeadlineSeconds != nil {
        tooLate = missedRun.Add(time.Duration(*cronJob.Spec.StartingDeadlineSeconds) * time.Second).Before(r.Now())
    }
    if tooLate {
        log.V(1).Info("missed starting deadline for last run, sleeping till next")
        // TODO(directxman12): events
        return scheduledResult, nil
    }

// figure out how to run this job -- concurrency policy might forbid us from running
    // multiple at the same time...
    if cronJob.Spec.ConcurrencyPolicy == apiv1alpha1.ForbidConcurrent && len(activeJobs) > 0 {
        log.V(1).Info("concurrency policy blocks concurrent runs, skipping", "num active", len(activeJobs))
        return scheduledResult, nil
    }

    // ...or instruct us to replace existing ones...
    if cronJob.Spec.ConcurrencyPolicy == apiv1alpha1.ReplaceConcurrent {
        for _, activeJob := range activeJobs {
            // we don't care if the job was already deleted
            if err := r.Delete(ctx, activeJob, client.PropagationPolicy(metav1.DeletePropagationBackground)); client.IgnoreNotFound(err) != nil {
                log.Error(err, "unable to delete active job", "job", activeJob)
                return ctrl.Result{}, err
            }
        }
    }

constructJobForCronJob := func(cronJob *apiv1alpha1.CronJob, scheduledTime time.Time) (*kbatch.Job, error) {
        // We want job names for a given nominal start time to have a deterministic name to avoid the same job being created twice
        name := fmt.Sprintf("%s-%d", cronJob.Name, scheduledTime.Unix())

        job := &kbatch.Job{
            ObjectMeta: metav1.ObjectMeta{
                Labels:      make(map[string]string),
                Annotations: make(map[string]string),
                Name:        name,
                Namespace:   cronJob.Namespace,
            },
            Spec: *cronJob.Spec.JobTemplate.Spec.DeepCopy(),
        }
        for k, v := range cronJob.Spec.JobTemplate.Annotations {
            job.Annotations[k] = v
        }
        job.Annotations[scheduledTimeAnnotation] = scheduledTime.Format(time.RFC3339)
        for k, v := range cronJob.Spec.JobTemplate.Labels {
            job.Labels[k] = v
        }
        if err := ctrl.SetControllerReference(cronJob, job, r.Scheme); err != nil {
            return nil, err
        }

        return job, nil
    }

    // actually make the job...
    job, err := constructJobForCronJob(&cronJob, missedRun)
    if err != nil {
        log.Error(err, "unable to construct job from template")
        // don't bother requeuing until we get a change to the spec
        return scheduledResult, nil
    }

    // ...and create it on the cluster
    if err := r.Create(ctx, job); err != nil {
        log.Error(err, "unable to create Job for CronJob", "job", job)
        return ctrl.Result{}, err
    }

    log.V(1).Info("created Job for CronJob run", "job", job)

// we'll requeue once we see the running job, and update our status
    return scheduledResult, nil
}

var (
    jobOwnerKey = ".metadata.controller"
    apiGVStr    = apiv1alpha1.GroupVersion.String()
)

func (r *CronJobReconciler) SetupWithManager(mgr ctrl.Manager) error {
    // set up a real clock, since we're not in a test
    if r.Clock == nil {
        r.Clock = realClock{}
    }

    if err := mgr.GetFieldIndexer().IndexField(context.Background(), &kbatch.Job{}, jobOwnerKey, func(rawObj client.Object) []string {
        // grab the job object, extract the owner...
        job := rawObj.(*kbatch.Job)
        owner := metav1.GetControllerOf(job)
        if owner == nil {
            return nil
        }
        // ...make sure it's a CronJob...
        if owner.APIVersion != apiGVStr || owner.Kind != "CronJob" {
            return nil
        }

        // ...and if so, return it
        return []string{owner.Name}
    }); err != nil {
        return err
    }

    return ctrl.NewControllerManagedBy(mgr).
        For(&apiv1alpha1.CronJob{}).
        Owns(&kbatch.Job{}).
        Complete(r)
}

if os.Getenv("ENABLE_WEBHOOKS") != "false" {
        if err = (&batchv1.CronJob{}).SetupWebhookWithManager(mgr); err != nil {
            setupLog.Error(err, "unable to create webhook", "webhook", "CronJob")
            os.Exit(1)
        }
    }
    //+kubebuilder:scaffold:builder

    if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
  setupLog.Error(err, "unable to set up health check")
  os.Exit(1)
 }
 if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
  setupLog.Error(err, "unable to set up ready check")
  os.Exit(1)
 }

 setupLog.Info("starting manager")
 if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
  setupLog.Error(err, "problem running manager")
  os.Exit(1)
 }

kubebuilder create webhook --group api --version v1alpha1 --kind CronJob --defaulting --programmatic-validation

Writing kustomize manifests for you to edit...
Writing scaffold for you to edit...
api/v1alpha1/cronjob_webhook.go
Update dependencies:
$ go mod tidy
Running make:
$ make generate
test -s /home/realjf/go/src/k8s-operator/bin/controller-gen && /home/realjf/go/src/k8s-operator/bin/controller-gen --version | grep -q v0.11.1 || \
GOBIN=/home/realjf/go/src/k8s-operator/bin go install sigs.k8s.io/controller-tools/cmd/[email protected]
/home/realjf/go/src/k8s-operator/bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."
Next: implement your new Webhook and generate the manifests with:
$ make manifests

import (
    "github.com/robfig/cron"
    apierrors "k8s.io/apimachinery/pkg/api/errors"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/schema"
    validationutils "k8s.io/apimachinery/pkg/util/validation"
    "k8s.io/apimachinery/pkg/util/validation/field"
    ctrl "sigs.k8s.io/controller-runtime"
    logf "sigs.k8s.io/controller-runtime/pkg/log"
    "sigs.k8s.io/controller-runtime/pkg/webhook"
)

var cronjoblog = logf.Log.WithName("cronjob-resource")

func (r *CronJob) SetupWebhookWithManager(mgr ctrl.Manager) error {
 return ctrl.NewWebhookManagedBy(mgr).
  For(r).
  Complete()
}

//+kubebuilder:webhook:path=/mutate-api-realjf-io-v1alpha1-cronjob,mutating=true,failurePolicy=fail,sideEffects=None,groups=api.realjf.io,resources=cronjobs,verbs=create;update,versions=v1alpha1,name=mcronjob.kb.io,admissionReviewVersions=v1

var _ webhook.Defaulter = &CronJob{}

// Default implements webhook.Defaulter so a webhook will be registered for the type
func (r *CronJob) Default() {
    cronjoblog.Info("default", "name", r.Name)

    if r.Spec.ConcurrencyPolicy == "" {
        r.Spec.ConcurrencyPolicy = AllowConcurrent
    }
    if r.Spec.Suspend == nil {
        r.Spec.Suspend = new(bool)
    }
    if r.Spec.SuccessfulJobsHistoryLimit == nil {
        r.Spec.SuccessfulJobsHistoryLimit = new(int32)
        *r.Spec.SuccessfulJobsHistoryLimit = 3
    }
    if r.Spec.FailedJobsHistoryLimit == nil {
        r.Spec.FailedJobsHistoryLimit = new(int32)
        *r.Spec.FailedJobsHistoryLimit = 1
    }
}

//+kubebuilder:webhook:verbs=create;update;delete,path=/validate-api-realjf-io-v1alpha1-cronjob,mutating=false,failurePolicy=fail,sideEffects=None,groups=api.realjf.io,resources=cronjobs,verbs=create;update,versions=v1alpha1,name=vcronjob.kb.io,admissionReviewVersions=v1

var _ webhook.Validator = &CronJob{}

// ValidateCreate implements webhook.Validator so a webhook will be registered for the type
func (r *CronJob) ValidateCreate() error {
    cronjoblog.Info("validate create", "name", r.Name)

    return r.validateCronJob()
}

// ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
func (r *CronJob) ValidateUpdate(old runtime.Object) error {
    cronjoblog.Info("validate update", "name", r.Name)

    return r.validateCronJob()
}

// ValidateDelete implements webhook.Validator so a webhook will be registered for the type
func (r *CronJob) ValidateDelete() error {
    cronjoblog.Info("validate delete", "name", r.Name)

    // TODO(user): fill in your validation logic upon object deletion.
    return nil
}

func (r *CronJob) validateCronJob() error {
    var allErrs field.ErrorList
    if err := r.validateCronJobName(); err != nil {
        allErrs = append(allErrs, err)
    }
    if err := r.validateCronJobSpec(); err != nil {
        allErrs = append(allErrs, err)
    }
    if len(allErrs) == 0 {
        return nil
    }

    return apierrors.NewInvalid(
        schema.GroupKind{Group: "batch.tutorial.kubebuilder.io", Kind: "CronJob"},
        r.Name, allErrs)
}

func (r *CronJob) validateCronJobSpec() *field.Error {
    // The field helpers from the kubernetes API machinery help us return nicely
    // structured validation errors.
    return validateScheduleFormat(
        r.Spec.Schedule,
        field.NewPath("spec").Child("schedule"))
}

func validateScheduleFormat(schedule string, fldPath *field.Path) *field.Error {
    if _, err := cron.ParseStandard(schedule); err != nil {
        return field.Invalid(fldPath, schedule, err.Error())
    }
    return nil
}

func (r *CronJob) validateCronJobName() *field.Error {
    if len(r.ObjectMeta.Name) > validationutils.DNS1035LabelMaxLength-11 {
        // The job name length is 63 character like all Kubernetes objects
        // (which must fit in a DNS subdomain). The cronjob controller appends
        // a 11-character suffix to the cronjob (`-$TIMESTAMP`) when creating
        // a job. The job name length limit is 63 characters. Therefore cronjob
        // names must have length <= 63-11=52. If we don't validate this here,
        // then job creation will fail later.
        return field.Invalid(field.NewPath("metadata").Child("name"), r.Name, "must be no more than 52 characters")
    }
    return nil
}

make manifests

make install

export ENABLE_WEBHOOKS=false
make run

apiVersion: api.realjf.io/v1
kind: CronJob
metadata:
  labels:
    app.kubernetes.io/name: cronjob
    app.kubernetes.io/instance: cronjob-sample
    app.kubernetes.io/part-of: project
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/created-by: project
  name: cronjob-sample
spec:
  schedule: "*/1 * * * *"
  startingDeadlineSeconds: 60
  concurrencyPolicy: Allow # explicitly specify, but Allow is also default.
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox
            args:
            - /bin/sh
            - -c
            - date; echo Hello from the Kubernetes cluster
          restartPolicy: OnFailure

kubectl create -f config/samples/api_v1alpha1_cronjob.yaml

kubectl get cronjob.api.realjf.io -o yaml
kubectl get job

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