Demo Deployment With Kubeadm

This guide demonstrates how to bootstrap a single-control-plane Kubernetes cluster with kubeadm. The example environment uses three Vagrant virtual machines:

Node	Hostname	Interface	IP address
Control plane	kubemaster	enp0s8	`192.168.56.11`
Worker node 1	kube-node-1	enp0s8	`192.168.56.21`
Worker node 2	kube-node-2	enp0s8	`192.168.56.22`

We use the enp0s8 interface for inter-node cluster traffic. Example condensed outputs for the enp0s8 interface (shown here for reference):

# On the master
vagrant@kubemaster:~$ ip addr show enp0s8
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 08:00:27:d9:69:94 brd ff:ff:ff:ff:ff:ff
    inet 192.168.56.11/24 brd 192.168.56.255 scope global enp0s8
       valid_lft forever preferred_lft forever

# On node-1
vagrant@kubenode01:~$ ip addr show enp0s8
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 ...
    inet 192.168.56.21/24 brd 192.168.56.255 scope global enp0s8

# On node-2
vagrant@kubenode02:~$ ip addr show enp0s8
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 ...
    inet 192.168.56.22/24 brd 192.168.56.255 scope global enp0s8

Before you begin, consult the official kubeadm documentation and choose a Kubernetes version (the examples below use v1.31):

Installing kubeadm

A screenshot of the Kubernetes documentation page for "Installing kubeadm," showing the left navigation menu and the main content with prerequisites and version links. The top banner advertises KubeCon + CloudNativeCon 2024.

Creating a cluster with kubeadm (for single control plane; see the HA guide below for multi-control-plane)
- Creating Highly Available Clusters with kubeadm

A screenshot of the Kubernetes documentation webpage titled "Creating a cluster with kubeadm," showing navigation links on the left and detailed instructions in the main content area. A blue header promotes KubeCon + CloudNativeCon 2024 at the top.

High-level flow:

Install kubeadm, kubelet, and kubectl on all nodes.
Install and configure a container runtime (containerd in this demo).
Ensure cgroup driver alignment between kubelet and container runtime.
Initialize the control plane on the master with kubeadm.
Install a Pod network (CNI) — Flannel in this example.
Join worker nodes to the cluster.
Validate cluster and run a test pod.

Step-by-step instructions with commands:

1) Install kubeadm, kubelet and kubectl on all nodes

Run the following on all three machines (control plane + both workers). This example targets Kubernetes v1.31:

# Prepare system and install prerequisites
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gnupg

# Create keyrings dir
sudo mkdir -p -m 755 /etc/apt/keyrings

# Add Kubernetes signing key (v1.31)
curl -fsS https://pkgs.k8s.io/core:/stable:/v1.31/deb/Release.key \
  | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

# Add Kubernetes apt repository
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.31/deb/ /' \
  | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Update and install kubelet, kubeadm, kubectl
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl

# Lock packages to prevent unintended upgrades
sudo apt-mark hold kubelet kubeadm kubectl

# Enable kubelet
sudo systemctl enable --now kubelet

kubeadm requires swap to be disabled. Disable swap immediately and make the change persistent by removing or commenting out swap entries in /etc/fstab before running kubeadm init or kubeadm join.

# Disable swap now
sudo swapoff -a

# Make persistent (example)
sudo sed -i.bak '/ swap / s/^/#/' /etc/fstab

2) Install and configure a container runtime (containerd)

Kubernetes needs a CRI-compatible container runtime. This demo uses containerd.

Container runtime docs: Container runtimes

A screenshot of the Kubernetes documentation page titled "Container Runtimes," showing the main article text and links, a left-hand navigation menu, and a blue KubeCon banner across the top.

Install and enable containerd, and configure networking sysctl values required by Kubernetes:

# Install containerd
sudo apt-get update
sudo apt-get install -y containerd

# Enable containerd
sudo systemctl enable --now containerd

# Required kernel settings for Kubernetes networking
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
sudo sysctl --system

3) Ensure cgroup driver alignment

For modern Debian/Ubuntu systems using systemd, kubelet and containerd should both use the systemd cgroup driver. Check the init system and configure containerd accordingly.

Cgroup driver considerations: Cgroup driver considerations

Verify the init system:

ps -p 1 -o comm=
# Expected: systemd

Generate containerd config and enable systemd cgroups:

sudo mkdir -p /etc/containerd
containerd config default \
  | sed 's/SystemdCgroup = false/SystemdCgroup = true/' \
  | sudo tee /etc/containerd/config.toml

sudo systemctl restart containerd

# Confirm setting
sudo grep -i SystemdCgroup -n /etc/containerd/config.toml
# Expected match: SystemdCgroup = true

4) Initialize the control plane with kubeadm

On the master node, run kubeadm init. Choose the API server advertise address (the master IP on the cluster network) and a pod network CIDR that matches your chosen CNI (Flannel typically uses 10.244.0.0/16). Example:

sudo kubeadm init \
  --apiserver-advertise-address 192.168.56.11 \
  --pod-network-cidr "10.244.0.0/16" \
  --upload-certs

kubeadm will perform preflight checks, fetch images, create certificates and static pod manifests, and print next steps including:

How to configure your local kubeconfig.
The kubeadm join command for worker nodes (with token and discovery hash).
(If --upload-certs was used) a certificate key for sharing control-plane certs.

After init completes, configure local kubeconfig:

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

# Verify the control plane node appears (NotReady until CNI is installed)
kubectl get nodes

Example important excerpt printed by kubeadm (condensed):

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, run as a regular user:
  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster. Then join worker nodes with the command printed below.

Example kubeadm join command:
kubeadm join 192.168.56.11:6443 --token <token> \
    --discovery-token-ca-cert-hash sha256:<hash>

5) Install a Pod network (CNI) — Flannel example

Pick a CNI that supports your pod CIDR. For a default Flannel setup with 10.244.0.0/16:

# Download and apply the flannel manifest
wget https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
kubectl apply -f kube-flannel.yml

Applying the manifest creates namespace, RBAC, configmap and a DaemonSet:

namespace/kube-flannel created
serviceaccount/flannel created
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds created

Verify CNI and system pods, and wait for nodes to become Ready:

kubectl get pods -n kube-flannel
kubectl get pods -n kube-system
kubectl get nodes

Expected result (example):

kubemaster   Ready    control-plane   18m   v1.31.1
kube-node-1  Ready    <none>          3m    v1.31.1
kube-node-2  Ready    <none>          2m    v1.31.1

6) Join worker nodes to the cluster

On each worker node, run the kubeadm join command that was printed by kubeadm init. If you lost it, you can create a new token or retrieve join info from the master:

# Example join (run on worker nodes)
sudo kubeadm join 192.168.56.11:6443 --token <token> \
  --discovery-token-ca-cert-hash sha256:<hash>

If you need to create a new token on the master:

# Create a new token and display join command
kubeadm token create --print-join-command

After joining, verify on the master:

kubectl get nodes
kubectl get pods -n kube-flannel

You should see flannel pods scheduled on the worker nodes:

# Example
# NAME                       READY   STATUS    RESTARTS   AGE
# kube-flannel-ds-xxxxx      1/1     Running   0          3m
# kube-flannel-ds-yyyyy      1/1     Running   0          2m

7) Test the cluster by running a simple Pod

Run an example Pod to confirm workload scheduling and networking:

kubectl run web --image=nginx --restart=Never
kubectl get pod web
# If troubleshooting:
kubectl describe pod web
kubectl logs pod/web

The pod should reach the Running state if networking and node readiness are correct.

Quick reference table: common commands

Action	Command
Disable swap	`sudo swapoff -a`
Install kubeadm/kubelet/kubectl	See install block above
Configure containerd for systemd cgroups	`containerd config default \| sed 's/SystemdCgroup = false/SystemdCgroup = true/' \| sudo tee /etc/containerd/config.toml`
Initialize control plane	`sudo kubeadm init --apiserver-advertise-address <MASTER_IP> --pod-network-cidr "<CIDR>" --upload-certs`
Apply Flannel CNI	`kubectl apply -f kube-flannel.yml`
Create join command	`kubeadm token create --print-join-command`

Tips:

If you plan to migrate from a single-control-plane to an HA setup later, pass --control-plane-endpoint to kubeadm init to reference a stable virtual IP or load balancer.
For K8s >= 1.22 kubeadm defaults to systemd cgroup driver; ensure your container runtime is configured accordingly (e.g., containerd with SystemdCgroup = true).
If kubeadm cannot find your CRI socket, use --cri-socket (e.g., unix:///var/run/containerd/containerd.sock) to point explicitly to the runtime.

This completes the kubeadm bootstrap flow: you now have a single-control-plane Kubernetes cluster with two worker nodes running Flannel as the CNI. For production or HA setups, consult the kubeadm HA guide and the Kubernetes official docs linked above.

Introduction

Core Concepts

Scheduling

Logging & Monitoring

Application Lifecycle Management

Cluster Maintenance

Security

Storage

Networking

Design and Install a Kubernetes Cluster

Install "Kubernetes the kubeadm way"

Troubleshooting

Helm Basics (2025 Updates)

Kustomize Basics (2025 Updates)

Other Topics

Mock Exams

Demo Deployment With Kubeadm

1) Install kubeadm, kubelet and kubectl on all nodes

2) Install and configure a container runtime (containerd)

3) Ensure cgroup driver alignment

4) Initialize the control plane with kubeadm

5) Install a Pod network (CNI) — Flannel example

6) Join worker nodes to the cluster

7) Test the cluster by running a simple Pod

Quick reference table: common commands

Watch Video

Practice Lab

​1) Install kubeadm, kubelet and kubectl on all nodes

​2) Install and configure a container runtime (containerd)

​3) Ensure cgroup driver alignment

​4) Initialize the control plane with kubeadm

​5) Install a Pod network (CNI) — Flannel example

​6) Join worker nodes to the cluster

​7) Test the cluster by running a simple Pod

​Quick reference table: common commands

Watch Video

Practice Lab

1) Install kubeadm, kubelet and kubectl on all nodes

2) Install and configure a container runtime (containerd)

3) Ensure cgroup driver alignment

4) Initialize the control plane with kubeadm

5) Install a Pod network (CNI) — Flannel example

6) Join worker nodes to the cluster

7) Test the cluster by running a simple Pod

Quick reference table: common commands