Docker è una 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. Sotto alcune istruzioni Dockerfile che devi conoscere.
DA
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.
Corri
Questa istruzione veniva utilizzata per eseguire il comando durante il processo di compilazione dell'immagine Docker. Puoi installare pacchetti aggiuntivi necessari per le tue immagini Docker.
AGGIUNGI
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.
AMBIENTE
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 in linea in molte.
CMD
L'istruzione CMD viene utilizzata per definire il comando predefinito da eseguire durante l'esecuzione del container. E il Dockerfile deve contenere solo un'istruzione CMD e, se sono presenti più CMD, verrà eseguita l'ultima istruzione CMD.
ESPOSIZIONE
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. Puoi usare questa istruzione nella finestra mobile 'comando build' durante il tempo di compilazione usando l'opzione '--build-arg variabile=valore' e puoi passare attraverso il Dockerfile. Inoltre, puoi utilizzare più ARG nel Dockerfile.
PUNTO DI ENTRATA
L'istruzione ENTRYPOINT viene utilizzata per definire il primo comando predefinito che verrà eseguito quando il contenitore è in esecuzione. Definisci il comando per avviare la tua applicazione con l'istruzione ENTRYPOINT.
DIREZIONE LAVORO
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à creata automaticamente.
UTENTE
L'istruzione USER viene utilizzata per definire l'utente o il gid predefinito durante l'esecuzione dell'immagine. RUN, CMD e ENTRYPOINT seguono l'istruzione USER nel Dockerfile.
VOLUME
L'istruzione VOLUME ad utilizzata per abilitare l'accesso/la directory collegata tra il container 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 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 di Ubuntu e installa Docker usando il comando apt di seguito.
sudo apt update
sudo apt install docker.io
Una volta completata l'installazione, avvia il servizio Docker e aggiungilo all'avvio del sistema.
systemctl start docker
systemctl enable docker
Ora controlla il servizio Docker usando il comando seguente.
systemctl status docker
Il servizio Docker è attivo e funzionante su Ubuntu 20.04.
Quindi, esegui il comando Docker qui sotto per assicurarti che l'installazione sia corretta.
docker run hello-world
Di seguito è riportato 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 si può vedere, ricevi il messaggio Hello World da Docker e l'installazione di Docker su Ubuntu 20.04 è stata completata con successo.
Passaggio 2:crea Dockerfile e altre configurazioni
In questo passaggio, ti mostreremo come creare un'immagine Docker personalizzata per la tua applicazione utilizzando 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
Nella parte superiore della riga, aggiungi l'immagine di base di Ubuntu 20.04 usando l'istruzione FROM come di seguito.
#Download base image ubuntu 20.04
FROM ubuntu:20.04
Ora aggiungi informazioni dettagliate sull'immagine personalizzata usando l'istruzione LABEL.
# LABEL about the custom image
LABEL maintainer="[email protected]"
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 successivo all'installazione utilizzando la variabile di ambiente 'DEBIAN_FRONTEND=noninteractive'.
# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive
Quindi, 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, rimuovi 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
Definisci una nuova variabile di ambiente che può essere passata 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' al variabile predefinita '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}
Copia la configurazione personalizzata del supervisore 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 usando 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"]
E l'ultimo, apri le porte HTTP e HTTPS predefinite sul contenitore usando 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="[email protected]"
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 di host virtuale "predefinita" di 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.
Rendi eseguibile lo script 'start.sh'.
chmod +x start.sh
Di conseguenza, tutte le configurazioni per la nostra immagine Docker personalizzata sono state create, 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:crea un nuovo container personalizzato ed esegui un nuovo container
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 utilizzando il comando seguente.
docker image ls
Di seguito è riportato il risultato che otterrai.
Come si può vedere, è stata creata la nuova immagine Docker personalizzata 'nginx-image'.
Successivamente, eseguiremo il nuovo contenitore Docker basato su 'nginx-image'.
Sul tuo computer locale, crea una nuova directory denominata 'webroot' che verrà utilizzata per memorizzare tutti i file web.
mkdir -p /webroot
Ora crea un nuovo contenitore chiamato test-container usando 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 =contenitore di test in esecuzione sulla porta 8080 sul computer host.
- -v /webroot:/var/www/html =/directory webroot sulla macchina host riscrivi la directory /var/www/html sul contenitore.
Dopodiché, controlla tutti i container in esecuzione sul tuo sistema usando il seguente comando.
docker ps
Di seguito è riportato il risultato che otterrai.
Di conseguenza, il nuovo contenitore denominato 'test-container' basato su 'nginx-image' ed espone la porta 8080 è attivo e funzionante.
Fase 4 - Test
Per assicurarci che il contenitore funzioni correttamente, creeremo un nuovo file index.html e phpinfo nella directory principale '/webroot' sulla macchina host. Perché la directory '/webroot' è montata nella directory del contenitore '/var/www/html'.
Crea il file index.html nella directory '/webroot' usando il comando seguente.
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 container 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.
Quindi, 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
Quindi, apri il tuo browser web e digita l'indirizzo IP del tuo server con la porta '8080' seguendo il percorso del file 'info.php'.
http://ip-server:8080/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.