Preparing Nodes for kubeadm Installation

Step 1: Understanding and Configuring Node Prerequisites

Before installing any Kubernetes packages, we need to ensure our nodes meet the baseline requirements. The official Kubernetes documentation is the definitive source for these prerequisites.

From the documentation, there are several key requirements. We'll focus on the three that require active configuration on a standard Linux installation (like Ubuntu Server).

A. Disable Swap

Kubernetes is designed to be the single source of truth for resource management on a node. The kubelet needs to control exactly how much CPU and memory is available to Pods. Swap memory on disk introduces unpredictability in performance and complicates resource accounting. Therefore, kubeadm will fail to initialize a cluster if it detects that swap is enabled.

You must disable swap on all nodes.

# Disable swap immediately
sudo swapoff -a

# Comment out the swap line in /etc/fstab to make the change persistent across reboots
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

This is a critical pre-flight check for kubeadm and a common point of failure for beginners.

B. Enable Kernel Modules and Bridged Traffic

For Pods on different nodes to communicate, packets need to be correctly routed through the node's network stack. Kubernetes networking plugins (CNIs) rely on the Linux kernel's ability to pass bridged traffic to iptables for processing. We need to explicitly load the necessary kernel modules and configure sysctl settings to enable this.

Here are the commands to execute on all nodes:

# Load required kernel modules
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

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

# Apply sysctl parameters without a reboot
sudo sysctl --system

Step 2: Install and Configure a Container Runtime

Kubernetes itself doesn't run containers. It delegates that task to a container runtime that complies with the Container Runtime Interface (CRI) standard. While you are familiar with Docker, since Kubernetes v1.24, the direct integration (dockershim) was removed. The recommended approach is to use a CRI-compliant runtime like containerd directly. Your experience with Docker is still highly relevant, as containerd is the underlying runtime used by Docker itself.

Let's watch a video that demonstrates the installation and configuration of containerd.

The most critical part of this step is ensuring the container runtime and the kubelet use the same cgroup driver. Cgroups are a Linux kernel feature for limiting and isolating the resource usage of a process group. A mismatch here will prevent the kubelet from starting correctly. The modern standard is the systemd cgroup driver.

Here's how to install containerd and configure it:

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

# 2. Create a default configuration file
sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml

# 3. Set the cgroup driver to systemd
# This command uses sed to find and replace the `SystemdCgroup` setting.
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

# 4. Restart containerd to apply the changes
sudo systemctl restart containerd

Step 3: Install Kubernetes Packages

With the prerequisites and container runtime in place, we can now install the three essential Kubernetes tools on every node:

• kubelet: The agent that runs on each node and communicates with the control plane. It's responsible for managing the lifecycle of Pods on its node.
• kubeadm: The command-line tool used to bootstrap a cluster, join nodes, and manage upgrades.
• kubectl: The command-line tool you will use to interact with your cluster's API server.

We will follow the official installation guide to add the new Kubernetes package repositories (pkgs.k8s.io).

Here is the consolidated sequence of commands based on the official documentation:

# 1. Update apt and install prerequisite packages
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

# 2. Download the public signing key for the Kubernetes package repositories
# The directory /etc/apt/keyrings might not exist by default, so we create it.
sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

# 3. Add the Kubernetes apt repository
# This example is for Kubernetes v1.30. For a different version, change v1.30 in the URL.
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

# 4. Update apt package index and install kubelet, kubeadm, and kubectl
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl

# 5. Pin the versions to prevent unwanted upgrades
sudo apt-mark hold kubelet kubeadm kubectl

The apt-mark hold command is particularly important. Kubernetes cluster upgrades are a deliberate process that must be managed carefully. Holding the packages prevents the system's package manager from automatically upgrading a component, which could cause version-skew issues and destabilize your cluster.

Conclusion

Excellent work. You have now completed the foundational setup for every node in our future cluster. While it seems like a lot of command-line work, understanding each step is vital for troubleshooting and for your CKA exam preparation, where you'll be expected to work efficiently in a terminal.

Let's summarize the key preparations you performed on each node:

• System Configuration: You disabled swap memory to ensure predictable resource management by the kubelet.
• Kernel Configuration: You enabled the overlay and br_netfilter modules and configured sysctl to allow container network traffic to be processed correctly.
• Container Runtime: You installed containerd and critically configured it to use the systemd cgroup driver, ensuring compatibility with the kubelet.
• Kubernetes Tooling: You installed kubelet, kubeadm, and kubectl from the official Kubernetes package repositories and placed a hold on them to prevent automatic upgrades.

Your nodes are now primed and ready. In our next lesson, we will use kubeadm init on one of these nodes to bootstrap the control plane, bringing your Kubernetes cluster to life. We will then install a Pod network add-on, which is essential for cluster networking.