DEV Community: Heyglon Fábio

GUIA PRÁTICO DE COMANDOS DO DOCKER #5

Heyglon Fábio — Fri, 01 Aug 2025 00:36:08 +0000

Neste artigo, iremos falar um pouco sobre Commit, Export e Import

1. Comando `commit`

O comando commit é utilizado para criar uma nova imagem baseada no estado atual de um container. Isso é útil quando você deseja preservar modificações feitas manualmente dentro de um container.
Exemplo Prático

1.1. Crie um container Alpine com shell habilitado:
docker container run -dt --name alpine-commit alpine:latest
1.2. Acesse o container:
docker container exec -it alpine-commit sh
1.3. Crie um arquivo dentro do container:
echo "Arquivo criado dentro do container" > container-file
Verifique o conteúdo:
cat container-file
1.4. Abra um novo terminal no host e gere a imagem baseada no container:
docker container commit alpine-commit alpine:custom
Neste caso:

alpine: nome da imagem

custom: tag personalizada

1.5. Confirme a criação da imagem
docker image ls
Você verá a nova imagem alpine:custom listada

2. Comando `export`

O comando export salva o sistema de arquivos de um container em um arquivo compactado .tar.
Diferente do commit, ele não cria uma imagem diretamente, apenas gera um snapshot do container.
Exemplo Prático

2.1. Crie um container Alpine:
docker container run -dt --name alpine-export alpine:latest
2.2. Acesse o container:
docker container exec -it alpine-export sh
2.3. Instale o pacote curl dentro do container (simulando uma modificação):
apk add curl
2.4. Abre um novo terminal no host e exporte o container:
docker container export alpine-export -o alpine-export.tar
A flag -o define o nome do arquivo de saída (output).

Agora você terá um arquivo chamado alpine-export.tar contendo o sistema de arquivos do container.

3. Comando `import`

O comando import transforma um arquivo .tar (gerado pelo export ou outros métodos) em uma nova imagem Docker.
Exemplo Prático

3.1. Importe o arquivo exportado anteriormente:
docker imagem import alpine-export.tar alpine:export
Neste caso, alpine é o nome da imagem e export é a tag da imagem.
3.2. Crie um container usando essa nova imagem:
docker container run -it --name alpine-import --entrypoint /bin/sh alpine:export
3.3. Verifique se as alterações ainda estão presentes (ex.: curl):
curl --version
Se o pacote estiver instalado, isso confirma que o estado do container foi preservado.

Resumo das Diferenças

commit : Cria uma nova imagem a partir de um container.
export : Gera um arquivo.tar com o sistema de arquivos do container.
import : Cria uma imagem a partir de um arquivo .tar.

GUIA PRÁTICO DE COMANDOS DO DOCKER #4

Heyglon Fábio — Thu, 31 Jul 2025 00:46:35 +0000

Neste artigo, iremos usar falar um pouco de: exec, cp, variáveis de ambiente e health check.

1. Comando `exec`

O comando exec permite executar comandos dentro de um container em execução.
Para acessar o container em modo interativo:
docker container exec -it meu-nginx bash

Note que:

-it: habilita modo interativo

bash: acessa o shell Bash como usuário root (se disponível)

Se você deseja apenas executar um comando sem entrar no shell, por exemplo listar os arquivos:
docker container exec meu-nginx ls

Isso retornará as pastas do diretório atual dentro do container.

Também é possível criar arquivos dentro do container:
docker container exec meu-nginx touch arquivo.txt

2. Comando `cp`

O comando cp permite copiar arquivos do container para o host e do host para o container.

Copiar do Container para o Host

1. Acesse o container: docker container exec -it meu-nginx bash
2. Dentro do container, crie um arquivo: echo "Arquivo criado no container" > container-file
3. Descubra o caminho do arquivo: pwd
4. No hosto copie o arquivo do container: docker container cp meu-nginx:/container-file .

Note que a / significa que o arquivo foi criado na pasta root do container e o . significa que o arquivo será copiado para o diretório atual do host

Copiar do Host para o Container

1. No host, crie um arquivo: echo "Arquivo criadno no host" > host-file
2. Copie para dentro do container: docker container cp host-file meu-nginx:/host-file
3. No container, verifique o conteúdo: cat /host-file

Obs.: para visualizar o conteúdo dos arquivos, utilize cat <nome-do-arquivo>

3. Variáveis de Ambiente, Hostname e Modo Read-Only

3.1 Variáveis de Ambiente
Podemos passar variáveis de ambiente criação do container:
docker container run -it --name alpine-environment -e VAR1=abc123 -e VAR2=def456 alpine:latest

Dentro do container use o comando env para verificar as variáveis criadas.

3.2 Modo Read-Only
O modo somente leitura impede qualquer alteração no sistema de arquivos:
docker container run -it alpine-read-only --read-only alpine:latest
Agora tente criar um arquivo dentro do container:
touch teste.txt

Note que será exibida uma mensagem de erro, indicando que o sistema de arquivos é apenas leitura.

3.3 Alterar o Hostname
Podemos definir um hostname personalizado para um container:
docker container run -it --name ubuntu-hostname --hostname meu-ubuntu ubuntu:24.04
Dentro do container, execute:
hostname

O retorno será meu-ubuntu

4. Health Check

O Health Check é usado para verificar automaticamente o estado de saúde de um container.

4.1 Usando --health-cmd
Crie um container com verificação de saúde:
docker container run -d --name nginx-healtcheck --rm --health-cmd="cat /usr/share/nginx/html/index.html" nginx:latest

Se o arquivo index.html existir, o container será considerado healthy; caso contrário, unhealthy.

4.2 Ajustando Intervalos e Tentativas
Podemos configurar a frequência e o número de tentativas de checks no container:
docker container run -d --name nginx-healthcheck --rm --health-cmd="caat /usr/share/nginx/html/index.html" --health-interval=30s --health-retries=3 --health-timeout=10s nginx:latest

Tempo entre verificações: --health-interval=30s
Número de tentativas antes de marcar como falha: --health-retries=3
Tempo limite para cada verificação: --health-timeout=10s

Verifique o estado: docker container ls
A coluna STATUS mostrará healthy ou unhealthy

GUIA PRÁTICO DE COMANDOS DO DOCKER #3

Heyglon Fábio — Wed, 30 Jul 2025 00:29:19 +0000

Neste artigo, estaremos trabalhando um pouco com PORT, LOGS e DIFF em containers.

1. Associando Portas do Host à Porta do Container

Para este exemplo, estaremos criando um container chamado meu-nginx:
docker container run --name meu-nginx -p 8080:80 nginx:latest
Após executar o comando, abra seu navegador de preferência e acesse:
http://127.0.0.1:8080
Se aparecer a página de boas-vindas do NGINX, significa que a configuração foi realizada com sucesso.

Explicação da flag -p:

O formato é -p <porta-do-host>:<porta-do-container>

No exemplo acima, a porta 8080 do host está associada à porta 80 do container

2. Comando Inspect

Para visualizar informações detalhadas do seu container:
docker container inspect meu-nginx

O retorno será um arquivo JSON contendo diversas informações, como:

Configurações de rede

Volumes montados

Variáveis de ambiente

Status do container

3. Comando Port

Para listar quais postas do host estão associadas às portas do container:
docker container port meu-nginx
O retorno mostrará a relação entre portas internas do container e portas do host.

4. Comando Diff

O comando diff mostra alterações realizadas no sistema de arquivos de um container. Para isso, iremos realizar alguns passos para chegar ao resultado esperado.
Passo a passo

Abra dois terminais no mesmo diretório

Baixe a imagem Alpine (caso não tenha ainda): docker image pull alpine:latest

No primeiro terminal, crie um container interativo: docker container run -it --name alpine-diff alpine:latest. Agora você estará dentro do container (note a mudança no prompt)

No segundo terminal, execute: docker container diff alpine-diff. E como nenhuma modificação foi feinda ainda, não haverá retorno.

No primeiro terminal, crie uma arquivo de teste: touch texte.txt

No segundo terminal, rode novamente o comando diff: docker container diff alpine-diff. Agora será mostrado que houve modificação no sistema de arquivos do container.

Significado dos símbolos do diff:

A: Arquivo adicionado

C: Arquivo alterado (changed)

D: Arquivo removido (deleted)

5. Comando Logs

Para visualizar os logs de um container, primeiro criaremos o seguinte container:
docker container run -d --name nginx-logs -p 8000:80 nginx:latest
O container será executado em segundo plano devido ao uso da flag -d.
Agora, visualize os logs:
docker container logs nginx-logs
Porém, para visualizar demais logs, tomaremos como exemplo os logs de acessos:

Abra seu navegador e acesse: http://127.0.0.1:8000. A página de boas-vindas do NGINX será exibida.

Volte ao terminal e execute novamente: docker container logs nginx-logs. Agora vocẽ verá registros de acesso (HTTP, GET) gerados pelo navegador.

Dica: Para acompanhar logs em tempo real, utilize a flag -f de modo que o comando fique:
docker container logs -f nginx-logs

GUIA PRÁTICO DE COMANDOS DO DOCKER #2

Heyglon Fábio — Fri, 25 Jul 2025 00:42:12 +0000

Trabalhando com Containers no Docker

Para este artigo, iremos criar um novo container chamado meu-nginx para servir de exemplo e pegando a imagem atual do nginx como referência.

1. Criando um Container

docker container create --name meu-nginx nginx:latest

Note que o container foi criado mas não iniciado.

2. Modificando o Entrypoint

Para alterar o entrypoint da imagem (ponto de entrada do container), utilize:
docker container run --entrypoint /bin/bash nginx:latest

3. Executando um Container em Segundo Plano

Para utilizar um container, sem a necessidade do terminal ficar travado, utilize:
docker container run -d meu-nginx

A flag -d significa detached mode

4. Autoremover um Container

Para que um container seja automaticamente removido após a sua execução (útil para testes rápidos), utilize:
docker container run --rm meu-nginx

5. Nomeando um Container

Você pode dar um nome ao container para facilidar seu gerenciamento:
docker container run --name <nome-do-container> nginx:latest

6. Iniciando um Container

Existem três formas de iniciar um container criado:

Pelo nome:
docker container start meu-nginx
Pelo ID abreviado (12 caracteres):
docker container start <ID_12>
Pelo ID completo:
docker container start <ID_COMPLETO>

Para descobrir o ID do container, utilize docker container ls -a

7. Parando um Container

Para parar um container em execução:
docker container stop meu-nginx
Outra opção é o comando kill, que força o encerramento imediado:
docker container kill meu-nginx

Diferenças entre Stop e Kill:

stop: envia um sinal de término (sigterm), permitindo que o processo finalize de forma graciosa (código de saída 0)
kill: engia um sinal de interrupção imediada (sigkill), encerrando o processo forçadamente (código de saída 173)

8. Pausar um Container

Para pausar a execução de todos os processos do container:
docker container pause meu-nginx

9. Retomar um Container Pausado

Para retomar a execução do mesmo container:
docker container unpause meu-nginx

10. Remover um Container

Para remover um container que não é mais necessário:
docker container rm meu-nginx

11. Reiniciando um Container

Neste exemplo, sugiro que tenha dois terminais abertos no mesmo diretório. No primeiro terminal você pode iniciar um novo container apenas para teste:
docker container run --name nginx-teste nginx:latest
Já no segundo terminal, podemos reiniciar o container de teste:
docker container restart nginx-teste

Note que após o comando de restart no segundo terminal, o container foi parado e iniciado automaticamente no primeiro terminal.

12. Renomeando um Container

Para alterar o nome de um container existente:
docker container renamde <nome-atual> <novo-nome>

13. Comando Wait

Para obter o código de saída de um container após ele ser finalizado:
docker container wait meu-nginx

Se o container foi finalizado com sucesso, o código de saída será 0. Outros códigos indicam diferentes tipos de falhas.

GUIA PRÁTICO DE COMANDOS DO DOCKER #1

Heyglon Fábio — Thu, 24 Jul 2025 00:14:09 +0000

1. Comandos Básicos de Imagens

1.1 Visualizar Ajuda

Para visualizar os comandos básicos do Docker, utilize:
docker image -- help

1.2 Baixar Imagem

Para baixar uma imagem, utilizamos os repositórios oficiais das imagens no Docker Hub e utilizamos a seguinte linha de comando:
docker image pull <nome-do-repo>:<tag>
Exemplo:
docker image pull nginx:latest

1.3 Listar Imagens

Para listar as imagens baixadas, rode o seguinte comando:
docker image ls
Podemos também listar apenas os ID's das imagens:
docker image ls -q

1.4 Inspecionar Imagens

Para visualizar informações detalhadas de uma imagem:
docker image inspect <repositorio>:<tag>
Podemos pegar como exemplo o NGINX em sua última versão:
docker image inspect nginx:latest

Note que esta linha de comando irá retornar um JSON contendo dados da imagem como camadas, arquitetura, variáveis de ambiente, volumes, entre outros.

1.5 Salvar Imagem (compactar)

Para exportar uma imagem para um arquivo compactado:
docker image save nginx -o nginx.tar

Note que a flag -o significa output (saída).
O arquivo nginx.tar poderá ser transferido para outro host ou armazenado como backup.

1.6 Carregar Imagem (descompactar)

Se você tiver uma imagem exportada (por exemplo, nginx.tar), pode carregá-la novamente:
docker image load -i nginx.tar

A flag -i significa input (entrada).

1.7 Remover Imagem

Para remover uma imagem que não está mais em uso:
docker image rm <id>
Além do ID, é possível usar o nome do repositório:
docker image rm nginx
Se houver múltiplas imagens com a mesma referência, utilize a flag de forçar para remover:
docker image rm --force nginx

2. Comandos Básicos de Containers

2.1 Executar um Container

Para rodar o NGINX na porta 8080 local apontando para a 80 do container:
docker container run --name meu_nginx -d -p 8080:80 nginx:latest

--name: nome amigável para o container

-d: modo detached (em background)

-p: mapeamento de portas (host:container)

2.2 Listar Containers

Para listar apenas os containers em execução:
docker container ls
Para listar todos os containers (inclusive parados):
docker container ls -a

2.3 Acessar Terminal de um Container

Para rodar linhas de comando em um container:
docker exec -it meu_nginx /bin/bash
ou caso use Alpine:
docker exec -it meu_nginx sh

2.4 Parar e Iniciar Containers

Para iniciar um container existente:
docker container start meu_nginx
Para parar um container em execução:
docker container stop meu_nginx

2.5 Reiniciar Container

Para reiniciar um container:
docker container restart meu_nginx

2.6 Logs de um Container

Para visualizar os logs de um container:
docker logs meu_nginx
Para acompanhar os logs em tempo real:
docker logs -f meu_nginx

2.7 Remover Container

Para remover um container:
docker container rm meu_nginx
Para remover um container que está sendo executado:
docker container rm --force meu_nginx

2.8 Remover Containers Parados

Para remover todos os containers parados com apenas um comando:
docker container prune