A presentation at Config Management Camp in in Ghent, Belgium by Horacio Gonzalez
Let’s dive into Kubernetes operator creation Horacio Gonzalez 2024-04-06
Who are we? Introducing myself and introducing Clever Cloud
Horacio Gonzalez @LostInBrittany Spaniard Lost in Brittany
Clever Cloud Our mission: give more speed to your teams and better quality to your projects
Warning Gophers, gophers everywhere!
Last year in Config Management Camp
I proposed a sequel for this year Let’s dive into Kubernetes operator creation This time Aurélie can’t do the talk with me 😢 So I must do it alone… Wish me luck!
And why Gophers? Because we love Gophers, of course! And because Golang and Kubernetes are so linked…
Credit where it is due All the gophers you will see are drawn by Aurélie and Horacio, and are based on the Go mascot designed by Renee French which is licensed under CC BY 3.0.
Kubernetes operators Helping to tame the complexity of K8s Ops
Taming microservices with Kubernetes
What about complex deployments
Tools like Helm helps with complexity
Helm Charts are configuration Operating is more than installs & upgrades
Kubernetes is about automation How about automating human operators?
Kubernetes Operators A Kubernetes version of the human operator
Building operators Basic K8s elements: Custom Resources & Controllers
Custom Resource Definitions Extending Kubernetes API
Extending Kubernetes API By defining new types of resources, internal or external to the cluster
With a CRD you can create CR in the cluster They are the blueprints of the Custom Resources
Custom Resources are simply data All the logic must be in the Controller
Kubernetes Controllers Keeping an eye on the resources
A reconcile loop Controllers watch the state of the cluster, and make or request changes where needed
Kubernetes Operator Automating operations
What’s a Kubernetes Operator?
Example: databases Things like adding an instance to a pool, doing a backup, sharding…
Knowledge encoded in CRDs and Controllers
Custom Controllers for Custom Resources Operators implement and manage Custom Resources using custom reconciliation logic
Operator Capability Model Gauging the operator maturity
A real, open-source example The Clever Operator
Available on Operator Hub & GitHub https://operatorhub.io/operator/clever-operator https://github.com/CleverCloud/clever-operator
Exposing Clever Cloud resources as CRD Allowing your apps to use our DBs as if they were in K8s
How can we write Operators? Which language? Any framework?
They are simply pods and manifests You can simply call Kubernetes APIs or use a compatible client
How to write an Operator
The Operator Framework Open source framework to accelerate the development of an Operator
Operator SDK Three different ways to build an Operator
Our objective Why? Because we can!
What do we want? ● In a simple and easy Kubernetes operator ● Handle cute Gophers ● In Javascript, because it’s very expressive and easy to understand… and I like it 😁
All the code is available https://github.com/LostInBrittany/lets-dive-into-kubernetes-operator-creation
Aurélie’s Gopher repository https://github.com/scraly/gophers
random-gopher container https://hub.docker.com/r/lostinbrittany/random-gopher
random-gopher container import express from ‘express’ ; import { readdir } from ‘node:fs/promises’ ; import path from ‘node:path’ ; let app = express(); let chosenGopher; async function initFiles() { try { const files = await readdir( ‘gophers’ ); const gophers = files.filter( (item) => item.endsWith( ‘png’) || item.endsWith( ‘jpg’) ); const randomIndex = Math.floor((Math.random()*gophers.length)); chosenGopher = gophers[randomIndex]; console.log(chosenGopher); } catch (err) { console.error(err); } } At startup it chooses and exposes a random gopher
random-gopher-deployment apiVersion: apps/v1 kind: Deployment metadata: name: random-gopher spec: selector: matchLabels: run: random-gopher replicas: 10 template: metadata: labels: run: random-gopher spec: containers: - name: random-gopher image: lostinbrittany/random-gopher:0.0.4 ports: - containerPort: 8080 Deploying lots of random-gophers in the cluster
Applying it to the cluster Deploying random-gopher-deployment Deploying the manifest kubectl apply -f manifests random-gopher-deployment.yaml Getting pods’ address kubectl get pods -o wide Create a busybox kubectl run -i —tty —rm debug —image=busybox —restart=Never — sh Asking for a Gopher name wget -qO - [pod_ip]:8080/gopher/name Let’s switch to the terminal…
We also have an API for Gophers https://github.com/LostInBrittany/lets-dive-into-kubernetes-operator-creation /tree/main/gopher-api-and-ui
We also have an API for Gophers
And an UI to see the Gophers in the API https://github.com/LostInBrittany/gophers-api-watcher
To make it easy we deploy on Clever Cloud
In the logs we get the API key
What we want An operator to feed the API with the deployed pods info
And we are doing it in the simplest way In JavaScript, yeah!
Taking as base k8s-operator-node https://github.com/dot-i/k8s-operator-node
Building the gopher operator Let’s switch to VS Code…
That’s all, folks! Thank you all!
Kubernetes Operators have emerged as a game-changing approach to simplify the deployment and management of complex applications within Kubernetes clusters. These operators leverage the power of Custom Resources and Controllers to automate tasks traditionally performed by human operators, thus streamlining the entire application lifecycle.
In this engaging and hands-on talk, we will demystify the process of creating a Kubernetes Operator. While the prospect of developing one may appear intimidating, the underlying concepts are surprisingly straightforward: define Custom Resource Definitions (CRDs) to model your application’s key concepts, and craft Controllers, which are specialized pods responsible for monitoring and taking action on specific resources in the cluster.
But we’re not stopping at theory! Writing an Operator doesn’t have to be a dry affair. To make it more enjoyable, we’ve chosen an original use case filled with hand-drawn Gophers, and we’ll livecode it right before your eyes to showcase its simplicity. Join us in this interactive session where we’ll combine education and entertainment, making the journey of building your own Kubernetes Operator both informative and fun.
Using the Gopher REST API as a foundation, we will break down the essentials of Operator creation while adding a touch of creativity and humor. We will provide valuable insights into crafting a simple yet efficient Operator architecture capable of managing not only Kubernetes objects but also external resources. You will witness the code and the operator in action, gaining practical knowledge that empowers you to automate and enhance your application deployment and management within Kubernetes environments.
Here’s what was said about this presentation on social media.
