Come creare immagini Docker con un Dockerfile su Ubuntu 16.04 LTS

Docker è la virtualizzazione a livello di sistema operativo destinata principalmente a sviluppatori e amministratori di sistema. Docker semplifica la creazione e il deployment di applicazioni in un ambiente isolato. Un file Docker è uno script che contiene raccolte di comandi e istruzioni che verranno automaticamente eseguiti in sequenza nell'ambiente della finestra mobile per la creazione di una nuova immagine della finestra mobile.

In questo tutorial, ti mostrerò come creare la tua immagine docker con un dockerfile. Spiegherò lo script dockerfile in dettaglio per consentirti di creare i tuoi script dockerfile.

Prerequisito

• Un server Linux:userò Ubuntu 16.04 come macchina host e Ubuntu 16.04 come immagine di base della finestra mobile.
• Privilegi root.
• Comprendere il comando Docker

Introduzione al comando Dockerfile

Un dockerfile è uno script che contiene una raccolta di comandi di dockerfile e comandi del sistema operativo (es:comandi Linux). Prima di creare il nostro primo dockerfile, dovresti acquisire familiarità con il comando dockerfile.

Di seguito sono riportati alcuni comandi dockerfile che devi conoscere:

DA

L'immagine di base per la creazione di una nuova immagine. Questo comando deve trovarsi in cima al dockerfile.

MANTENENTE

Facoltativo, contiene il nome del gestore dell' immagine.

Corri

Utilizzato per eseguire un comando durante il processo di compilazione dell'immagine della finestra mobile.

AGGIUNGI

Copia un file dalla macchina host nella nuova immagine Docker. C'è un'opzione per utilizzare un URL per il file, la finestra mobile scaricherà il file nella directory di destinazione.

AMBIENTE

Definisci una variabile di ambiente.

CMD

Utilizzato per eseguire comandi quando creiamo un nuovo contenitore dall'immagine della finestra mobile.

PUNTO DI ENTRATA

Definisci il comando predefinito che verrà eseguito quando il contenitore è in esecuzione.

DIREZIONE LAVORO

Questa è la direttiva per l'esecuzione del comando CMD.

UTENTE

Imposta l'utente o l'UID per il contenitore creato con l'immagine.

VOLUME

Abilita accesso/directory collegata tra il contenitore e la macchina host.

Ora iniziamo a creare il nostro primo dockerfile.

Passaggio 1:installazione di Docker

Accedi al tuo server e aggiorna il repository del software.

ssh [email protected]
apt-get update

Installa docker.io con questo comando apt:

apt-get install docker.io

Al termine dell'installazione, avvia il servizio Docker e abilita l'avvio all'avvio:

systemctl start docker
systemctl enable docker

Docker è stato installato ed è in esecuzione sul sistema.

Passaggio 2:crea un file Docker

In questo passaggio creeremo una nuova directory per il dockerfile e definiremo cosa vogliamo fare con quel dockerfile.

Crea una nuova directory e un nuovo file docker vuoto all'interno di quella directory.

mkdir ~/myimages 
cd myimages/
touch Dockerfile

Quindi, definisci cosa vogliamo fare con la nostra nuova immagine personalizzata. In questo tutorial, installerò Nginx e PHP-FPM 7 utilizzando un'immagine docker di Ubuntu 16.04. Inoltre, abbiamo bisogno di Supervisord, quindi possiamo avviare Nginx e PHP-FPM 7 in un unico comando.

Modifica il 'Dockerfile' con vim:

nano Dockerfile

Nella parte superiore del file, aggiungi una riga con l'immagine di base (Ubuntu 16.04) che vogliamo utilizzare.

#Download base image ubuntu 16.04
FROM ubuntu:16.04

Aggiorna il repository del software Ubuntu all'interno del dockerfile con il comando "Esegui".

# Update Ubuntu Software repository
RUN apt-get update

Quindi installa le applicazioni di cui abbiamo bisogno per l'immagine personalizzata. Installa Nginx, PHP-FPM e Supervisord dal repository di Ubuntu con apt. Aggiungi i comandi RUN per l'installazione di Nginx e PHP-FPM.

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

In questa fase, tutte le applicazioni sono installate e dobbiamo configurarle. Configurare Nginx per la gestione delle applicazioni PHP modificando la configurazione predefinita dell'host virtuale. Possiamo sostituirlo con il nostro nuovo file di configurazione, oppure possiamo modificare il file di configurazione esistente con il comando 'sed'.

In questo tutorial, sostituiremo la configurazione predefinita dell'host virtuale con una nuova configurazione utilizzando il comando 'COPIA' dockerfile.

#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/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}

Quindi, configura Supervisord per Nginx e PHP-FPM. Sostituiremo la configurazione predefinita di Supervisore con una nuova configurazione utilizzando il comando 'COPIA'.

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

Ora crea una nuova directory per il file sock php-fpm e cambia il proprietario della directory /var/www/html e della directory PHP in www-data.

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

Quindi, definisci il volume in modo da poter montare le directory elencate di seguito sulla macchina host.

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

Infine, imposta il comando contenitore predefinito "CMD" e apri la porta per HTTP e HTTPS. Creeremo un nuovo file start.sh per il comando "CMD" predefinito all'avvio del container. Il file contiene il comando 'supervisord' e noi copieremo il file nella nuova immagine con il comando dockerfile 'COPY'.

# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]

EXPOSE 80 443

Salva il file ed esci.

Ecco il Dockerfile completo in un unico pezzo:

#Download base image ubuntu 16.04
FROM ubuntu:16.04
 
# Update Software repository
RUN apt-get update
 
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
    rm -rf /var/lib/apt/lists/*
 
#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/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"]
 
# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]
 
EXPOSE 80 443

Ora all'interno della nostra directory "Dockerfile", crea un nuovo file di configurazione per l'host virtuale denominato "default", un file di configurazione supervisore "supervisord.conf" e uno script di configurazione del servizio "start.sh".

vim default

Incolla la configurazione predefinita dell'host virtuale di seguito:

server {
    listen 80 default_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.0-fpm.sock;
    }
 
    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny all;
    #}
}

File di configurazione del supervisore:

vim supervisord.conf

Incolla la configurazione di seguito:

[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             ;
 
; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[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
 
; The [include] section can just contain the "files" setting.  This
; setting can list multiple files (separated by whitespace or
; newlines).  It can also contain wildcards.  The filenames are
; interpreted as relative to this file.  Included files *cannot*
; include files themselves.
 
[include]
files = /etc/supervisor/conf.d/*.conf
 
 
[program:php-fpm7.0]
command=/usr/sbin/php-fpm7.0 -F
numprocs=1
autostart=true
autorestart=true
 
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true

Avvia il file.sh.

vim start.sh

Incolla la configurazione di seguito:

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

Salva ed esci

Rendi eseguibile start.sh con il comando chmod:

chmod +x start.sh

Salva il file ed esci.

Passaggio 3:crea una nuova immagine Docker e crea un nuovo contenitore basato su di essa

Il Dockerfile e tutti i file di configurazione richiesti sono stati creati, ora possiamo creare una nuova immagine Docker basata su Ubuntu 16.04 e il nostro Dockerfile con il comando Docker qui sotto:

docker build -t nginx_image .

Quando il comando è stato completato correttamente, possiamo controllare la nuova immagine 'nginx_image' con il comando docker seguente:

docker images

Quindi possiamo provare a creare un nuovo contenitore basato su nginx_images. E prima di creare un nuovo contenitore, possiamo creare una nuova directory sulla macchina host per i dati webroot.

mkdir -p /webroot

Ora esegui il nuovo contenitore con il comando seguente:

docker run -d -v /webroot:/var/www/html -p 80:80 --name hakase nginx_image

Quindi possiamo verificare che il nuovo contenitore con nome hakase basato su 'nginx_image' sia in esecuzione:

docker ps

Nota:

• --name hakase nginx_image =Creiamo un nuovo contenitore con il nome 'hakase', basato sull'immagine docker 'nginx_images'.
• -p 80:80 =contenitore hakase in esecuzione sulla porta 80 della macchina host.
• -v /webroot:/var/www/html =/webroot directory sulla macchina host riscrive la directory /var/www/html sul contenitore.

Il nuovo contenitore basato su nginx_image viene eseguito senza errori.

Fase 4:test di Nginx e PHP-FPM nel contenitore

Prova a creare un nuovo file index.html nella directory /webroot con echo:

echo '<h1>Nginx and PHP-FPM 7 inside Docker Container</h1>' > /webroot/index.html

Test con il comando curl accedendo all'indirizzo IP della macchina host.

curl 192.168.1.250
curl -I 192.168.1.250

Vedremo i risultati di seguito.

Quindi, verifica che PHP-FPM 7.0 sia in esecuzione creando un nuovo file phpinfo nella directory /webroot sul computer host.

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

Aprire il browser Web e digitare l'indirizzo IP della macchina host:

http://192.168.1.248/info.php

Ora puoi vedere l'output del file phpinfo.

la nuova immagine mobile 'nginx_image' è stata creata con successo, ora possiamo creare più contenitori basati su quell'immagine.