Como inspecionar alterações no sistema de arquivos de um contêiner do Docker

0
40


Os contêineres do Docker herdam o sistema de arquivos de sua imagem na compilação inicial. O sistema de arquivos do contêiner pode diferir do conteúdo da imagem após a criação se forem feitas alterações na camada gravável do contêiner.

Calculo de Frigorías para la capac...
Calculo de Frigorías para la capacidad de aire acondicionado Btu y Toneladas refrigeración

A capacidade de inspecionar alterações no sistema de arquivos pode ajudá-lo a depurar problemas e investigar dados ausentes. Os arquivos gravados no sistema de arquivos do contêiner serão perdidos quando esse contêiner for reiniciado ou destruído. Em alguns casos, você pode estar executando inadvertidamente gravações que deveriam ser direcionadas para um volume persistente.

Neste artigo, compartilharemos algumas técnicas para identificar as modificações feitas nos sistemas de arquivos de contêiner. Você pode usar essas informações para rastrear a atividade do contêiner e investigar discrepâncias entre diferentes ambientes.

Usando diferenças do Docker

A CLI do Docker possui um comando interno para essa finalidade. Corre docker diff listará todas as alterações feitas em arquivos e diretórios em um contêiner específico. Aceita o ID ou nome do contêiner que você deseja inspecionar.

Inicie um contêiner simples para fins de demonstração:

$ docker run -it --name alpine alpine:latest sh

Isso iniciará um novo contêiner executando a imagem Alpine. Sua janela de terminal será anexada ao contêiner. Mantenha esta janela aberta.

agora corra docker diff em uma segunda sessão de terminal:

$ docker diff alpine

Nenhuma saída é produzida, pois o novo contêiner ainda corresponde exatamente ao sistema de arquivos da imagem Alpine.

Volte ao seu primeiro terminal que ainda está conectado ao contêiner. Execute alguns comandos que adicionam, removem ou alteram arquivos:

/ # touch demo
/ # touch example

Volte para sua primeira janela de shell. Repita o docker diff comando para ver as alterações que foram feitas:

$ docker diff alpine
A /example
C /root
C /root/.ash_history
A /demo

Agora os dois novos arquivos estão visíveis na saída do comando. Corre touch ele também adicionou entradas ao histórico do shell do contêiner. a modificação para /root/.ash_history também é relatada, bem como a consequente mudança na /root diretório.

Interpretando a saída do Docker Diff

Cada linha de saída produzida por docker diff é precedido por qualquer A, C qualquer D dependendo do tipo de alteração que ocorreu:

  • A – O arquivo ou diretório foi adicionado ao sistema de arquivos do contêiner. Não existe na imagem original.
  • C – O conteúdo do arquivo ou diretório é diferente da versão da imagem.
  • D – Um caminho que está presente na imagem foi removido do contêiner.

Essas informações permitem que você encontre rapidamente discrepâncias que podem explicar dados ausentes ou comportamento inesperado.

Quaisquer alterações no sistema de arquivos que não são mostradas na saída terão caminhos afetados que mapeiam para um volume do Docker. Esses arquivos são armazenados fora do contêiner, independentemente do sistema de arquivos, para que não apareçam para docker diff .

Veja o conteúdo na imagem original

Pode ser útil comparar a versão do arquivo que está incluída na imagem original. Você pode fazer isso criando um novo contêiner e copiando o arquivo. Usar docker create em vez de docker run para que o contêiner seja criado, mas não iniciado. Isso garantirá que as modificações causadas pelo script do ponto de entrada da imagem não afetem a saída.

$ docker create --name temp-container my-image:latest
$ docker cp temp-container:/path/to/file copied-file
$ docker rm temp-container

Uma maneira alternativa é executar o contêiner com um ponto de entrada personalizado que emite o conteúdo do arquivo para o fluxo de saída padrão. Inclui o --rm marque para que o contêiner seja removido automaticamente após a conclusão do comando:

$ docker run --rm --entrypoint cat alpine:latest /path/to/file > copied-file

Comparando as diferenças entre dois contêineres

Às vezes, pode ser necessário comparar as diferenças entre dois contêineres diferentes executando a mesma imagem. primeiro uso docker diff para obter os changelogs individuais:

$ docker diff first-container > first
$ docker diff second-container > second

Agora você pode usar ferramentas padrão do Unix, como o diff Comando para encontrar as diferenças nas duas listas de mudanças:

diff first second
3c3
< A /a-new-file
---
> A /demo

A diferença mostra que /a-new-file foi removido no segundo recipiente enquanto /demo foi adicionado.

Outra maneira de comparar contêineres é usar docker export e o comando tar para acessar uma lista completa de arquivos:

$ docker export demo-container | tar tv
-rwxr-xr-x 0/0               0 2022-06-21 14:21 .dockerenv
drwxr-xr-x 0/0               0 2022-05-23 17:51 bin/
lrwxrwxrwx 0/0               0 2022-05-23 17:51 bin/arch -> /bin/busybox
lrwxrwxrwx 0/0               0 2022-05-23 17:51 bin/ash -> /bin/busybox
lrwxrwxrwx 0/0               0 2022-05-23 17:51 bin/base64 -> /bin/busybox
lrwxrwxrwx 0/0               0 2022-05-23 17:51 bin/bbconfig -> /bin/busybox
...

Repita este comando para ambos os contêineres. Você pode então usar diff para comparar as duas listas. a saída aprimorada do tar pode ajudá-lo a rastrear quando os arquivos foram alterados conforme os tempos de modificação e as permissões são exibidos.

Resumo

Os sistemas de arquivos de contêiner do Docker devem se parecer muito com a imagem a partir da qual foram criados. As discrepâncias podem ocorrer quando o software dentro do contêiner grava o conteúdo diretamente no sistema de arquivos. Os usuários podem ser outra fonte de diferenças, quando mecanismos como docker exec eles são usados ​​para executar comandos dentro de um contêiner em execução.

a docker diff O utilitário fornece uma maneira conveniente de visualizar essas alterações. Embora você não possa ver por que um arquivo foi adicionado ou excluído, a capacidade de recuperar uma lista de modificações pode ser inestimável para entender por que um determinado comportamento é observado.

Neste artigo, nos concentramos em examinar as alterações feitas nos contêineres em execução. Você pode usar diferentes ferramentas como docker history e Mergulhe para inspecionar as alterações feitas nas camadas em uma imagem do Docker. As duas abordagens podem ser usadas juntas, permitindo determinar o ponto exato em que um arquivo foi adicionado ou modificado na pilha de camadas de um contêiner.