Noções básicas do Docker: como usar Dockerfiles

Ao usar uma imagem Docker, não só é possível implantar um contêiner após o outro, como também é bastante fácil. Depois de extrair a imagem de um registro (como o Docker Hub), cada contêiner poderá ser implantado com um único janela de encaixe comando. Mas o que acontece quando você precisa implantar vários contêineres (cada um para uma finalidade diferente) a partir da mesma imagem? De repente, o gerenciamento desses contêineres pode ficar um pouco complicado.

Digamos, por exemplo, que você baixe a imagem mais recente do Ubuntu para desenvolvimento. Antes de poder desenvolver com esse contêiner, há uma série de modificações que você deseja fazer na imagem (como atualizar o software e adicionar os pacotes de desenvolvimento necessários para o trabalho em questão).

Para isso, você pode editar manualmente cada imagem conforme necessário (criando uma nova imagem para cada variação necessária do tema), ou pode construir um Dockerfile para cada variação. Depois de construir seu Dockerfile, você pode construir rapidamente a mesma imagem repetidamente, sem precisar perder tempo fazendo isso manualmente. Dockerfiles cuidadosamente elaborados podem economizar tempo e esforço consideráveis.

Quero orientar você no processo de criação de um Dockerfile. Demonstrarei usando a imagem mais recente do Ubuntu, atualizarei e atualizarei essa imagem e, em seguida, instalarei o pacote build-essential. Este será um Dockerfile bastante básico, mas que você pode facilmente desenvolver.

Noções básicas do Dockerfile

Antes de construirmos nosso Dockerfile, você precisa entender o que compõe o arquivo. Este será um arquivo de texto, chamado Dockerfile, que inclui palavras-chave específicas que determinam como construir uma imagem específica. As palavras-chave específicas que você pode usar em um arquivo são:

• ADICIONAR copia os arquivos de uma origem no host para o próprio sistema de arquivos do contêiner no destino definido.
• DMC pode ser usado para executar um comando específico dentro do contêiner.
• PONTO DE ENTRADA define um aplicativo padrão a ser usado sempre que um contêiner for criado com a imagem.
• ENV define variáveis ​​de ambiente.
• EXPOR associa uma porta específica para permitir a rede entre o contêiner e o mundo exterior.
• DE define a imagem base usada para iniciar o processo de construção.
• MANUTENTOR define um nome completo e endereço de e-mail do criador da imagem.
• CORRER é a diretiva central de execução para Dockerfiles.
• DO UTILIZADOR defina o UID (ou nome de usuário) que deve executar o contêiner.
• VOLUME é usado para permitir o acesso do contêiner a um diretório na máquina host.
• DIR_TRABALHO define o caminho onde o comando, definido com CMD, deve ser executado.
• RÓTULO permite que você adicione um rótulo à sua imagem do Docker.

Nem todas as palavras-chave são necessárias para que um Dockerfile funcione. Caso em questão, nosso exemplo só fará uso de DE, MANUTENTORe CORRER.

Construindo o Dockerfile

Antes de criarmos o Dockerfile, precisamos criar um novo diretório para trabalhar. Nós criaremos o dockerbuild diretório com o comando:

mkdir ~/dockerbuild

Mude para esse diretório recém-criado com o comando:

cd ~/dockerbuild

Agora vamos criar nosso Dockerfile. Crie o novo arquivo com o comando:

nano Dockerfile

Dentro desse arquivo, cole o seguinte:

FROM ubuntu:latest

MAINTAINER NAME EMAIL

RUN apt-get -y update

RUN apt-get -y upgrade

RUN apt-get install -y build-essential

Onde NOME é seu nome completo e EMAIL é seu endereço de e-mail.

Salve e feche esse arquivo.

Construindo sua imagem

Com o Dockerfile concluído, agora você pode construir a imagem desse arquivo. Emita o comando (de dentro do ~/dockerbuild diretório):

docker build -t "NAME:Dockerfile" .

Onde NAME é o nome da nova imagem a ser criada. É importante observar que NAME deve estar todo em letras minúsculas, caso contrário a compilação falhará.

Por exemplo: digamos que você queira criar imagens para desenvolvimento web, desenvolvimento de aplicativos e desenvolvimento de segurança. Você poderia emitir os seguintes comandos:

docker build -t "appdev:Dockerfile" .

docker build -t "webdev:Dockerfile" .

docker build -t "secdev:Dockerfile" .

Isso iniciará o processo de download da imagem ubuntu:latest e construção da imagem de acordo com o Dockerfile (figura 1):

Figura 1: A imagem foi construída.

Assim que a(s) compilação(ões) estiver(em) concluída(s), emita o comando:

docker images

Você deverá ver todas as imagens recém-construídas, agora disponíveis para uso (Figura 2):

Figura 2: Imagens recém-criadas prontas para serem implantadas.

Dockerfile para Rocky Linux

Digamos que você queira criar uma imagem usando Rocky Linux que atualize a imagem extraída do Rocky Linux e instale um servidor web. Para isso, primeiro criaríamos um novo diretório com o comando:

mkdir ~/rockylinux

Mude para esse diretório com o comando:

cd ~/rockylinux

Crie o novo Dockerfile com o comando:

nano Dockerfile

Cole o seguinte conteúdo nesse arquivo:

FROM rockylinux:9

MAINTAINER NAME EMAIL

RUN dnf makecache

RUN dnf upgrade -y

RUN dnf install -y httpd

Onde NOME é o seu nome e EMAIL é o seu endereço de e-mail.

Salve e feche o arquivo. Construa a imagem com o comando:

docker build -t “webdev_rockylinux:Dockerfile” .

Dependendo de quanta atualização for necessária, esta compilação específica demorará um pouco mais do que a imagem do Ubuntu. Assim que a compilação for concluída, emita o comando imagens da janela de encaixe para ver se sua imagem recém-criada (baseada em CentOS) está pronta (Figura 3):

Figura 3: A imagem do Rocky Linux está disponível para implantação.

Construção de imagem facilitada

E isso é tudo para construir imagens Docker com Dockerfiles. Este é um método muito mais eficiente e padrão para criar novas imagens do que confirmar alterações em uma imagem extraída. Depois de dominar Dockerfiles, não há limite para os tipos de imagens que você pode criar.

(Nota do editor: esta postagem foi atualizada. Foi publicada originalmente em 19 de junho de 2019).

A postagem Noções básicas do Docker: como usar Dockerfiles apareceu pela primeira vez em The New Stack.