Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Déploiement hors ligne du K8

environnement

Cible

déploiement hors ligne k8s

étape

Déployer Docker

Pour plus de détails, consultez l'article : "Installation hors ligne de Docker et packaging hors ligne de projets back-end"
https://blog.csdn.net/qq_45371023/article/details/140279746?spm=1001.2014.3001.5501
Tous les fichiers utilisés se trouvent à l'adresse :
Lien : https://pan.baidu.com/s/10cb-dXkgdShdjPEBCyvTrw?pwd=fpuy
Code d'extraction : fpuy

Installer cri_dockerd

1. Installez cri_dockerd

rpm -ivh cri-dockerd-0.3.9-3.el8.x86_64.rpm

2. Rechargez le démon système → Configurez cri-dockerd pour qu'il démarre automatiquement → Démarrez cri-dockerd

Recharger le démon système

sudo systemctl daemon-reload
1

Configurer cri-dockerd pour qu'il démarre automatiquement

sudo systemctl enable cri-docker.socket cri-docker
1

Commencer cri-dockerd

sudo systemctl start cri-docker.socket cri-docker

sudo systemctl status cri-docker.socket

sudo systemctl status cri-docker
1
2
3
4
5

Problème : échec du démarrage de cri-docker

mesure:

Méthode 1 : systemctl restart docker # Redémarrer le docker

Méthode 2 : désinstallez Docker et réinstallez-le, puis effectuez à nouveau les étapes ci-dessus

*Installer Kubernetes

Installer Kubectl

1. Installez Kubectl

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
1

2. Vérifiez si l'installation est terminée

kubectl version --client
1

Installer Kubeadm

3. Ouvrez le port ou fermez le pare-feu (pour garantir un processus d'installation fluide)

Port ouvert (serveur cloud)

Port ouvert 6443

sudo firewall-cmd --zone=public --add-port=6443/tcp --permanent
1

Recharger le pare-feu

sudo firewall-cmd --reload
1

Afficher tous les ports ouverts

sudo firewall-cmd --zone=public --list-ports
1

Ou désactivez le pare-feu (machine virtuelle)

Désactivez le pare-feu

sudo systemctl stop firewalld
1

Désactiver le démarrage automatique du pare-feu

sudo systemctl disable firewalld
1

4. Désactivez SELinux (assurez-vous que le conteneur peut accéder aux ressources système)

sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
1
2

5. Installez Kubeadm, Kubelet et Kubectl

Téléchargez le package d'installation hors ligne approprié au format RPM, qui existe sous 3_yum_package. Utilisez la commande pour installer tous les packages d'installation RPM dans le répertoire.

cd 3_yum_package && rpm -ivh *.rpm
1

6. Configurez Kubelet pour qu'il démarre automatiquement

sudo systemctl enable --now kubelet
1

*Déployer le cluster K8s

Après avoir terminé les étapes ci-dessus, vous aurez l'environnement suivant

·Deux serveurs ou machines virtuelles avec des adresses IP différentes peuvent communiquer entre eux et conserver l'état du réseau local. L'adresse IP est définie sur 192.168..34 et 192.168..35

·Le runtime du conteneur (Docker+cri_dockerd) est installé sur les deux serveurs et les composants Kubernetes kubectl, kubeadm et kubelet ont été installés.

Préparation environnementale

7. Fermez la partition d'échange. Elle est divisée en arrêt temporaire et arrêt permanent. L'arrêt permanent est recommandé pour les environnements de machines virtuelles car il sera activé et désactivé fréquemment. Au contraire, l'arrêt temporaire est recommandé pour les environnements cloud.

Fermez temporairement la partition de swap

swapoff -a
1

Pour fermer définitivement la partition swap, commentez la ligne contenant swap dans fstab.

vi /etc/fstab
1

# /dev/mapper/centos-swap swap swap valeurs par défaut 0 0

Redémarrez pour que cela prenne effet. Le redémarrage peut entraîner une modification de l'état de cri-dockerd. Dans le déploiement réel, je n'ai pas choisi de redémarrer. La raison est probablement que la version ou la configuration n'est pas configurée correctement. cri-dockerd puis démarrez cri-dockerd pour que le statut cri-dockerd soit normal

redémarrer

8. Installez runc comme environnement d'exploitation k8s

Installer runc

sudo install -m 755 runc.amd64 /usr/local/bin/runc
1

# Vérifiez si l'installation est réussie

runc -v
1

9. Docker et cri-dockerd ont mis en place une accélération d'image nationale (Étant donné que les noms des packages logiciels suivants à utiliser dans ce dossier ont des adresses miroir, il est recommandé de configurer l'accélération miroir correspondante même sur un réseau local pour empêcher kubectl de demander à Internet d'extraire les packages logiciels et d'ignorer le miroir local après le l'installation est terminée.）

sudo tee /etc/docker/daemon.json <<-'EOF'

{

 "registry-mirrors": ["https://tsvqojsz.mirror.aliyuncs.com"]

}

EOF

# 找到第10行

vi /usr/lib/systemd/system/cri-docker.service

# 修改为ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Redémarrer les composants Docker

systemctl daemon-reload && systemctl restart docker cri-docker.socket cri-docker
1

# Vérifier l'état du composant Docker

systemctl status docker cir-docker.socket cri-docker
1

10. Vérifiez le nom d'hôte et les hôtes

nœud maître

le nom d'hôte est k8s-master

vi /etc/hostname
1

Ajouter un mappage de nom de domaine

echo "192.168.**.35 k8s-slave01">> /etc/hosts
1

Autres nœuds

nom d'hôte为k8s-slave01

vi /etc/hostname
1

Ajouter un mappage de nom de domaine

echo "192.168.**.34 k8s-master" >> /etc/hosts
1

11. Transférez IPv4 et laissez iptables voir le flux du pont

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

overlay

br_netfilter

EOF

 

sudo modprobe overlay

sudo modprobe br_netfilter
1
2
3
4
5
6
7
8
9
10
11
12
13

Définissez les paramètres sysctl requis, qui persistent lors des redémarrages

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
1
2
3
4
5
6
7
8
9

#Appliquer les paramètres sysctl sans redémarrer

sudo sysctl --system

 

lsmod | grep br_netfilter

lsmod | grep overlay

 

sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward

1
2
3
4
5
6
7
8
9
10
11
12

# Si l'erreur iptables apparaît toujours lors de l'initialisation, veuillez exécuter

echo "1">/proc/sys/net/bridge/bridge-nf-call-iptables

echo "1">/proc/sys/net/ipv4/ip_forward
1
2
3

Initialiser le nœud/maître du plan de contrôle

12. Initialisez le nœud maître

Avant l'initialisation, vous devez obtenir l'image Docker requise pour l'initialisation via les images de configuration kubeadm :

Installez le docker d'images load -i **.tar

Les fichiers image pertinents existent dans 5_kubeadm-images.

Effectuer l'initialisation :

kubeadm init --node-name=k8s-master list--image-repository=registry.aliyuncs.com/google_containers --cri-socket=unix:///var/run/cri-dockerd.sock --apiserver-advertise-address=192.168.**.34 --pod-network-cidr=10.244.0.0/16 --service-cidr=10.96.0.0/12
1

–image-repository=registry.aliyuncs.com/google_containers # Remplacez la source de l'image du conteneur téléchargé par Alibaba Cloud. Sinon, l'image ne pourra pas être extraite pour des raisons de réseau et l'exécution échouera définitivement.

–cri-socket=unix:///var/run/cri-dockerd.sock # Il s'agit du runtime de conteneur spécifié, car containersd est également l'un des composants de Docker en cours de téléchargement. Docker téléchargera également containersd lors de l'initialisation de Kubernetes. détecte qu'il existe plusieurs environnements d'exécution de conteneur, il doit en sélectionner un manuellement. On peut également voir ici que containersd est en réalité beaucoup plus léger que Docker.

–apiserver-advertise-address=192.168.56.50 # Définissez l'adresse de diffusion du serveur API. Sélectionnez ici l'adresse IPv4 locale. Si vous ne souhaitez pas que le SERVEUR API soit défini sur d'autres nœuds, ne la remplacez pas par une autre adresse.

–pod-network-cidr=10.244.0.0/16 # Spécifiez la plage d'adresses IP qui peut être utilisée par le réseau de pods. Si vous n'êtes pas encore sûr, vous pouvez l'ignorer et utiliser cette valeur.

–service-cidr=10.96.0.0/12 # Spécifiez un segment d'adresse IP supplémentaire pour l'adresse IP virtuelle du service. Si vous n'êtes pas encore sûr, vous pouvez simplement utiliser cette valeur quand même.

Problème : la vérification cordns:v1.10.1 n'existe pas, en fait cordns:v1.10.1 existe déjà, mais c'est cordns:1.10.1.

Mesures : Modifier le tag des cordns.

docker tag registry.aliyuncs.com/google_containers/coredns:1.10.1 registry.aliyuncs.com/google_containers/coredns:v1.10.1
1

Réexécutez la commande d'initialisation

Enregistrez les informations ci-dessous kubeadm join, qui sont requises pour la jointure de nœud. Les informations pertinentes pour l'exemple ci-dessus sont :

kubeadm join 192.168.51.34:6443 --token 1qtv3k.p8tfvdcds6x5ichf 

​    --discovery-token-ca-cert-hash sha256:90afb5751086aabf7ac90d9e77a946eb768d47ffaaead62243264641954a5e26
1
2
3

Si vous oubliez, vous pouvez utiliser la liste de jetons kubeadm pour interroger. Le jeton existe pendant 24 heures, recréer kubeadm token create --print-join-command et le supprimer à l'aide de kubeadm token delete tokenid.

Utilisateurs non root, veuillez exécuter

mkdir -p $HOME/.kube

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

sudo chown $(id -u):$(id -g) $HOME/.kube/config
1
2
3
4
5

L'utilisateur root exécute directement

Il prend effet temporairement et deviendra invalide après le redémarrage. Ce n'est pas recommandé.

export KUBECONFIG=/etc/kubernetes/admin.conf 
1

Elle prend effet de manière permanente. Il n'est pas nécessaire d'exécuter à nouveau cette commande après avoir exécuté à nouveau kubeadm reset et init.

echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile 
1

Après avoir exécuté la commande efficace permanente, vous devez la rechercher pour la rendre efficace.

source ~/.bash_profile
1

Vérifiez si la configuration est efficace

echo $KUBECONFIG 

/etc/kubernetes/admin.conf
1
2
3

13. Installer et configurer les plug-ins réseau

Ici, la flanelle est utilisée pour télécharger et télécharger le fichier kube-flannel.yml sur le serveur.

Téléchargez l'image appropriée sur le serveur pour l'installation. kube-flannel.yml et les fichiers image existent dans 6_kube-flannel.

Interroger la carte réseau

siconfig

kube-flannel.yml recherchera la carte réseau enp1s0 par défaut. Dans cet exemple, la carte réseau 34 est enp1s0 et n'a pas besoin d'être modifiée. La carte réseau 35 est enp4s0.

//Modifiez kube-flannel.yml de 35 et ajoutez –iface=enp0s3 pour préciser (enp0s3 voici la carte réseau correspondant à l'ip, comme la partie dans la case ci-dessus). Les emplacements des paramètres sont les suivants :

container:

  ......

  command：

  - /opt/bin/flanneld

  arg:

  - --ip-masq

  - --kube-subnet-mgr

  - --iface=enp4s0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Configuration du plugin réseau Flanel pour Kubernetes

kubectl apply -f /data/k8s/6_kube-flannel/kube-flannel.yml
1

cat /run/flannel/subnet.env
1

# S'il n'existe pas de fichier ou de dossier de ce type, vous devez le créer manuellement. Le contenu est le même que ci-dessous.

FLANNEL_NETWORK=10.244.0.0/16

FLANNEL_SUBNET=10.244.0.1/24

FLANNEL_MTU=1450

FLANNEL_IPMASQ=true
1
2
3
4
5
6
7

Le nœud nœud rejoint le maître

14. Le nœud nœud rejoint le maître

14.1. Copiez /etc/kubernetes/admin.conf de la machine du nœud maître vers la machine du nœud esclave.

scp /etc/kubernetes/admin.conf 192.168.56.51:/etc/kubernetes/
1

# N'oubliez pas d'ajouter admin.conf à la variable d'environnement. Utilisez-le directement ici pour prendre effet de manière permanente.

echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile

source ~/.bash_profile
1
2
3

S'il y a un problème lors de la copie :

La clé d'hôte ECDSA pour 192.168.55.187 a changé et vous avez demandé une vérification stricte. La vérification de la clé d'hôte a échoué.

Exécutez les instructions suivantes pour réparer

ssh-keygen -R 192.168.55.187
1

14.2. Exécutez la commande join (une fois le nœud maître initialisé avec succès, la commande join sera donnée)

Par exemple:

kubeadm join 192.168.51.34:6443 --token by7t4x.da3f98dzrvjylykz --discovery-token-ca-cert-hash sha256:90afb5751086aabf7ac90d9e77a946eb768d47ffaaead62243264641954a5e26 --cri-socket unix:///var/run/cri-dockerd.sock

14.3. Exécutez kubectl pour obtenir des nœuds

Le cluster k8s a été déployé avec succès ! ! !

question

Question une

kubectl obtient des nœuds

Mesures : Vérifiez si le swap est fermé ; vérifiez si le pare-feu ouvre le port 6443.

Fermer l'échange

Désactivez temporairement le pare-feu

succès

question 2

kubectl obtient des nœuds

Après avoir ajouté un nœud k8s au cluster, vérifiez que l'état du nœud est NotReady

mesure:

systemctl restart kubelet.service

systemctl restart docker.service
1
2
3

Redémarrez Kubelet et Docker

Troisième question

kubeadm join 192.168.51.34:6443 --token l2qlvh.and3fnjmzecueu9h --discovery-token-ca-cert-hash sha256:90afb5751086aabf7ac90d9e77a946eb768d47ffaaead62243264641954a5e26 --cri-socket unix:///var/run/cri-dockerd.sock

Un délai d'initialisation se produit lors de l'ajout de nœuds enfants à un cluster k8s.

mesure:

kubeadm reset -f --cri-socket unix:///var/run/cri-dockerd.sock
1

succès

Question 4

Copiez /etc/kubernetes/admin.conf de la machine du nœud maître vers la machine du nœud esclave

scp /etc/kubernetes/admin.conf 192.168.55.187:/etc/kubernetes/

Si la copie du fichier échoue, le message d'erreur est le suivant :

La clé d'hôte ECDSA pour 192.168.55.187 a changé et vous avez demandé une vérification stricte.

La vérification de la clé de l'hôte a échoué.

Exécutez les instructions suivantes pour réparer

ssh-keygen -R 192.168.55.187
1

Suppression rapide

kubectl delete node k8s-slave01
kubectl delete node k8s-slave02
kubectl delete node k8s-master
1
2
3

nœud esclave

rm -rf /etc/kubernetes/*
kubeadm reset --cri-socket unix:///var/run/cri-dockerd.sock
1
2

nœud maître

rm -rf /etc/kubernetes/*
rm -rf ~/.kube/*
rm -rf /var/lib/etcd/*
kubeadm reset -f --cri-socket unix:///var/run/cri-dockerd.sock
1
2
3
4

Si nécessaire, réinitialisez le cluster k8s.

kubeadm init --node-name=k8s-master --image-repository=registry.aliyuncs.com/google_containers --cri-socket=unix:///var/run/cri-dockerd.sock --apiserver-advertise-address=192.168.51.34 --pod-network-cidr=10.244.0.0/16 --service-cidr=10.96.0.0/12
1

nœud maître

kubectl apply -f /data/k8s/6_kube-flannel/kube-flannel.yml
kubectl get pod -A
1
2

nœud maître

scp /etc/kubernetes/admin.conf 192.168.51.35:/etc/kubernetes/
scp /etc/kubernetes/admin.conf 192.168.51.36:/etc/kubernetes/
1
2

nœud esclave

kubeadm join 192.168.51.34:6443 --token 1k9kdy.dvn2qbtd7rjar1ly 
       --discovery-token-ca-cert-hash sha256:ff90d8ed41ae1902a839194f179a1c3ba8374a5197ea3111e10e5ca1c09fa442 --cri-socket unix:///var/run/cri-dockerd.sock
1
2

kubectl get pod -A
kubectl get nodes
1
2