Advertisement
  1. Code
  2. Docker

Docker do Zero: Construindo Imagens

by
Read Time:10 minsLanguages:
This post is part of a series called Docker from the Ground Up.
Docker From the Ground Up: Understanding Images

Portuguese (Português) translation by Erick Patrick (you can also view the original English article)

Containers Docker estão crescendo como uma melhor prática para deploy e administração de sistemas distribuídos nativos cloud. Containers são instâncias de imagens Docker. Acontece que existe muito a se saber e entender sobre imagens.

Nesse tutorial de duas partes, cobriremos imagens do Docker a fundo. Hoje, discutiremos os princípios básicos, considerações de projeto e inspecionaremos as "entranhas" de uma imagem. Cobriremos como criar nossas próprias imagens, resolução de problemas e trabalhar com repositórios de imagens.

Quando terminarmos, teremos um sólido entendimento do que são imagens Docker e como utilizá-las efetivamente em nossas aplicações e sistemas.

Criando Imagens

Há duas formas de criar imagens. Podemos modificar um container existente e então enviá-lo como uma nova imagem ou podemos criar um arquivo Dockerfile e criar uma imagem dele. Veremos ambos e explicaremos os prós e contras.

Criação Manual

Com criação manual, tratamos o container como um computador normal. Instalamos pacotes, criamos arquivos e quando tudo está feito, salvamos e acabamos com uma nova imagem para usarmos como modelo para criação de muitos outros containers ou mesmo como base de outras imagens.

Comecemos com a imagem alpine, que é bem pequena e simples, baseada no Linux Alpine. Podemos executá-la em modo interativo para acessar o terminal. Nosso objetivo é adicionar um arquivo chamado "yeah" com o texto "it works" no diretório raiz e então criar uma nova imagem chamada "yeah-alpine".

Aqui vamos nós. Certo, já estamos no diretório raiz. Vejamos o que temos lá.

Que editor está disponível? Nada de vim ou nano?

Bem... Apenas precisamos criar um arquivo:

Saímos do terminal e podemos ver o container chamado "vibrant_spenc" com docker ps --all. O semáforo --all é importante porque o container não está mais em execução.

Aqui, criamos uma nova imagem a partir do container "vibrate_spence". Adicionamos uma mensagem de registro "mine, mine, mine" por boas práticas.

Verifiquemos. Sim, há uma nova imagem e no histórico podemos ver a nova camada com o comentário "mine, mine, mine".

Agora, o teste de verdade. Apaguemos o container e criemos um novo a partir da imagem. O resultado esperado é que o arquivo "yeah" esteja presente no novo container.

O que podemos dizer? Funciona!!

Usando um Dockerfile

Criar imagens a partir de containers modificados é legal, mas não é sustentável. É difícil registrar as mudanças e saber quais foram as modificações. A forma disciplinada de criar imagens é a partir do Dockerfile.

O Dockerfile é um arquio de texto similar a um script de terminal, mas suporta vários comandos. Cada comando que modifica o sistema de arquivo cria uma nova camada. Na parte um discutimos a importância de dividir a nossa imagem em camadas apropriadas. O Dockerfile é um gráde tópico por si só.

Aqui, apenas demonstraremos alguns comandos pra criar outra imagem, "oh-yeah-alpine", baseada no Dockerfile. Além de criar o infame arquivo "yeah", também instalaremos vim. A distribuição Linux Alpine usa um sistema administrador de pacotes chamado "apk". Eis o Dockerfile:

A imagem base é alpine. Ele copia o arquivo "yeah" do diretório hospedeiro onde o Dockerfile está (o caminho do contexto de criação). Então executa apk update e instala vim. Por fim, configura o comando executado quando o container é executado. Nesse caso, imprimirá na tela o conteúdo do arquivo "yeah".

OK. Agora que sabemos onde nos metemos, construamos essa coisa. A opção "-t" configura o repositório. Não especificamos uma tag, então será o padrão "latest".

Parece legal. Verifiquemos se a imagem foi criada:

Notemos como instalar vim e suas dependências aumentaram o tamanho do container de 4.8MB da imagem alpine base para massivos 30.5MB!

É tudo muito bom. Mas funciona?

Ah, sim, funciona!

Caso ainda duvidemos, acessemos o container, examinemos o arquivo "yeah" com nosso vim recém instalado.

O Contexto de Criação e o Arquivo .dockerignore

Não dissemos ante, mas ao tentar criar a imagem oh-yeah-alpine, ela simplesmente ficou suspensa por vários minutos. O problema é que colocamos o Dockerfile no diretório padrão. Quando o Docker cria uma imagem, ele primeiro empacota todo o diretório onde o Dockerfile está (incluindo sub-diretório) e os disponibiliza para comandos COPY no Dockerfile.

Docker não está tentando ser esperto e analisando nossos comandos COPY. Ele apenas empacota tudo. Notemos que o conteúdo da criação não aparece na imagem, mas atrasa o comando build se o contexto de criação for grande demais.

Nesse caso, apenas copiamos o Dockerfile e o arquivo "yea" para um subdiretório e executamos o comando build no sub-diretório. Mas, alguma vezes, temos uma árvore de diretórios complicada da qual queremos copia sub-pastas e arquivos específicos e ignorar outros. O .dockerignore está aí para isso.

Ele nos permite controlar exatamente o que vai no contexto de criação. Nosso truque preferido é excluir tudo e começar a adicionar cada parte necessária. Por exemplo, nesse caso, poderíamos criar o .dockerignore abaixo e manter o Dockerfile o arquivo "yeah" no diretório raiz:

Não é preciso incluir o Dockerfile em si ou o .dockerignore no contexto de criação.

Copiar vs. Montar

Copiar arquivos para a imagem é algo que precisamos às vezes, mas, em outros casos, queremos que os containers sejam mais dinâmicos e trabalhem com arquivos no hospedeiro. É aí que volumes e montagens entram em ação.

Montar diretórios do hospedeiro é complicado. Os dados pertencem ao hospedeiro e não ao container, podem ser modificados quando ele está parado. E o container pode ser iniciado com diferentes diretórios hospedeiros montados.

Rotulando Imagens

Rotular imagens é importante se desenvolvemos sistemas baseados em micro-serviços e geramos várias imagens que precisam ser associadas umas com as outras. Podemos adicionar quantos rótulos quisermos a uma imagem.

Já vimos o rótulo padrão "latest". Alguma vez, faz mais sentido adicionar outros, como "tested", "release-1.4" ou hash do estado no Git que corresponde à imagem.

Podemos rotulá-la durante criação ou depois. Eis como adicionar rótulo a uma imagem existente. Notemos que, embora chamemos de rótulo, podemos atribuir um novo repositório também.

Também podemos remover rótulos de imagens usando o nome do rótulo. Isso é um pouco assustador por que se removermos o último rótulo sem querer, perdemos a imagem. Mas se criamo-na a partir de um Dockerfile, basta reconstruí-la.

Se tentarmos remover remover a última imagem rotulada, obtemos um erro porque ela é usada por um container.

Mas se removermos o container...

Sim, sumiu. Mas não nos preocupemos. Podemos reconstruí-la:

Yeah, está de volta! Viva o Dockerfile!

Trabalhando com Registros de Imagens

Imagens são similares a repositórios git. Também são criadas a partir de conjuntos ordenados de ordens. Podemos imaginar duas imagens usando a mesma imagem base como ramificação, mesmo não existindo mesclagem ou rebase no Docker). Um registro de imagem é o equivalente a uma hospedagem git centralizada, como o GitHub. Adivinhemos o nome do registro de imagens oficial do Docker: Sim, Docker Hub.

Baixando Imagens

Ao executar uma imagem, se não existir, Docker tentará baixá-la de um dos registros de imagens configurados. Por padrão, vai ao Docker Hub, mas podemos controlar pelo "~/.docker/config.json". Ao usar um registro diferente, seguimos suas instruções, o que costuma envolver autenticação com as credenciais deles.

Removamos a imagem "hello-world" e baixemo-na novamente usando o comando docker pull.

Se foi. Baixemos novamente.

A hello-world antiga foi substituída por uma versão mais nova.

Enviando Imagens

Enviar imagens é um pouco mais complicado. Primeiro precisamos criar uma conta no Docker Hub (ou outro registro). Depois, autenticar. Então precisamos rotular a imagem a ser enviada, de acordo com o nome da conta ("g1g1", nesse caso).

Agora, podemos enviar a imagem rotulada g1g1/hello-word.

Conclusão

Imagens Docker são modelos para containers, projetadas para serem eficientes e oferecer o máximo de reuso através de um driver de armazenamento em camadas de sistema de arquivos.

Docker provê muitas ferramentas para listar, inspecionar, construir e rotular imagens. Podemos baixar ou enviar imagens para registros, como o Docker Hub, para administrar ou compartilhar imagens facilmente.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.