Introdução
Os containers Docker são as unidades fundamentais da implantação de aplicações modernas. Neste laboratório, exploraremos técnicas avançadas de gerenciamento de containers que aprofundarão sua compreensão sobre as capacidades do Docker. Abordaremos a execução de containers em diferentes modos, o gerenciamento de seu ciclo de vida, a inspeção de detalhes técnicos, o trabalho com logs, a execução de comandos dentro de containers, a cópia de arquivos, a configuração de variáveis de ambiente e a imposição de limites aos recursos do sistema. Ao final deste laboratório, você terá uma compreensão abrangente de como trabalhar com containers Docker de maneira eficaz.
Executando Containers em Diferentes Modos
O Docker permite executar containers em diferentes modos para atender a diversos casos de uso. Exploraremos dois modos comuns: o modo isolado (detached) e o modo interativo.
Primeiro, vamos executar um container no modo isolado:
docker run -d --name nginx-detached nginx
Este comando realiza o seguinte:
-d: Executa o container em modo isolado (em segundo plano).--name nginx-detached: Atribui o nome "nginx-detached" ao container.nginx: Especifica a imagem a ser usada (ela será baixada do Docker Hub se não estiver disponível localmente).
Você deverá ver uma longa sequência de caracteres como saída, que é o ID do container.
Você pode verificar o status do container executando:
docker ps
Agora, vamos executar um container no modo interativo:
docker run -it --name ubuntu-interactive ubuntu /bin/bash
Este comando realiza o seguinte:
-it: Executa o container em modo interativo com um pseudo-TTY (terminal).--name ubuntu-interactive: Atribui o nome "ubuntu-interactive" ao container.ubuntu: Especifica a imagem a ser usada./bin/bash: O comando a ser executado dentro do container (neste caso, um shell bash).
Agora você deve estar dentro do container Ubuntu. Você pode sair do container digitando exit.
Vamos listar nossos containers ativos:
docker ps
Você deverá ver o container nginx-detached em execução, mas não o container ubuntu-interactive (porque saímos dele).
Gerenciando o Ciclo de Vida do Container
Entender como iniciar, parar e reiniciar containers é crucial para um gerenciamento eficaz.
Vamos começar parando o container nginx-detached:
docker stop nginx-detached
Agora, vamos verificar o status dos nossos containers:
docker ps -a
Você deverá ver que o container nginx-detached está agora no estado "Exited" (Encerrado).
Vamos iniciá-lo novamente:
docker start nginx-detached
Verifique o status mais uma vez:
docker ps
Você verá que o container nginx-detached está agora no estado "Up" (Ativo).
Também podemos reiniciar um container que já está em execução:
docker restart nginx-detached
Para ver o estado atual de todos os nossos containers, incluindo os parados, use:
docker ps -a
Você deverá ver tanto o container nginx-detached quanto o ubuntu-interactive listados, com seus respectivos status atuais.
Vamos remover o container ubuntu-interactive que está parado:
docker rm ubuntu-interactive
E verificar se ele foi removido:
docker ps -a
Você não deve mais ver o container ubuntu-interactive na lista.
Inspecionando Detalhes do Container
O Docker fornece ferramentas poderosas para inspecionar os detalhes de seus containers. Vamos explorá-las.
Para obter informações detalhadas sobre um container, use o comando inspect:
docker inspect nginx-detached
Este comando exibe um array JSON com informações minuciosas sobre o container. Como o volume de dados pode ser grande, vamos usar um filtro para obter informações específicas.
Para obter o endereço IP do container:
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' nginx-detached
Para ver o estado atual do container:
docker inspect -f '{{.State.Status}}' nginx-detached
Esses comandos utilizam templates do Go para filtrar a saída. A flag -f nos permite especificar um modelo de formatação.
Vamos também verificar os mapeamentos de porta:
docker port nginx-detached
O mapeamento de portas permite que os containers se comuniquem com o sistema hospedeiro ou redes externas. Ele vincula uma porta no sistema hospedeiro a uma porta dentro do container. Isso é fundamental para acessar serviços que rodam dentro de containers a partir de fora do ambiente Docker.
Se nenhuma porta estiver mapeada, este comando não produzirá saída. No nosso caso, não mapeamos explicitamente nenhuma porta para o container nginx-detached, então é provável que você não veja nada.
Para demonstrar o mapeamento de portas, vamos criar um novo container Nginx com um mapeamento definido:
docker run -d --name nginx-with-port -p 8080:80 nginx
Este comando mapeia a porta 8080 do hospedeiro para a porta 80 no container. Agora, se verificarmos os mapeamentos de porta:
docker port nginx-with-port
Você verá uma saída semelhante a:
80/tcp -> 0.0.0.0:8080
Isso significa que o tráfego direcionado à porta 8080 da sua máquina hospedeira será encaminhado para a porta 80 no container, onde o Nginx está escutando.
Trabalhando com Logs de Container
Acessar e compreender os logs do container é vital para a resolução de problemas e monitoramento de suas aplicações.
Vamos visualizar os logs do nosso container nginx:
docker logs nginx-detached
Isso mostra todos os logs desde o início do container. Para ver apenas os logs mais recentes, você pode usar a opção --tail:
docker logs --tail 10 nginx-detached
Isso exibe apenas as últimas 10 linhas de log.
Para acompanhar os logs em tempo real (semelhante ao tail -f), use a opção -f:
docker logs -f nginx-detached
Isso continuará transmitindo novas entradas de log conforme elas forem geradas. Pressione Ctrl+C para sair da transmissão de logs.
Você também pode obter carimbos de data/hora (timestamps) para suas entradas de log:
docker logs --timestamps nginx-detached
Isso pode ser particularmente útil para depurar problemas sensíveis ao tempo.
Executando Comandos em Containers Ativos
O Docker permite executar comandos dentro de um container que já está rodando, o que é incrivelmente útil para depuração e manutenção.
Vamos começar executando um comando simples no nosso container nginx:
docker exec nginx-detached echo "Olá de dentro do container"
Você deverá ver "Olá de dentro do container" impresso no seu terminal.
Agora, vamos obter um shell interativo dentro do container:
docker exec -it nginx-detached /bin/bash
Agora você está dentro do container. Vamos explorar um pouco:
ls /etc/nginx
cat /etc/nginx/nginx.conf
exit
Esses comandos listam o conteúdo do diretório de configuração do Nginx e exibem o arquivo de configuração principal. O comando exit retorna você ao shell do seu sistema hospedeiro.
Copiando Arquivos de e para Containers
O Docker oferece uma maneira de copiar arquivos entre o seu sistema hospedeiro e os containers. Isso é útil para tarefas como atualizar arquivos de configuração ou recuperar logs.
Primeiro, vamos criar um arquivo HTML simples no nosso sistema hospedeiro:
echo "<html><body><h1>Olá do hospedeiro</h1></body></html>" > hello.html
Agora, vamos copiar este arquivo para dentro do nosso container nginx:
docker cp hello.html nginx-detached:/usr/share/nginx/html/hello.html
Podemos verificar se o arquivo foi copiado executando um comando no container:
docker exec nginx-detached cat /usr/share/nginx/html/hello.html
Você deverá ver o conteúdo do arquivo HTML.
Agora, vamos copiar um arquivo do container para o nosso hospedeiro:
docker cp nginx-detached:/etc/nginx/nginx.conf ~/project/nginx.conf
Isso copia o arquivo de configuração do Nginx do container para o nosso diretório atual no hospedeiro.
Você pode verificar se o arquivo foi copiado:
ls -l ~/project/nginx.conf
Você deverá ver o arquivo nginx.conf listado.
Configurando Variáveis de Ambiente em Containers
As variáveis de ambiente são uma forma fundamental de configurar aplicações que rodam em containers. Vamos explorar como configurá-las e utilizá-las.
Primeiro, vamos executar um novo container com uma variável de ambiente:
docker run --name env-test -e MY_VAR="Olá, Ambiente" -d ubuntu sleep infinity
Este comando realiza o seguinte:
--name env-test: Nomeia o container como "env-test".-e MY_VAR="Olá, Ambiente": Define uma variável de ambiente chamada MY_VAR.-d: Executa o container em modo isolado.ubuntu: Usa a imagem do Ubuntu.sleep infinity: Mantém o container rodando indefinidamente.
Agora, vamos verificar se nossa variável de ambiente foi configurada:
docker exec env-test env | grep MY_VAR
Você deverá ver MY_VAR=Olá, Ambiente na saída.
Também podemos configurar variáveis de ambiente usando um arquivo. Crie um arquivo chamado env_file com o seguinte conteúdo.
Você pode usar o nano ou o vim para criar o arquivo:
nano env_file
ANOTHER_VAR=Vindo de um arquivo
YET_ANOTHER_VAR=Também vindo do arquivo
Saia do editor e salve o arquivo pressionando Ctrl+X, depois Y e Enter.
Agora, vamos iniciar outro container usando este arquivo:
docker run --name env-file-test --env-file env_file -d ubuntu sleep infinity
Verifique as variáveis de ambiente neste novo container:
docker exec env-file-test env | grep -E "ANOTHER_VAR|YET_ANOTHER_VAR"
Você deverá ver ambas as variáveis do arquivo na saída.
Limitando Recursos do Container
O Docker permite limitar os recursos (CPU e memória) que um container pode utilizar. Isso é crucial para gerenciar a alocação de recursos em ambientes com múltiplos containers.
Vamos iniciar um container com limites de memória e CPU:
docker run --name limited-nginx -d --memory=512m --cpus=0.5 nginx
Este comando realiza o seguinte:
--name limited-nginx: Nomeia o container como "limited-nginx".-d: Executa o container em modo isolado.--memory=512m: Limita o container a 512 megabytes de memória.--cpus=0.5: Limita o container a usar, no máximo, metade de um núcleo de CPU.nginx: Usa a imagem do Nginx.
Podemos verificar esses limites usando o comando inspect:
docker inspect -f '{{.HostConfig.Memory}}' limited-nginx
docker inspect -f '{{.HostConfig.NanoCpus}}' limited-nginx
O primeiro comando retornará 536870912 (512MB em bytes) e o segundo retornará 500000000 (0.5 CPU em nano-unidades).
Para ver como esses limites afetam o container em tempo real, podemos usar o comando stats:
docker stats limited-nginx
Isso mostrará uma transmissão ao vivo das estatísticas de uso de recursos. Pressione Ctrl+C para sair da visualização de estatísticas.
Resumo
Neste laboratório, exploramos técnicas avançadas de gerenciamento de containers no Docker. Aprendemos como executar containers em diferentes modos, gerenciar seu ciclo de vida, inspecionar detalhes técnicos, trabalhar com logs, executar comandos dentro de containers, copiar arquivos, configurar variáveis de ambiente e limitar os recursos do sistema. Essas habilidades formam uma base sólida para trabalhar com containers Docker em cenários mais complexos.
Lembre-se de que o gerenciamento eficaz de containers é crucial para construir aplicações conteinerizadas escaláveis e fáceis de manter. À medida que você continua sua jornada com o Docker, descobrirá que essas habilidades são inestimáveis para depurar, otimizar e gerenciar seus ambientes.
Continue praticando esses comandos e explorando as capacidades do Docker. Quanto mais você trabalhar com containers, mais confortável e proficiente se tornará. Bom trabalho com seus containers!
