docker-run - Online na nuvem

PROGRAMA:

NOME

docker-run - executa um comando em um novo contêiner

SINOPSE

docker corrida [-a|--anexar[=[]]] [--add-host[=[]]] [--peso-preto[=[BLKIO-PESO]]]
[--dispositivo de peso-blkio[=[]]] [--cpu-shares[=0]] [--cap-adicionar[=[]]] [--cap-drop[=[]]]
[--cgroup-pai[=CGROUP-PATH]] [--cidfile[=arquivo cid]] [--cpu-período[=0]] [--cpu-cota[=0]]
[--cpuset-cpus[=CPUSET-CPU]] [--cpuset-mems[=CPUSET-MEMS]] [-d|--separar]
[--detach-keys[=[]]] [--dispositivo[=[]]] [--dispositivo-leitura-bps[=[]]] [--device-read-iops[=[]]]
[--device-write-bps[=[]]] [--device-write-iops[=[]]] [--dns[=[]]] [--dns-opt[=[]]]
[--dns-pesquisa[=[]]] [-e|--env[=[]]] [--ponto de entrada[=PONTO DE ENTRADA]] [--env-arquivo[=[]]]
[--expor[=[]]] [--grupo-adicionar[=[]]] [-h|--nome de anfitrião[=NOME DE ANFITRIÃO]] [--Socorro] [-i|--interativo]
[--ip[=ENDEREÇO ​​IPv4]] [--ip6[=ENDEREÇO ​​IPv6]] [--ipc[=IPC]] [--isolamento[=omissão]]
[--kernel-memória[=MEMÓRIA DO NÚCLEO]] [-l|--rótulo[=[]]] [--label-arquivo[=[]]] [--ligação[=[]]]
[--log-driver[=[]]] [--log-opt[=[]]] [-m|--memória[=MEMÓRIA]] [--endereço MAC[=ENDEREÇO ​​MAC]]
[- reserva de memória[=RESERVA DE MEMÓRIA]] [- troca de memória[=LIMITE]]
[- troca de memória[=MEMÓRIA-TROCA]] [--nome[=NOME]] [--internet[="Ponte"]]
[--net-alias[=[]]] [--oom-kill-disable] [--oom-pontuação-adj[=0]] [-P|--publicar-tudo]
[-p|--publicar[=[]]] [--pid[=[]]] [--privilegiado] [--somente leitura] [--reiniciar[=REINICIAR]] [--rm]
[--security-opt[=[]]] [--sinal de parada[=SINAL]] [--shm-tamanho[=[]]] [--sig-proxy[=verdadeiro]]
[-t|--tty] [--tmpfs[=[CONTAINER-DIR [: ]]] [-u|--do utilizador[=USUÁRIO]] [--ulimit[=[]]]
[--uts[=[]]] [-v|--volume[=[[HOST-DIR:] CONTAINER-DIR [: OPÇÕES]]]]
[--driver de volume[=DRIVER]] [--volumes-de[=[]]] [-w|--workdir[=DIRTRABALHO]] IMAGEM [COMANDO]
[ARG ...]

DESCRIÇÃO

Execute um processo em um novo contêiner. docker corrida inicia um processo com seu próprio sistema de arquivos,
sua própria rede e sua própria árvore de processo isolada. A IMAGEM que inicia o processo
pode definir padrões relacionados ao processo que será executado no contêiner, o
rede para expor e muito mais, mas docker corrida dá o controle final ao operador ou
administrador que inicia o contêiner a partir da imagem. Por essa razão docker corrida tem mais
opções do que qualquer outro comando do Docker.

Se a IMAGEM ainda não estiver carregada, então docker corrida irá puxar a IMAGEM, e todas as imagens
dependências, do repositório da mesma forma executando docker puxar IMAGEM, antes disso
inicia o contêiner a partir dessa imagem.

OPÇÕES

-a, --anexar= []
Anexe a STDIN, STDOUT ou STDERR.

No modo de primeiro plano (o padrão quando -d não é especificado), docker corrida pode começar o
processo no contêiner e anexar o console à entrada e saída padrão do processo,
e erro padrão. Pode até fingir ser um TTY (isto é o que a maioria das linhas de comando
executáveis ​​esperados) e transmitir sinais. o -a opção pode ser definida para cada um dos stdin,
stdout e stderr.

--add-host= []
Adicionar um mapeamento host-a-IP personalizado (host: ip)

Adicione uma linha a / etc / hosts. O formato é hostname: ip. o --add-host opção pode ser definida
várias vezes.

--peso-preto=0
O peso do bloco IO (peso relativo) aceita um valor de peso entre 10 e 1000.

--dispositivo de peso-blkio= []
Peso IO do bloco (peso relativo do dispositivo, formato: DEVICE_NAME: WEIGHT).

--cpu-shares=0
Compartilhamento de CPU (peso relativo)

Por padrão, todos os contêineres obtêm a mesma proporção de ciclos de CPU. Essa proporção pode ser
modificado ao alterar a ponderação de compartilhamento da CPU do contêiner em relação à ponderação de todos
outros contêineres em execução.

Para modificar a proporção do padrão de 1024, use o --cpu-shares sinalizar para definir o
ponderação de 2 ou superior.

A proporção só se aplicará quando processos com uso intensivo de CPU estiverem em execução. Quando as tarefas em
um contêiner está ocioso, outros podem usar o tempo restante da CPU. O valor real
de tempo de CPU irá variar dependendo do número de contêineres em execução no sistema.

Por exemplo, considere três contêineres, um tem uma cpu-share de 1024 e dois outros têm um
configuração de cpu-share de 512. Quando os processos em todos os três contêineres tentam usar 100% de
CPU, o primeiro contêiner receberia 50% do tempo total da CPU. Se você adicionar um quarto
contêiner com cpu-share de 1024, o primeiro contêiner obtém apenas 33% da CPU. o
os demais contêineres recebem 16.5%, 16.5% e 33% da CPU.

Em um sistema com vários núcleos, as partes do tempo da CPU são distribuídas por todos os núcleos da CPU. Ainda que
um contêiner é limitado a menos de 100% do tempo de CPU, ele pode usar 100% de cada indivíduo
Núcleo da CPU.

Por exemplo, considere um sistema com mais de três núcleos. Se você iniciar um contêiner {C0}
com -c = 512 executando um processo e outro contêiner {C1} com -c = 1024 correndo dois
processos, isso pode resultar na seguinte divisão de compartilhamentos de CPU:

Compartilhamento de CPU do contêiner PID
100 {C0} 0 100% da CPU0
101 {C1} 1 100% da CPU1
102 {C1} 2 100% da CPU2

--cap-adicionar= []
Adicionar recursos do Linux

--cap-drop= []
Abandone os recursos do Linux

--cgroup-pai= ""
Caminho para cgroups sob o qual o cgroup para o contêiner será criado. Se o caminho
não é absoluto, o caminho é considerado relativo ao caminho cgroups do init
processo. Os cgroups serão criados se ainda não existirem.

--cidfile= ""
Grave o ID do contêiner no arquivo

--cpu-período=0
Limite o período de CPU CFS (Completely Fair Scheduler)

Limite o uso da CPU do contêiner. Este sinalizador diz ao kernel para restringir a CPU do contêiner
uso para o período que você especificar.

--cpuset-cpus= ""
CPUs nas quais permitir a execução (0-3, 0,1)

--cpuset-mems= ""
Nós de memória (MEMs) nos quais permitir a execução (0-3, 0,1). Efetivo apenas em NUMA
sistemas.

Se você tiver quatro nós de memória em seu sistema (0-3), use --cpuset-mems = 0,1 então processos
em seu contêiner do Docker usará apenas a memória dos dois primeiros nós de memória.

--cpu-cota=0
Limitar a cota de CPU CFS (Completely Fair Scheduler)

Limite o uso da CPU do contêiner. Por padrão, os contêineres são executados com o recurso completo da CPU.
Este sinalizador diz ao kernel para restringir o uso da CPU do contêiner para a cota que você especificar.

-d, --separar=verdadeiro|falso
Modo separado: execute o contêiner em segundo plano e imprima a nova ID do contêiner. o
padrão é falso.

A qualquer momento você pode correr docker ps no outro shell para ver uma lista dos
containers. Você pode reconectar a um contêiner separado com docker anexar. Se você escolher
executar um contêiner no modo desanexado, então você não pode usar o -rm opção.

Quando conectado no modo tty, você pode separar do contêiner (e deixá-lo rodando)
usando uma sequência de teclas configurável. A sequência padrão é CTRL-p CTRL-q. Você configura
a sequência chave usando o --detach-keys opção ou um arquivo de configuração. Ver
config-json(5) para documentação sobre como usar um arquivo de configuração.

--detach-keys= ""
Substitua a sequência de chaves para desanexar um contêiner. O formato é um único caractere [aZ]
or ctrl- onde é um dos: AZ, @, ^, [, , or _.

--dispositivo= []
Adicione um dispositivo host ao contêiner (por exemplo, --device = / dev / sdc: / dev / xvdc: rwm)

--dispositivo-leitura-bps= []
Limite a taxa de leitura de um dispositivo (por exemplo --device-read-bps = / dev / sda: 1mb)

--device-read-iops= []
Limite a taxa de leitura de um dispositivo (por exemplo --device-read-iops = / dev / sda: 1000)

--device-write-bps= []
Limitar a taxa de gravação para um dispositivo (por exemplo --device-write-bps = / dev / sda: 1mb)

--device-write-iops= []
Limitar taxa de gravação aa dispositivo (por exemplo --device-write-iops = / dev / sda: 1000)

--dns-pesquisa= []
Defina domínios de pesquisa DNS personalizados (use --dns-search =. Se não quiser definir a pesquisa
domínio)

--dns-opt= []
Definir opções de DNS personalizadas

--dns= []
Definir servidores DNS personalizados

Esta opção pode ser usada para substituir a configuração DNS passada para o contêiner.
Normalmente, isso é necessário quando a configuração do DNS do host é inválida para o contêiner
(por exemplo, 127.0.0.1). Quando este for o caso, --dns sinalizadores são necessários para cada execução.

-e, --env= []
Definir variáveis ​​de ambiente

Esta opção permite que você especifique variáveis ​​de ambiente arbitrárias que estão disponíveis para
o processo que será lançado dentro do container.

--ponto de entrada= ""
Sobrescrever o ENTRYPOINT padrão da imagem

Esta opção permite que você substitua o ponto de entrada padrão da imagem que está definido no
Dockerfile. O ENTRYPOINT de uma imagem é semelhante a um COMANDO porque especifica o que
executável para ser executado quando o contêiner é iniciado, mas é (propositalmente) mais difícil de
sobrepor. O ENTRYPOINT dá a um contêiner sua natureza ou comportamento padrão, de modo que quando
você definir um ENTRYPOINT, poderá executar o contêiner como se fosse aquele binário, completo com
opções padrão, e você pode passar mais opções por meio do COMANDO. Mas, às vezes um
operador pode querer executar outra coisa dentro do contêiner, para que você possa substituir o
ENTRYPOINT padrão em tempo de execução usando um --ponto de entrada e uma string para especificar o novo
PONTO DE ENTRADA.

--env-arquivo= []
Leia em um arquivo delimitado por linha de variáveis ​​de ambiente

--expor= []
Expor uma porta ou um intervalo de portas (por exemplo, --expose = 3300-3310) informa ao Docker que o
o contêiner escuta nas portas de rede especificadas no tempo de execução. Docker usa esta informação
para interconectar contêineres usando links e para configurar o redirecionamento de porta no sistema host.

--grupo-adicionar= []
Adicionar grupos adicionais para administrar como

-h, --nome de anfitrião= ""
Nome do host do contêiner

Define o nome do host do contêiner que está disponível dentro do contêiner.

--Socorro
Imprimir declaração de uso

-i, --interativo=verdadeiro|falso
Mantenha o STDIN aberto, mesmo se não estiver conectado. O padrão é falso.

Quando definido como verdadeiro, mantém o stdin aberto, mesmo se não estiver conectado. O padrão é falso.

--ip= ""
Define o endereço IPv4 da interface do contêiner (por exemplo, 172.23.0.9)

Só pode ser usado em conjunto com --internet para redes definidas pelo usuário

--ip6= ""
Define o endereço IPv6 da interface do contêiner (por exemplo, 2001: db8 :: 1b99)

Só pode ser usado em conjunto com --internet para redes definidas pelo usuário

--ipc= ""
O padrão é criar um namespace IPC privado (POSIX SysV IPC) para o contêiner
'recipiente: ': reutiliza outro container compartilhado
memória, semáforos e filas de mensagens
'host': use a memória compartilhada do host, semáforos e mensagem
filas dentro do contêiner. Observação: o modo host dá ao contêiner acesso total ao local
memória compartilhada e, portanto, considerada insegura.

--isolamento="omissão"
O isolamento especifica o tipo de tecnologia de isolamento usada pelos contêineres.

-l, --rótulo= []
Definir metadados no contêiner (por exemplo, --label com.example.key = value)

--kernel-memória= ""
Limite de memória do kernel (formato: [ ], onde unidade = b, k, m ou g)

Limita a memória do kernel disponível para um contêiner. Se um limite de 0 for especificado (não
utilização --kernel-memória), a memória do kernel do contêiner não é limitada. Se você especificar um
limite, pode ser arredondado para um múltiplo do tamanho da página do sistema operacional e o
o valor pode ser muito grande, milhões de trilhões.

--label-arquivo= []
Leia em um arquivo de etiquetas delimitado por linha

--ligação= []
Adicione um link a outro contêiner na forma de : alias ou apenas no
caso em que o alias irá corresponder ao nome

Se a operadora usa --ligação ao iniciar o novo contêiner do cliente, o cliente
o contêiner pode acessar a porta exposta por meio de uma interface de rede privada. Docker irá definir
algumas variáveis ​​de ambiente no contêiner do cliente para ajudar a indicar qual interface e
porta para usar.

--log-driver="arquivo json|syslog|diário|gel|fluente|awslogs|idiota|Nenhum"
Driver de registro para contêiner. O padrão é definido pelo daemon --log-driver bandeira.
Aviso: docker toras comando funciona apenas para o arquivo json e
diário drivers de registro.

--log-opt= []
Opções específicas do driver de registro.

-m, --memória= ""
Limite de memória (formato: [ ], onde unidade = b, k, m ou g)

Permite restringir a memória disponível para um contêiner. Se o host suporta troca
memória, então o -m a configuração da memória pode ser maior do que a RAM física. Se um limite de 0 for
especificado (não usando -m), a memória do contêiner não é limitada. O limite real pode ser
arredondado para um múltiplo do tamanho da página do sistema operacional (o valor seria muito
grande, isso significa milhões de trilhões).

- reserva de memória= ""
Limite flexível de memória (formato: [ ], onde unidade = b, k, m ou g)

Depois de definir a reserva de memória, quando o sistema detecta contenção de memória ou pouca memória,
os contêineres são forçados a restringir seu consumo à sua reserva. Então você deveria
sempre defina o valor abaixo --memória, caso contrário, o limite rígido terá precedência. Por
padrão, a reserva de memória será igual ao limite de memória.

- troca de memória= "LIMIT"
Um valor limite igual a memória mais troca. Deve ser usado com o -m (--memória) bandeira. o
trocar LIMITE deve sempre ser maior do que -m (--memória) valor.

O formato de LIMITE is [ ]. Unidade pode ser b (byte), k (quilobytes), m
(megabytes), ou g (gigabytes). Se você não especificar uma unidade, b é usado. Defina LIMIT para -1 para
permitir troca ilimitada.

--endereço MAC= ""
Endereço MAC do contêiner (por exemplo, 92: d0: c6: 0a: 29: 33)

Lembre-se de que o endereço MAC em uma rede Ethernet deve ser exclusivo. O link-local IPv6
o endereço será baseado no endereço MAC do dispositivo de acordo com RFC4862.

--nome= ""
Atribuir um nome ao contêiner

O operador pode identificar um contêiner de três maneiras:
Identificador longo UUID
(“f78375b1c487e03c9438c729345e54db9d20cfa2ac1fc3494b6eb60872e74778”)
Identificador curto UUID (“f78375b1c487”)
Nome (“jonah”)

Os identificadores UUID vêm do daemon Docker e, se um nome não for atribuído ao
recipiente com --nome então o daemon também irá gerar um nome de string aleatório. O nome é
útil ao definir links (veja --ligação) (ou qualquer outro lugar que você precise para identificar um
recipiente). Isso funciona para os contêineres do Docker em primeiro e segundo plano.

--internet="ponte"
Defina o modo de rede para o contêiner
'bridge': cria uma pilha de rede no Docker padrão
ponte
'none': sem rede
'recipiente: ': reutilizar a rede de outro contêiner
pilha
'host': use a pilha de rede do host Docker. Nota: o host
modo dá ao contêiner acesso total aos serviços do sistema local, como D-bus e é
portanto, considerado inseguro.
' | ': conectar-se a um definido pelo usuário
rede

--net-alias= []
Adicionar alias com escopo de rede para o contêiner

--oom-kill-disable=verdadeiro|falso
Se deve desativar o OOM Killer para o contêiner ou não.

--oom-pontuação-adj= ""
Ajuste as preferências OOM do host para contêineres (aceita -1000 a 1000)

-P, --publicar-tudo=verdadeiro|falso
Publique todas as portas expostas em portas aleatórias nas interfaces do host. O padrão é falso.

Quando definido como true, publique todas as portas expostas nas interfaces do host. O padrão é falso.
Se o operador usar -P (ou -p), o Docker tornará a porta exposta acessível no
host e as portas estarão disponíveis para qualquer cliente que possa acessar o host. Ao usar -P,
O Docker ligará qualquer porta exposta a uma porta aleatória no host dentro de um efêmero porta
alcance definido por / proc / sys / net / ipv4 / ip_local_port_range. Para encontrar o mapeamento entre o
portas do host e as portas expostas, use docker porta.

-p, --publicar= []
Publique a porta de um contêiner, ou intervalo de portas, para o host.

Formato: ip: hostPort: containerPort | ip :: containerPort | hostPort: containerPort |
containerPort HostPort e containerPort podem ser especificados como um intervalo de portas. Quando
especificando intervalos para ambos, o número de portas de contêiner no intervalo deve corresponder ao
número de portas de host no intervalo. (por exemplo, docker corrida -p 1234-1236: 1222-1224 --nome
isso funciona -t busybox mas não docker corrida -p 1230-1236: 1230-1240 --nome
RangeContainerPortsMaiorThanRangeHostPorts -t busybox) Com ip: docker corrida -p
127.0.0.1:$HOSTPORT:$CONTAINERPORT --nome CONTENTOR -t alguma imagem Use docker porta ver
o mapeamento real: docker porta CONTENTOR $ CONTAINERPORT

--pid=hospedeiro
Defina o modo PID para o recipiente
hospedeiro: use o namespace PID do host dentro do contêiner.
Nota: o modo host dá ao contêiner acesso total ao PID local e é, portanto,
considerado inseguro.

--uts=hospedeiro
Defina o modo UTS para o contêiner
hospedeiro: use o namespace UTS do host dentro do contêiner.
Nota: o modo de host dá ao contêiner acesso para alterar o nome de host do host e é
portanto, considerado inseguro.

--privilegiado=verdadeiro|falso
Conceda privilégios estendidos a este contêiner. O padrão é falso.

Por padrão, os contêineres do Docker são "sem privilégios" (= false) e não podem, por exemplo, executar um
Daemon do Docker dentro do contêiner do Docker. Isso ocorre porque, por padrão, um contêiner não é
permissão para acessar quaisquer dispositivos. Um contêiner “privilegiado” tem acesso a todos os dispositivos.

Quando o operador executa docker corrida --privilegiado, O Docker permitirá o acesso a todos
dispositivos no host, bem como definir algumas configurações no AppArmor para permitir o contêiner
quase todos os mesmos acessos ao host que os processos executados fora de um contêiner no
hospedeiro.

--somente leitura=verdadeiro|falso
Monte o sistema de arquivos raiz do contêiner como somente leitura.

Por padrão, um contêiner terá seu sistema de arquivos raiz gravável, permitindo que os processos gravem
arquivos em qualquer lugar. Especificando o --somente leitura sinalizar o contêiner terá sua raiz
sistema de arquivos montado como somente leitura, proibindo qualquer escrita.

--reiniciar="não"
Política de reinicialização a ser aplicada quando um contêiner sai (não, em caso de falha [: max-retry], sempre,
a menos que parado).

--rm=verdadeiro|falso
Remova automaticamente o contêiner ao sair (incompatível com -d). O padrão é
falso.

--security-opt= []
Opções de segurança

"rótulo: usuário: USUÁRIO": define o usuário do rótulo para o contêiner
"label: role: ROLE": defina a função do rótulo para o recipiente
"label: type: TYPE": define o tipo de rótulo para o recipiente
"label: level: LEVEL": Defina o nível de rótulo para o recipiente
"label: disable": desativa o confinamento de rótulos para o contêiner

--sinal de parada=PRAZO META
Sinalize para parar um contêiner. O padrão é SIGTERM.

--shm-tamanho= ""
Tamanho de / dev / shm. O formato é .
número deve ser superior a 0. A unidade é opcional e pode ser b (byte), k (quilobytes),
m(megabytes), ou g (gigabytes).
Se você omitir a unidade, o sistema usará bytes. Se você omitir o tamanho inteiramente, o sistema
usos 64m.

--sig-proxy=verdadeiro|falso
O proxy recebeu sinais para o processo (apenas modo não-TTY). SIGCHLD, SIGSTOP e
SIGKILL não são procurados. O padrão é verdadeiro.

- troca de memória= ""
Ajuste o comportamento de troca de memória de um contêiner. Aceita um número inteiro entre 0 e 100.

-t, --tty=verdadeiro|falso
Aloque um pseudo-TTY. O padrão é falso.

Quando definido como verdadeiro, o Docker pode alocar um pseudo-tty e anexar à entrada padrão de qualquer
recipiente. Isso pode ser usado, por exemplo, para executar um shell interativo descartável. o
o padrão é falso.

A -t opção é incompatível com um redirecionamento da entrada padrão do cliente docker.

--tmpfs= [] Criar uma montagem tmpfs

Monte um sistema de arquivos temporário (tmpfs) montar em um contêiner, por exemplo:

$ docker run -d --tmpfs / Tmp: rw, tamanho = 787448k, modo = 1777 minha_imagem

Este comando monta um tmpfs at / Tmp dentro do contêiner. As opções de montagem suportadas são
o mesmo que o Linux padrão montar bandeiras. Se você não especificar nenhuma opção, os sistemas
usa as seguintes opções: rw, noexec, nosuid, nodev, size = 65536k.

-u, --do utilizador= ""
Define o nome de usuário ou UID usado e, opcionalmente, o nome do grupo ou GID para o especificado
comando.

Os exemplos a seguir são todos válidos:
--user [usuário | usuário: grupo | uid | uid: gid | usuário: gid | uid: group]

Sem este argumento, o comando será executado como root no contêiner.

--ulimit= []
Opções Ulimit

-v|--volume[=[[HOST-DIR:] CONTAINER-DIR [: OPÇÕES]]]
Crie uma montagem de ligação. Se você especificar, -v / HOST-DIR: / CONTAINER-DIR, Docker
montagens de ligação / HOST-DIR no hospedeiro para / CONTAINER-DIR no Docker
recipiente. Se 'HOST-DIR' for omitido, o Docker criará automaticamente o novo
volume no host. o OPÇÕES são uma lista delimitada por vírgulas e podem ser:

· [Rw | ro]

· [Z | Z]

· [[r] compartilhado|[r] escravo|[r] privado]

A CONTAINER-DIR deve ser um caminho absoluto, como / src / docs. O HOST-DIR pode ser um
caminho absoluto ou um nome valor. UMA nome o valor deve começar com um caractere alfanumérico,
seguido a-z0-9, _ (sublinhado), . (ponto final) ou - (hífen). Um caminho absoluto começa com
a / (barra).

Se você fornecer um HOST-DIR esse é um caminho absoluto, o Docker se encaixa no caminho que você
especificamos. Se você fornecer um nome, O Docker cria um volume nomeado por aquele nome. Por exemplo, a
você pode especificar qualquer um / foo or Foo para uma HOST-DIR valor. Se você fornecer o / foo valor,
Docker cria uma montagem de ligação. Se você fornecer o Foo especificação, o Docker cria um nome
volume.

Você pode especificar vários -v opções para montar uma ou mais montagens em um contêiner. Usar
essas mesmas montagens em outros contêineres, especifique o --volumes-de opção também.

Você pode adicionar : ro or : rw sufixo a um volume para montá-lo no modo somente leitura ou leitura e gravação,
respectivamente. Por padrão, os volumes são montados para leitura e gravação. Veja exemplos.

Sistemas de rotulagem como o SELinux exigem que rótulos adequados sejam colocados no conteúdo do volume
montado em um contêiner. Sem um rótulo, o sistema de segurança pode impedir os processos
executando dentro do contêiner de usar o conteúdo. Por padrão, o Docker não muda
os rótulos definidos pelo sistema operacional.

Para alterar um rótulo no contexto do contêiner, você pode adicionar um dos dois sufixos :z or :Z para
a montagem do volume. Esses sufixos dizem ao Docker para rotular novamente os objetos de arquivo no
volumes. o z opção informa ao Docker que dois contêineres compartilham o conteúdo do volume. Como um
resultado, o Docker rotula o conteúdo com um rótulo de conteúdo compartilhado. Rótulos de volume compartilhado permitem
todos os contêineres para ler / gravar conteúdo. o Z opção diz ao Docker para rotular o conteúdo com
uma etiqueta privada não compartilhada. Apenas o contêiner atual pode usar um volume privado.

Por padrão, os volumes montados em ligação são privado. Isso significa que todas as montagens feitas dentro do contêiner
não será visível no host e vice-a-versa. Pode-se mudar esse comportamento especificando um
propriedade de propagação de montagem de volume. Fazendo um volume compartilhado montagens feitas sob aquele volume
dentro do contêiner ficará visível no host e vice-a-versa. Fazendo um volume escravo permite
apenas uma forma de propagação de montagem, ou seja, as montagens feitas no host sob esse volume serão
visível dentro do contêiner, mas não ao contrário.

Para controlar a propriedade de propagação de montagem do volume, pode-se usar : [r] compartilhado, : [r] escravo or
: [r] privado bandeira de propagação. A propriedade de propagação pode ser especificada apenas para montagem em ligação
volumes e não para volumes internos ou volumes nomeados. Para que a propagação de montagem funcione
o ponto de montagem de origem (ponto de montagem onde o diretório de origem está montado) deve ter o direito
propriedades de propagação. Para volumes compartilhados, o ponto de montagem de origem deve ser compartilhado. E para
volumes escravos, a montagem de origem deve ser compartilhada ou escrava.

Use df para descobrir a montagem da fonte e, em seguida, use encontrar -o
ALVO, PROPAGAÇÃO para descobrir as propriedades de propagação da fonte
montar. Se encontrar utilitário não está disponível, então pode-se olhar a entrada de montagem para a fonte
ponto de montagem em / proc / self / mountinfo. Olhe para opcional Campos e ver se alguma propagação
propriedades são especificadas. compartilhado: X significa que a montagem é compartilhado, mestre: X significa que a montagem é escravo
e se nada está lá, isso significa que o monte está privado.

Para alterar as propriedades de propagação de um ponto de montagem, use montar comando. Por exemplo, se um
deseja vincular o diretório de origem de montagem / foo um pode fazer montar --ligar / foo / foo e montar
--Tornar privado --make-compartilhado / foo. Isso irá converter / foo em um compartilhado ponto de montagem.
Alternativamente, pode-se alterar diretamente as propriedades de propagação da montagem de origem. Dizer / is
montagem de fonte para / foo, então use montar --make-compartilhado / converter / em uma compartilhado montar.

Note: Ao usar o systemd para gerenciar o início e a parada do daemon do Docker, no
arquivo de unidade systemd, há uma opção para controlar a propagação de montagem para o Docker
daemon em si, chamado MontarFlags. O valor desta configuração pode fazer com que o Docker não
veja as mudanças de propagação de montagem feitas no ponto de montagem. Por exemplo, se este valor
is escravo, você pode não ser capaz de usar o compartilhado or compartilhado propagação em um volume.

--driver de volume= ""
Driver de volume do contêiner. Este driver cria volumes especificados a partir de
de um Dockerfile VOLUME instrução ou do docker corrida -v bandeira.
See docker-volume-create(1) para maiores detalhes.

--volumes-de= []
Montar volumes do (s) contêiner (es) especificado (s)

Monta volumes já montados de um contêiner de origem em outro
recipiente. Você deve fornecer o ID do contêiner da fonte. Compartilhar
um volume, use o --volumes-de opção ao correr
o contêiner de destino. Você pode compartilhar volumes, mesmo se o contêiner de origem
não está correndo.

Por padrão, o Docker monta os volumes no mesmo modo (leitura-gravação ou
somente leitura), uma vez que é montado no contêiner de origem. Opcionalmente, você
pode mudar isso adicionando o sufixo do ID do contêiner com o : ro or
: rw palavra chave.

Se a localização do volume do contêiner de origem se sobrepõe a
dados que residem em um contêiner de destino, então o volume se esconde
esses dados no alvo.

-w, --workdir= ""
Diretório de trabalho dentro do contêiner

O diretório de trabalho padrão para a execução de binários em um contêiner é a raiz
diretório (/). O desenvolvedor pode definir um padrão diferente com o Dockerfile WORKDIR
instrução. O operador pode substituir o diretório de trabalho usando o -w opção.

saída Status

O código de saída de docker corrida fornece informações sobre por que o contêiner não funcionou ou
porque saiu. Quando docker corrida sai com um código diferente de zero, os códigos de saída seguem o
chroot padrão, veja abaixo:

125 if que o erro is com Estivador demônio se

$ docker run --foo busybox; eco $?
# sinalizador fornecido, mas não definido: --foo
Veja 'docker run --help'.
125

126 if que o contida comando não podes be invocado

$ docker execute o busybox / Etc; eco $?
# exec: "/ Etc": permissão negada
docker: Resposta de erro do daemon: Comando contido não pôde ser invocado
126

127 if que o contida comando não podes be encontrado

$ docker executa o busybox foo; eco $?
# exec: "foo": arquivo executável não encontrado em $ PATH
docker: Resposta de erro do daemon: Comando contido não encontrado ou não existe
127

saída código of contida comando de outra forma

$ docker execute o busybox / Bin / sh -c 'saída 3'
# 3

EXEMPLOS

Corrida recipiente in somente leitura modo

Durante o desenvolvimento da imagem do contêiner, os contêineres geralmente precisam gravar no conteúdo da imagem.
Instalando pacotes em / usr, por exemplo. Na produção, os aplicativos raramente precisam
escreva para a imagem. Aplicativos de contêiner gravam em volumes se precisarem gravar em arquivo
sistemas em tudo. Os aplicativos podem se tornar mais seguros executando-os em modo somente leitura
usando a opção --read-only. Isso protege a imagem dos contêineres de modificações. Leitura
apenas os contêineres ainda podem precisar gravar dados temporários. A melhor maneira de lidar com isso é
montar diretórios tmpfs em / corre e / tmp.

# docker run --read-only --tmpfs / corre --tmpfs / Tmp -i -t fedora / bin / bash

Expor log mensagens da que o recipiente para que o hospedeiro log

Se você quiser que as mensagens registradas em seu contêiner apareçam na janela do host
syslog / journal então você deve ligar e montar o diretório / dev / log como segue.

# docker run -v / dev / log: / dev / log -i -t fedora / bin / bash

De dentro do contêiner, você pode testar isso enviando uma mensagem para o log.

(bash) # logger "Hello from my container"

Em seguida, saia e verifique o diário.

# Saída

# journalctl -b | grep ola

Isso deve listar a mensagem enviada ao logger.

Anexando para um or mais da STDIN, STDOUT, STDERR

Se você não especificar -a, o Docker anexará tudo (stdin, stdout, stderr) que você
gostaria de conectar em vez disso, como em:

# docker run -a stdin -a stdout -i -t fedora / bin / bash

compartilhando IPC entre containers

Usando shm_server.c disponível aqui: ⟨https: //www.cs.cf.ac.uk/Dave/C/node27.html⟩

ensaio --ipc = host modo:

O host mostra um segmento de memória compartilhada com 7 pids anexados, que é de httpd:

$ sudo ipcs-m

------ Segmentos de memória compartilhada --------
key shmid proprietário perms bytes nattch status
0x01128e25 0 raiz 600 1000 7

Agora execute um contêiner regular, e ele NÃO vê corretamente o segmento de memória compartilhada de
O hospedeiro:

$ docker run -it shm ipcs -m

------ Segmentos de memória compartilhada --------
key shmid proprietário perms bytes nattch status

Execute um contêiner com o novo --ipc = host opção, e agora vê o segmento de memória compartilhada
do host httpd:

$ docker run -it --ipc = host shm ipcs -m

------ Segmentos de memória compartilhada --------
key shmid proprietário perms bytes nattch status
0x01128e25 0 raiz 600 1000 7

ensaio --ipc = container: CONTAINERID modo:

Inicie um contêiner com um programa para criar um segmento de memória compartilhada:

$ docker run -it shm bash
$ sudo shm / shm_server
$ sudo ipcs-m

------ Segmentos de memória compartilhada --------
key shmid proprietário perms bytes nattch status
0x0000162e 0 raiz 666 27 1

Criar um segundo contêiner corretamente não mostra nenhum segmento de memória compartilhada do primeiro contêiner:

$ docker execute shm ipcs -m

------ Segmentos de memória compartilhada --------
key shmid proprietário perms bytes nattch status

Crie um terceiro contêiner usando a nova opção --ipc = contêiner: CONTAINERID, agora ele mostra o
segmento de memória compartilhada do primeiro:

$ docker run -it --ipc = container: ed735b2264ac shm ipcs -m
$ sudo ipcs-m

------ Segmentos de memória compartilhada --------
key shmid proprietário perms bytes nattch status
0x0000162e 0 raiz 666 27 1

Linkagem Containers

Note: Esta seção descreve a vinculação entre contêineres no padrão (ponte)
rede, também conhecido como "links legados". Usando --ligação em redes definidas pelo usuário usa
a descoberta baseada em DNS, que não adiciona entradas para / Etc / hosts, e não define
variáveis ​​de ambiente para descoberta.

O recurso de link permite que vários contêineres se comuniquem entre si. Por exemplo, um
O contêiner cujo Dockerfile expôs a porta 80 pode ser executado e nomeado da seguinte maneira:

# docker run --name = link-test -d -i -t fedora / httpd

Um segundo contêiner, neste caso denominado vinculador, pode se comunicar com o contêiner httpd,
chamado link-test, executando com o --link = :

# docker run -t -i --link = link-test: lt --name = linker fedora / bin / bash

Agora, o vinculador de contêiner está vinculado ao teste de link de contêiner com o alias lt. Executando o
env o comando no contêiner do vinculador mostra as variáveis ​​de ambiente
com o contexto LT (alias) (LT_)

#env
HOSTNAME = 668231cb0978
TERM = xterm
LT_PORT_80_TCP = tcp: //172.17.0.3: 80
LT_PORT_80_TCP_PORT = 80
LT_PORT_80_TCP_PROTO = tcp
LT_PORT = tcp: //172.17.0.3: 80
PATH =/ usr / local / sbin:/ usr / local / bin:/ usr / sbin:/ usr / bin:/ sbin:/ bin
PWD = /
LT_NAME = / linker / lt
SHLVL = 1
HOME = /
LT_PORT_80_TCP_ADDR = 172.17.0.3
_=/ usr / bin / env

Ao vincular dois contêineres, o Docker usará as portas expostas do contêiner para criar um
túnel seguro para o pai acessar.

Se um contêiner estiver conectado à rede de ponte padrão e ligado com outra
recipientes, então o recipiente do / Etc / hosts arquivo é atualizado com o contêiner vinculado
nome.

Note Uma vez que o Docker pode atualizar ao vivo o contêiner / Etc / hosts arquivo, pode haver
situações em que os processos dentro do contêiner podem acabar lendo um vazio ou
incompleto / Etc / hosts Arquivo. Na maioria dos casos, tentar a leitura novamente deve corrigir o
problema.

Mapeamento Portas para Externo Uso

A porta exposta de um aplicativo pode ser mapeada para uma porta do host usando o -p bandeira. Para
Por exemplo, uma porta 80 httpd pode ser mapeada para a porta 8080 do host usando o seguinte:

# docker run -p 8080: 80 -d -i -t fedora / httpd

Criar e Montagem a Data Volume Recipiente

Muitos aplicativos requerem o compartilhamento de dados persistentes em vários contêineres. Docker
permite criar um contêiner de volume de dados a partir do qual outros contêineres podem ser montados. Para
Por exemplo, crie um contêiner nomeado que contenha os diretórios / var / volume1 e / tmp / volume2.
A imagem precisará conter esses diretórios, portanto, algumas instruções RUN mkdir
pode ser necessário para sua imagem fedora-data:

# docker run --name = data -v / var / volume1 -v / tmp / volume2 -i -t fedora-data true
# docker run --volumes-from = data --name = fedora-container1 -i -t fedora bash

Vários parâmetros --volumes-from irão reunir vários volumes de dados de vários
containers. E é possível montar os volumes que vieram do contêiner DATA em
ainda outro contêiner através do contêiner intermediário fedora-container1, permitindo
abstrair a fonte de dados real dos usuários desses dados:

# docker run --volumes-from = fedora-container1 --name = fedora-container2 -i -t fedora bash

Montagem Externo Calculo de volumes e distâncias

Para montar um diretório de host como um volume de contêiner, especifique o caminho absoluto para o
diretório e o caminho absoluto para o diretório do contêiner separado por dois pontos:

# docker run -v / var / db: / data1 -i -t fedora bash

Ao usar o SELinux, esteja ciente de que o host não tem conhecimento da política do SELinux do contêiner.
Portanto, no exemplo acima, se a política SELinux for aplicada, o / var / db diretório é
não gravável no contêiner. Uma mensagem "Permission Denied" ocorrerá e um avc:
mensagem no syslog do host.

Para contornar isso, no momento de escrever esta página de manual, o seguinte comando precisa ser
executar para que a etiqueta de tipo de política SELinux adequada seja anexada ao host
diretório:

# chcon -Rt svirt_sandbox_file_t / var / db

Agora, a gravação no volume / data1 no contêiner será permitida e as alterações serão
também se refletirá no host em / var / db.

utilização alternativa segurança marcação

Você pode substituir o esquema de rotulagem padrão para cada recipiente, especificando o
--security-opt bandeira. Por exemplo, você pode especificar o nível MCS / MLS, um requisito para MLS
sistemas. Especificar o nível no comando a seguir permite que você compartilhe o mesmo
conteúdo entre os contêineres.

# docker run --security-opt rótulo: nível: s0: c100, c200 -i -t fedora bash

Um exemplo de MLS pode ser:

# docker run --security-opt rótulo: nível: TopSecret -i -t rhel7 bash

Para desativar a rotulagem de segurança para este contêiner em vez de executar com o --permissivo
sinalizar, use o seguinte comando:

# docker run --security-opt rótulo: disable -i -t fedora bash

Se quiser uma política de segurança mais rígida nos processos de um contêiner, você pode especificar
um tipo alternativo para o contêiner. Você pode executar um contêiner que só tem permissão para
escute nas portas Apache executando o seguinte comando:

# docker run --security-opt rótulo: tipo: svirt_apache_t -i -t centos bash

Observação:

Você teria que escrever uma política definindo um svirt_apache_t tipo.

Configuração dispositivo peso

Se você deseja definir / Dev / sda peso do dispositivo para 200, você pode especificar o peso do dispositivo por
--dispositivo de peso-blkio bandeira. Use o seguinte comando:

# docker run -it --blkio-weight-device "/ dev / sda: 200" ubuntu

Especificar isolamento tecnologia para recipiente (--isolamento)

Esta opção é útil em situações em que você está executando contêineres Docker no Microsoft
Janelas. o --isolamento opção define a tecnologia de isolamento de um contêiner. No Linux,
o único suportado é o omissão opção que usa namespaces do Linux. Esses dois comandos
são equivalentes no Linux:

$ docker run -d busybox topo
$ docker run -d --isolation padrão busybox top

No Microsoft Windows, pode assumir qualquer um destes valores:

· omissão: Use o valor especificado pelo daemon do Docker --exec-opt . Se o demônio parece
não especificar uma tecnologia de isolamento, o Microsoft Windows usa processo como seu padrão
valor.

· processo: Apenas isolamento de namespace.

· hiperv: Isolamento baseado em partição de hipervisor Hyper-V.

Na prática, ao executar no Microsoft Windows sem um demônio conjunto de opções, estes dois
os comandos são equivalentes:

$ docker run -d --isolation padrão busybox top
$ docker run -d --isolation processo busybox top

Se você definiu o --exec-opt isolamento = hiperventilação opção no Docker demônio, nenhum desses
comandos também resultam em hiperv isolamento:

$ docker run -d --isolation padrão busybox top
$ docker run -d --isolation hyperv busybox topo

HISTÓRIA

Abril de 2014, Compilado originalmente por William Henry (whenry at redhat ponto com) com base em
material de origem e trabalho interno da docker.com. Junho de 2014, atualizado por Sven Dowideit
⟨[email protegido]⟩ Julho de 2014, atualizado por Sven Dowideit ⟨[email protegido]⟩
Novembro de 2015, atualizado por Sally O'Malley ⟨[email protegido]⟩

Use docker-run online usando serviços onworks.net