LabEx
EntrarJunte-se

Imagens Docker Personalizadas

DockerBeginner
Pratique Agora

Introdução

O Docker é uma ferramenta poderosa para empacotar e distribuir aplicações como containers. 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, as dependências e a configuração. 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 amigável 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 navegando até ele.

Ao longo deste laboratório, utilizaremos o WebIDE (VS Code) para editar arquivos. O WebIDE oferece uma interface familiar e amigável 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 comandos de criação do diretório do projeto

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

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

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

Entendendo estes 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 Explorador de Arquivos (geralmente o primeiro ícone na barra lateral esquerda).
  2. Clique com o botão direito no painel do Explorador de Arquivos 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 Explorador de Arquivos. 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 de documentos 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 dentro do diretório raiz web do container.
  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 Explorador de Arquivos novamente 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 se você fechou 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 nossa imagem com o nome my-nginx.
  • .: Isso especifica o contexto de construção (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ê deve ver a imagem my-nginx listada na saída.

Executar e Testar a Imagem Personalizada

Vamos executar um container baseado em nossa nova imagem e testá-lo.

  1. No terminal do WebIDE, inicie um container 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 container.
  • -d: Esta flag executa o container em modo "detached" (em segundo plano).
  • -p 8080:80: Isso mapeia a porta 8080 do seu host para a porta 80 no container.
  • --name my-nginx-container: Isso atribui um nome ao nosso container.
  • my-nginx: Este é o nome da imagem que estamos usando para criar o container.
  1. Verifique se o container está em execução:
docker ps

Você deve ver o my-nginx-container listado na saída. Este comando mostra todos os containers ativos.

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

Você deve 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 no ícone + para criar um novo servidor web e inserir a porta 8080 para visualizar o conteúdo no navegador.

Configuração de porta do servidor web

Adicionar Software Personalizado à Imagem

Agora, vamos modificar nossa imagem Docker para incluir software adicional. Adicionaremos o utilitário curl como exemplo.

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

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

Entendendo a nova linha:

  • RUN apt-get update && apt-get install -y curl: Esta linha atualiza a lista de pacotes (apt-get update) e depois instala o curl (apt-get install -y curl). A flag -y responde automaticamente "sim" a qualquer solicitação 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-curl .

Este comando constrói uma nova imagem Docker com a tag my-nginx-curl que inclui o utilitário curl.

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

Você deve ver a imagem my-nginx-curl listada na saída.

Testar a Imagem Personalizada com Curl

Vamos executar um container baseado em nossa nova imagem e testar o utilitário curl.

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

Este comando inicia um novo container baseado na imagem my-nginx-curl e o nomeia como curl-container.

  1. Execute um shell bash no container em execução:
docker exec -it curl-container bash

Este comando abre um shell bash interativo dentro do container que está rodando.

Entendendo este comando:

  • docker exec: Executa um comando em um container em execução.
  • -it: Estas flags alocam um pseudo-TTY e mantêm o STDIN aberto, permitindo que você interaja com o shell.
  • curl-container: Este é o nome do nosso container.
  • bash: Este é o comando que estamos executando no container (abrindo um shell bash).
  1. Você deve ver agora um novo prompt, indicando que você está dentro do container. Dentro do container, teste o utilitário curl:
curl http://localhost

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

  1. Saia do shell bash do container:
exit

Este comando retorna você ao shell do seu sistema host.

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. 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: 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: Usa o comando 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 container baseado na nova imagem:
docker run -d -p 9000:9000 --name env-container my-nginx-env

Este comando inicia um novo container baseado na imagem my-nginx-env e mapeia a porta 9000 do host para a porta 9000 no container. Note 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á rodando na porta especificada:
curl http://localhost:9000

Você deve 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 utilizar 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 container, 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 container baseado na nova imagem. Definiremos a porta para 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 container para ver a mensagem de inicialização:
docker logs entrypoint-container

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

  1. Verifique se o servidor web está funcionando corretamente na nova porta:
curl http://localhost:9100

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

Resumo

Neste laboratório, você aprendeu a criar imagens Docker personalizadas que agregam valor às suas aplicações. Você começou criando uma imagem simples com um servidor web e progrediu para a adição de software personalizado e o uso de 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 prático.

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 containers Docker, aprendendo sobre mapeamento de portas e nomeação de containers.
  4. Modificou uma imagem Docker para incluir software adicional (curl).
  5. Usou o comando docker exec para executar comandos dentro de um container.
  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