Como usar o comando docker commit para criar novas imagens

Introdução

Neste laboratório, você aprenderá como usar o comando docker container commit para criar novas imagens Docker a partir de contêineres existentes. Começaremos lançando e modificando um contêiner, e então faremos o commit dessas alterações em uma nova imagem.

Você também explorará como fazer o commit das alterações do contêiner com novas configurações, incluindo a definição de novas instruções CMD e EXPOSE, demonstrando a flexibilidade de criar imagens personalizadas com base em contêineres em execução.

Iniciar e modificar um contêiner

Nesta etapa, você aprenderá como iniciar um contêiner Docker e fazer alterações dentro dele. Usaremos uma imagem Ubuntu simples para demonstrar o processo.

Primeiro, vamos baixar a imagem Ubuntu. Este comando baixa a imagem Ubuntu do Docker Hub para sua máquina local.

docker pull ubuntu:latest

Você deve ver uma saída indicando que a imagem está sendo baixada. Depois que o download for concluído, você pode executar um contêiner com base nesta imagem.

Agora, vamos executar um contêiner interativo usando a imagem Ubuntu. As flags -it são usadas para alocar um pseudo-TTY e manter o stdin aberto, permitindo que você interaja com o shell do contêiner. A flag --name atribui um nome ao contêiner, tornando mais fácil referenciá-lo mais tarde.

docker run -it --name my-ubuntu ubuntu:latest /bin/bash

Após executar este comando, você estará dentro do shell bash do contêiner. Você pode verificar isso verificando o hostname, que será o ID do contêiner.

Dentro do contêiner, vamos criar um arquivo simples. Usaremos o comando echo para escrever algum texto em um arquivo chamado hello.txt no diretório raiz.

echo "Hello from inside the container!" > /hello.txt

Você pode verificar se o arquivo foi criado e contém o conteúdo correto usando o comando cat.

cat /hello.txt

Você deve ver a saída "Hello from inside the container!".

Agora que fizemos uma alteração dentro do contêiner, vamos sair do shell do contêiner.

exit

Você está agora de volta ao terminal da sua máquina host. O contêiner ainda está sendo executado em segundo plano. Você pode verificar isso listando os contêineres em execução.

docker ps

Você deve ver o contêiner my-ubuntu listado.

Fazer commit das alterações do contêiner em uma nova imagem

Na etapa anterior, fizemos uma alteração dentro de um contêiner em execução, criando um arquivo. Agora, aprenderemos como salvar essas alterações como uma nova imagem Docker. Esse processo é chamado de fazer o commit de um contêiner.

Fazer o commit de um contêiner cria uma nova imagem que inclui as alterações que você fez no sistema de arquivos e na configuração do contêiner. Isso é útil para criar imagens personalizadas com base nas existentes.

Para fazer o commit do contêiner, usamos o comando docker commit. A sintaxe básica é docker commit [container_name] [new_image_name]. Faremos o commit do contêiner my-ubuntu e nomearemos a nova imagem my-ubuntu-modified.

docker commit my-ubuntu my-ubuntu-modified

Você deve ver uma longa sequência de caracteres como saída, que é o ID da imagem recém-criada.

Agora, vamos verificar se a nova imagem foi criada. Podemos usar o comando docker images para listar todas as imagens em seu sistema.

docker images

Você deve ver my-ubuntu-modified listado na saída, junto com a imagem ubuntu original.

Para confirmar que as alterações foram salvas na nova imagem, vamos executar um novo contêiner com base em my-ubuntu-modified e verificar a existência do arquivo que criamos na etapa anterior.

docker run -it --name my-ubuntu-test my-ubuntu-modified /bin/bash

Dentro do novo contêiner, verifique a existência do arquivo /hello.txt.

cat /hello.txt

Você deve ver a saída "Hello from inside the container!", confirmando que as alterações foram commitadas com sucesso na nova imagem.

Agora, saia do contêiner.

exit

Finalmente, vamos limpar o contêiner de teste que acabamos de criar.

docker rm -f my-ubuntu-test

Fazer commit das alterações do contêiner com novas configurações

Nesta etapa, exploraremos como fazer o commit das alterações do contêiner e também incluir novas configurações para a imagem resultante. Isso permite que você defina aspectos como o comando padrão a ser executado quando um contêiner é iniciado ou variáveis de ambiente.

Continuaremos usando o contêiner my-ubuntu das etapas anteriores. Primeiro, vamos parar o contêiner, pois faremos o commit de seu estado atual.

docker stop my-ubuntu

Você deve ver o nome do contêiner my-ubuntu impresso como saída, indicando que ele foi parado.

Agora, vamos fazer o commit do contêiner e adicionar um rótulo (label) à nova imagem. Rótulos são pares chave-valor que podem ser anexados a imagens para adicionar metadados. Adicionaremos um rótulo indicando a versão da nossa imagem modificada. Usamos a flag -c seguida pela instrução de configuração.

docker commit -c 'LABEL version="1.0"' my-ubuntu my-ubuntu-labeled

Você deve ver o ID da imagem recém-criada como saída.

Vamos verificar se a nova imagem my-ubuntu-labeled foi criada e se o rótulo foi aplicado. Podemos usar o comando docker inspect para visualizar informações detalhadas sobre a imagem.

docker inspect my-ubuntu-labeled

A saída será um grande objeto JSON. Procure a seção "Labels" dentro do bloco "Config". Você deve encontrar "version": "1.0" listado lá.

Alternativamente, você pode usar docker inspect com filtragem para verificar especificamente o rótulo.

docker inspect --format '{{.Config.Labels}}' my-ubuntu-labeled

Este comando exibirá apenas os rótulos associados à imagem. Você deve ver algo como map[version:1.0].

Também podemos adicionar outras configurações durante o processo de commit, como definir uma variável de ambiente. Vamos fazer o commit do contêiner my-ubuntu novamente, desta vez adicionando uma variável de ambiente.

docker commit -c 'ENV MY_VARIABLE="Hello Docker"' my-ubuntu my-ubuntu-env

Verifique a nova imagem e a variável de ambiente usando docker inspect.

docker inspect --format '{{.Config.Env}}' my-ubuntu-env

Você deve ver uma saída semelhante a [PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin MY_VARIABLE=Hello Docker], confirmando que a variável de ambiente está definida.

Fazer commit das alterações do contêiner com novas instruções CMD e EXPOSE

Nesta etapa final, aprenderemos como fazer o commit das alterações do contêiner e definir o comando padrão (CMD) e as portas expostas (EXPOSE) para a nova imagem.

A instrução CMD define o comando padrão que será executado quando um contêiner for iniciado a partir da imagem sem especificar um comando. A instrução EXPOSE informa ao Docker que o contêiner escuta nas portas de rede especificadas em tempo de execução.

Faremos o commit do contêiner my-ubuntu novamente, desta vez definindo um comando padrão para imprimir o conteúdo de /hello.txt e expondo a porta 80.

Primeiro, certifique-se de que o contêiner my-ubuntu esteja parado.

docker stop my-ubuntu

Agora, faça o commit do contêiner com as instruções CMD e EXPOSE. Observe que a instrução CMD é fornecida como um array JSON de strings.

docker commit -c 'CMD ["cat", "/hello.txt"]' -c 'EXPOSE 80' my-ubuntu my-ubuntu-final

Você deve ver o ID da imagem recém-criada como saída.

Vamos verificar as configurações CMD e EXPOSE da nova imagem my-ubuntu-final usando docker inspect.

docker inspect --format '{{.Config.Cmd}}' my-ubuntu-final

Isso deve gerar [cat /hello.txt], confirmando que o comando padrão está definido.

Agora, vamos verificar as portas expostas.

docker inspect --format '{{.Config.ExposedPorts}}' my-ubuntu-final

Você deve ver uma saída semelhante a map[80/tcp:{}], indicando que a porta 80 está exposta.

Finalmente, vamos executar um contêiner a partir desta nova imagem sem especificar um comando para ver se o CMD padrão funciona.

docker run --rm my-ubuntu-final

A flag --rm remove automaticamente o contêiner quando ele sai. Como o comando padrão é cat /hello.txt, o contêiner deve ser executado, imprimir "Hello from inside the container!" e, em seguida, sair.

Você deve ver "Hello from inside the container!" impresso em seu terminal.

Isso demonstra como você pode fazer o commit das alterações do contêiner e definir o comportamento padrão e a configuração de rede da imagem resultante.

Resumo

Neste laboratório, você aprendeu como iniciar e modificar um contêiner Docker. Você puxou uma imagem Ubuntu, executou um contêiner interativo baseado nela, criou um arquivo dentro do contêiner e, em seguida, saiu do shell do contêiner, mantendo o contêiner em execução.

Posteriormente, você aprendeu como fazer o commit das alterações feitas dentro de um contêiner em execução para criar uma nova imagem Docker. Este processo permite que você salve o estado atual de um contêiner como uma imagem reutilizável.