The most efficient way to write a Kubernetes Operator is to use Go to combine Kubebuilder and controller-runtime. 1. Understand the Operator pattern: define custom resources through CRD, write a controller to listen for resource changes and perform reconciliation loops to maintain the expected state. 2. Initialize the project with Kubebuilder and create APIs to automatically generate CRDs, controllers, and configuration files. 3. Define the Spec and Status structures of CRD in api/v1/myapp_types.go, and run make manifests to generate CRD YAML. 4. Implement business logic in the controller's Reconcile method, and use r.Create, r.Update and other methods to manage Kubernetes resources. 5. Define RBAC permissions through Go annotations, build images using make manifests and make docker-build, and deploy them through kubectl or make deploy. 6. Follow best practices: Ensure reconciliation of logic idempotence, handle errors reasonably and use RequeueAfter to control retry, add logs and events, and use Finalizers and Webhooks if necessary. 7. Use envtest for integration testing and fakeclient for unit testing. Ultimately, the core of Operator development is to define CRD, write harmonic logic, use controller-runtime to simplify K8s interaction, and complete testing and deployment through mature toolchains.

Writing Kubernetes Operators in Go is one of the most effective ways to extend the Kubernetes control plane for managing complex, stateful applications. An operator uses custom resources (CRs) and controllers to automate tasks that a human operator would otherwise perform—like backups, scaling, upgrades, and failover. Go is the natural choice because Kubernetes itself is written in Go, and the ecosystem (like client-go and controller-runtime) is mature and well-documented.

Here's a practical guide to help you get started and understand the key components.

1. Understand the Operator Pattern

An Operator combines a Custom Resource Definition (CRD) with a controller that watches for changes to that resource and take action to reconcile the desired state with the actual state of the cluster.

• Custom Resource (CR) : A YAML manifest defining your application's desired state (eg, MyAppDatabase ).
• Controller : A Go program that watches MyAppDatabase objects and manages Kubernetes resources (eg, StatefulSets, Services) to match the spec.

This is based on the informer-pattern and reconciliation loop .

2. Use Kubebuilder and controller-runtime

The easiest way to build an operator in Go is using Kubebuilder , part of the Kubernetes SIGs, which scaffolds projects using controller-runtime —a library that handles low-level details like client setup, event handling, and reconciliation.

Install tools:

 # Install kubebuilder
curl -L -O https://go.kubebuilder.io/dl/latest/$(go env GOOS)/$(go env GOARCH)
tar -xzf kubebuilder_*_$(go env GOOS)_$(go env GOARCH).tar.gz
sudo mv kubebuilder_*_$(go env GOOS)_$(go env GOARCH) /usr/local/kubebuilder
export PATH=$PATH:/usr/local/kubebuilder/bin

Create a new project:

 mkdir myapp-operator
cd myapp-operator
kubebuilder init --domain example.com --repo example.com/myapp-operator
kubebuilder create api --group apps --version v1 --kind MyApp

This generates:

• api/v1/myapp_types.go – Define your CRD schema.
• controllers/myapp_controller.go – Where you write reconciliation logic.
• config/ – Kustomize manifests for deploying CRD and RBAC.

3. Define Your Custom Resource

Edit api/v1/myapp_types.go :

 type MyAppSpec struct {
    Replicas int32 `json:"replicas"`
    Image string `json:"image"`
    Port int32 `json:"port"`
}

type MyAppStatus struct {
    ReadyReplicas int32 `json:"readyReplicas"`
    Conditions []metav1.Condition `json:"conditions,omitempty"`
}

Run make manifests to generate CRD YAML from Go annotations.

4. Implement the Reconciliation Logic

In controllers/myapp_controller.go , the Reconcile method is called whenever a MyApp resource changes.

 func (r *MyAppReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    log := r.Log.WithValues("myapp", req.NamespacedName)

    var myapp MyApp
    if err := r.Get(ctx, req.NamespacedName, &myapp); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

    // Ensure a Deployment exists
    desiredDep := &appsv1.Deployment{
        ObjectMeta: metav1.ObjectMeta{
            Name: myapp.Name,
            Namespace: myapp.Namespace,
        },
        Spec: appsv1.DeploymentSpec{
            Replicas: &myapp.Spec.Replicas,
            Selector: &metav1.LabelSelector{
                MatchLabels: map[string]string{"app": myapp.Name},
            },
            Template:corev1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{
                    Labels: map[string]string{"app": myapp.Name},
                },
                Spec: corev1.PodSpec{
                    Containers: []corev1.Container{
                        {
                            Name: "app",
                            Image: myapp.Spec.Image,
                            Ports: []corev1.ContainerPort{{ContainerPort: myapp.Spec.Port}},
                        },
                    },
                },
            },
        },
    }

    // Use controller-runtime's client to create or update
    if err := r.Create(ctx, desiredDep); err != nil {
        if !errors.IsAlreadyExists(err) {
            return ctrl.Result{}, err
        }
    }

    // Update status
    myapp.Status.ReadyReplicas = 0 // Update from actual deployment
    if err := r.Status().Update(ctx, &myapp); err != nil {
        return ctrl.Result{}, err
    }

    return ctrl.Result{}, nil
}

Use r.Create , r.Update , r.Patch , or r.Delete to manage objects.

5. Add RBAC and Deploy

Kubebuilder uses Go annotations to generate RBAC rules:

 // kubebuilder:rbac:groups=apps.example.com,resources=myapps,verbs=get;list;watch;create;update;patch;delete
// kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
// kubebuilder:rbac:groups=core,resources=pods,verbs=list

Run:

 Make manifests
make docker-build IMG=myapp-operator:v0.0.1
kubectl apply -f config/crd/bases/apps.example.com_myapps.yaml
kubectl create deployment myapp-operator --image=myapp-operator:v0.0.1

Or use make deploy IMG=myapp-operator:v0.0.1 if using the default kustomize setup.

6. Best Practices

• Idempotency : Reconcile loops may run multiple times—ensure operations are safe to repeat.
• Error handling : Return errors to request; use ctrl.Result{RequeueAfter: time.Second} for periodic checks.
• Logging & Events : Use r.Log and r.Recorder.Event() to emit Kubernetes events.
• Finalizers : Use them when you need to perform cleanup before a CR is deleted.
• Webhooks : Add validation (ValidatingAdmissionWebhook) or defaults (MutatingAdmissionWebhook) via kubebuilder create webhook .

7. Testing

• Use envtest for integration tests that start etcd and kube-apiserver locally.
• Write unit tests for your reconciliation logic using fakeclient .

Example test setup:

 import (
    "sigs.k8s.io/controller-runtime/pkg/envtest"
)

var testEnv *envtest.Environment

Basically, building Kubernetes Operators in Go boils down to:

• Defining a CRD with kubebuilder
• Writing a controller that reconciles desired vs. actual state
• Using controller-runtime to handle Kubernetes interactions
• Testing with envtest and deploying with standard manifests

It's not trivial, but the tooling has matured a lot—Kubebuilder and controller-runtime do most of the heavy lifting. Start small, automate one thing well, and expand from there.

The above is the detailed content of Developing Kubernetes Operators in Go. For more information, please follow other related articles on the PHP Chinese website!