Como criar imagens Docker com um Dockerfile no Ubuntu 22.04 LTS

Docker é uma virtualização em nível de sistema operacional voltada principalmente para desenvolvedores e administradores de sistema. O Docker facilita a construção e implantação de aplicativos em um ambiente isolado.

Um Dockerfile é um script que contém coleções de comandos e instruções que são executados automaticamente um após o outro no ambiente Docker para criar uma nova imagem Docker.

Este tutorial mostrará como criar sua própria imagem Docker usando um Dockerfile. Explicamos em detalhes como criar sua própria imagem Docker usando um Dockerfile.

Pré-requisitos

Para este guia, usaremos Ubuntu 22.04 com 1 GB de RAM, 25 GB de espaço livre em disco e 2 CPUs. Além disso, usaremos Ubuntu 22.04 como imagem base para construir a imagem Docker personalizada.

Introdução ao comando Dockerfile

Um Dockerfile é um script que contém todos os comandos para construir uma imagem Docker. O Dockerfile contém todas as instruções que serão usadas para criar a imagem Docker com o comando ‘docker build’.

Antes de criar seu primeiro Dockerfile, você deve estar familiarizado com as instruções do Dockerfile. Abaixo estão algumas instruções do Dockerfile que você deve conhecer.

DE

Defina a imagem base para a nova imagem que você deseja criar. A instrução FROM inicializará o novo estágio de construção e deve estar localizada na parte superior do Dockerfile.

LABEL

Com esta instrução, você pode adicionar informações adicionais sobre sua imagem Docker, como versão, descrição, mantenedor, etc. A instrução LABEL é um par chave-valor que permite adicionar vários rótulos e valores multilinhas.

EXECUTAR

Esta instrução usada para executar o comando durante o processo de construção da imagem docker. Você pode instalar pacotes adicionais necessários para suas imagens Docker.

ADICIONAR

A instrução ADD é usada para copiar arquivos, diretórios ou arquivos remotos do URL para suas imagens Docker, do 'src' ao caminho absoluto 'dest'. Além disso, você pode configurar a propriedade padrão do seu arquivo.

ENV

A instrução ENV define uma variável de ambiente que pode ser usada durante o estágio de construção e também pode ser substituída inline em muitos.

CMD

A instrução CMD define o comando padrão a ser executado ao executar o contêiner. E o Dockerfile deve conter apenas uma instrução CMD e, se houver vários CMD, a última instrução CMD será executada.

EXPONDER

Esta instrução expõe a porta do contêiner nas portas de rede específicas em tempo de execução. O protocolo padrão exposto é o TCP, mas você pode especificar se é TCP ou UDP.

ARG

A instrução ARG é usada para definir uma variável que o usuário pode passar no tempo de construção. Você pode usar esta instrução no 'comando de construção' do docker durante o tempo de construção usando a opção '--build-arg variável=valor' e pode ser passada através do Dockerfile. Além disso, você pode usar vários ARG no Dockerfile.

PONTO DE ENTRADA

A instrução ENTRYPOINT é usada para definir o primeiro comando padrão que será executado quando o contêiner estiver em execução. Defina o comando para iniciar sua aplicação com a instrução ENTRYPOINT.

WORKDIR

A instrução WORKDIR é usada para definir o diretório de trabalho padrão de sua imagem Docker. As instruções RUN, CMD, ENTRYPOINT e ADD seguem as instruções WORKDIR. Você pode adicionar várias instruções WORKDIR em seu Dockerfile e, se não existirem, elas serão criadas automaticamente.

USUÁRIO

A instrução USER é usada para definir o usuário ou gid padrão ao executar a imagem. RUN, CMD e ENTRYPOINT seguem as instruções USER no Dockerfile.

VOLUME

O anúncio de instrução VOLUME usado para permitir o acesso/diretório vinculado entre o contêiner e a máquina host.

Agora, vamos começar a criar o primeiro Dockerfile.

Passo 1 – Instale o Docker no Ubuntu 22.04

Antes de criar um Dockerfile, instalaremos o Docker em nosso sistema Ubuntu 22.04, que está disponível por padrão no repositório Ubuntu.

Atualize a lista de todos os pacotes no repositório Ubuntu e instale o Docker usando o comando apt abaixo.

sudo apt update
sudo apt install docker.io

Assim que toda a instalação for concluída, inicie o serviço Docker e adicione-o à inicialização do sistema.

systemctl start docker
systemctl enable docker

Agora verifique o serviço Docker usando o comando abaixo.

systemctl status docker

O serviço Docker está instalado e funcionando no Ubuntu 22.04.

Em seguida, execute o comando docker abaixo para garantir que a instalação esteja correta.

docker run hello-world

Abaixo está o resultado que você obterá.

Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/
For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Como pode ser visto, você recebe a mensagem Hello World do Docker e a instalação do Docker no Ubuntu 22.04 foi concluída com sucesso.

Passo 2 - Criar Dockerfile e outras configurações

Nesta etapa, mostraremos como construir uma imagem Docker personalizada para seu aplicativo usando o Dockerfile. Criaremos uma nova imagem Docker personalizada baseada na imagem Ubuntu 22.04, para os serviços PHP-FPM e Nginx e, em seguida, executaremos o novo contêiner com um script phpinfo simples.

Primeiro, crie um novo diretório de projeto e crie um Dockerfile vazio.

mkdir -p nginx-image
cd nginx-image/
touch Dockerfile

Agora edite o script 'Dockerfile' usando seu próprio editor (neste exemplo estamos usando nano).

nano Dockerfile

No topo da linha, adicione a imagem base do Ubuntu 22.04 usando a instrução FROM conforme abaixo.

# Download base image ubuntu 22.04
FROM ubuntu:22.04

Agora adicione informações detalhadas sobre a imagem personalizada usando a instrução LABEL.

# LABEL about the custom image
LABEL maintainer="[email "
LABEL version="0.1"
LABEL description="This is a custom Docker Image for PHP-FPM and Nginx."

Iremos pular qualquer etapa interativa de pós-instalação para a instalação dos pacotes apt usando a variável de ambiente 'DEBIAN_FRONTEND=noninteractive'.

# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive

Em seguida, execute o comando ‘apt update’ antes de instalar qualquer pacote.

# Update Ubuntu Software repository
RUN apt update

Agora instale os pacotes Nginx, PHP-FPM e supervisor. Assim que toda a instalação for concluída, remova o cache de todos os pacotes para reduzir o tamanho da imagem personalizada.

# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor
RUN rm -rf /var/lib/apt/lists/*
RUN apt clean

Defina uma nova variável de ambiente que possa ser passada para a imagem personalizada.

# Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/8.1/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf

Agora copie a configuração padrão do Nginx para a variável 'nginx_vhost', substitua a configuração do PHP 'cgi.fix_pathinfo=1' por 'cgi.fix_pathinfo=0' no arquivo de configuração php.ini e adicione a opção 'daemon off' ao variável padrão 'nginx_conf'.

# Enable PHP-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && echo "\ndaemon off;" >> ${nginx_conf}

Copie a configuração personalizada do supervisord para a variável 'supervisor_conf'.

#Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}

Crie um novo diretório para o arquivo sock PHP-FPM, altere a propriedade do diretório raiz da web '/var/www/html' e do diretório PHP-FPM '/run/php' para o usuário padrão 'www-data'.

RUN mkdir -p /run/php
RUN chown -R www-data:www-data /var/www/html
RUN chown -R www-data:www-data /run/php

Defina o volume da imagem personalizada para que possamos montar todos esses diretórios na máquina host.

# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]

Agora adicione o script 'start.sh' e defina o comando do contêiner padrão usando a instrução CMD conforme abaixo.

# Copy start.sh script and define default command for the container
COPY start.sh /start.sh
CMD ["./start.sh"]

E por último, abra as portas HTTP e HTTPS padrão no contêiner usando a instrução EXPOSE.

# Expose Port for the Application 
EXPOSE 80 443

Salvar e fechar.

Abaixo está o script Dockerfile completo que acabamos de criar.

# Download base image ubuntu 22.04
FROM ubuntu:22.04
# LABEL about the custom image
LABEL maintainer="[email "
LABEL version="0.1"
LABEL description="This is a custom Docker Image for PHP-FPM and Nginx."
# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive
# Update Ubuntu Software repository
RUN apt update
RUN apt upgrade -y
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor
RUN rm -rf /var/lib/apt/lists/*
RUN apt clean
    
# Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/8.1/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
# Enable PHP-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && echo "\ndaemon off;" >> ${nginx_conf}
    
# Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}
RUN mkdir -p /run/php
RUN chown -R www-data:www-data /var/www/html
RUN chown -R www-data:www-data /run/php
    
# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
# Copy start.sh script and define default command for the container
COPY start.sh /start.sh
CMD ["./start.sh"]
# Expose Port for the Application 
EXPOSE 80 443

A seguir, criaremos uma configuração adicional para Nginx, supervisord e o script start.sh.

A configuração 'padrão' do Nginx virtualhost conterá a seção para o PHP-FPM. Na verdade, você pode executar o script PHP usando a imagem personalizada sem nenhuma alteração.

Crie uma nova configuração de host virtual 'padrão' do Nginx com seu editor.

nano default

Cole a seguinte configuração nele.

server {
    listen 80 default_server;
    root /var/www/html;
    index index.html index.htm index.nginx-debian.html;
 
    server_name _;
 
    location / {
        try_files $uri $uri/ =404;
    }
 
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.1-fpm.sock;
    }
}

Salvar e fechar.

A seguir, criaremos a configuração 'supervisrod.conf', que contém programas Nginx e PHP-FPM que serão executados automaticamente.

Crie o arquivo 'supervisrod.conf' usando seu editor.

nano supervisord.conf

Cole a seguinte configuração nele.

[unix_http_server]
file=/dev/shm/supervisor.sock   ; (the path to the socket file)
 
[supervisord]
logfile=/var/log/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB        ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10           ; (num of main logfile rotation backups;default 10)
loglevel=info                ; (log level;default info; others: debug,warn,trace)
pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=false               ; (start in foreground if true;default false)
minfds=1024                  ; (min. avail startup file descriptors;default 1024)
minprocs=200                 ; (min. avail process descriptors;default 200)
user=root             ;
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
 
[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; use a unix:// URL  for a unix socket
 
[include]
files = /etc/supervisor/conf.d/*.conf
 
[program:php-fpm8.1]
command=/usr/sbin/php-fpm8.1 -F
numprocs=1
autostart=true
autorestart=true
 
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true

Salvar e fechar.

Agora crie o script 'start.sh' usando um editor contendo o comando supervisord para iniciar.

nano start.sh

Cole a seguinte configuração nele.

#!/bin/sh
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf

Salvar e fechar.

Torne o script 'start.sh' executável.

chmod +x start.sh

Como resultado, todas as configurações de nossa imagem Docker personalizada foram criadas. Abaixo estão todas as configurações que criamos.

ls -la

Estamos prontos para criar uma nova imagem personalizada com base nessas configurações agora.

Etapa 3 - Construir um novo contêiner personalizado e executar um novo contêiner

Para criar a imagem personalizada do Docker, vá para o diretório do projeto ‘nginx-image’ e execute o comando ‘docker build’ conforme abaixo.

docker build -t nginx-image .

O comando irá baixar a imagem base do Ubuntu 22.04 e criar uma nova imagem personalizada com o nome ‘nginx-image.

Assim que todo o processo for concluído, verifique a lista de imagens Docker disponíveis em seu sistema usando o seguinte comando.

docker image ls

Abaixo está o resultado que você obterá.

Como pode ser visto, a nova imagem personalizada do Docker 'nginx-image' foi criada.

A seguir, executaremos o novo contêiner Docker baseado na 'imagem nginx'.

Na sua máquina local, crie um novo diretório chamado '/var/webroot' que será usado para armazenar todos os arquivos da web.

mkdir -p /var/webroot

Agora crie um novo contêiner chamado test-container usando o comando docker run abaixo.

docker run -d -v /var/webroot:/var/www/html -p 8080:80 --name test-container nginx-image

Nota:

• --name test-container nginx-image=Criamos um novo contêiner com o nome 'test-container', baseado na imagem docker 'nginx-image'.
• -p 8080:80=contêiner de teste em execução na porta 8080 na máquina host.
• -v /var/webroot:/var/www/html=diretório /var/webroot na máquina host reescreva o diretório /var/www/html no contêiner.

Depois disso, verifique todos os contêineres em execução no seu sistema usando o seguinte comando.

docker ps

Abaixo está o resultado que você obterá.

Como resultado, o novo contêiner denominado 'test-container' baseado na 'imagem nginx' e expõe a porta 8080 está instalado e funcionando.

Etapa 4 – Teste

Para garantir que o contêiner esteja funcionando corretamente, criaremos um novo arquivo index.html e phpinfo no diretório raiz '/webroot' da máquina host. Porque o diretório '/var/webroot' é montado no diretório do contêiner '/var/www/html'.

Crie o arquivo index.html no diretório '/webroot' usando o seguinte comando.

echo '<h1>Nginx and PHP-FPM 8.1 inside Docker Container with Ubuntu 22.04 Base Image</h1>' > /var/webroot/index.html

Agora teste o acesso ao seu contêiner com o comando curl na porta 8080.

curl server-ip:8080
curl -I server-ip:8080

Como resultado, você obterá a página index.html padrão que acabamos de criar.

Em seguida, crie um novo arquivo PHP 'info.php' no diretório '/webroot' para garantir que o serviço PHP-FPM esteja em execução.

Crie o arquivo 'info.php' usando o seguinte comando.

echo '<?php phpinfo(); ?>' > /var/webroot/info.php

Em seguida, abra seu navegador e digite o endereço IP do seu servidor com a porta ‘8080’ seguido do caminho do arquivo ‘info.php’.

http://server-ip:8080/info.php

Agora você obterá a página phpinfo conforme abaixo.

Como pode ser visto, o 'test-container' carregou com sucesso o script PHP.

E, como resultado, criamos com sucesso uma nova imagem Docker personalizada e executamos o novo contêiner com base nela sem nenhum erro.