Parâmetros do comando Docker Run

Introdução

Neste laboratório, vamos nos concentrar exclusivamente no comando docker run e em seus diversos parâmetros. O comando docker run é fundamental para trabalhar com o Docker: ele permite criar e iniciar contêineres com configurações específicas.

Ao dominar os parâmetros desse comando, você terá mais controle sobre seus aplicativos em contêineres e poderá implantar e gerenciar contêineres Docker com mais eficiência.

Vamos abordar uma ampla variedade de parâmetros, incluindo os usados para definir nomes, executar contêineres em segundo plano, mapear portas, montar volumes, configurar variáveis de ambiente e limitar recursos, entre outros.

Talvez você já conheça alguns desses parâmetros, enquanto outros podem ser novos.

Uso básico do Docker Run e nomes de contêineres

Neste laboratório, você começará com o básico do docker run e aprenderá a definir nomes para contêineres.

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

docker run nginx

Esse comando executa um contêiner do Nginx em primeiro plano. Você verá um fluxo de logs no terminal. Isso acontece porque o contêiner está sendo executado em primeiro plano e os logs são exibidos diretamente nele.

Para parar o contêiner, pressione Ctrl+C. Talvez ele leve alguns segundos para parar. Isso é normal: o Docker dá tempo para o contêiner encerrar de forma controlada.

Agora, execute o contêiner em segundo plano e atribua um nome a ele:

docker run -d --name my-nginx nginx

Veja o que cada parte do comando faz:

• docker run: comando básico para executar um contêiner.
• -d: executa o contêiner em segundo plano, sem exibir a saída no 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: nome da imagem usada para criar o contêiner.

Depois de executar esse comando, você verá uma longa sequência de caracteres: o ID do contêiner. Isso indica que o Docker iniciou o contêiner em segundo plano.

Se aparecer um erro informando que o nome já está em uso, significa que já existe um contêiner com esse nome. Você pode escolher outro nome ou remover o contêiner existente. Você aprenderá a fazer isso em laboratórios posteriores.

Mapeamento de portas

Neste laboratório, você usará o parâmetro -p do docker run para mapear uma porta do contêiner para o host. Isso é essencial para acessar, no host, os serviços executados dentro do contêiner.

Execute um contêiner do Nginx com o mapeamento de portas:

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

Veja o que há de novo neste comando:

• -p 8080:80: mapeia a porta 8080 do host para a porta 80 do contêiner. O formato é sempre host_port:container_port.

Por padrão, o Nginx usa a porta 80 dentro do contêiner. Como essa porta foi mapeada para a porta 8080 do host, você pode acessar o serviço em localhost:8080 usando um navegador.

Agora, confira se a página de boas-vindas do Nginx está acessível. Para isso, use o comando curl, que permite fazer requisições HTTP pela linha de comando:

curl --retry 5 --retry-all-errors --retry-delay 1 http://localhost:8080

Você deverá ver o conteúdo HTML da página de boas-vindas do Nginx. Se o curl não estiver instalado, instale-o com:

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

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

• Confira se o contêiner está em execução: docker ps | grep nginx-mapped
• Confira se a porta foi mapeada: docker port nginx-mapped
• Se estiver usando um servidor na nuvem, confira se o firewall permite tráfego na porta 8080.

Montagem de volumes

Neste laboratório, você usará o parâmetro -v do docker run para montar volumes e compartilhar dados entre o host e o contêiner. Isso é útil para persistir dados ou fornecer arquivos de configuração ao contêiner.

Primeiro, crie uma estrutura de diretórios simples no host:

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

Esses comandos fazem o seguinte:

• Criam o diretório nginx-data dentro do diretório project, no seu diretório pessoal.
• Criam um arquivo HTML simples chamado index.html dentro desse novo diretório.

Agora, execute um contêiner do Nginx e monte esse diretório nele:

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

Veja o que cada parte do comando faz:

• 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 contêiner.
• -p 8081:80: mapeia a porta 8081 do host para a porta 80 do contêiner.
• -v ~/project/nginx-data:/usr/share/nginx/html: monta o diretório nginx-data do host em /usr/share/nginx/html dentro do contêiner. É nesse diretório que o Nginx procura o conteúdo que será servido.
• nginx: nome da imagem usada para criar o contêiner.

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

curl --retry 5 --retry-all-errors --retry-delay 1 http://localhost:8081

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

Se o conteúdo personalizado não aparecer, verifique o seguinte:

• Confira se o arquivo ~/project/nginx-data/index.html existe no host.
• Confira se o contêiner está em execução: docker ps | grep nginx-volume
• Confira se há erros nos logs do Nginx: docker logs nginx-volume

A montagem de um diretório do host em um contêiner é chamada de bind mount. Essa é uma maneira simples de compartilhar arquivos entre o host e o contêiner. Lembre-se destes pontos:

• O caminho do diretório no host deve ser absoluto.
• Se o diretório do host não existir, o Docker o criará automaticamente.
• As alterações feitas nos arquivos desse diretório, no host ou no contêiner, ficam imediatamente visíveis nos dois.
• Tenha cuidado com as permissões: por padrão, o contêiner é executado como root e pode criar arquivos que seu usuário no host não consegue modificar.

Com esse método, você evita o erro "not a directory", pois está montando um diretório, não um único arquivo. Essa abordagem oferece mais flexibilidade para adicionar, remover ou modificar arquivos sem precisar recriar o contêiner.

Variáveis de ambiente

Neste laboratório, você usará o parâmetro -e do docker run para definir variáveis de ambiente no contêiner. Isso é útil para configurar o aplicativo sem alterar o código.

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

Veja o que há de novo no comando:

• -e NGINX_HOST=mywebsite.com: define a variável de ambiente NGINX_HOST com o valor mywebsite.com.
• -e NGINX_PORT=80: define outra variável de ambiente, NGINX_PORT, com o valor 80.

Variáveis de ambiente são pares de chave e valor que os processos executados dentro do contêiner podem acessar. Muitas imagens Docker são projetadas para usar variáveis de ambiente específicas na configuração.

Confira se as variáveis de ambiente foram definidas:

docker exec nginx-env env | grep NGINX_

Esse comando faz o seguinte:

• docker exec nginx-env: instrui o Docker a executar um comando no contêiner nginx-env, que está em execução.
• env: exibe todas as variáveis de ambiente.
• | grep NGINX_: filtra a saída para mostrar apenas as linhas que contêm "NGINX_".

Você deverá ver as duas variáveis de ambiente listadas.

Se elas não aparecerem, verifique o seguinte:

• O contêiner está em execução? Confira com docker ps | grep nginx-env
• Você digitou corretamente os nomes das variáveis de ambiente no comando docker run?

Limites de recursos

Neste laboratório, você definirá limites de recursos para contêineres usando parâmetros do docker run. Isso é essencial para gerenciar o desempenho e a estabilidade do host, especialmente quando vários contêineres estão em execução.

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

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

Veja o que há de novo no comando:

• --memory 256m: limita o uso de memória do contêiner a 256 megabytes. A letra 'm' representa megabytes. Você também pode usar 'g' para gigabytes.
• --cpus 0.5: limita o uso do contêiner a, no máximo, metade de um núcleo de CPU.

Esses limites impedem que o contêiner use mais recursos do que o especificado. Assim, você pode evitar que um único contêiner monopolize os recursos do host.

Confira se os limites foram aplicados corretamente:

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

O primeiro comando deverá exibir 268435456 (256 MB em bytes), e o segundo deverá exibir 500000000 (0,5 CPU em nanounidades).

Se os valores forem diferentes, confira o comando docker run e verifique se os limites foram especificados corretamente.

Observação: definir limites de recursos muito baixos pode prejudicar o desempenho do contêiner ou até mesmo fazer com que ele pare de funcionar. Se houver problemas com o contêiner, tente aumentar esses limites.

Configurações de rede

Neste laboratório, você usará o parâmetro --network do docker run para conectar um contêiner a uma rede. Isso é útil para permitir a comunicação entre contêineres e isolar grupos de contêineres.

Primeiro, crie uma rede bridge personalizada:

docker network create my-custom-network

Esse comando cria uma nova rede bridge chamada my-custom-network. As redes bridge são o tipo de rede mais comum no Docker.

Agora, execute um contêiner conectado a essa 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 você acabou de criar.

Contêineres na mesma rede podem se comunicar usando os nomes dos contêineres como nomes de host. Isso facilita a conexão entre serviços.

Se aparecer um erro informando que a rede não existe, confira se você a criou corretamente com o comando docker network create.

Políticas de reinicialização

Neste laboratório, você usará o parâmetro --restart do docker run para definir uma política de reinicialização para o contêiner. Isso ajuda a manter os contêineres em execução caso eles falhem ou o daemon do Docker seja 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 a política de reinicialização como "unless-stopped". Isso significa que o contêiner será reiniciado automaticamente, a menos que seja parado explicitamente por você.

Outras políticas de reinicialização incluem:

• no: padrão. Não reinicia o contêiner automaticamente.
• on-failure: reinicia o contêiner somente se ele encerrar com um status diferente de zero.
• always: reinicia o contêiner sempre, independentemente do status de saída.

Confira a política de reinicialização:

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

O comando deverá exibir unless-stopped.

Se o resultado esperado não aparecer, confira o comando docker run e verifique se a política de reinicialização foi especificada corretamente.

Diretório de trabalho e comando

Neste laboratório, você aprenderá a definir um diretório de trabalho dentro do contêiner e a executar comandos personalizados quando ele for iniciado.

O parâmetro -w do docker run define o diretório de trabalho dentro do contêiner. Você também pode especificar um comando para executar depois do nome da imagem.

Combine esses conceitos:

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

Veja o que cada parte do comando faz:

• -d: executa o contêiner em segundo plano.
• --name nginx-custom: atribui o nome "nginx-custom" ao contêiner.
• -w /app: define /app como o diretório de trabalho dentro do contêiner.
• nginx: nome da imagem a ser usada.
• sh -c "...": executa um comando no shell.
  • mkdir -p /app: cria o diretório /app caso ele não exista.
  • &&: executa o próximo comando somente se o anterior for concluído com sucesso.
  • touch newfile.txt: cria um arquivo vazio chamado newfile.txt.
  • &&: executa o próximo comando somente se o anterior for concluído com sucesso.
  • nginx -g 'daemon off;': inicia o Nginx em primeiro plano, mantendo o contêiner em execução.

Agora, confira se o contêiner está em execução e se o arquivo foi criado:

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

O primeiro comando deverá mostrar que o contêiner está em execução. O segundo deverá listar os detalhes do arquivo newfile.txt no diretório /app do contêiner.

Resumo

Neste laboratório, exploramos em detalhes o comando docker run e seus diversos parâmetros e opções. Vimos como:

1. Executar contêineres e definir seus nomes
2. Mapear portas para acessar serviços do contêiner a partir do host
3. Montar volumes para compartilhar dados entre o host e o contêiner
4. Definir variáveis de ambiente para configurar contêineres
5. Aplicar limites de recursos para controlar o uso de recursos pelos contêineres
6. Configurar redes para permitir a comunicação entre contêineres
7. Definir políticas de reinicialização para aumentar a confiabilidade dos contêineres
8. Especificar o diretório de trabalho e o comando executado na inicialização do contêiner

Esses parâmetros do docker run oferecem ferramentas poderosas para configurar e gerenciar contêineres Docker. Ao dominar essas opções, você poderá criar implantações de contêineres mais sofisticadas e adaptadas às suas necessidades. Você poderá controlar como os contêineres interagem com o host, quais recursos podem consumir e como se comportam em diferentes situações.