LabEx
EntrarJunte-se

Parâmetros do Comando Docker Run

DockerBeginner
Pratique Agora

Introdução

Neste laboratório, focaremos exclusivamente no comando docker run e em seus diversos parâmetros. O comando docker run é fundamental para as operações do Docker, permitindo criar e iniciar contêineres com configurações específicas.

Ao dominar os parâmetros deste comando, você terá maior controle sobre suas aplicações conteinerizadas, aprimorando sua capacidade de implantar e gerenciar contêineres Docker de forma eficaz.

Abordaremos uma ampla gama de parâmetros, incluindo aqueles para nomeação, modo em segundo plano (detached), mapeamento de portas, montagem de volumes, variáveis de ambiente, restrições de recursos e muito mais.

Alguns desses parâmetros podem já ser familiares para você, enquanto outros podem ser novidade.

Este é um Laboratório Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para concluir cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 96%. Ele recebeu uma taxa de avaliação positiva de 99% dos alunos.

Docker Run Básico e Nomeação de Contêineres

Vamos começar com o básico do docker run e explorar como nomear nossos contêineres.

Primeiro, execute um contêiner Nginx básico:

docker run nginx

Este comando executa um contêiner Nginx em primeiro plano (foreground). Você verá um fluxo de logs no seu terminal. Isso acontece porque o contêiner está ocupando o terminal atual e exibindo os logs diretamente.

Para parar este contêiner, pressione Ctrl+C. Você notará que pode levar alguns segundos para parar — isso é normal, pois o Docker está dando tempo para o contêiner encerrar os processos de forma segura.

Agora, vamos executá-lo no modo "detached" (segundo plano) e dar a ele um nome:

docker run -d --name my-nginx nginx

Vamos detalhar este comando:

  • docker run: O comando básico para executar um contêiner.
  • -d: Esta opção executa o contêiner em modo "detached", ou seja, ele roda em segundo plano. Você não verá a saída no seu terminal.
  • --name my-nginx: Atribui o nome "my-nginx" ao contêiner. Se você não especificar um nome, o Docker atribuirá um nome aleatório.
  • nginx: O nome da imagem que estamos usando para criar o contêiner.

Após executar este comando, você verá uma longa sequência de caracteres. Este é o ID do contêiner. O Docker iniciou o contêiner em segundo plano.

Se você encontrar um erro dizendo que o nome já está em uso, significa que você já tem um contêiner com esse nome. Você pode escolher um nome diferente ou remover o contêiner existente (aprenderemos como fazer isso em laboratórios posteriores).

Mapeamento de Portas

O parâmetro -p no docker run permite mapear portas do contêiner para a máquina hospedeira (host). Isso é crucial para acessar serviços que rodam dentro do contêiner a partir da sua máquina.

Execute um contêiner Nginx com mapeamento de portas:

docker run -d --name nginx-mapped -p 8080:80 nginx

Vamos detalhar as novas partes deste comando:

  • -p 8080:80: Mapeia a porta 8080 do seu host para a porta 80 no contêiner. O formato é sempre porta_do_host:porta_do_conteiner.

O Nginx, por padrão, roda na porta 80 dentro do contêiner. Ao mapeá-lo para a porta 8080 no nosso host, podemos acessá-lo navegando para localhost:8080 em um navegador web.

Agora, vamos verificar se a página de boas-vindas do Nginx está acessível. Usaremos o comando curl, que permite fazer requisições HTTP via linha de comando:

curl http://localhost:8080

Você deverá ver o conteúdo HTML da página de boas-vindas do Nginx. Se você não tiver o curl instalado, pode instalá-lo com:

sudo apt-get update && sudo apt-get install -y curl

Se ainda assim não conseguir acessar a página, verifique o seguinte:

  1. Certifique-se de que o contêiner está rodando: docker ps | grep nginx-mapped
  2. Verifique se a porta está realmente mapeada: docker port nginx-mapped
  3. Se estiver usando um servidor na nuvem, certifique-se de que o firewall permite tráfego na porta 8080.

Montagem de Volumes

O parâmetro -v no docker run permite montar volumes, compartilhando dados entre o host e o contêiner. Isso é incrivelmente útil para persistir dados ou fornecer arquivos de configuração ao contêiner.

Vamos começar criando uma estrutura simples de diretórios no nosso host:

mkdir -p ~/project/nginx-data
echo "<html><body><h1>Hello from mounted volume</h1></body></html>" > ~/project/nginx-data/index.html

Estes comandos realizam o seguinte:

  1. Criam um novo diretório nginx-data dentro da pasta project no seu diretório pessoal.
  2. Criam um arquivo HTML simples chamado index.html dentro deste novo diretório.

Agora, vamos executar um contêiner Nginx e montar este diretório:

docker run -d --name nginx-volume -p 8081:80 -v ~/project/nginx-data:/usr/share/nginx/html nginx

Vamos detalhar este comando:

  • docker run: Comando para executar um novo contêiner.
  • -d: Executa o contêiner em segundo plano.
  • --name nginx-volume: Atribui o nome "nginx-volume" ao nosso contêiner.
  • -p 8081:80: Mapeia a porta 8081 do host para a porta 80 no contêiner.
  • -v ~/project/nginx-data:/usr/share/nginx/html: Monta o diretório nginx-data do nosso host no diretório /usr/share/nginx/html do contêiner. É aqui que o Nginx busca o conteúdo para servir.
  • nginx: O nome da imagem utilizada.

Agora, vamos verificar se a página personalizada está sendo servida:

curl http://localhost:8081

Você deverá ver o conteúdo do seu arquivo HTML personalizado: "Hello from mounted volume!"

Se não vir o conteúdo personalizado, verifique:

  1. Se o arquivo ~/project/nginx-data/index.html existe no seu sistema host.
  2. Se o contêiner está rodando: docker ps | grep nginx-volume
  3. Os logs do Nginx para eventuais erros: docker logs nginx-volume

Este método de montar um diretório do host em um contêiner é chamado de "bind mount". É uma forma direta de compartilhar arquivos. Pontos importantes para lembrar:

  1. O caminho do diretório no host deve ser um caminho absoluto.
  2. Se o diretório no host não existir, o Docker o criará automaticamente.
  3. Qualquer alteração nos arquivos (seja no host ou no contêiner) será visível instantaneamente para ambos.
  4. Cuidado com as permissões: o contêiner roda como root por padrão, o que pode criar arquivos que seu usuário no host não consiga modificar.

Ao usar este método, evitamos erros de "não é um diretório" porque estamos montando uma pasta inteira. Essa abordagem oferece flexibilidade para adicionar ou modificar arquivos sem precisar recriar o contêiner.

Variáveis de Ambiente

O parâmetro -e no docker run permite definir variáveis de ambiente no contêiner. Isso é útil para configurar a aplicação que roda no contêiner sem precisar alterar seu código-fonte.

Execute um contêiner com variáveis de ambiente:

docker run -d --name nginx-env -e NGINX_HOST=mywebsite.com -e NGINX_PORT=80 nginx

Vamos detalhar as novas partes:

  • -e NGINX_HOST=mywebsite.com: Define uma variável de ambiente chamada NGINX_HOST com o valor mywebsite.com.
  • -e NGINX_PORT=80: Define outra variável chamada NGINX_PORT com o valor 80.

Variáveis de ambiente são pares de chave-valor que podem ser acessados pelos processos dentro do contêiner. Muitas imagens Docker são projetadas para usar variáveis específicas para configuração.

Você pode verificar as variáveis de ambiente:

docker exec nginx-env env | grep NGINX_

Este comando faz o seguinte:

  • docker exec nginx-env: Diz ao Docker para executar um comando dentro do contêiner nginx-env que já está rodando.
  • env: Comando que lista todas as variáveis de ambiente.
  • | grep NGINX_: Filtra a saída para mostrar apenas as linhas que contêm "NGINX_".

Você deverá ver suas duas variáveis listadas.

Se não as vir, verifique:

  1. O contêiner está rodando? Verifique com docker ps | grep nginx-env
  2. Você digitou os nomes das variáveis corretamente no comando docker run?

Restrições de Recursos

O Docker permite definir limites de recursos para os contêineres usando vários parâmetros no docker run. Isso é fundamental para gerenciar o desempenho e a estabilidade do seu sistema host, especialmente ao rodar múltiplos contêineres.

Execute um contêiner com limites de memória e CPU:

docker run -d --name nginx-limited --memory 256m --cpus 0.5 nginx

Vamos detalhar as novas partes:

  • --memory 256m: Limita o contêiner a 256 megabytes de memória. O 'm' significa megabytes. Você também poderia usar 'g' para gigabytes.
  • --cpus 0.5: Limita o contêiner a usar, no máximo, metade de um núcleo de CPU.

Esses limites impedem que o contêiner utilize mais recursos do que o especificado, evitando que um único contêiner monopolize os recursos do host.

Você pode verificar se esses limites foram aplicados corretamente:

docker inspect -f '{{.HostConfig.Memory}}' nginx-limited
docker inspect -f '{{.HostConfig.NanoCpus}}' nginx-limited

O primeiro comando deve retornar 268435456 (256MB em bytes) e o segundo deve retornar 500000000 (0.5 CPU em nano-unidades).

Se vir valores diferentes, revise seu comando docker run para garantir que os limites foram especificados corretamente.

Nota: Definir limites de recursos muito baixos pode fazer com que o contêiner tenha um desempenho ruim ou até mesmo sofra um crash. Se tiver problemas, tente aumentar esses limites.

Configurações de Rede

O parâmetro --network no docker run permite conectar um contêiner a uma rede. Isso é útil para a comunicação entre contêineres e para isolar grupos de aplicações.

Primeiro, crie uma rede bridge personalizada:

docker network create my-custom-network

Isso cria uma nova rede do tipo bridge chamada my-custom-network. Redes bridge são o tipo de rede mais comum no Docker.

Agora, execute um contêiner conectado a esta rede:

docker run -d --name nginx-networked --network my-custom-network nginx

A opção --network my-custom-network conecta o contêiner à rede que acabamos de criar.

Contêineres na mesma rede podem se comunicar entre si usando seus nomes de contêiner como hostnames. Isso facilita muito a interligação de serviços.

Se receber um erro dizendo que a rede não existe, certifique-se de que a criou corretamente com o comando docker network create.

Políticas de Reinicialização

O parâmetro --restart no docker run permite especificar uma política de reinicialização para o contêiner. Isso garante que seus contêineres continuem rodando, mesmo se falharem ou se o serviço do Docker for reiniciado.

Execute um contêiner com uma política de reinicialização:

docker run -d --name nginx-restart --restart unless-stopped nginx

A opção --restart unless-stopped define que o contêiner deve reiniciar automaticamente, a menos que tenha sido parado explicitamente pelo usuário.

Outras políticas de reinicialização incluem:

  • no: O padrão. Não reinicia o contêiner automaticamente.
  • on-failure: Reinicia apenas se o contêiner sair com um código de erro (diferente de zero).
  • always: Sempre reinicia o contêiner, independentemente do motivo da parada.

Você pode verificar a política de reinicialização:

docker inspect -f '{{.HostConfig.RestartPolicy.Name}}' nginx-restart

A saída deve ser unless-stopped.

Se não vir o resultado esperado, verifique se especificou o parâmetro corretamente no comando inicial.

Diretório de Trabalho e Comando Personalizado

Nesta etapa, exploraremos como definir um diretório de trabalho dentro de um contêiner e como executar comandos personalizados ao iniciá-lo.

O parâmetro -w no docker run define o diretório de trabalho (working directory) interno, e você pode especificar um comando para rodar logo após o nome da imagem.

Vamos combinar esses conceitos:

docker run -d --name nginx-custom -w /app nginx sh -c "mkdir -p /app && touch newfile.txt && nginx -g 'daemon off;'"

Vamos detalhar este comando:

  • -d: Executa o contêiner em segundo plano.
  • --name nginx-custom: Nomeia o contêiner como "nginx-custom".
  • -w /app: Define o diretório de trabalho dentro do contêiner como /app.
  • nginx: O nome da imagem.
  • sh -c "...": Executa um comando shell.
    • mkdir -p /app: Cria o diretório /app se ele não existir.
    • &&: Executa o próximo comando apenas se o anterior for bem-sucedido.
    • touch newfile.txt: Cria um arquivo vazio chamado newfile.txt.
    • &&: Executa o próximo comando se o anterior tiver sucesso.
    • nginx -g 'daemon off;': Inicia o Nginx em primeiro plano, mantendo o contêiner ativo.

Agora, vamos verificar se o contêiner está rodando e se o arquivo foi criado:

docker ps | grep nginx-custom
docker exec nginx-custom ls -l /app/newfile.txt

O primeiro comando deve mostrar que o contêiner está ativo, e o segundo deve listar os detalhes do arquivo newfile.txt no diretório /app do contêiner.

Resumo

Neste laboratório, mergulhamos profundamente no comando docker run, explorando seus diversos parâmetros e opções. Vimos:

  1. Execução básica e nomeação de contêineres.
  2. Mapeamento de portas para acessar serviços do contêiner a partir do host.
  3. Montagem de volumes para compartilhar dados entre host e contêiner.
  4. Definição de variáveis de ambiente para configuração.
  5. Aplicação de restrições de recursos para limitar o uso de memória e CPU.
  6. Configurações de rede para comunicação entre contêineres.
  7. Políticas de reinicialização para aumentar a confiabilidade.
  8. Especificação de diretório de trabalho e comandos personalizados na inicialização.

Esses parâmetros do docker run fornecem ferramentas poderosas para configurar e gerenciar seus contêineres Docker. Ao dominar essas opções, você poderá criar implantações de contêineres mais sofisticadas e personalizadas, controlando como eles interagem com o sistema host, quais recursos consomem e como se comportam em diferentes cenários.

Relacionados Docker Cursos
Docker para Iniciantes

Docker para Iniciantes

dockerdevops
Desafios Práticos de Docker

Desafios Práticos de Docker

dockerdevops
Laboratórios Práticos de Docker

Laboratórios Práticos de Docker

dockerdevops