Explorer le cluster Kubernetes

KubernetesBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire (lab), vous allez explorer un cluster Kubernetes local en utilisant Minikube. Vous allez démarrer le cluster, vérifier sa configuration et inspecter les ressources de base du cluster telles que les pods et les déploiements (deployments). Cette expérience pratique vous aidera à comprendre les composants et les commandes fondamentales d'un environnement Kubernetes, en jetant les bases pour une exploration et un développement ultérieurs.

Vous commencerez par configurer un cluster Minikube sur votre machine locale, en vous assurant que le cluster est en cours d'exécution et prêt à être utilisé. Ensuite, vous vérifierez la configuration et l'état du cluster en utilisant les commandes kubectl essentielles, telles que kubectl cluster-info et kubectl get nodes. Enfin, vous inspecterez les ressources de base du cluster, y compris les pods et les déploiements (deployments), pour vous familiariser avec le modèle d'objet Kubernetes et l'état global du cluster.

Démarrer le cluster Kubernetes local

Dans cette étape, vous allez démarrer et vérifier un cluster Kubernetes local en utilisant Minikube, qui offre un moyen simple de configurer un environnement Kubernetes mono - noeud pour l'apprentissage et le développement.

Tout d'abord, accédez au répertoire du projet :

cd ~/project

Démarrez le cluster Minikube :

Note : Les utilisateurs gratuits ne peuvent pas se connecter à Internet, donc Minikube est déjà démarré au démarrage du laboratoire (lab). Vous pouvez passer directement à la section de code ci - dessous pour vérifier l'état du cluster. Passez à la version Pro pour pratiquer le démarrage du cluster vous - même.

Uniquement pour les utilisateurs Pro
minikube start

Exemple de sortie :

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23...
🚀  Launching Kubernetes...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Vérifiez l'état du cluster en utilisant plusieurs commandes :

minikube status

Exemple de sortie :

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Vérifiez les noeuds du cluster :

kubectl get nodes

Exemple de sortie :

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Ces commandes confirment que :

  1. Minikube a été démarré avec succès
  2. Le cluster Kubernetes local est en cours d'exécution
  3. Le cluster est prêt à être utilisé
  4. Vous disposez d'un cluster mono - noeud avec des capacités de plan de contrôle

Le cluster Minikube fournit un environnement Kubernetes complet sur votre machine locale, vous permettant de développer et de tester des applications sans avoir besoin d'un cluster multi - noeuds complet.

Aperçu de l'architecture Kubernetes

Kubernetes fonctionne sur un modèle client-serveur, avec un Plan de Contrôle (Control Plane) centralisé qui gouverne l'état du cluster et un ensemble de nœuds (Nodes) de travail qui exécutent les charges de travail. Au niveau global, un utilisateur (souvent un développeur) interagit avec le cluster Kubernetes via des outils en ligne de commande ou des API. Le Plan de Contrôle prend des décisions sur ce qui doit être exécuté où, surveille l'état du cluster et s'assure que l'état souhaité est atteint. Les nœuds de travail hébergent vos applications dans des Pods - des groupes d'un ou plusieurs conteneurs - et offrent les ressources de calcul et de stockage nécessaires pour les exécuter.

Plan de Contrôle (Control Plane)

C'est le "cerveau" du cluster, composé de plusieurs composants qui travaillent ensemble pour gérer l'ensemble du système :

  • kube-apiserver (API) : Fait office de porte d'entrée du cluster. Toutes les commandes administratives et les demandes de ressources passent par lui.
  • etcd (Magasin clé-valeur) : Stocke toutes les données de configuration et l'état actuel du cluster. Si vous perdez les données d'etcd, vous perdez l'état du cluster.
  • kube-scheduler (SCH) : Assigne les Pods aux nœuds en fonction des besoins en ressources, des contraintes et des politiques.
  • kube-controller-manager (CTLM) : Exécute une variété de contrôleurs qui ajustent continuellement l'état du cluster, en s'assurant que l'état réel correspond à l'état souhaité défini par vos déploiements et configurations.

Nœuds (Machines de travail)

Les nœuds sont les endroits où les charges de travail s'exécutent. Chaque nœud possède :

  • kubelet (KLT) : Un agent au niveau du nœud qui communique avec le Plan de Contrôle. Il s'assure que les Pods sont en cours d'exécution et rapporte leur état au Plan de Contrôle.
  • Runtime de conteneur (CR) : Logiciel qui exécute et gère les conteneurs (par exemple, Docker ou containerd). Il crée et gère les applications conteneurisées au sein des Pods.

Pods

Un Pod est l'unité déployable la plus petite dans Kubernetes, représentant généralement une instance unique d'une application en cours d'exécution. Les Pods peuvent contenir un ou plusieurs conteneurs qui partagent le même espace de noms réseau et les mêmes volumes de stockage.

Services

Un Service est une abstraction qui définit un ensemble logique de Pods et une politique pour y accéder. Les Services fournissent des adresses IP stables, des noms DNS et un équilibrage de charge, garantissant que les consommateurs externes et les autres composants du cluster peuvent se connecter de manière fiable à vos applications - même lorsque les Pods se déplacent entre les nœuds ou sont remplacés lors de mises à l'échelle ou de mises à jour incrémentielles.

Interaction avec le cluster

  • Les développeurs et les administrateurs interagissent avec le cluster via le kube-apiserver, souvent en utilisant kubectl ou d'autres clients Kubernetes.
  • Lorsqu'une nouvelle application est déployée, les composants du Plan de Contrôle (planificateur, contrôleurs) travaillent pour placer les Pods sur les nœuds appropriés.
  • Le kubelet sur chaque nœud s'assure que les Pods sont en bonne santé et s'exécutent comme instructé.
  • Les Services acheminent le trafic vers les Pods appropriés, permettant aux clients d'accéder aux applications sans avoir à suivre les changements d'emplacement des Pods.
flowchart TB %% User interacting with the cluster User((Developer)) User -->|kubectl CLI| API[kube-apiserver] %% Control Plane Components subgraph ControlPlane[Control Plane] API ETCD[etcd - Key Value Store] SCH[kube-scheduler] CTLM[kube-controller-manager] API --> ETCD API --> SCH API --> CTLM end %% Worker Node 1 subgraph Node1[Worker Node] KLT1[kubelet] CR1[Container Runtime] subgraph Pods1[Pods] P1[Pod] P2[Pod] end KLT1 --> CR1 CR1 --> P1 CR1 --> P2 end %% Worker Node 2 subgraph Node2[Worker Node] KLT2[kubelet] CR2[Container Runtime] subgraph Pods2[Pods] P3[Pod] P4[Pod] end KLT2 --> CR2 CR2 --> P3 CR2 --> P4 end %% Connections between Control Plane and Nodes API --> KLT1 API --> KLT2 %% Service connecting to Pods across different Nodes Service[Service] Service --> P1 Service --> P2 Service --> P3 Service --> P4

Dans le diagramme :

  • Le développeur interagit avec le kube-apiserver (API) via un outil en ligne de commande comme kubectl.
  • Les composants du Plan de Contrôle (API, etcd, Planificateur, Gestionnaire de contrôleurs) gèrent l'état du cluster et orchestrent les charges de travail.
  • Chaque nœud de travail exécute un kubelet et un runtime de conteneur, hébergeant plusieurs Pods.
  • Un Service achemine le trafic externe ou interne vers les Pods appropriés, fournissant un point d'accès stable qui abstrait la complexité des cycles de vie des Pods et des changements d'adresse IP.

Ce modèle conceptuel vous aide à comprendre ce que vous voyez lorsque vous inspectez l'état du cluster, vérifiez l'état des nœuds, liste les Pods et interrogez les Services - des concepts que vous appliquerez au fur et à mesure que vous continuerez à explorer Kubernetes avec les commandes kubectl.

Vérifier la configuration du cluster

Dans cette étape, vous allez apprendre à vérifier la configuration et l'état de santé de votre cluster Kubernetes en utilisant les commandes kubectl essentielles. Ces commandes vous aideront à comprendre l'état actuel et la connectivité du cluster.

Tout d'abord, vérifiez les informations du cluster :

kubectl cluster-info

Exemple de sortie :

Kubernetes control plane is running at https://192.168.49.2:8443
CoreDNS is running at https://192.168.49.2:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'

Cette commande fournit des détails sur le plan de contrôle Kubernetes et les services de base tels que CoreDNS.

Ensuite, obtenez une vue détaillée des nœuds du cluster :

kubectl get nodes -o wide

Exemple de sortie :

NAME       STATUS   ROLES           AGE    VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION
minikube   Ready    control-plane   15m    v1.26.1   192.168.49.2   <none>        Ubuntu 22.04 LTS    5.15.0-72-generic

Examinons plus en détail les informations sur le nœud :

kubectl describe node minikube

Exemple de sortie (partielle) :

Name:               minikube
Roles:              control-plane
Labels:             beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
                    kubernetes.io/arch=amd64
                    kubernetes.io/hostname=minikube
                    kubernetes.io/os=linux
                    minikube.k8s.io/commit=86a3b7e45a9a35cdcf8f4c80a4c6a46d20dda00f
Annotations:        node.alpha.kubernetes.io/ttl: 0
                    volumes.kubernetes.io/controller-managed-attach-detach: true
CreationTimestamp:  [Current Timestamp]
Capacity:
  cpu:                2
  ephemeral-storage:  17784212Ki
  memory:             1947748Ki
  pods:               110
Allocatable:
  cpu:                2
  ephemeral-storage:  16388876Ki
  memory:             1845348Ki
  pods:               110

Principales informations fournies par ces commandes :

  1. Vérifiez que le plan de contrôle du cluster est en cours d'exécution.
  2. Vérifiez l'état des nœuds (Prêt/Non prêt).
  3. Comprenez les ressources et la configuration des nœuds.
  4. Confirmez la version de Kubernetes et les détails des nœuds.

Inspecter les ressources de base du cluster

Dans cette étape, vous allez inspecter les ressources de base de Kubernetes telles que les Pods, les Déploiements (Deployments) et les Services dans tous les espaces de noms (Namespaces). En utilisant le flag -A (ou --all-namespaces), vous verrez comment les ressources sont organisées dans tout le cluster. C'est une excellente occasion d'introduire et de comprendre le concept des Espaces de noms dans Kubernetes.

Espaces de noms : Isolation des ressources

Les espaces de noms sont des partitions logiques au sein d'un cluster Kubernetes qui aident à organiser et à gérer les ressources. Ils offrent un moyen de regrouper les objets liés et d'appliquer des politiques, des contrôles d'accès et des quotas de ressources de manière granulaire. En séparant les ressources dans différents espaces de noms, vous pouvez :

  • Améliorer l'organisation : Regrouper les charges de travail liées (par exemple, par projet, équipe ou environnement comme le développement, les tests et la production).
  • Renforcer la sécurité et le contrôle d'accès : Restreindre les utilisateurs ou les comptes de service qui peuvent consulter ou modifier les ressources dans un espace de noms particulier.
  • Simplifier la gestion des ressources : Appliquer plus efficacement des limites de ressources, des politiques réseau et d'autres configurations à l'échelle du cluster.

Lorsque vous liste les ressources avec le flag -A (ou --all-namespaces), vous remarquerez que les composants appartenant au système Kubernetes résident dans l'espace de noms kube-system, qui est dédié à l'infrastructure au niveau du cluster. Les applications créées par l'utilisateur résident généralement dans l'espace de noms default ou dans d'autres espaces de noms personnalisés que vous définissez.

Espaces de noms et ressources

flowchart LR %% User interacts with the cluster via kube-apiserver User((Developer)) User -->|kubectl get pods -A| API[kube-apiserver] %% Control Plane Subgraph subgraph ControlPlane[Control Plane] API ETCD[etcd] SCH[kube-scheduler] CTLM[kube-controller-manager] end API --> ETCD API --> SCH API --> CTLM %% kube-system namespace subgraph kube-system[Namespace: kube-system] SysDeployment[Deployment: coredns] SysPod1[Pod: coredns-xxx] SysService[Service: kube-dns] SysDeployment --> SysPod1 SysService --> SysPod1 end %% default namespace (renamed to avoid parse issues) subgraph defaultNs[Namespace: default] DefDeployment[Deployment: my-app] DefPod1[Pod: my-app-pod1] DefPod2[Pod: my-app-pod2] DefService[Service: my-app-service] DefDeployment --> DefPod1 DefDeployment --> DefPod2 DefService --> DefPod1 DefService --> DefPod2 end %% dev namespace subgraph dev[Namespace: dev] DevDeployment[Deployment: dev-app] DevPod[Pod: dev-app-pod] DevService[Service: dev-app-service] DevDeployment --> DevPod DevService --> DevPod end %% Demonstration of communication API --> kube-system API --> defaultNs API --> dev

Dans le diagramme :

  • Le Plan de contrôle gère l'ensemble du cluster, communiquant avec les nœuds et contrôlant les charges de travail.
  • Les Espaces de noms (tels que kube-system, default et dev) séparent logiquement les ressources au sein du cluster.
    • kube-system contient les composants au niveau du système comme CoreDNS et kube-dns.
    • default est couramment utilisé pour les charges de travail générales, représenté ici par un déploiement my-app.
    • dev peut représenter un environnement de développement, isolé des charges de travail de production.

En visualisant les ressources dans tous les espaces de noms, vous obtenez une compréhension globale de la façon dont ces partitions logiques contribuent à maintenir un cluster organisé et sécurisé.

Exemples :

Lister tous les pods dans tous les espaces de noms :

kubectl get pods -A

Exemple de sortie :

NAMESPACE     NAME                               READY   STATUS    RESTARTS      AGE
kube-system   coredns-787d4945fb-j8rhx           1/1     Running   0             20m
kube-system   etcd-minikube                      1/1     Running   0             20m
kube-system   kube-apiserver-minikube            1/1     Running   0             20m
kube-system   kube-controller-manager-minikube   1/1     Running   0             20m
kube-system   kube-proxy-xb9rz                   1/1     Running   0             20m
kube-system   kube-scheduler-minikube            1/1     Running   0             20m
kube-system   storage-provisioner                1/1     Running   1 (20m ago)   20m

Ici, vous voyez tous les pods liés au système en cours d'exécution dans l'espace de noms kube-system. Si vous aviez d'autres déploiements ou services dans différents espaces de noms, ils apparaîtraient également dans cette liste, chacun clairement limité par son espace de noms.

Lister tous les déploiements dans tous les espaces de noms :

kubectl get deployments -A

Exemple de sortie :

NAMESPACE     NAME      READY   UP-TO-DATE   AVAILABLE   AGE
kube-system   coredns   1/1     1            1           20m

Le déploiement coredns réside dans l'espace de noms kube-system.

Obtenir une vue complète de toutes les ressources dans tous les espaces de noms :

kubectl get all -A

Cette commande affiche un aperçu des pods, des services et des déploiements dans différents espaces de noms, vous aidant à comprendre comment ces ressources sont réparties dans le cluster.

Points clés :

  • Les Espaces de noms offrent une isolation et une organisation logiques au sein d'un cluster Kubernetes.
  • Différents composants et ressources de Kubernetes sont organisés dans des espaces de noms spécifiques (par exemple, kube-system pour les services de base, default pour les charges de travail générales et d'autres espaces de noms que vous créez).
  • En utilisant -A pour visualiser les ressources dans tous les espaces de noms, vous obtenez une idée de la structure de votre cluster et de la façon dont les espaces de noms servent de limites pour l'organisation des ressources et le contrôle d'accès.

En comprenant le fonctionnement des espaces de noms comme des environnements logiques, vous pouvez mieux naviguer, isoler et gérer vos charges de travail et les ressources de cluster associées, surtout lorsque vous élargissez vos déploiements et introduisez plus de complexité dans votre environnement Kubernetes.

Résumé

Dans ce laboratoire, vous avez démarré et vérifié un cluster Kubernetes local en utilisant Minikube, qui offre un moyen simple de configurer un environnement Kubernetes mono - noeud pour l'apprentissage et le développement. Vous avez confirmé que le cluster Minikube a été démarré avec succès, que le cluster Kubernetes local est en cours d'exécution, que le cluster est prêt à être utilisé et que vous disposez d'un cluster mono - noeud avec des capacités de plan de contrôle. Vous avez également appris à vérifier la configuration et l'état de santé de votre cluster Kubernetes en utilisant les commandes kubectl essentielles, telles que kubectl cluster-info et kubectl get nodes, qui vous ont aidé à comprendre l'état actuel et la connectivité du cluster.