Operator SDK basics in Kubernetes - Commands & Configuration

Introduction

Creating and managing Kubernetes operators can be complex. Operator SDK helps you build operators easily by providing tools and libraries to automate application management on Kubernetes.

When you want to automate deployment and lifecycle management of your custom application on Kubernetes.

When you need to extend Kubernetes with your own custom resources and controllers.

When you want to package your operational knowledge into code for repeatable management.

When you want to manage complex stateful applications that require custom logic beyond standard Kubernetes resources.

When you want to build operators using Go language with scaffolding and testing support.

Config File - PROJECT

PROJECT

domain: example.com
layout: go.kubebuilder.io
projectName: my-operator
version: 3

This file defines the Operator SDK project settings.

domain: Your organization domain used for API group naming.

layout: Project layout style, here using Go with kubebuilder conventions.

projectName: The name of your operator project.

version: Operator SDK project version.

Commands

Initialize a new Operator SDK project with your domain and Go module path. This sets up the basic project structure.

Terminal

operator-sdk init --domain example.com --repo github.com/example/my-operator

Expected Output

INFO[0000] Creating new Go operator 'my-operator' version 'v1'  

INFO[0000] Created new project version '3' with domain 'example.com' and repo 'github.com/example/my-operator'

→

--domain - Sets the API group domain for your custom resources

→

--repo - Defines the Go module path for your operator code

Create a new API and controller for a custom resource named MyApp in group apps and version v1. This scaffolds the resource and controller code.

Terminal

operator-sdk create api --group apps --version v1 --kind MyApp --resource --controller

Expected Output

INFO[0000] Created API version apps/v1

INFO[0000] Created controller for MyApp

→

--group - Specifies the API group for the custom resource

→

--version - Specifies the API version

→

--kind - Defines the kind name of the custom resource

→

--resource - Generates the resource manifests

→

--controller - Generates the controller code

Install the CustomResourceDefinition (CRD) into your Kubernetes cluster so the new resource type is recognized.

Terminal

make install

Expected Output

kubectl apply -f config/crd/bases/apps.example.com_myapps.yaml

customresourcedefinition.apiextensions.k8s.io/myapps.apps.example.com created

Run the operator locally to test your controller logic against a Kubernetes cluster.

Terminal

make run

Expected Output

INFO[0000] Starting the Cmd.

INFO[0001] Starting controller

INFO[0002] Controller is running

Verify that the CustomResourceDefinition for your operator is installed and available in the cluster.

Terminal

kubectl get crd

Expected Output

NAME                      CREATED AT

myapps.apps.example.com    2024-06-01T12:00:00Z

Key Concept

If you remember nothing else from this pattern, remember: Operator SDK scaffolds your operator project and automates creating APIs and controllers to manage custom Kubernetes resources.

Common Mistakes

Not running 'make install' before using the custom resource

The Kubernetes cluster does not recognize the new resource type without the CRD installed, so your operator cannot manage it.

Always run 'make install' to apply the CRD before creating or managing custom resources.

Forgetting to specify --resource and --controller flags when creating the API

Without these flags, the resource manifests and controller code are not generated, so the operator lacks the logic to manage resources.

Include both --resource and --controller flags to generate all necessary code and manifests.

Running 'make run' without a configured Kubernetes cluster

The operator needs access to a Kubernetes cluster to watch and manage resources; without it, it will fail to start properly.

Ensure your kubeconfig is set and points to a running cluster before running the operator locally.

Summary

Initialize an Operator SDK project with 'operator-sdk init' to set up the structure.

Create APIs and controllers with 'operator-sdk create api' including resource and controller flags.

Install the CRD into the cluster using 'make install' so Kubernetes knows your custom resource.

Run the operator locally with 'make run' to test your controller logic.

Verify CRD installation with 'kubectl get crd' to confirm your resource is registered.

Practice

1. What is the primary purpose of the Operator SDK in Kubernetes?

easy

A. To monitor network traffic in Kubernetes

B. To replace Kubernetes API server

C. To help automate application management on Kubernetes clusters

D. To create Kubernetes clusters automatically

Solution

1. Step 1: Understand Operator SDK's role

   The Operator SDK is designed to simplify building and managing Kubernetes operators, which automate app lifecycle tasks.

2. Step 2: Compare options

   Options A, B, and C describe unrelated Kubernetes functions, while D correctly states the SDK's purpose.

3. Final Answer:

   To help automate application management on Kubernetes clusters -> Option C

4. Quick Check:

   Operator SDK automates app management = D [OK]

Hint: Remember: Operator SDK automates app tasks on Kubernetes [OK]

Common Mistakes:

• Confusing Operator SDK with Kubernetes cluster creation tools
• Thinking Operator SDK replaces core Kubernetes components
• Assuming it monitors network traffic

2. Which command initializes a new Operator SDK project?

easy

A. operator-sdk create api

B. operator-sdk start

C. kubectl init operator

D. operator-sdk init

Solution

1. Step 1: Identify the command to start a project

   The operator-sdk init command sets up a new operator project structure.

2. Step 2: Eliminate incorrect commands

   create api adds resources, kubectl init operator is invalid, and start is not a recognized init command.

3. Final Answer:

   operator-sdk init -> Option D

4. Quick Check:

   Init command for project setup = B [OK]

Hint: Use 'init' to start your operator project [OK]

Common Mistakes:

• Confusing 'create api' with project initialization
• Using kubectl commands instead of operator-sdk
• Trying 'start' instead of 'init'

3. What will happen if you run operator-sdk create api --group=app --version=v1 --kind=AppService?

medium

A. It creates a new API and resource type named AppService in group app/v1

B. It deletes the existing AppService resource

C. It initializes a new operator project

D. It runs the operator locally

Solution

1. Step 1: Understand the create api command

   The command operator-sdk create api adds a new API resource to the operator project with specified group, version, and kind.

2. Step 2: Analyze the command parameters

   Here, group is 'app', version is 'v1', and kind is 'AppService', so it creates that resource type.

3. Final Answer:

   It creates a new API and resource type named AppService in group app/v1 -> Option A

4. Quick Check:

   Create API command adds resource = A [OK]

Hint: Create API adds resource with group, version, kind [OK]

Common Mistakes:

• Thinking it deletes resources
• Confusing create api with init
• Assuming it runs the operator

4. You ran operator-sdk init --domain=example.com app-operator but got an error. What is a common cause?

medium

A. Missing Go module initialization before running init

B. Using an invalid domain format

C. Not having Kubernetes cluster running

D. Running create api before init

Solution

1. Step 1: Check prerequisites for operator-sdk init

   The Operator SDK requires a Go module initialized (via go mod init) before running init.

2. Step 2: Evaluate other options

   Domain format is usually flexible, Kubernetes cluster is not needed for init, and create api must come after init, not before.

3. Final Answer:

   Missing Go module initialization before running init -> Option A

4. Quick Check:

   Go module must be ready before init = C [OK]

Hint: Always run 'go mod init' before 'operator-sdk init' [OK]

Common Mistakes:

• Ignoring Go module setup
• Assuming cluster must be running for init
• Running create api before init

5. You want to test your operator locally before deploying. Which command should you run?

hard

A. operator-sdk deploy cluster

B. operator-sdk up local

C. kubectl apply -f deploy.yaml

D. operator-sdk create api

Solution

1. Step 1: Identify command for local testing

   The operator-sdk up local command runs the operator locally on your machine for testing.

2. Step 2: Compare other options

   deploy cluster deploys to cluster, kubectl apply applies manifests, and create api adds resources, none run locally.

3. Final Answer:

   operator-sdk up local -> Option B

4. Quick Check:

   Run local command tests operator locally = A [OK]

Hint: Use 'up local' to test operator on your machine [OK]

Common Mistakes:

• Trying to deploy before local testing
• Confusing create api with running operator
• Using kubectl instead of operator-sdk for local run