Uncategorized on mikeda.me

State Reconciliation is a two-way street

Mon, 12 Sep 2022 22:10:31 +0000

If you like this post, you can learn more about operators from my book, The Kubernetes Operator Framework Book.

Recently my team and I were working on a feature for our operator when we came across a state-reconciliation bug that was potentially serious. What’s worse, we almost didn’t catch it. This was especially surprising as a diverse team of developers that were both new and experienced with Kubernetes. The tl;dr was that it is important for an operator to watch both its inputs and outputs.

The Kubernetes Operator Framework Book is now available!

Fri, 15 Jul 2022 14:35:23 +0000

As of today, I am officially a published author. My first book, The Kubernetes Operator Framework Book, is now available from Amazon and Packt (in both print and ebook).

In this book, I try to offer a casual introduction to Kubernetes Operators and the experience of building and maintaining one. If you or someone on your team is familiar with Kubernetes but curious about Operators, I think The Kubernetes Operator Framework Book will be a great resource for getting up to speed with the core concepts. It was my goal with this book to provide a friendly, welcoming tutorial with hands-on application of the most important topics, which I think new users will find easy to understand.

How to build custom Kubernetes control plane images (and test them with Kind)

Tue, 03 Nov 2020 20:44:52 +0000

If you are working on changes to a core Kubernetes component such as the scheduler, controller-manager, or apiserver, you may be confused about how to actually build and deploy your changes in a local environment to test them. This post will go over the method I use to build and test control plane component changes. There are probably more efficient ways to do it, but this works for me and gives me some flexibility over each step which I will explain.

Error compiling oc for OpenShift on Mac

Fri, 13 Mar 2020 17:36:41 +0000

When I recently switched to a Mac for my personal/work laptop, I ran into this problem trying to build oc:

# github.com/apcera/gssapi
vendor/github.com/apcera/gssapi/name.go:213:9: could not determine kind of name for C.wrap_gss_canonicalize_name
cgo:
clang errors for preamble:
vendor/github.com/apcera/gssapi/name.go:90:2: error: unknown type name 'gss_const_name_t'
 gss_const_name_t input_name,
 ^
1 error generated.
make: *** [build] Error 2

This led me to this helpful comment that explains the gssapi headers on Mac are outdated. This was fixed by installing the heimdal HomeBrew package: brew install heimdal

"git trash"

Tue, 05 Mar 2019 19:18:20 +0000

I often end up doing test bumps of dependencies that leave my repo with a ton of trash changes that I just want to be able to undo easily and reset my repo including any new or deleted files and directories, so I added this to my .gitconfig :

[alias]
 trash = !git stash && git clean -fd

This lets me run git trash to quickly stash all my unstaged changes and delete all my untracked files at once, which I couldn’t find any other solution for.

How to Add Collaborators to Your OpenShift Online Pro Account

Wed, 17 Jan 2018 13:56:27 +0000

*(**Note: *This post originally appeared on the Red Hat OpenShift Blog)

OpenShift Online recently made a new feature available to Pro accounts: Collaboration. Collaboration allows a Pro account user to provision cluster account access for other users, called collaborators. These collaborators have normal access to the same cluster as the Pro account (without any resource quotas or ability to create new projects) and thus can be granted permissions to work on projects owned by the Pro account.

My First Simple Chrome Extension

Mon, 04 Dec 2017 02:39:06 +0000

Homebrewing is one of my favorite hobbies, so I’m a big fan of Brewer’s Friend for looking up recipes (as well as using their various calculators for OG/FG, IBUs, and others). Their search functionality is very good, and makes it easy to find exactly the kind of recipe you’re looking for.

What’s odd, however, is that on their recipe pages they will show a total amount of grain used:

But for hops, they’ll only show the total for each type of hop:

Hacking a Controller for OpenShift/Kubernetes, Pt. 3

Thu, 25 Aug 2016 14:25:14 +0000

Part 1: Introduction to the OpenShift client Part 2: Coding for Kubernetes

In the previous post, I went more in-depth into how Kubernetes works in the command line. For this post, let’s step back to the code from Part 1 of this series and modify it to run continuously, showing the list of pods currently in the cluster and updating every time a new pod is created.

The Watch Interface

Kubernetes’ Watch interface provides the ability to listen for several different types of events in the cluster. Using the channel functionality built into Go, this is perfect for us to set up an asynchronous controller that can run continuously. First we need to update our code to take advantage of channels. Go back to the code we had in Part 1 and change the main() function in your cmd/controller/cmd.go file to look like this: func main() { config, err := clientcmd.DefaultClientConfig(pflag.NewFlagSet(“empty”, pflag.ContinueOnError)).ClientConfig() kubeClient, err := kclient.New(config) if err != nil { log.Printf(“Error creating cluster config: %s”, err) os.Exit(1) } openshiftClient, err := osclient.New(config) if err != nil { log.Printf(“Error creating OpenShift client: %s”, err) os.Exit(2) }

Hacking a Controller for OpenShift/Kubernetes, Pt. 2

Tue, 23 Aug 2016 17:10:17 +0000

Part 1: Introduction to the OpenShift client Part 3: Writing a controller

In my last post, I went over how to set up an OpenShift environment for developing. That tutorial used the OpenShift Client API to make function calls which interacted with our cluster. However, there may be a situation where you need more direct interaction with your cluster’s resources (or perhaps you are interested in contributing to the open-source OpenShift Origin repository), and even the provided function calls aren’t enough to satiate your needs. In this case, it’s good to know how OpenShift interacts with Kubernetes directly to serve your cluster resources hot-and-ready.

Hacking a Controller for OpenShift/Kubernetes

Mon, 22 Aug 2016 20:05:02 +0000

Part 2: Coding for Kubernetes Part 3: Writing a controller

For OpenShift Online, we run several controllers in our cluster which serve functions such as provisioning persistent volumes and providing user analytics. But let’s say you have your own OpenShift cluster, upon which you’d like to run a controller that interacts with the resources in that cluster. I’m going to run you through setting up OpenShift and Kubernetes in a way that allows you to develop your own controller. By the end of this guide, we’ll have a simple controller that shows the cumulative running time for all pods in a namespace.

Running an IRC Bot in Ruby on OpenShift V3

Thu, 04 Aug 2016 17:54:01 +0000

Note: This post also appears on the Red Hat OpenShift Blog, along with many other cool posts by cool people.

At Red Hat, all of our instant internal messaging is done through IRC. Because of this, many of our channels have a couple bots in them that do things like process links, report new pull requests, and keep track of users’ karma. What’s cool is that a lot of these bots are actually developed and running on OpenShift, so let’s look at how you could get your own IRC bot running in OpenShift Online V3.