Muito amor e muitos +1s. Eu uso terminais 80x24 (para grande desgosto de
meus colegas) e este tem sido um pouco irritante para mim por um bom tempo
Tempo.

Eu tenho que dizer que isso muitas vezes me pega também.

Alguma ideia para uma solução? Ter uma versão menor em terminais mais estreitos soa bem.

Bem, a identidade não precisa estar lá.

Que tal agora:

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

Explicação:

• sem ID porque os contêineres sempre têm nomes
• não criado, você pode inspecionar para isso
• parece muito útil conhecer uma visão geral de todas as portas que estão abertas, mas talvez isso possa ser descartado?
• comando pode ser truncado para a largura do terminal, como /bin/ps

@bfirsh :thumbsup: com essas notas;

• Por favor, não deixe cair as portas, para mim elas são bastante úteis para ver rapidamente quais portas estão conectadas a qual contêiner. Ter que inspecionar cada contêiner é complicado
• O que fazer com --no-trunc , agora que o container-id não está mais visível? Existem muitos exemplos que contam com esse recurso para limpar contêineres interrompidos
• Qual será a ordem de classificação (padrão)? Data de criação (não lógica, pois essa coluna não está mais visível)? Alfabeticamente no nome do contêiner?
• Para melhoria futura; permite especificar quais as colunas a mostrar e ordenar (por exemplo --columns=a,f,g --sort=a,e
• Para melhoria futura; tornar as colunas para mostrar e classificar configuráveis ​​em um arquivo de configuração
• Para melhoria futura; permitir a configuração de opções de filtro padrão (não mostrar/mostrar contêineres parados por padrão ( -a ))

O que há de errado com a tubulação para um pager?

docker ps | less -S

@benjamin-thomas ou docker ps detectando um TTY e canalizando para less -S por padrão?

Belo truque @benjamin-thomas , definitivamente usarei isso no futuro. Uma consideração é que deixa de fora as informações com as quais me importo, mais importante, os nomes dos contêineres. Considerando que, no meu caso de uso, geralmente não me importo muito com, por exemplo, CREATED e STATUS .

IMO, o caso de uso pode variar entre os usuários, para mim, STATUS _é_ importante obter uma verificação rápida se meus contêineres ainda estão funcionando bem ou fizeram um 'whoopsie'.

Não tenho certeza se isso deve se tornar uma grande reimplementação da saída ps ou _start_ tornando-o um pouco mais limpo por padrão e com base nisso, tornando-o mais configurável adicionando opções para especificar colunas para mostrar, ordem de classificação e filtragem.

@nathanleclaire , basta usar as teclas de seta quando estiver dentro de less , você terá acesso a todo o conteúdo. Ou eu não entendi você?

@grahamc por que não, pessoalmente, prefiro ferramentas que não façam essas coisas automaticamente. Pode-se sempre definir um alias de shell para este IMO, se necessário.

@thaJeztah especificar os nomes das colunas com opções faz sentido para mim, como o comando ps do sistema /bin/ps -o pid,ruser=RealUser -o comm=Command .

@benjamin-thomas Ah, eu nem tinha percebido isso. Agradável! Gosto muito desta solução.

@benjamin-thomas /bin/ps faz isso automaticamente. Se você quiser desativá-lo, você pode canalizá-lo através de cat ou qualquer outra coisa.

Relacionado à largura da saída docker ps : é realmente necessário tratar todas as cadeias possíveis de ligações para um determinado contêiner como um novo nome para esse contêiner? Por exemplo, se eu tiver cinco contêineres chamados A, B, C, D e E, e A links para B, B links para C e assim por diante, então E terá cinco nomes diferentes: E, D/E, C/ D/E, B/C/D/E e A/B/C/D/E.

Então, se B também liga para, digamos, D, E recebe ainda MAIS nomes: B/D/E e A/B/D/E. Uma execução do sistema em que estou trabalhando inicia dezessete contêineres -- que, todos juntos, devido a 31 relacionamentos de dependência, têm _trezentos e oitenta e sete nomes_. Não importa o tamanho das janelas do meu terminal, a saída de docker ps é ilegível sem um pager. Realmente faz sentido que o número de nomes seja _pior que quadrático_ no número de contêineres? Seria pelo menos bom se houvesse uma maneira de desativar esse nível pedante de enumeração.

@mraccident :+1: docker ps deve mostrar apenas o nome principal, nem todos os nomes desse contêiner

Salut, estava me incomodando também e acabei de adicionar uma opção '--short' ao docker. mantendo a coluna da porta completa.
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.
$

Como sou novato, acho que meu código poderia ser... otimizado...
Mas é incrível como é fácil mudar o código, como um cara python de um ano. Eu gosto disso!

EDIT: Talvez alguém possa buscar o tamanho do terminal e chutar colunas para encurtar as linhas ...

EDIT2: eu encurtei os NAMES e adicionei uma contagem (CHILDREN), mesmo que seja um pouco enganosa, porque conta fd3->fd2->fd1 também.

$ ~/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: Agora extraio o nome correto

$ ./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

Eu sinto que a definição das portas e a verbosidade dos tempos são uma grande parte da largura da saída docker ps . Acho que abreviar os tempos e fazer as definições de portas quebrarem as linhas economizaria muito espaço (além de me permitir selecionar/ocultar colunas).

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 tal permitir fornecer um modelo, por exemplo, definindo uma variável de ambiente DOCKER_PS_FORMAT com columnname:width :modifier, columnname:width :modifier, ...
onde modifier pode permitir configurações adicionais como no-trunc , full (por exemplo, para ID de contêiner) ou short para CREATED onde ~1h pode ser uma forma abreviada de About an hour ago .

Eu escrevi esta função bash/zsh no meu ~/.bashrc para exibir melhor a saída de docker ps , você pode ocultar ou reordenar as colunas:

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 $@; }

Hack de solução alternativa. Modifique quais $cols[x] você deseja manter conforme desejado.

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

Não seria mais fácil ter algo como:

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

e todos poderiam usar o apelido docker ps .

Obrigado, @caiguanhao. Solução provisória inteligente. Adicionado como um plugin Tackle para a concha de peixe.

Pessoal, acabei de fazer uma pequena melhoria no código do @caiguanhao para poder escolher quais colunas mostrar. Quando você tem um contêiner que expõe muitas portas (como o serviço Consul, que expõe 5 ou 6 portas e pode fazer até um estouro de tela de 300 caracteres), é bom ter um comando para mostrar todas as colunas, exceto essas portas, e depois outro que mostra apenas o nome dos contêineres e suas portas (adicionei essas opções como novos comandos por padrão):

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

Uma mudança simples que ajudaria um pouco é reduzir o espaçamento entre as colunas CONTAINER ID e IMAGE. As outras colunas são todas separadas por 3 espaços, mas essas duas são separadas por 8.

Meus 5 centavos até que eles tornem o 'docker ps' legível:

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

Vamos ver alguma atualização sobre isso?
docker ps é o comando mais comum que eu acho. Espero que não seja tão difícil nos dar a opção de filtrar colunas para mostrar.
(Eu esperaria algo como que )

dibs

Como @AntouanK disse e @wpp já sugeriu, um sinalizador de colunas seria preferido para a maioria das situações

Acho que # 10255 deve resolver isso.

@duglin Isso torna o padrão mais curto? Eu gostaria de manter isso aberto se não.

@bfirsh bom ponto, não, não mudaria o padrão. Mas não tenho certeza se podemos alterar o padrão até v2 (se/quando for) porque quebraríamos os clientes existentes se o fizéssemos.

mesmo aqui. talvez algum mecanismo inteligente que selecione colunas padrão exibidas aplicando limites a ENV['COLUMNS']?

Eu concordo com https://github.com/docker/docker/issues/7477#issuecomment -70243594, apenas nos dê a opção de escolher as colunas.

Também voto na opção https://github.com/docker/docker/issues/7477#issuecomment -70243594.
docker ps seria docker ps --columns=id,image,command,created,status,ports,name e poderia ser facilmente implementar mais colunas como ip como alguns usuários queriam https://github.com/docker/docker/issues/8786

+1 para --colunas

Como solução alternativa, combino docker ps -q com docker inspect --format :

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

Você precisa se aprofundar na saída do docker inspect e do golang templates, mas é quase infinitamente configurável.

@jafcrocker Que legal. Talvez possamos fazer uma essência pública para manter lá uma coleção de soluções alternativas como esta? Até conseguirmos alguns sinalizadores para personalizar a saída corretamente...

acabamos de mesclar o #14699 que permite executar docker ps --format ... para alterar a saída do ps. Você também pode definir um formato padrão, se quiser, confira esta captura de tela:

Vou encerrar este problema como corrigido. Por favor, sinta-se à vontade para experimentar e deixe-nos saber o que você pensa.

Para aqueles que desejam experimentá-lo, as compilações "mestre" podem ser encontradas em https://master.dockerproject.org e esse recurso deve estar disponível em breve (se ainda não estiver)

Embora o --format seja uma adição muito boa, não acho que isso resolva o problema principal. Quase todas as ferramentas de linha de comando que uso diariamente lidam com terminais de tamanho variável corretamente. A maioria olhando para a variável de ambiente $COLUMNS e exibindo o texto apropriado.

Por exemplo, ps aux em um terminal 80x24:

E em um terminal 137x24:

Ele altera a largura da coluna e encurta o comando para que tudo se encaixe perfeitamente em uma linha. Tudo para legibilidade e fácil de analisar para um ser humano.

Claro, eu posso escrever um bash wrapper que aplicará diferentes opções de formatação dependendo de $COLUMNS mas começa a soar muito hacky e algo que eu acho que deveria ser o comportamento padrão para qualquer programa de linha de comando. Lamento dizer, a saída do docker é confusa e difícil de ler.

Existe uma razão para isso não ser feito? Alguma limitação em alguma biblioteca ou uma decisão de sua parte? Preciso saber se isso é algo que vale a pena considerar para corrigir em um PR, ou talvez eu esteja latindo para a árvore errada.

@nsg : De acordo - a saída padrão ainda pode ser melhorada.

Houve alguma atualização sobre este assunto?

Portanto, por qualquer motivo, os hashes de imagem não são mais truncados na saída ps. Eu já tive que tornar meu terminal ultra-amplo (tomando toda a tela) apenas para tornar o docker utilizável no passado, agora isso não é mais suficiente. A partir de 1.7.1, cada linha tem cerca de 200 colunas de largura. Quem usa um terminal tão largo?

Eu tenho brincado um pouco com isso.

A remoção de ID e criado nos leva um pouco até lá:

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"

Ainda muito tempo embora. Podemos ignorar 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"

Mas ainda um pouco longo. Talvez seja necessária alguma criatividade para encurtar o status... algo analisável/scannable, mas ainda curto... Exit (2) 23s ago talvez?

Embora o comando possa ser encurtado, também precisaríamos encurtar qualquer outra coisa para garantir que pelo menos _some_ do comando seja mostrado. Não é possível encurtar o nome. A imagem talvez possa receber um "..." quando for truncada. O mesmo para portas longas.

Pensamentos?

Alguns hacks estão aqui: https://github.com/docker/docker/compare/master...bfirsh :7477-shorter-ps

@bfirsh Acho que você está no

Se você alterar o Status (como você disse) para 23s em vez de 23s e truncar a coluna de imagens e portas, deve ser curto o suficiente.

@bfirsh você está começando a trabalhar na visualização padrão? Você está pensando na opção --format algumas pessoas estão falando?

Além disso, poderíamos usar s vez de sec e m vez de mins

@aanm já temos o --format no docker 1.8. Você também pode alterar o comportamento padrão do ps no arquivo de configuração do cliente adicionando algo assim:

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

Você pode definir seu padrão com o formato que preferir.

Muitas vezes, preciso ver o nome do contêiner atual, para executar o próximo docker exec para anexar.

então, espero que se conseguir mover NAMES depois de IMAGE , fique bom, não preciso mais de configuração.

Obrigado.

Problema no docker 1.8.1 (fc21)
--format não sabe sobre nomes de contêineres.

docker ps --format "{{.ID}}t{{.Image}}t{{.CreatedAt}}t{{.RunningFor}}t{{.Status}}t{{.Name}}" -a
Erro de análise de modelo: modelo: :1:64: executando "" em <.Name>: o nome não é um campo do tipo struct *ps.containerContext

Até agora usando:
janela de encaixe ps -a | perl -ne 'chomp; @cols = dividir /s{2,}/, $_; $nome=pop @cols; printf "%-28s %-20s %-20s %-30sn", $nome, $cols[1], $cols[3], $cols[4]'

@parf o espaço reservado é realmente chamado Names :

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

obrigado a @caiguanhao pela inspiração.

só estou deixando isso aqui:

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

Legal @GottZ , obrigado por compartilhar!

@thaJeztah Acabei de

Enquanto isso, minha abordagem com 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 por que não simplesmente;

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

Isso já foi confirmado e liberado. Eu não entendo, por que isso ainda está aberto?

@thaJeztah você está certo, obrigado :)

@ovidiub13 principalmente por causa de https://github.com/docker/docker/issues/7477#issuecomment -123898874

sim isso incomoda..

Normalmente, estou bem apenas truncar o ps padrão na largura da coluna do terminal:

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

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

Este problema ainda existe infelizmente. De qualquer forma, uma solução alternativa é colocar o abaixo (testado no Ubuntu) em seu .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'

Correr watchdocker dá:

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 }}' lhe dará isso sem fazer todas aquelas chamadas de API para cada contêiner.
Além disso, você pode colocar isso em ~/.docker/config.json para torná-lo o formato padrão

@ cpuguy83 qual versão suporta isso? Eu nunca consegui fazer isso funcionar, nem no trabalho ou em casa. Seria legal se nos documentos fosse mencionado qual versão suporta o quê.

@Pithikos 1.8 ou 1.9, não tenho certeza.

ajustar docker ps/imagens a 80 colunas

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

dibs

o uso correto é com a palavra-chave "table" na string de formato, isso lhe dará uma boa formatação espaçada docker ps -a --format="table {{.ID}}\t{{.Names}}\t{{.Image}}\t{{.Command}}\t{{.Status}}"

Estou fechando este porque parece que o sinalizador --format para ps está resolvendo o problema. Obrigado a todos!

Esta questão talvez não tenha sido bem nomeada. Ainda resta que o _default_ para comandos deve ter 80 caracteres de largura. Feliz por isso ser fechado, porque não é tão importante.

--format não parece bem o suficiente.
https://docs.docker.com/engine/reference/commandline/ps/#/formatting

que tal adicionar opção para exibir o resultado verticalmente, como select * from foobar\G no MySQL

Normalmente, eu só quero saber quais contêineres estão em execução (e por quanto tempo).

Isso faz o truque para mim:

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

Melhor ainda, eu o envolvi em um alias muito fácil de lembrar:

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

Aqui está uma amostra da saída:

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

Você pode aprender mais sobre o comando --format aqui:
https://docs.docker.com/engine/reference/commandline/ps/

Espero que ajude alguém 😃

@joshmedeski você também pode armazenar sua formatação preferida em um arquivo de configuração, para que seja usado como padrão; https://docs.docker.com/engine/reference/commandline/cli/#/configuration -files

No espírito de salvar pressionamentos de tecla, aqui está o pequeno script bash que escrevi para obter uma lista de argumentos, construir a string do modelo go e executar o comando docker ps para fornecer exibição imediata de quaisquer colunas desejadas em qualquer ordem. Colocar a configuração em um arquivo não é dinâmico o suficiente - acho que ter um conjunto de colunas um momento e um conjunto diferente um momento depois é bastante útil. O script está aqui , espero que seja útil para alguém. Saúde - 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)

coloque isso em seu ~/.docker/config.json
{ "psFormat": "table {{.Names}}\\t{{.Image}}\\t{{.RunningFor}} ago\\t{{.Status}}\\t{{.Command}}", "imagesFormat": "table {{.Repository}}\\t{{.Tag}}\\t{{.ID}}\\t{{.Size}}" }

E modifique ao seu gosto. Para mim, o problema sempre foi o nome da imagem longa (já que continha o nome do meu repositório pessoal para minhas imagens personalizadas)

todos que estão procurando um docker ps melhor devem conferir isso:
https://github.com/moncho/dry

Hack de solução alternativa. Modifique quais $cols[x] você deseja manter conforme desejado.

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

Obrigado.

Isso era tudo que eu precisava:
docker ps | perl -ne '<strong i="12">@cols</strong> = split /\s{2,}/, $_; printf "%30s %20s %20s", $cols[1], $cols[4], $cols[6]'

dando NOMES DE STATUS DE IMAGEM
em colunas bem alinhadas

EDITAR

é melhor criar um alias bash com algo assim:

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

Observe o formato "tabela"

Hack de solução alternativa. Modifique quais $cols[x] você deseja manter conforme desejado.

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

Isso é incrível, thnx

@nagracks se você quiser esse formato como padrão, eu recomendo usar a abordagem --format (que pode ser armazenada em seu arquivo de configuração ~/.docker/config.json )

Se eu modificar meu arquivo .docker/config.json com algo personalizado assim:

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

Como posso usar o comando docker ps para visualizar o formato padrão? Eu tentei docker ps --format "" , mas ainda usava a configuração.

Usar docker ps --format=table deve fornecer o formato de tabela padrão

Eu realmente apreciaria se houvesse uma versão menos detalhada da saída disponível por padrão, sem ter que lembrar qual é a sintaxe de formatação da tabela ou quais são os nomes das variáveis ​​no contexto de formatação. Mesmo se o padrão fosse mantido como está, um sinalizador para uma versão _pré-formatada_ menos detalhada seria útil.

Quanto a quais informações podem ser reduzidas de uma versão menos detalhada, aqui estão meus dois centavos:

• Nome e ID para a maioria dos usos servem ao mesmo propósito, e esse pode ser eliminado.
• A data e hora da criação é provavelmente algo que você ficaria bem em ser omitido da saída menos detalhada
• Eu também ficaria bem em omitir portas da saída menos detalhada

No meu caso de uso, geralmente só quero procurar o nome do contêiner no qual estarei executando alguns outros comandos (por exemplo, em um nó de servidor remoto), e ter a saída agrupada em várias linhas torna difícil descobrir o nome exato do contêiner no qual estou interessado.

Estou um pouco desapontado que a solução "aprovada" aqui é "apenas configure um alias com --format parâmetro", como se você sempre estivesse executando esses comandos em ambientes onde você tem seu alias definido, ou lembre-se da sintaxe de formatação e variáveis ​​de contexto

Eu ainda me deparo com esse problema diariamente, FWIW. Minha saída atual de docker ps -a tem _180 caracteres de largura_ -- mais da metade da minha tela 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

Não se deve esperar que o usuário médio apelide seu comando docker ps apenas para torná-lo legível em um terminal de tamanho razoável. Talvez não precise ser tão pequeno quanto 80 caracteres, mas certamente não deve ser 180 caracteres.

Estou tentado a abrir um pull request como um espantalho. 😏