Introduction to Kubernetes Operators

• What: Operators are software extensions that manage operational complexity of applications on Kubernetes.
• Components: Custom Resource (CR), Custom Resource Definition (CRD), and Controller.
• Why: To automate application-specific tasks like backup, updates, and scaling.

Writing Custom Operators

• Decide Use-Case: Determine if your application has unique complexities that Kubernetes cannot handle natively.
• Design CRDs: Outline the Custom Resource Definitions that capture the desired state of your application.
• Implement Controller: Write the controller logic to watch the CR and reconcile the actual state to match the desired state.
• Languages: Go is the most commonly used, but you can use Python, Java, etc.

Example: Custom Operator for a Redis Cache in Java

Here’s a very simplified example written in Java using the Fabric8 Kubernetes Client.

import io.fabric8.kubernetes.client.KubernetesClient;
import io.fabric8.kubernetes.client.Watcher;
import io.fabric8.kubernetes.client.Watcher.Action;

public class RedisOperator {

    private KubernetesClient client;

    public RedisOperator(KubernetesClient client) {
        this.client = client;
    }

    public void watchRedisResources() {
        client.customResources(RedisCustomResource.class)
            .inNamespace("default")
            .watch(new Watcher<RedisCustomResource>() {
                @Override
                public void eventReceived(Action action, RedisCustomResource resource) {
                    reconcile(resource);
                }
                
                @Override
                public void onClose(KubernetesClientException e) {
                    // Handle close events
                }
            });
    }

    public void reconcile(RedisCustomResource redisResource) {
        String name = redisResource.getMetadata().getName();
        String namespace = redisResource.getMetadata().getNamespace();
        
        // Reconciliation logic here, for example, create a new Pod
    }
}

Operator Framework

• Operator SDK: Provides tools to generate operator boilerplate code, build and push container images.
• Kubebuilder: Another toolkit that simplifies creating controllers and CRDs.
• Metacontroller: Allows you to create simple operators using scripts in languages like JavaScript and Python.

Deploying and Managing Operators

1. Install Operator: Apply the CRD and deploy the operator using a Deployment manifest.
2. Deploy CR: Create a Custom Resource that matches the CRD to trigger the operator’s controller.
3. Manage: Update the CR to change application configuration, scale, etc.
4. Monitor: Use Kubernetes native tools (kubectl logs, kubectl describe) to debug issues.