\n<\/p>\n
In the rapidly evolving world of cloud-native applications, Kubernetes has emerged as the leading container orchestration platform, offering a robust API and extensibility framework. One of the core components that allow Kubernetes to manage resources effectively is the Controller. In this article, we will dive into what custom controllers are, why they are essential, and how to build one from scratch.<\/p>\n
<\/p>\n
<\/p>\n
A Kubernetes Controller<\/strong> continuously watches the state of your cluster, comparing the current state of its resources to the desired state defined by the user. If there’s a discrepancy, the controller takes action to rectify the situation. Controllers work behind the scenes to manage various aspects of your environment, from scaling applications to handling network traffic.<\/p>\n <\/p>\n <\/p>\n While Kubernetes API already includes several built-in controllers (like Deployments and StatefulSets), there are scenarios where custom controllers are necessary:<\/p>\n <\/p>\n <\/p>\n <\/p>\n \n<\/ul>\n <\/p>\n <\/p>\n <\/p>\n Before diving into custom controllers, you should have a solid understanding of:<\/p>\n <\/p>\n <\/p>\n <\/p>\n \n<\/ul>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n \n<\/ol>\n <\/p>\n <\/p>\n <\/p>\n The first step in creating a custom controller is defining a CRD. A CRD allows you to extend Kubernetes with your own resource types.<\/p>\n <\/p>\n Here\u2019s an example of a CRD that defines a <\/p>\n <\/p>\n <\/p>\n Initialize a Go Module<\/strong>:<\/p>\n <\/p>\n Start a new Go module for your controller:<\/p>\n <\/p>\n \n<\/li>\n <\/p>\n Install Client Libraries<\/strong>:<\/p>\n <\/p>\n Install necessary dependencies:<\/p>\n <\/p>\n \n<\/li>\n <\/p>\n Write the Controller Logic<\/strong>:<\/p>\n <\/p>\n Create a new file, <\/p>\n \n<\/li>\n \n<\/ol>\n <\/p>\n <\/p>\n Dockerize Your Application<\/strong>:<\/p>\n <\/p>\n Create a Dockerfile to build your controller image.<\/p>\n <\/p>\n \n<\/li>\n <\/p>\n Build and Push the Docker Image<\/strong>:<\/p>\n <\/p>\n \n<\/li>\n <\/p>\n Create Kubernetes Deployment<\/strong>:<\/p>\n <\/p>\n Deploy your controller to Kubernetes using a Deployment manifest.<\/p>\n <\/p>\n \n<\/li>\n <\/p>\n Apply the CRD and Deployment<\/strong>:<\/p>\n <\/p>\n \n<\/li>\n \n<\/ol>\n <\/p>\n <\/p>\n Create a Custom Resource instance to see your controller in action:<\/p>\n <\/p>\n <\/p>\n Deploy it using:<\/p>\n <\/p>\n <\/p>\n Monitor the logs of your controller to verify that it is reconciling the custom resource as expected.<\/p>\n <\/p>\n <\/p>\n Building a custom controller in Kubernetes provides immense flexibility and control over your workloads. With the power of CRDs and custom logic, you can automate complex scenarios and ensure your applications are managed effectively.<\/p>\n <\/p>\n By following this guide, you should now be equipped to create, deploy, and test a custom controller tailored to your needs. Stay tuned for more insights and advanced topics on Kubernetes and cloud-native technologies on WafaTech Blogs!<\/p>\n\n","protected":false},"excerpt":{"rendered":" In the rapidly evolving world of cloud-native applications, Kubernetes has emerged as the leading container orchestration platform, offering a robust API and extensibility framework. One of the core components that allow Kubernetes to manage resources effectively is the Controller. In this article, we will dive into what custom controllers are, why they are essential, and […]<\/p>\n","protected":false},"author":2,"featured_media":2411,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","inline_featured_image":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[213],"tags":[646,218,216,240,233,217],"class_list":["post-2410","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-kubernetes","tag-building","tag-comprehensive","tag-controllers","tag-custom","tag-guide","tag-kubernetes","et-has-post-format-content","et_post_format-et-post-format-standard"],"yoast_head":"\nCustom Controllers: Definition and Use Cases<\/h3>\n
<\/p>\n
Prerequisites<\/h2>\n
Knowledge<\/h3>\n
<\/p>\n
Environment Setup<\/h3>\n
<\/p>\n
kubectl<\/code> configured to communicate with your Kubernetes cluster.<\/li>\nCreating a Custom Controller<\/h2>\n
Step 1: Define a Custom Resource Definition (CRD)<\/h3>\n
CronJob<\/code> resource:<\/p>\napiVersion: apiextensions.k8s.io\/v1
\nkind: CustomResourceDefinition
\nmetadata:
\n name: cronjobs.example.com
\nspec:
\n group: example.com
\n versions:
\n - name: v1
\n served: true
\n storage: true
\n schema:
\n openAPIV3Schema:
\n type: object
\n properties:
\n spec:
\n type: object
\n properties:
\n schedule:
\n type: string
\n image:
\n type: string
\n scope: Namespaced
\n names:
\n plural: cronjobs
\n singular: cronjob
\n kind: CronJob
\n shortNames:
\n - cj<\/code><\/pre>\nStep 2: Create the Controller<\/h3>\n
<\/p>\n
mkdir cronjob-controller
\ncd cronjob-controller
\ngo mod init example.com\/cronjob-controller<\/code><\/pre>\ngo get k8s.io\/apimachinery@v0.23.x
\ngo get k8s.io\/client-go@v0.23.x
\ngo get k8s.io\/controller-runtime@0.10.x<\/code><\/pre>\nmain.go<\/code>, and start writing your controller. Here\u2019s a simplified example:<\/p>\npackage main
\n
\nimport (
\n \"context\"
\n \"os\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/controller\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/controller\/controllerutil\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/manager\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/source\"
\n corev1 \"k8s.io\/api\/core\/v1\"
\n metav1 \"k8s.io\/apimachinery\/pkg\/apis\/meta\/v1\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/reconcile\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/controller\/controlleroptions\"
\n \"sigs.k8s.io\/controller-runtime\/pkg\/client\"
\n)
\n
\ntype CronJobReconciler struct {
\n client.Client
\n}
\n
\nfunc (r *CronJobReconciler) Reconcile(req reconcile.Request) (reconcile.Result, error) {
\n ctx := context.Background()
\n cronJob := &corev1.Pod{}
\n
\n if err := r.Get(ctx, req.NamespacedName, cronJob); err != nil {
\n return reconcile.Result{}, client.IgnoreNotFound(err)
\n }
\n
\n \/\/ Implement your reconciliation logic here
\n
\n return reconcile.Result{}, nil
\n}
\n
\nfunc main() {
\n mgr, err := manager.New(config.GetConfigOrDie(), manager.Options{})
\n if err != nil {
\n os.Exit(1)
\n }
\n
\n if err := controller.New(\"cronjob-controller\", mgr, controlleroptions.Options{}).
\n Watch(&source.Kind{Type: &corev1.Pod{}}, &handler.EnqueueRequestForObject{}); err != nil {
\n os.Exit(1)
\n }
\n
\n if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
\n os.Exit(1)
\n }
\n}<\/code><\/pre>\nStep 3: Deploy the Controller<\/h3>\n
<\/p>\n
FROM golang:1.20 AS builder
\nWORKDIR \/app
\nCOPY . .
\nRUN go build -o cronjob-controller .
\n
\nFROM alpine:latest
\nWORKDIR \/root\/
\nCOPY --from=builder \/app\/cronjob-controller .
\nCMD [\".\/cronjob-controller\"]<\/code><\/pre>\ndocker build -t your-docker-repo\/cronjob-controller:v1 .
\ndocker push your-docker-repo\/cronjob-controller:v1<\/code><\/pre>\napiVersion: apps\/v1
\nkind: Deployment
\nmetadata:
\n name: cronjob-controller
\nspec:
\n replicas: 1
\n selector:
\n matchLabels:
\n app: cronjob-controller
\n template:
\n metadata:
\n labels:
\n app: cronjob-controller
\n spec:
\n containers:
\n - name: cronjob-controller
\n image: your-docker-repo\/cronjob-controller:v1
\n imagePullPolicy: Always<\/code><\/pre>\nkubectl apply -f cronjob-crd.yaml
\nkubectl apply -f cronjob-controller-deployment.yaml<\/code><\/pre>\nStep 4: Test Your Custom Controller<\/h3>\n
apiVersion: example.com\/v1
\nkind: CronJob
\nmetadata:
\n name: my-cronjob
\nspec:
\n schedule: \"*\/1 * * * *\"
\n image: \"busybox\"<\/code><\/pre>\nkubectl apply -f my-cronjob.yaml<\/code><\/pre>\nConclusion<\/h2>\n