Usando as Instruções ENTRYPOINT e CMD do Dockerfile – techsyncer

Se você já precisou executar um ou dois comandos em seu contêiner Docker na inicialização, este tutorial é para você. Usando as instruções Dockerfile ENTRYPOINT e CMD, você pode executar quantos comandos de inicialização desejar.

Neste tutorial, você aprenderá como usar as instruções ENTRYPOINT e CMD para executar comandos de inicialização em um Dockerfile e entender as diferenças entre eles.

Pré-requisitos

Já que este tutorial será uma demonstração prática, certifique-se de ter o seguinte em mãos:

A Windows 10 PC – Windows 10 v10.0.19042 was used in this tutorial.
Docker Desktop – Este tutorial utiliza o Docker Desktop v3.3.1.

Criando um Dockerfile

Antes de poder executar comandos de inicialização de contêiner Docker, você deve primeiro criar um Dockerfile. Um Dockerfile é um documento de texto que contém uma lista de comandos para construir contêineres, imagens do Docker e determina como uma imagem do Docker é criada.

1. Primeiro, abra o PowerShell como administrador.

2. Crie uma nova pasta para armazenar o Dockerfile e todos os arquivos associados que este tutorial utilizará e mude para esse diretório. Este tutorial está usando ~/docker.

mkdir ~/docker
cd docker

3. Agora, crie um arquivo de texto em branco chamado Dockerfile com o seguinte comando.

cd > Dockerfile

Alternativamente, você pode criar um Dockerfile com o seguinte comando se estiver no Linux ou no Mac OS.

touch Dockerfile

4. Finalmente, adicione o seguinte conteúdo no Dockerfile

FROM ubuntu:20.04

Você agora criou um Dockerfile prestes a ser utilizado!

Construindo uma Imagem Docker

Agora que você criou seu Dockerfile, você deve construir uma imagem Docker para executar os comandos escritos nas instruções ENTRYPOINT e CMD do seu Dockerfile. Uma maneira de construir uma imagem é usando o comando build.

Enquanto estiver no diretório ~/docker, execute o seguinte comando. O comando abaixo cria uma imagem Docker chamada demo (-t demo) a partir do Dockerfile em ~/docker especificando o diretório de trabalho atual (.).

docker build -t demo .

Rodando um Contêiner Docker

Após ter construído a imagem Docker, você precisará de um contêiner para rodar a imagem Docker que executará os comandos das instruções ENTRYPOINT e CMD do Dockerfile.

Para executar um contêiner Docker, invoque o comando run para criar uma camada de contêiner gravável sobre a imagem Docker (demo). O exemplo abaixo está utilizando o parâmetro -it para se conectar de forma interativa ao contêiner, para que você possa ver a saída de amostra.

docker run -it demo

Exec vs. Forma de Shell

Ao começar a trabalhar com um Dockerfile e descobrir como executar comandos de inicialização, você pode se deparar com dois métodos diferentes de definir esses comandos. Cada método invocará comandos, mas o faz de forma um pouco diferente.

Quando o Docker executa comandos, ele pode fazê-lo diretamente chamando exec ou passando pelo shell do contêiner (/bin/sh -c no Linux ou cmd /S /C no Windows), chamado shell.

Você notará que os comandos executados via exec têm uma instrução seguida pelos executáveis a serem invocados seguidos por um ou mais argumentos de linha de comando, como mostrado abaixo.

ENTRYPOINT ["executables", "parameter1", "parameter2", ...]
CMD ["executables", "parameter1", "parameter2:, ...]

Escrever comandos na forma de shell, por outro lado, não requer envolver os comandos em colchetes, como mostrado abaixo.

ENTRYPOINT <command> "parameter1"
CMD <command> "parameter1"

Se você não especificar um argumento para CMD, o Docker sempre executará o comando na forma de exec, por exemplo CMD <command>.

Se você está apenas começando, diferenciar entre essas duas invocações de comando não importará muito, mas à medida que você se torna mais avançado, logo verá os benefícios e desvantagens de cada uma.

Executando Comandos de Inicialização

Vamos agora entrar no cerne deste tutorial e sujar as mãos percorrendo alguns exemplos de execução de comandos de inicialização dentro de um Dockerfile, usando as instruções ENTRYPOINT e CMD.

1. Abra o Dockerfile que você criou anteriormente no seu editor de texto preferido.

2. Copie e cole o conteúdo do exemplo do Dockerfile no seu Dockerfile, conforme mostrado abaixo, e salve-o.

Este Dockerfile cria uma camada usando a imagem base ubuntu:20.04. Em seguida, diz ao Docker para invocar o comando echo, passando o argumento Hello world tanto para as instruções CMD quanto ENTRYPOINT do Dockerfile, usando as formas exec e shell.

FROM ubuntu:20.04
# Instrução CMD
CMD ["echo", "Hello world"] # Exec Form
CMD echo "Hello world"      # Shell Form
# Instrução ENTRYPOINT
ENTRYPOINT ["echo", "Hello world"] # Exec Form
ENTRYPOINT echo "Hello world"      # Shell Form

3. Enquanto estiver no diretório ~/docker, construa a nova imagem executando docker build e chame-a de demo. O comando abaixo etiqueta a imagem como demo e procura por um Dockerfile no diretório de trabalho atual (.).

docker build -t demo .

Building a Docker image with docker build

4. Agora, execute um contêiner usando a imagem e execute um contêiner Docker com base na imagem Docker criada anteriormente. Você verá que o contêiner retorna Hello world, que veio da instrução CMD fornecida no Dockerfile.

docker run -it demo

Running a Docker container with docker run

Usando Variáveis em um Dockerfile

Às vezes, você pode não saber os argumentos exatos da linha de comando para passar para um comando com antecedência. Os argumentos que você precisa passar para um comando são expostos apenas em tempo de execução. Em vez de atribuir estaticamente os argumentos do comando, você pode capturar e passar esses argumentos para comandos com variáveis.

Você só pode usar variáveis Dockerfile no formato shell. O Docker não suporta variáveis em comandos invocados via exec.

Abra o Dockerfile no seu editor de texto preferido novamente, substitua tudo por uma série de comandos a seguir e salve-o.

Você notará que desta vez, o Dockerfile usa variáveis de ambiente e as mostra usando ENV. No exemplo abaixo, o Dockerfile está definindo uma variável de ambiente chamada name com um valor de friend. Uma vez criada, essa variável de ambiente é referenciada por meio de $name.

Quando o Docker executa um contêiner com base neste Dockerfile, ele invocará o comando echo e passará o argumento Bem-vindo, amigo.

FROM ubuntu:20.04
ENV name friend

CMD echo "Welcome, $name"
# ou
## ENTRYPOINT echo "Bem-vindo, $name"

Agora, crie a imagem Docker e execute o contêiner novamente, opcionalmente fornecendo um nome de tag shellform. Você notará que o Docker invocou o comando echo e retornou a saída esperada.

Building a Docker Image (shellform) and Running a Docker Container

Combinando as instruções ENTRYPOINT e CMD do Dockerfile

Muitas vezes, você estará invocando comandos de inicialização seja no CMD ou na instrução ENTRYPOINT. Afinal, você pode invocar quantos comandos desejar usando cada método. No entanto, você também pode invocar um único comando e “adicionar mais comandos” usando ambas as instruções.

Baseando-se nos exemplos anteriores, talvez você tenha um Dockerfile que se pareça com o exemplo abaixo. Como está, se você criar uma imagem e executar um contêiner a partir dessa imagem, o Docker invocaria o comando echo e retornaria Hello.

FROM ubuntu:20.04
ENTRYPOINT ["echo", "Hello"]

Talvez você tenha outro argumento que gostaria de passar para o comando echo, mas não imediatamente. Talvez você queira fazer isso mais abaixo no Dockerfile. Chamando a instrução CMD sem um comando, você pode fazer isso.

Quando você especifica um comando para ser executado via instrução ENTRYPOINT seguido da instrução CMD, o Docker automaticamente assume que o valor passado para CMD é um argumento; não um comando.

Agora, adicione uma referência de instrução CMD sem um comando, apenas um argumento chamado world, como mostrado abaixo.

FROM ubuntu:20.04
ENTRYPOINT ["echo", "Hello"]
CMD ["world"]

Adicionar instruções deve sempre ser escrito na forma exec devido ao seu comportamento “semelhante a uma matriz” de especificar valores individualmente separados por vírgulas em vez de tudo em uma única string.

Depois de construir a imagem e executar o contêiner a partir da imagem, você verá que em vez de duas linhas de saída (Hello e world), o Docker retorna apenas uma, o que significa apenas uma única invocação do comando echo.

Building a Docker Image (demo3) and Running a Docker Container

Conclusão

Você deve agora ter um bom entendimento de como executar comandos de inicialização de contêineres Docker por meio das instruções Dockerfile CMD e ENTRYPOINT. Cada instrução é um pouco diferente, mas realiza a mesma tarefa e até pode ser usada juntas.

Você consegue pensar em um cenário onde você preferiria usar CMD em vez de ENTRYPOINT para executar um comando de inicialização?