Operator pattern overview in Kubernetes - Mini Project: Build & Apply

Operator Pattern Overview in Kubernetes

📖 Scenario: You are working as a DevOps engineer managing applications on Kubernetes. You want to automate the management of a custom application lifecycle using the Operator pattern.

🎯 Goal: Build a simple Kubernetes Operator setup that watches a custom resource and updates its status.

📋 What You'll Learn

Create a Custom Resource Definition (CRD) manifest

Define a configuration variable for the Operator's watch namespace

Write a basic reconciliation loop logic in the Operator code

Output the status update of the custom resource

💡 Why This Matters

🌍 Real World

Operators automate complex application management tasks on Kubernetes, like deploying, scaling, and healing applications automatically.

💼 Career

Understanding the Operator pattern is essential for DevOps roles working with Kubernetes to improve automation and reliability.

1

Create a Custom Resource Definition (CRD)

Create a YAML manifest named myapp-crd.yaml that defines a Custom Resource Definition called MyApp in the group example.com with version v1. The CRD should have a spec with a field replicas of type integer.

Kubernetes

# Write the YAML manifest for the MyApp CRD here
# Your code here

Need a hint?

Define the CRD with apiVersion, kind, metadata.name, and spec including group, versions, and names.

2

Set Operator Watch Namespace Configuration

In your Operator code, create a variable called watchNamespace and set it to the string default to specify the namespace the Operator will watch.

Kubernetes

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: myapps.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                replicas:
                  type: integer
  scope: Namespaced
  names:
    plural: myapps
    singular: myapp
    kind: MyApp
    shortNames:
    - ma

# Define the watchNamespace variable
# Your code here

Need a hint?

Use a simple assignment to create the variable watchNamespace with value "default".

3

Implement Basic Reconciliation Logic

Write a function called reconcile that takes a parameter myapp. Inside the function, set a variable status to the string "Running with {replicas} replicas" where {replicas} is replaced by myapp['spec']['replicas'].

Kubernetes

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: myapps.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                replicas:
                  type: integer
  scope: Namespaced
  names:
    plural: myapps
    singular: myapp
    kind: MyApp
    shortNames:
    - ma

watchNamespace = "default"

def reconcile(myapp):
    # Your code here

Need a hint?

Use an f-string to insert myapp['spec']['replicas'] into the status message.

4

Print the Status Update

Add a print statement to display the status variable inside the reconcile function.

Kubernetes

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: myapps.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                replicas:
                  type: integer
  scope: Namespaced
  names:
    plural: myapps
    singular: myapp
    kind: MyApp
    shortNames:
    - ma

watchNamespace = "default"

def reconcile(myapp):
    status = f"Running with {myapp['spec']['replicas']} replicas"
    # Print the status
    # Your code here

Need a hint?

Use print(status) inside the reconcile function and call it with a sample myapp dictionary.