Kubernetes On Ubuntu VirtualBox: A Quick Setup Guide

Nov 3, 2025 by Team 53 views

Hey guys! Ever wanted to dive into the world of Kubernetes but felt a bit intimidated? Well, you're in the right place! This guide will walk you through setting up a Kubernetes cluster on Ubuntu using VirtualBox. It's a fantastic way to get hands-on experience without messing with your production environment. So, grab your favorite beverage, and let's get started!

Why Kubernetes and VirtualBox?

Before we jump into the how-to, let's quickly touch on why these two technologies are a great combo. Kubernetes, often abbreviated as K8s, is an open-source container orchestration system that automates the deployment, scaling, and management of containerized applications. Think of it as the conductor of an orchestra, ensuring all the instruments (containers) play together harmoniously. VirtualBox, on the other hand, is a powerful virtualization tool that allows you to run multiple operating systems on a single physical machine. This means you can create a virtual environment for your Kubernetes cluster without needing extra hardware. Using VirtualBox provides a safe and isolated environment for experimenting with Kubernetes. You can easily create, destroy, and recreate your cluster without affecting your host system. This is particularly useful for learning and testing new configurations. Furthermore, VirtualBox is free and open-source, making it an accessible option for anyone looking to get started with Kubernetes. Setting up a Kubernetes cluster locally using VirtualBox is an excellent way to learn and experiment with Kubernetes concepts and features. You can deploy and manage applications, test different configurations, and troubleshoot issues in a controlled environment. It's also a cost-effective solution for small-scale deployments and development environments. Plus, it's a great way to understand the underlying infrastructure requirements of Kubernetes before deploying it to a production environment.

Prerequisites

Before we start, make sure you have the following:

VirtualBox: Download and install the latest version from the VirtualBox website.
Ubuntu ISO: Grab the latest Ubuntu Server ISO image from the Ubuntu website.
Basic Linux knowledge: Familiarity with the command line is essential.
A computer: With enough RAM (8GB or more recommended) and CPU cores (at least 2).

Step-by-Step Guide

1. Create Ubuntu Virtual Machines

First, we'll create three Ubuntu VMs: one for the Kubernetes master node and two for the worker nodes. The master node is the brain of the cluster, while the worker nodes are where your applications will actually run. Open VirtualBox and follow these steps for each VM:

Click "New" to create a new virtual machine.
Give it a name (e.g., k8s-master, k8s-worker-1, k8s-worker-2).
Select "Linux" as the type and "Ubuntu (64-bit)" as the version.
Allocate at least 2GB of RAM (more is better!).
Create a virtual hard disk (VDI) with at least 20GB of storage.
Choose "Dynamically allocated" for the storage type.

For each VM, configure the network settings:

Go to Settings -> Network.
For Adapter 1, select "Attached to: NAT". This will allow the VMs to access the internet.
For Adapter 2, enable it and select "Attached to: Host-only Adapter". This will allow the VMs to communicate with each other.

Important: Make sure to create a Host-only Network if you don't have one already. Go to VirtualBox -> Preferences -> Network -> Host-only Networks and click the "+" button.

2. Install Ubuntu on Each VM

Now, let's install Ubuntu on each VM. Select the VM, click "Start," and choose the Ubuntu ISO image you downloaded. Follow the on-screen instructions to install Ubuntu. During the installation, make sure to:

Create a user account.
Configure the network with a static IP address. This is crucial for the Kubernetes cluster to function correctly. Edit /etc/netplan/01-network-manager-all.yaml and configure static IPs for the enp0s8 interface (the Host-only Adapter). For example:
```
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
      dhcp4: yes
    enp0s8:
      dhcp4: no
      addresses: ["192.168.56.101/24"]
      gateway4: 192.168.56.1
      nameservers:
        addresses: ["8.8.8.8", "8.8.4.4"]
```
Replace 192.168.56.101 with a unique IP address for each VM (e.g., 192.168.56.101 for the master, 192.168.56.102 for worker 1, 192.168.56.103 for worker 2). Ensure the gateway matches your Host-Only network adapter's IP (typically 192.168.56.1). After editing the file, apply the changes by running sudo netplan apply.
Install the SSH server. This will allow you to connect to the VMs remotely.
```
sudo apt update
sudo apt install openssh-server
```

3. Prepare the Hosts

After installing Ubuntu on all VMs, SSH into each of them. You can use ssh <username>@<ip_address>, replacing <username> with your Ubuntu username and <ip_address> with the static IP you assigned. Once connected, perform the following steps on all VMs:

Update the package index:
```
sudo apt update
```
Upgrade installed packages:
```
sudo apt upgrade -y
```
Disable swap: Kubernetes requires swap to be disabled. To disable it temporarily, run:
```
sudo swapoff -a
```
To disable it permanently, comment out the swap line in /etc/fstab:
```
sudo nano /etc/fstab
```
Comment out the line that starts with /swapfile by adding a # at the beginning.
Install container runtime (Docker): While Kubernetes is moving away from Docker as the only container runtime, it's still a very common and well-supported option. Let's install Docker:
```
sudo apt install docker.io -y
sudo systemctl enable docker
sudo systemctl start docker
```

Configure Docker:

sudo mkdir /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
sudo systemctl restart docker

Install kubeadm, kubelet, and kubectl: These are the essential Kubernetes command-line tools.

sudo apt update
sudo apt install -y apt-transport-https ca-certificates 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 -a /etc/apt/sources.list.d/kubernetes.list
sudo apt update
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

4. Initialize the Kubernetes Master Node

Now, it's time to initialize the Kubernetes master node. SSH into the k8s-master VM and run the following command:

sudo kubeadm init --pod-network-cidr=192.168.0.0/16 --apiserver-advertise-address=<master_ip>

Replace <master_ip> with the static IP address of your master node (e.g., 192.168.56.101).

Important: The --pod-network-cidr specifies the IP address range that will be used for pods in your cluster. Choose a range that doesn't conflict with your existing network. The kubeadm init command will output a kubeadm join command. Save this command! You'll need it to join the worker nodes to the cluster.

After the initialization is complete, follow the instructions to configure kubectl for your user:

mkdir -p $HOME/.kube
sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

5. Deploy a Pod Network

Kubernetes requires a pod network to enable communication between pods. We'll use Calico, a popular and flexible networking solution. Run the following command on the master node:

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

6. Join the Worker Nodes

SSH into each worker node (k8s-worker-1 and k8s-worker-2) and run the kubeadm join command that you saved from the master node initialization. It should look something like this:

sudo kubeadm join <master_ip>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>

Replace <master_ip>, <token>, and <hash> with the values from the output of the kubeadm init command.

7. Verify the Cluster

Back on the master node, run the following command to verify that the worker nodes have joined the cluster:

kubectl get nodes

You should see all three nodes listed, with their status as "Ready."

Congratulations!

You've successfully set up a Kubernetes cluster on Ubuntu using VirtualBox! Now you can start deploying applications and exploring the world of container orchestration. To deploy a simple application, try this:

kubectl create deployment nginx --image nginx
kubectl expose deployment nginx --port 80 --type NodePort
kubectl get service nginx

This will deploy a simple Nginx web server. You can access it by visiting the IP address of any of your worker nodes in a web browser, using the NodePort that kubectl get service nginx outputs. For example, if kubectl get service nginx outputs a NodePort of 30000, and your worker node's IP address is 192.168.56.102, you would visit http://192.168.56.102:30000 in your browser.

Troubleshooting

If you encounter any issues, here are a few things to check:

Network connectivity: Make sure the VMs can communicate with each other. Ping each VM from the others using their static IP addresses.
Firewall: Ensure that the firewall is not blocking traffic between the nodes. Disable the firewall for testing purposes.
Kubelet status: Check the status of the kubelet service on each node using sudo systemctl status kubelet.
Logs: Examine the logs for the kubelet, kubeadm, and kubectl commands for any errors.

Further Exploration

This is just the beginning! Here are some things you can explore next:

Kubernetes Dashboard: Deploy the Kubernetes Dashboard for a graphical interface to manage your cluster.
Helm: Use Helm, a package manager for Kubernetes, to easily deploy and manage applications.
Ingress: Configure Ingress to expose your applications to the outside world.
Persistent Volumes: Learn about Persistent Volumes for persistent storage in your cluster.

Setting up a Kubernetes cluster can seem daunting at first, but with a little practice, you'll be orchestrating containers like a pro in no time. Enjoy the journey, and happy Kubernetes-ing!