# Unlocking Kubernetes Mastery with Kubeadm and Calico

Welcome to the world of Kubernetes, often referred to as k8s, where containerized applications meet orchestration excellence. In this guide, we'll embark on a journey to master Kubernetes using Kubeadm and Calico, ensuring your containerized applications thrive in a dynamic and scalable environment.

## Prerequisites:

Before we dive into the exciting world of Kubernetes, make sure you have the following prerequisites in place:

**Hardware Requirements:**

Prepare for Kubernetes mastery by ensuring you have a minimum of two nodes. Each node should meet these hardware specs:

* Minimum of 2GB of RAM
    
* Minimum of 2 CPU cores
    

**Software Requirements:**

Your chosen nodes should be running a Linux distribution that plays well with Kubernetes. For our journey, we recommend Ubuntu 20.04. Additionally, you'll need to equip each node with Docker.

**Network Requirements:**

Ensure your nodes can communicate seamlessly with each other over a network. A reliable network connection between the nodes is crucial for a successful Kubernetes journey.

## Installation of Kubeadm and Calico: Step By Step

### **Step 1: Setting the Stage with Hostnames**

Let's begin by configuring hostnames to ensure smooth communication between nodes. Open the `/etc/hosts` file on each node using the following command:

```bash
sudo nano /etc/hosts
```

This opens the file in the nano text editor. Append the following lines to the end of the file, replacing the IP addresses with your node's IP addresses:

```bash
10.0.0.2        master-node
10.0.0.3        worker-node1
10.0.0.4        worker-node2
```

Save and close the file.

### **Step 2: Skipping Swap Memory Tweaks**

If you're running your Kubernetes cluster on a cloud VM service like a pro, you can skip this step. Kubernetes will work harmoniously with the memory configurations provided by your cloud provider.

```plaintext
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
```

### **Step 3: Crafting the IPV4 Bridge on All Nodes**

To establish the IPV4 bridge across all nodes, execute the following commands on each node:

```bash
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# Sysctl parameters required by the setup; these persist through reboots
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 reboot
sudo sysctl --system
```

These commands set up the necessary network bridge and kernel parameters, orchestrating Kubernetes in harmony.

### **Step 4: Updating the Repository and Securing Required Packages**

Prepare your nodes by updating the package repository and securing essential packages with these commands:

```bash
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```

### **Step 5: Grasping the Google Cloud Public Signing Key**

Secure the Google Cloud public signing key with these commands:

```bash
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```

### **Step 6: Adding the Kubernetes APT Repository**

Add the Kubernetes APT repository with this command:

```bash
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
```

### **Step 7: Revving Up the Repo & Deploying kubelet, kubeadm, kubectl, and** [**docker.io**](http://docker.io)

Prepare to deploy Kubernetes and Docker on all nodes with these commands:

```bash
sudo apt-get update
sudo apt install -y kubelet=1.28.1-1.1 kubeadm=1.28.1-1.1 kubectl=1.28.1-1.1 docker.io
sudo apt-mark hold kubelet kubeadm kubectl docker.io
```

This crafts the right environment and ensures that Kubernetes packages remain stable.

### **Step 8: Orchestrating Containerd Configurations on All Nodes**

Create a containerd directory and configure container runtime settings with these commands:

```bash
sudo mkdir /etc/containerd
sudo sh -c "containerd config default > /etc/containerd/config.toml"
```

Now, it's time for some fine-tuning. Edit the `config.toml` file and locate the entry setting `SystemdCgroup` to false. Switch it to true, save the file, and restart containerd with these commands:

```bash
sudo sed -i 's/            SystemdCgroup = false/            SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd.service
sudo systemctl restart kubelet.service
sudo systemctl enable kubelet.service
```

Note that these commands must be executed as root on all nodes in your Kubernetes orchestra.

### **Step 9: Initiating Kubeadm Magic**

On the master node, invoke the magic wand to initialize the Kubernetes control plane:

```bash
sudo kubeadm init --pod-network-cidr=10.10.0.0/16
```

### **Step 10: Copying Configuration to User's Realm**

On the master node, transfer the configuration to the user's realm with these commands:

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

This sets the stage for user interaction with the Kubernetes cluster.

### **Step 11: Crafting the Calico Network**

After the Kubeadm initiation, it's time to weave the Calico network for seamless pod-to-pod communication. Execute these commands on the master node:

```bash
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/tigera-operator.yaml
curl https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/custom-resources.yaml -O
sed -i 's/cidr: 192\.168\.0\.0\/16/cidr: 10.10.0.0\/16/g' custom-resources.yaml
kubectl create -f custom-resources.yaml
```

### **Step 12: Welcoming Worker Nodes**

With the master node all set, it's time to welcome the worker nodes into the Kubernetes party. During the Kubeadm initialization on the master node, you'll receive a token to invite worker nodes: