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.