Configuration du cluster Kubernetes sur Ubuntu, expliquée

Introduction

Le but de cet article est de fournir des directives aux personnes intéressées par les détails de la configuration du cluster Kubernetes, la compréhension de l’interconnexion des pods et d’autres aspects liés au cluster Kubernetes.

Cet article a fourni les détails de la configuration du cluster Kubernetes sur Ubuntu. Les sujets principaux sont les suivants :

• Présentation de l’architecture Kubernetes
• Interface réseau de conteneurs avec Calico
• Procédures détaillées de configuration du cluster Kubernetes
• Procédures de dépannage

Pour la configuration de Kubernetes, j’utilise un cluster à trois nœuds dans lequel nous avons un nœud maître et deux nœuds de travail. Voici les types spécifiques pour le cluster Kubernetes

• Exécution du conteneur : conteneur
• Stratégie réseau et CNI : Calicot
• Système opérateur: Ubuntu

Présentation de l’architecture

Le schéma suivant illustre les composants des clusters Kubernetes. Les nœuds Kubernetes se divisent en deux catégories : le plan de contrôle et les nœuds de travail. Toutes les applications s’exécutent sur les nœuds de travail en tant que conteneurs à l’intérieur du pod.

Cliquez ici pour plus de détails.

Quelques points clés à noter :

• Le serveur d’API est le cerveau du cluster. Pratiquement toute la communication et l’administration sont réalisées par ce composant
• La communication entre les nœuds de travail et le plan de contrôle se fait via des kubelets et un serveur API.

Pour la politique CNI/réseau, j’utilise Calio. Il existe de nombreux fournisseurs de CNI. Le tableau suivant est un résumé clé des fournisseurs CNI open source :

Trois grands fournisseurs de cloud, Azure, GCP et AWS ont le CNI suivant :

• Microsoft a Azure CNI
• Google GKE utilise kubenet CNI qui se trouve au-dessus de Calico
• AWS utilise Amazon VPN CNI

Mise en réseau des pods Kubernetes avec Calico

Détails de configuration

Dans cette section, je décrirai les détails de la configuration du cluster Kubernetes.

Pré-installation

Configurez la saisie semi-automatique de Kubeetc sur le nœud maître :

Ajoutez ce qui suit au ~/.bashrc sur le nœud maître :

source <(kubectl completion bash) # set up autocomplete in bash into the current shell, bash-completion package should be installed first.
echo "source <(kubectl completion bash)" >> ~/.bashrc # add autocomplete permanently to your bash shell.

alias k=kubectl
complete -o default -F __start_kubectl k

Visitez la feuille de triche de Kubectl

Commandes communes sur tous les nœuds

Changer le nom d’hôte

sudo hostnamectl set-hostname "k8smaster.ggl.com" 
sudo hostnamectl set-hostname "k8sworker1.ggl.com" 
sudo hostnamectl set-hostname "k8sworker2.ggl.com"

172.31.105.189 k8smaster.ggl.com k8smaster
172.31.104.148 k8sworker1.ggl.com k8sworker1
172.31.100.4 k8sworker1.ggl.com k8sworker2

Désactiver l’échange

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

Remarque : La raison de la désactivation de l’échange de mémoire (swapoff) est pour des raisons de stabilité et de performances. Il s’agit de l’étape requise dans toute configuration Kubernetes (AKS, GKE, EKS).

Charger les modules du noyau

sudo tee /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter
lsmod | egrep "overlay|br_net"

Remarque : Kubernetes utilise un module de noyau superposé pour les systèmes de fichiers. Noyau Linux br_netfilter sert à transférer le trafic IP4 et à permettre à iptable de voir le trafic ponté.

Définir les paramètres du noyau

sudo tee /etc/sysctl.d/kubernetes.conf <<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sudo sysctl --system

Activer le référentiel Docker

sudo apt install -y curl gnupg2 software-properties-common apt-transport-https ca-certificates
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmour -o /etc/apt/trusted.gpg.d/docker.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Installer et activer le runtime en conteneur

sudo apt update
sudo apt install -y containerd.io
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
sudo sed -i 's/SystemdCgroup \= false/SystemdCgroup \= true/g' /etc/containerd/config.toml
cat /etc/containerd/config.toml

sudo systemctl restart containerd.service
sudo systemctl enable containerd
sudo systemctl status containerd

Ajouter un référentiel Kubernetes

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"
sudo apt update

Installer kubeadm kubelet kubectl

sudo apt install -y kubelet kubeadm kubectl

sudo kubeadm init --pod-network-cidr=192.168.0.0/16 --control-plane-endpoint=k8smaster.ggl.com

To start using your cluster, you need to run the following 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

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of control-plane nodes by copying certificate authorities
and service account keys on each node and then running the following as root:

  kubeadm join k8smaster.ggl.com:6443 --token 7sx7ky.z54u1q0pexh5vh25 \
	--discovery-token-ca-cert-hash sha256:6cce1257cfdbd54c981ad64e2a553711e276afc402a52e3899a4725470902686 \
	--control-plane

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join k8smaster.ggl.com:6443 --token 7sx7ky.z54u1q0pexh5vh25 \
	--discovery-token-ca-cert-hash sha256:6cce1257cfdbd54c981ad64e2a553711e276afc402a52e3899a4725470902686

Note: the joining commands for master nodes and worker node are different with only option --control-plane.

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
k8smaster.ggl.com Ready control-plane 6m22s v1.26.1

$ sudo lsof -iTCP -nP | egrep LISTEN
systemd-r 515 systemd-resolve 14u IPv4 15918 0t0 TCP 127.0.0.53:53 (LISTEN)
sshd 935 root 3u IPv4 17128 0t0 TCP *:22 (LISTEN)
sshd 935 root 4u IPv6 17130 0t0 TCP *:22 (LISTEN)
node 1464 root 18u IPv4 20071 0t0 TCP *:31297 (LISTEN)
container 3743 root 13u IPv4 35540 0t0 TCP 127.0.0.1:45019 (LISTEN)
kube-sche 6398 root 7u IPv4 47451 0t0 TCP 127.0.0.1:10259 (LISTEN)
kube-cont 6425 root 7u IPv4 47423 0t0 TCP 127.0.0.1:10257 (LISTEN)
kube-apis 6446 root 7u IPv6 48257 0t0 TCP *:6443 (LISTEN)
etcd 6471 root 7u IPv4 47402 0t0 TCP 172.31.105.189:2380 (LISTEN)
etcd 6471 root 8u IPv4 47406 0t0 TCP 127.0.0.1:2379 (LISTEN)
etcd 6471 root 9u IPv4 47407 0t0 TCP 172.31.105.189:2379 (LISTEN)
etcd 6471 root 14u IPv4 48266 0t0 TCP 127.0.0.1:2381 (LISTEN)
kubelet 6549 root 23u IPv6 47676 0t0 TCP *:10250 (LISTEN)
kubelet 6549 root 26u IPv4 47683 0t0 TCP 127.0.0.1:10248 (LISTEN)
kube-prox 6662 root 14u IPv4 49323 0t0 TCP 127.0.0.1:10249 (LISTEN)
kube-prox 6662 root 15u IPv6 49330 0t0 TCP *:10256 (LISTEN)
calico-no 7377 root 10u IPv4 55531 0t0 TCP 127.0.0.1:9099 (LISTEN)

sudo ufw status verbose
sudo ufw allow 6443/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 2379:2380/tcp

C’est une étape très importante pour ouvrir tous les ports nécessaires. Sinon, nous ne pourrons pas rejoindre le noeud worker. Dans les autres environnements Linux, nous devons désactiver le pare-feu pour que le nœud de travail rejoigne le cluster.

sudo kubeadm token create --print-join-command

Commandes de nœud de travail

Rejoignez le cluster Kubernetes

sudo kubeadm join k8smaster.example.net:6443 \
--token ufkijl.ukrhpo372w6eoung \
--discovery-token-ca-cert-hash sha256:e6b04ca3f6f4258b027d22a5de4284d03d543331b81cae93ec4c982ab94c342f

Ouvrir les ports sur le nœud de travail

sudo ufw status
sudo ufw allow 10250
sudo ufw allow 30000:32767/tcp
sudo ufw status

kubectl create deployment...