• Assurez la sécurité des applications de la bonne manière! Détectez, protégez, surveillez, accélérez et plus encore…
  • Kubernetes, également connu sous le nom de K8S, est un outil d'orchestration de conteneurs populaire pour la gestion et la mise à l'échelle d'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 afficher, contrôler et gérer le cluster. Il est pris en charge sur différentes plates-formes et peut être facilement configuré pour gérer un cluster.

    Dans cet article, nous allons couvrir certaines 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 à partir d'un système distant, vous pouvez facilement l'installer pour qu'il fonctionne avec n'importe quelle configuration de cluster.

    Sur un Linux système, 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 PATH variable et rendez-le exécutable avec chmod +x commander.

    Sur un Windows box, vous pouvez télécharger la dernière version disponible de kubectl en obtenant d'abord la dernière version stable de https://dl.k8s.io/release/stable.txt

    Et puis téléchargez-le 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 plates-formes prises en charge, vous pouvez trouver 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 en tant que:

    $ kubectl version --client

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

    $ 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 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 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 "clé-client" 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, par exemple, 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 incorporer des données de certificat client dans l'entrée «cluster-admin», la syntaxe change 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]

    Créer des 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 YAML or JSON fichier avec extension .yaml or .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 du référentiel comme:

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

    Par exemple, pour déployer une seule instance de serveur Web Nginx:

    $ kubectl create deployment nginx --image=nginx

    Enfin, pour déployer directement les ressources en tapant le YAML contenu dans la CLI sans faire référence à un fichier manifeste enregistré, 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

    Afficher / rechercher des ressources

    kubectl fournit get commande pour répertorier les ressources déployées, obtenir leurs détails et en savoir plus à leur sujet.

    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 devons répertorier plus de détails sur les pods déployés, utilisez -o wide marquer 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 drapeau comme:

    $ 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 aide à obtenir ces détails.

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

    $ kubectl describe nodes [node-name]

    Ou de même pour les pods comme:

    $ kubectl describe pods [pod-name]

    kubectl permet de trier la sortie en fonction d'un champ particulier. Pour répertorier 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 -o jsonpath drapeau avec la syntaxe ci-dessous:

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

    Pour récupérer les libellés associés à une ressource, par exemple des pods, essayez:

    $ kubectl get pods --show-labels

    Pour obtenir une liste d'événements mais qui est triée par horodatage, nous pouvons utiliser -sort-by marquer comme:

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

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

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

    Modifier les ressources

    Les ressources déployées étaient souvent modifiées pour tout changement de configuration.

    Pour effectuer une mise à jour continue de, disons "www" conteneurs de, disons "frontend" déploiement 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 la révision comme:

    $ kubectl rollout history deployment/frontend

    Ou pour revenir à un déploiement précédent, utilisez:

    $ kubectl rollout undo deployment/frontend

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

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

    Et pour vérifier l'état des mises à jour progressives, nous utilisons:

    $ kubectl rollout status -w deployment/frontend

    Pour le redémarrage progressif du déploiement, disons «frontal», 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 recréer une ressource (REMARQUE: cela entraînera également une interruption de service), ce qui peut être effectué comme suit:

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

    Étiqueter une ressource (qui prend en charge les étiquettes) est facile et peut être fait en utilisant:

    $ 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] icon-url=[url]

    L'autoscaling 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 automatiquement et min-val et max-val indique la valeur minimale et maximale à utiliser pour la mise à l'échelle automatique.

    Modifier les ressources

    Il est possible de modifier une ressource API dans votre éditeur préféré avec edit commander.

    $ 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 facilite cette opération.

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

    $ kubectl scale --replicas=3 rs/foo

    Ou à la place, nous pouvons faire référence à un fichier YAML manifeste pour spécifier la ressource à mettre à l'échelle comme:

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

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

    Supprimer des ressources

    Les ressources créées devront éventuellement être modifiées ou supprimées. Avec kubectl, nous pouvons supprimer des ressources existantes de plusieurs manières.

    Pour supprimer un pod à l'aide de la spécification 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:

    $ 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 label-name, on peut 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 l'exécution de pods qui aident administrer un cluster Kubernetes.

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

    $ kubectl logs [pod-name]

    Ou pour vider les journaux de pod avec une étiquette spécifique:

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

    Ou pour obtenir des journaux pour un conteneur spécifique comme:

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

    Nous pouvons également diffuser des journaux comme nous le faisons avec Linux tail -f commande avec kubectl -f drapeau aussi:

    $ kubectl logs -f [pod-name]

    L'exécution d'un pod de manière interactive peut être effectuée avec kubectl comme:

    $ 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 [namespace]

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

    $ 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 et obtenir la sortie, utilisez:

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

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

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

    Pour afficher les métriques de performances pour un pod donné et ses conteneurs, nous pouvons utiliser:

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

    Ou pour le trier par une mesure, par exemple CPU ou mémoire, nous pouvons y parvenir 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 pour la même chose.

    Pour marquer un nœud comme non planifiable, utilisez:

    $ kubectl cordon [node-name]

    Pour vidanger un nœud dans le cadre de la préparation de la maintenance:

    $ kubectl drain [node-name]

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

    $ kubectl uncordon [node-name]

    Pour obtenir des métriques de performances liées à 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 également vider l'état du cluster sur la sortie standard en utilisant:

    $ kubectl cluster-info dump

    Ou pour vider dans un fichier, utilisez:

    $ 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 dynamisera toujours votre carrière. kubectl est la principale interface pour interagir avec un cluster Kubernetes et cet article a démontré à quel point cet outil est puissant entre les mains d'un utilisateur expérimenté.

    Pourtant, 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 voir ce qu'il prend en charge, reportez-vous à sa documentation officielle ici.