Hub de Connaissances DevOps
Hub de Connaissances DevOps

Techniques avancées de `kubectl get` : filtrage de la sortie avec des labels et JSONPath

Libérez tout le potentiel de `kubectl get` en maîtrisant les techniques de filtrage avancées. Ce guide complet explique comment utiliser les sélecteurs de labels Kubernetes pour un ciblage précis des ressources, vous permettant d'interroger des Pods, des Deployments et des Services spécifiques. De plus, apprenez à créer des modèles JSONPath personnalisés pour extraire et formater exactement les données dont vous avez besoin dans un format lisible par machine. Avec des exemples pratiques et des meilleures pratiques, améliorez votre gestion de cluster, votre débogage et vos flux de travail d'automatisation en récupérant efficacement des informations précises et personnalisées de votre environnement Kubernetes.

37 vues

Techniques avancées de kubectl get : Filtrer la sortie avec les étiquettes (Labels) et JSONPath

kubectl get est l'une des commandes les plus fondamentales et fréquemment utilisées pour interagir avec les clusters Kubernetes. Elle permet aux utilisateurs de récupérer des informations sur diverses ressources, des Pods et Deployments aux Services et ConfigMaps. Bien que les commandes kubectl get de base soient suffisantes pour un aperçu rapide, les environnements Kubernetes réels impliquent souvent une multitude de ressources, ce qui rend difficile la localisation efficace d'informations spécifiques.

Cet article explore en profondeur les techniques avancées de kubectl get, vous permettant de filtrer et de formater précisément la sortie. Nous verrons comment tirer parti des puissants sélecteurs d'étiquettes (label selectors) de Kubernetes pour cibler des ressources spécifiques, puis maîtriser les modèles JSONPath pour extraire et présenter exactement les données dont vous avez besoin dans un format personnalisé et lisible par les machines. À la fin de ce guide, vous serez en mesure d'interroger votre cluster avec une précision inégalée, améliorant considérablement vos capacités de diagnostic, d'automatisation et de reporting.

Comprendre les étiquettes Kubernetes : La base de la sélection de ressources

Avant de plonger dans le filtrage avancé, il est crucial de comprendre les étiquettes Kubernetes. Les étiquettes sont des paires clé-valeur attachées aux objets Kubernetes (tels que les Pods, les Services, les Deployments, etc.) qui sont utilisées pour identifier et organiser les ressources. Ce sont des métadonnées que les clients et les utilisateurs peuvent utiliser pour sélectionner des sous-ensembles d'objets.

Les étiquettes sont distinctes des annotations ; les étiquettes sont destinées à identifier des caractéristiques significatives et pertinentes pour que les utilisateurs puissent interroger et sélectionner des objets, tandis que les annotations sont destinées aux métadonnées non identifiantes. De bonnes pratiques d'étiquetage sont essentielles pour une gestion efficace des ressources et les opérations avancées de kubectl get.

Pour voir les étiquettes actuellement affectées à vos ressources, vous pouvez utiliser l'indicateur --show-labels :

kubectl get pods --show-labels

Ceci ajoutera une colonne LABELS à votre sortie, montrant toutes les étiquettes associées à chaque Pod.

Sélecteurs d'étiquettes avancés avec kubectl get -l

L'indicateur -l ou --selector est votre outil principal pour filtrer la sortie de kubectl get basée sur les étiquettes. Il vous permet de spécifier un ensemble d'exigences d'étiquettes que les ressources doivent satisfaire pour être incluses dans la sortie. Les sélecteurs peuvent être de simples paires clé-valeur ou des expressions basées sur des ensembles plus complexes.

Sélection d'étiquettes de base

Correspondance exacte

Pour sélectionner les ressources qui possèdent une étiquette spécifique avec une valeur exacte, utilisez la syntaxe cle=valeur.

# Obtenir tous les pods avec l'étiquette 'app' définie sur 'nginx'
kubectl get pods -l app=nginx

# Obtenir tous les services dans l'espace de noms 'default' avec l'étiquette 'tier' définie sur 'frontend'
kubectl get services -n default -l tier=frontend

Correspondance par inégalité

Pour sélectionner les ressources dont une étiquette spécifique n'est pas définie sur une valeur particulière, utilisez la syntaxe cle!=valeur.

# Obtenir tous les pods où l'étiquette 'app' n'est pas 'nginx'
kubectl get pods -l app!=nginx

Existence (Clé seule)

Pour sélectionner les ressources qui possèdent simplement une étiquette particulière, quelle que soit sa valeur, spécifiez simplement la cle.

# Obtenir tous les pods qui ont l'étiquette 'environment', quelle que soit sa valeur
kubectl get pods -l environment

Non-existence (Clé seule)

Pour sélectionner les ressources qui n'ont pas d'étiquette particulière, préfixez la cle par !.

# Obtenir tous les pods qui N'ONT PAS l'étiquette 'component'
kubectl get pods -l !component

Combinaison de plusieurs sélecteurs d'étiquettes (Logique ET)

Vous pouvez combiner plusieurs sélecteurs d'étiquettes en les séparant par une virgule. Cela implique une relation ET (AND), ce qui signifie qu'une ressource doit satisfaire toutes les conditions d'étiquetage spécifiées pour être incluse.

# Obtenir les pods avec 'app=nginx' ET 'env=production'
kubectl get pods -l app=nginx,env=production

# Obtenir les déploiements avec 'tier=backend' ET qui N'ONT PAS l'étiquette 'version'
kubectl get deployments -l tier=backend,!version

Sélecteurs d'étiquettes basés sur des ensembles

Kubernetes prend également en charge des sélecteurs d'étiquettes basés sur des ensembles plus puissants, particulièrement utiles lorsque vous traitez plusieurs valeurs possibles pour une seule étiquette.

cle in (valeur1, valeur2, ...)

Pour sélectionner les ressources dont la valeur d'une étiquette fait partie d'une liste spécifiée de valeurs.

# Obtenir les pods où l'étiquette 'app' est soit 'nginx' SOIT 'redis'
kubectl get pods -l 'app in (nginx,redis)'

# Obtenir les services dans l'espace de noms 'kube-system' où l'étiquette 'k8s-app' est 'kube-dns' OU 'kubernetes-dashboard'
kubectl get services -n kube-system -l 'k8s-app in (kube-dns,kubernetes-dashboard)'

cle notin (valeur1, valeur2, ...)

Pour sélectionner les ressources dont la valeur d'une étiquette n'est aucune d'une liste spécifiée de valeurs.

# Obtenir les pods où l'étiquette 'env' n'est NI 'dev' NI 'test'
kubectl get pods -l 'env notin (dev,test)'

Astuce : Lorsque vous utilisez des sélecteurs basés sur des ensembles ou des sélecteurs contenant des caractères spéciaux, entourez toujours l'expression de sélection complète d'apostrophes ('...') pour éviter les problèmes d'interprétation du shell.

Meilleures pratiques pour l'étiquetage

  • Cohérence : Établissez un schéma d'étiquetage clair et respectez-le dans l'ensemble de votre cluster. Cela rend le filtrage prévisible et fiable.
  • Noms significatifs : Utilisez des étiquettes qui décrivent clairement les caractéristiques de la ressource (par exemple, app, tier, environment, version).
  • Granularité : Les étiquettes doivent être suffisamment spécifiques pour permettre une sélection précise, mais pas si granulaires qu'elles deviennent ingérables.
  • Immuabilité : Évitez d'utiliser des étiquettes pour des données qui changent fréquemment. Les étiquettes conviennent mieux aux propriétés d'identification statiques.
  • Étiquettes courantes : Utilisez des étiquettes largement adoptées comme app.kubernetes.io/name, app.kubernetes.io/instance, app.kubernetes.io/version, etc., pour une meilleure interopérabilité avec les outils.

Extraction de données personnalisées avec JSONPath

Alors que les sélecteurs d'étiquettes vous aident à identifier quelles ressources vous voulez, JSONPath vous aide à définir quelles informations vous voulez extraire de ces ressources et comment elles doivent être formatées. kubectl get permet de sortir les détails des ressources dans divers formats (par exemple, yaml, json, wide), mais -o jsonpath (ou -o jsonpath-file) offre le contrôle ultime.

La prise en charge de JSONPath par kubectl est alimentée par les modèles Go, qui peuvent interpréter les expressions JSONPath pour naviguer dans la structure JSON d'un objet Kubernetes. Cela permet un puissant templating et une extraction de données.

Pour utiliser JSONPath, spécifiez le format de sortie avec -o jsonpath='<modèle>'.

Bases de JSONPath et cas d'utilisation courants

Premièrement, il est souvent utile de visualiser la sortie JSON complète d'une ressource pour comprendre sa structure avant d'écrire une expression JSONPath :

# Obtenir la structure JSON complète d'un pod
kubectl get pod <nom-du-pod> -o json

Cela vous donnera une carte claire pour construire vos requêtes JSONPath.

Accès à un champ unique

Utilisez {.champ.sous_champ} pour accéder à des valeurs spécifiques. Par exemple, pour obtenir le nom d'un Pod :

# Obtenir le nom d'un pod spécifique
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.metadata.name}'

# Obtenir le nom du nœud où un pod est en cours d'exécution
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.spec.nodeName}'

Accès aux éléments d'un tableau

Pour accéder aux éléments au sein d'un tableau, vous pouvez utiliser [*] pour itérer sur tous les éléments ou [index] pour un élément spécifique.

# Obtenir les noms de tous les conteneurs dans un pod spécifique
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.spec.containers[*].name}'

# Obtenir l'image du premier conteneur dans un pod spécifique
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.spec.containers[0].image}'

Itération sur une liste de ressources (en utilisant range)

Lorsque kubectl get renvoie plusieurs ressources (par exemple, tous les pods), la sortie est généralement un objet contenant un tableau items. Vous devrez utiliser la fonction range du modèle Go pour itérer dessus.

# Lister tous les noms de pods et leurs IP, chacun sur une nouvelle ligne
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.podIP}{"\n"}{end}'

# Lister tous les noms de déploiements et le nombre de réplicas prêts
kubectl get deployments -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.readyReplicas}{"\n"}{end}'
  • {range .items[*]} : Démarre une itération sur chaque élément du tableau .items.
  • {.metadata.name} : À l'intérieur de la boucle, . fait référence à l'élément courant (par exemple, un objet Pod unique).
  • {" "} : Insère un caractère de tabulation pour le formatage.
  • {" "} : Insère un caractère de nouvelle ligne.
  • {end} : Ferme la boucle range.

Sortie conditionnelle (en utilisant if)

Vous pouvez utiliser des instructions if des modèles Go pour le rendu conditionnel.

# Lister les noms des pods, et si un pod a un 'nodeName', l'imprimer, sinon imprimer 'N/A'
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.nodeName}{end}{"\n"}'

# Un exemple plus complexe avec 'if' et 'else' pour l'IP du pod (si elle existe)
kubectl get pods -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.podIP}{"\n"}{end}'

# Plus précisément, pour le 'if-else' du modèle Go avec des vérifications nulles :
kubectl get pods -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{with .status.podIP}{.}{else}N/A{end}{"\n"}{end}'
  • {with .status.podIP}{.}{else}N/A{end} : Cette construction de modèle Go vérifie si .status.podIP existe. Si c'est le cas, . fait référence à sa valeur ; sinon, elle imprime N/A.

Formatage personnalisé et en-tête

Vous pouvez ajouter votre propre texte statique et créer un en-tête pour votre sortie de type tableau.

# Sortie personnalisée pour les noms de pods, les images et le nœud, avec un en-tête
kubectl get pods -o=jsonpath='{"NAME\tIMAGE\tNODE\n"}{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\t"}{.spec.nodeName}{"\n"}{end}'

Avertissement : L'implémentation JSONPath de kubectl est basée sur les modèles Go, qui sont puissants mais possèdent leur propre syntaxe. Ce n'est pas une implémentation JSONPath générique complète comme jq. Si vous avez besoin d'un filtrage ou d'une manipulation extrêmement complexes au-delà du chemin de base et de range/if, envisagez de rediriger kubectl get -o json vers jq.

Conseils pour JSONPath

  • Commencez simple : Commencez par un chemin de base, puis ajoutez de la complexité.
  • Inspecter le JSON : Utilisez toujours kubectl get <ressource> <nom> -o json pour comprendre la structure exacte que vous interrogez.
  • Caractères d'échappement : N'oubliez pas d'échapper les caractères spéciaux comme les nouvelles lignes (\n) et les tabulations (\t) dans votre chaîne de modèle JSONPath si vous souhaitez qu'ils soient rendus comme des littéraux dans la sortie.
  • Enregistrer les modèles : Pour les expressions JSONPath complexes ou fréquemment utilisées, enregistrez-les dans un fichier et utilisez -o jsonpath-file=/chemin/vers/template.jsonpath.

Combinaison des étiquettes et de JSONPath

La vraie puissance réside dans la combinaison de ces techniques. Tout d'abord, utilisez les sélecteurs d'étiquettes pour réduire l'ensemble des ressources, puis appliquez JSONPath pour extraire et formater des données spécifiques de cet ensemble filtré.

# Obtenir les noms et les images de conteneur de tous les pods avec 'app=my-app' et 'env=production'
kubectl get pods -l 'app=my-app,env=production' -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\n"}{end}'

# Obtenir les noms et les adresses IP de cluster de tous les services qui ont l'étiquette 'tier' définie sur 'backend'
kubectl get services -l tier=backend -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.clusterIP}{"\n"}{end}'

# Trouver tous les pods s'exécutant sur un nœud spécifique 'worker-node-1' et lister leurs noms et statuts
kubectl get pods --field-selector spec.nodeName=worker-node-1 -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.phase}{"\n"}{end}'

Note : Bien que les sélecteurs d'étiquettes (-l) soient destinés aux paires clé-valeur arbitraires, kubectl offre également --field-selector pour filtrer en fonction des champs de ressources (par exemple, status.phase=Running, metadata.namespace=default). Cela fournit une autre couche puissante de filtrage qui peut être combinée avec les étiquettes et JSONPath.

Dépannage et pièges courants

  • Erreurs de syntaxe JSONPath : Même une petite faute de frappe peut casser le modèle. Vérifiez attentivement les accolades, les points et l'accès aux tableaux.
  • Champs manquants : Si un champ n'existe pas pour une ressource particulière, JSONPath peut renvoyer <no value> ou une chaîne vide. Utilisez les constructions de modèle Go if ou with pour gérer ces cas avec élégance.
  • Échappement du shell : Les apostrophes entourant l'expression JSONPath sont cruciales. Si votre expression contient des guillemets internes ou des caractères spéciaux, vous pourriez avoir besoin d'un échappement de shell supplémentaire.
  • Modèle Go contre JSONPath pur : Rappelez-vous que kubectl utilise des modèles Go, et non un moteur JSONPath universel. Les fonctionnalités comme le filtrage avancé (?()) font généralement partie de jq ou d'autres processeurs JSON dédiés, et ne sont pas directement prises en charge dans -o jsonpath de kubectl.
  • Tableau items vide : Si votre sélecteur d'étiquettes ne correspond à aucune ressource, items sera vide et votre boucle range ne produira aucun résultat.

Conclusion

La maîtrise des techniques avancées de kubectl get avec les sélecteurs d'étiquettes et JSONPath est une compétence inestimable pour tout utilisateur de Kubernetes. Ces puissantes options de filtrage et de formatage transforment kubectl get d'un simple outil de listage en un utilitaire sophistiqué d'extraction de données. Vous pouvez rapidement identifier les ressources problématiques, générer des rapports personnalisés ou injecter des données précises dans des scripts d'automatisation.

En appliquant constamment de bonnes pratiques d'étiquetage et en devenant compétent dans la création d'expressions JSONPath, vous obtiendrez un contrôle inégalé sur les informations de votre cluster Kubernetes, menant à une gestion plus efficace, à un débogage plus rapide et à une automatisation plus robuste. Continuez à expérimenter avec différents sélecteurs et modèles JSONPath, et vous débloquerez tout le potentiel de kubectl get.