Ricerca nel sito web

Come creare immagini Docker con un Dockerfile su Ubuntu 20.04 LTS

Questo tutorial esiste per queste versioni del sistema operativo

  • Ubuntu 16.04 (Xenial Xerus)

Su questa pagina

  1. Introduzione al comando Dockerfile
  2. Passaggio 1 - Installa Docker su Ubuntu 20.04
  3. Passaggio 2 - Crea Dockerfile e altre configurazioni
  4. Passaggio 3: creazione di un nuovo contenitore personalizzato ed esecuzione di un nuovo contenitore
  5. Passaggio 4 - Test

Docker è la virtualizzazione a livello di sistema operativo destinata principalmente a sviluppatori e amministratori di sistema. Docker semplifica la creazione e la distribuzione di applicazioni in un ambiente isolato.

Un Dockerfile è uno script che contiene raccolte di comandi e istruzioni che verranno automaticamente eseguiti in sequenza nell'ambiente docker per creare una nuova immagine docker.

In questo tutorial, ti mostreremo come creare la tua immagine Docker con un Dockerfile. Spiegheremo i dettagli relativi al Dockerfile per consentirti di creare la tua immagine Docker.

Prerequisiti

Per questa guida utilizzeremo Ubuntu 20.04 con 1 GB di RAM, 25 GB di spazio libero su disco e 2 CPU. Inoltre, utilizzeremo Ubuntu 20.04 come immagine di base per creare l'immagine Docker personalizzata.

Introduzione al comando Dockerfile

Un Dockerfile è uno script che contiene tutti i comandi per la creazione di un'immagine Docker. Il Dockerfile contiene tutte le istruzioni che verranno utilizzate per creare l'immagine Docker con il comando docker build.

Prima di creare il tuo primo Dockerfile, dovresti familiarizzare con l'istruzione Dockerfile. Di seguito alcune istruzioni Dockerfile che devi conoscere.

A PARTIRE DAL

Imposta l'immagine di base per la nuova immagine che desideri creare. L'istruzione FROM inizializzerà la nuova fase di compilazione e deve trovarsi nella parte superiore del Dockerfile.

ETICHETTA

Con questa istruzione, puoi aggiungere ulteriori informazioni sulla tua immagine Docker, come la versione, la descrizione, il manutentore, ecc. L'istruzione LABEL è una coppia chiave-valore che ti consente di aggiungere più etichette e valori su più righe.

CORRERE

Questa istruzione era utilizzata per eseguire il comando durante il processo di compilazione dell'immagine docker. Puoi installare pacchetti aggiuntivi necessari per le tue immagini Docker.

INSERISCI

L'istruzione ADD viene utilizzata per copiare file, directory o file remoti dall'URL alle immagini Docker, da src al percorso assoluto dest. Inoltre, puoi impostare la proprietà predefinita del tuo file.

ENV

L'istruzione ENV viene utilizzata per definire una variabile di ambiente che può essere utilizzata durante la fase di compilazione e può essere sostituita anche inline in molti.

cmd

L'istruzione CMD viene utilizzata per definire il comando predefinito da eseguire durante l'esecuzione del contenitore. E il Dockerfile deve contenere solo un'istruzione CMD e, se sono presenti più CMD, verrà eseguita l'ultima istruzione CMD.

ESPORRE

Questa istruzione viene utilizzata per esporre la porta del contenitore sulle porte di rete specifiche in fase di esecuzione. Il protocollo predefinito esposto è TCP, ma è possibile specificare se TCP o UDP.

ARG

L'istruzione ARG viene utilizzata per definire una variabile che l'utente può passare in fase di compilazione. È possibile utilizzare questa istruzione nel comando docker build durante il tempo di compilazione utilizzando l'opzione --build-arg variable=value e può essere passata attraverso il Dockerfile. Inoltre, puoi utilizzare più ARG nel Dockerfile.

PUNTO D'ENTRATA

L'istruzione ENTRYPOINT viene utilizzata per definire il primo comando predefinito che verrà eseguito quando il contenitore è in esecuzione. Definire il comando per avviare l'applicazione con l'istruzione ENTRYPOINT.

WORKDIR

L'istruzione WORKDIR viene utilizzata per definire la directory di lavoro predefinita dell'immagine Docker. Le istruzioni RUN, CMD, ENTRYPOINT e ADD seguono l'istruzione WORKDIR. Puoi aggiungere più istruzioni WORKDIR sul tuo Dockerfile e, se non esiste, verrà creato automaticamente.

UTENTE

L'istruzione USER viene utilizzata per definire l'utente o gid predefinito durante l'esecuzione dell'immagine. RUN, CMD e ENTRYPOINT seguono l'istruzione USER nel Dockerfile.

VOLUME

L'annuncio dell'istruzione VOLUME utilizzato per abilitare l'accesso/directory collegata tra il contenitore e la macchina host.

Ora, iniziamo a creare il primo Dockerfile.

Passaggio 1: installa Docker su Ubuntu 20.04

Prima di creare un Dockerfile, installeremo il Docker sul nostro sistema Ubuntu 20.04, che è disponibile per impostazione predefinita nel repository Ubuntu FocalFossa.

Aggiorna l'elenco di tutti i pacchetti nel repository Ubuntu e installa Docker utilizzando il comando apt di seguito.

sudo apt update
sudo apt install docker.io

Una volta completata l'installazione, avviare il servizio Docker e aggiungerlo all'avvio del sistema.

systemctl start docker
systemctl enable docker

Ora controlla il servizio Docker utilizzando il comando seguente.

systemctl status docker

Il servizio Docker è attivo e funzionante su Ubuntu 20.04.

Successivamente, esegui il comando docker di seguito per assicurarti che l'installazione sia corretta.

docker run hello-world

Di seguito il risultato che otterrai.

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/

Come puoi vedere, ricevi il messaggio Hello World da Docker e l'installazione di Docker su Ubuntu 20.04 è stata completata correttamente.

Passaggio 2: creazione di Dockerfile e altre configurazioni

In questo passaggio, ti mostreremo come creare un'immagine Docker personalizzata per la tua applicazione utilizzando il Dockerfile. Creeremo una nuova immagine Docker personalizzata basata sull'immagine Ubuntu 20.04, per i servizi PHP-FPM e Nginx, quindi eseguiremo il nuovo contenitore con un semplice script phpinfo.

Innanzitutto, crea una nuova directory di progetto e crea un Dockerfile vuoto.

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

Ora modifica lo script Dockerfile usando il tuo editor (per questo esempio stiamo usando vim).

vim Dockerfile

In cima alla riga, aggiungi l'immagine Ubuntu 20.04 dell'immagine di base usando l'istruzione FROM come di seguito.

#Download base image ubuntu 20.04
FROM ubuntu:20.04

Ora aggiungi informazioni dettagliate sull'immagine personalizzata utilizzando l'istruzione LABEL.

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

Per l'installazione dei pacchetti apt, salteremo qualsiasi passaggio interattivo post-installazione utilizzando la variabile d'ambiente DEBIAN_FRONTEND=noninteractive.

# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive

Successivamente, esegui il comando apt update prima di installare qualsiasi pacchetto.

# Update Ubuntu Software repository
RUN apt update

Ora installa i pacchetti Nginx, PHP-FPM e supervisor. Una volta completata l'installazione, rimuovere la cache di tutti i pacchetti per ridurre le dimensioni dell'immagine personalizzata.

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

Definire una nuova variabile di ambiente che può essere trasmessa all'immagine personalizzata.

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

Ora copia la configurazione predefinita di Nginx nella variabile nginx_vhost, sostituisci la configurazione PHP cgi.fix_pathinfo=1 con cgi.fix_pathinfo=0 nel file di configurazione php.ini, quindi aggiungi l'opzione daemon off alla variabile nginx_conf predefinita.

# 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}

Copia la configurazione supervisionata personalizzata nella variabile supervisor_conf.

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

Crea una nuova directory per il file sock PHP-FPM, cambia la proprietà della directory web-root /var/www/html e della directory PHP-FPM /run/php con l'utente predefinito www-data.

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

Definisci il volume per l'immagine personalizzata in modo da poter montare tutte quelle directory sul computer host.

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

Ora aggiungi lo script start.sh e definisci il comando contenitore predefinito utilizzando l'istruzione CMD come di seguito.

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

Infine, apri le porte HTTP e HTTPS predefinite sul contenitore utilizzando l'istruzione EXPOSE.

# Expose Port for the Application 
EXPOSE 80 443

Salva e chiudi.

Di seguito è riportato lo script Dockerfile completo che abbiamo appena creato.

# Download base image ubuntu 20.04
FROM ubuntu:20.04

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

# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive

# Update Ubuntu Software repository
RUN apt update

# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor && \
    rm -rf /var/lib/apt/lists/* && \
    apt clean
    
# Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.4/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 && \
    chown -R www-data:www-data /var/www/html && \
    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

Successivamente, creeremo una nuova configurazione aggiuntiva per Nginx, supervisord e lo script start.sh.

La configurazione predefinita dell'host virtuale Nginx conterrà la sezione per PHP-FPM. In effetti, puoi eseguire lo script PHP utilizzando l'immagine personalizzata senza alcuna modifica.

Crea una nuova configurazione virtualhost predefinita Nginx con il tuo editor.

vim default

Incolla la seguente configurazione al suo interno.

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/php7.4-fpm.sock;
    }
}

Salva e chiudi.

Successivamente, creeremo la configurazione supervisrod.conf che contiene sia il programma Nginx che PHP-FPM che verrà eseguito automaticamente.

Crea il file supervisrod.conf usando il tuo editor.

vim supervisord.conf

Incolla la seguente configurazione al suo interno.

[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-fpm7.4]
command=/usr/sbin/php-fpm7.4 -F
numprocs=1
autostart=true
autorestart=true
 
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true

Salva e chiudi.

Ora crea lo script start.sh usando t=il tuo editor, conterrà il comando supervisord per iniziare.

vim start.sh

Incolla la seguente configurazione al suo interno.

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

Salva e chiudi.

Rende eseguibile lo script start.sh.

chmod +x start.sh

Di conseguenza, è stata creata tutta la configurazione per la nostra immagine Docker personalizzata, di seguito sono riportate tutte le configurazioni che abbiamo creato.

tree .

Ora siamo pronti per creare una nuova immagine personalizzata basata su queste configurazioni.

Passaggio 3: creazione di un nuovo contenitore personalizzato ed esecuzione di un nuovo contenitore

Per creare l'immagine personalizzata Docker, vai alla directory del progetto nginx-image ed esegui il comando docker build come di seguito.

docker build -t nginx-image .

Il comando scaricherà l'immagine di base Ubuntu 20.04 e creerà una nuova immagine personalizzata con il nome nginx-image.

Una volta completato tutto il processo, controlla l'elenco delle immagini Docker disponibili sul tuo sistema usando il seguente comando.

docker image ls

Di seguito il risultato che otterrai.

Come si può vedere, è stata creata la nuova immagine Docker personalizzata nginx-image.

Successivamente, eseguiremo il nuovo contenitore Docker basato sull'immagine nginx.

Sul tuo computer locale, crea una nuova directory denominata webroot che verrà utilizzata per archiviare tutti i file Web.

mkdir -p /webroot

Ora crea un nuovo contenitore denominato test-container utilizzando il comando docker run di seguito.

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

Nota:

  • --name test-container nginx-image=Creiamo un nuovo contenitore con il nome test-container, basato sull'immagine docker nginx-image.
  • -p 8080:80=container test-container in esecuzione sulla porta 8080 sulla macchina host.
  • -v /webroot:/var/www/html=La directory /webroot sulla macchina host riscrive la directory /var/www/html sul contenitore.

Successivamente, controlla tutti i contenitori in esecuzione sul tuo sistema usando il seguente comando.

docker ps

Di seguito il risultato che otterrai.

Di conseguenza, il nuovo contenitore denominato test-container basato sull'immagine nginx ed espone la porta 8080 è attivo e funzionante.

Passaggio 4: test

Per assicurarci che il contenitore funzioni correttamente, creeremo un nuovo file index.html e phpinfo nella directory root /webroot sulla macchina host. Perché la directory /webroot è montata nella directory del contenitore /var/www/html.

Crea il file index.html nella directory /webroot utilizzando il seguente comando.

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

Ora prova l'accesso al tuo contenitore con il comando curl sulla porta 8080.

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

Di conseguenza, otterrai la pagina index.html predefinita che abbiamo appena creato.

Successivamente, crea un nuovo file PHP info.php nella directory /webroot per assicurarti che il servizio PHP-FPM sia in esecuzione.

Crea il file info.php usando il seguente comando.

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

Successivamente, apri il tuo browser web e digita l'indirizzo IP del tuo server con la porta 8080 seguita dal percorso del file info.php.

Ora otterrai la pagina phpinfo come di seguito.

Come si può vedere, il test-container ha caricato con successo lo script PHP.

Di conseguenza, abbiamo creato con successo una nuova immagine Docker personalizzata ed eseguito il nuovo contenitore basato su di essa con qualsiasi errore.