Exemples de commandes kubectl à connaître en tant qu'administrateur système

Kubernetes, également connu sous le nom de K8S, est un outil d'orchestration de conteneurs très répandu qui permet de gérer et de mettre à l'échelle une infrastructure conteneurisée.

kubectl est l'outil CLI commun que nous utilisons pour interroger et gérer un cluster Kubernetes. kubectl utilise l'interface API de Kubernetes pour visualiser, contrôler et gérer le cluster. Il est pris en charge par différentes plateformes et peut être facilement configuré pour gérer un cluster.

Dans cet article, nous allons aborder quelques commandes kubectl courantes qui aident à l'administration quotidienne de Kubernetes.

Obtenir kubectl

kubectl est déjà installé dans le cadre de la configuration du cluster Kubernetes. Si vous gérez un cluster depuis un système distant, vous pouvez facilement l'installer pour qu'il fonctionne avec n'importe quelle configuration de cluster.

Sur un Linux vous pouvez utiliser la commande ci-dessous pour obtenir la dernière version de kubectl :

$ curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Veillez à placer le fichier binaire téléchargé à un endroit fixe, en ajoutant l'emplacement à votre fichier PATH et le rendre exécutable avec chmod +x commande.

Sur un Fenêtres vous pouvez télécharger la dernière version disponible de kubectl en récupérant d'abord la dernière version stable à partir de https://dl.k8s.io/release/stable.txt.

Puis téléchargez-la en remplaçant {version} avec la dernière version en utilisant curl comme :

$ curl -LO https://dl.k8s.io/release/{version}/bin/windows/amd64/kubectl.exe

Pour la version 1.20.0, voici la commande curl :

$ curl -LO https://dl.k8s.io/release/v1.20.0/bin/windows/amd64/kubectl.exe

Si vous n'avez pas curl sur votre système, vous pouvez également télécharger l'exécutable kubectl en utilisant votre navigateur comme n'importe quel autre téléchargement.

Pour les autres méthodes et plateformes supportées, vous pouvez consulter le guide officiel pour obtenir kubectl ici.

Vérifier la configuration de kubectl

Pour vérifier votre configuration kubectl, vous pouvez exécuter la commande version comme suit :

$ kubectl version --client

La syntaxe générale pour l'utilisation de kubectl est la suivante :

$ kubectl [command] [TYPE] [NAME] [flags]

Définir le contexte et la configuration

Avant d'utiliser les commandes kubectl sur un cluster Kubernetes, nous devons d'abord définir la configuration et le contexte. Cela peut être fait avec la commande kubectl elle-même.

Pour afficher la configuration actuelle de kubectl, utilisez :

$ kubectl config view

Pour dresser la liste de tous les contextes disponibles :

$ kubectl config get-contexts

Pour obtenir le contexte actuel de kubectl :

$ kubectl config current-context

Nous pouvons modifier le contexte d'utilisation en utilisant :

$ kubectl config use-context [cluster-name]

Pour autoriser l'ajout d'un nouvel utilisateur dans kubeconf :

$ kubectl config set-credentials NAME [--client-certificate=path/to/certfile] [--client-key=path/to/keyfile] [--token=bearer_token] [--username=basic_user] [--password=basic_password]

Par exemple, pour définir uniquement le champ "client-key" sur le "cluster-admin" sans toucher aux autres valeurs, nous pouvons utiliser :

$ kubectl config set-credentials cluster-admin --client-key=~/.kube/admin.key

Ou, autre exemple, pour définir l'authentification de base pour, disons, l'entrée "cluster-admin", vous pouvez spécifier le nom d'utilisateur et le mot de passe comme suit :

$ kubectl config set-credentials cluster-admin --username=[username] --password=[password]

Si vous souhaitez intégrer les données du certificat client dans l'entrée "cluster-admin", la syntaxe est modifiée comme suit :

$ kubectl config set-credentials cluster-admin --client-certificate=~/.kube/admin.crt --embed-certs=true

Si vous voulez que kubectl utilise un espace de noms spécifique et l'enregistre pour toutes les commandes kubectl ultérieures dans ce contexte :

$ kubectl config set-context --current --namespace=[NAMESPACE]

Création d'objets

kubectl est utilisé pour déployer différents objets pris en charge dans un cluster Kubernetes. Son manifeste peut être défini dans un fichier YAML ou JSON fichier avec l'extension .yaml ou .yml et .json respectivement.

En utilisant le fichier manifeste donné, nous pouvons créer des ressources définies à l'aide de la commande suivante :

$ kubectl apply -f [manifest.yaml]

Ou pour spécifier plusieurs fichiers YAML, utilisez :

$ kubectl apply -f [manifest1.yaml] [manifest2.yaml]

Pour créer une ou plusieurs ressources dans tous les fichiers manifestes présents dans un répertoire :

$ kubectl apply -f ./dir

Ou pour créer des ressources à partir d'une URL :

$ kubectl apply -f [URL]

Ou directement à partir du nom de l'image dans le référentiel comme :

$ kubectl create deployment [deployment-name] --image=[image-name]

Par exemple, pour déployer une seule instance du serveur web Nginx :

$ kubectl create deployment nginx --image=nginx

Enfin, pour déployer des ressources directement en tapant la commande YAML dans l'interface de programmation sans faire référence à un fichier manifeste sauvegardé, essayez quelque chose comme :

# Create multiple YAML objects from stdin
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000000"
---
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep-less
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000"
EOF

Voir/trouver des ressources

kubectl fournit get pour dresser la liste des ressources déployées, obtenir leurs coordonnées et en savoir plus sur elles.

Pour répertorier tous les services dans l'espace de noms par défaut, utilisez :

$ kubectl get services

De même, pour lister les pods dans tous les espaces de noms, la syntaxe sera :

$ kubectl get pods --all-namespaces

Si nous avons besoin de lister plus de détails sur les pods déployés, utilisez -o wide comme :

$ kubectl get pods -o wide

La syntaxe pour obtenir les détails du déploiement est la suivante :

$ kubectl get deployment [deployment-name]

Pour obtenir le contenu YAML d'un pod, nous pouvons utiliser -o yaml comme un drapeau :

$ kubectl get pod [pod-name] -o yaml

Nous avons souvent besoin d'obtenir des détails sur les ressources Kubernetes. La commande describe de kubectl nous aide à obtenir ces détails.

Nous pouvons obtenir plus de détails sur un nœud comme :

$ kubectl describe nodes [node-name]

Il en va de même pour les cosses :

$ kubectl describe pods [pod-name]

kubectl permet de trier les résultats en fonction d'un champ particulier. Pour lister les services triés par nom de service, utilisez :

$ kubectl get services --sort-by=.metadata.name

Ou pour obtenir tous les pods en cours d'exécution dans l'espace de noms, nous pouvons essayer :

$ kubectl get pods --field-selector=status.phase=Running

Pour récupérer uniquement les adresses IP externes de tous les nœuds, si elles sont attribuées, nous pouvons utiliser la fonction -o jsonpath avec la syntaxe suivante :

$ kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'

Pour récupérer les étiquettes attachées à une ressource, par exemple les pods, essayez :

$ kubectl get pods --show-labels

Pour obtenir une liste d'événements triés par date, nous pouvons utiliser -sort-by comme :

$ kubectl get events --sort-by=.metadata.creationTimestamp

Si nous voulons comparer l'état actuel du cluster à l'état dans lequel il se trouverait si le manifeste était appliqué, nous utilisons diff comme :

$ kubectl diff -f ./manifest-file.yaml

Modification des ressources

Les ressources déployées sont souvent modifiées pour tenir compte des changements de configuration.

Pour effectuer une mise à jour continue des conteneurs, disons "www", du déploiement, disons "frontend", en mettant à jour leur image, nous pouvons utiliser :

$ kubectl set image deployment/frontend www=image:v2

Nous pouvons vérifier l'historique des déploiements, y compris les révisions :

$ kubectl rollout history deployment/frontend

Ou pour revenir à un déploiement antérieur, utilisez :

$ kubectl rollout undo deployment/frontend

Nous pouvons également revenir à une révision spécifique en spécifiant --to-revision comme :

$ kubectl rollout undo deployment/frontend --to-revision=2

Et pour vérifier l'état de la mise à jour du roulement, nous utilisons :

$ kubectl rollout status -w deployment/frontend

Pour un redémarrage en continu d'un déploiement "frontend", par exemple, utilisez :

$ kubectl rollout restart deployment/frontend

Nous pouvons spécifier un manifeste JSON pour remplacer un pod en le passant à l'entrée standard comme indiqué ci-dessous :

$ cat pod.json | kubectl replace -f -

Il peut arriver que vous deviez forcer le remplacement, la suppression, puis la recréation d'une ressource (REMARQUE : cela entraînera également une interruption de service), ce qui peut être fait de la manière suivante :

$ kubectl replace --force -f [manifest-file]

L'étiquetage d'une ressource (qui prend en charge les étiquettes) est facile et peut être effectué à l'aide de :

$ kubectl label pods [pod-name] new-label=[label]

De même, une annotation peut être ajoutée à une ressource à l'aide de :

$ kubectl annotate pods [pod-name] icon-url=[url]

La mise à l'échelle automatique d'un déploiement est possible avec :

$ kubectl autoscale deployment [dep-name] --min=[min-val] --max=[max-val]

Ici, dep-name est le nom du déploiement à mettre à l'échelle et min-val et max-val indique les valeurs minimale et maximale à utiliser pour la mise à l'échelle automatique.

Ressources d'édition

Il est possible de modifier une ressource API dans votre éditeur préféré à l'aide de la fonction edit commande.

$ kubectl edit [api-resource-name]

Ou pour utiliser votre propre éditeur alternatif, spécifiez KUBE_EDITOR comme :

KUBE_EDITOR="nano" kubectl edit [api-resource-name]

Mise à l'échelle des ressources

La mise à l'échelle des ressources est l'une des fonctionnalités prises en charge par Kubernetes et kubectl permet de le faire facilement.

Pour mettre à l'échelle un ensemble de répliques nommé, disons foo, à 3, nous utilisons :

$ kubectl scale --replicas=3 rs/foo

Nous pouvons également nous référer à un fichier YAML de manifeste pour spécifier la ressource à mettre à l'échelle :

$ kubectl scale --replicas=3 -f foo.yaml

Nous pouvons également procéder à une mise à l'échelle en fonction de l'état actuel du déploiement :

$ kubectl scale --current-replicas=2 --replicas=3 deployment/nginx

Suppression des ressources

Les ressources créées auront éventuellement besoin d'être modifiées ou supprimées. Avec kubectl, nous pouvons supprimer des ressources existantes de plusieurs façons.

Pour supprimer un pod à l'aide de la spécification du fichier JSON, nous utilisons :

$ kubectl delete -f ./pod.json

Nous pouvons supprimer les pods et les services portant le même nom. pod-name et service-name comme :

$ kubectl delete pod,service [pod-name] [service-name]

Si les ressources sont étiquetées et que nous devons supprimer les ressources portant une étiquette spécifique, par exemple label-namenous pouvons utiliser :

$ kubectl delete pods,services -l name=[label-name]

Pour supprimer tous les pods et services contenus dans un espace de noms, utilisez :

$ kubectl -n [namespace] delete pod,svc --all

Interagir avec les pods en cours d'exécution

Nous pouvons utiliser kubectl pour obtenir des détails sur les pods en cours d'exécution. administrer un cluster Kubernetes.

L'une des commandes les plus courantes consiste à obtenir les journaux d'un pod, ce qui peut être fait comme suit :

$ kubectl logs [pod-name]

Ou pour déverser des journaux de pods avec une étiquette spécifique :

$ kubectl logs -l name=[label-name]

Ou pour obtenir les journaux d'un conteneur spécifique :

$ kubectl logs -l name=[label-name] -c [container-name]

Nous pouvons également diffuser les journaux comme nous le faisons avec Linux tail -f avec la commande -f également le drapeau de l'UE :

$ kubectl logs -f [pod-name]

L'exécution interactive d'un pod peut être réalisée avec kubectl as :

$ kubectl run -i --tty busybox --image=busybox -- sh

Ou pour faire fonctionner un pod dans un espace de noms spécifique :

$ kubectl run nginx --image=nginx -n [namespace]

Vous pouvez l'attacher à un conteneur en cours d'exécution avec attach commandement :

$ kubectl attach [pod-name] -i

La redirection de port peut être effectuée pour un pod au moment de l'exécution avec la commande suivante :

$ kubectl port-forward [pod-name] [local-machine-port]:[pod-port]

Pour exécuter quelque chose directement dans un pod login et obtenir le résultat, utilisez :

$ kubectl exec [pod-name] -- [command]

La commande ci-dessus fonctionne si le module contient un seul conteneur. Pour les pods contenant plusieurs conteneurs, utilisez :

$ kubectl exec [pod-name] -c [container-name] -- [command]

Pour afficher les mesures de performance d'un pod donné et de ses conteneurs, nous pouvons utiliser :

$ kubectl top pod [pod-name] --containers

Ou pour les trier en fonction d'une mesure, par exemple le CPU ou la mémoire, nous pouvons le faire en utilisant :

$ kubectl top pod [pod-name] --sort-by=cpu

Interagir avec les nœuds et le cluster

kubectl peut interagir avec les nœuds et le cluster. Voici quelques-unes des commandes que kubectl utilise à cette fin.

Pour marquer un nœud comme non ordonnançable, utilisez :

$ kubectl cordon [node-name]

Drainage d'un nœud dans le cadre de la préparation à la maintenance :

$ kubectl drain [node-name]

Pour marquer à nouveau le nœud comme planifiable, utilisez :

$ kubectl uncordon [node-name]

Pour obtenir les mesures de performance relatives à un nœud, nous pouvons utiliser :

$ kubectl top node [node-name]

Pour obtenir des détails sur le cluster actuel :

$ kubectl cluster-info

Nous pouvons en outre afficher l'état de la grappe sur la sortie standard en utilisant :

$ kubectl cluster-info dump

Ou pour enregistrer dans un fichier :

$ kubectl cluster-info dump --output-directory=/path/to/cluster-state

Conclusion

Kubernetes kubectl est l'interface principale pour interagir avec un cluster Kubernetes et cet article a démontré à quel point cet outil est puissant dans les mains d'un utilisateur expérimenté.

Cependant, nous ne pouvons couvrir qu'une vue résumée de ce que kubectl peut faire de plus. Pour l'explorer plus en détail et découvrir tout ce qu'il prend en charge, consultez sa documentation officielle ici.