Jak vytvořit Docker Images pomocí Dockerfile na Ubuntu 16.04 LTS

Docker je virtualizace na úrovni operačního systému určená především pro vývojáře a správce systému. Docker usnadňuje vytváření a nasazování aplikací v izolovaném prostředí. A Dockerfile je skript, který obsahuje kolekce příkazů a instrukcí, které budou automaticky postupně prováděny v prostředí dockeru pro vytvoření nového obrazu dockeru.

V tomto tutoriálu vám ukážu, jak vytvořit svůj vlastní obrázek dockeru pomocí souboru dockerfile. Skript dockerfile podrobně vysvětlím, abyste si mohli vytvořit své vlastní skripty dockerfile.

Předpoklad

• Linuxový server – jako hostitelský počítač budu používat Ubuntu 16.04 a jako základní obraz dockeru Ubuntu 16.04.
• Kořenová oprávnění.
• Porozumění příkazu Docker

Úvod do příkazu Dockerfile

Dockerfile je skript, který obsahuje kolekci příkazů dockerfile a příkazů operačního systému (např. příkazy Linuxu). Než vytvoříme náš první dockerfile, měli byste se seznámit s příkazem dockerfile.

Níže jsou uvedeny některé příkazy dockerfile, které musíte znát:

OD

Základní obrázek pro vytvoření nového obrázku. Tento příkaz musí být v horní části dockerfile.

ÚDRŽBA

Volitelně obsahuje jméno správce obrázku.

RUN

Používá se ke spuštění příkazu během procesu sestavování obrazu dockeru.

PŘIDAT

Zkopírujte soubor z hostitelského počítače do nového obrazu dockeru. Existuje možnost použít pro soubor adresu URL, docker pak tento soubor stáhne do cílového adresáře.

ENV

Definujte proměnnou prostředí.

CMD

Používá se pro provádění příkazů, když vytváříme nový kontejner z obrazu dockeru.

VSTUPNÍ BOD

Definujte výchozí příkaz, který bude spuštěn, když je kontejner spuštěn.

WORKDIR

Toto je příkaz pro provedení příkazu CMD.

UŽIVATEL

Nastavte uživatele nebo UID pro kontejner vytvořený s obrázkem.

VOLUME

Povolit přístup/propojený adresář mezi kontejnerem a hostitelským počítačem.

Nyní začněme vytvářet náš první dockerfile.

Krok 1 – Instalace Dockeru

Přihlaste se ke svému serveru a aktualizujte softwarové úložiště.

ssh [email protected]
apt-get update

Nainstalujte docker.io pomocí tohoto příkazu apt:

apt-get install docker.io

Po dokončení instalace spusťte službu docker a povolte její spuštění při spouštění:

systemctl start docker
systemctl enable docker

Docker byl nainstalován a běží v systému.

Krok 2 – Vytvoření souboru Dockerfile

V tomto kroku vytvoříme nový adresář pro soubor dockerfile a definujeme, co s tímto souborem dockeru chceme dělat.

Vytvořte nový adresář a v tomto adresáři nový a prázdný dockerfile.

mkdir ~/myimages 
cd myimages/
touch Dockerfile

Dále definujte, co chceme s naším novým vlastním obrázkem dělat. V tomto tutoriálu nainstaluji Nginx a PHP-FPM 7 pomocí obrazu dockeru Ubuntu 16.04. Navíc potřebujeme Supervisord, abychom mohli spustit Nginx a PHP-FPM 7 v jednom příkazu.

Upravte 'Dockerfile' pomocí vim:

nano Dockerfile

Do horní části souboru přidejte řádek se základním obrázkem (Ubuntu 16.04), který chceme použít.

#Download base image ubuntu 16.04
FROM ubuntu:16.04

Aktualizujte softwarové úložiště Ubuntu v dockerfile pomocí příkazu 'RUN'.

# Update Ubuntu Software repository
RUN apt-get update

Poté nainstalujte aplikace, které potřebujeme pro vlastní image. Nainstalujte Nginx, PHP-FPM a Supervisord z úložiště Ubuntu pomocí apt. Přidejte příkazy RUN pro instalaci Nginx a 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/*

V této fázi jsou všechny aplikace nainstalovány a musíme je nakonfigurovat. Nakonfigurujeme Nginx pro práci s aplikacemi PHP úpravou výchozí konfigurace virtuálního hostitele. Můžeme jej nahradit naším novým konfiguračním souborem nebo můžeme upravit stávající konfigurační soubor příkazem 'sed'.

V tomto tutoriálu nahradíme výchozí konfiguraci virtuálního hostitele novou konfigurací pomocí příkazu 'COPY' 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}

Dále nakonfigurujte Supervisord pro Nginx a PHP-FPM. Výchozí konfiguraci správce nahradíme novou konfigurací pomocí příkazu 'COPY'.

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

Nyní vytvořte nový adresář pro soubor sock php-fpm a změňte vlastníka adresáře /var/www/html a adresáře PHP na www-data.

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

Dále definujte svazek, abychom mohli připojit níže uvedené adresáře k hostitelskému počítači.

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

Nakonec nastavte výchozí příkaz kontejneru „CMD“ a otevřete port pro HTTP a HTTPS. Při spouštění kontejneru vytvoříme nový soubor start.sh pro výchozí příkaz 'CMD'. Soubor obsahuje příkaz 'supervisord' a my jej zkopírujeme do nového obrazu pomocí příkazu 'COPY' dockerfile.

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

EXPOSE 80 443

Uložte soubor a ukončete.

Zde je kompletní Dockerfile v jednom kuse:

#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

Nyní v našem adresáři 'Dockerfile' vytvořte nový konfigurační soubor pro virtuálního hostitele s názvem 'default', konfigurační soubor supervizora 'supervisord.conf' a konfigurační skript služby 'start.sh'.

vim default

Níže vložte výchozí konfiguraci virtuálního hostitele:

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

Dozorovaný konfigurační soubor:

vim supervisord.conf

Vložte konfiguraci níže:

[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

Soubor Start.sh.

vim start.sh

Vložte konfiguraci níže:

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

Uložit a ukončit

Udělejte start.sh spustitelný pomocí příkazu chmod:

chmod +x start.sh

Uložte soubor a ukončete.

Krok 3 – Vytvořte nový obrázek dockeru a vytvořte na něm nový kontejner

Dockerfile a všechny požadované konfigurační soubory byly vytvořeny, nyní můžeme vytvořit nový docker image založený na Ubuntu 16.04 a našem dockerfile pomocí příkazu docker níže:

docker build -t nginx_image .

Po úspěšném dokončení příkazu můžeme zkontrolovat nový obrázek 'nginx_image' pomocí příkazu docker níže:

docker images

Poté se můžeme pokusit vytvořit nový kontejner založený na nginx_images. A před vytvořením nového kontejneru můžeme na hostitelském počítači vytvořit nový adresář pro data webroot.

mkdir -p /webroot

Nyní spusťte nový kontejner pomocí příkazu níže:

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

Poté můžeme zkontrolovat, zda je spuštěn nový kontejner s názvem hakase založeným na 'nginx_image':

docker ps

Poznámka:

• --name hakase nginx_image =Vytvoříme nový kontejner s názvem 'hakase' na základě obrázku dockeru 'nginx_images'.
• -p 80:80 =kontejner hakase běžící na portu 80 na hostitelském počítači.
• -v /webroot:/var/www/html =adresář /webroot na hostitelském počítači přepište adresář /var/www/html v kontejneru.

Nový kontejner založený na nginx_image běží bez chyby.

Krok 4 – Testování Nginx a PHP-FPM v kontejneru

Zkuste vytvořit nový soubor index.html v adresáři /webroot s echo:

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

Testování pomocí příkazu curl přístupem k IP adrese hostitelského počítače.

curl 192.168.1.250
curl -I 192.168.1.250

Výsledky uvidíme níže.

Dále otestujte, že PHP-FPM 7.0 běží, vytvořením nového souboru phpinfo v adresáři /webroot na hostitelském počítači.

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

Otevřete webový prohlížeč a zadejte IP adresu hostitelského počítače:

http://192.168.1.248/info.php

Nyní můžete vidět výstup souboru phpinfo.

nový obrázek dockeru 'nginx_image' byl úspěšně vytvořen, nyní můžeme na základě tohoto obrázku vytvořit více kontejnerů.