Chapters (35)
- 0:00Introduction & Prerequisites
- 1:55What is a Controller? (The Observe-Compare-Act Loop)
- 6:45Idempotency in Controllers
- 7:55Deep Dive: The Reconcile Loop (Happy Path, Sad Path, & Error Handling)
- 19:45The Foundation of Writing Operators
- 23:05What is an Operator? (The "Helper" Analogy)
- 27:35CRDs (Custom Resource Definitions) and CRs (Custom Resources)
- 31:35Kubernetes as an SDK & Extensibility
- 34:00Networking, Storage, & Admission Controllers
- 35:20Internal Developer Platforms (IDP) & Platform Engineering
- 39:50Bootstrapping with Kubebuilder
- 41:05Setting up the Local Environment (K3D, Docker)
- 52:15Introduction to the Kubebuilder Framework
- 56:35Project Initialization (kubebuilder init)
- 1:00:30Exploring Scaffolding (Makefiles, Dockerfiles, main.go)
- 1:04:15Creating your first API (kubebuilder create api)
- 1:06:45Defining EC2 Instance Types & Specs in Go
- 1:13:05Understanding TypeMeta and ObjectMeta
- 1:21:45Internal Controller Logic Breakdown
- 1:24:05Deep Dive: Manager Architecture & Controller-Runtime
- 1:31:05Cert Watchers, Health Checks, & Prometheus Metrics
- 1:52:55Initializing the Manager in main.go
- 2:07:35Implementing the Reconcile Loop Logic
- 2:22:35Custom Resource Definitions (CRDs) in Action
- 2:46:45Running the Operator Locally
- 3:01:45AWS SDK Integration in Go
- 3:22:55Using Finalizers for Cleanup Logic
- 3:36:55Creating EC2 Instances on AWS via the Operator
- 3:53:20Implementing Waiters for Instance State (Running/Terminated)
- 4:13:45Idempotency & Reconciler Loop Internals
- 4:46:35How Informers, Caches, and WorkQueues Work
- 5:11:20Handling Object Deletion & Timestamps
- 5:32:05Packaging the Operator with Helm
- 5:43:05Deploying to Kubernetes (RBAC & Service Accounts)
- 6:16:20Conclusion & Future Steps
Show the creator's full description
In this hands-on Kubernetes Operator course, you will learn how to extend Kubernetes by building your own custom operators and controllers from scratch. You’ll go beyond simply using Kubernetes and start treating it as a Software Development Kit (SDK).
You will learn how to build a real-world operator that manages AWS EC2 instances directly from Kubernetes, covering everything from the internal architecture of Informers and Caches to advanced concepts like Finalizers and Idempotency.
💻 Code & Resources: https://github.com/shkatara/kubernetes-ec2-operator
Shubham: https://www.linkedin.com/in/shubhamkatara/
Saiyam: https://www.linkedin.com/in/saiyampathak
Kubesimplify: https://www.youtube.com/@kubesimplify
Course Curriculum & Timestamps
Part 1: The Theory of Controllers
- 0:00:00 Introduction & Prerequisites
- 0:01:55 What is a Controller? (The Observe-Compare-Act Loop)
- 0:06:45 Idempotency in Controllers
- 0:07:55 Deep Dive: The Reconcile Loop (Happy Path, Sad Path, & Error Handling)
- 0:19:45 The Foundation of Writing Operators
- 0:23:05 What is an Operator? (The "Helper" Analogy)
- 0:27:35 CRDs (Custom Resource Definitions) and CRs (Custom Resources)
Part 2: Kubernetes Extensibility
- 0:31:35 Kubernetes as an SDK & Extensibility
- 0:34:00 Networking, Storage, & Admission Controllers
- 0:35:20 Internal Developer Platforms (IDP) & Platform Engineering
- 0:39:50 Bootstrapping with Kubebuilder
Part 3: Setting Up the Environment
- 0:41:05 Setting up the Local Environment (K3D, Docker)
- 0:52:15 Introduction to the Kubebuilder Framework
- 0:56:35 Project Initialization (kubebuilder init)
- 1:00:30 Exploring Scaffolding (Makefiles, Dockerfiles, main.go)
Part 4: Building the API & Logic
- 1:04:15 Creating your first API (kubebuilder create api)
- 1:06:45 Defining EC2 Instance Types & Specs in Go
- 1:13:05 Understanding TypeMeta and ObjectMeta
- 1:21:45 Internal Controller Logic Breakdown
- 1:24:05 Deep Dive: Manager Architecture & Controller-Runtime
- 1:31:05 Cert Watchers, Health Checks, & Prometheus Metrics
- 1:52:55 Initializing the Manager in main.go
Part 5: Hands-on Development
- 2:07:35 Implementing the Reconcile Loop Logic
- 2:22:35 Custom Resource Definitions (CRDs) in Action
- 2:46:45 Running the Operator Locally
- 3:01:45 AWS SDK Integration in Go
- 3:22:55 Using Finalizers for Cleanup Logic
- 3:36:55 Creating EC2 Instances on AWS via the Operator
- 3:53:20 Implementing Waiters for Instance State (Running/Terminated)
Part 6: Advanced Internals & Deployment
- 4:13:45 Idempotency & Reconciler Loop Internals
- 4:46:35 How Informers, Caches, and WorkQueues Work
- 5:11:20 Handling Object Deletion & Timestamps
- 5:32:05 Packaging the Operator with Helm
- 5:43:05 Deploying to Kubernetes (RBAC & Service Accounts)
- 6:16:20 Conclusion & Future Steps
Description and video by freeCodeCamp.org. This page is an independent companion view; the video is embedded from YouTube.