Docker Exec: Seu Comando Padrão para Executar Comandos no Docker

Tutoriais
Docker

Já precisaste de ver o que está a acontecer dentro de um recipiente Docker? Os contentores devem ser idempotentes: se houver um problema, redesenha um novo recipiente. Muitas vezes, a vida não é tão simples. Precisas de executar comandos no recipiente para identificar o problema. Aqui é onde o comando docker exec pode ajudar.

Este artigo irá ensinar-te como executar comandos num recipiente Docker em execução usando o comando docker exec.

Pré-requisitos

Para acompanhar os exemplos neste artigo, precisarás de cumprir o seguinte.

  • Qualquer versão recente do Docker Desktop funcionará no Windows, Linux ou macOS. Este tutorial utiliza a v3.1.0 a correr no Windows 10.

Relacionado:Implantar o teu Primeiro Recipiente com o Docker para o Windows

Começar um Recipiente NGINX

O exec do Docker executa comandos nos contentores. Mas, para isso, precisas primeiro de ter um recipiente para executar esses comandos. Vamos começar por descarregar uma imagem Docker e criar um recipiente de demonstração.

  1. Cria um novo diretório, este tutorial usa C:\gitrepos\test, para guardar os ficheiros usados no recipiente.

2. Crie um arquivo chamado dockerfile (sem extensão), contendo o seguinte código. O Dockerfile define as etapas necessárias para criar um contêiner. 

FROM nginx:alpine
 COPY index.html /usr/share/nginx/html/index.html

3. Em seguida, crie um arquivo, no mesmo diretório, chamado index.html, que contém o seguinte código. Este é um arquivo HTML que, quando o contêiner for iniciado, exibirá uma mensagem de Hello World. 

<!DOCTYPE html> 
<html lang="en"> 
<head> 
    <meta charset="UTF-8"> 
    <meta name="viewport" content="width=device-width, initial-scale=1.0"> 
    <meta http-equiv="X-UA-Compatible" content="ie=edge"> 
    <title>Hello World - Nginx Docker</title> 
    <style> 
       h1{ font-weight:lighter; font-family: Arial, Helvetica, sans-serif; 
       } 
    </style> 
    </head> 
    <body> 
       <h1> 
          Hello World 
       </h1> 

    </body> 
    </html>

4. Agora crie o contêiner Docker do Nginx. Como o Dockerfile está no diretório de trabalho atual, especifique . para informar ao mecanismo do Docker para procurar lá. Além disso, certifique-se de marcar o contêiner com my-nginx usando o parâmetro t para facilitar a referência futura. 

docker build -t my-nginx .
Creating a Docker container with the build command.

5. Agora que o contêiner está construído, inicie o contêiner com o comando Docker run. 

# rm - Informa ao Docker para excluir o contêiner após ele parar 
# d - Retorna o controle da linha de comando após o comando ser executado 
# p - Mapeia a porta interna do contêiner 80 para uma porta externa 80 docker run --rm -d -p 80:80 my-nginx
Start the container with the Docker run command.

6. Por fim, abra seu navegador da web e acesse http://localhost/ para ver o seguinte.

Output of the running NGINX container.

Executando Comandos com Docker Exec

Quando executar comandos em um contêiner Docker, talvez seja necessário executar um comando interativamente. Executar comandos interativamente significa digitar um comando, obter feedback, digitar outro comando, etc. Comandos interativos assumem o controle da sua sessão e impedem que você faça qualquer outra coisa.

Mas e se você já souber os comandos a serem enviados para o contêiner antecipadamente e quiser executar comandos em segundo plano? Nesse caso, você pode executar comandos não interativos. Comandos não interativos permitem que você envie um comando para o Docker e retorne instantaneamente o controle do console.

Localizando o Nome e ID do Contêiner

Agora que você construiu o contêiner, pode executar comandos dentro dele. Antes de executar um comando, localize o nome ou ID do contêiner NGINX. Tanto o nome quanto o ID funcionarão em comandos Docker. Nesse sentido, lembrar do ID pode ser mais desafiador do que o nome!

Para exibir informações sobre qualquer contêiner em execução, execute o comando Docker ps para obter as seguintes informações.

docker ps
Displaying running Docker containers.

Copie o ID único, e17e4b6be01a, ou o nome gerado aleatoriamente mystifying_chandrasekhar para a área de transferência para uso posterior.

Executando um Comando Não Interativo com o Docker Exec

Como exemplo de execução de um comando não interativo, copie e execute o comando abaixo para retornar uma lista de arquivos no diretório /var/log com o comando ls -l. Passe tudo após o nome do contêiner, mystifying_chandrasekhar, para o comando Docker exec.

docker exec mystifying_chandrasekhar ls -l /var/log
Executing a directory listing within the NGINX container.

Avoidar Saída no Console com Comandos do Docker

Ao retornar instantaneamente o controle do shell para o usuário, operações grandes evitam prender o console. Abandone a saída no console com a opção d desanexada. O comando abaixo cria o arquivo /tmp/execWorks via comando touch dentro do contêiner e não exibe nenhuma saída no console.

docker exec -d mystifying_chandrasekhar touch /tmp/execWorks

Executando Comandos Interativos com Docker Exec

Até este ponto, você aprendeu como executar comandos não interativos em um contêiner Docker com docker exec. Mas, você pode enfrentar um momento em que precisa solucionar problemas com um contêiner, por exemplo, quando precisa emitir comandos para o contêiner de forma interativa. Nesse caso, você precisa executar comandos interativamente.

Executar comandos de forma interativa com docker exec requer duas opções, i e t. A opção i mantém o STDIN aberto, permitindo que os comandos sejam enviados para o contêiner, e a opção t aloca um pseudo-TTY (PTY), um canal de comunicação, para digitar comandos.

Copie e cole o seguinte comando para abrir um prompt de comando interativo para o contêiner Docker em execução com o shell Bourne (sh), conforme indicado pela alteração do prompt para / #.

docker exec -it mystifying_chandrasekhar sh
Running an interactive Docker shell.

Uma vez no shell, execute agora os comandos abaixo para demonstrar a listagem de arquivos de dentro do contêiner. Finalmente, execute o comando exit para sair do shell interativo.

ls -l /var/log
exit
Open an interactive command prompt to the container.

Para abrir um prompt interativo em um diretório específico, passe o caminho para a opção w, informando ao Docker para iniciar o shell em um diretório especificado.

Passando Variáveis Ambientais para um Contêiner em Execução

Muitos programas utilizam variáveis de ambiente para configurar as opções durante a inicialização. Por exemplo, a maioria das aplicações Java requer que a variável de ambiente JAVA_HOME seja configurada com o caminho do Java.

Você pode passar variáveis de ambiente para uma sessão usando a opção e. Por exemplo, talvez você precise inserir uma variável de ambiente chamada MYVAR em um contêiner em execução. Para fazer isso, use a opção e e forneça o par chave/valor de MYVAR="<algum valor>", conforme mostrado abaixo.

docker exec -it -e MYVAR="hello" mystifying_chandrasekhar sh
echo $MYVAR
Pass environment variables

Passando Variáveis de Ambiente Com um Arquivo

Se você tiver muitas variáveis de ambiente ou uma configuração compartilhada, armazenar essas variáveis em um arquivo pode ser mais fácil. Passe o arquivo através de um caminho relativo ou absoluto para o Docker com a opção --env-file. Essa técnica é frequentemente usada para fornecer credenciais seguras a um contêiner. Certifique-se de nunca incluir credenciais no controle de versão!

Crie um arquivo de texto chamado env-vars.txt com as variáveis de ambiente a serem passadas e seus valores. Este arquivo pode ter qualquer nome que você desejar e não precisa da extensão .txt.

Text file with environmental variables defined.

Passe as variáveis de ambiente para o Docker com a opção env-file. Verifique se as variáveis estão disponíveis com o comando echo, conforme mostrado na captura de tela abaixo.

# Passe o arquivo env-vars.txt e abra um prompt interativo
docker exec -it --env-file env-vars.txt mystifying_chandrasekhar sh
# Verifique se as variáveis ambientais estão disponíveis no contêiner Docker
echo $MYVAR
echo $FOO
echo $SOMETHING
Passing a environmental variables file to Docker and verifying the environment variables exist in the container.

Interagindo com um Contêiner em Execução como um Usuário Diferente

Na produção, as aplicações frequentemente são executadas como um usuário específico para restringir seu acesso. Se estiver executando aplicações como um usuário específico na produção, você também deve fazer isso ao testar comandos.

Neste exemplo, o contêiner Docker é executado como o usuário nginx. Passe o usuário para a opção w para dizer ao Docker para iniciar o contêiner como a conta nginx. O comando whoami, executado de dentro do contêiner, confirma que o usuário nginx está de fato sendo utilizado.

docker exec -it -u nginx mystifying_chandrasekhar sh
whoami
Running the container as the nginx user.

Próximos Passos

Você aprendeu como executar comandos dentro de um contêiner em execução usando o comando docker exec. Utilizando o comando exec para entrar e interrogar contêineres em execução, você tem uma nova ferramenta poderosa em seu arsenal para solucionar problemas com contêineres Docker.

Agora tente levar o que aprendeu um passo adiante e use o controle de versão Git para puxar um site estático para o contêiner, em vez de copiar um único arquivo. Se Git é novo para você, então o artigo Um Guia para Iniciantes sobre Visual Studio Code e Git é um ótimo lugar para começar.

Source:
https://adamtheautomator.com/docker-exec/