Neste artigo, aprofundaremos a diferença entre uma imagem do Docker e um contêiner e criaremos nosso Dockerfile para entender melhor todas as várias fases da virtualização do contêiner do Docker.
Já falamos sobre esse sistema em um tutorial onde aprendemos a instalar o Docker.
Mas por que falar sobre imagens e contêineres?

Imagem e contêiner do Docker

Para esclarecer melhor quais são as diferenças entre imagens e contêineres, tente pensar em uma linguagem orientada a objetos. Nessa analogia, a classe representa a imagem enquanto sua instância, o objeto, é o contêiner.
A mesma imagem pode criar mais contêineres.
Portanto, a virtualização de contêiner é fundamentalmente baseada em imagens, nos arquivos disponíveis no Docker Hub e usados ​​para criar e inicializar um aplicativo em um novo contêiner do Docker.
Cada imagem é definida por um Dockerfile, um arquivo de configuração que contém todos os comandos que um usuário precisa executar para modelar a imagem.

As camadas do Dockerfile

O dockerfile é uma ferramenta poderosa para definir imagens, graças à sua estrutura em camadas , que contém comandos, bibliotecas a serem usadas e dependências.
Algumas camadas podem estar em mais projetos, portanto, esse recurso garante a reutilização do que já foi baixado e, consequentemente, garante as performances e, não menos importante, a economia de tempo e espaço físico.

Vamos supor, por exemplo, que precisamos usar imagens de dois RDBMS, como PostgreSQL e MySQL (ou MariaDB ).

Primeiro, começamos a pesquisar, com o comando docker search , as imagens oficiais contidas no dockerhub para esses dois sistemas e, em seguida, captamos as imagens oficiais.

#docker search postgresql

docker search postgresql

#docker search mysql

docker search mysql

Neste segundo caso, podemos escolher MySQL ou MariaDB.
Nós escolhemos o último e, com o comando docker pull, fazemos o download das imagens localmente no DockerHub.

# docker pull postgres

docker pull postgres

#docker pull mariadb

docker pull mariadb

Podemos observar que o status final indica o download correto das imagens (versão mais recente – identificada pela tag padrão ) e que nos dois casos elas são compostas por 14 camadas distintas .
Observamos, no entanto, que no caso do MariaDB, as quatro primeiras camadas são indicadas com “Já existe” . Na verdade, eles já haviam sido baixados em um pull anterior e, portanto, não é necessário fazer o download novamente.

Um identificador distingue cada uma dessas camadas, enquanto a penúltima string “Digest” representa univocamente a imagem que acabou de ser baixada como um hash da própria imagem.

Para entender melhor esse aspecto das camadas do Docker, vamos explorar como criar um DockerFile .

Criar um DockerFile

Se necessário, é possível criar seus próprios Dockerfiles, adicionando níveis a uma imagem de base – uma que represente a base a partir da qual iniciar – ou a partir de uma imagem vazia, caso seja necessário ter a máxima liberdade de gerenciamento.
Nos dois casos, a primeira linha conterá o comando FROM, que indicará a imagem de base (zero no caso de uma imagem vazia).
Vamos dar o exemplo de um Dockerfile simples derivado de uma imagem oficial do ubuntu.
Criamos nosso Dockerfile com o editor preferido e adicionamos as seguintes linhas:

FROM ubuntu
RUN apt-get update
RUN apt-get install --yes apache2
COPY index.html /var/www/html/index.html

No primeiro nível (do ubuntu ), adicionamos três níveis que representam os comandos que queremos adicionar.
Executamos o comando build para criar a imagem conforme descrito no arquivo da seguinte maneira:

#docker build.

Não se esqueça do ponto (.) Que indica o diretório atual em que o docker pesquisa um arquivo docker, exatamente com esse nome.

Como você pode ver nas imagens abaixo, a operação de compilação consiste em 4 etapas , que correspondem às quatro camadas da nossa imagem.

docker build 1-4

docker build 2-4

docker build 3-4

docker build 4-4

Na verdade, serão construídos níveis intermediários, que têm função de cache nas seguintes execuções, como pode ser visto no comando:

#docker images -a

docker image -a

As imagens identificadas com <none> na coluna do repositório são as intermediárias.
Para entender melhor, vamos tentar executar novamente o comando agora

#docker build .

docker image cache

É fácil testar que agora a criação da imagem é muito mais rápida e reutiliza imagens que já estão armazenadas em cache.
A imagem 46115e101915 , por exemplo, é a que é reutilizada na etapa 3/4.

Containers

Até agora, falamos sobre como fazer o download de uma imagem ou criar e implementar sua própria.
Mas é com o comando “docker run” que tudo realmente toma forma.

#docker run --rm --name ubuntu_apache -it ubuntu

docker run --rm

De fato, este comando permite instanciar um contêiner na imagem recém-criada .
As opções escolhidas neste caso são as referentes à interatividade (-i) , à alocação de um console TTY (-t) e à possibilidade de remover diretamente o contêiner após sair (–rm) .

A documentação oficial do Docker contém a lista de todas as opções para o comando run.

Enquanto a imagem consiste em uma série de camadas, todas no modo somente leitura, o contêiner adiciona uma camada superior (também chamada camada de contêiner) no modo leitura/gravação .

E toda vez que um novo contêiner é instanciado na mesma imagem, uma nova camada é adicionada para criar novos contêineres.

Se quisermos ter uma lista de contêineres ativos e inativos , podemos executar o comando:

#docker ps -a

docker ps -a

O uso de contêineres é útil porque você pode criar com facilidade e rapidez um ambiente de desenvolvimento ou teste quantas vezes quiser.

Saindo do console com o comando exit , o contêiner, graças à opção –rm , não existirá mais.

Agora vamos tentar usar o comando:

#docker run --name ubuntu_apache -it ubuntu

sem a opção de remoção anterior.

docker run

Nesse ponto, se quiséssemos removê-lo manualmente, teríamos que usar o:

#docker rm

comando seguido pelo id.

Mas não antes de parar.

Portanto, a sequência correta dos comandos é a seguinte:

docker stop rm

Se, em vez disso, desejamos reiniciar o contêiner parado anteriormente , o comando a ser usado é:

#docker start

e, no nosso exemplo, seria:

docker start

Conclusões

Neste artigo, conseguimos entender, a partir de alguns exemplos, como é fácil implementar ambientes perfeitamente funcionais, replicáveis ​​em qualquer máquina, usando a escalabilidade do sistema de camadas das imagens do docker .
Mais adiante, falaremos sobre como aumentar o potencial dessa ferramenta com mecanismos poderosos, como Docker-compone e Docker-swarm.

(Inglês)





Qual a diferença entre uma imagem Docker e contêiner? Como criar um arquivo docker
Iperius Backup Brasil
*****************************************

PLEASE NOTE: if you need technical support or have any sales or technical question, don't use comments. Instead open a TICKET here: https://support.iperius.net

*****************************************

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

*****************************************

PLEASE NOTE: if you need technical support or have any sales or technical question, don't use comments. Instead open a TICKET here: https://support.iperius.net

*****************************************