Imagens do acoplador vs. contentores

Em Dockerland, há imagense há recipientes {contentores . Os dois estão intimamente relacionados, mas distintos. Para mim, agarrar esta dicotomia esclareceu imensamente o Docker.

Uma imagem é um ficheiro inerte, imutável, que é essencialmente uma imagem de um contentor. As imagens são criadas com a compilação o comando, e eles vão produzir um recipiente quando começarem comexecutar . As imagens são gravadas num registo do Docker como registry.hub.docker.com . dado que podem tornar-se bastante grandes, as imagens são desenhadas para serem compostas por camadas de outras imagens, permitindo que uma quantidade miminal de dados seja enviada ao transferir imagens pela rede.

As imagens locais podem ser listadas em execução docker images:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu                    13.10               5e019ab7bf6d        2 months ago        180 MB
ubuntu                    14.04               99ec81b80c55        2 months ago        266 MB
ubuntu                    latest              99ec81b80c55        2 months ago        266 MB
ubuntu                    trusty              99ec81b80c55        2 months ago        266 MB
<none>                    <none>              4ab0d9120985        3 months ago        486.5 MB

Algumas coisas a notar:

1. O ID da imagem é o os primeiros 12 caracteres do verdadeiro identificador de uma imagem. Você pode criar muitas tags de uma determinada imagem, mas seus IDs serão todos os mesmos (como acima).
2. O tamanho VIRTUAL évirtual porque está a adicionar os tamanhos de todas as camadas subjacentes distintas. Isto significa que a soma de todos os valores nessa coluna é provavelmente muito maior do que o espaço em disco usado por todas essas imagens.
3. o valor na coluna do repositório vem da bandeira -t do comando docker build, ou de docker tag - ing uma imagem existente. Você é livre para marcar imagens usando uma nomenclatura que faz sentido para você, mas saiba que o docker irá usar a tag como o local de registro em um docker push ou docker pull.
4. a forma completa de uma etiqueta é [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Para ubuntu acima, o REGISTRYHOST é inferido como registry.hub.docker.com. Por isso, se planeia armazenar a sua imagem chamada my-application num registo em docker.example.com, deve marcar essa imagem docker.example.com/my-application.
5. a coluna de marcas é apenas a parte [:marca] da marca completa. Isto é ... terminologia infeliz.
6. a marca latest não é mágica, é simplesmente a marca predefinida quando não indica uma marca.
Pode ter imagens não marcadas só identificáveis pela identificação da imagem. Estes irão obter a etiqueta e o repositório <none>. É fácil esquecê-los.

Mais informações sobre as imagens estão disponíveis nos docse glossário.

Ver contentores locais comdocker ps:

CONTAINER ID        IMAGE                               COMMAND                CREATED             STATUS              PORTS                    NAMES
f2ff1af05450        samalba/docker-registry:latest      /bin/sh -c 'exec doc   4 months ago        Up 12 weeks         0.0.0.0:5000->5000/tcp   docker-registry

1. tal como o ID da imagem, o ID do contentor é o identificador verdadeiro para recipiente. Tem a mesma forma, mas identifica um tipo diferente de objeto.
2. {[17] } apenas Saídas a correr contentores. Pode ver todos os contentores (a correr ou parados ) com docker ps -a.
3. os nomes podem ser usados para identificar um contentor iniciado através da bandeira --name.

Podemos remover todas as imagens não marcadas combinando docker rmi com a recente dangling=true pesquisa:

docker images -q --filter "dangling=true" | xargs docker rmi

O 'Docker' não será capaz de remover as imagens que estão por detrás dos contentores existentes, por isso poderá ter de remover os contentores parados com docker rm primeiro:

docker rm `docker ps --no-trunc -aq`

1. remova sempre um contentor inútil, parado com docker rm [CONTAINER_ID].
2. remova sempre a imagem atrás de um contentor inútil, parado com docker rmi [IMAGE_ID].

Embora seja mais simples pensar num recipiente como uma imagem em execução, isto não é completamente preciso.

Uma imagem é realmente um modelo que pode ser transformado em um recipiente. Para transformar uma imagem em um recipiente, O motor Docker pega a imagem, adiciona um sistema de arquivos de leitura-escrita no topo e inicia várias configurações, incluindo portas de rede, nome do recipiente, ID e limites de recursos. Um container em execução tem um processo de execução atual, mas um container também pode ser parado (ou saiu na terminologia de Docker). Um recipiente saído é não o mesmo que uma imagem, uma vez que pode ser reiniciado e irá manter as suas configurações e quaisquer alterações no sistema de ficheiros.

Tudo começa com o ficheiro de Dockerfile . O ficheiro Dockerfile é o código fonte da imagem.

Uma vez criado o ficheiro Dockerfile, você constrói-o para criar a imagem do contentor. A imagem é apenas a "versão compilada" do "código fonte" que é o Dockerfile.

Assim que tiver a imagem do contentor, deve redistribuí-la usando o registo . O registro é como um git repositório -- você pode enviar e extrair imagens.

A seguir, você pode usar a imagem para executar containers . Um recipiente em execução é muito semelhante, em muitos aspectos, a uma máquina virtual (mas sem o hipervisor).

Este post explica muitas coisas básicas sobre containers docker (é falar de Docker e fantoche, mas há muitos conceitos que podem ser usados em qualquer contexto) {[[2]}

Em palavras fáceis.

Imagens -

O sistema de ficheiros e a aplicação de configuração(apenas para leitura) que é usada para criar recipientes. mais detalhes.

Contentores -

Estas são instâncias executando imagens do acoplador. Os contentores correm o real aplicacao. Um recipiente inclui uma aplicação e todas as suas dependência. Ele compartilha o kernel com outros contêineres e funciona como um isolado processar no espaço do utilizador no SO máquina. mais detalhes.

outros termos importantes a notificar:

Servidor do Docker -

O serviço de fundo a funcionar na máquina que gere o edifício, a gerir e a distribuir contentores de Docker.

Cliente do acoplador -

A ferramenta da linha de comandos que permite ao utilizador interagir com o acoplador servidor.

Docker Store -

A Loja é, entre outras coisas, um registo de imagens do ancoradouro. Podes. pense no registro como um diretório de todas as imagens disponíveis do Docker.

(para uma compreensão mais profunda, por favor leiaisto .)

Resumo:

• puxe a imagem do hub do acoplador ou comporte a partir de um ficheiro do acoplador = > dá uma imagem do acoplador (não editavel).
• execute a imagem (docker run image_name:tag_name) = > dá uma imagem em execução, ou seja, contentor (editável)

Fluxo de trabalho

Aqui está o fluxo de trabalho extremo-a-extremo que mostra os vários comandos e as suas entradas e Saídas associadas. Isso deve esclarecer a relação entre uma imagem e um recipiente.

+------------+  docker build   +--------------+  docker run -dt   +-----------+  docker exec -it   +------+
| Dockerfile | --------------> |    Image     | --------------->  | Container | -----------------> | Bash |
+------------+                 +--------------+                   +-----------+                    +------+
                                 ^
                                 | docker pull
                                 |
                               +--------------+
                               |   Registry   |
                               +--------------+

Para listar as imagens que poderá executar, execute:

docker image ls

Para listar os contentores em que poderá executar comandos em:

docker ps

Eu não conseguia entender o conceito de imagem e camada apesar de ler todas as perguntas aqui e, em seguida, eventualmente, tropeçou este excelente documentação da janela de Encaixe (duh!).

O exemplo existe realmente a chave para entender todo o conceito. Trata-se de um cargo demorado, pelo que estou a resumir os pontos-chave que precisam de ser realmente compreendidos para obter clareza.

• Imagem: uma imagem do acoplador é construída a partir de uma série de apenas para leitura camadas

• Camada : cada camada representa uma instrução no ficheiro de Dockerfile da imagem.

Example: o Dockerfile abaixo contém quatro comandos, cada um dos quais cria uma camada.

De ubuntu: 15.04

Entendido . /app

Executar make / app

CMD python /app/app.py

Importante , cada camada é apenas um conjunto de diferenças da camada anterior ele.

• Recipiente . Quando você cria um novo recipiente, você adiciona uma nova camada escrita no topo das camadas subjacentes. Esta camada é muitas vezes chamada de "camada contêiner". Todas as alterações feitas no container em execução, como a escrita de novos ficheiros, a modificação de ficheiros existentes e a remoção de ficheiros, são escritas nesta camada de container thin.

Por isso, a maior diferença entre um recipiente e uma imagem é the top writable camada. Tudo escreve para o container que adiciona novo ou modificar os dados existentes são armazenados nesta camada escrita. Quando a o recipiente é excluído, a camada escrita também é excluído. O a imagem subjacente permanece inalterada.

Compreender os contentores de imagens cnd numa perspectiva de tamanho em disco

Para ver o tamanho aproximado de um contentor em execução, pode usar o comando docker ps -s. Você tem size e virtual size como duas das saídas:

• Tamanho: a quantidade de dados (no disco) que é usada para a camada escrita de cada recipiente

• Tamanho Virtual: a quantidade de dados utilizados para os dados de imagem apenas de leitura utilizados pelo recipiente. Vários recipientes podem compartilhar alguns ou todos os dados de imagem apenas para leitura. Por conseguinte, estes não são aditivos. Ou seja, você não pode adicionar todos os tamanhos virtuais para calcular quanto tamanho no disco é usado pela imagem

Outro conceito importante é o copy-on-write estratégia

Se um ficheiro ou directório existir numa camada inferior dentro da imagem, e outra camada (incluindo a camada gravável) necessitar de acesso de leitura a ele, apenas usa o ficheiro existente. A primeira vez que outra camada precisa modificar o arquivo (ao construir a imagem ou executar o container), o arquivo é copiado para essa camada e modificado.

Dockerfile > (Build) > Image > (Run) > Container.

• Dockerfile: contém um conjunto de instruções do docker que fornece o seu sistema operativo da forma que desejar, e instala/configura todas as instruções do seu software.

• Imagem : ficheiro do Dockerfile compilado. Poupa-lhe tempo de reconstruir o ficheiro Dockerfile sempre que precisa de executar um contentor. E é uma forma de esconder a tua provisão codigo.

• Container: o sistema operacional virtual em si, você pode SSH nele e executar todos os comandos que desejar, como se fosse um ambiente real. Você pode executar mais de 1000 contêineres a partir da mesma imagem.

O conceito central de docker é tornar mais fácil criar "máquinas" que neste caso podem ser consideradas recipientes. O recipiente ajuda na reutilização, permitindo que você crie e deixe cair recipientes com facilidade.

1. criar uma imagem
2. iniciar um recipiente
3. faça alterações no recipiente
4. guarde o contentor como uma imagem

Um container é apenas um executável binário que deve ser executado pelo sistema operacional host sob um conjunto de restrições que são predefinidas usando uma aplicação (por exemplo, acoplador) que sabe como dizer ao sistema operacional quais as restrições a aplicar.

As restrições típicas são relacionadas com o isolamento do processo, relacionadas com a segurança (como usar a proteção SELinux) e relacionadas com os recursos do sistema (memória, disco, cpu, rede).

Até há pouco tempo, apenas os kernels em sistemas baseados no Unix suportavam a capacidade de executar executáveis sob restrições rigorosas. É por isso que a maioria dos container talk hoje envolve principalmente Linux ou outras distribuições Unix.

O Docker é uma daquelas aplicações que sabe como dizer ao so (principalmente Linux) quais as restrições para executar um executável. O executável está contido na imagem Docker, que é apenas um arquivo tarfile. Esse executável é geralmente uma versão despojada de uma distribuição Linux (Ubuntu, centos, Debian etc) pré-configurada para executar uma ou mais aplicações dentro.

Embora a maioria das pessoas use uma base Linux como o executável, pode ser qualquer outra aplicação binária, desde que o sistema operacional host possa executá-la. (veja criando uma imagem base simples usando scratch ). Se o binário na imagem docker é um SO ou simplesmente uma aplicação, para o host do SO é apenas outro processo, um processo contido governado por limites predefinidos do sistema operacional.

Outras aplicações que, como a Docker, podem dizer ao so anfitrião quais os limites a aplicar a um processo enquanto ele é executar incluir LXC, libvirt , and systemd. O Docker costumava usar essas aplicações para interagir indiretamente com o sistema operacional Linux, mas agora o Docker interage diretamente com o Linux usando sua própria biblioteca chamada " libcontainer ".

Os contentores são apenas processos a correr num modo restrito, semelhante ao que chroot costumava fazer.

Ver https://en.m.wikipedia.org/wiki/Docker_(Linux_container_engine)

Simplesmente disse, Se uma imagem é uma classe, então um recipiente é uma instância de uma classe é um objeto em tempo de execução.

Uma imagem do acoplador embala a aplicação e o ambiente exigidos pela aplicação para executar, e um recipiente é uma instância em execução da imagem.

As imagens são a parte de embalagem do docker, análoga a" código fonte "ou a"programa". Containers are the execution part of docker, analogous to a "process".

Na pergunta, apenas a parte" programa " é referida e essa é a imagem. A parte" running " do docker é o contentor. Quando um recipiente é executado e as alterações são feito, é como se o processo faz uma mudança no seu próprio código fonte e o salva como a nova imagem.

Imagem é um equivalente a uma definição de classe em OOP e camadas são métodos e propriedades diferentes dessa classe.

Container é a instanciação real da imagem tal como um objecto é uma instanciação ou uma instância de uma classe.

Como no aspecto de programação,

A imagem é um código-fonte.

Quando o código-fonte é compilado e compilado, é chamado como aplicação.

Simillar para que "quando a instância é criada para a imagem", é chamado como " Container"

Resumindo:

Container é uma divisão (virtual) em um kernel que compartilha um SO comum e executa uma imagem (imagem Docker).

Um recipiente é uma aplicação auto-sustentável que terá pacotes e todas as dependências necessárias em conjunto para executar o código.

Uma imagem é para uma classe como um recipiente para um objecto.

Um recipiente é uma instância de uma imagem como um objeto é uma instância de uma classe.

Como muitas respostas mostraram isso: Você construir Dockerfile para obter uma imagem e executar imagem para obter uma recipiente.

No entanto, os seguintes passos ajudaram-me a sentir melhor o que é a imagem e o recipiente do acoplador:

1) Construir O Ficheiro Dockerfile:

docker build -t my_image dir_with_dockerfile

2) gravar a imagem no.tar ficheiro

docker save -o my_file.tar my_image_id

my_file.tar vai armazenar a imagem. Abre-o com tar -xvf my_file.tar, e tu vai poder ver todas as camadas. Se você mergulhar mais fundo em cada camada você pode ver que mudanças foram adicionadas em cada camada. (Eles devem estar muito perto de comandos no Dockerfile).

3) para dar uma olhada dentro de um recipiente, você pode fazer:

sudo docker run -it my_image bash

O ficheiro Dockerfile é como o teu script bash que produz um tarball (imagem do Docker).

Para uma analogia de programação fictícia, você pode pensar que o Docker tem um ImageFactory abstrato que contém imagens de que eles vêm store .

Então, uma vez que você quer criar um aplicativo a partir desse ImageFactory, você terá um novo container, e você pode modificá-lo como quiser. DotNetImageFactory será imutável, porque atua como uma classe de fábrica abstrata, onde só fornece instâncias que você deseja.

IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();

Um contentor está a correr uma instância de uma imagem. Você pode relacionar uma imagem com um programa e um container com um processo:)