Ao usar o Docker, começamos com uma imagem base. Inicializamos, criamos alterações e essas alterações são salvas em camadas, formando outra imagem.

Então, eventualmente, tenho uma imagem para minha instância do PostgreSQL e uma imagem para meu aplicativo da Web, alterações nas quais continuam sendo persistentes.

O que é um contêiner?

Uma instância de uma imagem é chamada de contêiner. Você tem uma imagem, que é um conjunto de camadas que você descreve. Se você iniciar esta imagem, terá um contêiner em execução dessa imagem. Você pode ter muitos contêineres em execução da mesma imagem.

Você pode ver todas as suas imagens docker imagesenquanto você pode ver seus contêineres em execução com docker ps(e você pode ver todos os contêineres com docker ps -a).

Portanto, uma instância em execução de uma imagem é um contêiner.

Do meu artigo em Automatizando implantações do Docker :

Imagens do Docker vs. contêineres

Em Dockerland, existem imagens e existem contêineres . Os dois estão intimamente relacionados, mas distintos. Para mim, compreender essa dicotomia esclareceu Docker imensamente.

O que é uma imagem?

Uma imagem é um arquivo inerte e imutável que é essencialmente um instantâneo de um contêiner. As imagens são criadas com o comando build e produzem um contêiner quando iniciado com run . As imagens são armazenadas em um registro do Docker, como o registry.hub.docker.com . Como elas podem se tornar muito grandes, as imagens são projetadas para serem compostas por camadas de outras imagens, permitindo que uma quantidade mínima de dados seja enviada ao transferir imagens pela rede.

As imagens locais podem ser listadas executando 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 serem observadas:

1. ID de IMAGEM são os primeiros 12 caracteres do identificador verdadeiro de uma imagem. Você pode criar várias tags de uma determinada imagem, mas seus IDs serão todos iguais (como acima).
2. O TAMANHO VIRTUAL é virtual porque está somando os tamanhos de todas as camadas subjacentes distintas. Isso significa que a soma de todos os valores nessa coluna é provavelmente muito maior que o espaço em disco usado por todas essas imagens.
3. O valor na coluna REPOSITORY vem do -tsinalizador do docker buildcomando ou da docker tagimagem existente. Você pode marcar imagens usando uma nomenclatura que faça sentido para você, mas saiba que a janela de encaixe usará a tag como o local do registro em um docker pushou docker pull.
4. A forma completa de uma tag é [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Por ubuntuacima, REGISTRYHOST é inferida a ser registry.hub.docker.com. Portanto, se você planeja armazenar sua imagem chamada my-applicationem um registro em docker.example.com, deve marcar essa imagem docker.example.com/my-application.
5. A coluna TAG é apenas a parte [: TAG] da tag completa . Esta é uma terminologia infeliz.
6. A latesttag não é mágica, é simplesmente a tag padrão quando você não especifica uma tag.
7. Você pode ter imagens não marcadas apenas identificáveis ​​por seus IDs de IMAGEM. Estes receberão o <none>TAG e o REPOSITÓRIO. É fácil esquecê-los.

Mais informações sobre imagens estão disponíveis na documentação e no glossário do Docker .

O que é um contêiner?

Para usar uma metáfora de programação, se uma imagem é uma classe, um contêiner é uma instância de uma classe - um objeto de tempo de execução. Esperamos que os contêineres estejam usando o Docker; são encapsulações leves e portáteis de um ambiente no qual os aplicativos são executados.

Visualize contêineres locais em execução com docker 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

Aqui, estou executando uma versão dockerizada do registro da docker, para que eu tenha um local privado para armazenar minhas imagens. Novamente, algumas coisas a serem observadas:

1. Assim como o ID da IMAGEM, o ID do CONTAINER é o identificador verdadeiro do contêiner. Ele tem a mesma forma, mas identifica um tipo diferente de objeto.
2. docker psapenas gera contêineres em execução . Você pode ver todos os contêineres (em execução ou parados ) com docker ps -a.
3. NAMES pode ser usado para identificar um contêiner iniciado por meio do --namesinalizador.

Como evitar o acúmulo de imagens e contêineres

Uma das minhas primeiras frustrações com o Docker foi o aparente acúmulo constante de imagens não identificadas e os contêineres parados . Em algumas ocasiões, esse acúmulo resultou em um número máximo de discos rígidos, diminuindo a velocidade do meu laptop ou interrompendo meu pipeline de construção automatizado. Fale sobre "recipientes em todos os lugares"!

Podemos remover todas as imagens não marcadas combinando docker rmicom a dangling=trueconsulta recente :

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

O Docker não poderá remover as imagens que estão atrás dos contêineres existentes; portanto, talvez seja necessário remover os contêineres parados docker rmprimeiro:

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

Esses são pontos problemáticos conhecidos com o Docker e podem ser abordados em versões futuras. No entanto, com um entendimento claro de imagens e contêineres, essas situações podem ser evitadas com algumas práticas:

1. Remova sempre um recipiente parado e inútil docker rm [CONTAINER_ID].
2. Sempre remova a imagem atrás de um recipiente parado e inútil docker rmi [IMAGE_ID].

Em palavras fáceis.

Imagens -

O sistema de arquivos e o aplicativo de configuração (somente leitura) usado para criar contêineres. Mais detalhes .

Contentores -

Essas são instâncias em execução de imagens do Docker. Contêineres executam os aplicativos reais. Um contêiner inclui um aplicativo e todas as suas dependências. Ele compartilha o kernel com outros contêineres e é executado como um processo isolado no espaço do usuário no SO host. Mais detalhes .

Outros termos importantes a serem observados:

Daemon do Docker -

O serviço de segundo plano em execução no host que gerencia a construção, execução e distribuição de contêineres do Docker.

Cliente Docker -

A ferramenta de linha de comando que permite ao usuário interagir com o daemon do Docker.

Loja Docker -

A loja é, entre outras coisas, um registro de imagens do Docker. Você pode pensar no registro como um diretório de todas as imagens disponíveis do Docker.

Uma imagem desta postagem do blog vale mais que mil palavras.

(Para uma compreensão mais profunda, leia isso .)

Resumo:

• Puxe a imagem do hub do Docker ou crie a partir de um arquivo Docker => Dá uma imagem do Docker (não editável).
• Executar a imagem ( docker run image_name:tag_name) => Dá uma imagem em execução, ou seja, contêiner (editável)

Embora seja mais simples pensar em um contêiner como uma imagem em execução, isso não é muito preciso.

Uma imagem é realmente um modelo que pode ser transformado em um contêiner. Para transformar uma imagem em um contêiner, o mecanismo do Docker pega a imagem, adiciona um sistema de arquivos de leitura e gravação e inicializa várias configurações, incluindo portas de rede, nome do contêiner, ID e limites de recursos. Um contêiner em execução tem um processo em execução no momento, mas também pode ser parado (ou encerrado na terminologia do Docker). Um contêiner encerrado não é o mesmo que uma imagem, pois pode ser reiniciado e manterá suas configurações e quaisquer alterações no sistema de arquivos.

Talvez a explicação de todo o fluxo de trabalho possa ajudar.

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

Depois que o Dockerfile é criado, você o cria para criar a imagem do contêiner. A imagem é apenas a "versão compilada" do "código-fonte", que é o Dockerfile.

Depois de ter a imagem do contêiner, você deve redistribuí-lo usando o registro . O registro é como um repositório Git - você pode enviar e receber imagens.

Em seguida, você pode usar a imagem para executar contêineres . Um contêiner em execução é muito semelhante, em muitos aspectos, a uma máquina virtual (mas sem o hipervisor ).

Fluxo de trabalho

Aqui está o fluxo de trabalho de ponta a ponta, mostrando os vários comandos e suas entradas e saídas associadas. Isso deve esclarecer a relação entre uma imagem e um contêiner.

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

Para listar as imagens que você pode executar, execute:

docker image ls

Para listar os contêineres nos quais você pode executar comandos:

docker ps

Eu não conseguia entender o conceito de imagem e camada , apesar de ler todas as perguntas aqui e, em seguida, acabei encontrando esta excelente documentação da Docker (duh!).

O exemplo é realmente a chave para entender todo o conceito. Como é um post longo, estou resumindo os principais pontos que precisam ser realmente compreendidos para obter clareza.

• Imagem : Uma imagem do Docker é criada a partir de uma série de camadas somente leitura

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

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

FROM ubuntu: 15.04

CÓPIA DE . /aplicativo

EXECUTAR make / app

CMD python /app/app.py

É importante ressaltar que cada camada é apenas um conjunto de diferenças em relação à camada anterior.

• Container . Ao criar um novo contêiner, você adiciona uma nova camada gravável sobre as camadas subjacentes . Essa camada é freqüentemente chamada de "camada de contêiner". Todas as alterações feitas no contêiner em execução, como gravar novos arquivos, modificar arquivos existentes e excluir arquivos, são gravadas nessa camada fina de contêiner gravável.

Portanto, a principal diferença entre um contêiner e uma imagem é a camada superior gravável . Todas as gravações no contêiner que adicionam novos ou modificam dados existentes são armazenadas nessa camada gravável. Quando o contêiner é excluído, a camada gravável também é excluída. A imagem subjacente permanece inalterada.

Noções básicas sobre imagens e contêineres sob uma perspectiva de tamanho no disco

Para visualizar o tamanho aproximado de um contêiner em execução, você pode usar o docker ps -scomando Você obtém sizee virtual sizecomo duas das saídas:

• Tamanho: a quantidade de dados (em disco) usada para a camada gravável de cada contêiner

• Tamanho virtual: a quantidade de dados usados ​​para os dados de imagem somente leitura usados ​​pelo contêiner. Vários contêineres podem compartilhar alguns ou todos os dados de imagem somente leitura. Portanto, estes não são aditivos. Ou seja, você não pode adicionar todos os tamanhos virtuais para calcular quanto tamanho do disco é usado pela imagem

Outro conceito importante é a estratégia de copiar na gravação

Se um arquivo ou diretório existir em uma camada inferior da imagem, e outra camada (incluindo a camada gravável) precisar de acesso de leitura, apenas usará o arquivo existente. A primeira vez que outra camada precisa modificar o arquivo (ao criar a imagem ou ao executar o contêiner), o arquivo é copiado nessa camada e modificado.

Espero que ajude alguém como eu.

Arquivo de encaixe → (Compilação) → Imagem → (Executar) → Contêiner .

• Dockerfile : contém um conjunto de instruções do Docker que provisionam seu sistema operacional da maneira que você gosta e instala / configura todo o seu software.

• Imagem : Dockerfile compilado. Economiza tempo com a reconstrução do Dockerfile toda vez que você precisa executar um contêiner. E é uma maneira de ocultar seu código de provisão.

• Contêiner : o próprio sistema operacional virtual. Você pode ssh nele e executar os comandos que desejar, como se fosse um ambiente real. Você pode executar mais de 1000 contêineres da mesma imagem.

Simplificando, se uma imagem é uma classe , um contêiner é uma instância de uma classe e um objeto de tempo de execução .

Um contêiner é apenas um binário executável que deve ser executado pelo sistema operacional host sob um conjunto de restrições predefinidas usando um aplicativo (por exemplo, Docker) que sabe como informar ao sistema operacional quais restrições aplicar.

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

Até recentemente, apenas kernels em sistemas baseados em Unix suportavam a capacidade de executar executáveis ​​sob restrições estritas. É por isso que a maioria das conversas sobre contêineres hoje envolve principalmente Linux ou outras distribuições Unix.

O Docker é um desses aplicativos que sabe como informar ao SO (principalmente Linux) sob quais restrições executar um executável. O executável está contido na imagem do Docker, que é apenas um tarfile. Esse executável é geralmente uma versão simplificada de uma distribuição Linux (Ubuntu, CentOS, Debian etc.) pré-configurada para executar um ou mais aplicativos.

Embora a maioria das pessoas use uma base Linux como executável, ela pode ser qualquer outro aplicativo binário, desde que o SO host possa executá-lo (consulte a criação de uma imagem básica simples usando o scratch ). Seja o binário na imagem do Docker um sistema operacional ou simplesmente um aplicativo, para o host do sistema operacional é apenas mais um processo, um processo contido controlado por limites predefinidos do sistema operacional.

Outros aplicativos que, como o Docker, podem dizer ao sistema operacional host quais limites aplicar a um processo durante a execução, incluem LXC , libvirt e systemd . O Docker costumava usar esses aplicativos para interagir indiretamente com o sistema operacional Linux, mas agora o Docker interage diretamente com o Linux usando sua própria biblioteca chamada " libcontainer " ".

Portanto, os contêineres são apenas processos executados em um modo restrito, semelhante ao que o chroot costumava fazer.

Na IMO, o que diferencia o Docker de qualquer outra tecnologia de contêiner é seu repositório (Docker Hub) e suas ferramentas de gerenciamento, que tornam extremamente fácil o trabalho com contêineres.

Consulte Docker (software) .

O conceito principal do Docker é facilitar a criação de "máquinas" que, neste caso, podem ser consideradas contêineres. O contêiner ajuda na reutilização, permitindo criar e soltar contêineres com facilidade.

As imagens representam o estado de um contêiner em todos os momentos. Portanto, o fluxo de trabalho básico é:

1. criar uma imagem
2. iniciar um contêiner
3. fazer alterações no contêiner
4. salve o contêiner de volta como uma imagem

Como muitas respostas apontaram isso: Você cria o Dockerfile para obter uma imagem e executa a imagem para obter um contêiner .

No entanto, as etapas a seguir me ajudaram a ter uma ideia melhor do que são a imagem e o contêiner do Docker:

1) Compile o Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Salve a imagem no .tararquivo

docker save -o my_file.tar my_image_id

my_file.tarirá armazenar a imagem. Abra-o com tar -xvf my_file.tare você verá todas as camadas. Se você se aprofundar em cada camada, poderá ver quais alterações foram adicionadas em cada camada. (Eles devem estar bem próximos dos comandos no Dockerfile).

3) Para dar uma olhada dentro de um contêiner, você pode:

sudo docker run -it my_image bash

e você pode ver que é muito parecido com um sistema operacional.

A imagem é equivalente a uma definição de classe no OOP e as camadas são métodos e propriedades diferentes dessa classe.

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

Eu acho que é melhor explicar no começo.

Suponha que você execute o comando docker run hello-world . O que acontece?

Ele chama o Docker CLI, responsável por receber os comandos do Docker e transformá-lo para chamar os comandos do servidor Docker . Assim que o servidor Docker obtém um comando para executar uma imagem , ele verifica se o cache de imagens mantém uma imagem com esse nome.

Suponha que o olá mundo não exista. O servidor do Docker acessa o Docker Hub (o Docker Hub é apenas um repositório gratuito de imagens) e pergunta, ei Hub, você tem uma imagem chamada hello-world? Respostas do hub - sim, eu faço. Então me dê, por favor. E o processo de download é iniciado. Assim que a imagem do Docker é baixada, o servidor do Docker a coloca no cache da imagem .

Portanto, antes de explicar o que são as imagens e os contêineres do Docker, vamos começar com uma introdução sobre o sistema operacional no seu computador e como ele executa o software.

Quando você executa, por exemplo, o Chrome no seu computador, ele chama o sistema operacional, o próprio sistema operacional chama o kernel e pergunta: ei, eu quero executar este programa. O kernel consegue executar arquivos do seu disco rígido.

Agora imagine que você tem dois programas, Chrome e Node.js. O Chrome requer a versão 2 do Python para ser executado e o Node.js exige a versão 3 do Python para a execução. Se você instalou apenas o Python v2 no seu computador, apenas o Chrome será executado.

Para que ambos os casos funcionem, de alguma forma você precisa usar um recurso do sistema operacional conhecido como namespacing. Um espaço para nome é um recurso que oferece a oportunidade de isolar processos, disco rígido, rede, usuários, nomes de host e assim por diante.

Então, quando falamos sobre uma imagem , na verdade falamos sobre um instantâneo do sistema de arquivos. Uma imagem é um arquivo físico que contém instruções e metadados para criar um contêiner específico . O contêiner em si é uma instância de uma imagem ; ele isola o disco rígido usando o namespace, disponível apenas para esse contêiner . Portanto, um contêiner é um processo ou conjunto de processos que agrupa diferentes recursos atribuídos a ele.

Uma imagem do Docker compacta o aplicativo e o ambiente exigidos pelo aplicativo para execução, e um contêiner é uma instância em execução da imagem.

As imagens são a parte da embalagem do Docker, análoga a "código fonte" ou a um "programa". Contêineres são a parte de execução do Docker, análoga a um "processo".

Na questão, apenas a parte "programa" é mencionada e essa é a imagem. A parte "em execução" do Docker é o contêiner. Quando um contêiner é executado e as alterações são feitas, é como se o processo fizesse uma alteração em seu próprio código-fonte e o salvasse como a nova imagem.

Como no aspecto de programação,

Imagem é código fonte.

Quando o código-fonte é compilado e compilado, ele é chamado de aplicativo.

Semelhante ao "quando uma instância é criada para a imagem", é chamada de " contêiner ".

Uma imagem é um "instantâneo" de um contêiner . Você pode criar imagens de um contêiner (novos "snapshots") e também pode iniciar novos contêineres a partir de uma imagem (instanciar o "snapshot").

Por exemplo, você pode instanciar um novo contêiner a partir de uma imagem base, executar alguns comandos no contêiner e, em seguida, capturá-lo como uma nova imagem. Em seguida, você pode executar 100 contêineres a partir dessa nova imagem.

Outras coisas a considerar:

• Uma imagem é composta de camadas e as camadas são "diffs" de snapshot (portanto, quando você pressiona uma imagem, você só precisa enviar o "diff" para o registro).
• Um Dockerfile define alguns comandos na parte superior de uma imagem base, que cria novas camadas ("diffs") que resultam em uma nova imagem ("instantâneo").
• Tags de imagem não são apenas tags. Eles são o "nome completo" da imagem ("repositório: tag"). Se a mesma imagem tiver vários nomes, ela será exibida várias vezes ao fazê-lo docker images.

Gostaria de preencher a parte que falta aqui entre docker imagese containers. O Docker usa um sistema de arquivos de união ( UFS ) para contêineres, o que permite que vários sistemas de arquivos sejam montados em uma hierarquia e apareçam como um único sistema de arquivos. O sistema de arquivos da imagem foi montado como uma read-onlycamada e quaisquer alterações no contêiner em execução são feitas em uma read-writecamada montada em cima disso. Por esse motivo, o Docker precisa apenas olhar para a camada superior de leitura e gravação para encontrar as alterações feitas no sistema em execução.

Para uma analogia de programação fictícia, você pode pensar que o Docker possui um ImageFactory abstrato que contém os ImageFactories que eles vêm da loja .

Depois que você quiser criar um aplicativo a partir desse ImageFactory, você terá um novo contêiner e poderá modificá-lo conforme desejar. O DotNetImageFactory será imutável, pois atua como uma classe abstrata de fábrica, onde apenas fornece as instâncias que você deseja.

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

Em resumo:

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

Um contêiner é um aplicativo auto-sustentável que terá pacotes e todas as dependências necessárias para executar o código.

Um contêiner do Docker está executando uma instância de uma imagem. Você pode relacionar uma imagem com um programa e um contêiner com um processo :)

Uma imagem é para uma classe como um contêiner para um objeto.

Um contêiner é uma instância de uma imagem, pois um objeto é uma instância de uma classe.

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

Os contêineres do Docker são como a versão extraída do tarball. Você pode ter quantas cópias desejar em diferentes pastas (os contêineres).