Como usar o comando docker compose exec para interagir com serviços

Introdução

Neste laboratório, você aprenderá como usar efetivamente o comando docker compose exec para interagir com serviços em execução. Você explorará a execução de comandos dentro de um container de serviço, a execução de comandos em modo detached (destacado), a execução de comandos como um usuário diferente e a execução de comandos com um diretório de trabalho específico. Esta experiência prática irá equipá-lo com habilidades essenciais para depurar e gerenciar suas aplicações Dockerizadas.

Executar um comando em um container de serviço em execução

Neste passo, você aprenderá como executar um comando dentro de um container Docker em execução. Esta é uma técnica muito útil para depurar ou interagir com um serviço em execução dentro de um container sem precisar pará-lo e reiniciá-lo.

Primeiro, vamos baixar uma imagem Nginx simples para usar nesta demonstração. Usaremos a imagem nginx:alpine, pois ela é pequena e rápida para baixar.

docker pull nginx:alpine

Você deve ver uma saída indicando que a imagem está sendo baixada e extraída.

Em seguida, executaremos esta imagem Nginx em modo detached (destacado), o que significa que o container será executado em segundo plano e não ocupará seu terminal. Também daremos um nome a ele para que seja mais fácil referenciá-lo mais tarde.

docker run -d --name my-nginx nginx:alpine

A saída será o ID do container do container recém-criado e em execução.

Agora que o container está em execução, podemos executar um comando dentro dele usando o comando docker exec. A sintaxe básica é docker exec [options] container command [args...]. Vamos tentar listar os arquivos no diretório raiz do container.

docker exec my-nginx ls /

Você deve ver uma lista de diretórios e arquivos presentes no sistema de arquivos raiz do container Nginx, como bin, etc, usr, etc. Isso confirma que você executou com sucesso um comando dentro do container em execução.

Vamos tentar outro comando. Podemos verificar a versão do Nginx em execução dentro do container.

docker exec my-nginx nginx -v

A saída mostrará a versão do Nginx instalada no container, por exemplo, nginx version: nginx/1.24.0.

Isso demonstra como você pode interagir com um container em execução e executar comandos arbitrários dentro de seu ambiente.

Executar um comando em modo detached (destacado)

No passo anterior, executamos um container em modo detached usando a flag -d. Esta é uma prática comum quando você deseja que um container seja executado em segundo plano sem ocupar seu terminal. Neste passo, exploraremos mais a fundo a execução de comandos em modo detached, especificamente usando docker exec.

Embora docker exec seja tipicamente usado para sessões interativas ou para executar comandos curtos em um container em execução, você também pode executar um comando em modo detached usando a flag -d com docker exec. Isso é útil para iniciar um processo em segundo plano dentro de um container já em execução.

Vamos usar o container my-nginx que iniciamos no passo anterior. Executaremos um comando simples em modo detached. Por exemplo, vamos executar um comando que escreve a data e hora atuais em um arquivo dentro do container a cada 5 segundos.

docker exec -d my-nginx sh -c 'while true; do date >> /usr/share/nginx/html/date.txt; sleep 5; done'

Neste comando:

• docker exec -d my-nginx: Executa o seguinte comando em modo detached dentro do container my-nginx.
• sh -c '...': Executa a string de comando subsequente usando o shell sh.
• while true; do date >> /usr/share/nginx/html/date.txt; sleep 5; done: Este é o comando que está sendo executado. É um loop simples que continuamente anexa a data e hora atuais ao arquivo /usr/share/nginx/html/date.txt e, em seguida, espera 5 segundos antes de repetir.

Após executar o comando, você verá o ID do container impresso em seu terminal, indicando que o comando foi iniciado em segundo plano dentro do container.

Para verificar se o comando está em execução e escrevendo no arquivo, podemos executar outro comando para visualizar o conteúdo do arquivo date.txt. Como o comando está sendo executado em segundo plano, pode levar alguns segundos para que o arquivo seja criado e preenchido.

docker exec my-nginx cat /usr/share/nginx/html/date.txt

Você deve ver a data e hora sendo impressas na saída e, se você executar o comando cat novamente após alguns segundos, deverá ver novas entradas adicionadas ao arquivo. Isso confirma que o processo em segundo plano iniciado com docker exec -d está sendo executado conforme o esperado.

Executar um comando como um usuário diferente

Neste passo, você aprenderá como executar um comando dentro de um container em execução como um usuário específico. Por padrão, docker exec executa comandos como o usuário root dentro do container, mas você pode especificar um usuário diferente usando a flag -u ou --user. Isso é importante para segurança e para aderir ao princípio do menor privilégio (least privilege).

Vamos continuar usando o container my-nginx. Primeiro, vamos ver como o comando ls / é executado por padrão.

docker exec my-nginx whoami

A saída provavelmente será root, pois este é o usuário padrão para docker exec.

Agora, vamos tentar executar um comando como um usuário diferente. A imagem Nginx normalmente executa o processo Nginx como um usuário não-root, frequentemente chamado nginx. Vamos tentar executar o comando whoami como o usuário nginx.

docker exec -u nginx my-nginx whoami

Você deve ver a saída nginx, confirmando que o comando foi executado como o usuário nginx.

Você também pode especificar um ID de usuário (UID) em vez de um nome de usuário. Para encontrar o UID do usuário nginx dentro do container, podemos olhar para o arquivo /etc/passwd.

docker exec my-nginx cat /etc/passwd | grep nginx

A saída mostrará a entrada para o usuário nginx, incluindo seu UID e GID (Group ID). Por exemplo, pode ter a seguinte aparência: nginx:x:101:101:nginx user,,,:/nonexistent:/bin/false. Neste exemplo, o UID é 101.

Agora, vamos executar o comando whoami usando o UID. Substitua 101 pelo UID real que você encontrou no passo anterior, se for diferente.

docker exec -u 101 my-nginx whoami

A saída deve ser novamente nginx, demonstrando que você pode usar o nome de usuário ou o UID para especificar o usuário para docker exec.

Executar comandos como um usuário não-root é uma boa prática de segurança, especialmente ao interagir com arquivos sensíveis ou ao realizar operações que não exigem privilégios de root.

Executar um comando com um diretório de trabalho específico

Neste passo final, você aprenderá como executar um comando dentro de um container em execução com um diretório de trabalho específico. Por padrão, docker exec executa comandos no diretório de trabalho definido no Dockerfile da imagem do container (frequentemente /). No entanto, você pode alterar isso usando a flag -w ou --workdir. Isso é útil quando você precisa executar comandos relativos a um caminho específico dentro do sistema de arquivos do container.

Vamos continuar usando o container my-nginx. Primeiro, vamos ver o diretório de trabalho padrão quando executamos um comando sem especificar um. Podemos usar o comando pwd (print working directory - imprimir diretório de trabalho) para isso.

docker exec my-nginx pwd

A saída provavelmente será /, que é o diretório raiz.

Agora, vamos executar um comando em um diretório de trabalho diferente. O container Nginx tem um diretório /usr/share/nginx/html de onde o servidor web serve os arquivos. Vamos alterar o diretório de trabalho para este caminho e, em seguida, listar os arquivos dentro dele.

docker exec -w /usr/share/nginx/html my-nginx ls

Neste comando:

• docker exec -w /usr/share/nginx/html my-nginx: Executa o seguinte comando dentro do container my-nginx, definindo o diretório de trabalho para /usr/share/nginx/html.
• ls: O comando a ser executado, que lista os arquivos no diretório de trabalho atual.

Você deve ver os arquivos presentes no diretório /usr/share/nginx/html, como index.html e date.txt (que criamos em um passo anterior).

Vamos tentar outro exemplo. Podemos criar um novo diretório dentro de /usr/share/nginx/html e, em seguida, alterar nosso diretório de trabalho para o diretório recém-criado antes de executar um comando.

docker exec my-nginx mkdir /usr/share/nginx/html/new_dir
docker exec -w /usr/share/nginx/html/new_dir my-nginx pwd

O primeiro comando cria um diretório chamado new_dir dentro de /usr/share/nginx/html. O segundo comando, então, altera o diretório de trabalho para /usr/share/nginx/html/new_dir e imprime o diretório de trabalho atual.

A saída do segundo comando deve ser /usr/share/nginx/html/new_dir, confirmando que o diretório de trabalho foi alterado com sucesso para a execução do comando pwd.

Usar a flag -w com docker exec permite que você execute comandos no contexto de um diretório específico dentro do container, o que é muito útil para navegar e interagir com o sistema de arquivos do container de forma mais eficiente.

Resumo

Neste laboratório, você aprendeu como usar o comando docker exec para interagir com um container Docker em execução. Você praticou a execução de comandos dentro de um container, especificamente listando arquivos e verificando a versão do Nginx, demonstrando a capacidade de depurar e interagir com serviços sem interrompê-los.

Você também abordou brevemente a execução de containers em modo detached (destacado) usando a flag -d, um conceito fundamental para a execução de containers em segundo plano. Embora os passos subsequentes não tenham sido totalmente detalhados, os passos iniciais forneceram uma base sólida para entender como executar comandos dentro de um ambiente de container em execução.