Installing Kubernetes

---

1 - Installation options

There are several ways to install Kubernetes depending on your needs:

Solution	Usage	Advantages	Drawbacks
Minikube	Local dev	Easy, multi-driver	Single-node
Kind	CI/CD, tests	Fast, multi-node	Not for prod
kubeadm	Production	Flexible, official	Complex
k3s	Edge, IoT	Lightweight	Fewer features
EKS/AKS/GKE	Cloud	Managed, HA	Cost, vendor lock-in

---

2 - Installing kubectl

kubectl is the command-line tool for interacting with Kubernetes.

2.1 Installation on Linux

# Télécharger la dernière version
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

# Rendre exécutable et déplacer
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

# Vérifier l'installation
kubectl version --client

2.2 Installation on macOS

# Avec Homebrew
brew install kubectl

# Ou téléchargement direct
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl"

2.3 Installation on Windows

# Avec Chocolatey
choco install kubernetes-cli

# Ou téléchargement direct
curl -LO "https://dl.k8s.io/release/v1.28.0/bin/windows/amd64/kubectl.exe"

2.4 Configuring autocompletion

# Bash
echo 'source <(kubectl completion bash)' >> ~/.bashrc
echo 'alias k=kubectl' >> ~/.bashrc
echo 'complete -o default -F __start_kubectl k' >> ~/.bashrc
source ~/.bashrc

# Zsh
echo 'source <(kubectl completion zsh)' >> ~/.zshrc
source ~/.zshrc

---

3 - Minikube

Minikube creates a single-node Kubernetes cluster on your local machine.

3.1 Installation

# Linux
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# macOS
brew install minikube

# Windows
choco install minikube

3.2 Available drivers

3.3 Start a cluster

# Démarrer avec le driver Docker (recommandé)
minikube start --driver=docker

# Avec des ressources personnalisées
minikube start --driver=docker --cpus=4 --memory=8192 --disk-size=50g

# Avec une version spécifique de Kubernetes
minikube start --kubernetes-version=v1.28.0

# Vérifier le status
minikube status

# Output attendu :
# minikube
# type: Control Plane
# host: Running
# kubelet: Running
# apiserver: Running
# kubeconfig: Configured

3.4 Useful Minikube commands

# Accéder au dashboard
minikube dashboard

# Obtenir l'IP du cluster
minikube ip

# SSH dans le node
minikube ssh

# Exposer un service via tunnel
minikube tunnel

# Arrêter le cluster
minikube stop

# Supprimer le cluster
minikube delete

# Créer un cluster multi-node
minikube start --nodes 3

3.5 Minikube add-ons

# Lister les add-ons disponibles
minikube addons list

# Activer des add-ons
minikube addons enable ingress
minikube addons enable metrics-server
minikube addons enable dashboard

# Désactiver un add-on
minikube addons disable dashboard

---

4 - Kind (Kubernetes IN Docker)

Kind runs Kubernetes clusters inside Docker containers.

4.1 Installation

# Linux / macOS
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# macOS avec Homebrew
brew install kind

# Windows
choco install kind

4.2 Create a simple cluster

# Cluster par défaut (1 node)
kind create cluster

# Cluster nommé
kind create cluster --name mon-cluster

# Vérifier
kind get clusters
kubectl cluster-info --context kind-mon-cluster

4.3 Multi-node cluster

# kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    kubeadmConfigPatches:
    - |
      kind: InitConfiguration
      nodeRegistration:
        kubeletExtraArgs:
          node-labels: "ingress-ready=true"
    extraPortMappings:
    - containerPort: 80
      hostPort: 80
      protocol: TCP
    - containerPort: 443
      hostPort: 443
      protocol: TCP
  - role: worker
  - role: worker
  - role: worker

# Créer le cluster avec la configuration
kind create cluster --config kind-config.yaml --name prod-like

# Vérifier les nodes
kubectl get nodes

4.4 Load local images

# Construire une image locale
docker build -t mon-app:v1 .

# Charger l'image dans Kind
kind load docker-image mon-app:v1 --name mon-cluster

# Utiliser l'image dans un déploiement
kubectl create deployment mon-app --image=mon-app:v1

4.5 Delete a cluster

# Supprimer un cluster spécifique
kind delete cluster --name mon-cluster

# Supprimer tous les clusters
kind delete clusters --all

---

5 - kubeadm

kubeadm is the official tool for creating production Kubernetes clusters.

5.1 Prerequisites

5.2 Preparing the nodes (on all nodes)

# Désactiver le swap
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

# Charger les modules kernel nécessaires
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# Paramètres sysctl requis
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

sudo sysctl --system

5.3 Install containerd

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

# Configurer containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml

# Activer systemd cgroup driver
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

# Redémarrer containerd
sudo systemctl restart containerd
sudo systemctl enable containerd

5.4 Install kubeadm, kubelet, and kubectl

# Ajouter le repo Kubernetes
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

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

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

# Installer les composants
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

5.5 Initialize the Control Plane

# Sur le node master
sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=<IP_MASTER>

# Configurer kubectl pour l'utilisateur courant
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# Installer le plugin réseau (Calico)
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.0/manifests/calico.yaml

# Ou Flannel
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

5.6 Join the Worker Nodes

# La commande join est affichée après kubeadm init
# Exécuter sur chaque worker node :
sudo kubeadm join <MASTER_IP>:6443 --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH>

# Si le token a expiré, générer un nouveau :
kubeadm token create --print-join-command

5.7 Verifying the cluster

# Vérifier les nodes
kubectl get nodes

# Output attendu :
# NAME          STATUS   ROLES           AGE   VERSION
# master        Ready    control-plane   10m   v1.28.0
# worker-1      Ready    <none>          5m    v1.28.0
# worker-2      Ready    <none>          5m    v1.28.0

# Vérifier les pods système
kubectl get pods -n kube-system

---

6 - Managed Kubernetes services

6.1 Amazon EKS

# Installer eksctl
curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
sudo mv /tmp/eksctl /usr/local/bin

# Créer un cluster EKS
eksctl create cluster \
  --name mon-cluster \
  --region eu-west-1 \
  --nodegroup-name workers \
  --node-type t3.medium \
  --nodes 3 \
  --nodes-min 1 \
  --nodes-max 5 \
  --managed

6.2 Azure AKS

# Installer Azure CLI
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Se connecter
az login

# Créer un groupe de ressources
az group create --name monResourceGroup --location westeurope

# Créer un cluster AKS
az aks create \
  --resource-group monResourceGroup \
  --name monClusterAKS \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keys

# Configurer kubectl
az aks get-credentials --resource-group monResourceGroup --name monClusterAKS

6.3 Google GKE

# Installer gcloud CLI
# https://cloud.google.com/sdk/docs/install

# Se connecter
gcloud auth login
gcloud config set project MON_PROJET

# Créer un cluster GKE
gcloud container clusters create mon-cluster \
  --zone europe-west1-b \
  --num-nodes 3 \
  --machine-type e2-medium

# Configurer kubectl
gcloud container clusters get-credentials mon-cluster --zone europe-west1-b

---

7 - Verifying the installation

7.1 Basic tests

# Vérifier la version
kubectl version

# Informations du cluster
kubectl cluster-info

# Liste des nodes
kubectl get nodes -o wide

# Composants du système
kubectl get componentstatuses  # Deprecated mais utile
kubectl get pods -n kube-system

7.2 Deploy a test application

# Déployer nginx
kubectl create deployment nginx --image=nginx

# Exposer le déploiement
kubectl expose deployment nginx --port=80 --type=NodePort

# Vérifier
kubectl get pods,svc

# Tester l'accès
kubectl port-forward svc/nginx 8080:80
# Ouvrir http://localhost:8080

# Nettoyer
kubectl delete deployment nginx
kubectl delete svc nginx

---

Summary

In this chapter, we learned how to:

• Install kubectl on different OSes
• Use Minikube for local development
• Create clusters with Kind for testing
• Deploy a production cluster with kubeadm
• Use the managed services EKS, AKS, GKE

---

Next step

In the next chapter, we will explore Pods and Containers, the basic unit of Kubernetes.

→ Next chapter: Pods and Containers

---

← Back to the table of contents