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-name
nous 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.