Créer un cluster Kubernetes à plan de contrôle unique avec kubeadm

Introduction

Kubernetes est un cluster et orchestration moteur pour les conteneurs Docker. En d'autres termes, Kubernetes est un logiciel ou un outil open source utilisé pour orchestrer et gérer les conteneurs Docker dans un environnement de cluster. Kubernetes est également connu sous le nom de k8s et il a été développé par Google et donné à la "fondation Cloud Native Computing"

Objectif

Cette configuration du cluster Kubernetes aura 1 nœud maître avec CentOS 7 et 2 nœuds de calcul également connu sous le nom de sbires avoir des serveurs Windows 2k19 système d'exploitation.

Nous installerons et configurerons le cluster Kubernetes sur les machines virtuelles du centre de données pour gérer les conteneurs Docker. Ce cluster comprend 1 maître (Linux) et 2 nœuds de travail (Windows), le maître contrôlera les horaires et les déploiements de pods sur les nœuds de travail.

Schéma d'architecture Kubernetes

Quelques informations importantes sur la terminologie Kubernetes besoin de savoir avant de commencer la configuration

ETCD (nœud de cluster) :Kubernetes utilise "etcd" en tant que magasin de base de données clé-valeur. Il stocke la configuration du cluster Kubernetes dans "etcd" .

kube-controller-manager : Le gestionnaire de contrôleur Kubernetes est un démon qui intègre les boucles de contrôle principales fournies avec Kubernetes. Dans Kubernetes, un contrôleur est une boucle de contrôle qui surveille l'état partagé du cluster via le "apiserver" et apporte des modifications en tentant de déplacer l'état actuel vers l'état souhaité. Des exemples de contrôleurs livrés avec Kubernetes aujourd'hui sont le contrôleur de réplication, le contrôleur de points de terminaison, le contrôleur d'espace de noms et le contrôleur de comptes de service

kube-apiserver :Le serveur d'API Kubernetes valide et configure les données des objets API qui incluent les pods, les services, les contrôleurs de réplication et autres. Le serveur d'API gère les opérations REST et fournit l'interface de l'état partagé du cluster à travers lequel tous les autres composants interagissent.

planificateur de kube : Le planificateur Kubernetes est une fonction riche en règles, sensible à la topologie et spécifique à la charge de travail qui a un impact significatif sur la disponibilité, les performances et la capacité. Le planificateur doit prendre en compte les besoins en ressources individuelles et collectives, les exigences en matière de qualité de service, les contraintes matérielles/logicielles/politiques, les spécifications d'affinité et d'anti-affinité, la localité des données, les interférences entre les charges de travail, les délais, etc.

kubelet :Le "kubelet" est le principal "agent de nœud ” qui s'exécute sur chaque nœud. Il peut enregistrer le nœud auprès de l'apiserver en utilisant l'un des éléments suivants :le nom d'hôte ; un indicateur pour remplacer le nom d'hôte ; ou une logique spécifique pour un fournisseur de cloud.

kube-proxy :Le proxy réseau Kubernetes s'exécute sur chaque nœud. Cela reflète les services tels que définis dans l'API Kubernetes sur chaque nœud et peut effectuer un simple transfert de flux TCP, UDP et SCTP ou un transfert circulaire TCP, UDP et SCTP sur un ensemble de back-ends.

Description de la configuration du cluster Kubernetes

Dans la configuration de Kubernetes, nous avons 1 nœud maître (CentOS 7) et 2 nœuds de travail (Win 2k19). Depuis le nœud maître, nous pouvons gérer le cluster et ses nœuds à l'aide de 'kubeadm 'et 'kubectl 'commande.

Kubernetes peut être installé et déployé à l'aide des méthodes suivantes :

Minikube (il s'agit d'un cluster Kubernetes à nœud unique)
Kops (configuration de kubernetes multi-nœuds dans AWS)
Kubeadm (Cluster multi-nœuds dans nos propres locaux)

Dans cet article, nous installerons la dernière version de Kubernetes 1.16 sur CentOS 7 / RHEL 7 avec l'utilitaire kubeadm. Dans cette configuration, nous prenons 1 serveur CentOS 7 et 2 serveurs Windows 2k19 avec une installation minimale. Un serveur agira comme nœud maître et les deux autres serveurs seront des nœuds minion ou worker

Sur le nœud maître, les composants suivants seront installés

Serveur d'API - Il fournit l'API kubernetes en utilisant Jason / Yaml sur http, les états des objets API sont stockés dans etcd
Planificateur - Il s'agit d'un programme sur le nœud maître qui effectue les tâches de planification telles que le lancement de conteneurs dans les nœuds de travail en fonction de la disponibilité des ressources
Gestionnaire du contrôleur - Le travail principal du gestionnaire de contrôleur consiste à surveiller les contrôleurs de réplication et à créer des pods pour maintenir l'état souhaité.
etcd - Il s'agit d'une base de données de paires de valeurs clés. Il stocke les données de configuration du cluster et de l'état du cluster.
Utilitaire Kubectl - Il s'agit d'un utilitaire de ligne de commande qui se connecte au serveur API sur le port 6443. Il est utilisé par les administrateurs pour créer des pods, des services, etc.

Sur les nœuds de travail, les composants suivants seront installés

Kubelet - C'est un agent qui s'exécute sur chaque nœud de travail, il se connecte à Docker et s'occupe de créer, démarrer, supprimer des conteneurs.
Proxy Kube – Il achemine le trafic vers les conteneurs appropriés en fonction de l'adresse IP et du numéro de port de la demande entrante. En d'autres termes, nous pouvons dire qu'il est utilisé pour la traduction du port.
Cosse – Le pod peut être défini comme un multiniveau ou un groupe de conteneurs déployés sur un nœud de travail unique ou un hôte Docker.

Étapes d'installation de Kubernetes 1.16 sur CentOS 7

Étape 1 : Définissez le nom d'hôte, désactivez SELinux et configurez le pare-feu, dans notre cas, le pare-feu et SELinux sont à l'état désactivé et le nom d'hôte est défini comme kube-master. Et assurez-vous que tous les nœuds sont

Étape 2 : Configurer le référentiel Kubernetes

Les packages Kubernetes ne sont pas disponibles dans les référentiels CentOS 7 et RHEL 7 par défaut. Utilisez les URL ci-dessous pour configurer ses référentiels de packages.

Étape 3 : Installez Kubeadm et Docker en utilisant la commande ci-dessous

# yum install kubeadm docker -y

Ensuite, démarrez et activez kubectl et docker service en utilisant les commandes ci-dessous.

# systemctl restart docker && systemctl enable docker
# systemctl restart kubelet && systemctl enable kubelet

Étape 4 :Initialisez le maître Kubernetes avec ‘kubeadm init’

La sortie de la commande ci-dessus serait quelque chose comme ci-dessous

Comme nous pouvons le voir dans la sortie, le maître kubernetes a été initialisé avec succès. Exécutez les commandes ci-dessous pour utiliser le cluster en tant qu'utilisateur root.

Étape 5 :Déployer le réseau de pods sur le cluster

Essayez d'exécuter les commandes ci-dessous pour obtenir l'état du cluster et des pods.

kubectl get nodes
kubectl get pods –all-namespaces

Pour que l'état du cluster soit prêt et que l'état kube-dns soit en cours d'exécution, déployez le réseau de pods afin que les conteneurs de différents hôtes communiquent entre eux. Le réseau POD est le réseau superposé entre les nœuds de travail.

Exécutez la commande ci-dessous pour déployer le réseau.

Exécutez maintenant les commandes suivantes pour vérifier l'état. Comme nous pouvons voir que le nœud maître est maintenant prêt, nous allons maintenant ajouter des nœuds de travail à ce cluster kubernetes.

Sélection et configuration de la solution réseau du cluster Kubernetes

Une fois que vous avez configuré un nœud maître Kubernetes, vous êtes prêt à choisir une solution de mise en réseau. Il existe plusieurs façons de rendre le sous-réseau du cluster virtuel routable entre les nœuds. Choisissez l'une des options suivantes pour Kubernetes sur Windows dès aujourd'hui :

Utilisez un plug-in CNI tel que Flannel pour configurer un réseau superposé pour vous.
Utilisez un plug-in CNI tel que Flannel pour programmer les itinéraires pour vous (utilise le mode réseau l2bridge).
Configurez un commutateur intelligent Top-of-Rack (ToR) pour acheminer le sous-réseau.

Flanelle en mode vxlan

Flannel en mode vxlan peut être utilisé pour configurer un réseau superposé virtuel configurable qui utilise le tunnel VXLAN pour acheminer les paquets entre les nœuds.

Préparer le maître Kubernetes pour Flannel

Une préparation mineure est recommandée sur le maître Kubernetes de notre cluster. Il est recommandé d'activer le trafic IPv4 ponté vers les chaînes iptables lors de l'utilisation de Flannel. Cela peut être fait en utilisant la commande suivante :

# sudo sysctl net.bridge.bridge-nf-call-iptables=1

Télécharger et configurer Flannel

Téléchargez le manifeste Flannel le plus récent à l'aide de la commande ci-dessous :

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Il y a deux sections que vous devez modifier pour activer le backend de mise en réseau vxlan :

Dans net-conf.json section de votre kube-flannel.yml , revérifiez :
- Le sous-réseau du cluster (par exemple "10.244.0.0/16") est défini comme souhaité.
- VNI 4096 est défini dans le backend
- Le port 4789 est défini dans le backend
Dans le cni-conf.json section de votre kube-flannel.yml , remplacez le nom du réseau par "vxlan0" .

Après avoir appliqué les étapes ci-dessus, votre net-conf.json devrait ressembler à ceci :

Votre cni-conf.json devrait ressembler à ceci :

Lancer Flannel et valider

Lancez Flannel à l'aide de la commande

# kubectl apply -f kube-flannel.yml

Ensuite, puisque les pods Flannel sont basés sur Linux, appliquez notre correctif Linux NodeSelector à kube-flannel-ds DaemonSet pour cibler uniquement Linux en utilisant les commandes ci-dessous pour télécharger et configurer NodeSelector

# wget https://github.com/microsoft/SDN/blob/master/Kubernetes/flannel/l2bridge/manifests/node-selector-patch.yml

# kubectl patch ds/kube-flannel-ds-amd64 --patch "$(cat node-selector-patch.yml)" -n=kube-system

Après quelques minutes, vous devriez voir tous les pods en cours d'exécution si le réseau de pods Flannel a été déployé.

Joindre les nœuds de travail Windows au cluster kubernetes

Une fois que vous avez configuré un nœud maître Kubernetes et sélectionné la solution réseau souhaitée, vous êtes prêt à rejoindre les nœuds Windows Server pour former un cluster. Cela nécessite une certaine préparation sur les nœuds Windows avant de rejoindre.

Préparer un nœud Windows

Installer Docker (nécessite un redémarrage)

Kubernetes utilise Docker comme moteur de conteneur, nous devons donc l'installer. Vous pouvez suivre les instructions officielles de Docs, les instructions Docker ou essayer les étapes ci-dessous :

Install-Module -Name DockerMsftProvider -Repository PSGallery -Force
Install-Package -Name Docker -ProviderName DockerMsftProvider
Restart-Computer –Force

Si vous êtes derrière un proxy, les variables d'environnement PowerShell suivantes doivent être définies :

[Environnement]::SetEnvironmentVariable("HTTP_PROXY", "http://proxy.example.com:80/", [EnvironmentVariableTarget]::Machine)

[Environnement]::SetEnvironmentVariable("HTTPS_PROXY", "http://proxy.example.com:443/", [EnvironmentVariableTarget]::Machine)

Si après le redémarrage, vous voyez l'erreur suivante :

Ensuite, démarrez le service Docker manuellement :

Menu fixe de démarrage du service

Préparer le répertoire Kubernetes pour Windows

Créez un répertoire "Kubernetes pour Windows" pour stocker les fichiers binaires Kubernetes ainsi que les scripts de déploiement et les fichiers de configuration.

mkdir c:\k

Copier le certificat Kubernetes

Copiez le fichier de certificat Kubernetes ($HOME/.kube/config ) du maître vers ce nouveau C:\k répertoire.

Télécharger les binaires Kubernetes

Pour pouvoir exécuter Kubernetes, vous devez d'abord télécharger le kubectl , kubelet , et kube-proxy binaires. Vous pouvez les télécharger à partir des liens dans le CHANGELOG.md fichier des dernières versions.

Par exemple, voici les binaires de nœud v1.14.
Utilisez un outil comme Expand-Archive pour extraire l'archive et placer les binaires dans C:\k\ .

(Facultatif) Configurer kubectl sous Windows

Si vous souhaitez contrôler le cluster depuis Windows, vous pouvez le faire en utilisant le kubectl commande. Tout d'abord, pour créer kubectl disponible en dehors du C:\k\ répertoire, modifiez le PATH variable d'environnement :

$env:Path += ";C:\k"

Si vous souhaitez rendre ce changement permanent, modifiez la variable dans la cible machine :

[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\k", [EnvironmentVariableTarget]::Machine)

Ensuite, nous vérifierons que le certificat de cluster est valide. Afin de définir l'emplacement où kubectl recherche le fichier de configuration, vous pouvez passer le --kubeconfig paramètre ou modifier le KUBECONFIG variables d'environnement. Par exemple, si la configuration se trouve dans C:\k\config :

$env:KUBECONFIG="C:\k\config"

Pour rendre ce paramètre permanent pour la portée de l'utilisateur actuel :

[Environment]::SetEnvironmentVariable("KUBECONFIG", "C:\k\config", [EnvironmentVariableTarget]::User)

Enfin, pour vérifier si la configuration a bien été découverte, vous pouvez utiliser :

kubectl config view

Si vous recevez une erreur de connexion

Unable to connect to the server: dial tcp [::1]:8080: connectex: No connection could be made because the target machine actively refused it.

Vous devez revérifier l'emplacement de kubeconfig ou essayer de le copier à nouveau.

Si vous ne voyez aucune erreur, le nœud est maintenant prêt à rejoindre le cluster.

Rejoindre le nœud Windows

Selon la solution réseau que vous avez choisie, vous pouvez :

Joindre les nœuds Windows Server à un cluster Flannel (vxlan ou host-gw) (nous utilisons cette solution)
Joindre les nœuds Windows Server à un cluster avec un commutateur ToR

Rejoindre un cluster Flannel

Il existe une collection de scripts de déploiement Flannel sur ce référentiel Microsoft qui vous aide à joindre ce nœud au cluster.

Téléchargez le script Flannel start.ps1, dont le contenu doit être extrait vers C:\k :

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
wget https://raw.githubusercontent.com/Microsoft/SDN/master/Kubernetes/flannel/start.ps1 -o c:\k\start.ps1

En supposant que vous ayez préparé votre nœud Windows et votre c:\k répertoire se présente comme ci-dessous, vous êtes prêt à rejoindre le nœud.

Rejoindre le nœud Windows

Pour simplifier le processus d'adhésion à un nœud Windows, il vous suffit d'exécuter un seul script Windows pour lancer kubelet , kube-proxy , flanneld , et rejoignez le nœud.

cd c:\k

.\start.ps1 -ManagementIP <Windows Node IP> -NetworkMode <network mode>  -ClusterCIDR <Cluster CIDR> -ServiceCIDR <Service CIDR> -KubeDnsServiceIP <Kube-dns Service IP> -LogDir <Log directory>

Après l'avoir exécuté, vous devriez pouvoir :

Afficher les nœuds Windows joints à l'aide des nœuds get kubectl
Voir 3 fenêtres powershell ouvertes, une pour kubelet, une pour flanneld et une autre pour kube-proxy
Voir les processus d'agent hôte pour flanneld, kubelet et kube-proxy exécutés sur le nœud