Aller au texte
ShemolInstallation d'un cluster k8s et préparation au déploiement de KubeEdge
流程记录 / 云原生

Installation d'un cluster k8s et préparation au déploiement de KubeEdge

Shemol
流程记录云原生
Environnement d’expérience : Debian GNU/Linux 12 (bookworm) x86_64

Installer containerd

Avant d’installer k8s, il faut d’abord installer containerd. Côté edge de KubeEdge, containerd suffit ; côté cloud, il faut k8s.

Préparation avant d’installer k8s

Activer le transfert de trafic

Modifier la config iptables et activer le module « br_netfilter », pour que kubernetes puisse inspecter et transférer le trafic réseau.

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

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward=1 # better than modify /etc/sysctl.conf
EOF

sudo sysctl --system

Désactiver la partition Swap Linux

Pour des raisons de sécurité (les docs officielles promettent que les Secrets ne sont lus et écrits qu’en mémoire, jamais persistés sur disque) et pour garantir la cohérence de synchro des nœuds, depuis la 1.8 Kubernetes dit clairement dans sa doc qu’il ne prend pas Swap en charge par défaut. Sur une machine où Swap n’est pas coupé, le cluster ne démarrera tout simplement pas.
shell
sudo cp /etc/fstab /etc/fstab_bak
sudo swapoff -a
sudo sed -ri '/\\sswap\\s/s/^#?/#/' /etc/fstab

Enregistrer le dépôt apt

J’ai choisi le miroir Tsinghua. Doc officielle : https://mirrors.tuna.tsinghua.edu.cn/help/kubernetes/

shell
sudo apt install -y apt-transport-https ca-certificates curl

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg <https://packages.cloud.google.com/apt/doc/apt-key.gpg>

Créer /etc/apt/sources.list.d/kubernetes.list, avec ce contenu :

shell
deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] <https://mirrors.tuna.tsinghua.edu.cn/kubernetes/apt> kubernetes-xenial main

Ensuite

shell
sudo apt update

Installer kubeadm, kubelet, kubectl

Le rôle de ces trois outils, à toi de l’apprendre.

shell
sudo apt install kubeadm kubelet kubectl

Personnellement je n’ai pas figé la version. Si tu as besoin de la figer, lis l’article de référence.

Vérifier le résultat de l’install :

shell
cloud@cloud:~$ kubeadm version
kubeadm version: &version.Info{Major:"1", Minor:"28", GitVersion:"v1.28.10", GitCommit:"21be1d76a90bc00e2b0f6676a664bdf097224155", GitTreeState:"clean", BuildDate:"2024-05-14T10:51:30Z", GoVersion:"go1.21.9", Compiler:"gc", Platform:"linux/amd64"}
cloud@cloud:~$ kubectl version
Client Version: v1.28.10
Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
The connection to the server localhost:8080 was refused - did you specify the right host or port?
cloud@cloud:~$ kubelet --version
Kubernetes v1.28.10

Voir les versions d’images dont on aura besoin ensuite :

shell
cloud@cloud:~$ sudo kubeadm config images list --kubernetes-version v1.28.10
registry.k8s.io/kube-apiserver:v1.28.10
registry.k8s.io/kube-controller-manager:v1.28.10
registry.k8s.io/kube-scheduler:v1.28.10
registry.k8s.io/kube-proxy:v1.28.10
registry.k8s.io/pause:3.9
registry.k8s.io/etcd:3.5.12-0
registry.k8s.io/coredns/coredns:v1.10.1

Initialiser le control plane du cluster

  1. Démarrer kubelet, et s’assurer qu’il se lance au boot
shell
sudo systemctl start kubelet
sudo systemctl enable kubelet
  1. Commencer le déploiement. Ici je suis passé sur le compte root
shell
kubeadm init \\
--image-repository registry.cn-hangzhou.aliyuncs.com/google_containers \\
--pod-network-cidr=10.10.0.0/16 \\
--apiserver-advertise-address=10.129.196.8 \\
--kubernetes-version=v1.28.10 \\
--v=5

Explication des flags (oui, j’ai juste recopié l’article de référence) :

  • -image-repository : tirer les images de base ci-dessus depuis Aliyun ; si tu ne le mets pas, il faudra aller les chercher sur les serveurs Google ;
  • -pod-network-cidr : définir le CIDR des Pods du cluster ; c’est pour installer le plugin réseau Flannel ensuite ;
  • -kubernetes-version : spécifier la version de Kubernetes ;
  • -v=5 : afficher les logs de trace détaillés, voir ici ;
  • -apiserver-advertise-address : spécifier l’IP de l’api-server. S’il y a plusieurs cartes réseau, choisis clairement laquelle. L’apiserver a un rôle très important dans un cluster Kubernetes — beaucoup de configs (ConfigMap, etc.) stockent directement cette adresse, et la changer plus tard est un vrai casse-tête, donc fais gaffe.
  1. Suivre les logs pour configurer kube config

Ma méthode : le faire en root. Plus tard, au déploiement de kubeedge, le fichier config par défaut est $HOME/.kube/config, c’est-à-dire /root/.kube/config.

shell
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

Installer le plugin réseau

Sur les plugins réseau de k8s, à toi d’apprendre — moi aussi je dois encore creuser...

Ici on choisit Flannel, comme dans l’article de référence.

Récupérer le fichier d’install kube-flannel.yml depuis Github, puis le modifier :

plain text
net-conf.json: |
    {
      "Network": "10.244.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }

Ajuster le Network ci-dessus au CIDR pod qu’on a fixé à l’init du cluster :

yaml
net-conf.json: |
    {
      "Network": "10.10.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }

Enfin on installe avec kubectl apply :

plain text
kubectl apply -f kube-flannel.yml

On peut aussi le faire à la façon du site officiel de flannel :

shell
kubectl apply -f <https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml>

Côté version, je pense que les deux vont à peu près, mais de toute façon le CIDR des pods doit être configuré.

Un petit problème à noter

Plus tard, en lançant le cas de test edgemesh, j’ai vu que les pods déployés côté edge restaient en ContainerCreating. Les logs edgecore du edge disaient que /run/flannel/subnet.env n’existait pas. Après avoir copié le contenu de ce fichier du cloud vers le edge, le déploiement est devenu normal. Donc garde un œil là-dessus ; j’en reparlerai au déploiement d’edgemesh.

À propos des images

Avant d’avoir configuré le proxy de containerd, j’ai eu le problème que l’image flannel ne se pullait pas. Voici une méthode de remplacement par un miroir domestique que j’ai utilisée.

Chercher les images concernées sur 渡渡鸟镜像同步站, puis kubectl edit pod/deployment/daemonset ** -n ** pour remplacer directement par l’image domestique. Si 渡渡鸟 n’a pas l’image, tu peux aussi l’ajouter en suivant le guide d’utilisation du site.

Enlever le taint du master

On enlève le taint pour que le nœud master puisse déployer des services métier. Au moment de déployer cloudcore, ce problème m’a fait perdre un peu de temps...

shell
kubectl taint nodes cloud node-role.kubernetes.io/control-plane:NoSchedule-

L’article de référence parle aussi d’ajuster la plage NodePort. Pour l’instant je n’ai pas eu de souci, donc j’ai sauté. Si tu en as besoin, lis l’article.

Ajouter des nœuds Worker n’est pas nécessaire pour l’instant non plus ; lis l’article si besoin.

Installer Docker

En plus, pour le cas de joint inference, il faut construire les images des grands/petits modèles de détection de casque (lancer le script build_image.sh de l’exemple — j’en parlerai aussi plus tard), donc il faut installer docker ce.

Installer docker ce depuis le miroir Tsinghua. Doc officielle : https://mirrors.tuna.tsinghua.edu.cn/help/docker-ce/

Docker aussi, mieux vaut configurer un proxy et un miroir domestique. Cherche la méthode toi-même.

Articles de référence