Commandes kubectl

Kubectl travaille avec le cluster Kubernetes. Il s'agit d'un outil de ligne de commande qui est utilisé pour l'implémentation du cluster Kubernetes. Le «Kubectl» est la représentation de l'outil de ligne de commande «Kubernetes» utilisé pour exécuter des commandes pour les clusters Kubernetes. La plate-forme Kubectl vous permet de déployer, d'inspecter et de gérer les applications Kubernetes et les ressources de cluster. Cet article est spécialement conçu pour en savoir plus sur les commandes Kubectl utilisées avec le cluster Kubernetes.

Qu'est-ce que Kubectl?

Le Kubectl est un outil CLI officiel qui permet la communication avec le panneau de commande des grappes de Kubernetes via l'API Kubernetes. Il authentifie le cluster de nœuds maître et passe des appels API pour effectuer diverses actions de gestion. Lorsque vous commencez à travailler avec Kubernetes, vous devez passer beaucoup de temps avec Kubectl.

L'utilisation de la dernière version de Kubectl, qui est entièrement compatible avec votre version Ubuntu, vous aide à éviter les circonstances imprévues. Il existe différentes méthodes pour installer le kubectl pour utiliser les grappes de Kubernetes, la gestion des packages natifs, la commande «curl» pour installer binaire sur Linux, etc. Nous discuterons en détail de l'installation de Kubectl et vous guiderons sur la façon d'installer le kubectl dans les autres sections.

Comment utiliser la commande kubectl?

L'utilisation de commandes kubectl est très facile. La même syntaxe est suivie pour chaque commande. Voir la syntaxe générale de la commande kubectl fournie ci-dessous:

Kubectl

Cette même syntaxe est suivie pour chaque commande en modifiant la commande, le type, le nom et le drapeau avec Kubectl.

: Il représente la commande principale qui effectue l'application, la création, l'obtention, la suppression, etc. les fonctions.

: Il représente les ressources des Kubernetes, comme les gousses et les nœuds.

: Il représente le nom donné aux ressources. Si vous ne spécifiez pas le nom, Kubectl renvoie toutes les ressources représentées par le .

: Il représente toute commande spécifique ou globale supplémentaire à exécuter sur la ressource de cluster.

Voici plusieurs commandes Kubectl de base qui sont utilisées avec les clusters Kubernetes:

Commandes	Description
obtenir	Utilisé pour répertorier toutes les ressources, les packages et tout ce qui est spécifié par le
courir	Commencez à exécuter les instances de l'image sur le cluster
Créer	Créez le pod, le nœud, l'espace de noms, ou tout ce qui est spécifié par
déploiement	Créer un déploiement spécifié par le
espace de noms	Créer un espace de noms spécifié par le
Supprimer	Supprimer les ressources, les gousses, l'espace de noms, etc. spécifié par le
Appliquer	Appliquer la configuration sur le
Attacher	Joignez les ressources spécifiées par le conteneur
CP	Copier le fichier, le dossier, les ressources, ou tout ce qui est spécifié par
décrire	Décrire les ressources spécifiées par le
API-Version	Énumérez toutes les versions disponibles de l'API
cluster-info	Renvoie l'adresse des services et du panneau de configuration
Resources API	Énumérez toutes les ressources prises en charge disponibles de l'API
Configurer	Modifier la configuration des ressources dans le cluster Kubernetes

Ce sont les commandes de base kubectl qui s'exécutent avec une variété de services différents. Pour exécuter toutes ces commandes, vous devez avoir un minikube installé dans votre Ubuntu 20.04. Passez à la section suivante pour en savoir plus sur le minikube.

Qu'est-ce que Minikube?

Un seul nœud d'un cluster Kubernetes s'exécute sur chaque système d'exploitation, y compris Windows, Linux, MacOS, UNIX, etc. En termes simples, Minikube est un moteur Kubernetes local qui prend en charge toutes les fonctionnalités de Kubernetes pour son développement d'applications locales. Il crée une machine virtuelle dans une machine locale pour permettre l'implémentation de Kubernetes en déployant un simple cluster de nœuds unique composé de dockers qui permettent aux conteneurs d'exécuter à l'intérieur du nœud.

L'interface de ligne de commande de Minikube permet aux opérations de base de bootstrapage de fonctionner avec le cluster, qui comprend le démarrage, la suppression, le statut et l'arrêt. L'objectif principal de Minikube est d'être l'outil parfait pour le développement d'applications Kubernetes local. Il fournit l'environnement local parfait pour tester l'implémentation de Kubernetes sans utiliser de ressources supplémentaires.

Ce tutoriel montre la procédure complète pour installer Minikube sur Ubuntu 20.04.

Comment installer minikube sur Ubuntu?

Travailler avec Minikube est simple. Il prend en charge toutes les dernières versions de Kubernetes et est capable de travailler simultanément avec plusieurs conteneurs. Il simplifie toutes sortes d'implémentations locales de Kubernetes en fournissant une plate-forme de développement. Pour les tests, la mise en œuvre ou l'exécution de tout type d'application Kubernetes, un minikube doit être installé dans le système.

Avant de commencer l'installation du Minikube, voyons quelles conditions préalables devraient être remplies.

Conditions préalables

Comme nous installons le minikube sur Ubuntu 20.04, le système doit avoir Ubuntu 20.04 Courir. Les privilèges sudo doivent être activés pour un utilisateur de machine spécifique.

Jetez un œil à chaque étape et suivez les instructions pour installer en douceur le minikube.

Étape n ° 1: Mettez à jour le système

La première étape de l'installation du minikube est de mettre à jour le système. La commande «sudo apt-get upding» est utilisée pour mettre à jour le système. Regardez la commande et sa sortie ci-dessous:

Étape # 2: Améliorer le système

Une fois le système mis à jour avec toutes les mises à jour nouvelles et essentielles, mettez-la à la mise à niveau en utilisant la commande «Sudo apt-get upgrade». La commande «Mise à niveau» lit l'ensemble de la liste des packages et construit une arborescence de dépendance pour mettre à niveau le système pour un traitement ultérieur. Voici comment vous pouvez mettre à niveau votre système:

Étape # 3: Installer les packages

Maintenant que le système est mis à jour et mis à niveau avec toutes les mises à jour récentes, il est prêt à installer les packages nécessaires. Faites simplement une vérification rapide pour vous assurer que les packages ne sont pas déjà installés.

Installons «Curl», afin que nous puissions transférer HTTP, FTP, SFTC et tous les autres protocoles vers ou depuis un serveur. Reportez-vous à l'exécution de la commande «apt-get install curl» ci-dessous:

Pour installer le minikube, nous aurons besoin d'accéder aux référentiels via le protocole de transport HTTPS. Il est par défaut inclus dans le TRANSPORT-HTTPS. Si vous regardez la sortie ci-dessous, cela indique que les versions mises à jour des packages sont déjà installées:

Étape n ° 4: Installer Minikube

Dans ce tutoriel, nous utilisons Docker, nous n'installons donc pas la machine virtuelle séparément. En supposant que Docker est déjà en place, installons le minikube sur Ubuntu 20.04. Utilisez la commande «wget» pour télécharger et installer le minikube à partir du stockage Web. Le «WGET» est un utilitaire gratuit qui permet des téléchargements de fichiers non interactifs et directs à partir du Web. L'adresse Web est donnée ci-dessous, à partir de laquelle vous pouvez télécharger et installer Minikube dans Ubuntu 20.04:

Une fois le téléchargement terminé avec succès, copiez tous les fichiers et déplacez-les dans un dossier local, dites le dossier «/ usr / local / bin / minikube». Exécutez la commande complète ci-dessous sur votre terminal Ubuntu, et vous aurez vos fichiers téléchargés minikube copiés dans le dossier local, / usr / local / bin / minikube:

Si le processus de copie des fichiers a été effectué correctement et a réussi, vous n'aurez aucune sortie sur le terminal. La prochaine chose que vous devez faire est d'utiliser la commande «Chmod» pour permettre de déposer. Reportez-vous à la sortie d'exécution de la commande «CHMOD» ci-dessous:

Encore une fois, si le processus est correct et réussi, vous n'aurez aucune sortie sur le terminal. Si tel est le cas, alors vous avez réussi à installer le minikube sur Ubuntu 20.04. Maintenant, vérifions la version du minikube pour vous assurer qu'elle est installée avec succès. Pour cela, nous avons la commande «Version». La commande «Version» dans Ubuntu ou Linux est utilisée pour obtenir la version du logiciel, des packages ou tout ce qui est installé dans le système.

Comme vous pouvez le voir dans la sortie précédente, la version du minikube est renvoyée par la commande «Version», et c'est «V1.26.1".

Étape # 5: Installer Kubectl

Maintenant que nous avons réussi à installer Minikube sur notre Ubuntu 20.04 Système, notre système est prêt à tester et à exécuter les applications Kubernetes. Mais, avant de commencer les tests de Kubernetes, nous devons installer le kubectl. Comme indiqué précédemment, Kubectl permet à l'utilisateur de jouer avec Kubernetes sur la plate-forme Ubuntu. Encore une fois, utilisez la commande «Curl» pour télécharger le kubectl. La déclaration complète suivante est utilisée pour télécharger la commande kubectl sur Ubuntu 20.04:

Comme vous pouvez le voir dans la sortie que le kubectl est téléchargé avec succès; L'étape suivante consiste à faire un champ binaire exécutable. Installez le binaire Kubectl en utilisant le «Chmod + x ./ Kubectl ”Commande. Lorsque vous exécutez cette commande sur votre terminal Ubuntu, il installera le binaire Kubectl dans votre système. Encore une fois, si vous ne voyez aucune erreur ou toute autre sortie sur le terminal, cela signifie que le plugin est installé avec succès.

Suivez à nouveau le même processus et copiez tous les fichiers de votre dossier local, qui est / usr / local / bin / kubectl. Pour cela, utilisez la commande «Sudo MV». La commande «MV» dans le système Linux ou Unix est utilisée pour déplacer des fichiers d'un répertoire ou d'un dossier à un autre endroit. La commande complète pour le déplacement des fichiers est fournie ci-dessous:

Enfin, nous pouvons maintenant vérifier que le kubectl est installé avec succès. Utilisez à nouveau la même commande «Version» pour vérifier la version de Kubectl et vérifier qu'elle est installée correctement.

La commande «Version» a renvoyé tous les champs, y compris la version de Kubectl, et c'est «V4.5.4 ”. Le terminal a indiqué que notre système est prêt, et nous pouvons maintenant commencer à travailler dans le minikube.

Étape # 6: Démarrez Minikube

Toutes les exigences des conditions préalables sont remplies, et tous les logiciels et packages requis sont installés et configurés pour le minikube. Maintenant, nous pouvons y travailler. Lorsque vous exécutez la commande «Minikube Start» sur votre terminal Ubuntu, le système téléchargera le fichier ISO Minikube à partir d'une source Web et d'un binaire localkube. Après cela, il se connectera avec le Docker pour la configuration car nous utilisons le Docker au lieu d'une machine virtuelle dans une boîte virtuelle. Commençons le minikube:

Notez que la commande est revenue avec une erreur. Cela s'est produit parce que la version de Minikube et les pilotes installés ne sont pas parfaitement compatibles avec la version de Docker. Cependant, le système a suggéré de résoudre l'erreur, et c'est en ajoutant l'utilisateur au groupe Docker. Cela peut être réalisé en exécutant la commande «Usermod» avant de recommencer le minikube.

La commande «Usermod» dans Ubuntu est utilisée pour modifier ou modifier les attributs de l'utilisateur actuel via CLI. Lorsque vous exécutez la commande «UserMod» dans votre terminal, la commande demandera le mot de passe, le nom d'utilisateur, le shell, le shell, l'emplacement du répertoire, etc. L'instruction complète «UserMod» pour l'ajout de l'utilisateur est indiquée ci-dessous:

Notez que les commandes «usermod» et «newgrp» sont utilisées ensemble. La commande "Usermod" est utilisée pour modifier les détails du compte utilisateur actuel, et la commande "newGrp" est utilisée pour ajouter le groupe d'utilisateurs à Docker. Si le processus a été correctement effectué et que l'utilisateur a été ajouté au Docker avec succès, il n'y aura pas de sortie sur le terminal indiquant que le système est prêt à démarrer le minikube. Tapez la même commande «Minikube Start» pour démarrer le minikube:

Notez que le minikube a commencé avec succès et que le pilote Docker est utilisé avec les privilèges racinaires. Le terminal montre également que Kubectl est configuré pour utiliser le minikube, et nous sommes prêts à partir. Nous pouvons maintenant implémenter des clusters Kubernetes et Kubectl dans notre minikube et tester les commandes. Mais, avant de passer aux commandes de Kubectl, créons d'abord un daemonset pour Kubernetes.

Qu'est-ce que Daemonset à Kubernetes?

Le Daemonset à Kubernetes est une fonctionnalité qui garantit que tous les pods système sont en marche et planifié sur chaque nœud. Ainsi, lorsque nous travaillons avec Kubernetes, nous devons créer un daemonset pour nous assurer que la copie de chaque pod fonctionne avec succès sur tous les nœuds. L'avantage de la création d'un Daemonset est que chaque fois que vous créez un nouveau nœud dans un cluster Kubernetes, un nouveau pod est automatiquement ajouté au nœud nouvellement créé. Lorsque vous supprimez les nœuds du cluster, leur copie restera derrière dans le pod. Uniquement lorsque vous supprimez le daemonset, puis les pods créés seront supprimés du système.

Quelle est l'utilisation de Daemonset à Kubernetes?

Daemonset est créé dans Kubernetes pour s'assurer que chaque nœud a une copie du pod. La pod attachée au nœud est généralement sélectionnée par le planificateur, bien que le contrôleur Daemonset planifie et gère les gousses après la création de Daemonset. De plus, lorsqu'un nouveau nœud est ajouté au cluster, une copie du pod s'y attache automatiquement, et lorsque le nœud est supprimé, la copie de pod sera également supprimée. Cependant, les pods ne seront nettoyés que si le Daemonset est retiré du système. Les utilisations les plus courantes d'un Daemonset sont les suivantes:

Stockage du cluster: Exécutez le stockage du cluster comme Ceph, Gluster, etc. sur chaque nœud qui a été créé.

Collection de journaux: Exécutez la collection de journaux comme Logstash, Fluentd, etc. sur chaque nœud qui a été créé.

Surveillance du nœud: Exécuter la surveillance du nœud comme Collectd, Exportateur de nœuds, etc. sur chaque nœud qui a été créé.

Déploiement de plusieurs daémonsins: pour Un type de démon, déployez plusieurs daémonssets via le processeur ou les demandes de mémoire de différents types de drapeaux qui prennent en charge une variété de matériel et de configurations.

Création de daemonset dans le cluster Kubernetes?

Maintenant, nous savons ce qu'est Daemonset et quelles sont ses utilisations, créons un Daemonset dans Ubuntu 20.04. Pour cela, assurez-vous qu'au moins un nœud de travailleur doit exister dans le cluster de Kubernetes. Suivez les étapes ci-dessous pour créer un Daemonset dans votre cluster Kubernetes:

Étape n ° 1: Vérifiez Daemonset

La première étape pour créer un Daemonset est de s'assurer qu'elle n'est pas déjà créée dans le cluster Kubernetes. Énumérez tous les daemonsets en utilisant le drapeau «-all-namespaces» avec la commande «get». La commande «get» est utilisée pour extraire des fichiers, des packages et tout de la cluster Kubernetes, et lorsque l'indicateur «DaemonSet Names Namespace» y sera ajouté, il répertorie tous les Daemonsets de l'espace de noms par défaut. Cependant, pour énumérer tous les démonsts de tous les espaces de noms, ajoutez le drapeau «tout» avec «Espace de noms».

Notez que tous les champs d'un Daemonset sont renvoyés par des «espaces de noms», y compris l'espace de noms, le nom, le désir, le courant, le prêt, à jour, le sélecteur de nœuds et l'âge. Il n'y a qu'un seul Daemonset nommé «Kube-Proxy» qui appartient à l'espace de noms «Kube-System».

Étape # 2: Obtenez des pods

Maintenant, nous avons la liste des daemonsets, obtenons les pods qui appartiennent aux daémonssets «Kube-System» Espace de noms. La même commande «get» est utilisée pour obtenir les pods qui appartiennent à l'espace de noms «kube-system». Exécutez la commande «kubectl get gods -n kube-system» dans le terminal pour obtenir les pods qui appartiennent à cet espace de noms spécifique. Reportez-vous à la capture d'écran fournie ci-dessous:

Étape # 3: Obtenez des pods proxy

La commande «Get Pods» a renvoyé la liste des pods de l'espace de noms «Kube-System». Maintenant, en utilisant les mêmes commandes «Get Pods», nous pouvons obtenir les pods proxy du même espace de noms. Ajoutez la commande «Get Proxy» aux commandes «Get Pods» pour obtenir les pods proxy de l'espace de noms. L'instruction de commande complète est affichée ci-dessous:

Étape n ° 4: Vérifiez les détails de Daemonset

Après avoir extrait toutes les gousses et les gousses proxy, obtenez les détails du Daemonset qui contrôlent les gousses proxy. La commande «kubectl décrire daemonset» est utilisée pour obtenir les détails de la daemonset. La commande «décrire» dans Kubernetes est utilisée pour décrire les ressources de Kubernetes. Il peut être utilisé pour définir des ressources célibataires et multiples en même temps.

Lorsque vous devez décrire une ressource spécifique de Kubernetes, fournissez simplement le nom de cette ressource avec la commande «décrire». Dans ce cas, nous avons besoin des détails de notre Daemonset «Kube-Proxy» de l'espace de noms «Kube-System», nous fournirons donc ce nom de l'espace de noms et le nom du Daemonset à la commande «décrire». La sortie de la commande «décrire» est indiquée ci-dessous:

Notez qu'une liste complète de détails est renvoyée par la commande «décrire». La sortie contient tous les détails du Daemonset qui contrôle les pods proxy à Kubernetes.

Étape # 5: Créez un fichier YAML

L'étape suivante consiste à créer un fichier YAML vide dans Docker. Utilisez la commande «Touch» pour générer un fichier yaml. Voir l'instruction de commande complète fournie ci-dessous:

Le «toucher» est la commande pour construire un fichier YAML vide, le «démon» est le nom du fichier et «.yaml "est l'extension du fichier. L'instruction complète demande au système de créer un fichier YAML nommé "Daemon". Maintenant, ouvrons le fichier YAML dans l'éditeur souhaité. La commande «nano» est utilisée pour ouvrir le fichier dans l'éditeur souhaité de l'utilisateur. Utilisez la commande «nano» avec le nom de fichier spécifique pour l'ouvrir dans l'éditeur souhaité. Voir le code suivant:

Lorsque vous exécutez les deux commandes précédentes, un fichier YAML nommé «Daemon.Yaml »sera créé. La sortie fournie ci-dessous montre la liste complète des définitions Daemonset pour le démon.fichier yaml. Vous verrez la version API, l'espace de noms, les ressources comme le processeur et la mémoire, etc. Dans la définition du fichier de démon.

Étape # 6: Créez un démon de la définition du fichier de définition

Maintenant que nous avons créé un fichier YAML et acquis sa définition complète, nous pouvons facilement en créer un daemonset à partir. Utilisez simplement la commande «Create» pour créer le daemonset à l'aide du fichier de définition que nous avons créé à l'étape précédente. Utilisez la commande «Create -F» pour créer le Daemonset à partir du fichier de définition créé. Reportez-vous à la commande complète fournie ci-dessous:

Le Daemonset nommé My-Fluentd-Elasticsearch-Daemonset a été créé avec succès. Maintenant, obtenons à nouveau l'espace de noms pour vérifier que le daemonset de My-Fluentd-Elasticsearch-Daemonset est ajouté dans l'espace de noms «Kube-System». Utilisez à nouveau l'instruction «Get» pour répertorier tous les daémonsets de l'espace de noms «Kube-System».

Comme vous pouvez le voir sur la sortie précédente, le nouveau Daemonset a maintenant été créé dans l'espace de noms «Kube-System».

Étape # 7: Décrivez le nouveau Daemonset

Puisque nous avons créé un nouveau Daemonset, il est temps de le décrire. Comme le Daemonset est créé dans l'espace de noms «Kube-System», nous devons définir le Daemonset dans le même espace de noms. Utilisez la même commande «décrire» avec le nom de Daemonset «My-Fluentd-Elasticsearch-Daemonset» et l'espace de noms «Kube-System» pour décrire le nouveau Daemonset. Voir la commande complète dans la capture d'écran fournie ci-dessous:

Si vous voyez soigneusement la sortie précédente, vous remarquerez que 1 pod a été déployé avec les nœuds. Notez également que le statut du pod «attend».

Étape n ° 8: Obtenez les détails du pod déployé

Ici, nous savons combien de gousses sont déployées sur les nœuds. Obtenez les détails du pod déployé en utilisant les mêmes commandes «Get Pods» et «Grep». Jetez un œil à la commande complète fournie ci-dessous:

Nous avons réussi à créer un Daemonset et avons appris comment les pods sont déployés dans le Daemonset nouvellement créé sur chaque nœud du cluster Kubernetes. Nous avons presque terminé avec toutes les installations essentielles, et nous avons créé chaque package requis pour exécuter en douceur les commandes Kubectl dans le cluster Kubernetes géré par Minikube. Dans la section suivante, nous allons répertorier toutes les commandes Kubectl de base et les plus couramment utilisées et fournirons des exemples simples et faciles pour chaque commande afin que vous puissiez en savoir plus sur les codes. Les exemples d'exemples vous aideront dans le processus d'implémentation, et vous pourrez créer votre application en utilisant ces commandes.

Commandes de base kubectl

Comme nous le savons, le Kubectl est un outil officiel de ligne de commande pour implémenter, exécuter et exécuter l'application Kubernetes. L'outil et les commandes de Kubectl vous permettent de construire, de mettre à jour, d'inspecter et de supprimer les objets Kubernetes. Ici, nous fournirons quelques commandes de base qui peuvent être utilisées avec plusieurs ressources et composants de Kubernetes. Voyons les commandes communes de Kubectl une par une. N'oubliez pas que le mot-clé «kubectl» sera utilisé avec toutes les commandes. Qui est essentiel pour exécuter n'importe quelle commande kubectl.

Commande n ° 1: cluster-info

La commande «Cluster-Info», comme son nom l'indique, fournira les informations du cluster. Il fournit les informations de point de terminaison des services et du maître du cluster. Découvrez la sortie de la commande «Cluster-Info» illustré ci-dessous:

Le «cluster-info» a fourni les informations du cluster fonctionnant sur quel port.

Commande n ° 2: version

La commande «Version» de Kubectl est utilisée pour obtenir la version des Kubernetes, qui s'exécute sur le serveur et le client. Regardez la commande «Version» exécutée suivante avec sa sortie produite:

Notez que la commande «Version» a renvoyé le «V4.5.Version 4 ”des Kubernetes.

Commande n ° 3: vue de configuration

La commande suivante est la «vue de configuration». Il est utilisé pour configurer le cluster à Kubernetes. Lorsque vous exécutez la commande «Kubectl Config View», vous obtiendrez une définition complète de la configuration du cluster. Les détails contiennent la dernière mise à jour, les informations du fournisseur, la version de Minikube, la version API, etc. Voir la liste complète des détails dans la sortie ci-dessous:

Commande n ° 4: Resources API

Il existe de nombreuses ressources API utilisées dans Kubernetes; Pour répertorier tous ceux-ci, nous avons la commande «Api-Resource». Jetez un œil à la liste de toutes les ressources actives fournies ci-dessous:

Commande n ° 5: API-Versions

Pour répertorier toutes les versions disponibles de l'API, nous avons la commande «API-Versions» disponible. Exécutez simplement «Kubectl API-Version» dans le terminal et obtenez toutes les versions d'API disponibles actuellement. Voici la liste de toutes les versions API disponibles ci-dessous:

Commande n ° 6: Obtenez tous les espaces de noms

Nous avons déjà utilisé la commande de noms de noms dans la section précédente pour créer le daemonset. Cependant, voyons la définition générale de la commande «All Namespaces». La commande -all-namespaces répertorie tous les espaces de noms créés dans le kubectl. Voir la liste de tous les espaces de noms fournis ci-dessous:

Commande n ° 7: Obtenez Daemonset

La commande «Get Daemonset» est utilisée pour obtenir la liste de tous les daemonsets créés dans l'espace de noms par défaut jusqu'à présent.

Supposons que vous exécutiez cette commande avant de créer un Daemonset. Il ne renverra rien car aucune ressource Daemonset n'a été créée dans l'espace de noms. Cependant, nous avons créé un Daemonset dans la section précédente, et nous pouvons voir la liste de Daemonset nouvellement créée là-bas.

Commande n ° 8: Obtenez le déploiement

La commande «Get Deployment» est utilisée pour répertorier tous les déploiements qui ont été effectués jusqu'à présent dans les Kubernetes.

Puisqu'il n'y a pas encore de déploiement, aucune ressource n'a été trouvée dans l'espace de noms.

Commande n ° 9: Touche

La commande «Touch» est utilisée pour créer un nouveau fichier vierge pour fournir la configuration dedans. Pour créer un fichier vierge, fournissez simplement le nom de fichier avec l'extension de fichier souhaitée décrivant le type de fichier à la commande «Touch». Voir l'exécution de commande suivante:

Commande n ° 10: Nano

La commande «nano» est utilisée pour ouvrir les fichiers de l'éditeur souhaité. Nous avons créé un yaml en utilisant la commande «Touch», nous fournirons donc le même nom de fichier à la commande «nano» afin de l'ouvrir.

Voici la sortie de la commande «nano»:

Comme vous pouvez le voir, le déploiement nommé «httpd-frontend» a été créé. L'étiquette «App» sous le champ de modèle indique l'étiquette du pod, et c'est «httpd-frontend». Enfin, l'étiquette «Image» sous le champ de modèle spécifie la version d'image, qui est 2.4-Alpine, et l'étiquette «nom» indique que les pods exécutent le conteneur «httpd».

Commande n ° 11: Créer -F

La commande «Create -f» est rejetée pour générer un déploiement. Lorsque vous exécutez le déploiement «Kubectl Create -f.Commande yaml »sur le terminal, la commande Create créera le déploiement. Voir le nouveau déploiement dans la sortie suivante:

Comme vous pouvez le voir, un déploiement «httpd-frontend» a été créé avec succès. Pour voir les détails du déploiement, exécutez la même commande «Get Deployment» dans le terminal. Lorsque vous exécutez la commande «Get Deployment», elle répertorie tous les déploiements créés jusqu'à présent. Voir la liste suivante:

Commande n ° 12: Obtenez ReplicaseT | grep

Le «Obtenez réplique | La commande grep »est utilisée pour afficher la liste des répliques des déploiements. Comme nous venons de créer un déploiement, nous pouvons en voir les détails en utilisant la commande suivante:

Commande n ° 13: Obtenez des pods | grep

Lorsque vous créez un déploiement, il créera des pods et des répliques. Nous avons déjà répertorié le répliques. Maintenant, obtenons toutes les gousses créées par le répliquant. Les «Get Pods | La commande grep »est utilisée pour répertorier toutes les pods créés par le répliquant. La liste des pods créés par le répliques sera affichée, correspondant au nom spécifié fourni par l'utilisateur. Voir la sortie suivante:

Commande n ° 14: Supprimer

Supprimez le pod pour tester la création automatique du pod. Pour supprimer le pod existant, nous avons la commande «Supprimer». Lorsque vous exécutez la commande «delete pod», le pod spécifié sera supprimé. Voir la sortie suivante:

Comme vous pouvez le noter, le pod «httpd-frontend-6f67496c45-56vn8» a été supprimé avec succès. Maintenant, vérifions si le nouveau pod est automatiquement créé après avoir spécifiquement supprimé le pod existant. Pour ce faire, exécutez les «Get Pods | Grep ”Commande à nouveau dans le terminal. Voici le résultat suivant:

Notez qu'un nouveau pod a été automatiquement créé après avoir supprimé le pod existant. Maintenant, vérifions ce qui se passe après avoir supprimé le répliquant. Tout d'abord, nous obtiendrons la liste de répliques en utilisant le même «Obtenez ReplicaseT | Commande grep ». Voir la liste suivante:

Maintenant, supprimez le répliques en utilisant la commande de suppression et en spécifiant le nom du répliquant.

Comme vous pouvez le voir, le terminal indique que le répliquant a été supprimé avec succès. Alors, vérifions si le déploiement avait automatiquement créé le répliquant ou non lorsqu'il a été supprimé. Laissez-nous exécuter le même «Get ReplicaseT | Commande grep ”pour répertorier tout le répliquant créé par le déploiement. Voir la sortie suivante:

Notez que le répliquant a été automatiquement créé par le déploiement même après avoir été supprimé avec force. Consultez la commande suivante pour obtenir plus de détails sur le pod:

Commande n ° 15: -o large

La commande «-o large» est utilisée pour obtenir les détails du pod qui a été créé récemment. Spécifiez simplement le nom du pod et utilisez la commande «get» avec le champ «-o large» pour obtenir des informations détaillées sur le pod. Voir la sortie fournie ci-dessous:

Maintenant, si vous avez besoin de voir les détails complets du pod, vous pouvez exécuter à nouveau la commande «décrire» en fournissant spécifiquement le nom du pod.

Comme vous pouvez le voir, la commande décrite a renvoyé les détails complets du pod httpd-frontend, y compris le nom de pod, l'espace de noms, l'heure de début, les détails du nœud, l'état, l'adresse IP, l'ID de conteneur, etc. Maintenant, si vous n'avez plus besoin du déploiement, supprimez-le en utilisant la commande «Supprimer». Tout d'abord, obtenez la liste des déploiements via la commande «Get Deployment».

Le seul déploiement que nous avons dans le cluster de Kubernetes est «Httpd-frontend». Exécutez la commande «Supprimer» sur le déploiement «httpd-frontend» pour le supprimer.

Le déploiement «httpd-frontend» a été supprimé avec succès. Si vous vérifiez les déploiements maintenant, rien ne sera retourné. Voir la sortie fournie ci-dessous:

Notez que lorsque nous avons supprimé le déploiement, il n'a plus été créé. Cependant, lorsque nous avons supprimé le pod et le répliquant, ils ont tous deux été créés automatiquement par le déploiement. Étant donné que les deux font partie du déploiement, ils seront à nouveau créés jusqu'à ce que vous supprimez le déploiement lui-même, même si vous les supprimez avec force.

Création d'espaces de noms dans Kubernetes à l'aide de commandes Kubectl?

Il permet à l'administrateur d'organiser, de structurer, d'organiser, de regrouper et d'allouer des ressources pour fonctionner en douceur l'opération de cluster. Plusieurs espaces de noms peuvent être trouvés dans un seul cluster Kubernetes, tous logiquement séparés les uns des autres.

Étape n ° 1: Créer un fichier YAML

La première étape que vous devez effectuer est de créer un nouveau fichier YAML pour la configuration à l'aide de la commande «Touch». Après cela, ouvrez le fichier nouvellement créé dans l'éditeur souhaité en utilisant la commande «Nano».

Un fichier YAML de type d'espace de noms a été créé. Ajoutez maintenant «Apiversion: v1, kind: namespace, métadonnées: nom: kalsoom» dans le fichier et enregistrez-le. Voir le fichier ouvert fourni ci-dessous:

Étape # 2: Créez un YAML spécifique avec Kubectl Créer -F

Utilisez la commande «kubectl create -f» avec le nom de l'espace de noms suivi du chemin du fichier yaml pour créer l'espace de noms de ce nom spécifique.

Comme vous pouvez le voir que la sortie indique que l'espace de noms a été créé avec succès.

Étape # 3: Répertoriez tous les espaces de noms

Utilisez la commande «Kubectl Get Namespaces» pour répertorier tous les espaces de noms présents dans le cluster.

Le «Get Namespaces» a renvoyé le nom, le statut et l'âge de tous les espaces de noms existant dans le cluster Kubernetes. Si vous souhaitez voir le détail d'un espace de noms spécifique, vous pouvez le faire en utilisant le nom de l'espace de noms avec la commande get, comme indiqué ci-dessous:

Étape n ° 4: Obtenez la description complète de l'espace de noms

Si vous avez besoin de voir les détails complets d'un espace de noms spécifique, cela peut être fait en utilisant la commande décrite. Voir la sortie fournie ci-dessous:

Comment travailler avec des pods dans Kubernetes en utilisant les commandes Kubectl?

Créons quelques pods dans le cluster Kubernetes.

Étape n ° 1: Obtenez tous les nœuds existants

Exécutez la commande «kubectl get nœuds» dans le terminal pour voir les nœuds du cluster. Voir la sortie ci-dessous:

Étape # 2: Créez le pod à l'aide de l'image nginx

Le pod peut être créé en utilisant l'image nginx.

La sortie montre que le pod nginx a été créé en cours d'exécution avec l'image Nginx sur le moyeu docker. Notez que le drapeau «redémarrer» a été réglé sur «jamais». Cela est fait pour s'assurer que les Kubernetes crée une seule pod au lieu d'un déploiement.

Étape n ° 3: répertorier tous les pods

Pour voir le pod qui a été créé récemment, nous pouvons exécuter la commande «Get Pods». La commande «kubectl run pods» affiche l'état du pod.

Étape n ° 4: Obtenez tous les détails des pods

Si vous avez besoin de voir les détails complets et la configuration entière des pods, utilisez à nouveau la même commande «décrire» avec le nom du pod. La commande complète est illustrée ci-dessous:

Vous pouvez voir le yaml pour le pod qui a été créé récemment. La configuration comprend le nom, l'espace de noms, l'heure de début, les étiquettes, l'état, le type d'image, etc. Cela contient également les détails complets du conteneur Nginx.

Étape # 5: Supprimer la pod

La pod créée dans les sections précédentes peut être supprimée en utilisant simplement la commande «Supprimer» avec le nom de la nappe.

L'exécution de la commande «Delete» a été réussie, donc la pod a été supprimée.

Conclusion

Lorsque vous commencez votre voyage Kubernetes, vous devrez faire face à toutes sortes de commandes Kubectl. Cet article complet vous aidera à comprendre les commandes Kubectl et comment vous pouvez les utiliser pour créer différents packages, espaces de noms, gousses, nœuds, etc. Ces commandes vous aident à effectuer les opérations de base sur tous les objets de cluster Kubernetes.