Aller au contenu principal

Kubectl de A à Z

Dans ce guide, je vais vous accompagner à travers l'administration de clusters Kubernetes en utilisant l'outil kubectl. kubectl est l'interface en ligne de commande qui vous permet d'interagir avec vos clusters Kubernetes.

Que vous soyez débutant ou administrateur expérimenté, ce guide vous fournira les connaissances nécessaires pour démarrer dans l'administration de vos clusters en utilisant des exemples concrets et des explications claires. Vous découvrirez comment installer kubectl, vous connecter à un cluster, gérer les Pods et les Services et bien plus encore.

Concepts de base​

Avant de plonger dans les commandes et les fonctionnalités avancées, il est essentiel de comprendre les concepts de base de Kubernetes. Ce chapitre reprend les notions fondamentales abordées dans le guide d'introduction à Kubernetes. Ces concepts de base sont essentiels pour comprendre comment Kubernetes fonctionne et pour administrer efficacement vos clusters. Dans les chapitres suivants, nous allons explorer en détail comment utiliser ces concepts avec kubectl pour gérer vos déploiements et assurer le bon fonctionnement de vos applications.

Cluster​

Un cluster Kubernetes est un ensemble de nœuds (machines physiques ou virtuelles) sur lesquels Kubernetes déploie et gère vos applications. Chaque cluster est constitué de deux types de composants principaux : le master et les nœuds de travail.

  • Master : Il est responsable de la gestion de l'état du cluster. Il orchestre les tâches, répartit les charges de travail et assure la communication entre les composants. Le master comprend plusieurs composants, tels que l'API server, le scheduler et le controller manager.
  • Nœuds de travail : Ce sont les machines qui exécutent les applications conteneurisées. Chaque nœud contient un agent Kubernetes appelé kubelet qui gère les Pods, ainsi qu'un environnement d'exécution de conteneurs comme Docker.

Pod​

Le Pod est l'unité de base de déploiement dans Kubernetes. Il représente un ensemble d'un ou plusieurs conteneurs qui partagent le même réseau et le même stockage. Les Pods sont éphémères par nature et peuvent être remplacés ou redéployés automatiquement.

Service​

Un Service est une abstraction Kubernetes qui définit une politique pour accéder aux Pods. Il permet de regrouper un ensemble de Pods sous une adresse IP unique et un nom DNS, facilitant ainsi la communication entre les différentes parties de votre application. Les Services permettent également de gérer la découverte et le load balancing des Pods.

Namespace​

Les Namespaces sont utilisés pour diviser un cluster Kubernetes en espaces logiques distincts, permettant une organisation et une gestion plus efficaces des ressources. Chaque ressource dans Kubernetes, comme les Pods et les Services, appartient à un namespace. Par défaut, Kubernetes crée plusieurs namespaces tels que default, kube-system et kube-public.

Deployment​

Un Deployment est une ressource Kubernetes qui gère le déploiement et la mise à jour des Pods de votre application. Il permet de définir le nombre de réplicas, de mettre à jour les versions de conteneurs et de rouler les mises à jour de manière contrôlée.

ConfigMap et Secret​

  • ConfigMap : Permet de séparer les configurations de l'application du code source. Il stocke des données de configuration non sensibles sous forme de paires clé-valeur.
  • Secret : Similaire à ConfigMap, mais utilisé pour stocker des informations sensibles comme des mots de passe, des jetons ou des clés SSH. Les données sont encodées en base64 pour plus de sécurité.

Persistent Volume (PV) et Persistent Volume Claim (PVC)​

  • Persistent Volume (PV) : Représente un stockage disponible pour une utilisation dans le cluster. Il est provisionné par un administrateur.
  • Persistent Volume Claim (PVC) : Une demande de stockage par un utilisateur. Les PVC sont liés aux PV pour fournir un espace de stockage persistant aux Pods.

Installation de kubectl​

Pour administrer vos clusters Kubernetes, vous devez installer kubectl, l'outil en ligne de commande de Kubernetes. kubectl vous permet de déployer, inspecter et gérer les ressources Kubernetes directement depuis votre terminal.

Prérequis​

Avant d'installer kubectl, assurez-vous que vous avez accès à un terminal ou une ligne de commande sur votre machine. Vous devez également disposer des privilèges nécessaires pour installer des logiciels sur votre système.

Installation sur Linux​

Pour installer kubectl sur Linux, suivez ces étapes :

# Téléchargez 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"

# Rendez le fichier exécutable
chmod +x kubectl

# Déplacez le binaire dans votre PATH
sudo mv kubectl /usr/local/bin/

# Vérifiez l'installation
kubectl version --client

Installation sur macOS​

Si vous utilisez macOS, vous pouvez installer kubectl via Homebrew :

# Installez kubectl avec Homebrew
brew install kubectl

# Vérifiez l'installation
kubectl version --client
Client Version: v1.30.1
Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3

Installation sur Windows​

Pour installer kubectl sur Windows, utilisez Chocolatey, un gestionnaire de paquets pour Windows :

# Installez kubectl avec Chocolatey
choco install kubernetes-cli

# Vérifiez l'installation
kubectl version --client

Installation avec asdf​

Pour installer kubectl on peut aussi utiliser asdf qui permet d'installer une très grande partie des outils permettant de gérer des clusters kubernetes.

asdf plugin add kubectl
asdf install kubectl latest
asdf global kubectl latest

Mise à jour de kubectl​

Il est important de maintenir kubectl à jour pour bénéficier des dernières fonctionnalités et correctifs de sécurité. Pour mettre à jour kubectl, suivez les mêmes instructions que pour l'installation, selon votre système d'exploitation et votre méthode d'installation.

Avec ces étapes, vous devriez maintenant avoir kubectl installé sur votre système. Dans le chapitre suivant, nous allons voir comment configurer kubectl pour se connecter à un cluster Kubernetes.

Syntaxe de kubectl​

Sa syntaxe est la suivante :

kubectl [commande] [TYPE] [NOM] [flags]
  • commande : Indique l'opération que vous désirez exécuter sur une ou plusieurs ressources, par exemple create, get, describe, delete.
  • TYPE : Indique le type de ressources que vous voulez manipuler
  • NOM : Indique le nom de la ressource (sensible à la casse)
  • flags : flags optionnels

Configuration de kubectl​

Après avoir installé kubectl, il est essentiel de le configurer correctement pour interagir avec vos clusters Kubernetes. Dans ce chapitre, je vais expliquer comment mettre en place l'autocomplétion, gérer les fichiers de configuration dans le répertoire .kube et utiliser les contextes.

Mise en place de l'autocomplétion​

L'autocomplétion permet de faciliter l'utilisation de kubectl en vous suggérant automatiquement des commandes et des arguments. Voici comment l'activer pour différents shell's.

Bash​

Pour activer l'autocomplétion dans Bash, exécutez les commandes suivantes :

# Ajouter l'autocomplétion à votre profil Bash
echo "source <(kubectl completion bash)" >> ~/.bashrc

Zsh​

Pour activer l'autocomplétion dans Zsh, suivez ces étapes :

# Ajouter l'autocomplétion à votre profil Zsh
echo "source <(kubectl completion zsh)" >> ~/.zshrc

Fish​

Pour activer l'autocomplétion dans Fish, utilisez la commande suivante :

# Ajouter l'autocomplétion à votre profil Fish
kubectl completion fish > ~/.config/fish/completions/kubectl.fish

Redémarrer votre shell et tapez kubectl suivi de tabulation. Vous ferez par exemple pour changer de namespace, on verra la création plus tard, il suffit de taper kubectl -n tab et la liste de tous les namespaces existant sur votre cluster s'affichera.

Les fichiers de configuration​

Le répertoire .kube situé dans votre répertoire personnel contient les fichiers de configuration utilisés par kubectl. Le fichier principal est config, qui stocke les informations nécessaires pour se connecter à un ou plusieurs clusters.

Le fichier de configuration config contient les clusters, les utilisateurs et les contextes configurés. Voici un exemple de fichier config typique :

apiVersion: v1
clusters:
- cluster:
    server: https://my-cluster-api-server
    certificate-authority: /path/to/ca.crt
  name: my-cluster
contexts:
- context:
    cluster: my-cluster
    user: my-user
    namespace: default
  name: my-context
current-context: my-context
kind: Config
preferences: {}
users:
- name: my-user
  user:
    token: MY_ACCESS_TOKEN

Utilisation de la variable KUBECONFIG​

Lorsque vous travaillez avec plusieurs clusters ou environnements, il est pratique de séparer les configurations dans plusieurs fichiers. kubectl permet d'utiliser plusieurs fichiers de configuration grâce à la variable d'environnement KUBECONFIG.

# Sous Linux/macOS
export KUBECONFIG=~/.kube/config-cluster2

# Sous Windows
set KUBECONFIG=%USERPROFILE%\.kube\config-cluster2

Vous pouvez définir la variable KUBECONFIG pour utiliser plusieurs fichiers de configuration en les séparant par des deux-points (:) sous Linux/macOS ou par un point-virgule (;) sous Windows. Par exemple :

# Sous Linux/macOS
export KUBECONFIG=~/.kube/config:~/.kube/config-cluster2

# Sous Windows
set KUBECONFIG=%USERPROFILE%\.kube\config;%USERPROFILE%\.kube\config-cluster2

Fusionner les configurations​

Pour vérifier et fusionner les configurations :

kubectl config view --merge --flatten > ~/.kube/merged-config
export KUBECONFIG=~/.kube/merged-config

Gestion des contextes​

Les contextes dans kubectl permettent de définir des configurations spécifiques pour interagir avec différents clusters ou utilisateurs. Cela facilite le passage d'un environnement à un autre sans modifier constamment le fichier de configuration.

Afficher les contextes​

Pour afficher la liste des contextes disponibles :

kubectl config get-contexts

Utiliser un contexte​

Pour changer de contexte et utiliser un autre cluster ou utilisateur :

kubectl config use-context my-context

Ajouter un contexte​

Pour ajouter un nouveau contexte :

kubectl config set-context new-context --cluster=my-cluster --user=my-user --namespace=my-namespace

Supprimer un contexte​

Pour supprimer un contexte :

kubectl config delete-context old-context

Avec ces configurations, vous pouvez personnaliser et optimiser votre utilisation de kubectl pour gérer plusieurs clusters et utilisateurs efficacement. Dans le chapitre suivant, nous allons aborder la gestion des Pods et des Services.

Bonnes pratiques de gestion des fichiers de configuration​

Pour éviter les erreurs et faciliter la gestion des configurations, il est recommandé de suivre quelques bonnes pratiques :

  • Séparer les environnements : Utilisez des fichiers de configuration distincts pour chaque environnement (développement, test, production) afin de minimiser les risques de modification accidentelle des ressources en production.
  • Nommer les fichiers de configuration : Donnez des noms explicites à vos fichiers de configuration (par exemple, config-dev, config-prod) pour une identification rapide.
  • Utiliser des répertoires spécifiques : Organisez vos fichiers de configuration dans des répertoires distincts (par exemple, ~/.kube/dev, ~/.kube/prod) pour maintenir une structure claire.
  • Vérifier les configurations : Avant d'exécuter des commandes critiques, vérifiez toujours le contexte actuel avec kubectl config current-context.

Avec ces bonnes pratiques, vous pouvez personnaliser et optimiser votre utilisation de kubectl pour gérer plusieurs clusters efficacement.

Obtenir la liste des ressources kubernetes : api-resources​

La commande kubectl api-resources est un outil essentiel pour obtenir des informations sur les types de ressources disponibles dans l'API Kubernetes. Elle permet de lister toutes les ressources accessibles via l'API, ainsi que leurs groupes, versions et si elles sont nommées ou non. Cette commande est particulièrement utile pour découvrir de nouvelles ressources ou pour comprendre l'organisation de l'API Kubernetes.

Syntaxe de base​

La syntaxe de base de la commande kubectl api-resources est la suivante :

kubectl api-resources [flags]
  • flags (optionnel) : Options supplémentaires pour filtrer ou formater la sortie.

Affichage des ressources​

Lister toutes les ressources​

Pour lister toutes les ressources disponibles dans l'API Kubernetes :

kubectl api-resources

Cette commande affiche une liste complète de toutes les ressources, avec des colonnes pour le nom de la ressource, son type court, son groupe, sa version, et si elle est de type nommée (NAMESPACED).

Filtrer les ressources par groupe​

Pour filtrer les ressources appartenant à un groupe spécifique, utilisez l'option --api-group :

kubectl api-resources --api-group=apps

Cette commande affiche toutes les ressources du groupe apps.

Informations fournies par api-resources​

La commande kubectl api-resources fournit une liste structurée des ressources, incluant :

  • Name : Le nom complet de la ressource.
  • ShortNames : Les abréviations ou noms courts utilisés pour référencer la ressource.
  • APIGroups : Le groupe d'API auquel la ressource appartient.
  • Namespaced : Indique si la ressource est liée à un namespace (true ou false).
  • Kind : Le type ou la classe de la ressource.

Exemples pratiques​

Lister les ressources dans un groupe spécifique​

Pour lister toutes les ressources dans le groupe batch :

kubectl api-resources --api-group=batch

Cette commande affiche des ressources telles que jobs et cronjobs appartenant au groupe batch.

Lister les ressources non nommées​

Pour lister uniquement les ressources qui ne sont pas liées à un namespace :

kubectl api-resources --namespaced=false

Lister les ressources avec des noms courts​

Pour afficher toutes les ressources avec leurs noms courts :

kubectl api-resources --sort-by=shortnames

Cette commande trie les ressources par leurs noms courts, facilitant la recherche des abréviations utilisées pour certaines ressources.

Utilisation avancée​

L'utilisation de kubectl api-resources est particulièrement utile pour découvrir de nouvelles ressources introduites dans des versions plus récentes de Kubernetes ou par des Custom Resource Definitions (CRD).

La commande kubectl api-resources peut être intégrée dans des scripts pour automatiser la découverte et la gestion des ressources disponibles dans un cluster Kubernetes. Par exemple, un script peut lister toutes les ressources d'un groupe spécifique et exécuter des commandes sur chacune d'elles.

Bonnes pratiques​

L'utilisation de kubectl api-resources fait partie des bonnes pratiques pour l'administration de Kubernetes, car elle permet de :

  • Explorer l'API : Comprendre l'étendue des ressources disponibles et comment elles sont organisées dans l'API.
  • Configurer correctement les RBAC : S'assurer que les règles de contrôle d'accès basées sur les rôles (RBAC) sont correctement configurées en connaissant toutes les ressources à protéger.
  • Optimiser les scripts : Écrire des scripts plus robustes et dynamiques qui peuvent s'adapter aux changements dans les ressources de l'API.

Utilisation de la commande explain​

La commande kubectl explain est un outil précieux pour comprendre la structure et les propriétés des ressources Kubernetes. Elle permet d'afficher des informations détaillées sur les champs des ressources Kubernetes, aidant ainsi à mieux comprendre comment configurer et utiliser ces ressources.

Syntaxe de base​

La syntaxe de base de la commande kubectl explain est la suivante :

kubectl explain [RESOURCE_TYPE] [FIELD_PATH] [flags]
  • RESOURCE_TYPE : Le type de ressource que vous souhaitez expliquer (par exemple, pods, services, deployments).
  • FIELD_PATH (optionnel) : Le chemin vers le champ spécifique de la ressource que vous souhaitez expliquer.
  • flags (optionnel) : Options supplémentaires pour spécifier des détails supplémentaires.

Affichage des ressources​

Expliquer une ressource de haut niveau​

Pour obtenir une explication de haut niveau d'une ressource telle qu'un Pod :

kubectl explain pod

Cette commande affiche une description générale de la ressource Pod, incluant ses champs principaux et leur signification.

Expliquer un champ spécifique​

Pour obtenir des informations détaillées sur un champ spécifique d'une ressource, utilisez le chemin du champ. Par exemple, pour expliquer le champ spec d'un Pod :

kubectl explain pod.spec

Expliquer un champ de niveau inférieur​

Vous pouvez également obtenir des informations sur des champs plus spécifiques en fournissant un chemin plus détaillé. Par exemple, pour expliquer le champ containers sous spec d'un Pod :

kubectl explain pod.spec.containers

Informations fournies par explain​

La commande kubectl explain fournit des informations complètes sur les champs des ressources, y compris :

  • Description : Une description textuelle de ce que le champ représente.
  • Type : Le type de données du champ (par exemple, string, integer, array).
  • Champ requis ou optionnel : Indique si le champ est obligatoire ou optionnel.
  • Champs enfants : Les sous-champs que ce champ peut contenir.

Exemples pratiques​

Comprendre la structure des Pods​

Pour comprendre la structure globale d'un Pod, exécutez :

kubectl explain pod

Cette commande vous donne une vue d'ensemble des champs disponibles dans un Pod, tels que metadata, spec et status.

Explorer les conteneurs dans un Pod​

Pour explorer en détail le champ containers d'un Pod, qui est crucial pour définir les conteneurs à l'intérieur d'un Pod :

kubectl explain pod.spec.containers

Cette commande vous montre tous les sous-champs de containers, comme image, ports et resources.

Détails des ports d'un conteneur​

Pour obtenir des informations spécifiques sur le champ ports d'un conteneur :

kubectl explain pod.spec.containers.ports

Utilisation avancée​

Expliquer les ressources personnalisées​

Vous pouvez également utiliser kubectl explain pour des ressources personnalisées définies par des CRD (Custom Resource Definitions). Par exemple, pour expliquer une ressource personnalisée nommée MyResource :

kubectl explain MyResource

Utilisation avec des sélecteurs​

Bien que la commande explain ne soit pas directement combinée avec des sélecteurs, elle peut être utilisée en conjonction avec des ressources sélectionnées pour mieux comprendre leur structure et configuration.

Bonnes pratiques​

Utiliser kubectl explain est une bonne pratique lors de la rédaction de fichiers de configuration ou de l'apprentissage de nouvelles ressources Kubernetes. Voici quelques conseils :

  • Documentation intégrée : Utilisez kubectl explain comme documentation intégrée pour comprendre les ressources et leurs champs sans quitter votre terminal.
  • Validation : Avant de déployer des configurations, utilisez kubectl explain pour vérifier la structure et les champs disponibles, évitant ainsi les erreurs de syntaxe et de configuration.
  • Formation continue : Pour les nouveaux administrateurs ou développeurs Kubernetes, kubectl explain est un excellent outil pour explorer et apprendre les différentes ressources et leurs configurations.

Commande déclarative (apply) vs Commandes impératives (create)​

Lors de l'administration de clusters Kubernetes avec kubectl, il existe deux approches principales pour gérer les ressources : le mode déclaratif et le mode impératif. Chacune de ces approches a ses avantages et ses inconvénients et il est important de comprendre leurs différences pour choisir celle qui convient le mieux à vos besoins.

Mode impératif (create)​

Le mode impératif consiste à exécuter des commandes kubectl directement depuis la ligne de commande pour créer, mettre à jour ou supprimer des ressources. Cette approche est rapide et pratique pour des tâches simples et ponctuelles.

Exemple de commande impérative​

Pour créer un Pod en mode impératif, vous pouvez utiliser la commande suivante :

kubectl create deployment nginx-deployment --image=nginx

Avantages du mode impératif​

  • Rapidité : Idéal pour des opérations simples et rapides.
  • Simplicité : Aucune définition de fichier de configuration requise.
  • Interactivité : Permet de tester et d'ajuster les configurations en temps réel.

Inconvénients du mode impératif​

  • Non reproductible : Les commandes doivent être exécutées manuellement à chaque fois.
  • Difficile à suivre : En l'absence de fichier de configuration, il peut être difficile de suivre l'état actuel des configurations.
  • Gestion des versions : Pas de suivi des versions des configurations appliquées.

Mode déclaratif (apply)​

Le mode déclaratif utilise des fichiers de configuration YAML ou JSON pour définir l'état souhaité des ressources Kubernetes. Ces fichiers sont ensuite appliqués au cluster à l'aide de la commande kubectl apply.

Exemple de fichier de configuration déclaratif​

Voici un exemple de fichier YAML pour un déploiement :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Pour appliquer ce fichier, utilisez la commande suivante :

kubectl apply -f deployment.yaml

Avantages du mode déclaratif​

  • Reproductible : Les configurations sont stockées dans des fichiers, ce qui permet de les réutiliser et de les partager.
  • Gestion des versions : Les fichiers de configuration peuvent être versionnés avec des systèmes de gestion de version comme Git.
  • Facilité de suivi : Les fichiers de configuration permettent de garder une trace claire et précise des configurations appliquées.

Inconvénients du mode déclaratif​

  • Moins interactif : Nécessite la création et la gestion de fichiers de configuration, ce qui peut être moins pratique pour des tâches simples et rapides.
  • Complexité initiale : Peut nécessiter un effort initial pour créer et organiser les fichiers de configuration.

Comparaison des deux modes​

AspectMode impératifMode déclaratif
ApprocheCommandes en ligneFichiers de configuration
RapiditéRapide pour des tâches simplesPlus lent initialement
ReproductibilitéFaibleÉlevée
Gestion des versionsDifficileFacile avec des systèmes de gestion de versions
TraçabilitéDifficileFacile

Choisir le bon mode​

Le choix entre le mode déclaratif et le mode impératif dépend de vos besoins spécifiques et de votre contexte de travail. Pour des tâches simples et ponctuelles, le mode impératif peut être suffisant. En revanche, pour des environnements complexes, nécessitant une traçabilité et une gestion des versions, le mode déclaratif est souvent plus approprié.

En maîtrisant ces deux approches, vous serez en mesure d'administrer vos clusters Kubernetes de manière flexible et efficace. Dans les chapitres suivants, nous allons explorer en détail comment utiliser ces modes pour gérer les Pods, les Services et d'autres ressources Kubernetes.## Obtenir de la documentation

Utilisation de la commande get​

La commande kubectl get est l'une des commandes les plus fréquemment utilisées pour interagir avec Kubernetes. Elle permet de récupérer et d'afficher des informations sur les ressources d'un cluster Kubernetes. Que vous soyez en train de gérer des Pods, des Services, des Déploiements ou d'autres objets Kubernetes, kubectl get vous offre une vue d'ensemble de l'état de ces ressources.

Syntaxe de base​

La syntaxe de base de la commande kubectl get est la suivante :

kubectl get [RESOURCE_TYPE] [NAME] [flags]
  • RESOURCE_TYPE : Le type de ressource que vous souhaitez afficher (par exemple, pods, services, deployments).
  • NAME (optionnel) : Le nom spécifique de la ressource. Si omis, toutes les ressources du type spécifié seront listées.
  • flags (optionnel) : Options supplémentaires pour filtrer ou formater la sortie.

Affichage des ressources​

Afficher tous les Pods​

Pour afficher tous les Pods dans le namespace par défaut, utilisez :

kubectl get pods

Pour afficher les Pods dans un namespace spécifique :

kubectl get pods -n my-namespace

Afficher un Pod spécifique​

Pour afficher un Pod spécifique nommé nginx-pod :

kubectl get pod nginx-pod

Afficher d'autres types de ressources​

De la même manière, vous pouvez afficher d'autres types de ressources :

  • Tous les Services :

    kubectl get services

  • Tous les Déploiements :

    kubectl get deployments

Options de formatage​

La commande kubectl get offre plusieurs options pour formater la sortie, ce qui peut être très utile pour obtenir des informations spécifiques dans un format facile à lire ou à traiter par des scripts.

Option -o wide​

Pour obtenir une sortie plus détaillée, vous pouvez utiliser l'option -o wide :

kubectl get pods -o wide

Cette option ajoute des colonnes supplémentaires à la sortie, telles que l'adresse IP du Pod et le Node sur lequel il s'exécute.

Option -o yaml ou -o json​

Pour afficher les ressources au format YAML ou JSON, utilisez respectivement les options -o yaml ou -o json :

kubectl get pod nginx-pod -o yaml

kubectl get pod nginx-pod -o json

Option --selector (ou -l)​

Pour filtrer les ressources en fonction de labels, utilisez l'option --selector ou -l :

kubectl get pods -l app=nginx

Utilisation avancée​

Afficher les ressources dans tous les namespaces​

Pour afficher les ressources dans tous les namespaces, utilisez l'option --all-namespaces :

kubectl get pods --all-namespaces

Surveiller les ressources en temps réel​

Pour surveiller les ressources en temps réel, utilisez l'option -w (watch) :

kubectl get pods -w

Exemple pratique​

Supposons que vous souhaitez vérifier l'état des Pods, des Services et des Déploiements dans le namespace production. Vous pouvez exécuter les commandes suivantes :

kubectl get pods -n production
kubectl get services -n production
kubectl get deployments -n production

Pour obtenir des informations détaillées sur un Pod spécifique nommé web-app-pod, vous pouvez utiliser :

kubectl get pod web-app-pod -n production -o wide

Pour surveiller en temps réel les changements d'état des Pods dans ce namespace :

kubectl get pods -n production -w

Utilisation de la commande describe​

La commande kubectl describe est un outil puissant pour obtenir des informations détaillées sur les ressources Kubernetes. Contrairement à kubectl get, qui fournit une vue d'ensemble des ressources, kubectl describe offre une description approfondie, incluant les événements récents, les configurations et les états actuels des ressources. Cela peut être extrêmement utile pour le dépannage et la compréhension des comportements des ressources dans votre cluster.

Syntaxe de base​

La syntaxe de base de la commande kubectl describe est la suivante :

kubectl describe [RESOURCE_TYPE] [NAME] [flags]
  • RESOURCE_TYPE : Le type de ressource que vous souhaitez décrire (par exemple, pods, services, deployments).
  • NAME (optionnel) : Le nom spécifique de la ressource. Si omis, toutes les ressources du type spécifié seront décrites.
  • flags (optionnel) : Options supplémentaires pour spécifier le namespace ou d'autres paramètres.

Affichage des descriptions​

Décrire un Pod spécifique​

Pour obtenir une description détaillée d'un Pod spécifique nommé nginx-pod :

kubectl describe pod nginx-pod

Cette commande affiche des informations complètes sur le Pod, y compris ses événements, ses conteneurs, ses volumes, ses conditions et bien plus encore.

Décrire un Pod dans un namespace spécifique​

Pour décrire un Pod dans un namespace particulier, utilisez l'option -n pour spécifier le namespace :

kubectl describe pod nginx-pod -n my-namespace

Décrire d'autres types de ressources​

De la même manière, vous pouvez décrire d'autres types de ressources :

  • Décrire un Service :

    kubectl describe service my-service

  • Décrire un Déploiement :

    kubectl describe deployment my-deployment

Informations fournies par describe​

La commande kubectl describe fournit une vue détaillée des ressources. Voici les types d'informations que vous pouvez obtenir :

  • Métadonnées : Informations sur le nom, le namespace, les labels, les annotations, etc.
  • Spécifications : Détails sur la configuration de la ressource, tels que les images des conteneurs, les ports exposés, les stratégies de mise à jour, etc.
  • Statut : État actuel de la ressource, y compris les conditions, les événements récents, les états des conteneurs, etc.
  • Événements : Liste des événements récents qui ont affecté la ressource, ce qui est crucial pour le dépannage.

Exemples pratiques​

Décrire un Pod et analyser ses événements​

Pour décrire un Pod nommé web-app-pod et analyser les événements récents :

kubectl describe pod web-app-pod

Cette commande affiche des informations telles que :

  • Les conteneurs du Pod, leurs images et leurs ports.
  • Les volumes montés dans le Pod.
  • Les conditions actuelles du Pod (par exemple, prêt, en cours de démarrage).
  • Les événements récents, tels que les échecs de démarrage des conteneurs, les redémarrages, etc.

Décrire un Service et vérifier ses configurations​

Pour décrire un Service nommé my-service :

kubectl describe service my-service

Vous obtiendrez des informations sur :

  • Les ports exposés par le Service et leurs protocoles.
  • Les sélecteurs utilisés pour associer les Pods au Service.
  • Les adresses IP assignées au Service (ClusterIP, ExternalIPs, etc.).

Décrire un Déploiement et examiner ses stratégies​

Pour décrire un Déploiement nommé nginx-deployment :

kubectl describe deployment nginx-deployment

Cette commande fournit des détails sur :

  • Le nombre de réplicas souhaitées et disponibles.
  • La stratégie de mise à jour (par exemple, RollingUpdate).
  • Les conditions du déploiement, telles que Available et Progressing.
  • Les événements récents liés aux mises à jour et aux déploiements.

Utilisation avancée​

Décrire des ressources dans tous les namespaces​

Pour décrire une ressource dans tous les namespaces, vous devez spécifier le namespace dans la commande. Il n'y a pas de support direct pour --all-namespaces dans describe comme pour get, mais vous pouvez exécuter la commande pour chaque namespace manuellement.

Utilisation avec des sélecteurs​

Pour décrire des ressources en utilisant des sélecteurs, vous pouvez combiner la commande get avec describe. Par exemple, pour décrire tous les Pods avec le label app=nginx :

kubectl describe pod -l app=nginx

La commande kubectl describe est un outil essentiel pour obtenir des informations détaillées et diagnostiques sur les ressources Kubernetes. Elle permet de comprendre en profondeur le comportement des ressources, d'identifier les problèmes et de les résoudre efficacement. En maîtrisant cette commande, vous pourrez gérer et dépanner vos clusters Kubernetes de manière plus proactive et informée.

Surveiller vos applications avec logs​

La commande kubectl logs est un outil essentiel pour surveiller et déboguer les applications exécutées dans un cluster Kubernetes. Elle permet d'afficher les journaux des conteneurs, offrant ainsi une visibilité sur le fonctionnement interne de vos applications. Cette commande est particulièrement utile pour diagnostiquer les problèmes et comprendre le comportement des applications.

Syntaxe de base​

La syntaxe de base de la commande kubectl logs est la suivante :

kubectl logs [POD_NAME] [-c CONTAINER_NAME] [flags]
  • POD_NAME : Le nom du Pod dont vous souhaitez afficher les journaux.
  • -c CONTAINER_NAME (optionnel) : Le nom du conteneur spécifique dans le Pod (si le Pod en contient plusieurs).
  • flags (optionnel) : Options supplémentaires pour filtrer ou formater la sortie.

Affichage des journaux​

Afficher les journaux d'un Pod​

Pour afficher les journaux d'un Pod nommé nginx-pod :

kubectl logs nginx-pod

Afficher les journaux d'un conteneur spécifique​

Si le Pod contient plusieurs conteneurs, spécifiez le conteneur avec l'option -c :

kubectl logs nginx-pod -c nginx-container

Options de filtrage et de formatage​

La commande kubectl logs offre plusieurs options pour filtrer et formater la sortie des journaux, ce qui peut être très utile pour trouver des informations spécifiques ou pour une meilleure lisibilité.

Afficher les journaux en temps réel​

Pour afficher les journaux en temps réel (similaire à la commande tail -f en Unix) :

kubectl logs -f nginx-pod

Afficher les journaux des Pods précédents​

Si un Pod a été redémarré, vous pouvez afficher les journaux de l'instance précédente avec l'option --previous :

kubectl logs nginx-pod --previous

Limiter le nombre de lignes de journaux​

Pour limiter le nombre de lignes affichées à partir des journaux (par exemple, les 10 dernières lignes) :

kubectl logs nginx-pod --tail=10

Afficher les journaux depuis une période spécifique​

Pour afficher les journaux générés au cours des 5 dernières minutes, utilisez l'option --since :

kubectl logs nginx-pod --since=5m

Utilisation avancée​

Afficher les journaux de plusieurs Pods​

Pour afficher les journaux de tous les Pods d'un déploiement ou d'un service, utilisez un script pour automatiser l'affichage des journaux de chaque Pod. Par exemple, pour un déploiement nommé nginx-deployment :

kubectl get pods -l app=nginx-deployment -o name | xargs -I {} kubectl logs {}

Utiliser avec des sélecteurs​

Pour afficher les journaux des Pods qui correspondent à un sélecteur de label spécifique :

kubectl logs -l app=nginx

Bonnes pratiques​

Utiliser kubectl logs fait partie des bonnes pratiques pour la surveillance et le débogage des applications Kubernetes. Voici quelques conseils pour en tirer le meilleur parti :

  • Surveillance proactive : Utilisez kubectl logs -f pour surveiller en temps réel les journaux des applications critiques et détecter rapidement les problèmes.
  • Automatisation : Intégrez des scripts utilisant kubectl logs dans vos processus CI/CD pour collecter automatiquement les journaux en cas d'échec des déploiements.
  • Centralisation des journaux : Bien que kubectl logs soit utile pour un accès rapide, envisagez de centraliser les journaux avec des outils comme Elasticsearch, Fluentd et Kibana (EFK) pour une surveillance à long terme et une analyse approfondie.
  • Filtrage et formatage : Utilisez les options de filtrage et de formatage pour extraire rapidement les informations pertinentes des journaux volumineux.

Surveiller vos ressources avec top​

La commande kubectl top est un outil puissant pour surveiller les ressources utilisées par les composants du cluster Kubernetes. Elle fournit des informations en temps réel sur l'utilisation des ressources CPU et mémoire par les nœuds et les pods, ce qui est essentiel pour la gestion de la performance et la détection des goulets d'étranglement.

Pré-requis​

Pour que kubectl top fonctionne correctement, le cluster Kubernetes doit avoir installé et configuré le Metrics Server. Le Metrics Server collecte les métriques d'utilisation des ressources de chaque nœud et pod dans le cluster.

Installer Metrics Server​

Si Metrics Server n'est pas encore installé, vous pouvez l'installer en suivant ces étapes :

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Après l'installation, vous pouvez vérifier que Metrics Server fonctionne correctement :

kubectl get apiservices | grep -i metrics

Syntaxe de base​

La syntaxe de base de la commande kubectl top est la suivante :

kubectl top [resource] [name] [flags]
  • resource : Le type de ressource que vous souhaitez surveiller (par exemple, nodes, pods).
  • name (optionnel) : Le nom spécifique de la ressource. Si omis, toutes les ressources du type spécifié seront listées.
  • flags (optionnel) : Options supplémentaires pour filtrer ou formater la sortie.

Affichage des ressources​

Afficher l'utilisation des ressources par les nœuds​

Pour afficher l'utilisation des ressources CPU et mémoire par tous les nœuds du cluster :

kubectl top nodes

Cette commande liste tous les nœuds et affiche l'utilisation actuelle du CPU et de la mémoire pour chacun d'eux.

Afficher l'utilisation des ressources par un nœud spécifique​

Pour afficher les détails de l'utilisation des ressources d'un nœud spécifique nommé node-1 :

kubectl top node node-1

Afficher l'utilisation des ressources par les pods​

Pour afficher l'utilisation des ressources CPU et mémoire par tous les pods dans le namespace par défaut :

kubectl top pods

Pour afficher les pods dans un namespace spécifique, utilisez l'option -n :

kubectl top pods -n my-namespace

Afficher l'utilisation des ressources par un pod spécifique​

Pour afficher les détails de l'utilisation des ressources d'un pod spécifique nommé nginx-pod :

kubectl top pod nginx-pod

Utilisation avancée​

Surveiller les ressources dans tous les namespaces​

Pour afficher l'utilisation des ressources par les pods dans tous les namespaces :

kubectl top pods --all-namespaces

Filtrer les résultats par labels​

Pour filtrer les pods par labels, utilisez l'option -l (ou --selector) :

kubectl top pods -l app=nginx

Bonnes pratiques​

L'utilisation de kubectl top s'inscrit dans les bonnes pratiques de gestion et de surveillance des ressources dans Kubernetes. Voici quelques recommandations :

  • Surveillance proactive : Utilisez kubectl top régulièrement pour surveiller l'utilisation des ressources et détecter les anomalies ou les augmentations soudaines de la consommation de CPU ou de mémoire.
  • Automatisation : Intégrez kubectl top dans des scripts de surveillance automatisés pour collecter régulièrement les données de performance et générer des alertes en cas de dépassement des seuils définis.
  • Optimisation des ressources : Analysez les données de kubectl top pour identifier les ressources sous-utilisées ou sur-utilisées et ajuster les allocations de ressources en conséquence.
  • Capacité de planification : Utilisez les données collectées pour planifier la capacité et prendre des décisions éclairées sur l'ajout ou la suppression de nœuds dans le cluster.

Conclusion​

Maîtriser la CLI kubectl est essentiel pour tout administrateur de clusters Kubernetes. En tant qu'outil principal pour interagir avec les clusters, kubectl offre une gamme complète de fonctionnalités qui permettent de gérer, déboguer et surveiller efficacement les ressources Kubernetes.

Pour l'administration, kubectl permet de créer, modifier et supprimer des ressources de manière déclarative et impérative. La capacité de comprendre et d'utiliser les commandes comme apply, create, get et delete est cruciale pour maintenir un environnement Kubernetes sain et performant. De plus, la gestion des configurations à l'aide de fichiers YAML et de contextes multiples permet une administration plus organisée et sécurisée.

Lorsqu'il s'agit de déboguer des problèmes dans le cluster, kubectl est un outil indispensable. Les commandes comme describe et logs fournissent des informations détaillées sur l'état des ressources et les journaux des conteneurs, permettant d'identifier rapidement les problèmes. La commande explain aide à comprendre les structures des ressources, ce qui est utile pour diagnostiquer les erreurs de configuration.

Pour la surveillance, kubectl offre des commandes comme get et top qui fournissent des instantanés de l'état des ressources et des métriques de performance. Ces outils sont essentiels pour surveiller la santé des pods, des services et des autres ressources et pour prendre des mesures proactives en cas de dégradation des performances ou d'autres anomalies.

Il est important de noter que kubectl propose de nombreuses autres commandes qui ne sont pas décrites dans ce guide. Ces commandes, bien que non couvertes ici, jouent un rôle crucial dans l'administration, le débogage et la surveillance des clusters Kubernetes.

Pour une compréhension plus approfondie et une maîtrise complète de l'administration des clusters Kubernetes, je vous invite à consulter mon prochain guide détaillé sur l'administration des clusters Kubernetes. Ce guide couvrira l'utilisation avancée de kubectl, des scénarios de gestion des ressources, des pratiques de sécurité et bien d'autres aspects essentiels pour gérer efficacement vos clusters Kubernetes.

En somme, la maîtrise de kubectl est non seulement nécessaire, mais aussi bénéfique pour administrer, déboguer et surveiller efficacement les clusters Kubernetes. En utilisant pleinement les capacités de cette CLI, vous pouvez gérer vos environnements Kubernetes avec plus de confiance et d'efficacité, assurant ainsi une infrastructure robuste et résiliente.

Je vous encourage vivement à continuer à explorer et à pratiquer avec kubectl, car cette compétence est essentielle pour tout professionnel travaillant avec Kubernetes. Les chapitres précédents de ce guide vous fourniront une base solide pour démarrer et approfondir votre expertise dans l'administration de clusters Kubernetes.