initial redis operator code

Author: initcron

Dockerfile

@@ -0,0 +1,16 @@
+# Use an official lightweight Python image.
+FROM python:3.9-slim
+
+# Set the working directory.
+WORKDIR /app
+
+# Copy the Python requirements file and install dependencies.
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the operator script.
+COPY redis_operator.py /app/
+
+# Run the operator.
+CMD ["kopf", "run", "/app/redis_operator.py"]
+

docker-compose.yaml

@@ -0,0 +1,12 @@
+version: '3.8'
+
+services:
+  redis-operator:
+    build: .
+    image: schoolofdevops/redis-operator:latest
+    environment:
+      KUBECONFIG: /root/.kube/config
+    volumes:
+      - ~/.kube:/root/.kube
+    command: kopf run /app/redis_operator.py
+

my-redis.yaml

@@ -0,0 +1,13 @@
+apiVersion: database.example.com/v1
+kind: Redis
+metadata:
+  name: my-redis
+  namespace: default
+spec:
+  masterSize: 1
+  slaveSize: 2
+  image: "redis:6.2.6" # Specify the Redis image version you prefer
+  backupEnabled: true
+  backupSchedule: "0 */6 * * *"  # Schedule backups every 6 hours
+  persistentVolumeSize: "200Mi"    # Specify the size for the persistent volume
+

redis-crd.yaml

@@ -0,0 +1,49 @@
+# redis-crd.yaml
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: redises.database.example.com
+spec:
+  group: database.example.com
+  versions:
+    - name: v1
+      served: true
+      storage: true
+      schema:
+        openAPIV3Schema:
+          type: object
+          properties:
+            spec:
+              type: object
+              properties:
+                masterSize: 
+                  type: integer
+                  default: 1
+                slaveSize:
+                  type: integer
+                  default: 2
+                image:
+                  type: string
+                  default: "redis:latest"
+                backupEnabled:
+                  type: boolean
+                  default: false
+                backupSchedule:
+                  type: string
+                persistentVolumeSize:
+                  type: string
+                  default: "1Gi"
+            status:
+              type: object
+              properties:
+                nodes:
+                  type: array
+                  items:
+                    type: string
+  scope: Namespaced
+  names:
+    plural: redises
+    singular: redis
+    kind: Redis
+    shortNames:
+      - rd

redis_operator-deploy.yaml

@@ -0,0 +1,20 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redis-operator
+  namespace: default
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: redis-operator
+  template:
+    metadata:
+      labels:
+        app: redis-operator
+    spec:
+      containers:
+      - name: redis-operator
+        image: schoolofdevops/redis-operator:latest
+        imagePullPolicy: Always
+      serviceAccountName: redis-operator

redis_operator-rbac.yaml

@@ -0,0 +1,42 @@
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: redis-operator
+  namespace: default
+
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: redis-operator-clusterrole
+rules:
+- apiGroups: [""]
+  resources: ["pods", "pods/exec", "pods/log", "services", "endpoints", "persistentvolumeclaims", "events"]
+  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+- apiGroups: ["apps"]
+  resources: ["deployments", "replicasets"]
+  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+- apiGroups: ["batch"]
+  resources: ["jobs", "cronjobs"]
+  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+- apiGroups: ["database.example.com"]
+  resources: ["redises"]
+  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+- apiGroups: ["apiextensions.k8s.io"]
+  resources: ["customresourcedefinitions"]
+  verbs: ["get", "list", "watch", "create", "delete"]
+
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: redis-operator-clusterrolebinding
+subjects:
+- kind: ServiceAccount
+  name: redis-operator
+  namespace: default
+roleRef:
+  kind: ClusterRole
+  name: redis-operator-clusterrole
+  apiGroup: rbac.authorization.k8s.io
+

redis_operator.py

@@ -0,0 +1,100 @@
+import kopf
+import kubernetes.client
+from kubernetes.client.rest import ApiException
+
+def create_redis_deployment(name, namespace, size, role, image):
+    # Labels to identify the pods
+    labels = {"app": f"{name}-{role}"}
+    return kubernetes.client.V1Deployment(
+        api_version="apps/v1",
+        kind="Deployment",
+        metadata=kubernetes.client.V1ObjectMeta(name=f"{name}-{role}", namespace=namespace),
+        spec=kubernetes.client.V1DeploymentSpec(
+            replicas=size,
+            selector=kubernetes.client.V1LabelSelector(
+                match_labels=labels
+            ),
+            template=kubernetes.client.V1PodTemplateSpec(
+                metadata=kubernetes.client.V1ObjectMeta(
+                    labels=labels
+                ),
+                spec=kubernetes.client.V1PodSpec(
+                    containers=[
+                        kubernetes.client.V1Container(
+                            name="redis",
+                            image=image,
+                            ports=[kubernetes.client.V1ContainerPort(container_port=6379)]
+                        )
+                    ]
+                )
+            )
+        )
+    )
+
+def create_backup_cron_job(name, namespace, schedule, image):
+    # Define a CronJob resource for backups
+    return kubernetes.client.V1CronJob(
+        api_version="batch/v1",
+        kind="CronJob",
+        metadata=kubernetes.client.V1ObjectMeta(name=f"{name}-backup", namespace=namespace),
+        spec=kubernetes.client.V1CronJobSpec(
+            schedule=schedule,
+            job_template=kubernetes.client.V1JobTemplateSpec(
+                spec=kubernetes.client.V1JobSpec(
+                    template=kubernetes.client.V1PodTemplateSpec(
+                        spec=kubernetes.client.V1PodSpec(
+                            containers=[
+                                kubernetes.client.V1Container(
+                                    name="backup",
+                                    image=image,
+                                    args=["redis-cli", "save"]
+                                )
+                            ],
+                            restart_policy="OnFailure"
+                        )
+                    )
+                )
+            )
+        )
+    )
+
+@kopf.on.create('database.example.com', 'v1', 'redises')
+def create_fn(body, name, namespace, logger, **kwargs):
+    # Extract the spec from the body of the custom resource
+    spec = body.get('spec', {})
+    master_size = spec.get('masterSize', 1)
+    slave_size = spec.get('slaveSize', 2)
+    image = spec.get('image', 'redis:latest')
+    backup_enabled = spec.get('backupEnabled', False)
+    backup_schedule = spec.get('backupSchedule', '0 */12 * * *')
+
+    k8s_apps_v1 = kubernetes.client.AppsV1Api()
+
+    # Create master deployment
+    master_deployment = create_redis_deployment(name, namespace, master_size, 'master', image)
+    try:
+        k8s_apps_v1.create_namespaced_deployment(namespace=namespace, body=master_deployment)
+        logger.info(f"Master deployment for Redis '{name}' created.")
+    except ApiException as e:
+        logger.error(f"Failed to create master deployment: {str(e)}")
+        raise kopf.TemporaryError(f"Failed to create master deployment: {str(e)}", delay=30)
+
+    # Create slave deployment
+    slave_deployment = create_redis_deployment(name, namespace, slave_size, 'slave', image)
+    try:
+        k8s_apps_v1.create_namespaced_deployment(namespace=namespace, body=slave_deployment)
+        logger.info(f"Slave deployment for Redis '{name}' created.")
+    except ApiException as e:
+        logger.error(f"Failed to create slave deployment: {str(e)}")
+        raise kopf.TemporaryError(f"Failed to create slave deployment: {str(e)}", delay=30)
+
+    # Create a backup job if enabled
+    if backup_enabled:
+        backup_job = create_backup_cron_job(name, namespace, backup_schedule, image)
+        k8s_batch_v1 = kubernetes.client.BatchV1Api()
+        try:
+            k8s_batch_v1.create_namespaced_cron_job(namespace=namespace, body=backup_job)
+            logger.info(f"Backup cron job for Redis '{name}' created.")
+        except ApiException as e:
+            logger.error(f"Failed to create backup cron job: {str(e)}")
+            raise kopf.TemporaryError(f"Failed to create backup cron job: {str(e)}", delay=30)

requirements.txt

@@ -0,0 +1,4 @@
+kopf
+kubernetes
+pyyaml
+