Local Kubernetes using Docker Desktop

Kubernetes is really starting to be a de-facto standard in how we deploy things to the cloud. It provides a ton of functionality around docker images that it deploys while at the same time making optimal use of the hardware that it is running on. Having worked with traditional servers and then VMs, I have found Kubernetes to be quite refreshing. A lot of the tedious things that you had to deal with are just handled by default.

Running kubernetes locally is really quite simple. You only need to have docker desktop installed. That should be almost an automatic these days if you are developing software for the cloud. Now if you are someone that has docker desktop installed but hasn’t messed with kubernetes, don’t worry. A lot of folks do write apps and build docker images for them without needing to play with it. They are either leveraging a hosted service, like AWS ECS, to run and manage their containers or they have someone on their team that is hogging all the fun. Here’s a quick tutorial on how to start a container on kubernetes locally.

Step 1: Create a docker image

You might already have an image kicking around for an app you are developing. Let’s assume that you are starting from scratch though. Create a file called Dockerfile with the following contents. alpine is a minimal linux distro and we are going to install HTTPie on it. The working directory is set to be /opt/. The image opens a shell using the command /bin/sh.

FROM alpine:edge

RUN apk add httpie

WORKDIR /opt/

CMD /bin/sh

Build the image using the following command:

docker build --no-cache -t hello-world:docker-desktop .

You can verify that the image is built and working as expected by run it in interactive tty mode. That will allow you to interact with the shell as you would through a console.

docker run -it hello-world:docker-desktop

In the shell, you can run httpie from the container. That basically proves that your simple docker image was built correctly.

http https://jsonplaceholder.typicode.com/todos/1

No need to clean up. As soon as you exit the shell the container will stop running.

Step 2: Create a kubernetes pod

Now that you have a simple docker image, let’s create a kubernetes pod for it. A pod is a group of one or more containers. In this tutorial, it is just going to be one container that has our small image with HTTPie installed.

Select the docker-desktop context from the docker desktop kubernetes drop down menu. That is the locally running kubernetes instance that you get with docker desktop. You can confirm that you have that context selected using this command:

kubectx

Let’s create a namespace in your context called hello-namespace. Namespaces let you group together pods. In fact, you can create multiple pods with the same name as long as they exist in different namespaces.

kubectl create namespace hello-namespace

That gives us the kubernetes infrastructure needed for deploying our pod. A pod is defined using manifest files like the one below. They can either be JSON or YAML but virtually everyone uses YAML. This manifest says to create a pod named hello-pod with a single container called hello-container. This container will use the hello-world image and runs the command sleep 15m which means it will run for 15 minutes before completing. Copy this manifest into a file named hello-manifest.yaml

---
apiVersion: v1
kind: Pod
metadata:
  name: hello-pod
  namespace: foo
spec:
  containers:
    - name: hello-container
      image: hello-world:docker-desktop
      imagePullPolicy: IfNotPresent
      workingDir: /opt/
      command: ["sleep"]
      args: ["15m"]

We can deploy the pod using this command:

kubectl apply -f hello-manifest.yaml

We can now see that our pod has successful been deployed using get pods.

kubectl get -n hello-namespace pods

Step 3: Shell into your pod

Let’s jump into that pod you just deployed. The command below should look very familiar as it is almost the same as the one we used to shell into your docker container from step 1.

kubectl -n hello-namespace exec -it hello-world /bin/sh

Just like in step 1, let’s run HTTPie.

http https://jsonplaceholder.typicode.com/todos/1

The pod will complete after 15 minutes but we should still clean up and remove it. Use the command below to delete the pod:

kubectl delete -f hello-word.yaml 

Closing thoughts

This tutorial has walked you through how to deploy a kubernetes pod with a docker image you built. The image that we used is really quite basic but you should be able to see that with a little effort, you can use it to deploy any image you are working on. There is more that you need to tinker with if you are going to setup a Web app or service but what we covered in this post is a good first step in that direction.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: