Un guide pour débutant à Kubernetes

Qu'est-ce que Kubernetes?

Kubernetes ou K8S est une plate-forme gratuite et open source pour gérer les environnements et services d'application conteneurisés. Kubernetes vous permet de créer des applications conteneurisées portables et hautement extensibles qui sont faciles à déployer et à gérer. Il est couramment utilisé aux côtés de Docker pour développer un meilleur contrôle des applications et services conteneurisés.

Caractéristiques de Kubernetes

Voici les fonctionnalités essentielles offertes par Kubernetes:

1. Déploiements automatisés et reculs dans le cas où des erreurs se produisent.
2. Infrastructure automatique évolutive.
3. Mise à l'échelle horizontale
4. Équilibreur de chargement
5. Contrôles de santé automatisés et capacités d'auto-guérison.
6. Infrastructure hautement prévisible
7. Montures et système de stockage pour exécuter les applications
8. Utilisation efficace des ressources
9. Chaque unité de Kubernetes est liée de manière lâche les unes avec les autres, et chacune peut agir comme un composant autonome.
10. Gestion automatique des composants de sécurité, de réseau et de réseau.

Architecture de Kubernetes

Comprendre l'architecture Kubernetes vous aidera à acquérir une connaissance plus approfondie de la façon de travailler avec Kubernetes.

Voici les composants matériels de l'architecture Kubernetes:

Un nœud est une représentation d'une seule machine dans un cluster Kubernetes. Le nœud représente une seule machine de travailleur, soit dans une machine virtuelle ou un matériel physique.

Chaque nœud à Kubernetes comprend divers composants logiciels Kubernetes tels que les pods, le kubulet, le kube-proxy et l'exécution du conteneur tel que Docker.

Un pod fait référence à une ou plusieurs applications conteneurisées regroupées ensemble. Kubernetes gère les gousses respectives au lieu des conteneurs et crée des répliques si l'un d'eux échoue. Les pods fournissent des ressources partagées telles que les interfaces réseau et les périphériques de stockage.

Conteneur / conteneur-runtime

Un conteneur est un progiciel isolé et autonome. Un conteneur contient tout ce qui est nécessaire pour exécuter une application, y compris le code, les bibliothèques système et d'autres dépendances. Une fois qu'un conteneur est déployé, vous ne pouvez pas modifier le code car il est immuable. Par défaut, l'exécution du conteneur de Kubernetes est fournie par Docker.

Kublet

Le kubelet est une application simple qui permet la communication entre le nœud et le nœud maître. Il est responsable de la gestion des gousses et des conteneurs. Le nœud maître utilise le kubectl pour effectuer les actions nécessaires au nœud spécifique.

Kube

Le Kube-Proxy est un proxy réseau disponible dans tous les nœuds Kubernetes. Il gère les communications réseau à l'intérieur et à l'extérieur du cluster.

Grappe

Un cluster est une collection de nœuds Kubernetes qui agrégent leurs ressources pour créer une machine puissante. Les ressources partagées par les nœuds Kubernetes incluent la mémoire, le processeur et les disques.

Un cluster Kubernetes est composé d'un nœud maître et d'autres nœuds esclaves. Le nœud maître contrôle le cluster Kubernetes, y compris les applications de planification et d'échelle, de pousser et d'appliquer des mises à jour et de gérer les états de cluster.

Volumes persistants

Des volumes persistants sont utilisés pour stocker des données dans un cluster Kubernetes. Les volumes persistants sont faits de divers volumes à partir des nœuds de cluster. Une fois qu'un nœud dans le cluster est supprimé ou ajouté, le nœud maître distribue efficacement le travail.

Entrée

L'engression de Kubernetes est un objet API qui permet d'accéder au service Kubernetes en dehors du cluster. La pénétration utilise généralement le protocole HTTP / HTTPS pour exposer les services. Une entrée est implémentée dans un cluster à l'aide d'un contrôleur d'entrée ou d'un équilibreur de charge.

Maître

Le maître, également connu sous le nom de plan de contrôle, fait référence au composant de contrôle central de l'architecture Kubernetes. Il est chargé de gérer la charge de travail et d'interfacer la communication entre le cluster et ses membres.

Le maître est composé de divers composants. Ceux-ci inclus:

1. Responsable du contrôle
2. Planificateur
3. Serveur API
4. Etcd

Responsable du contrôle

Le Control Manager ou Kube-Control-Manager est responsable de l'exécution et de la gestion du cluster. Le démon de contrôle recueille des informations sur le cluster et les rapporte au serveur d'API.

Planificateur

Le Kube-Scheduler ou simplement le planificateur est responsable de la distribution de la charge de travail. Il remplit des fonctions telles que déterminer si le cluster est sain, la création de conteneurs, et plus.

Il garde une trace des ressources telles que la mémoire et le processeur et les pods de planification aux nœuds de calcul appropriés.

Serveur API

Le Kube-apiserver est une interface frontale avec le maître de Kubernetes. Il vous permet de parler au cluster Kubernetes. Une fois que le serveur API a reçu une demande, il détermine si la demande est valide et la traite si elle est vraie.

Pour interagir avec le serveur API, vous devez utiliser les appels de repos via les outils de contrôle de ligne de commande tels que Kubectl ou Kubeadm.

Etcd

L'ETCD est une base de données de valeur clé responsable du stockage des données de configuration et des informations sur l'état du cluster Kubernetes. Il reçoit des commandes des autres composants de cluster et effectue les actions nécessaires.

Exécution de Kubernetes

Cette section couvre comment démarrer avec Kubernetes. Cette illustration est testée sur un système Debian.

Lancez le terminal et mettez à jour votre système.

Mise à jour Sudo apt-get
SUDO APT-GET ANGRADE

Ensuite, installez diverses exigences comme indiqué dans la commande ci-dessous:

sudo apt-get install curl gnupg ca-certificats apt-transport-https

Installer Docker

Ensuite, nous devons installer Docker car Kubernetes l'utilisera comme l'exécution du conteneur. Les instructions ci-dessous sont pour le système d'exploitation Debian. Apprenez à installer Docker sur votre système.

Ajouter la clé GPG officielle Docker:

curl -fssl https: // télécharger.docker.com / linux / debian / gpg | Sudo
gpg --dearmor -o / usr / share / keyrings / docker-archive-keyring.GPG

Ensuite, configurez les référentiels Docker aux sources comme indiqué dans la commande:

écho \
"Deb [Arch = AMD64 Signed-by = / usr / share / clés / docker-archive-keyring.gpg] https: // télécharger.docker.com / linux / debian \
$ (lsb_release -cs) stable "| sudo tee / etc / apt / sources.liste.d / docker.liste> / dev / null

Ensuite, mettez à jour et installez Docker:

Sudo Apt-Get Update && sudo apt-get install docker-ce contenerd.IO Docker-CE-CLI

Enfin, démarrez et activez le service Docker

sudo systemctl activer docker.service
sudo systemctl start docker.service

Installer Kubernetes

Ensuite, nous devons installer des kubernetes sur le système. De même, les instructions de ce guide sont testées sur un système Debian.

Apprenez à installer Kubernetes sur votre système

Commencez par télécharger la clé de signature de Google Cloud:

sudo curl -fsslo / usr / share / keyrings / kubernetes-archive-keyring.gpg https: // packages.nuage.Google.com / apt / doc / apt-key.GPG

Ensuite, ajoutez le référentiel Kubernetes:

echo "Deb [signé-by = / usr / share / clés / kubernetes-archive-keyring.gpg] https: // apt.kubernetes.IO / Kubernetes-Xenial Main "| Sudo Tee / etc / APT / Sources.liste.d / kubernetes.liste

Enfin, mettez à jour et installez les composants Kubernetes

Mise à jour Sudo apt-get

sudo apt-get install kubectl kubelet kubeadm kubernetes kubernetes-cni

Nœud maître initiale Kubernetes

L'étape suivante consiste à démarrer le nœud maître Kubernetes. Avant de faire cela, il est recommandé d'éteindre l'échange.

Pour ce faire, utilisez la commande:

sudo swapoff -a

Une fois que vous éteignez l'échange, initialisez le nœud maître avec les commandes:

sudo kubeadm init

Une fois la commande exécutée avec succès, vous devriez obtenir trois commandes.

Copiez et exécutez les commandes comme:

mkdir -p $ home /.kube \
sudo cp -i / etc / kubernetes / admin.Conf $ home /.kube / config \
sudo chown $ (id -u): $ (id -g) $ home /.kube / config

Déployer le réseau POD

L'étape suivante consiste à déployer un réseau de pod. Dans ce guide, nous utiliserons le VPC CNI AWS pour Kubernetes.

Utilisez la commande comme:

sudo kubectl appliquer -f https: // brut.githubusercontent.com / aws / amazon-vpc-cni-k8s / v1.8.0 / config / v1.8 / AWS-K8S-CNI.yaml

Une fois terminé, assurez-vous que le cluster est opérationnel en exécutant la commande:

Sudo Kubectl Cluster-Info

Il serait préférable que vous obteniez la sortie comme indiqué:

Kubernetes Control Plane fonctionne sur https: // 192.168.43.29: 6443
Coredns fonctionne sur https: // 192.168.43.29: 6443 / API / V1 / Espaces de noms / Kube-System / Services / Kube-DNS: DNS / Proxy

Pour afficher tous les nœuds en cours d'exécution, utilisez la commande:

sudo kubectl obtenir des nœuds

Déploier une demande

Déployons une application MySQL et exposons le service sur le port 3306. Utilisez la commande comme indiqué:

sudo kubectl appliquer -f https: // k8s.IO / Exemples / Application / MySQL / MySQL-déploiement.yaml
Sudo Kubectl Expose Deployment MySQL --port = 3306 --name = MySQL-Server

Pour afficher la liste des déploiements, utilisez la commande:

Kubectl obtient des déploiements

Pour obtenir des informations sur les pods, utilisez la commande:

sudo kubectl décrivent les pods

Pour résumer

Kubernetes est un outil de déploiement et de gestion des conteneurs robustes. Ce tutoriel ne fait que gratter la surface de Kubernetes et ses capacités.