How to Create a Single Node Kubernetes Cluster: A Complete Beginner’s Guide

Kubernetes is widely used to manage containerized applications across multi-node and large clusters. However, you do not really need an entire fleet of machines to get started. A single node Kubernetes helps you to run the entire Kubernetes control panel and worker node on just a single machine, which makes it ideal for learning, development, and testing. 

Whether you are a developer experimenting with container orchestration or looking to build a reliable Kubernetes environment without the complexity, a single node Kubeenetes cluster is your answer. 

In this guide, we will learn what a single node Kubernetes cluster is and how to create one for yourself with popular tools like Minikube, Kind, and kubeadm. 

Benefits and Limitations of Single Node Kubernetes Clusters

Just like everything else, single node Kubernetes comes with its own set of benefits and limitations. 

Benefits:

• A single node Kubernetes is super easy to set up since it only requires one machine, which makes installation quick and easy. 
• It creates an excellent learning environment to experiment with Kubernetes concepts, YAML files, and deployments without a full cluster. 
• It consumes fewer resources than multi-node clusters and can run on both local setups and virtual machines. 
• It has a faster development cycle since changes can be tested instantly. 

Limitations:

• All services, such as control planes and workloads run on the same machine, so if one goes down, the entire cluster collapses.
• It is not suitable for production and it lacks redundancy, scalability, and fault tolerance. 
• It is limited in the capacity because of it being a single machine. 
• It does not fully replicate the behavior of distributed clusters, which can affect how the network-dependent workloads behave.

Prerequisites for Setting Up a Single Node Kubernetes Cluster

Before creating a single node cluster, make sure you have the following in place:

Operating System

• Linux (Ubuntu, CentOS, Debian), macOS, or Windows (with WSL2)
• For kubeadm, a Linux-based OS is recommended.

Hardware Requirements

• Minimum 2 CPUs (4 recommended)
• At least 4 GB of RAM (8+ GB preferred)
• 10–20 GB of free disk space

Software Requirements

• Minikube: Docker or a hypervisor (VirtualBox, KVM, Hyper-V, etc.)
• Kind: Docker installed and running. 
• Kubeadm: Linux VM or server with root access, container runtime (like containerd), kubeadm, kubelet, and kubectl

Internet Connection

• Required to pull container images and install dependencies during setup.

User Permissions

• You should have root or sudo access to install packages and configure system services.

Related Article: What is Kubernetes RBAC: Roles, Permissions, and Policies Simplified

Methods to Create a Single Node Kubernetes Cluster

There are multiple methods to run a single node Kubernetes cluster, where each one of them is customized for a specific use case. However, some of the most widely used tools are: 

1. Using Minikube

Minikube is a popular lightweight tool that can create a local single node Kubernetes cluster with either a virtual machine or a container driver. It is designed for the local development environment and is the best choice for beginners due to its simple nature.  

2. Using Kind (Kubernetes in Docker)

Kind runs single node Kubernetes clusters in Docker containers to test platform behaviour in CI environments or in systems where it is not practical to install virtual machines. 

3. Using kubeadm

kubeadm is a command-line tool by Kubernetes to bootstrap clusters. It is more of a production-like environment and it gives you deeper control, though it requires manual configuration. You typically use it on bare-metal or virtual Linux machines. 

Step-by-Step Guide: Create a Single Node Kubernetes Cluster with Minikube

Prerequisites:

• Docker or a hypervisor (e.g., VirtualBox, Hyper-V)
• kubectl installed
• Minikube installed:
  curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo install minikube-linux-amd64 /usr/local/bin/minikube

Steps:

1. Start the cluster

minikube start

2. Verify the status

minikube status

3. Access the dashboard (optional)

minikube dashboard

4. Deploy a sample app

kubectl create deployment hello-minikube –image=kicbase/echo-server:1.0

kubectl expose deployment hello-minikube –type=NodePort –port=8080

minikube service hello-minikube

Step-by-Step Guide: Create a Single Node Cluster with Kind

Prerequisites:

• Docker installed
• Kind installed:
  GO111MODULE=”on” go install sigs.k8s.io/[email protected]

Steps:

1. Create a configuration file (optional):

kind: Cluster

apiVersion: kind.x-k8s.io/v1alpha4

nodes:

  – role: control-plane

2. Create the cluster:

kind create cluster –name kind-single-node –config kind-config.yaml

3. Verify the cluster:

kubectl cluster-info –context kind-kind-single-node

4. Deploy a sample app:

kubectl create deployment nginx –image=nginx

kubectl expose deployment nginx –port=80 –type=NodePort

Step-by-Step Guide: Create a Single Node Cluster with kubeadm

Prerequisites:

• A clean Linux VM or server (Ubuntu 20.04+ recommended)
• Root/sudo access
• Swap disabled and required ports open

Steps:

1. Install dependencies:

sudo apt update && sudo apt install -y apt-transport-https curl

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add –

echo “deb https://apt.kubernetes.io/ kubernetes-xenial main” | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update

sudo apt install -y kubelet kubeadm kubectl

sudo apt-mark hold kubelet kubeadm kubectl

2. Install a container runtime (e.g., containerd):

sudo apt install -y containerd

sudo systemctl enable containerd

sudo systemctl start containerd

3. Disable swap:

sudo swapoff -a

sudo sed -i ‘/ swap / s/^/#/’ /etc/fstab

4. Initialize the cluster:

sudo kubeadm init –pod-network-cidr=192.168.0.0/16

5. Set up kubeconfig for your user:

mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

6. Install a network add-on (e.g., Calico):

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

7. (Optional) Allow scheduling on the control-plane node:

kubectl taint nodes –all node-role.kubernetes.io/control-plane-

Managing and Accessing Your Single Node Kubernetes Cluster

Once your single node Kubernetes cluster is ready, you can interact with it using the platform’s command-line tool, kubectl. This allows you to deploy applications, view logs, inspect resources, and apply configurations using these commands: 

• View cluster status:

kubectl cluster-info

• List all nodes:

kubectl get nodes

• View all running pods:

kubectl get pods -A

• Apply configurations:

kubectl apply -f your-config.yaml

• Monitor logs:

kubectl logs <pod-name>

You can also just install the Kubernetes Dashboard or use tools such as Lens Kubernetes for a more visual interface. Just keep in mind that in single node Kubernetes, you are essentially just using the same machine for all elements, so monitor your resources closely. 

Converting a Single Node Kubernetes to a Multi-Node Cluster

While using a single node Kubernetes is great for testing and local environments, you ,ight want to upgrade to a multi-node cluster to add one or more worker nodes to the control-plane node. If you are using the native command-line tool, here is how you can do it: 

1. Prepare the new node(s) with the same setup configurations as your control plane (container runtime, kubelet, kubeadm, etc.).
2. On the control plane, join the command: kubeadm token create –print-join-command
3. Run the join command on the new node(s) to connect them to the cluster.
4. Verify the new nodes: kubectl get nodes

Converting to a multi-node cluster provides better fault tolerance and resource scalability, making it a critical step toward a production-ready setup.

Conclusion

Creating a single node Kubernetes cluster is a super simple yet powerful method to explore containers and test environments without making things complicated. While single node Kubernetes clusters are not ideal for production, they are best suited for learning the fundamentals. 

FAQs