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

$ kubebuilder init --domain example.com --license apache2 --owner "Your Name" --repo github.com/example/my-operator

$ kubebuilder create api --group mygroup --version v1alpha1 --kind MyResource

package controllers

import (
  "context"
  "github.com/go-logr/logr"
  "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
  "sigs.k8s.io/controller-runtime/pkg/controller/inject"
  "sigs.k8s.io/controller-runtime/pkg/reconcile"

  myv1alpha1 "github.com/example/my-operator/api/v1alpha1"
  corev1 "k8s.io/api/core/v1"
  "k8s.io/apimachinery/pkg/api/errors"
  "k8s.io/apimachinery/pkg/runtime"
  "sigs.k8s.io/controller-runtime/pkg/client"
  "sigs.k8s.io/controller-runtime/pkg/controller"
  logf "sigs.k8s.io/controller-runtime/pkg/log"
  "sigs.k8s.io/controller-runtime/pkg/log/zap"
  "sigs.k8s.io/controller-runtime/pkg/manager"
  "sigs.k8s.io/controller-runtime/pkg/reconcile"
  "sigs.k8s.io/controller-runtime/pkg/source"
)

var log = logf.Log.WithName("controller_myresource")

// Add creates a new MyResource Controller and adds it to the Manager. The Manager will set fields on the Controller
// and Start it when the Manager is Started.
func Add(mgr manager.Manager) error {
  return add(mgr, newReconciler(mgr))
}

// newReconciler returns a new reconcile.Reconciler
func newReconciler(mgr manager.Manager) reconcile.Reconciler {
  return &ReconcileMyResource{client: mgr.GetClient(), scheme: mgr.GetScheme()}
}

// blank assignment to verify that ReconcileMyResource implements reconcile.Reconciler
var _ reconcile.Reconciler = &ReconcileMyResource{}

// ReconcileMyResource reconciles a MyResource object
type ReconcileMyResource struct {
  client client.Client
  scheme *runtime.Scheme
}

// Reconcile reads that state of the cluster for a MyResource object and makes changes based on the state read
// and what is in the MyResource.Spec
func (r *ReconcileMyResource) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {
  reqLogger := log.WithValues("Namespace", request.Namespace, "Name", request.Name)
  reqLogger.Info("Reconciling MyResource")

  // Fetch the MyResource instance
  myresource := &myv1alpha1.MyResource{}
  err := r.client.Get(ctx, request.NamespacedName, myresource)
  if err != nil {
    if errors.IsNotFound(err) {
      // Request object not found, could have been deleted after reconcile request.
      // Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
      // Return and don't requeue
      return reconcile.Result{}, nil
    }
    // Error reading the object - requeue the request.
    return reconcile.Result{}, err
  }

  // Add finalizer logic here

  // Add reconcile logic here

  return reconcile.Result{}, nil
}

func main() {
    // set logger
    ctrl.SetLogger(zap.New())

    // Set up a Manager
    mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
      Scheme:             myv1alpha1.SchemeBuilder.Scheme,
      MetricsBindAddress: *metricsHost,
      Port:               9443,
      LeaderElection:     *enableLeaderElection,
      LeaderElectionID:   "my-operator-lock",
    })
    if err != nil {
        setupLog.Error(err, "unable to start manager")
        os.Exit(1)
    }

    // in a real controller, we'd create a new scheme for this
    err = api.AddToScheme(mgr.GetScheme())
    if err != nil {
        setupLog.Error(err, "unable to add scheme")
        os.Exit(1)
    }

    // Create a new Reconciler
    r := &ReconcileMyResource{
      client: m.GetClient(),
      scheme: m.GetScheme(),
    }

    // Create a new Controller and register the Reconciler
    err = ctrl.NewControllerManagedBy(mgr).
        For(&myv1alpha1.MyResource{}).     // 自定义crd
        Complete(r)                        // 注册Reconciler
    if err != nil {
        setupLog.Error(err, "unable to create controller")
        os.Exit(1)
    }

    err = ctrl.NewWebhookManagedBy(mgr).
        For(&api.ChaosPod{}).
        Complete()
    if err != nil {
        setupLog.Error(err, "unable to create webhook")
        os.Exit(1)
    }

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