Avantages du déploiement conteneurisé : Auparavant, les projets étaient déployés de manière commune et ils ne pouvaient pas être isolés les uns des autres. Si la mémoire d'un projet fuyait, le serveur serait indisponible. La gestion conteneurisée Docker évite cette situation, et k8s est équivalent à la gestion docker conteneurisée. L'écosystème orchestre tous les conteneurs et gère automatiquement les services de conteneurs
La fonction principale :
Découverte de serveurs et équilibrage de charge
Arrangement de stockage (lorsque la mémoire de l'application de service est gérée par k8s, lorsque le serveur n'est pas utilisé, il sera automatiquement nettoyé)
Déploiement et restauration automatiques, calcul automatique de l'emballage : en cas de problème avec l'application, revenir à la version précédente et contrôler la mémoire et la taille du processeur occupées par chaque application
Auto-guérison : L'application dans le serveur peut être surveillée. Si un serveur est raccroché, il sera automatiquement placé sur d'autres machines.
Présentation des composants Kubernetes
Un cluster kubernetes est principalement composé de nœuds de contrôle (maître) et de nœuds de travail (nœuds), et différents composants sont installés sur chaque nœud.
Nœud de contrôle (maître) : Le plan de contrôle du cluster, responsable de la prise de décision du cluster.
Serveur d'API : seul point d'entrée pour les opérations de cluster, il reçoit les commandes saisies par les utilisateurs et fournit des mécanismes tels que l'authentification, l'autorisation, l'enregistrement d'API et la découverte.
Planificateur : responsable de la planification des ressources du cluster et de la planification des pods sur les nœuds correspondants conformément à une politique de planification prédéterminée.
ControllerManager : responsable de la maintenance de l'état du cluster, tel que les modalités de déploiement du programme, la détection des pannes, la mise à l'échelle automatique et les mises à jour continues.
Etcd : responsable du stockage des informations sur divers objets de ressource dans le cluster.
Nœud de travail (nœud) : le plan de données du cluster, chargé de fournir l'environnement d'exécution du conteneur.
Kubelet : responsable de la maintenance du cycle de vie des conteneurs, c'est-à-dire en contrôlant Docker, pour créer, mettre à jour et détruire les conteneurs.
KubeProxy : chargé de fournir la découverte de services et l'équilibrage de charge au sein du cluster.
Docker : responsable de diverses opérations du conteneur sur le nœud.
Flux de travail des composants
Déployez un service Nginx pour illustrer la relation d'appel de chaque composant du système Kubernetes :
① Tout d'abord, il doit être clair qu'une fois l'environnement Kubernetes démarré, le maître et le nœud stockeront leurs propres informations dans la base de données etcd.
② Une demande d'installation d'un service Nginx sera d'abord envoyée au composant API Server sur le nœud maître.
③ Le composant API Server appellera le composant Scheduler pour décider sur quel nœud le service doit être installé. À ce stade, il lira les informations de chaque nœud à partir d'etcd, puis le sélectionnera selon un certain algorithme et informera le serveur API du résultat.
④ API Server appelle Controller-Manager pour appeler le nœud Node afin d'installer le service Nginx.
⑤ Une fois que Kubelet aura reçu l'instruction, il notifiera Docker, puis Docker démarrera un pod Nginx. Un pod est la plus petite unité opérationnelle de Kubernetes, et un conteneur doit s'exécuter dans un pod.
⑥ Un service Nginx est en cours d'exécution. Si vous devez accéder à Nginx, vous devez utiliser kube-proxy pour accéder au pod, afin que les utilisateurs externes puissent accéder au service Nginx dans le cluster.
autres nœuds
Maître : nœud de contrôle du cluster. Chaque cluster nécessite au moins un nœud maître responsable de la gestion et du contrôle du cluster.
Nœud : nœud de charge de travail. Le maître affecte des conteneurs à ces nœuds de travail de nœud, puis le Docker sur le nœud de nœud est responsable de l'exécution du conteneur.
Pod : la plus petite unité de contrôle de Kubernetes. Les conteneurs s'exécutent dans des pods. Un pod peut avoir un ou plusieurs conteneurs.
Contrôleur : Le contrôleur, à travers lequel la gestion des pods est réalisée, comme le démarrage des pods, l'arrêt des pods, la mise à l'échelle du nombre de pods, etc.
Service : Une entrée unifiée pour les services externes du Pod, sous laquelle plusieurs Pods de la même classe peuvent être maintenus.
Label : Label, utilisé pour classer les Pods, un même type de Pod aura le même label.
NameSpace : espace de noms utilisé pour isoler l'environnement d'exécution du pod.
Construire un environnement de cluster
Vérifiez la version de la machine virtuelle, de préférence 7.5 ou supérieure
chat /etc/redhat-release
Configurez la résolution du nom d'hôte pour une référence facile
vim /etc/hosts
Ajouter l'analyse
192.168.6.100 maître
192.168.6.101 nœud1
192.168.6.102 nœud2
ping pour voir si vous pouvez ping
Synchronisation de l'heure : kubernetes exige que l'heure du nœud dans le cluster soit précise et cohérente, ajoutez donc une synchronisation de l'heure sur chaque nœud
systemctl start chronyd
systemctl enable chronyd #boot
date de démarrage automatique #view time
Le démarrage de Docker générera des règles iptables pour éviter toute confusion du système et devra être fermé, et le système n'aura pas besoin d'être traité.
#Fermez le pare-feu
systemctl stop firewalld
systemctl disable firewalld #Fermez
le service iptables
systemctl stop iptables
systemctl disable iptables #Désactivez
les services de sécurité Linux pour voir si selinux est activé
getenforce #Fermez définitivement
selinux, vous devez redémarrer
vim /etc/selinux/config
SELINUX =désactivé #Fermer temporairement
selinux , après le redémarrage,
setenforce invalide 0
Fermer la partition d'échange : partition de mémoire virtuelle, une fois la mémoire physique épuisée, allumez le disque et utilisez-le comme mémoire virtuelle
vim /etc/fstab #Commentez
la dernière ligne
#/dev/mapper/centos-swap swap swap defaults
Modifier les paramètres du noyau Linux et créer des fichiers de configuration
vim /etc/sysctl.d/kubernetes.conf
# Passer le trafic IPv4 ponté à la chaîne iptables
net.bridge.bridge-nf-call-ip6tables=1
net.bridge.bridge-nf-call-iptables=1
net.ipv4.ip_forward=1
recharger la configuration
sysctl-p
Charger le module de filtre de pont
modprobe br_netfilter
Vérifiez s'il est chargé
lsmod | poignée br_netfilter
Configurer la fonction ipvs
Il existe deux modèles de proxy pour le service dans k8s, l'un est iptables et l'autre est ipvs, et ipvs a des performances plus élevées.
Charger manuellement le module ipvs
miam -y installer ipset ipvsadm
Ajoutez le fichier de script correspondant et écrivez le contenu correspondant
cat > /etc/sysconfig/modules/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF
Ajouter une autorisation d'exécution
chmod +x /etc/sysconfig/modules/ipvs.modules
Exécutez le fichier, chargez le module
/bin/bash /etc/sysconfig/modules/ipvs.modules
Vérifier le succès
lsmod | grep -e ipvs -e nf_conntrack_ipv4
À ce stade, l'environnement est configuré, redémarrez le redémarrage
Installez Docker, kubeadm, kubelet et kubectl par nœud
installer le menu fixe
#Switch miroir
wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo #Install yum -y install
docker
-ce-18.06.3.ce-3.el7
Ajoutez des fichiers de configuration, docker utilise cgroupfs par défaut, k8s recommande d'utiliser systemd
mkdir /etc/docker
vim daemon.json #Entrez
ce qui suit
{ "exec-opts":["native.cgroupdriver=systemd"], "registry-mirrors":["https://kn0t2bca.mirror.aliyuncs.com" ] }
désinstaller le menu fixe
yum list installed|grep docker Afficher la liste d'installation de docker
yum -y remove xxx Désinstaller le nom détecté
systemctl enable docker auto-start
Installer les composants k8s
changer la source du miroir
cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck =0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key. gpg
EOF
Installer
yum install -y --setopt=obsoletes=0 kubeadm-1.17.4-0 kubelet-1.17.4-0 kubectl-1.17.4-0 -y
卸载
rpm -e kubelet-1.18.0 kubelet-1.18.0 kubelet- 1.18.0 --nodeps
Afin de rendre le pilote de groupe de contrôle utilisé par Docker cohérent avec le pilote de groupe de contrôle utilisé par kubelet, le contenu du fichier "/etc/sysconfig/kubelet"
# Passez à
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
Démarrage automatique
systemctl activer kubelet
Configuration du cluster
Parce que k8s est un site Web étranger, le téléchargement doit configurer le miroir et spécifier la version de téléchargement
Afficher l'image souhaitée
liste des images de configuration kubeadm
Spécifiez une version fixe
images = (
apiserver : v1.17.4
vers controller-manager : v1.17.4
vers scheduler : v1.17.4
vers proxy : v1.17.4
pause : 3.1
etcd : 3.4.3-0
coredns : 1.6.5
)
boucler les téléchargements
pour imageName dans ${images[@]} ; faire Docker Pull Registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName Docker Tag Registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName
k8s.gcr.io/$imageName Docker RMI Registry.cn-hangzhou.aliyuncs .com/google_containers/$imageName terminé
Vérifiez si l'image a été téléchargée avec succès images docker
Déployez uniquement le nœud maître de k8s
kubeadm init \
--kubernetes-version v1.17.4 \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16 \
--apiserver-advertise-address=192.168.6.100
La ligne de commande vous demandera
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
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/
Then you can join any number of worker nodes by running the following on each as root:
kubeadm join 192.168.6.101:6443 --token sv5epz.4f8hvj7ukjlrv857 \
--discovery-token-ca-cert-hash sha256:56bc77d7c4c95cc7aca777185e14274e4f99bc8d3b21da65d89ff19987e83554 Entrez ensuite
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config
Entrez sur un autre serveur
kubeadm join 192.168.6.101:6443 --token sv5epz.4f8hvj7ukjlrv857 \
--discovery-token-ca-cert-hash sha256:56bc77d7c4c95cc7aca777185e14274e4f99bc8d3b21da65d89ff199547e835
Afficher les nœuds
kubectl obtenir des nœuds
Ensuite, le nœud nœud n'est pas connecté après l'entrée, et la raison en est que le nœud nœud ne peut pas être démarré automatiquement. Vous devez copier le fichier /etc/kubernetes/admin.conf du nœud maître sur le serveur du nœud nœud.
Installez le plugin réseau sur le nœud maître
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
Démarrer la flanelle avec le fichier de configuration
kubectl appliquer -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
Consultez la progression du déploiement du plug-in réseau CNI :
kubectl get pods -n kube-system
Vérifiez l'état du cluster :
kubectl obtenir cs