Introdução

Neste laboratório, você aprenderá como usar o comando docker container diff para inspecionar as alterações no sistema de arquivos dentro de um container Docker. Começaremos executando um container Nginx simples e, em seguida, usaremos docker container diff para examinar as modificações iniciais no sistema de arquivos feitas após a criação do container.

Após a inspeção inicial, você fará alterações dentro do container em execução. Por fim, você usará docker container diff novamente para observar e entender as diferenças no sistema de arquivos resultantes dessas modificações. Este exercício prático fornecerá experiência prática no uso deste valioso comando Docker para depuração e compreensão do comportamento do container.

Executar um container Nginx

Nesta etapa, aprenderemos como executar um servidor web Nginx simples dentro de um container Docker. O Docker nos permite empacotar aplicativos e suas dependências em containers, garantindo que eles sejam executados de forma consistente em diferentes ambientes.

Primeiro, precisamos garantir que a imagem Nginx esteja disponível em nosso sistema. Podemos baixar a imagem oficial do Nginx do Docker Hub usando o comando docker pull. Este comando baixa a imagem para sua máquina local.

docker pull nginx:latest

Você deve ver uma saída indicando que a imagem está sendo baixada. Depois que o download for concluído, você pode verificar se a imagem está disponível listando as imagens em seu sistema:

docker images

Você deve ver nginx listado na saída.

Agora, vamos executar o container Nginx. Usaremos o comando docker run. A flag -d executa o container em modo detached (em segundo plano), e a flag -p 80:80 mapeia a porta 80 em nossa máquina host para a porta 80 dentro do container. Isso nos permite acessar o servidor web Nginx do nosso navegador host. Também damos ao container um nome usando --name my-nginx-container para facilitar a identificação.

docker run -d -p 80:80 --name my-nginx-container nginx

Após executar o comando, o Docker exibirá uma string longa, que é o ID do container. Isso indica que o container foi iniciado com sucesso em segundo plano.

Para verificar se o container está em execução, você pode usar o comando docker ps, que lista todos os containers em execução:

docker ps

Você deve ver my-nginx-container listado com o status Up.

Finalmente, vamos acessar o servidor web Nginx de nossa máquina host. Como mapeamos a porta 80, podemos usar curl para fazer uma requisição HTTP para localhost na porta 80.

curl localhost

Você deve ver o HTML da página de boas-vindas padrão do Nginx na saída. Isso confirma que o container Nginx está em execução e acessível.

Inspecionar as alterações iniciais no sistema de arquivos usando docker container diff

Nesta etapa, exploraremos como inspecionar as alterações no sistema de arquivos que ocorrem quando um container Docker é iniciado. O Docker usa um sistema de arquivos em camadas (layered filesystem), e quando um container é executado, uma nova camada gravável é adicionada no topo das camadas da imagem. O comando docker container diff nos permite ver as diferenças introduzidas nesta camada gravável desde que o container foi criado.

O comando docker container diff recebe o nome ou ID do container como um argumento. Usaremos o nome do container Nginx que iniciamos na etapa anterior, que é my-nginx-container.

docker container diff my-nginx-container

Ao executar este comando imediatamente após iniciar o container, você provavelmente verá uma lista de arquivos e diretórios. A saída mostra as alterações no sistema de arquivos do container em relação à imagem base. O formato da saída é tipicamente:

• A indica que um arquivo ou diretório foi adicionado.
• C indica que um arquivo ou diretório foi alterado.
• D indica que um arquivo ou diretório foi excluído.

As alterações iniciais que você vê geralmente estão relacionadas ao processo de inicialização do container, como a criação de arquivos temporários, arquivos de log ou alterações em diretórios do sistema. Estes são os arquivos e diretórios que são criados ou modificados na camada gravável do container quando ele é iniciado.

Compreender essas alterações iniciais nos ajuda a ver o que acontece por dentro quando um container é lançado e como a camada gravável é preenchida.

Fazer alterações dentro do container

Nesta etapa, faremos algumas alterações no sistema de arquivos dentro do container Nginx em execução. Isso demonstrará como as modificações dentro de um container são registradas em sua camada gravável.

Usaremos o comando docker exec para executar comandos dentro do container. O comando docker exec nos permite executar um comando em um container em execução. Precisamos especificar o nome do container (my-nginx-container) e o comando que queremos executar.

Primeiro, vamos criar um novo arquivo dentro do diretório /tmp do container. Usaremos o comando touch.

docker exec my-nginx-container touch /tmp/my_new_file.txt

Este comando executa touch /tmp/my_new_file.txt dentro do my-nginx-container. Você não verá nenhuma saída se o comando for bem-sucedido.

Em seguida, vamos modificar o arquivo index padrão do Nginx. A página de boas-vindas padrão do Nginx geralmente está localizada em /usr/share/nginx/html/index.html dentro do container. Usaremos o comando echo para anexar algum texto a este arquivo.

docker exec my-nginx-container echo "<h1>Hello from LabEx!</h1>" >> /usr/share/nginx/html/index.html

Este comando anexa a string HTML "

Hello from LabEx!

Para verificar se as alterações foram feitas, você pode novamente usar curl de sua máquina host para acessar o servidor Nginx.

curl localhost

Você deve agora ver o conteúdo original da página de boas-vindas do Nginx seguido por "

Hello from LabEx!

Essas alterações que fizemos (criando um novo arquivo e modificando um existente) são registradas na camada gravável do my-nginx-container. Na próxima etapa, usaremos docker container diff novamente para ver essas alterações específicas.

Inspecionar as alterações atualizadas no sistema de arquivos usando docker container diff

Nesta etapa final, usaremos o comando docker container diff novamente para observar as alterações no sistema de arquivos que fizemos na etapa anterior. Isso mostrará claramente como nossas ações dentro do container são refletidas em sua camada gravável.

Lembre-se que na etapa anterior, criamos um novo arquivo /tmp/my_new_file.txt e modificamos o arquivo /usr/share/nginx/html/index.html dentro do my-nginx-container. Agora, vamos executar docker container diff no container novamente.

docker container diff my-nginx-container

Desta vez, a saída deve incluir as alterações que fizemos. Você deve ver linhas semelhantes a estas:

A /tmp/my_new_file.txt
C /usr/share/nginx/html/index.html

A linha A /tmp/my_new_file.txt indica que um novo arquivo chamado my_new_file.txt foi Adicionado no diretório /tmp. A linha C /usr/share/nginx/html/index.html indica que o arquivo index.html no diretório /usr/share/nginx/html/ foi Alterado.

Esta saída confirma que docker container diff mostra efetivamente as modificações feitas no sistema de arquivos do container desde que foi iniciado. Essas alterações são armazenadas na camada gravável do container, que é separada das camadas da imagem base. Este é um conceito fundamental no sistema de arquivos em camadas (layered filesystem) do Docker e como os containers mantêm seu estado.

Quando o container é removido, essa camada gravável também é removida, e quaisquer alterações feitas dentro do container são perdidas, a menos que sejam persistidas usando volumes ou bind mounts (que são tópicos para outro laboratório).

Para limpar, você pode parar e remover o container:

docker stop my-nginx-container
docker rm my-nginx-container

Isso conclui nossa exploração de docker container diff. Você aprendeu como inspecionar as alterações iniciais no sistema de arquivos quando um container é iniciado e como ver as alterações que você faz dentro de um container em execução.

Resumo

Neste laboratório, aprendemos como executar um container Nginx simples usando docker run, garantindo que ele fosse acessível via mapeamento de portas e verificando seu status com docker ps. Em seguida, exploramos o comando docker container diff para inspecionar as alterações iniciais no sistema de arquivos introduzidas pelas camadas da imagem do container após a criação.

Posteriormente, praticamos a realização de modificações dentro do sistema de arquivos do container em execução e utilizamos docker container diff novamente para observar e entender como essas alterações são rastreadas e refletidas pelo Docker, destacando a utilidade do comando na identificação de diferenças entre o estado atual do container e sua imagem base.