Lab Solution Build The WebApp Operator Scaffold

This lesson walks through recreating the webapp-operator scaffold using Kubebuilder. The objective is to:

Initialize the project with the exact course identifiers,
Generate CRD manifests from your API types,
Build the manager binary to verify the scaffold compiles.

Follow the numbered steps below in order and watch for common slip points noted along the way.

Initialize the Kubebuilder project scaffold

Run kubebuilder init with the exact domain, repository, and project name. These identifiers are critical because downstream labs and generated import paths depend on them.

kubebuilder init --domain kodekloud.com --repo github.com/kodekloud/webapp-operator --project-name webapp-operator

Make sure the --domain, --repo, and --project-name values exactly match the course. If these are incorrect, the fully qualified group names and import paths will differ and later steps will fail.

Add the WebApp API

Create the API group, version, and kind. Use --resource to generate API types and --controller to scaffold a reconciler:

kubebuilder create api --group webapp --version v1 --kind WebApp --resource --controller

--resource generates the Go types for the custom resource (CR).
--controller scaffolds the reconciler (controller) skeleton that watches and reconciles WebApp objects.

After this command completes, confirm the following generated files and locations:

File / Path	Purpose
`api/v1/webapp_types.go`	API type definitions (CR spec/status structs)
`api/v1/groupversion_info.go`	Group/version registration helpers
`controllers/webapp_controller.go`	Reconciler scaffold and reconcile logic entrypoint
`controllers/suite_test.go`	Test harness for the controllers
`cmd/main.go`	Manager bootstrap, including scheme registration

Inspect scheme registration in cmd/main.go

Open cmd/main.go and ensure your API package registers with the manager’s scheme. This registration lets controller-runtime encode/decode webapp.kodekloud.com/v1 objects. A typical snippet looks like:

package main

import (
    utilruntime "k8s.io/apimachinery/pkg/util/runtime"
    "k8s.io/apimachinery/pkg/runtime"
    clientgoscheme "k8s.io/client-go/kubernetes/scheme"
    ctrl "sigs.k8s.io/controller-runtime"
    webappv1 "github.com/kodekloud/webapp-operator/api/v1"
)

var (
    scheme   = runtime.NewScheme()
    setupLog = ctrl.Log.WithName("setup")
)

func init() {
    utilruntime.Must(clientgoscheme.AddToScheme(scheme))
    utilruntime.Must(webappv1.AddToScheme(scheme))
}

// main continues with manager setup...

If the call to webappv1.AddToScheme(scheme) is missing, the manager will not recognize your CRD types at runtime.

Generate CRD manifests

Generate CRD YAML and RBAC manifests using the project’s Makefile target, which runs controller-gen and produces artifacts under config/:

make manifests

You should see output similar to:

/bin/controller-gen rbac:roleName=manager-role crd webhook paths="./..." output:crd:artifacts:config=config/crd/bases

Confirm the CRD YAML exists in config/crd/bases and follows the naming pattern group_domain_plural.yaml, for example:

webapp.kodekloud.com_webapps.yaml

If the CRD file is missing or out of date, you most likely edited the Go type definitions without rerunning make manifests. Always regenerate manifests after changing API types.

Sanity build the manager binary

Compile the project to verify it builds cleanly:

make build

This runs a build that produces bin/manager. You can also run the equivalent steps manually:

go fmt ./...
go vet ./...
go build -o bin/manager ./cmd/main.go

If the build fails, examine the compiler errors for missing imports or incorrectly defined types in api/ or controllers/.

Confirm project metadata (PROJECT file)

Kubebuilder stores project-wide settings in the PROJECT file at the repository root. Verify the domain, repo, project name, and resources entry. A representative PROJECT YAML:

cliVersion: 4.14.0
domain: kodekloud.com
layout:
  - go.kubebuilder.io/v4
projectName: webapp-operator
repo: github.com/kodekloud/webapp-operator
resources:
  - api:
      crdVersion: v1
      namespaced: true
      controller: true
      domain: kodekloud.com
      group: webapp
      kind: WebApp
      path: github.com/kodekloud/webapp-operator/api/v1
      version: v1
version: "3"

Verify the resources entry lists group: webapp, version: v1, kind: WebApp, and the correct domain and path. Mismatches here lead to incorrect scaffold behavior and import path errors.

Summary & next steps

kubebuilder init sets up the project with the correct domain/repo/project name.
kubebuilder create api adds the API types and controller scaffold.
make manifests generates CRD YAML from API markers.
make build compiles the manager binary to confirm the scaffold is valid.

This scaffold is the skeleton of your operator. After validating it, implement the controller logic in controllers/webapp_controller.go, update your API types in api/v1/webapp_types.go, and keep regenerating manifests whenever you modify the API. Links and references

Kubebuilder: https://book.kubebuilder.io/
controller-runtime: https://pkg.go.dev/sigs.k8s.io/controller-runtime
controller-gen: https://pkg.go.dev/sigs.k8s.io/controller-tools/cmd/controller-gen
Go tooling: https://golang.org/doc/ and go build, go vet, go fmt documentation

Watch Video

Demo Kubebuilder Create API For WebApp

Demo What The Generator Wrote For You

Introduction to Operator Fundamentals

Custom Resource Definitions Deep Dive

Kubebuilder Scaffolding

Building The WebApp Operator Core Reconcile

Running Testing Debugging Locally

Status Conditions Events

Finalizers And Cleanup

Validation Webhooks And CEL Policies

Packaging And Distribution

Alternative Approaches Operator SDK Helm Operator

Consuming Popular Operators

Production Readiness Testing Wrap Up

Lab Solution Build The WebApp Operator Scaffold

Watch Video