Comment devenir un utilisateur expérimenté de Docker CLI avec « -format » et des modèles de sortie

L’utilisation de l’interface de ligne de commande Docker pour répertorier et inspecter les ressources de votre système produit souvent une sortie détaillée qui peut masquer des détails importants. Docker prend en charge la syntaxe de modèle de Go en conjonction avec le --format drapeau pour vous donner le contrôle sur ce qui est affiché.

Apprendre à utiliser des modèles peut faire de vous un utilisateur expérimenté de Docker CLI. Ils vous permettent de sélectionner et de transformer efficacement les sorties de commande pour créer les vues dont vous avez besoin. Cela se traduit par une expérience CLI plus productive et moins de temps passé à analyser de longues lignes de console.

Quelles commandes prennent en charge le « -format » ?

La --format flag est pris en charge par les plus couramment utilisés docker commandes. Vous pouvez l’utiliser avec docker inspect et des commandes qui produisent des listes d’éléments, telles que docker ps, docker imageset docker volumes.

Lorsque vous incluez le --format flag, Docker enverra la sortie de la commande via la chaîne de modèle Go que vous fournissez. Vous pouvez utiliser les fonctionnalités de création de modèles fournies par Go pour utiliser les espaces réservés définis par Docker. Ceux-ci vous donnent accès aux données récupérées par la CLI.

Un exemple de base

Fonctionnement docker inspect sur un conteneur affiche un long objet JSON qui déborde généralement de votre fenêtre de terminal. Utilisant --formatvous pouvez extraire les parties spécifiques des données qui vous intéressent. Voici un exemple qui montre l’état, le PID et l’heure de début du conteneur :

~$ docker inspect 94a8d1315315 --format '{{.State.Status}} (PID: {{.State.Pid}}) {{.State.StartedAt}}'
running (PID: 1488278) 2022-03-22T20:45:58.614115689Z

Il est beaucoup plus facile de repérer les valeurs cibles à l’aide d’un modèle qu’en parcourant manuellement le JSON brut.

Accéder aux valeurs de sortie

Les parties dynamiques de votre modèle sont entourées de doubles parenthèses bouclées. Vous pouvez référencer des valeurs dans la sortie de la commande Docker à l’aide de {{.Field}} syntaxe. Field doit être le nom d’une propriété dans la représentation JSON de cette sortie. Les champs imbriqués sont sélectionnés à l’aide d’une syntaxe chaînée similaire aux accès aux propriétés en JavaScript, .Field.NestedValue.

Vous pouvez déterminer quels champs sont disponibles en affichant la sortie brute de la commande. docker inspect affiche JSON par défaut ; cela peut être directement mappé aux espaces réservés de la syntaxe du modèle. Pour d’autres commandes telles que ps et imagesvous pouvez récupérer la structure JSON sous-jacente à l’aide d’un modèle spécial :

docker ps --format '{{json .}}`

La json La fonction affiche la version JSON brute des données que vous fournissez.

Transformations simples

Les fonctions de transformation offrent un moyen pratique de manipuler les valeurs. upper et lower convertir les chaînes en majuscules et minuscules respectivement. Vous pouvez appliquer la casse du titre à une chaîne avec title. Les fonctions sont insérées dans le modèle avant la valeur sur laquelle elles opèrent :

~$ docker inspect 94a8d1315315 --format '{{upper .State.Status}} (PID: {{.State.Pid}})'
RUNNING (PID: 1488278)

Si vous souhaitez ajouter un caractère de saut de ligne entre les valeurs, utilisez le println fonction:

~$ docker inspect 94a8d1315315 --format '{{.State.Status}} {{.State.Pid}}{{println}}{{.State.StartedAt}}'
running 1488278
2022-03-22T20:45:58.614115689Z

Travailler avec des tableaux

La syntaxe du modèle a intégré la prise en charge de l’itération des éléments d’un tableau. La range la fonction boucle sur les valeurs d’un tableau et définit le . variable à chacun :

~$ docker inspect 94a8d1315315 --format '{{range .Mounts}}{{println .Destination}}{{end}}'
/config
/data

Vous pouvez combiner des éléments de tableau avec les join fonction:

~$ docker inspect 94a8d1315315 --format '{{join .Config.Cmd " "}}'
caddy run --config /etc/caddy/Caddyfile --adapter caddyfile

Cela crée une chaîne qui incorpore chaque valeur dans le tableau. Les éléments sont joints avec le texte spécifié comme deuxième paramètre de l’argument.

Tabulation de la sortie

De nombreuses commandes Docker affichent par défaut les données dans une disposition de tableau lisible par l’homme. Vous pouvez créer vos propres tableaux en utilisant le spécial table composant de modèle.

Utilisation t caractères pour séparer les champs de données en colonnes de table. Le modèle sera exécuté pour chacun des éléments inclus dans la sortie de la commande Docker CLI. Les colonnes du tableau sont automatiquement dimensionnées pour correspondre à la longueur de leur contenu.

~$ docker images --format 'table {{.ID}}t{{.Tag}}t{{.Size}}'
IMAGE ID       TAG          SIZE
ede20431e41f   caddy        40.4MB
e5179b119094   <none>       40.4MB

Docker inclut automatiquement les en-têtes de colonne appropriés pour les champs de votre modèle.

Mise en forme conditionnelle

Les modèles prennent également en charge les instructions conditionnelles « if ». Vous pouvez personnaliser dynamiquement le résultat de la commande en affichant une valeur différente en fonction d’une condition :

~$ docker ps --format '{{.ID}} {{if eq .State "running"}}Alive{{else}}Not Running{{end}}'
94a8d1315315 Alive

Ce modèle affiche soit Alive ou Not Running selon que chaque contenant State champ est défini sur running. La if block est suivi de la valeur qui s’affiche lorsque la condition correspond. Un facultatif else bloc peut être enchaîné par la suite. La condition est résiliée par le {{end}} mot-clé.

Les modèles Go comprennent plusieurs opérateurs de comparaison. La eq ci-dessus vérifie si la première valeur est égale à la seconde. Les options suivantes sont disponibles en plus :

• ne – Une comparaison « différent de ».
• lt – Une comparaison « inférieur à » (<)).
• lte – Une comparaison « inférieur ou égal à » (<=)).
• gt – Une comparaison « supérieur à » (>)).
• gte – Une comparaison « supérieur ou égal à » (>=)).

Il y a and, oret not également des mots-clés pour enchaîner des conditions dans des expressions complexes.

Formatage avancé à l’aide de Jq

La --format flag est principalement utilisé pour créer des chaînes de sortie lisibles par l’homme. Si vous êtes plus à l’aise pour inspecter JSON brut, vous pouvez utiliser d’autres outils comme jq pour manipuler plus directement la sortie de Docker. Cela peut être utile lorsque vous souhaitez créer des requêtes plus avancées que les modèles Go seuls peuvent fournir.

docker inspect produit JSON par défaut afin que sa sortie puisse être dirigée directement dans jq:

~$ docker inspect 94a8d1315315 | jq .[0].Config.Cmd
[
  "caddy",
  "run",
  "--config",
  "/etc/caddy/Caddyfile",
  "--adapter",
  "caddyfile"
]

La sortie des autres commandes doit être convertie en son JSON brut avec --format avant qu’il ne soit transmis à jq:

~$ docker images --format '{{json .}}' | jq .Size
"968MB"
"946MB"
"40.1MB"

Jq fournit sa propre syntaxe pour sélectionner, manipuler et formater les données JSON. Les principes de base sont similaires aux espaces réservés de modèle de Go. Les champs sont référencés à l’aide de la .Field syntaxe. Il existe un support pour sélectionner des éléments de tableau à l’aide de la .[index] notation.

Conclusion

La CLI Docker devient plus puissante lorsque vous pouvez afficher et manipuler de manière sélective les données de sortie. Aller modèles avec le --format flag offrent un moyen de créer des interfaces personnalisées qui rationalisent la gestion de vos conteneurs.

Dans certaines situations, --format n’offrent peut-être pas la puissance et la flexibilité dont vous avez besoin. Transférer des commandes Docker à des outils externes tels que jq offre un autre moyen d’interroger rapidement votre installation et de faire apparaître ses données dans d’autres systèmes.