Download K0S - Zero-Friction Kubernetes

k0s is a zero-friction Kubernetes distribution that runs on any Linux-based operating system. It’s great for learning Kubernetes or building high-performance projects on platforms from Raspberry Pis to bare metal datacenters. k0s is distributed as a single binary, installed on any node from the internet with one command, that works like a command-line application. You can call k0s from the command line to start a master (or master+worker) node, then ask the master for code that can be run on further machines to create and add more masters and workers. Note: The instructions below are for installing k0s using an installer script. If you instead prefer to install k0s using the k0sctl utility, you can find instructions here.

Prerequisites

• A laptop or VM with internet access, configured for Kubernetes operations and development. If you haven’t already constructed this, our tutorial How to Build a Kubernetes Development Environment gives a complete recipe.

• Two server VMs, connected to the same local network, accessible via public or private IP addresses, and able to reach the internet, on which to install a k0s manager and a k0s worker node. We recommend Ubuntu 18.04 LTS servers running on AWS or VirtualBox, though the instructions should work for VMs running any popular Linux on any public or private cloud. If you’re not familiar with launching VMs on AWS or building VMs on VirtualBox, our tutorials Launching Virtual Machines on AWS and How to Create a Server on VirtualBox provide all the instructions.

• Servers must be configured for passwordless sudo, and must have curl installed. Instructions for these configuration steps can be found in the tutorial How to Create a Server on VirtualBox.

Hardware Requirements for k0s nodes

• 1 vCPU (2 vCPU recommended)

• 1 GB of RAM (2 GB recommended)

• .5 GB of free disk space for controller nodes. SSD is recommended.

• 1.3 GB of free disk space for worker nodes. SSD is recommended.

• 1.7 GB of free disk space for combined controller/worker nodes. SSD is recommended.

Step 1: Create target servers

Begin by creating your two target machine servers, ensuring they’re configured correctly, that you can SSH to them with your private key, and that your administrative user can issue sudo commands without a password. Also ensure that curl is installed on both machines.

Step 2: Download Assets

Fill out the form below and submit to obtain code to download the k0s installer script. Then SSH to the server you wish to make into a k0s Kubernetes controller, and issue the curl command as shown after form submission. The script downloads the k0s binary, then installs it on your server.

Download K0S installer script

Step 3: Start the controller

From here, all you need to do is start the controller. While you can install it as a single process, for convenience we’ll go ahead and install it as a service set to start every time the machine boots up.

sudo k0s install controller
sudo systemctl start k0scontroller
sudo systemctl enable k0scontroller

Step 4: Accessing the cluster

You can either install kubectl separately or use the version that k0s installs to access the cluster. On installation, k0s writes the KUBECONFIG file to /var/lib/k0s/pki/admin.conf, so let’s copy it to somewhere accessible and set it to be used by kubectl:

mkdir ~/Documents
sudo cp /var/lib/k0s/pki/admin.conf ~/Documents/kubeconfig.cfg
sudo chown $USER ~/Documents/kubeconfig.cfg
export set KUBECONFIG=~/Documents/kubeconfig.cfg

Now, if you look at the existing nodes, you’ll see that there aren’t any:

k0s kubectl get nodes
No resources found

This is because k0s runs all of the controller functions as bare functions, so there is no controller “node”. To run workloads, we’ll have to set up a worker node.

Step 3: Add a worker node

K0s provides two ways to add a worker node. The first is to create one when you create the controller. This essentially turns the controller into a worker node, enabling you to schedule workloads to it. We don’t recommend you do this in production, but it is a simple way to test k0s without needing multiple servers. To start up k0s with a worker node, you can either specify it as a single process:

sudo k0s controller --enable-worker &

Or add it to the service. First we’ll remove the original service:

sudo k0s reset

(Yes, you’re removing the cluster you already created. But this isn’t production, remember?)

sudo k0s install controller --enable-worker
sudo systemctl start k0scontroller

Now you can go ahead and copy the new KUBECONFIG file and again look for the nodes:

sudo cp /var/lib/k0s/pki/admin.conf ~/Documents/kubeconfig.cfg
export set KUBECONFIG=~/Documents/kubeconfig.cfg
k0s kubectl get nodes
NAME              STATUS   ROLES    AGE   VERSION
nick-virtualbox   Ready        2m   v1.20.4-k0s1

As you can see, there’s now a single worker node. For a production environment, you would need to create additional nodes.

Step 4: Add an additional worker

To add an additional worker node, you will need to first create a k0s token. On your original controller, type:

sudo k0s token create --role=worker > k0sworkertoken.txt

(Note that you must have root privileges for this command.) The resulting output is a long string of text that represents a KUBECONFIG that has been encoded using BASE64. To create a new worker node, move the token to the target machine, install k0s, and start the new node, as in:

scp user@serverip:~/k0sworkertoken.txt .
sudo curl -sSLf k0s.sh | sudo sh
sudo k0s install worker --token-file /absoute/path/to/token/file
sudo systemctl start k0sworker

Now you can see the new node from any of the k0s nodes:

K0s kubectl get nodes
NAME              STATUS   ROLES    AGE   VERSION
Nick-virtualbox    Ready       92m   v1.20.4-k0s1
nick-virtualbox2   Ready        2m   v1.20.4-k0s1

You can also add an additional controller node by creating a controller token rather than a worker token, as in:

k0s token create --role=controller > k0scontrollertoken.txt

Then on the target machine:

k0s install controller --token-file /absolute/path/to/token/file
systemctl start k0scontroller

Now let’s look at connecting to Kubernetes from outside the cluster.

Step 5: Make the Kubernetes cluster accessible

You’re not always going to want to connect using the kubectl that comes with k0s, so you’re going to need to do two things:

• Configure the cluster to receive external requests

• Access the KUBECONFIG file

By default, the cluster is configured to receive requests only from inside the cluster. To receive requests directed to an external IP address, you will need to add that address to the k0s configuration and restart the controller. First, generate the configuration file:

k0s default-config > k0s.yaml

From here, add the address on which you want to reach the cluster as an entry under spec/api/sans, as in:

apiVersion: k0s.k0sproject.io/v1beta1
kind: Cluster
metadata:
  name: k0s
spec:
  api:
    externalAddress: my-lb-address.example.com
    address: 192.168.68.106
    sans:
    - 192.168.68.106
    - 52.10.92.152
    extraArgs: {}
  controllerManager:
    extraArgs: {}
  scheduler:
    extraArgs: {}
 ...

To get k0s to pick up the changes, you need to stop the service, install the changes, and start it up again.

k0s stop
k0s reset
k0s install k0s.yaml
k0s start

Now you should be able to access the cluster from anywhere that has access to that IP address.

Step 6: Get the KUBECONFIG file

Once again, when k0s installs, it places the KUBECONFIG file at /var/lib/k0s/pki/admin.conf; to use it, we copied it to a convenient location and point the KUBECONFIG variable at it, as in:

cp /var/lib/k0s/pki/admin.conf ~/kubeconfig.cfg
export KUBECONFIG=~/kubeconfig.cfg

To use it on an external machine, copy it to the target machine with a tool such as scp:

scp nick@192.168.1.193:~/Documents/kubeconfig.cfg .

You’ll also need to change the value of the server to point to the public IP of the Kubernetes cluster. This is the same value you added to k0s.yaml under sans, as in:

apiVersion: v1
clusters:
- cluster:
    server: https://192.168.1.193:6443
...

Now you should be able to access the cluster through kubectl. There’s also a simpler way.

Step 7: Connect to your k0s cluster using Lens

The simplest way to access a Kubernetes cluster is to use the Lens Kubernetes IDE. To access the cluster, first install Lens, then add the cluster as follows: Click the add cluster button along the left-hand side of the window: 

 Select the KUBECONFIG file and the context you want to add (if there’s more than one). 

 Finally, click Add Cluster. 

 You are now ready to work with your new Kubernetes cluster.