Fonction bash pour trier la sortie Docker ps

Le tri de la sortie de docker ps peut être utile lorsque vous gérez plusieurs conteneurs et que vous avez besoin d’une vue plus claire de ce qui s’exécute. Dans ce tutoriel, nous allons voir comment créer une fonction Bash qui organise cette sortie de manière plus lisible à l’aide d’outils shell intégrés tels que awk et sort. Cela s’appuie sur les commandes de base de Docker telles que docker ps, docker images et docker inspect pour créer des outils de gestion de conteneurs plus puissants.

• Comment l’intégrer dans votre environnement shell
• Comment tester et utiliser la fonction en pratique

Configuration logicielle requise et conventions de ligne de commande Linux

Fonctions bash pour trier la sortie Docker PS

Instructions étape par étape

Rôle de ces fonctions

Ces fonctions bash résolvent les problèmes courants de gestion des conteneurs Docker :

• docker_ps_sort : trie par ordre alphabétique vos conteneurs en cours d’exécution par nom tout en conservant le format de table. Cela vous permet de localiser rapidement des conteneurs spécifiques dans des environnements comportant de nombreux services.
• docker_ps_sort_image – Trie les conteneurs par nom d’image, ce qui facilite l’identification de tous les conteneurs exécutant la même version d’image. Ceci est particulièrement utile pour le contrôle de version et la planification des mises à jour.

Vous trouverez ci-dessous les étapes à suivre pour créer, appliquer et tester des fonctions Bash améliorées pour trier la sortie docker ps tout en conservant un formatage de table correct.

1. Création de la fonction BashOuvrez votre fichier de profil shell (par exemple, ~/.bashrc ou ~/.bash_aliases) et ajoutez la fonction améliorée suivante :

   function docker_ps_sort() {
       docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Image}}" | 
       (read -r header && echo "$header" && sort)
   }

Cette fonction conserve la ligne d’en-tête en haut tout en triant les entrées de conteneur en dessous, ce qui vous donne une sortie correctement formatée.

2. Appliquer les modificationsRechargez la configuration de votre shell pour appliquer la nouvelle fonction :

   source ~/.bashrc

Vous pouvez également exécuter la définition de fonction directement dans votre session shell actuelle pour un test immédiat.

3. Exécuter la fonctionExécutez la fonction pour voir la sortie du conteneur Docker triée avec le formatage approprié :

   docker_ps_sort

   Vous verrez une sortie comme ceci, avec l’en-tête correctement positionné :

   

   Avantages de cette fonction : Le tri alphabétique des noms de conteneurs facilite grandement les opérations suivantes :

   • Localisez rapidement un conteneur spécifique par son nom dans les environnements comportant de nombreux conteneurs
   • Identifier les conteneurs qui appartiennent à la même application ou au même service (généralement nommés avec des préfixes similaires)
   • Analysez la liste plus efficacement car elle est dans un ordre prévisible
   • Maintenir une sortie cohérente dans les scripts ou les outils de surveillance

4. Personnaliser le triSi vous souhaitez trier en fonction d’un autre champ, tel que le nom de l’image, créez une autre fonction avec une chaîne de format modifiée :

   function docker_ps_sort_image() {
       docker ps --format "table {{.Image}}\t{{.Names}}\t{{.Status}}" | 
       (read -r header && echo "$header" && sort)
   }

   Cette fonction produira une sortie triée par nom d’image :

   

   Pourquoi c’est utile : Le tri par nom d’image vous permet d’identifier rapidement les conteneurs qui exécutent les mêmes images. Cela peut s’avérer inestimable lorsque :

• Planification de mises à jour d’images ou de correctifs de sécurité
• Identification des conteneurs exécutant des versions d’image obsolètes
• Regroupement des services associés qui utilisent les mêmes images de base
• Audit de votre environnement pour la standardisation des images

5. Personnalisation avancéeVous pouvez personnaliser davantage le tri à l’aide de commandes supplémentaires :

   • Trier par colonne spécifique : Utilisez sort -k2 pour trier par la deuxième colonne
   • Inversez l’ordre : Ajouter l’indicateur -r (trier -r)
   • Filtrer les résultats : Ajouter grep pour n’afficher que des conteneurs spécifiques

   function docker_ps_uptime() {
       # Sort containers by uptime (newest first)
       docker ps --format "table {{.Names}}\t{{.RunningFor}}\t{{.Status}}" | 
       (read -r header && echo "$header" && sort -k2 -r)
   }

   Rôle de cette fonction : La fonction docker_ps_uptime trie les conteneurs en fonction de leur durée d’exécution, en affichant les conteneurs les plus récents en haut. Cela est particulièrement utile lors du dépannage des conteneurs récemment déployés ou lorsque vous devez identifier les conteneurs susceptibles d’avoir redémarré de manière inattendue.

6. Rendez-le permanentAssurez-vous que les fonctions sont chargées à chaque session en les conservant dans votre fichier de configuration shell. Vous pouvez créer un fichier dédié aux fonctions Docker :

   In ~/.bashrc or ~/.zshrc
   if [ -f ~/.docker_functions ]; then
       source ~/.docker_functions
   fi

Placez ensuite toutes vos fonctions Docker dans ~/.docker_functions pour une meilleure organisation.

Comprendre les composants clés

• Le format de la table : Le --format "table {{. Noms}}\t{{. État}}\t{{. Image}}" crée un tableau formaté avec les colonnes spécifiées.

• La préservation de l’en-tête : La partie (lire -r en-tête & & echo « $header » & tri) :

  • Crée une sous-couche avec des parenthèses
  • Lit la première ligne (en-tête) dans une variable
  • Affiche cet en-tête en premier
  • Trie ensuite les lignes restantes

• Options de format disponibles : vous pouvez utiliser l’un de ces espaces réservés dans votre chaîne de format :

  • {{.ID}} – ID de conteneur
  • {{. Names}} – Nom du conteneur
  • {{. Image}} – Nom de l’image
  • {{. Status}} – État du conteneur
  • {{. RunningFor}} – Temps écoulé depuis le démarrage du conteneur
  • {{. Ports}} – Ports exposés
  • {{. Commande}} – Commande en cours d’exécution
  • {{. Size}} – Taille du conteneur

Fonctions de tri bash de commande docker ps plus avancées

1. Trier les conteneurs en fonction de l’utilisation de la mémoire : recherchez les conteneurs qui consomment le plus de mémoire

   docker_sort_by_mem() {
       docker stats --no-stream --format "{{.Name}}\t{{.MemPerc}}\t{{.ID}}" | \
       sort -k2 -nr | \
       awk 'BEGIN {print "CONTAINER NAME\tMEMORY USAGE\tCONTAINER ID"} {print $0}'
   }

Cette fonction extrait les statistiques d’utilisation de la mémoire de tous les conteneurs en cours d’exécution et les trie par ordre décroissant. La sortie affiche les noms de conteneurs, les pourcentages d’utilisation de la mémoire et les ID de conteneur, ce qui vous permet d’identifier rapidement les conteneurs gourmands en mémoire. Ceci est particulièrement utile pour l’optimisation des ressources dans les environnements de production.

2. Répertorier les conteneurs par temps de fonctionnement (les plus anciens en premier) : affichez les conteneurs triés en fonction de leur durée d’exécution.

   docker_sort_by_age() {
       docker ps --format "{{.CreatedAt}}\t{{.Names}}\t{{.RunningFor}}\t{{.Status}}" | \
       sort -k1 | \
       awk -F'\t' '{print $2 "\t" $3 "\t" $4}' | \
       column -t -s $'\t'
   }

   Cette fonction répertorie les conteneurs par temps de disponibilité, en affichant d’abord les conteneurs en cours d’exécution les plus anciens. La sortie est formatée en colonnes pour plus de lisibilité. Ceci est utile pour identifier les conteneurs de longue durée qui peuvent nécessiter des mises à jour ou une rotation dans le cadre des procédures de maintenance.

   

3. Grouper les conteneurs par image : découvrez quelles images contiennent le plus de conteneurs en cours d’exécution

   docker_group_by_image() {
       docker ps --format "{{.Image}}" | \
       sort | \
       uniq -c | \
       sort -nr | \
       awk '{printf("%s containers using image %s\n", $1, $2)}'
   }

Cette fonction regroupe et compte les conteneurs en cours d’exécution en fonction de leur image de base, en affichant les résultats dans l’ordre décroissant. Cela vous donne un aperçu rapide des images les plus déployées dans votre environnement, ce qui est utile pour les audits de sécurité ou la planification des mises à jour.

4. Rechercher des conteneurs avec des conflits de ports : Identifiez les conteneurs dont les mappages de port peuvent se chevaucher

   docker_find_port_conflicts() {
       docker ps --format "{{.Names}}\t{{.Ports}}" | \
       grep -v "0.0.0.0" | \
       awk -F'->' '{print $1}' | \
       awk '{print $1 "\t" $NF}' | \
       sort -k2 | \
       awk '{
           port=$2;
           if(port==prev) {
               print "CONFLICT: " prev_name " and " $1 " both use " port;
           }
           prev=port;
           prev_name=$1;
       }'
   }

Cette fonction complexe analyse les mappages de ports de tous les conteneurs afin d’identifier les conflits potentiels lorsque plusieurs conteneurs peuvent essayer d’utiliser le même port hôte. Il analyse la sortie, extrait les informations de port et signale les conteneurs avec des affectations de port correspondantes, ce qui permet d’éviter les comportements inattendus dans les applications en réseau.

5. Surveiller les conteneurs avec des pics de processeur élevés : suivre les conteneurs dépassant un seuil de processeur défini

   docker_monitor_cpu_spikes() {
       threshold=${1:-50}  # Default threshold of 50%
       
       watch -n 5 "docker stats --no-stream --format \"{{.Name}}\t{{.CPUPerc}}\t{{.MemPerc}}\" | \
       awk -v threshold=\"$threshold\" '\
       BEGIN {printf \"%-30s %-15s %-15s %-10s\\n\", \"CONTAINER\", \"CPU %\", \"MEM %\", \"STATUS\"}\
       {
           cpu=\$2; 
           sub(/%/, \"\", cpu); 
           if (cpu > threshold) {
               printf \"%-30s %-15s %-15s %-10s\\n\", \$1, \$2, \$3, \"WARNING\";
           } else {
               printf \"%-30s %-15s %-15s %-10s\\n\", \$1, \$2, \$3, \"OK\";
           }
       }'"
   }

Cette fonction de surveillance vérifie en permanence les conteneurs qui dépassent un seuil d’utilisation du processeur spécifié (par défaut à 50 % si non spécifié). Il s’actualise toutes les 5 secondes et met en évidence les conteneurs à forte consommation de processeur, ce qui facilite l’identification des problèmes de performances en temps réel lors de scénarios de débogage ou de test de charge.

6. Analyser la mise en réseau des conteneurs : trier les conteneurs en fonction du volume de trafic réseau

   docker_sort_by_network() {
       docker stats --no-stream --format "{{.Name}}\t{{.NetIO}}" | \
       awk '{
           split($2, io, "/");
           # Extract numeric values and convert to bytes
           gsub(/[^0-9.]/, "", io[1]);
           if($2 ~ /kB/) io[1] *= 1024;
           if($2 ~ /MB/) io[1] *= 1024 * 1024;
           if($2 ~ /GB/) io[1] *= 1024 * 1024 * 1024;
           # Print with the calculated byte values for sorting
           printf "%s\t%s\t%.0f\n", $1, $2, io[1];
       }' | \
       sort -k3 -nr | \
       head -10 | \
       awk '{printf("%-30s %s\n", $1, $2)}'
   }

Cette fonction sophistiquée analyse les E/S réseau de tous les conteneurs, convertit les différentes unités (Ko, Mo, Go) en une échelle commune, trie en fonction du trafic réseau le plus élevé et affiche les 10 conteneurs les plus consommateurs de bande passante. Ceci est inestimable pour identifier les conteneurs qui peuvent rencontrer des goulots d’étranglement réseau ou des modèles de trafic anormaux.

7. Tableau de bord de l’état de santé : créez une vue d’ensemble colorée de l’état de santé du conteneur

   docker_health_dashboard() {
       docker ps --format "{{.Names}}\t{{.Status}}" | \
       awk '{
           container_name = $1;
           # Remove the first field and preserve the rest as status
           $1 = "";
           status = $0;
           
           printf "%s\t", container_name;
           
           if (status ~ /\(unhealthy\)/) {
               printf "\033[31mUNHEALTHY\033[0m\n";
           } else if (status ~ /\(healthy\)/) {
               printf "\033[32mHEALTHY\033[0m\n";
           } else if (status ~ /Up/ && status !~ /health/) {
               printf "\033[33mUP (NO HEALTH CHECK)\033[0m\n";
           } else if (status ~ /Restarting/) {
               printf "\033[35mRESTARTING\033[0m\n";
           } else {
               printf "\033[31mCRITICAL\033[0m\n";
           }
       }' | \
       column -t -s $'\t'
   }

   Cette fonction crée un tableau de bord d’intégrité coloré indiquant l’état de tous les conteneurs avec un codage couleur intuitif : vert pour sain, rouge pour non sain, jaune pour l’exécution sans vérification de l’état et violet pour le redémarrage des conteneurs. Cela fournit un aperçu visuel rapide de l’état de votre flotte de conteneurs, ce qui permet de repérer facilement les problèmes en un coup d’œil.

   

Conclusion

Cette fonction Bash améliore votre flux de travail lors de la gestion de plusieurs conteneurs Docker. Il est particulièrement utile sur les systèmes occupés et vous permet d’identifier rapidement les conteneurs importants en fonction de la logique de tri que vous définissez.

Foire aux questions (FAQ)

1. Puis-je trier par utilisation du processeur ou de la mémoire ?

   Pas directement avec docker ps, mais vous pouvez utiliser les statistiques docker avec des scripts personnalisés ou des outils comme ctop.

2. Cela fonctionnera-t-il sur Zsh ou Fish ?

   Vous devrez peut-être ajuster légèrement la syntaxe en fonction de votre shell, mais le concept reste le même.

3. Puis-je l’utiliser pour des hôtes Docker distants ?

   Oui, si votre client Docker est configuré pour communiquer avec un hôte distant, la fonction fonctionne de la même manière.

4. Que faire si je veux filtrer des conteneurs spécifiques ?

   Vous pouvez ajouter une commande grep avant le tri pour filtrer les noms ou les statuts des conteneurs en fonction de vos besoins.

5. Comment puis-je améliorer encore la fonctionnalité ?

   Envisagez d’intégrer la gestion des erreurs et des options de tri supplémentaires en fonction de vos scénarios d’utilisation typiques.