Sawl

Appearance

Kubectl ​

kubectl est un outil en ligne de commande utilisé pour interagir avec des clusters Kubernetes. Il permet de gérer et de déployer des applications, de contrôler les ressources du cluster (comme les pods, services et déploiements) et d'effectuer des opérations administratives, comme le scaling, le débogage ou la surveillance. En résumé, c'est l'interface principale pour gérer des clusters Kubernetes.

Installation ​

Linux ​

  1. Ouvrez un terminal sur votre machine Linux.

  2. Utilisez la commande curl pour télécharger la dernière version stable de kubectl. Exécutez la commande suivante dans le terminal :

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

  3. Une fois le fichier téléchargé, il est nécessaire de rendre le binaire exécutable et accessible. Exécutez les commandes suivantes :

    sh
    chmod +x kubectl
sudo mv kubectl /usr/local/bin/

Windows ​

  • Rendez-vous sur la page des releases de kubectl.
  • Téléchargez la version Windows du binaire kubectl.
  • Renommez le fichier téléchargé en kubectl.exe.
  • Déplacer l'exécutable dans un dossier accessible :
  • Comme pour Minikube, placez kubectl.exe dans un dossier accessible à partir du PATH. Vous pouvez le placer dans le même dossier que minikube.exe (C:\minikube\).

Principales commandes ​

sh
kubectl get pods
  • Cette commande affiche la liste de tous les pods dans le namespace courant. Elle donne une vue d'ensemble rapide des pods et de leur état. Les informations renvoyées incluent :
    • Nom du pod
    • État (par exemple : Running, Pending, Failed, etc.)
    • Redémarrages (nombre de fois où le pod a été redémarré)
    • Âge du pod (temps depuis son lancement)
  • Utile pour surveiller rapidement l'état des pods dans ton cluster.
sh
kubectl get pods -n <namespace>
  • Liste les pods dans un namespace spécifique en utilisant l'option -n pour indiquer le namespace souhaité. Remplace <namespace> par le nom de ton namespace. Exemple : kubectl get pods -n production pour voir les pods dans le namespace production.
  • Cela te permet de restreindre la vue uniquement aux pods d’un namespace particulier, évitant ainsi de mélanger les pods d'autres environnements ou projets.
sh
kubectl get pods --namespace <namespace>
  • Alternative équivalente à la commande précédente kubectl get pods -n <namespace>. Le flag --namespace permet également de spécifier un namespace particulier.
  • L'avantage est principalement une question de style et de lisibilité : certaines personnes préfèrent cette syntaxe plus explicite.
sh
kubectl get pods -A
# ou
kubectl get pods --all-namespaces
  • Ces deux commandes sont identiques et permettent de lister tous les pods de tous les namespaces dans le cluster. L'option -A est une abréviation de --all-namespaces.
  • Cette commande est utile pour avoir une vue d'ensemble du cluster Kubernetes entier, surtout pour les administrateurs qui souhaitent vérifier l'état de tous les pods dans tous les namespaces.
sh
kubectl get nodes
  • Liste tous les nœuds (machines physiques ou virtuelles) de ton cluster Kubernetes. Les informations renvoyées incluent :
    • Nom du nœud
    • État du nœud (par exemple : Ready, NotReady, Unknown, etc.)
    • Rôles du nœud (par exemple, master ou worker)
    • Âge du nœud (durée depuis que le nœud fait partie du cluster)
    • Version de Kubernetes qui fonctionne sur chaque nœud.
  • Cette commande est utile pour surveiller l'état de santé des nœuds et leur disponibilité.
sh
kubectl describe pod <pod-name>
  • Cette commande fournit une description détaillée du pod spécifié par <pod-name>. Les informations incluent :
    • Les événements associés au pod (par exemple, démarrage, redémarrage, erreurs).
    • Les conditions (par exemple : si le container est prêt, si les probes de santé sont OK).
    • Les détails des containers à l'intérieur du pod (image utilisée, statut, ressources consommées).
    • Les logs des événements récents associés au pod.
  • Utile pour troubleshooter un pod qui pose problème.
sh
kubectl get pod <pod-name> -o yaml
  • Affiche la définition complète du pod <pod-name> au format YAML. Ce format est utilisé pour la définition des objets Kubernetes, il est lisible par l'humain et facile à manipuler.
  • La sortie YAML contient des détails comme les labels, annotations, configurations des containers, montages de volumes, etc.
  • Utile pour comprendre la configuration exacte d'un pod ou pour exporter sa configuration afin de la réutiliser.
sh
kubectl get pod <pod-name> -o json
  • Affiche les mêmes informations qu'avec la commande précédente, mais cette fois au format JSON. JSON est un format de données largement utilisé et compatible avec de nombreux outils d'analyse et de traitement.
  • Ce format est particulièrement utile pour automatiser des traitements ou pour intégrer des systèmes externes qui s'attendent à recevoir des données en JSON.
sh
kubectl get pod <pod-name> -o yaml | yq
  • Cette commande affiche la définition du pod <pod-name> au format YAML, puis passe la sortie via l'outil yq, un utilitaire qui permet de manipuler les fichiers YAML directement en ligne de commande.
  • Tu peux utiliser yq pour extraire des données spécifiques du YAML, modifier des valeurs ou filtrer certaines sections du fichier YAML. Par exemple, tu pourrais l'utiliser pour ne récupérer que les labels d'un pod sans avoir à lire l'intégralité du YAML.
sh
kubectl get pod <pod-name> -o json | jq
  • Cette commande affiche la définition du pod <pod-name> au format JSON et les passe via l'outil jq, un outil puissant pour manipuler des données JSON.
  • jq permet de filtrer, formater, et transformer les données JSON. Par exemple, tu peux extraire uniquement les annotations ou les ressources consommées par les containers du pod.
  • C'est un outil très utile pour automatiser des tâches complexes ou pour extraire rapidement des informations spécifiques depuis une sortie JSON volumineuse.
sh
kubectl logs <pod-name>
  • Affiche les logs du container principal d'un pod. C'est la commande la plus utilisée pour debugger une application.
  • Options utiles :
    • -f : suit les logs en temps réel (comme tail -f)
    • --tail=100 : affiche les 100 dernières lignes
    • -c <container> : spécifie le container si le pod en contient plusieurs
    • --previous : affiche les logs du container précédent (utile si le container a redémarré)
sh
kubectl exec -it <pod-name> -- /bin/sh

  • Ouvre un shell interactif à l'intérieur du container. Très utile pour debugger ou inspecter l'état d'un container en cours d'exécution.

  • Options :

    • -i : mode interactif (garde STDIN ouvert)
    • -t : alloue un TTY (terminal)
    • -c <container> : spécifie le container si le pod en contient plusieurs

  • Tu peux aussi exécuter une commande unique sans shell interactif :

    sh
    kubectl exec <pod-name> -- cat /etc/config/app.conf
sh
kubectl apply -f <fichier.yaml>

  • Crée ou met à jour des ressources Kubernetes à partir d'un fichier YAML (ou JSON). C'est la méthode déclarative recommandée pour gérer les ressources.

  • Tu peux aussi appliquer un répertoire entier ou une URL :

    sh
    kubectl apply -f ./manifests/
kubectl apply -f https://exemple.com/deployment.yaml

  • L'option -k permet d'utiliser Kustomize :

    sh
    kubectl apply -k ./overlays/production/
sh
kubectl delete <resource> <name>

  • Supprime une ressource du cluster. Exemples :

    sh
    kubectl delete pod my-pod
kubectl delete deployment my-deployment
kubectl delete -f deployment.yaml

  • Options utiles :

    • --force --grace-period=0 : suppression immédiate (à utiliser avec précaution)
    • --all : supprime toutes les ressources d'un type dans le namespace
sh
kubectl config get-contexts

  • Affiche la liste des contextes disponibles. Un contexte combine un cluster, un utilisateur et un namespace.

  • Commandes associées :

    sh
    kubectl config current-context        # Affiche le contexte actuel
kubectl config use-context <name>     # Change de contexte
kubectl config set-context --current --namespace=<ns>  # Change le namespace par défaut
sh
kubectl get services
  • Liste tous les services dans le namespace courant. Les services exposent les pods sur le réseau.
  • Affiche le type de service (ClusterIP, NodePort, LoadBalancer), les ports exposés et l'IP du cluster.
sh
kubectl get deployments
  • Liste tous les deployments dans le namespace courant. Un deployment gère un ensemble de pods répliqués.
  • Affiche le nombre de réplicas souhaités, disponibles et à jour.
sh
kubectl scale deployment <name> --replicas=<n>

  • Scale un deployment en ajustant le nombre de réplicas. Exemple :

    sh
    kubectl scale deployment nginx --replicas=5
sh
kubectl rollout status deployment/<name>

  • Affiche le statut d'un rollout (déploiement progressif). Utile pour suivre un déploiement en cours.

  • Commandes associées :

    sh
    kubectl rollout history deployment/<name>   # Historique des révisions
kubectl rollout undo deployment/<name>      # Rollback à la version précédente
kubectl rollout restart deployment/<name>   # Redémarre tous les pods
sh
kubectl port-forward <pod-name> <local-port>:<pod-port>

  • Crée un tunnel entre ta machine locale et un pod. Utile pour accéder à un service sans l'exposer publiquement.

    sh
    kubectl port-forward pod/nginx 8080:80
# Accessible sur http://localhost:8080

  • Fonctionne aussi avec les services :

    sh
    kubectl port-forward svc/nginx 8080:80

Activer l'autocomplétion avec zsh ​

Editez votre ~/.zshrc et ajouter

sh
autoload -Uz compinit
compinit
source <(kubectl completion zsh)

kubectl get <TAB> fournira alors l'autocomplétion sur les différents objets du cluster.