Tellement d'amour et beaucoup de +1. J'utilise des bornes 80x24 (au grand dam de
mes collègues) et celui-ci a été un irritant mineur pour moi pendant un certain temps
temps.

Je dois dire que cela me touche souvent aussi.

Des idées de solution ? Avoir une version plus petite sur des terminaux plus étroits semble bien.

Eh bien, ID n'a pas vraiment besoin d'être là.

Que dis-tu de ça:

NAME               IMAGE              STATUS      PORTS             COMMAND
prickly_perlman    ubuntu:14.04       Up 15s      8000->8000/tcp    sleep 30000

Explication:

• pas d'identifiant car les conteneurs ont toujours des noms
• non créé, vous pouvez inspecter pour cela
• il semble assez utile de connaître un aperçu de tous les ports ouverts, mais peut-être que cela pourrait être supprimé ?
• la commande peut être tronquée à la largeur du terminal, comme /bin/ps

@bfirsh :thumbsup: avec ces notes ;

• S'il vous plaît, ne laissez pas tomber les ports, pour moi ils sont très utiles pour voir rapidement quels ports sont connectés à quel conteneur. Devoir inspecter chaque conteneur est fastidieux
• Que faire avec --no-trunc , maintenant que le conteneur-id n'est plus visible ? De nombreux exemples existent qui s'appuient sur cette fonctionnalité pour purger les conteneurs arrêtés
• Quel sera l'ordre de tri (par défaut) ? Date de création (pas logique, puisque cette colonne n'est plus visible) ? Par ordre alphabétique sur le nom du conteneur ?
• Pour une amélioration future ; permet de spécifier sur quelles colonnes afficher et trier (par exemple --columns=a,f,g --sort=a,e
• Pour une amélioration future ; rendre les colonnes à afficher et à trier configurables dans un fichier de configuration
• Pour une amélioration future ; autoriser la définition des options de filtrage par défaut (ne pas afficher/ne pas afficher les conteneurs arrêtés par défaut ( -a ))

Qu'est-ce qui ne va pas avec le raccordement à un téléavertisseur ?

docker ps | less -S

@benjamin-thomas ou docker ps détectant un TTY et redirigeant vers less -S par défaut ?

Belle astuce @benjamin-thomas , je vais certainement l'utiliser à l'avenir. Une considération est que cela laisse de côté les informations qui m'intéressent, le plus important, les noms de conteneurs. Alors que dans mon cas d'utilisation, je ne me soucie généralement pas autant de, par exemple, CREATED et STATUS .

OMI, le cas d'utilisation peut varier selon les utilisateurs, pour moi, STATUS _est_ important d'obtenir une vérification rapide si mes conteneurs fonctionnent toujours correctement ou ont fait un « whoopsie ».

Je ne sais pas vraiment si cela devrait devenir une grande réimplémentation de la sortie ps, ou _start_ en le rendant un peu plus propre par défaut et en s'appuyant sur cela, le rendant plus configurable en ajoutant des options pour spécifier les colonnes à afficher, ordre de tri et filtrage.

@nathanleclaire , utilisez simplement vos touches fléchées une fois que vous êtes à l'intérieur de less , vous avez accès à tout le contenu. Ou je t'ai mal compris ?

@grahamc pourquoi pas, personnellement, je préfère les outils pour ne pas faire ces choses automatiquement. On peut toujours définir un alias shell pour cette OMI si nécessaire.

@thaJeztah spécifiant les noms de colonnes avec des commutateurs a du sens pour moi, comme la commande système ps /bin/ps -o pid,ruser=RealUser -o comm=Command .

@benjamin-thomas Oh, je ne m'en étais même pas rendu compte. Agréable! J'aime beaucoup cette solution.

@benjamin-thomas /bin/ps fait automatiquement. Si vous souhaitez le désactiver, vous pouvez le rediriger via cat ou autre.

Lié à la largeur de la sortie docker ps : est-il vraiment nécessaire de traiter chaque chaîne de liens possible vers un conteneur donné comme un nouveau nom pour ce conteneur ? Par exemple, si j'ai cinq conteneurs nommés A, B, C, D et E, et que A est lié à B, B est lié à C, et ainsi de suite, alors E aura cinq noms différents : E, D/E, C/ D/E, B/C/D/E et A/B/C/D/E.

Ensuite, si B est également lié à, disons, D, E obtient encore PLUS de noms : B/D/E et A/B/D/E. Une exécution du système sur lequel je travaille démarre dix-sept conteneurs -- qui, au total, en raison de 31 relations de dépendance, ont _trois cent quatre-vingt-sept noms_. Quelle que soit la largeur des fenêtres de mon terminal, la sortie de docker ps est illisible sans pager. Est-il vraiment logique que le nombre de noms soit _pire que quadratique_ dans le nombre de conteneurs ? Ce serait au moins bien s'il y avait un moyen de désactiver ce niveau d'énumération pédant.

@mraccident :+1 : docker ps ne doit afficher que le nom principal, pas tous les noms de ce conteneur

Salut, ça me dérangeait aussi et je viens d'ajouter une option '--short' à docker. en gardant la colonne port complète.
https://github.com/ChristianKniep/docker/tree/7477-short_ps

$ docker run --name fd1 -d -p 80 -p 22 -p 53 fedora sleep 600
af6599f9b1178b237f6c2524f14cada45a46b234168e5270b99b16d1ce0be295
$ docker run --name fd2 --link fd1:fd1  -d -p 80 -p 22 -p 53 fedora sleep 600
ec2b2afc72dae7e62b197dc5adbcdeb548435ac495b8c935c728eb7aff658004
$ docker run --name fd3 --link fd2:fd2  --link fd1:fd1  -d -p 80 -p 22 -p 53 fedora sleep 600
ac57921063cc6afbe1cf715872dc33df45147ef1f464859c0912261b88e6bb4b
$ docker ps
CONTAINER ID        IMAGE                       COMMAND             CREATED             STATUS              PORTS                                                                 NAMES
ac57921063cc        fedora:latest   sleep 600           3 seconds ago       Up 2 seconds        0.0.0.0:49159->22/tcp, 0.0.0.0:49160->53/tcp, 0.0.0.0:49161->80/tcp   fd3                               
ec2b2afc72da        fedora:latest   sleep 600           11 seconds ago      Up 10 seconds       0.0.0.0:49156->22/tcp, 0.0.0.0:49157->53/tcp, 0.0.0.0:49158->80/tcp   fd2,fd3/fd2                       
af6599f9b117        fedora:latest   sleep 600           31 seconds ago      Up 30 seconds       0.0.0.0:49153->22/tcp, 0.0.0.0:49154->53/tcp, 0.0.0.0:49155->80/tcp   fd1,fd2/fd1,fd3/fd1,fd3/fd2/fd1                    
$ ./docker-1.1.2-dev ps -S
CONTAINER ID        IMAGE                       PORTS                                                                 NAMES
ac57921063cc        fedora:latest   0.0.0.0:49159->22/tcp, 0.0.0.0:49160->53/tcp, 0.0.0.0:49161->80/tcp   fd3                               
ec2b2afc72da        fedora:latest   0.0.0.0:49156->22/tcp, 0.0.0.0:49157->53/tcp, 0.0.0.0:49158->80/tcp   fd2,fd3/fd2                       
af6599f9b117        fedora:latest   0.0.0.0:49153->22/tcp, 0.0.0.0:49154->53/tcp, 0.0.0.0:49155->80/tcp   fd1,fd2/fd1,fd3/fd1,fd3/fd2/fd1             
$ ./docker-1.1.2-dev ps -h

Usage: docker ps [OPTIONS]

List containers

  -a, --all=false       Show all containers. Only running containers are shown by default.
  --before=""           Show only container created before Id or Name, include non-running ones.
  -f, --filter=[]       Provide filter values. Valid filters:
                          exited=<int> - containers with exit code of <int>
  -l, --latest=false    Show only the latest created container, include non-running ones.
  -n=-1                 Show n last created containers, include non-running ones.
  --no-trunc=false      Don't truncate output
  -q, --quiet=false     Only display numeric IDs
  -S, --short=false     Skip command created and status
  -s, --size=false      Display sizes
  --since=""            Show only containers created since Id or Name, include non-running ones.
$

Comme je suis un débutant, je suppose que mon code pourrait être... optimisé...
Mais c'est incroyable à quel point il est facile de changer le code, en tant que python d'un an. Je l'aime bien!

EDIT : On pourrait peut-être récupérer la taille du terminal et supprimer des colonnes pour raccourcir les lignes...

EDIT2 : j'ai raccourci les NOMS et ajouté un compte (ENFANTS), même si c'est un peu trompeur, car il compte également fd3->fd2->fd1.

$ ~/bin/docker-1.1.2-dev ps -S
CONTAINER ID        IMAGE                       PORTS                                                                 NAME                #CHILDREN
9b382826657c        fedora:latest   0.0.0.0:49168->22/tcp, 0.0.0.0:49169->53/tcp, 0.0.0.0:49170->80/tcp   fd3                 0
93f5a7b13d8b        fedora:latest   0.0.0.0:49165->22/tcp, 0.0.0.0:49166->53/tcp, 0.0.0.0:49167->80/tcp   fd2                 1
4c6f3564612c        fedora:latest   0.0.0.0:49162->80/tcp, 0.0.0.0:49163->22/tcp, 0.0.0.0:49164->53/tcp   fd1                 3

EDIT3 : Maintenant, j'extrait le nom correct

$ ./docker-1.1.2-dev ps -S
CONTAINER ID        IMAGE                       PORTS                                                                 NAME                #LINKS
71d9d03bba50        fedora:latest   0.0.0.0:49177->22/tcp, 0.0.0.0:49178->53/tcp, 0.0.0.0:49179->80/tcp   fd3                 0
cf67008f418f        fedora:latest   0.0.0.0:49174->22/tcp, 0.0.0.0:49175->53/tcp, 0.0.0.0:49176->80/tcp   fd2                 1
5549c65007b5        fedora:latest   0.0.0.0:49171->22/tcp, 0.0.0.0:49172->53/tcp, 0.0.0.0:49173->80/tcp   fd1                 3

Je pense que la définition des ports et la verbosité des temps sont une grande partie de la largeur de la sortie docker ps . Je pense qu'abréger les heures et faire en sorte que les définitions des ports recouvrent les lignes économiserait beaucoup d'espace (en plus de me permettre de sélectionner/masquer des colonnes).

CONTAINER ID     IMAGE                 COMMAND                CREATED     STATUS              PORTS                            NAMES
8a2e6a22ae1f     me/abc-data:latest    "/bin/sh -c bash"      6 sec       Exited (0) 6 sec                                     app-without-ports
749ed051fb73     me/webserver:latest   "/opt/server/run.sh"   4 days      Up 4 days           0.0.0.0:8080->8080/tcp,          my-webserver
                                                                                              192.168.1.1:9990->9990/tcp      
2eb3c43af24f     me/app:latest         "/opt/container-star   8 days      Up 8 days           0.0.0.0:1234->1234/tcp,          some-other-app
                                                                                              0.0.0.0:4567->4567/tcp, 
                                                                                              0.0.0.0:50000->50000/tcp, 
                                                                                              0.0.0.0:50000->50000/udp  

Que diriez-vous de permettre de fournir un modèle par exemple en définissant une variable d'environnement DOCKER_PS_FORMAT avec columname:width :modifier, columname:width :modifier, ...
où modifier peut autoriser des paramètres supplémentaires comme no-trunc , full (par exemple pour l'identifiant du conteneur) ou short pour CREATED où ~1h pourrait être une forme abrégée pour About an hour ago .

J'ai écrit cette fonction bash/zsh dans mon ~/.bashrc pour mieux afficher la sortie de docker ps , vous pouvez masquer ou réorganiser les colonnes :

dps()  {
  docker ps $@ | awk '
  NR==1{
    FIRSTLINEWIDTH=length($0)
    IDPOS=index($0,"CONTAINER ID");
    IMAGEPOS=index($0,"IMAGE");
    COMMANDPOS=index($0,"COMMAND");
    CREATEDPOS=index($0,"CREATED");
    STATUSPOS=index($0,"STATUS");
    PORTSPOS=index($0,"PORTS");
    NAMESPOS=index($0,"NAMES");
    UPDATECOL();
  }
  function UPDATECOL () {
    ID=substr($0,IDPOS,IMAGEPOS-IDPOS-1);
    IMAGE=substr($0,IMAGEPOS,COMMANDPOS-IMAGEPOS-1);
    COMMAND=substr($0,COMMANDPOS,CREATEDPOS-COMMANDPOS-1);
    CREATED=substr($0,CREATEDPOS,STATUSPOS-CREATEDPOS-1);
    STATUS=substr($0,STATUSPOS,PORTSPOS-STATUSPOS-1);
    PORTS=substr($0,PORTSPOS,NAMESPOS-PORTSPOS-1);
    NAMES=substr($0, NAMESPOS);
  }
  function PRINT () {
    print ID NAMES IMAGE STATUS CREATED COMMAND PORTS;
  }
  NR==2{
    NAMES=sprintf("%s%*s",NAMES,length($0)-FIRSTLINEWIDTH,"");
    PRINT();
  }
  NR>1{
    UPDATECOL();
    PRINT();
  }' | less -FSX;
}
dpsa() { dps -a $@; }

Piratage de la solution de contournement. Modifiez les $cols[x] que vous souhaitez conserver comme vous le souhaitez.

docker ps | perl -ne '<strong i="6">@cols</strong> = split /\s{2,}/, $_; printf "%30s %20s %20s\n", $cols[1], $cols[3], $cols[4]'

Ne serait-il pas plus simple d'avoir quelque chose comme :

$ docker ps --columns=name,id,status,image

et tout le monde pourrait simplement créer un alias docker ps .

Merci @caiguanhao. Solution intérimaire intelligente. Ajouté en tant que plugin Tackle pour la carapace de poisson.

Les gars, je viens d'apporter une petite amélioration au code de

https://github.com/jpmelos/dotfiles/commit/457a9c68f87eb5bd455aa22bdadab81c2651c2ea

Un changement simple qui aiderait un peu est de réduire l'espacement entre les colonnes CONTAINER ID et IMAGE. Les autres colonnes sont toutes séparées par 3 espaces, mais ces deux sont séparées par 8.

Mes 5 cents jusqu'à ce qu'ils rendent 'docker ps' lisible :

https://github.com/t0mk/dosk#dops

Allons-nous voir une mise à jour à ce sujet?
Je pense que docker ps est la commande la plus courante. J'espère que ce n'est pas si difficile de nous donner la possibilité de filtrer les colonnes à afficher.
(je m'attendrais à quelque chose comme ça )

dibs

Comme @AntouanK l'a dit et @wpp déjà suggéré, un indicateur de colonnes serait préférable pour la plupart des situations

Je pense que #10255 devrait résoudre ce problème.

@duglin Cela

@bfirsh bon point, non, cela ne changerait pas la valeur par défaut. Mais je ne suis pas sûr que nous puissions changer la valeur par défaut jusqu'à la v2 (si/quand c'est le cas) car nous casserions les clients existants si nous le faisions.

pareil ici. peut-être un mécanisme intelligent qui sélectionne les colonnes par défaut affichées en appliquant des seuils à ENV['COLUMNS'] ?

Je suis d'accord avec https://github.com/docker/docker/issues/7477#issuecomment -70243594, donnez-nous simplement la possibilité de choisir les colonnes.

Je vote également pour l'option https://github.com/docker/docker/issues/7477#issuecomment -70243594.
docker ps serait docker ps --columns=id,image,command,created,status,ports,name et il pourrait être facile d'implémenter plus de colonnes telles que ip comme le voulaient certains utilisateurs https://github.com/docker/docker/issues/8786

+1 pour --columns

Pour contourner le problème, je combine docker ps -q avec docker inspect --format :

docker ps -q | xargs docker inspect --format '{{printf "%.12s\t%s" .Id .Config.Cmd}}'

Vous devez creuser dans la sortie de docker inspect et de golang templates, mais c'est presque configurable à l'infini.

@jafcrocker Joli. Peut-être pouvons-nous faire une idée publique pour y conserver une collection de solutions de contournement comme celle-ci ? Jusqu'à ce que nous obtenions des indicateurs pour personnaliser correctement la sortie ...

nous venons de fusionner #14699 qui vous permet d'exécuter docker ps --format ... pour modifier la sortie ps. Vous pouvez également définir un format par défaut si vous le souhaitez, consultez cette capture d'écran :

Je vais clore ce problème comme résolu. S'il vous plaît, n'hésitez pas à essayer et dites-nous ce que vous en pensez.

Pour ceux qui souhaitent l'essayer, les versions "master" peuvent être trouvées sur https://master.dockerproject.org et cette fonctionnalité devrait y être bientôt (si ce n'est déjà fait)

Bien que le --format soit un très bon ajout, je ne pense pas que cela résolve le problème principal. Presque tous les outils de ligne de commande que j'utilise quotidiennement gèrent correctement les terminaux de taille variable. La plupart en regardant la variable d'environnement $COLUMNS et en affichant le texte approprié.

Par exemple, ps aux dans un terminal 80x24 :

Et dans une borne 137x24 :

Il modifie la largeur de la colonne et raccourcit la commande afin que tout tienne bien sur une seule ligne. Tout pour la lisibilité et facile à analyser pour un humain.

Bien sûr, je peux écrire un wrapper bash qui appliquera différentes options de formatage en fonction de $COLUMNS mais cela commence à sembler vraiment bidon et quelque chose que je pense devrait être le comportement par défaut pour tout programme en ligne de commande. Je suis désolé de le dire, la sortie de docker est désordonnée et difficile à lire.

Y a-t-il une raison pour laquelle cela n'est pas fait ? Une limitation dans une bibliothèque ou une décision de votre part ? J'ai besoin de savoir si c'est quelque chose qui vaut la peine d'être corrigé dans un PR, ou peut-être que j'aboie dans le mauvais arbre.

@nsg : D'accord - la sortie par défaut pourrait encore être améliorée.

Y a-t-il eu une mise à jour sur ce problème?

Ainsi, pour une raison quelconque, les hachages d'image ne sont plus tronqués dans la sortie ps. Je devais déjà rendre mon terminal ultra-large (occupant tout l'écran) juste pour rendre docker utilisable dans le passé, maintenant cela ne suffit plus. Depuis la 1.7.1, chaque ligne fait environ 200 colonnes de large. Qui utilise un terminal aussi large ?

J'ai joué un peu avec ça.

La suppression de l'ID et de la création nous permet d'y arriver un peu :

NAMES                 IMAGE          STATUS                     PORTS                         COMMAND
elegant_turing        nginx          Up 13 secs                 0.0.0.0:80->80/tcp, 443/tcp   "nginx -g 'daemon off"
composedemo_web_1     composedemo_   Exited (2) 23 secs ago                                   "/bin/sh -c 'python a"
composedemo_redis_1   redis          Exited (137) 11 secs ago                                 "/entrypoint.sh redis"
elated_carson         hello-world    Exited (0) 23 mins ago                                   "/hello"

Encore trop long quand même. On pourrait ignorer 0.0.0.0 :

NAMES                 IMAGE          STATUS                     PORTS                 COMMAND
elegant_turing        nginx          Up 13 secs                 80->80/tcp, 443/tcp   "nginx -g 'daemon off"
composedemo_web_1     composedemo_   Exited (2) 23 secs ago                           "/bin/sh -c 'python a"
composedemo_redis_1   redis          Exited (137) 11 secs ago                         "/entrypoint.sh redis"
elated_carson         hello-world    Exited (0) 23 mins ago                           "/hello"

Mais encore un peu long. Peut-être qu'un peu de créativité est nécessaire pour raccourcir le statut... quelque chose d'analysable/analysable, mais toujours court... Exit (2) 23s ago peut-être ?

Bien que la commande puisse être raccourcie, nous aurions également besoin de raccourcir autre chose pour nous assurer qu'au moins _certain_ de la commande est affiché. Impossible de raccourcir le nom. L'image pourrait peut-être avoir un "..." lorsqu'elle est tronquée. Idem pour les ports longs.

Les pensées?

Quelques hacks sont ici : https://github.com/docker/docker/compare/master...bfirsh :7477-shorter-ps

@bfirsh Je pense que vous êtes sur quelque chose.

Si vous changez le statut (comme vous l'avez dit) en 23s au lieu de 23 secondes et tronquez la colonne image et ports, cela devrait être suffisamment court.

@bfirsh tu commences à travailler dans la vue par défaut ? Pensez-vous à l'option --format dont parlent certaines personnes ?

Aussi, nous pourrions utiliser s au lieu de sec et m au lieu de mins

@aanm, nous avons déjà le --format dans docker 1.8. Vous pouvez également modifier le comportement par défaut de ps dans le fichier de configuration client en ajoutant quelque chose comme ceci :

{
  "psFormat": "table {{ .ID }}\\t{{ .Status }}"
}

Vous pouvez définir votre valeur par défaut avec le format que vous préférez.

J'ai souvent besoin de voir le nom du conteneur actuel, pour exécuter le prochain docker exec à attacher.

donc, j'espère que si vous pouvez déplacer NAMES après IMAGE , ça ira bien, je n'ai plus besoin de configuration.

Merci.

Problème dans docker 1.8.1 (fc21)
--format ne connaît pas les noms de conteneurs.

docker ps --format "{{.ID}}t{{.Image}}t{{.CreatedAt}}t{{.RunningFor}}t{{.Status}}t{{.Name}}" -a
Erreur d'analyse du modèle : modèle : : :1:64 : exécution de "" à <.Name> : le nom n'est pas un champ de type struct *ps.containerContext

Jusqu'à présent en utilisant:
docker ps-a | perl -ne 'chomp; @cols = diviser /s{2,}/, $_; $nom=pop @cols; printf "%-28s %-20s %-20s %-30sn", $nom, $cols[1], $cols[3], $cols[4]'

@parf l'espace réservé s'appelle en fait Names :

https://github.com/calavera/docker/blob/missing_ps_placeholder/docs/reference/commandline/ps.md#formatting

merci à @caiguanhao pour l'inspiration.

je laisse juste ça ici :

IMAGE                                NAMES                     STATUS              PORTS
xxxxx:x.x                            xx_xxxxxxxx_xxxxx         Up About an hour    10.23.123.111:26002->6379/tcp
xxxxxxxxx:x.x                        xx_xxxxxxxx_xxxxxxxxx     Up About an hour    29015/tcp
                                                                                   10.23.123.111:26001->8080/tcp
                                                                                   10.23.123.111:26000->28015/tcp
xxxxxxxx_xx_xxxxxxxx                 xx_xxxxxxxx               Up About an hour    127.0.0.1:8086->8080/tcp
xxxxxx_xx                            xx_xxx_xxx                Up About an hour    127.0.0.1:8082->8888/tcp
xxx_xx                               xx_xxx                    Up About an hour    127.0.0.1:8083->8080/tcp
xxxx/xxxxxxxxx-xxxxxx                xx_xxx_xxxxxxxxx_xxx      Up 2 hours          10.23.123.111:25002->25565/tcp
xxxx/xxxxxxxxx-xxxxxx                xx_xxx_xxxxxxxxx_xxxxxx   Up 2 hours          10.23.123.111:25001->25565/tcp
xxxxxx/xxxxxxxx:xxxxxx               xxx_xxxxxxxx              Up 3 hours          127.0.0.1:8080->8080/tcp
xxxxxxxxxx/xxxxxxx                   xxx_xxxxxxx               Up 3 hours          10.23.123.111:25->25/tcp
                                                                                   10.23.123.111:587->587/tcp
xx_xxx                               xx_xx                     Up 3 hours          10.23.123.112:9987->9987/tcp
                                                                                   10.23.123.112:10011->10011/tcp
                                                                                   10.23.123.112:30033->30033/tcp
                                                                                   10.23.123.112:9987->9987/udp
xxxx.xx/xxxxxxxxx/xxxxxx:x.x.x       xxx_xxxxxx                Up 3 hours          10.42.241.123:22->22/tcp
                                                                                   443/tcp
                                                                                   127.0.0.1:8000->80/tcp
xxxxxx/xxxxxx-xxxxxx:xxxxxx          xxx_xxxxxx_xx_xxxxxx      Up 3 hours
xxxx.xx/xxxxxxxxx/xxxxxxxxxx:x.x-x   xxx_xxxxxx_xxxxxxxx       Up 3 hours          5432/tcp
xxxx.xx/xxxxxxxxx/xxxxx:xxxxxx       xxx_xxxxxx_xxxxx          Up 3 hours          6379/tcp

/etc/profile.d/dps.sh : https://gist.github.com/GottZ/4a6c2af314d73cd8b71d

Sympa @GottZ , merci pour le partage !

@thaJeztah, je viens de mettre en gras chaque ligne paire pour une meilleure visibilité. amusez-vous bien :sourire:

En attendant, mon approche avec awk :

$ alias my_docker_ps="docker ps | awk 'BEGIN{FIELDWIDTHS = \"20 33 23 20 20 70 20\"}{print \$1,\$2,\$5,\$7}'"

$ my_docker_ps         
CONTAINER ID         IMAGE                             STATUS               NAMES
b83fe9a6a06e         kibana                            Up 32 minutes        kibana              
4d78b9cd2bed         elasticsearch                     Up About an hour     evil_feynman        
fbbc40a49569         mattermost/platform               Up 9 weeks           mattermost-dev      
3b4dd9d00305         outcoldman/splunk:latest          Up 9 weeks           boring_yalow           

@danidelvalle pourquoi pas simplement ;

docker ps --format "table {{.ID}}\t{{.Image}}\t{{.Status}}\t{{.Names}}"

Cela a déjà été commis et publié. Je ne comprends pas, pourquoi est-ce toujours ouvert ?

@thaJeztah tu as raison, merci :)

@ovidiub13 principalement à cause de https://github.com/docker/docker/issues/7477#issuecomment -123898874

oui c'est ennuyeux..

Je suis généralement d'accord pour tronquer simplement le ps par défaut à la largeur de la colonne terminale :

dps() {
  docker ps | cut -c-$(tput cols)
}

+1 pour --columns=name,id,status,image

Ce problème existe toujours malheureusement. Quoi qu'il en soit, une solution de contournement consiste à mettre ce qui suit (testé sous Ubuntu) dans votre .bashrc :

CMD_WATCHDOCKER="watch \"docker ps -q | xargs docker inspect --format '{{.Id}} @{{.Config.Image}} @{{.Config.Cmd}} @{{range \\\$p, \\\$conf := .NetworkSettings.Ports}}{{\\\$p}}->{{(index \\\$conf 0).HostPort}}{{end}} @{{.NetworkSettings.IPAddress}}' | column -t -s='@' | cut -c 1-5,64-\""
alias watchdocker='eval $CMD_WATCHDOCKER'

Exécuter watchdocker donne :

4596c3   ruby:2.2.2   [bash]                        172.17.0.82
827ca9   postgres     [postgres]   5432/tcp->5432   172.17.0.72

@Pithikos docker ps--format '{{ .ID }}\t{{ .Image }}\t{{ .Command }}\t{{ .Ports }}' vous le donnera sans faire tous ces appels d'API pour chaque conteneur.
Vous pouvez également le mettre dans ~/.docker/config.json pour en faire le format par défaut

@cpuguy83 quelle version prend en charge cela ? Je n'ai jamais réussi à faire fonctionner cela, ni au travail ni à la maison. Ce serait cool si dans la documentation il était mentionné quelle version prend en charge quoi.

@Pithikos Soit 1.8 ou 1.9, pas sûr.

adapter docker ps/images à 80 colonnes

https://github.com/rhoit/my-config/blob/e374a3cf28f3bc461766ce32f823207692c74f83/shell/shellrc.d/docker.sh#L10 -L28

dibs

l'utilisation correcte est avec le mot-clé "table" dans la chaîne de format, cela vous donnera une belle mise en forme espacée docker ps -a --format="table {{.ID}}\t{{.Names}}\t{{.Image}}\t{{.Command}}\t{{.Status}}"

Je ferme celui-ci car il semble que le drapeau --format pour ps résout le problème. Merci a tous!

Cette question n'était peut-être pas bien nommée. Il reste que le _default_ des commandes doit avoir une largeur de 80 caractères. Heureux que cela soit fermé parce que ce n'est pas si important.

--format ne semble pas assez bien.
https://docs.docker.com/engine/reference/commandline/ps/#/formatting

que diriez-vous d'ajouter une option pour afficher le résultat verticalement, comme select * from foobar\G dans MySQL

En général, je veux juste savoir quels conteneurs sont en cours d'exécution (et pendant combien de temps).

Cela fait l'affaire pour moi:

$ docker ps --format "table {{.Names}}\t{{.Status}}"

Mieux encore, je l'ai enveloppé dans un alias très facile à retenir :

alias dps='docker ps --format "table {{.Names}}\t{{.Status}}"'

Voici un exemple de sortie :

NAMES                     STATUS
projectxyz_chrome_1       Up 11 minutes
projectxyz_web_1          Up 11 minutes
projectxyz_app_1          Up 11 minutes
projectxyz_phpmyadmin_1   Up 11 minutes
projectxyz_memcached_1    Up 11 minutes
projectxyz_db_1           Up 11 minutes

Vous pouvez en savoir plus sur la commande --format ici :
https://docs.docker.com/engine/reference/commandline/ps/

J'espère que ça aidera quelqu'un

@joshmedeski vous pouvez également stocker votre formatage préféré dans un fichier de configuration, afin qu'il soit utilisé par défaut ; https://docs.docker.com/engine/reference/commandline/cli/#/configuration -files

Dans l'esprit de sauvegarder les frappes, voici le petit script bash que j'ai écrit pour prendre une liste d'arguments, construire la chaîne de modèle go et exécuter la commande docker ps afin d'afficher immédiatement les colonnes souhaitées dans n'importe quel ordre. Mettre la configuration dans un fichier n'est pas assez dynamique - je trouve qu'avoir un ensemble de colonnes un instant et un ensemble différent un instant plus tard est assez utile. Le script est ici , j'espère qu'il sera utile à quelqu'un. Bravo -andy

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

import subprocess

show_all = False
fields = [
  "Names",
  "Command",
  "Image",
  "CreatedAt",
  "Status",
]

cmd = ['docker', 'ps']
if show_all:
  cmd += ['-a']
cmd += ['--format', '\t'.join([('{{ .'+field+' }}') for field in fields])]
response = subprocess.check_output(cmd)

dataset = [fields]
dataset_widths = [0] * len(fields)
for idx, line in enumerate(response.split('\n')[:-1]):
  fieldvalues = line.decode('utf-8').replace(u"\u2026", u"_").split('\t')
  dataset.append(fieldvalues)
  for jdx, fieldvalue in enumerate(fieldvalues):
    if dataset_widths[jdx] < len(fieldvalue):
      dataset_widths[jdx] = len(fieldvalue)

for idx, items in enumerate(dataset):
  output_line = ['{:>3d}'.format(idx)]
  for jdx, item in enumerate(items):
    output_line.append(('{:'+str(dataset_widths[jdx])+'s}').format(item))
  print '   '.join(output_line)

mettez ceci dans votre ~/.docker/config.json
{ "psFormat": "table {{.Names}}\\t{{.Image}}\\t{{.RunningFor}} ago\\t{{.Status}}\\t{{.Command}}", "imagesFormat": "table {{.Repository}}\\t{{.Tag}}\\t{{.ID}}\\t{{.Size}}" }

Et modifiez à votre guise. Pour moi, le problème était toujours le nom d'image long (puisqu'il contenait le nom de mon référentiel personnel pour mes images personnalisées)

tous ceux qui recherchent un meilleur docker ps devraient vérifier ceci :
https://github.com/moncho/dry

Piratage de la solution de contournement. Modifiez les $cols[x] que vous souhaitez conserver comme vous le souhaitez.

docker ps | perl -ne '<strong i="7">@cols</strong> = split /\s{2,}/, $_; printf "%30s %20s %20s\n", $cols[1], $cols[3], $cols[4]'

Merci.

C'était tout ce dont j'avais besoin :
docker ps | perl -ne '<strong i="12">@cols</strong> = split /\s{2,}/, $_; printf "%30s %20s %20s", $cols[1], $cols[4], $cols[6]'

donner les NOMS D'ÉTAT D'IMAGE
en colonnes bien alignées

ÉDITER

il vaut mieux créer un alias bash avec quelque chose comme ceci :

docker ps --format="table {{.Image}}\t{{.Status}}\t{{.Ports}}\t{{.Names}}"

Remarquez le format "tableau"

Piratage de la solution de contournement. Modifiez les $cols[x] que vous souhaitez conserver comme vous le souhaitez.

docker ps | perl -ne '<strong i="7">@cols</strong> = split /\s{2,}/, $_; printf "%30s %20s %20s\n", $cols[1], $cols[3], $cols[4]'

C'est génial, merci

@nagracks si vous voulez ce format par défaut, je vous recommande d'utiliser l'approche --format (qui peut être stockée dans votre fichier de configuration ~/.docker/config.json )

Si je modifie mon fichier .docker/config.json avec quelque chose de personnalisé comme ceci :

"imagesFormat": "table {{.ID}}  {{.Repository}}\t{{.Tag}}  {{.CreatedSince}}  {{.Size}}",
"psFormat": "table {{.ID}}  {{.Names}}\t{{.Image}}  {{.Command}}  {{.Status}}",

Comment puis-je ensuite utiliser la commande docker ps pour afficher le format par défaut ? J'ai essayé docker ps --format "" , mais il utilisait toujours la configuration.

L'utilisation de docker ps --format=table devrait donner le format de table par défaut

J'apprécierais vraiment s'il y avait une version moins détaillée de la sortie disponible par défaut, sans avoir à se rappeler quelle est la syntaxe de formatage du tableau ou quels sont les noms de variables dans le contexte de formatage. Même si la valeur par défaut était conservée telle quelle, un indicateur pour une version _pré-formatée_ moins détaillée serait utile.

Quant aux informations qui pourraient être réduites à partir d'une version moins détaillée, voici mes deux cents :

• Le nom et l'identifiant pour la plupart des utilisations ont le même objectif, et celui-ci pourrait être éliminé.
• La date et l'heure de création sont probablement quelque chose que vous seriez bien d'omettre de la sortie moins détaillée
• Personnellement, je serais également d'accord avec l'omission des ports de la sortie moins détaillée

Dans mon cas d'utilisation, je veux généralement simplement rechercher le nom du conteneur sur lequel je vais exécuter d'autres commandes (par exemple sur un nœud de serveur distant), et le fait que la sortie soit encapsulée sur plusieurs lignes rend difficile la recherche du nom exact du conteneur qui m'intéresse.

Je suis quelque peu déçu que la solution "approuvée" ici soit "juste configurer un alias avec le paramètre --format", comme si vous exécutiez toujours ces commandes dans des environnements où votre alias est défini, ou rappelez-vous la syntaxe de formatage et les variables de contexte

Je rencontre toujours ce problème quotidiennement, FWIW. Ma sortie actuelle de docker ps -a est de _180 caractères de large_ -- plus de la moitié de mon écran 4K de 27" !

CONTAINER ID        IMAGE                                          COMMAND                 CREATED             STATUS                    PORTS               NAMES
994be99dddd1        nvidia/cuda:10.2-devel-ubuntu18.04             "bash"                  4 days ago          Exited (0) 4 days ago                         eager_tesla
30796cc3db32        nvidia/cuda:10.2-devel-ubuntu18.04             "bash"                  4 days ago          Exited (127) 4 days ago                       laughing_maxwell
ed5f20c1cff3        gcr.io/deeplearning-platform-release/tf2-gpu   "/entrypoint.sh bash"   4 days ago          Exited (0) 3 days ago                         distracted_ardinghelli
0bb06e992ef4        gcr.io/deeplearning-platform-release/tf2-gpu   "/entrypoint.sh bash"   4 days ago          Exited (0) 4 days ago                         bold_brahmagupta

On ne devrait pas s'attendre à ce que l'utilisateur moyen crée un alias de sa commande docker ps juste pour la rendre lisible sur un terminal de taille raisonnable. Peut-être qu'il n'a pas besoin d'être aussi petit que 80 caractères, mais il ne devrait certainement pas être de 180 caractères.

Je suis tenté d'ouvrir une pull request en tant qu'homme de paille. ??