Comment utiliser kubectl plus efficacement : guide détaillé

Voyons un exemple simple :

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NOM
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

La sortie contient une colonne avec les noms des pods.

L'expression dans l'option choisit les noms des pods à partir du champ metadata.name. C'est parce que le nom du pod est défini dans le champ enfant name du champ métadonnées dans la description de la ressource de pod. Vous pouvez en savoir plus dans le guide API ou entrer la commande kubectl explain pod.metadata.name.

Supposons maintenant que vous souhaitiez ajouter une colonne supplémentaire à la sortie, par exemple, en montrant le nœud sur lequel chaque pod fonctionne. Pour cela, vous pouvez simplement ajouter la spécification de colonne appropriée dans l'option des colonnes personnalisées :

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

L'expression sélectionne le nom du nœud à partir de spec.nodeName — lorsque le pod est assigné à un nœud, son nom est inscrit dans le champ spec.nodeName de la spécification des ressources du pod. Vous pouvez trouver plus d'informations dans la sortie kubectl explain pod.spec.nodeName.

Notez que les champs des ressources Kubernetes sont sensibles à la casse.

Vous pouvez visualiser n'importe quel champ de la ressource sous forme de colonne. Il suffit de consulter la spécification de la ressource et d'essayer avec n'importe quel champ que vous souhaitez.

Mais d'abord, examinons de plus près les expressions de sélection de champs.

Expressions JSONPath

Les expressions pour sélectionner des champs de ressources sont basées sur JSONPath.

JSONPath est un langage pour extraire des données à partir de documents JSON. Sélectionner un seul champ est le cas d'utilisation le plus simple de JSONPath. Il possède beaucoup plus de fonctionnalités, y compris des sélecteurs, des filtres, etc.

Kubectl explain prend en charge un nombre limité de fonctionnalités JSONPath. Voici les fonctionnalités et exemples d'utilisation :

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

L'opérateur [] revêt une importance particulière. De nombreux champs des ressources Kubernetes sont des listes, et cet opérateur permet de sélectionner des éléments de ces listes. Il est souvent utilisé avec un joker tel que [*] pour sélectionner tous les éléments de la liste.

Exemples d'application

Les possibilités d'utilisation d'un format de sortie de colonnes personnalisé sont illimitées, car vous pouvez afficher n'importe quel champ ou combinaison de champs de la ressource dans la sortie. Voici quelques exemples d'applications, mais n'hésitez pas à les explorer vous-même et à trouver des utilisations utiles.

1. Affichage des images des conteneurs pour les pods :

   $ kubectl get pods 
     -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'
   
   NAME                        IMAGES
   engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
   engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
   engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
   web-ui-6db964458-8pdw4      wordpress

   Cette commande affiche les noms des images des conteneurs pour chaque pod.

   N'oubliez pas qu'un pod peut contenir plusieurs conteneurs, et donc les noms des images seront affichés sur une seule ligne, séparés par des virgules.

2. Affichage des zones de disponibilité des nœuds :

   $ kubectl get nodes 
     -o 
   custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'
   
   NAME                          ZONE
   ip-10-0-118-34.ec2.internal   us-east-1b
   ip-10-0-36-80.ec2.internal    us-east-1a
   ip-10-0-80-67.ec2.internal    us-east-1b

   Cette commande est utile si votre cluster est hébergé dans un cloud public. Elle affiche la zone de disponibilité pour chaque nœud.

   Une zone de disponibilité est un concept cloud qui limite la zone de réplication à une région géographique.

   Les zones de disponibilité pour chaque nœud sont obtenues via une étiquette spéciale — failure-domain.beta.kubernetes.io/zone. Si le cluster est exécuté dans un cloud public, cette étiquette est créée automatiquement et remplie avec les noms des zones de disponibilité pour chaque nœud.

   Les étiquettes ne font pas partie de la spécification des ressources Kubernetes, donc vous ne trouverez pas d'informations les concernant dans guide API. Cependant, vous pouvez les voir (comme n'importe quelle autre étiquette) en demandant des informations sur les nœuds au format YAML ou JSON :

   $ kubectl get nodes -o yaml
   # ou
   $ kubectl get nodes -o json

   C'est un excellent moyen d'en apprendre davantage sur les ressources, en plus d'étudier les spécifications des ressources.

4. Changement facile entre les clusters et les espaces de noms

Lorsque kubectl effectue une requête à l'API Kubernetes, il lit d'abord le fichier kubeconfig pour obtenir tous les paramètres nécessaires à la connexion.

Par défaut, le fichier kubeconfig est ~/.kube/config. En général, ce fichier est créé ou mis à jour par une commande spéciale.

Lorsque vous travaillez avec plusieurs clusters, votre fichier kubeconfig contient les paramètres de connexion pour tous ces clusters. Vous avez besoin d'une manière d'indiquer à la commande kubectl avec quel cluster vous travaillez.

À l'intérieur du cluster, vous pouvez créer plusieurs espaces de noms — un type de cluster virtuel à l'intérieur d'un cluster physique. Kubectl détermine quel espace de noms utiliser également à partir des données du fichier kubeconfig. Cela signifie que vous avez également besoin d'une manière d'indiquer à la commande kubectl avec quel espace de noms travailler.

Dans ce chapitre, nous expliquerons comment cela fonctionne et comment y parvenir efficacement.

Veuillez noter que vous pouvez avoir plusieurs fichiers kubeconfig listés dans la variable d'environnement KUBECONFIG. Dans ce cas, tous ces fichiers seront combinés en une seule configuration lors de l'exécution. Vous pouvez également modifier le fichier kubeconfig par défaut en lançant kubectl avec le paramètre --kubeconfig. Voir la documentation officielle.

Fichiers kubeconfig

Voyons ce que le fichier kubeconfig contient exactement :

Comme vous pouvez le voir, le fichier kubeconfig contient un ensemble de contextes. Un contexte se compose de trois éléments :

• Cluster — URL de l'API du serveur de cluster.
• User — informations d'identification de l'utilisateur pour s'authentifier dans le cluster.
• Namespace — l'espace de noms utilisé lors de la connexion au cluster.

En pratique, on utilise souvent un seul contexte par cluster dans son fichier kubeconfig. Cependant, vous pouvez avoir plusieurs contextes pour un même cluster, différenciés par l'utilisateur ou l'espace de noms. Cette configuration avec plusieurs contextes est néanmoins rare, si bien qu'il existe généralement une correspondance univoque entre les clusters et les contextes.

À tout moment, l'un des contextes est actif :

Lorsque kubectl lit le fichier de configuration, il prend toujours les informations du contexte actif. Dans l'exemple ci-dessus, kubectl se connectera au cluster Hare.

Par conséquent, pour basculer vers un autre cluster, vous devez changer le contexte actif dans le fichier kubeconfig :

Désormais, kubectl se connectera au cluster Fox.

Pour changer d'espace de noms dans le même cluster, vous devez modifier la valeur de l'élément namespace pour le contexte actif :

Dans l'exemple ci-dessus, kubectl utilisera l'espace de noms Prod du cluster Fox (l'espace de noms Test a été configuré auparavant).

Notez que kubectl fournit également les paramètres --cluster, --user, --namespace et --context, qui permettent de remplacer des éléments individuels et le contexte actif lui-même, indépendamment de ce qui est défini dans le fichier kubeconfig. Voir options kubectl.

Théoriquement, vous pouvez modifier manuellement les paramètres dans le fichier kubeconfig. Mais cela est peu pratique. Pour simplifier ces opérations, il existe diverses utilitaires qui permettent de modifier les paramètres automatiquement.

Utilisez kubectx

Un utilitaire très populaire pour passer d'un cluster à un autre et changer d'espaces de noms.

L'outil propose les commandes kubectx et kubens pour changer le contexte actuel et l'espace de noms en conséquence.

Comme mentionné précédemment, changer le contexte actuel signifie changer de cluster, si vous n'avez qu'un seul contexte par cluster.

Voici un exemple de l'exécution de ces commandes :

Essentiellement, ces commandes modifient simplement le fichier kubeconfig, comme décrit ci-dessus.

Pour installer kubectx, suivez les instructions sur Github.

Les deux commandes prennent en charge l'auto-complétion des noms de contextes et d'espaces de noms, ce qui permet de ne pas les saisir entièrement. Les instructions pour configurer l'auto-complétion ici.

Une autre fonction utile kubectx est le mode interactif. Il fonctionne en conjonction avec l'outil fzf, qui doit être installé séparément. L'installation de fzf rend automatiquement le mode interactif disponible dans kubectx. En mode interactif, vous pouvez choisir le contexte et l'espace de noms via une interface interactive de recherche libre fournie par fzf.

Utilisation des alias de la ligne de commande

Vous n'avez pas besoin d'outils séparés pour changer le contexte actuel et l'espace de noms, car kubectl fournit également des commandes pour cela. Ainsi, la commande kubectl config fournit des sous-commandes pour éditer des fichiers kubeconfig.

Voici quelques-uns d'entre eux :

• kubectl config get-contexts: afficher tous les contextes ;
• kubectl config current-context: obtenir le contexte actuel ;
• kubectl config use-context: changer le contexte actuel ;
• kubectl config set-context: modifier l'élément du contexte.

Cependant, utiliser ces commandes directement n'est pas très pratique, car elles sont longues. Vous pouvez créer des alias pour la ligne de commande qui sont faciles à exécuter.

J'ai créé un ensemble d'alias basé sur ces commandes qui fournissent une fonctionnalité similaire à kubectx. Vous pouvez voir leur fonctionnement ici :

Notez que les alias utilisent fzf pour fournir une interface interactive de recherche libre (comme dans le mode interactif de kubectx). Cela signifie que vous devez installer fzf, pour utiliser ces alias.

Voici les définitions des alias :

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

Pour installer ces alias, vous devez ajouter les définitions ci-dessus dans votre fichier ~\/bashrc ou ~/.zshrc et recharger votre shell.

Utilisation des plugins

Kubectl permet de charger des plugins qui s'exécutent de la même manière que les commandes principales. Par exemple, vous pouvez installer le plugin kubectl-foo et l'exécuter en utilisant la commande kubectl foo.

Il serait pratique de changer le contexte et l'espace de noms de cette manière, par exemple, en exécutant kubectl ctx pour changer le contexte et kubectl ns pour changer l'espace de noms.

J'ai écrit deux plugins qui le font :

• kubectl-ctx
• kubectl-ns

Le fonctionnement des plugins est basé sur des alias du chapitre précédent.

Voici comment ils fonctionnent :

Notez que les plugins utilisent fzf pour fournir une interface interactive de recherche libre (comme en mode interactif kubectx). Cela signifie que vous devez installer fzf, pour utiliser ces alias.

Pour installer les plugins, téléchargez les scripts shell nommés kubectl-ctx et kubectl-ns dans n'importe quel répertoire de votre variable PATH et rendez-les exécutables, par exemple, avec chmod +x. Après cela, vous pourrez utiliser kubectl ctx et kubectl ns.

5. Raccourci de saisie avec auto-aliases

Les alias de commande shell sont une bonne opportunité pour accélérer la saisie. Le projet kubectl-aliases contient environ 800 raccourcis pour les commandes principales de kubectl.

Vous vous demandez peut-être comment se souvenir de 800 alias ? Mais il n'est pas nécessaire de tous les mémoriser, car ils sont construits selon un schéma simple, comme indiqué ci-dessous :

Par exemple :

1. kgpooyaml — kubectl get pods oyaml
2. ksysgsvcw — kubectl -n kube-system get svc w
3. ksysrmcm — kubectl -n kube-system rm cm
4. kgdepallsl — kubectl get deployment all sl

Comme vous pouvez le voir, les alias sont constitués de composants, chacun représentant un élément spécifique de la commande kubectl. Chaque alias peut avoir un composant pour la commande de base, l'opération et la ressource, et plusieurs composants pour les paramètres. Vous remplissez simplement ces composants de gauche à droite selon le schéma ci-dessus.

Le schéma détaillé actuel se trouve sur GitHub. Vous y trouverez également la liste complète des alias.

Par exemple, l'alias kgpooyamlall équivaut à la commande kubectl get pods -o yaml --all-namespaces.

L'ordre relatif des options n'est pas important : la commande kgpooyamlall est équivalente à la commande kgpoalloyaml.

Vous n'avez pas à utiliser tous les composants comme alias. Par exemple k, kg, klo, ksys, kgpo peuvent également être utilisés. De plus, dans la ligne de commande, vous pouvez combiner des alias et des commandes ou options standard :

Par exemple :

1. Au lieu de kubectl proxy peut être écrit k proxy.
2. Au lieu de kubectl get roles peut être écrit kg roles (il n'existe actuellement pas d'alias pour la ressource Roles).
3. Pour obtenir des données sur un pod spécifique, vous pouvez utiliser la commande kgpo my-pod — kubectl get pod my-pod.

Notez que certains alias nécessitent un argument dans la ligne de commande. Par exemple, l'alias kgpol signifie kubectl get pods -l. L'option -l requiert un argument - la spécification de l'alias. Si vous utilisez un alias, il apparaîtra comme kgpol app=ui.

Comme certaines parties des alias nécessitent des arguments, les alias a, f et l doivent être utilisés en dernier.

En général, une fois que vous maîtrisez ce schéma, vous pourrez intuitivement déduire des alias des commandes que vous souhaitez exécuter, ce qui vous fera gagner beaucoup de temps de saisie.

Installation

Pour installer kubectl-aliases, vous devez télécharger le fichier .kubectl_aliases depuis GitHub et l'inclure dans le fichier ~\/bashrc ou ~/.zshrc:

source ~/.kubectl_aliases

Auto-complétion

Comme nous l'avons déjà mentionné, vous ajoutez souvent des mots supplémentaires à l'alias dans la ligne de commande. Par exemple :

$ kgpooyaml test-pod-d4b77b989

Si vous utilisez l'auto-complétion de la commande kubectl, vous avez probablement utilisé l'auto-complétion pour des choses comme les noms de ressources. Mais peut-on faire cela lorsqu'on utilise des alias ?

C'est une question très importante, car si l'auto-complétion ne fonctionne pas, vous perdrez une partie des avantages des alias.

La réponse dépend de la shell que vous utilisez :

1. Pour Zsh, l'auto-complétion pour les alias fonctionne "out of the box".
2. Pour Bash, malheureusement, certaines actions sont nécessaires pour faire fonctionner l'auto-complétion.

Activation de l'auto-complétion pour les alias dans Bash

Le problème avec Bash est qu'il essaie de compléter (chaque fois que vous appuyez sur Tab) l'alias, et non la commande à laquelle l'alias fait référence (comme le fait Zsh). Comme vous n'avez pas de scripts de complétion pour les 800 alias, l'auto-complétion ne fonctionne pas.

Projet complete-alias offre une solution générale à ce problème. Il se connecte au mécanisme de complétion pour les alias, complète l'alias en commande et renvoie les options de complétion pour la commande complétée. Cela signifie que la complétion pour un alias se comporte exactement comme pour une commande complète.

Je vais d'abord expliquer comment installer complete-alias, puis comment le configurer pour activer la complétion pour tous les alias de kubectl.

Installation de complete-alias

Tout d'abord, complete-alias dépend de bash-completion. Par conséquent, avant d'installer complete-alias, vous devez vous assurer que bash-completion est installé. Les instructions d'installation ont été fournies précédemment pour Linux et MacOS.

Remarque importante pour les utilisateurs de MacOS: tout comme le script de complétion kubectl, complete-alias ne fonctionne pas avec Bash 3.2, qui est utilisé par défaut dans MacOS. En particulier, complete-alias dépend de bash-completion v2 (brew install bash-completion@2), pour lequel Bash 4.1 est requis au minimum. Cela signifie que pour utiliser complete-alias sur MacOS, vous devez installer une version plus récente de Bash.

Vous devez télécharger le script bash_completion.sh de du dépôt GitHub et l’inclure dans votre fichier ~\/bashrc:

source ~/bash_completion.sh

Après avoir redémarré l’interpréteur de commande, complete-alias sera complètement installé.

Activation de l’autocomplétion pour les alias kubectl

Techniquement, complete-alias fournit une fonction de shell _complete_alias. Cette fonction vérifie l'alias et retourne des suggestions d'autocomplétion pour la commande d'alias.

Pour lier la fonction à un alias spécifique, vous devez utiliser le mécanisme intégré de Bash complete, pour définir _complete_alias comme fonction d’autocomplétion d’alias.

Prenons comme exemple l'alias k, représentant la commande kubectl. Pour définir _complete_alias comme fonction d’autocomplétion pour cet alias, vous devez exécuter la commande suivante :

$ complete -F _complete_alias k

Ce résultat signifie que chaque fois que vous utilisez l’autocomplétion pour l'alias k, la fonction _complete_alias, qui vérifie l'alias et retourne des suggestions d'autocomplétion pour la commande, est appelée. kubectl.

Pour un deuxième exemple, prenons l'alias kg, qui représente kubectl get:

$ complete -F _complete_alias kg

Tout comme dans l’exemple précédent, lorsque vous utilisez l’autocomplétion pour kg, vous obtenez les mêmes suggestions d'autocomplétion que celles que vous auriez pour kubectl get.

Notez qu'il est possible d’utiliser complete-alias pour n’importe quel alias de votre système.

Ainsi, pour activer l’autocomplétion pour tous les alias kubectl, vous devez exécuter la commande mentionnée ci-dessus pour chacun d'eux. Le fragment suivant le fait exactement à condition que vous ayez installé kubectl-aliases dans ~/ .kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$// ' ~/ .kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

Ce morceau de code doit être placé dans votre ~\/bashrc, redémarrez l'interpréteur de commande et l’autocomplétion sera disponible pour tous les 800 alias kubectl.

6. Extension de kubectl avec des plugins

À partir de à partir de la version 1.12, kubectl prend en charge un mécanisme de plugins, qui permet d'étendre ses fonctionnalités avec des commandes supplémentaires.

Si vous êtes familier avec les mécanismes de plugins Git, les plugins kubectl sont construits selon le même principe.

Dans ce chapitre, nous allons expliquer comment installer des plugins, où les trouver et comment créer vos propres plugins.

Installation de plugins

Les plugins kubectl sont distribués sous forme de fichiers exécutables simples avec des noms de type kubectl-x. Le préfixe kubectl- est obligatoire, suivi d'une nouvelle sous-commande kubectl qui permet d'appeler le plugin.

Par exemple, le plugin hello sera distribué sous la forme d'un fichier nommé kubectl-hello.

Pour installer le plugin, il faut copier le fichier kubectl-x dans n'importe quel répertoire dans votre variable PATH et le rendre exécutable, par exemple en utilisant chmod +x. Juste après cela, vous pouvez appeler le plugin avec kubectl x.

Vous pouvez utiliser la commande suivante pour afficher la liste de tous les plugins actuellement installés sur votre système :

$ kubectl plugin list

Cette commande affiche également des avertissements si vous avez plusieurs plugins avec les mêmes noms, ou s'il y a un fichier de plugin qui n'est pas exécutable.

Recherche et installation de plugins avec Krew

Les plugins Kubectl sont destinés à être partagés ou réutilisés comme des paquets logiciels. Mais où pouvez-vous trouver les plugins partagés par d'autres ?

Le projet Krew vise à fournir une solution unifiée pour le partage, la recherche, l'installation et la gestion des plugins kubectl. Le projet se décrit comme un « gestionnaire de paquets pour les plugins kubectl » (Krew est similaire à Brew).

Krew est une liste de plugins kubectl que vous pouvez choisir et installer. Krew est également un plugin pour kubectl.

Cela signifie que l'installation de Krew fonctionne essentiellement comme l'installation de tout autre plugin kubectl. Vous pouvez trouver des instructions détaillées sur la page GitHub.

Les commandes Krew les plus importantes :

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

Veuillez noter que l'installation de plugins avec Krew n'empêche pas l'installation de plugins de la manière standard décrite ci-dessus.

Notez que la commande kubectl krew list affiche uniquement les plugins qui ont été installés avec Krew, tandis que la commande kubectl plugin list énumère tous les plugins, c'est-à-dire ceux qui ont été installés avec Krew et ceux qui ont été installés par d'autres moyens.

Recherche de plugins ailleurs

Krew est un jeune projet, à l'heure actuelle, son liste compte environ 30 plugins. Si vous ne trouvez pas ce que vous cherchez, vous pouvez trouver des plugins ailleurs, par exemple sur GitHub.

Je recommande de consulter la section GitHub kubectl-plugins. Là, vous trouverez plusieurs dizaines de plugins disponibles qui valent la peine d'être examinés.

Écriture de vos propres plugins

Vous pouvez créer vous-même Créer des plugins — ce n'est pas difficile. Vous devez créer un fichier exécutable qui fait ce dont vous avez besoin, et le nommer comme kubectl-x et l'installer comme décrit ci-dessus.

Le fichier peut être un script bash, un script python ou une application compilée en go — peu importe. La seule condition est qu'il puisse être exécuté directement dans le système d'exploitation.

Créons un exemple de plugin tout de suite. Dans la section précédente, vous avez utilisé la commande kubectl pour afficher la liste des conteneurs pour chaque pod. Vous pouvez facilement transformer cette commande en un plugin que vous pouvez appeler, par exemple, avec kubectl img.

Créez un fichier kubectl-img avec le contenu suivant :

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

Maintenant, rendez le fichier exécutable avec chmod +x kubectl-img et déplacez-le dans n'importe quel répertoire de votre PATH. Juste après cela, vous pouvez utiliser le plugin kubectl img.

Comme mentionné, les plugins kubectl peuvent être écrits dans n'importe quel langage de programmation ou de script. Si vous utilisez des scripts de shell, il est avantageux de pouvoir facilement appeler kubectl depuis le plugin. Cependant, vous pouvez écrire des plugins plus complexes dans de vrais langages de programmation, en utilisant la bibliothèque cliente Kubernetes. Si vous utilisez Go, vous pouvez également utiliser la bibliothèque cli-runtime, qui est spécifiquement conçue pour écrire des plugins kubectl.

Comment partager vos plugins

Si vous pensez que vos plugins peuvent être utiles aux autres, n'hésitez pas à les partager sur GitHub. Assurez-vous de les ajouter à un sujet kubectl-plugins.

Vous pouvez également demander l'ajout de votre plugin dans la liste Krew. Des instructions sur la façon de procéder sont disponibles dans le dépôt GitHub.

Autocomplétion des commandes

Actuellement, les plugins ne supportent pas l'autocomplétion. Cela signifie que vous devez entrer le nom complet du plugin et les noms complets des arguments.

Dans le dépôt GitHub de kubectl, cette fonction a une demande ouverte. Ainsi, il est possible que cette fonctionnalité soit mise en œuvre un jour à l'avenir.

Bonne chance !!!

Suggestions de lecture supplémentaires:

1. Trois niveaux d'auto-scaling dans Kubernetes et comment les utiliser efficacement.
2. Kubernetes à la manière des pirates avec un modèle de mise en œuvre.
3. Notre chaîne Autour de Kubernetes sur Telegram.

Source : habr.com