Kubernetes Operators Explained

Custom Resource (CR) → Controller → Kubernetes API
     "I want 3         Watches CR,      Creates/updates
      Postgres          reconciles       pods, services,
      replicas"         desired state    configmaps, PVCs

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: databases.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                engine:
                  type: string
                  enum: [postgres, mysql]
                version:
                  type: string
                replicas:
                  type: integer
                  minimum: 1
                storage:
                  type: string
  scope: Namespaced
  names:
    plural: databases
    singular: database
    kind: Database
    shortNames:
      - db

apiVersion: example.com/v1
kind: Database
metadata:
  name: my-postgres
  namespace: production
spec:
  engine: postgres
  version: "16"
  replicas: 3
  storage: 100Gi

kubectl apply -f my-database.yaml
kubectl get databases
kubectl describe database my-postgres

1. Watch: Controller watches for Database CRs
2. Diff: Compare desired state (CR spec) vs actual state (cluster)
3. Act: Create/update/delete resources to match desired state
4. Repeat: Continuous reconciliation loop

// Simplified reconciliation logic
func (r *DatabaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    // Fetch the Database CR
    db := &v1.Database{}
    r.Get(ctx, req.NamespacedName, db)

    // Check if StatefulSet exists
    sts := &appsv1.StatefulSet{}
    err := r.Get(ctx, types.NamespacedName{Name: db.Name, Namespace: db.Namespace}, sts)

    if errors.IsNotFound(err) {
        // Create StatefulSet, Service, ConfigMap, etc.
        r.createStatefulSet(ctx, db)
        r.createService(ctx, db)
        return ctrl.Result{}, nil
    }

    // Update if spec changed
    if sts.Spec.Replicas != db.Spec.Replicas {
        sts.Spec.Replicas = &db.Spec.Replicas
        r.Update(ctx, sts)
    }

    return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
}

helm install cnpg cloudnative-pg/cloudnative-pg -n cnpg-system --create-namespace

apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: my-postgres
spec:
  instances: 3
  storage:
    size: 10Gi
  postgresql:
    parameters:
      max_connections: "200"
      shared_buffers: "256MB"
  bootstrap:
    initdb:
      database: myapp
      owner: app
  backup:
    barmanObjectStore:
      destinationPath: s3://my-backups/postgres/
      s3Credentials:
        accessKeyId:
          name: s3-creds
          key: ACCESS_KEY_ID
        secretAccessKey:
          name: s3-creds
          key: SECRET_ACCESS_KEY

helm install cert-manager jetstack/cert-manager --set installCRDs=true

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@example.com
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
      - http01:
          ingress:
            class: nginx
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: app-tls
spec:
  secretName: app-tls-secret
  issuerRef:
    name: letsencrypt-prod
    kind: ClusterIssuer
  dnsNames:
    - app.example.com
    - api.example.com

operator-sdk init --domain example.com --repo github.com/myorg/my-operator
operator-sdk create api --group app --version v1 --kind MyApp --resource --controller

kubebuilder init --domain example.com
kubebuilder create api --group app --version v1 --kind MyApp

# OperatorHub.io
# https://operatorhub.io

# Artifact Hub
# https://artifacthub.io

# OLM (Operator Lifecycle Manager)
kubectl get catalogsources -n olm