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 système 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"

Assurez-vous de placer le binaire téléchargé à un emplacement fixe, ajoutez l’emplacement à votre variable PATH et rendez-le exécutable avec la commande chmod x.

Sur une machine Windows, vous pouvez télécharger la dernière version disponible de kubectl en obtenant 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} par la dernière version en utilisant curl comme suit :

$ 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 trouver le guide officiel pour obtenir kubectl ici.

Vérifiez l’installation de kubectl

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

$ kubectl version --client

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

$ kubectl <x><x>[command]</x></x> [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 voir la configuration actuelle de kubectl, utilisez :

$ kubectl config view

Pour lister tous les contextes disponibles :

$ kubectl config get-contexts

Pour obtenir le contexte actuel de kubectl :

$ kubectl config current-context

Nous pouvons changer le contexte en cours 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 [--certificat-client=chemin/vers/fichier-cert] [--clé-client=chemin/vers/fichier-clé] [--token=token_porteur] [--username=utilisateur_basique] [--password=mot_de_passe_basique]

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, comme 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

$ 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 suivantes dans ce contexte :

kubectl config set-context --current --namespace=[NAMESPACE] $ 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 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 la commande suivante : $ kubectl apply -f [manifest.yaml] :

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

Pour créer une ou plusieurs ressources dans tous les fichiers manifest 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 d’un nom d’image du 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 saisissant le contenu YAML dans l’interface de programmation sans se référer à un fichier manifeste enregistré, essayez quelque chose comme :

# Créez plusieurs objets YAML à partir de stdin
cat <<EOF | kubectl apply -f -
apiVersion : v1
kind : Pod
metadata :
name : busybox-sleep
spec :
conteneurs :
- name : busybox
image : busybox
args :
- sleep
- "1000000"
---
apiVersion : v1
kind : Pod
metadata :
name : busybox-sleep-less
spec :
conteneurs :
- name : busybox
image : busybox
args :
- sleep
- "1000"
EOF

Afficher/trouver des ressources

kubectl fournit la commande get pour lister les ressources déployées, obtenir leurs détails et en savoir plus sur elles.

Pour lister 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 la suivante :

$ kubectl get pods --all-namespaces

Si vous souhaitez obtenir plus de détails sur les pods déployés, utilisez l’option -o wide comme suit : $ kubectl get pods –all-namespaces

$ 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 l’indicateur -o yaml comme suit : $ kubectl get pod [deployment-name] :

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

Souvent, nous avons 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 suit :

$ kubectl describe nodes [node-name]

Ou de la même manière pour les pods : $ kubectl describe pods [node-name] :

$ 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 – – – – – – – – – – – – – – – :

$ 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 l’option -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, vous pouvez utiliser l’option -sort-by comme suit :

$ 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 la commande diff comme suit :

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

Modifier les ressources

Les ressources déployées sont souvent modifiées en fonction 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, comme suit : $ kubectl rollout history

$ 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 le drapeau --to-revision comme suit :

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

Et pour vérifier l’état de la mise à jour, nous utilisons : $ kubectl rollout status :

$ kubectl rollout status -w deployment/frontend

Pour redémarrer le déploiement, disons “frontend”, utilisez : $ kubectl rollout restout :

$ 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 ayez besoin de forcer le remplacement, la suppression, puis la recréation d’une ressource (NOTE : cela provoquera également une interruption de service), ce qui peut être fait comme suit :

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

L’étiquetage d’une ressource (qui supporte les étiquettes) est facile et peut être fait en utilisant : $ kubectl label pods :

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

De même, une annotation peut être ajoutée à une ressource en utilisant : $ kubectl annotate pods [pod-name] new-label=[label] :

$ 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 représentent les valeurs minimum et maximum à utiliser pour la mise à l’échelle automatique.

Modification des ressources

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

kubectl edit [api-resource-name]

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

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 supportées 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

Au lieu de cela, nous pouvons nous référer à un fichier YAML de manifeste pour spécifier la ressource à mettre à l’échelle comme suit : $ kubectl scale –replicas=3 rs/foo

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

Nous pouvons également effectuer une mise à l’échelle en fonction de l’état actuel du déploiement, comme suit : $ kubectl scale –replicas=3 -f foo.yaml

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

Suppression de ressources

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

Pour supprimer un pod en utilisant les spécifications du fichier JSON, nous utilisons :

$ kubectl delete -f ./pod.json

Nous pouvons supprimer des pods et des services avec les mêmes noms pod-name et service-name comme suit : $ kubectl delete pod,service-name -f ./pod.json

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

Si les ressources sont étiquetées et que nous devons supprimer des ressources avec une étiquette spécifique, disons nom-étiquette, nous pouvons utiliser : $ kubectl delete pods, service [pod-name] [service-name] :

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

Pour supprimer tous les pods et services contenus dans un espace de noms, utilisez : $ kubectl -n [label-name] :

$ kubectl -n <x>[namespace]</x> delete pod,svc --all

Interaction 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, ce qui permet d’administrer un cluster Kubernetes.

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

$ kubectl logs [pod-name]

Ou pour extraire les logs d’un pod avec une étiquette spécifique :

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

Ou pour obtenir les logs d’un conteneur spécifique : $ kubectl logs -l name=[label-name] :

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

Nous pouvons également diffuser les logs comme nous le faisons avec la commande Linux tail -f avec l’option -f de kubectl :

$ kubectl logs -f [nom-de-pod]

L’exécution interactive d’un pod peut être réalisée avec kubectl comme suit :

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

Ou pour exécuter un pod dans un espace de noms spécifique, utilisez :

$ kubectl run nginx --image=nginx -n <x>[namespace]</x>

Vous pouvez l’attacher à un conteneur en cours d’exécution avec la commande attach:

$ 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 ci-dessous :

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

Pour exécuter quelque chose directement dans un pod, connectez-vous et obtenez la sortie avec la commande suivante : $ kubectl exec [pod-port] :

$ kubectl exec [pod-name] -- <x><x>[command]</x></x>

La commande ci-dessus fonctionne si le pod ne contient qu’un seul conteneur. Pour les pods multi-conteneurs, utilisez :

$ kubectl exec [nom-de-pod] -c [nom-de-conteneur] -- <x><x>[commande]</x></x>

Pour afficher les mesures de performance d’un pod donné et de ses conteneurs, vous pouvez utiliser : $ kubectl top pod [pod-name] -c [container-name] — [command] :

$ kubectl top pod [nom-de-pod] --containers

Ou pour les trier par mesure, par exemple le CPU ou la mémoire, nous pouvons le faire en utilisant : $ kubectl top pod [pod-name] –containers :

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

Interagir avec les nœuds et les clusters

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

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

$ kubectl cordon [node-name]

Pour drainer un nœud dans le cadre de la préparation d’une maintenance, utilisez : $ kubectl drain [node-name] :

$ kubectl drain [node-name]

Pour marquer à nouveau le nœud comme planifiable, utilisez : $ kubectl uncordon [node-name] :

$ kubectl uncordon [node-name]

Pour obtenir les mesures de performance relatives à un nœud, nous pouvons utiliser : $ kubectl top node [node-name] :

$ kubectl top node [node-name]

Pour obtenir des détails sur le cluster actuel, utilisez : $ kubectl cluster-info [node-name] :

$ kubectl cluster-info

Nous pouvons également afficher l’état de la grappe sur la sortie standard en utilisant : $ kubectl cluster-info

$ kubectl cluster-info dump

Ou, pour transférer l’état du cluster dans un fichier, utilisez : $ kubectl cluster-info dump

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

Conclusion

Kubernetes est le mot à la mode dans l’industrie et savoir comment le gérer efficacement stimulera toujours votre carrière. 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 n’avons pu 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, reportez-vous à sa documentation officielle ici.