Build a Kubernetes Operator in 10 minutes with Operator SDK

In Kubernetes, objects are analogous to a job or a accomplished activity in the actual world. You can use them to outline widespread duties, retailer them in a model management system, and apply them with kubectl apply. Kubernetes ensures that this triggers the whole lot essential to deliver your declarative description to life by creating the relying assets (like pods) to run your software program. Kubernetes accommodates a lot of built-in object varieties that may be created with this workflow, like Deployments and Services.

With Operators, Kubernetes permits cluster maintainers or software program suppliers to outline their very own Kubernetes object varieties, known as customized useful resource definitions (CRDs). These objects will be dealt with by the Kubernetes API, similar to built-in object varieties. Inside the Operator code, authors can outline find out how to act on these customized objects.

The Operator person can use kubectl apply to create an object of this practice sort, which known as a customized useful resource (CR).

There are many various makes use of for CRs, from deploying just a few pods to extra advanced functions. Imagine working kubectl -f postgres.yml and getting a high-availability PostgreSQL cluster prepared to be used.

This article will use a Kubernetes Operator to deploy a easy utility consisting of 1 config map and one pod. In the CR, you possibly can specify a Markdown string that will likely be reworked into an HTML5-based presentation. (After all, who would not wish to put together the slides for his or her subsequent speak utilizing kubectl edit presentation my-presentation, as you will do on this tutorial?)

If you are not already acquainted with working a Kubernetes cluster, learn Getting started with Minikube: Kubernetes on your laptop to make it simpler to comply with together with this how-to.

Install the Operator SDK

Before I start, I am going to assume you’re already logged into the Kubernetes cluster you wish to use. You should even have Golang 1.13 or later.

Install the newest model of Operator SDK to your laptop from the Operator SDK releases web page on GitHub, then make it executable and put it into your PATH as operator-sdk:

$ wget https://github.com/operator-framework/operator-sdk/releases/obtain/v0.15.2/operator-sdk-v0.15.2-x86_64-linux-gnu
$ sudo mv operator-sdk-v0.15.2-x86_64-linux-gnu /usr/native/bin/operator-sdk
$ sudo chmod +x /usr/native/bin/operator-sdk

Bootstrap a brand new Kubernetes Operator

Now you are able to get began with the Operator growth! The operator-sdk binary can be utilized to generate the boilerplate code widespread to many various Operators. This permits each Operator creator to give attention to creating their very own logic that differentiates it from different Operators, as a substitute of reinventing the Operator logic time and again. To generate the boilerplate code, run the next command in a folder the place you wish to create the Operator. Operator SDK will generate a folder with the title of the Operator you specify:

$ cd ~/operators
$ operator-sdk new presentation-example-operator --type go --repo github.com/NautiluX/presentation-example-operator

Point the repo argument to the repository you wish to use to your Go module. This command will obtain some dependencies, create the folder presentation-example-operator, and create a primary undertaking setup. Next, generate some Go code to signify your customized useful resource definition (the “API” of your Operator):

$ cd presentation-example-operator
$ operator-sdk add api --kind Presentation --api-version presentation.instance.com/v1alpha1

This command specifies that the CRD will likely be known as Presentation and creates the file pkg/apis/presentation/v1alpha1/presentation_types.go, which you’ll be able to modify to specify the enter parameter of your CRD. For this instance utility, you want just one parameter, known as Markdown:

...
sort PresentationSpec struct 

        // INSERT ADDITIONAL SPEC FIELDS - desired state of cluster

        // Important: Run "operator-sdk generate k8s" to regenerate code after modifying this file

        // Add customized validation utilizing kubebuilder tags: https://book-v1.book.kubebuilder.io/beyond_basics/generating_crd.html
        // This subject can be utilized to outline your presentation in markdown. Use --- to separate slides.
        Markdown string `json:"markdown,omitempty"`

...

Note that the one issues completely different listed below are a remark for the sector and the declaration of the Markdown subject. The remainder of the file is generated by Operator SDK and will be adjusted to your wants.

Now, generate the precise CRDs from this definition and a little bit of Go code. To achieve this, run the next instructions:

$ operator-sdk generate crds
$ operator-sdk generate k8s

In deploy/crds/presentation.instance.com_presentations_crd.yaml, you will see that the CRD, which you’ll be able to set up in your cluster utilizing the next command:

$ kubectl apply -f deploy/crds/presentation.instance.com_presentations_crd.yaml

The Operator will run a so-called reconcile-loop, which ensures a chunk of code is executed each time a CR from an Operator’s CRDs is created. This piece of code lives in a controller. Every CRD the Operator desires to function on may have a corresponding controller within the operator. In this case, you solely want one controller, as you solely have a single CRD. It’s widespread, although, to have a number of CRDs and a number of controllers packaged in a single Operator. To create a controller to your newly created CRD, run the next command:

$ operator-sdk add controller --kind Presentation --api-version presentation.instance.com/v1alpha1

Now you possibly can add your personal logic to the perform Reconcile within the generated file pkg/controller/add_presentation.go. This perform will likely be known as each time a Presentation CR is created, modified, or deleted. Whenever it returns an error, the identical request will run one other spherical via that perform.

After it’s generated, it accommodates instance code that creates a pod, which you’ll be able to alter to suit your wants. You can discover the total implementation of the known as features within the Git repository of this example Operator. This code exhibits the workflow within the Reconcile perform:

...
        configMapChanged, err := r.ensureLatestConfigMap(occasion)
        if err != nil 
                return reconcile.Result, err
        
        err = r.ensureLatestPod(occasion, configMapChanged)
        if err != nil 
                return reconcile.Result, err
        
        return reconcile.Result, nil
...

First, it ensures a ConfigMap with the present Markdown exists. Then, it ensures a pod is created with the newest model of the ConfigMap mounted.

Iterate shortly: Run the Operator outdoors the cluster

The Operator will be deployed to the cluster, similar to some other utility. However, for fast iterations throughout growth, it’s useful to run it in your native machine. That means, you possibly can see the output immediately and may cease it by merely urgent Ctrl+C. To begin the Operator, run the next command:

$ operator-sdk run --local

Now you possibly can create your first presentation from a separate terminal and watch the Operator do its work:

$ kubectl apply -f <(echo "
apiVersion: presentation.instance.com/v1alpha1
sort: Presentation
metadata:
  title: example-presentation
spec:
  markdown: |
    # My First Presentation
    ---
    ## Test slide
    * Test
    ---
")

This will spin up a pod and create a config map, as you outlined it within the Go code above:

$ kubectl get pods

NAME                       READY   STATUS    RESTARTS   AGE

example-presentation-pod   1/1     Running   zero          103s
$ kubectl get configmaps
NAME                          DATA   AGE
example-presentation-config   1      104s

To entry this little utility and see your slides, you should port-forward port 80 from contained in the pod. In an actual utility, you possibly can create a service useful resource from the Operator code:

$ kubectl port-forward example-presentation-pod 8080:80

Now you possibly can see your presentation by navigating your browser to http://localhost:8080. Whenever you replace the Markdown (for instance, utilizing kubectl edit presentation example-presentation), the web page will likely be up to date after the pod has been redeployed (and you will want to restart port-forwarding once more).

Deploy the Operator

To deploy the Operator, you should create a container picture that may be accessed by your Kubernetes cluster. Luckily, Operator SDK accommodates tooling to create this picture. After constructing, you possibly can push the picture with the Docker CLI:

$ operator-sdk construct manueldewald/presentation-example-operator
$ docker push manueldewald/presentation-example-operator

Now, you should alter the deployment config that was beforehand generated by the Operator SDK in deploy/operator.yaml:

$ sed -i 's|REPLACE_IMAGE|manueldewald/presentation-example-operator|g' deploy/operator.yaml

Finally, you possibly can deploy the Operator utilizing kubectl apply -f deploy/operator.yml, and it’ll begin working contained in the cluster. Now you possibly can attempt to change your presentation or deploy a brand new one.

Conclusion

It’s pretty simple to create and deploy a customized Operator and customized Kubernetes varieties utilizing the Operator SDK.

If you want the concept of making slides utilizing Markdown, check out Remark.js, which was used on this instance Operator. You needn’t run a Kubernetes cluster to make use of it; opening a easy HTML file will likely be sufficient. But if you wish to current out of your Kubernetes cluster for any cause, now you know the way to do it.