Pesquisa de site

Como construir e configurar automaticamente imagens Docker personalizadas com Dockerfile - Parte 3

Este tutorial se concentrará em como construir uma imagem Docker personalizada baseada no Ubuntu com o serviço Apache instalado. Todo o processo será automatizado usando um Dockerfile.

As imagens Docker podem ser criadas automaticamente a partir de arquivos de texto, denominados Dockerfiles. Um arquivo Docker contém instruções ou comandos ordenados passo a passo usados para criar e configurar uma imagem Docker.

Requisitos

  • Instale o Docker e aprenda a manipulação do contêiner Docker – Parte 1
  • Implantar e executar aplicativos em contêineres Docker – Parte 2

Basicamente, um arquivo Docker contém várias instruções para construir e configurar um contêiner específico com base em seus requisitos. As seguintes instruções são as mais utilizadas, sendo algumas delas obrigatórias:

  1. FROM=Obrigatório como primeira instrução em um arquivo Docker. Instrui o Docker a extrair a imagem base da qual você está construindo a nova imagem. Use uma tag para especificar a imagem exata a partir da qual você está construindo:
Ex: FROM ubuntu:20.04
  1. MAINTAINER=Autor da imagem de construção
  2. RUN=Esta instrução pode ser usada em várias linhas e executa qualquer comando após a criação de uma imagem Docker.
  3. CMD=Execute qualquer comando quando a imagem Docker for iniciada. Use apenas uma instrução CMD em um Dockerfile.
  4. ENTRYPOINT=Igual ao CMD, mas usado como comando principal da imagem.
  5. EXPOSE=Instrui o contêiner a escutar nas portas de rede durante a execução. As portas do contêiner não podem ser acessadas pelo host por padrão.
  6. ENV=Definir variáveis de ambiente do contêiner.
  7. ADD=Copia recursos (arquivos, diretórios ou arquivos de URLs).

Etapa 1: Criando ou Escrevendo Repositório Dockerfile

1. Primeiro, vamos criar algum tipo de repositório Dockerfile para reutilizar arquivos no futuro para criar outras imagens. Crie um diretório vazio em algum lugar da partição /var onde criaremos o arquivo com as instruções que serão usadas para construir a nova imagem Docker.

mkdir -p /var/docker/ubuntu/apache
touch /var/docker/ubuntu/apache/Dockerfile

2. Em seguida, comece a editar o arquivo com as seguintes instruções:

vi /var/docker/ubuntu/apache/Dockerfile

Trecho do arquivo Doker:

FROM ubuntu
MAINTAINER  your_name  <[email >
RUN apt-get -y install apache2
RUN echo “Hello Apache server on Ubuntu Docker” > /var/www/html/index.html
EXPOSE 80
CMD /usr/sbin/apache2ctl -D FOREGROUND

Agora, vamos seguir as instruções do arquivo:

A primeira linha nos diz que estamos construindo a partir de uma imagem do Ubuntu. Se nenhuma tag for enviada, digamos 14:10, por exemplo, a imagem mais recente do Docker Hub será usada.

Na segunda linha, adicionamos o nome e o e-mail do criador da imagem. As próximas duas linhas RUN serão executadas no contêiner ao construir a imagem e instalarão o daemon Apache e eco algum texto na página padrão do Apache .

A linha EXPOSE instruirá o contêiner docker a escutar na porta 80, mas a porta não estará disponível para fora. A última linha instrui o contêiner a executar o serviço Apache em primeiro plano após o contêiner ser iniciado.

3. A última coisa que precisamos fazer é começar a criar a imagem emitindo o comando abaixo, que criará localmente uma nova imagem Docker chamada ubuntu-apache com base no Dockerfile criado anteriormente, conforme mostrado neste exemplo:

docker build -t ubuntu-apache /var/docker/ubuntu/apache/

4. Após a imagem ter sido criada pelo Docker, você pode listar todas as imagens disponíveis e identificar sua imagem emitindo o seguinte comando:

docker images

Etapa 2: execute o contêiner e acesse o Apache pela LAN

5. Para executar o contêiner continuamente (em segundo plano) e acessar os serviços (portas) expostos ao contêiner a partir do host ou de outra máquina remota em sua LAN, execute o comando abaixo no prompt do terminal do host :

docker run -d -p 81:80 ubuntu-apache

Aqui, a opção -d executa o contêiner ubuntu-apache em segundo plano (como um daemon) e a opção -p mapeia a porta do contêiner 80 para a porta localhost 81. O acesso externo da LAN ao serviço Apache pode ser alcançado somente pela porta 81.

O comando Netstat lhe dará uma ideia sobre quais portas o host está escutando.

Após o contêiner ter sido iniciado, você também pode executar o comando docker ps para visualizar o status do contêiner em execução.

6. A página da web pode ser exibida em seu host a partir da linha de comando usando o utilitário curl no endereço IP da sua máquina, localhost ou interface de rede docker na porta 81. Use o comando IP linha para mostrar endereços IP da interface de rede.

ip addr               [List nework interfaces]
curl ip-address:81    [System Docker IP Address]
curl localhost:81     [Localhost]

7. Para visitar a página do contêiner a partir da sua rede, abra um navegador em um local remoto e use o protocolo HTTP, o endereço IP da máquina onde o contêiner está sendo executado, seguido pela porta 81 conforme ilustrado na página imagem abaixo.

http://ip-address:81

8. Para saber quais processos estão sendo executados dentro do contêiner, emita o seguinte comando:

docker ps
docker top <name or ID of the container>

9. Para interromper o problema do contêiner, execute o comando docker stop seguido pelo ID ou nome do contêiner.

docker stop <name or ID of the container>
docker ps

10. Caso queira atribuir um nome descritivo ao container use a opção --name conforme mostrado no exemplo abaixo:

docker run --name my-www -d -p 81:80 ubuntu-apache
docker ps

Agora você pode referenciar o contêiner para manipulação (iniciar, parar, topo, estatísticas, etc.) apenas usando o nome atribuído.

docker stats my-www

Etapa 3: Crie um arquivo de configuração de todo o sistema para Docker Container

11. No CentOS/RHEL você pode criar um arquivo de configuração systemd e gerenciar o contêiner como faria normalmente para qualquer outro serviço local.

Por exemplo, crie um novo arquivo systemd chamado, digamos, apache-docker.service usando o seguinte comando:

vi /etc/systemd/system/apache-docker.service

Trecho do arquivo apache-docker.service:

[Unit]
Description=apache container
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/bin/docker start -a my-www
ExecStop=/usr/bin/docker stop -t 2 my-www

[Install]
WantedBy=local.target

12. Após terminar de editar o arquivo, feche-o, recarregue o daemon systemd para refletir as alterações e inicie o contêiner emitindo os seguintes comandos:

systemctl daemon-reload
systemctl start apache-docker.service
systemctl status apache-docker.service

Este foi apenas um exemplo simples do que você pode fazer com um simples Dockerfile, mas você pode pré-construir alguns aplicativos bastante sofisticados que podem ser iniciados em questão de segundos com recursos e esforço mínimos.

Leitura adicional: