LabEx
EntrarJunte-se

Imagens Docker Personalizadas

DockerBeginner
Pratique Agora

Introdução

O Docker é uma ferramenta poderosa para empacotar e distribuir aplicações como contêineres. No centro desse processo estão as imagens Docker, que são pacotes pré-construídos contendo tudo o que é necessário para executar uma aplicação, incluindo o código, dependências e configurações. Neste laboratório, você aprenderá a criar imagens Docker personalizadas que aprimoram suas aplicações ao incorporar softwares, bibliotecas ou configurações adicionais.

Ao longo deste laboratório, utilizaremos o WebIDE (VS Code) para editar arquivos. O WebIDE oferece uma interface familiar e intuitiva para a edição de arquivos, facilitando o trabalho com arquivos de configuração e código.

Configurar o Ambiente do Projeto

Vamos começar criando um diretório para o projeto e acessando-o.

Ao longo deste laboratório, utilizaremos o WebIDE (VS Code) para editar arquivos. O WebIDE oferece uma interface familiar e intuitiva para a edição de arquivos, facilitando o trabalho com arquivos de configuração e código.

  1. Abra um terminal no WebIDE. Você pode fazer isso clicando em "Terminal" no menu superior e selecionando "New Terminal".
  2. No terminal, execute os seguintes comandos:
mkdir -p ~/project/docker
cd ~/project/docker

Terminal mostrando os comandos de criação do diretório do projeto

Isso cria um novo diretório chamado docker na pasta ~/project e altera o diretório de trabalho atual para ele.

  1. Verifique se você está no diretório correto:
pwd

Você deverá ver /home/labex/project/docker como saída.

Entendendo esses comandos:

  • mkdir -p: Este comando cria um diretório. A flag -p permite criar diretórios pai caso eles não existam.
  • cd: Este comando altera o diretório atual.
  • pwd: Este comando imprime o diretório de trabalho atual.

Criar uma Imagem Docker Simples

Agora, vamos criar uma imagem Docker simples que executa um servidor web Nginx.

  1. No WebIDE, navegue até o File Explorer (geralmente o primeiro ícone na barra lateral esquerda).
  2. Clique com o botão direito no painel do File Explorer e selecione "New File". Nomeie-o como Dockerfile (com 'D' maiúsculo e sem extensão de arquivo).
  3. Abra o Dockerfile clicando nele no File Explorer. Adicione o seguinte conteúdo:
FROM nginx
COPY index.html /usr/share/nginx/html/

Este Dockerfile define uma nova imagem baseada na imagem oficial do Nginx e copia um arquivo chamado index.html para o diretório raiz padrão do Nginx.

Entendendo o Dockerfile:

  • FROM nginx: Esta linha especifica a imagem base a partir da qual estamos construindo. Neste caso, estamos usando a imagem oficial do Nginx.
  • COPY index.html /usr/share/nginx/html/: Esta linha copia nosso arquivo index.html para o diretório raiz web do contêiner.
  1. Crie um novo arquivo chamado index.html no mesmo diretório. Você pode fazer isso clicando com o botão direito no painel do File Explorer e selecionando "New File".
  2. Abra o index.html e adicione o seguinte conteúdo:
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Hello Docker!</title>
  </head>
  <body>
    <h1>Hello Docker!</h1>
    <p>This is a custom Docker image.</p>
  </body>
</html>

Esta é uma página HTML simples que será servida pelo nosso servidor Nginx.

  1. Abra um terminal no WebIDE (Terminal -> New Terminal, caso tenha fechado o anterior) e construa a imagem Docker usando o seguinte comando:
docker build -t my-nginx .

Este comando constrói uma nova imagem Docker com a tag my-nginx.

Entendendo o comando:

  • docker build: Este é o comando para construir uma imagem Docker.
  • -t my-nginx: A flag -t etiqueta (tag) nossa imagem com o nome my-nginx.
  • .: Isso especifica o contexto de build (o diretório que contém o Dockerfile) como o diretório atual.
  1. Assim que a construção for concluída, verifique se a imagem foi criada com sucesso:
docker images

Você deverá ver a imagem my-nginx listada na saída.

Executar e Testar a Imagem Personalizada

Vamos executar um contêiner baseado em nossa nova imagem e testá-lo.

  1. No terminal do WebIDE, inicie um contêiner usando o seguinte comando:
docker run -d -p 8080:80 --name my-nginx-container my-nginx

Entendendo este comando:

  • docker run: Este comando cria e inicia um novo contêiner.
  • -d: Esta flag executa o contêiner em modo "detached" (em segundo plano).
  • -p 8080:80: Isso mapeia a porta 8080 do seu host para a porta 80 no contêiner.
  • --name my-nginx-container: Isso atribui um nome ao nosso contêiner.
  • my-nginx: Este é o nome da imagem que estamos usando para criar o contêiner.
  1. Verifique se o contêiner está em execução:
docker ps

Você deverá ver my-nginx-container listado na saída. Este comando mostra todos os contêineres em execução.

  1. Para visualizar o conteúdo da página web, use o comando curl:
curl http://localhost:8080

Você deverá ver o conteúdo HTML do arquivo index.html exibido no terminal.

Se você estiver curioso sobre o que o curl faz, ele é uma ferramenta para transferir dados de ou para um servidor. Neste caso, estamos usando-o para buscar o conteúdo do nosso servidor web.

Você também pode navegar até o topo da VM do LabEx, clicar em + para criar um novo servidor web e inserir a porta 8080 para visualizar o conteúdo.

Configuração da porta do servidor web

Adicionar Software Personalizado à Imagem

Nesta etapa, você modificará sua imagem Docker para incluir softwares adicionais. Adicionaremos o editor de texto nano como exemplo, pois ele não está incluído na imagem base nginx.

  1. No WebIDE, abra o Dockerfile. Você pode fazer isso clicando em Dockerfile no painel do File Explorer.
  2. Modifique o conteúdo do Dockerfile para:
FROM nginx
RUN apt-get update && apt-get install -y nano
COPY index.html /usr/share/nginx/html/

Este Dockerfile adiciona uma nova instrução RUN que atualiza o índice de pacotes e instala o pacote nano usando o gerenciador de pacotes apt-get.

Entendendo a nova linha:

  • RUN apt-get update && apt-get install -y nano: Esta linha atualiza a lista de pacotes (apt-get update) e, em seguida, instala o nano (apt-get install -y nano). A flag -y responde automaticamente "yes" a quaisquer prompts durante a instalação.
  1. Salve o arquivo no WebIDE pressionando Ctrl+S (ou Cmd+S no Mac).
  2. No terminal do WebIDE, reconstrua a imagem Docker com uma nova tag:
docker build -t my-nginx-nano .

Este comando constrói uma nova imagem Docker com a tag my-nginx-nano que inclui o editor nano.

  1. Verifique se a nova imagem foi criada:
docker images

Você deverá ver a imagem my-nginx-nano listada na saída.

Testar a Imagem Personalizada com Nano

Nesta etapa, você executará um contêiner baseado em sua nova imagem e confirmará que o pacote nano está disponível dentro dele.

  1. No terminal do WebIDE, inicie um novo contêiner usando o seguinte comando:
docker run -d --name nano-container my-nginx-nano

Este comando inicia um novo contêiner baseado na imagem my-nginx-nano e o nomeia como nano-container.

  1. Execute o seguinte comando para verificar a versão do nano instalada dentro do contêiner:
docker exec nano-container nano --version

Este comando executa nano --version dentro do contêiner em execução para que você possa confirmar que o pacote está instalado.

Entendendo este comando:

  • docker exec: Isso executa um comando em um contêiner em execução.
  • nano-container: Este é o nome do nosso contêiner.
  • nano --version: Isso imprime a versão do nano instalada de dentro do contêiner.
  1. Você deverá ver uma saída que começa com GNU nano, o que confirma que a imagem personalizada agora inclui o editor.

Usar Variáveis de Ambiente na Imagem

Nesta etapa, modificaremos nossa imagem Docker para usar variáveis de ambiente para personalização.

  1. No WebIDE, abra o Dockerfile novamente.

  2. Modifique o conteúdo do Dockerfile para:

FROM nginx
ENV NGINX_PORT 9000
RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
COPY index.html /usr/share/nginx/html/

Este Dockerfile adiciona uma instrução ENV que define a variável NGINX_PORT como 9000. Ele também inclui uma instrução RUN que modifica a configuração do Nginx para usar esta porta.

Entendendo as novas linhas:

  • ENV NGINX_PORT 9000: Isso define uma variável de ambiente NGINX_PORT com o valor 9000.
  • RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf: Isso usa o sed para substituir a porta padrão (80) pela nossa variável de ambiente no arquivo de configuração do Nginx.

  1. Salve o arquivo no WebIDE.

  2. No terminal do WebIDE, reconstrua a imagem Docker com uma nova tag:

docker build -t my-nginx-env .
  1. Execute um contêiner baseado na nova imagem:
docker run -d -p 9000:9000 --name env-container my-nginx-env

Este comando inicia um novo contêiner baseado na imagem my-nginx-env e mapeia a porta 9000 no host para a porta 9000 no contêiner. Observe que a variável de ambiente já está definida no Dockerfile, portanto, não é necessário defini-la novamente no comando docker run.

  1. Verifique se o servidor web está em execução na porta especificada:
curl http://localhost:9000

Você deverá ver o conteúdo HTML do arquivo index.html exibido no terminal.

Usar ENTRYPOINT no Dockerfile

Nesta etapa, aprenderemos como usar a instrução ENTRYPOINT em um Dockerfile e usar uma porta diferente (9100).

  1. No WebIDE, abra o Dockerfile novamente.

  2. Modifique o conteúdo do Dockerfile para:

FROM nginx
COPY index.html /usr/share/nginx/html/
COPY start.sh /start.sh
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]

Este Dockerfile remove a variável de ambiente e o comando sed. Em vez disso, lidaremos com a configuração em tempo de execução usando um script ENTRYPOINT. Isso torna nossa imagem mais flexível.

  1. Crie um novo arquivo chamado start.sh no mesmo diretório com o seguinte conteúdo:
#!/bin/bash
## Set a default port if NGINX_PORT is not set
export NGINX_PORT=${NGINX_PORT:-9100}
## Replace the port in the nginx configuration
sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
echo "Starting Nginx on port $NGINX_PORT"
nginx -g 'daemon off;'

Este script define uma porta padrão, modifica a configuração do Nginx na inicialização do contêiner, imprime uma mensagem mostrando em qual porta o Nginx será executado e, em seguida, inicia o Nginx.

  1. Salve ambos os arquivos no WebIDE.

  2. No terminal do WebIDE, reconstrua a imagem Docker com uma nova tag:

docker build -t my-nginx-entrypoint .
  1. Execute um contêiner baseado na nova imagem. Definiremos a porta como 9100 usando uma variável de ambiente.
docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint
  1. Verifique os logs do contêiner para ver a mensagem de inicialização:
docker logs entrypoint-container

Você deverá ver a mensagem "Starting Nginx on port 9100" na saída.

  1. Verifique se o servidor web está em execução corretamente na nova porta:
curl http://localhost:9100

Você deverá ver o conteúdo HTML do arquivo index.html exibido no terminal.

Resumo

Neste laboratório, você aprendeu como criar imagens Docker personalizadas que agregam valor às suas aplicações. Você começou criando uma imagem simples com um servidor web, depois progrediu para adicionar softwares personalizados e usar variáveis de ambiente para configuração. Ao longo do laboratório, você utilizou o WebIDE (VS Code) para editar arquivos, tornando o processo mais intuitivo e amigável.

Aqui está um resumo do que você realizou:

  1. Configurou um ambiente de projeto e aprendeu comandos básicos de terminal.
  2. Criou uma imagem Docker simples com Nginx e uma página HTML personalizada.
  3. Construiu e executou contêineres Docker, aprendendo sobre mapeamento de portas e nomeação de contêineres.
  4. Modificou uma imagem Docker para incluir softwares adicionais (curl).
  5. Usou o docker exec para executar comandos dentro de um contêiner.
  6. Incorporou variáveis de ambiente em sua imagem Docker para facilitar a configuração.
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