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í.

Dockerfile je skript, který obsahuje kolekce příkazů a instrukcí, které budou automaticky provedeny v sekvenci v prostředí dockeru pro vytvoření nového obrazu dockeru.

V tomto tutoriálu vám ukážeme, jak vytvořit svůj vlastní obrázek Docker pomocí souboru Docker. Vysvětlíme podrobnosti související s Dockerfile, abyste si mohli vytvořit svůj vlastní Docker image.

Předpoklady

Pro tuto příručku použijeme Ubuntu 18.04 s 1 GB RAM, 25 GB volného místa na disku a 2 CPU. Také použijeme Ubuntu 18.04 jako základní obraz pro vytvoření vlastního obrazu Dockeru.

Úvod do příkazu Dockerfile

Dockerfile je skript, který obsahuje všechny příkazy pro vytvoření obrazu Docker. Soubor Dockerfile obsahuje všechny pokyny, které budou použity k vytvoření obrazu Docker pomocí příkazu 'docker build'.

Před vytvořením svého prvního souboru Dockerfile byste se měli seznámit s pokyny pro Dockerfile. Níže jsou některé instrukce Dockerfile, které musíte znát.

OD

Nastavte základní obrázek pro nový obrázek, který chcete vytvořit. Instrukce FROM inicializuje novou fázi sestavení a musí být umístěna v horní části souboru Dockerfile.

LABEL

Pomocí této instrukce můžete přidat další informace o vašem obrazu Dockeru, jako je verze, popis, správce atd. Instrukce LABEL je pár klíč–hodnota, který vám umožňuje přidat více štítků a víceřádkových hodnot.

RUN

Tato instrukce se používá ke spuštění příkazu během procesu sestavování obrazu dockeru. Můžete nainstalovat další balíčky potřebné pro vaše obrazy Docker.

PŘIDAT

Instrukce ADD se používá ke kopírování souborů, adresářů nebo vzdálených souborů z URL do vašich obrázků Docker, z 'src' do absolutní cesty 'dest'. Můžete také nastavit výchozí vlastnictví souboru.

ENV

Instrukce ENV se používá k definování proměnné prostředí, kterou lze použít během fáze sestavení a lze ji v mnoha také nahradit inline.

CMD

Instrukce CMD se používá k definování výchozího příkazu, který se má provést při spuštění kontejneru. A Dockerfile musí obsahovat pouze jednu CMD instrukci, a pokud existuje více CMD, bude spuštěna poslední CMD instrukce.

VYSTAVIT

Tato instrukce se používá k odhalení kontejnerového portu na konkrétních síťových portech za běhu. Výchozí vystavený protokol je TCP, ale můžete určit, zda TCP nebo UDP.

ARG

Instrukce ARG se používá k definování proměnné, kterou může uživatel předat ve vestavěném čase. Tuto instrukci můžete použít v dockeru 'build command' během doby sestavení pomocí možnosti '--build-arg variable=value' a lze ji předat přes Dockerfile. Také můžete použít více ARG v Dockerfile.

VSTUPNÍ BOD

Instrukce ENTRYPOINT se používá k definování prvního a výchozího příkazu, který bude proveden, když je kontejner spuštěn. Definujte příkaz pro spuštění aplikace pomocí instrukce ENTRYPOINT.

WORKDIR

Instrukce WORKDIR se používá k definování výchozího pracovního adresáře vašeho obrazu Dockeru. Instrukce RUN, CMD, ENTRYPOINT a ADD se řídí instrukcí WORKDIR. Do souboru Dockerfile můžete přidat více instrukcí WORKDIR, a pokud žádná neexistuje, bude vytvořena automaticky.

UŽIVATEL

Instrukce USER se používá k definování výchozího uživatele nebo gid při spouštění obrazu. RUN, CMD a ENTRYPOINT se řídí instrukcemi USER v Dockerfile.

VOLUME

Reklama s instrukcemi VOLUME používaná k povolení přístupu/propojeného adresáře mezi kontejnerem a hostitelským počítačem.

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

Krok 1 – Instalace Docker CE (Community Edition)

Před vytvořením souboru Dockerfile nainstalujeme Docker CE do našeho systému Ubuntu 18.04.

Aktualizujte index balíčků Ubuntu a nainstalujte některé balíčky pomocí příkazu apt níže.

aktualizace sudo apt
instalace sudo apt \
    apt-transport-https \
    ca-certifikáty \
    curl \
    gnupg-agent \
 software-properties-common

Dále přidejte klíč GPG oficiálního úložiště Docker.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Dále přidejte úložiště Docker CE Community Edition pomocí následujícího příkazu.

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
 stabilní"

Příkaz automaticky znovu aktualizuje index balíčku.

Dále nainstalujte balíčky Docker CE pomocí příkazu apt níže.

sudo apt install docker-ce docker-ce-cli containerd.io

Po dokončení instalace spusťte službu Docker a přidejte ji do spouštění systému.

systemctl start docker
systemctl enable docker

Služba Docker je spuštěna a spuštěna, nyní spusťte níže uvedený příkaz docker, abyste se ujistili, že je instalace správná.

Docker spustit hello-world

Níže je výsledek, který dostanete.

Dobrý den z Dockeru!
Tato zpráva ukazuje, že vaše instalace zřejmě funguje správně.

K vygenerování této zprávy provedl Docker následující kroky:
 1. The Docker klient kontaktoval démona Docker.
 2. Démon Docker stáhl obrázek „hello-world“ z centra Docker.
    (amd64)
 3. Démon Docker z něj vytvořil nový kontejner obrázek, který spouští
    spustitelný soubor, který vytváří výstup, který právě čtete.
 4. Démon Docker streamoval tento výstup do klienta Docker, který jej odeslal
    do vašeho terminálu.
 
Chcete-li zkusit něco ambicióznějšího, můžete spustit kontejner Ubuntu pomocí:
 $ docker run -it ubuntu bash

Sdílejte obrázky, automatizujte pracovní postupy a další pomocí bezplatného ID Dockeru :
 https://hub.docker.com/

Další příklady a nápady naleznete na adrese:
 https://docs.docker.com/get-started/ 

 Jak je vidět, dostanete zprávu hello-world od Dockeru a instalace Docker CE byla úspěšně dokončena.
 
Krok 2 – Vytvoření souboru Dockerfile a dalších konfigurací
 

 V tomto kroku vám ukážeme, jak vytvořit vlastní image Dockeru pro vaši aplikaci pomocí Dockerfile. Vytvoříme nový vlastní obrázek Dockeru založený na obrázku Ubuntu 18.04 pro služby PHP-FPM a Nginx a poté spustíme nový kontejner pomocí jednoduchého skriptu phpinfo.
 

 Nejprve vytvořte nový adresář projektu a vytvořte prázdný soubor Dockerfile.
 
mkdir -p nginx-image; cd nginx-image/
dotkněte se Dockerfile
 

 Nyní upravte skript 'Dockerfile' pomocí svého vlastního editoru (pro tento příklad používáme vim).
 
vim Dockerfile
 

 Na začátek řádku přidejte základní obrázek Ubuntu 18.04 pomocí instrukce FROM, jak je uvedeno níže.
 
#Stáhnout základní obrázek ubuntu 18.04
Z ubuntu:18.04
 

 Nyní přidejte podrobné informace o vlastním obrázku pomocí instrukce LABEL.
 
# LABEL o vlastním obrázku
LABEL administrator="[email protected]"
LABEL version="0.1"
LABEL description="Toto je vlastní obrázek Dockeru pro \
služby PHP-FPM a Nginx."
 

 Při instalaci balíčků apt přeskočíme jakýkoli interaktivní krok po instalaci pomocí proměnné prostředí 'DEBIAN_FRONTEND=noninteractive'.
 
# Zakázat výzvu během instalace balíčků
ARG DEBIAN_FRONTEND=noninteractive
 

 Dále před instalací jakýchkoli balíčků spusťte příkaz 'apt update'.
 
# Aktualizovat úložiště softwaru Ubuntu
SPUSTIT aktualizaci apt
 

 Nyní nainstalujte balíčky Nginx, PHP-FPM a Supervisor. Po dokončení instalace odstraňte mezipaměť všech balíčků, aby se zmenšila velikost vlastního obrazu.
 
# Nainstalujte nginx, php-fpm a správce z úložiště ubuntu
SPUSTÍTE apt install -y nginx php-fpm správce &&\
    rm -rf /var/lib/apt/lists/* &&\ 
    apt clean
 

 Definujte novou proměnnou prostředí, kterou lze předat vlastnímu obrazu.
 
#Definujte proměnnou ENV
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.2/fpm/php.ini
ENV nginx_conf /etc /nginx/nginx.conf
ENV Supervisor_conf /etc/supervisor/supervisord.conf
 

 Nyní zkopírujte výchozí konfiguraci Nginx do proměnné 'nginx_vhost', nahraďte konfiguraci PHP 'cgi.fix_pathinfo=1' za 'cgi.fix_pathinfo=0' v konfiguračním souboru php.ini a poté přidejte možnost 'daemon off' do výchozí proměnná 'nginx_conf'.
 
# Povolit PHP-fpm na konfiguraci virtuálního hostitele nginx
KOPÍROVAT výchozí ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} &&\
    echo "\ndaemon off;">> ${nginx_conf}
 

 Zkopírujte vlastní konfiguraci supervizora do proměnné 'supervisor_conf'.
 
#Kopírovat konfiguraci supervizora
COPY Supervisord.conf ${supervisor_conf}
 

 Vytvořte nový adresář pro PHP-FPM sock soubor, změňte vlastnictví webového kořenového adresáře '/var/www/html' a PHP-FPM adresáře '/run/php' na výchozího uživatele 'www-data'.
 
RUN mkdir -p /run/php &&\
    chown -R www-data:www-data /var/www/html &&\
    chown -R www-data:www-data / run/php
 

 Definujte svazek pro vlastní obraz, abychom mohli všechny tyto adresáře připojit k hostitelskému počítači.
 
# Konfigurace svazku
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx ", "/var/www/html"]
 

 Nyní přidejte skript 'start.sh' a definujte výchozí příkaz kontejneru pomocí instrukce CMD, jak je uvedeno níže.
 
# Zkopírujte skript start.sh a definujte výchozí příkaz pro kontejner
COPY start.sh /start.sh
CMD [./start.sh"]
 

 A jako poslední otevřete výchozí porty HTTP a HTTPS na kontejneru pomocí instrukce EXPOSE.
 
# Expose Port pro aplikaci 
EXPOSE 80 443
 

 Uložit a zavřít.
 

 Níže je kompletní skript Dockerfile, který jsme právě vytvořili.
 
# Stáhnout základní obrázek ubuntu 18.04
Z ubuntu:18.04

# LABEL o vlastním obrázku
LABEL maintenanceer="[email protected]"
Verze LABEL ="0.1"
LABEL description="Toto je vlastní Docker Image pro \
služby PHP-FPM a Nginx."

# Zakázat výzvu během instalace balíčků
 ARG DEBIAN_FRONTEND=neinteraktivní

# Aktualizace úložiště softwaru Ubuntu
SPOUŠTĚJTE aktualizaci apt

# Nainstalujte nginx, php-fpm a dohled z úložiště ubuntu
RUN apt install -y nginx php-fpm správce &&\
    rm -rf /var/lib/apt/lists/* &&\
    apt clean
    
# Definujte proměnnou ENV
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.2/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
 ENV Supervisor_conf /etc/supervisor/supervisord.conf

# Povolit PHP-fpm na konfiguraci virtuálního hostitele nginx
KOPÍROVAT výchozí ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/ cgi.fix_pathinfo=0/g' ${php_conf} &&\
    echo "\ndaemon off;">> ${nginx_conf}
    
# Kopírovat konfiguraci supervizora
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
    
# Konfigurace hlasitosti
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www /html"]

# Zkopírujte skript start.sh a definujte výchozí příkaz pro kontejner
COPY start.sh /start.sh
CMD [./start.sh" ]

# Expose Port pro aplikaci 
EXPOSE 80 443
 

 Dále vytvoříme novou dodatečnou konfiguraci pro Nginx, supervizor a skript start.sh.
 

 „Výchozí“ konfigurace virtuálního hostitele Nginx bude obsahovat sekci pro PHP-FPM. Ve skutečnosti můžete skript PHP spouštět pomocí vlastního obrazu bez jakýchkoli změn.
 

 Pomocí editoru vytvořte novou „výchozí“ konfiguraci virtuálního hostitele Nginx.
 
výchozí nastavení vim
 

 Vložte do něj následující konfiguraci.
 
server {
    listen 80 default_server;
 
    root /var/www/html;
    index index.html index.htm index.nginx-debian.html;
 
    server_name _;
 
    umístění / {
        try_files $uri $uri/ =404;
    }
 
    umístění ~ \. php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php7.2-fpm.sock;
    }
}
 

 Uložit a zavřít.
 

 Dále vytvoříme konfiguraci 'supervisrod.conf', která obsahuje program Nginx i PHP-FPM, který bude spuštěn automaticky.
 

 Pomocí editoru vytvořte soubor 'supervisrod.conf'.
 
vim Supervisord.conf
 

 Vložte do něj následující konfiguraci.
 
[unix_http_server]
file=/dev/shm/supervisor.sock  ; (cesta k souboru soketu)
 
[supervisord]
logfile=/var/log/supervisord.log; (hlavní soubor protokolu; výchozí $CWD/supervisord.log)
logfile_maxbytes=50 MB       ; (maximální počet bajtů hlavního souboru protokolu b4 rotace; výchozí 50 MB)
zálohy_souboru protokolu=10          ; (počet záloh rotace hlavního souboru protokolu; výchozí 10)
loglevel=info               ; (úroveň protokolu;výchozí informace; ostatní:debug,warn,trace)
pidfile=/tmp/supervisord.pid; (pidfile supervizora; výchozí supervizor.pid)
nodaemon=false              ; (začít v popředí, pokud je pravda; výchozí nepravda)
minfds=1024                 ; (min. dostupné popisovače spouštěcích souborů; výchozí 1024)
minprocs=200                ; (min. dostupné deskriptory procesu; výchozí 200)
user=root            ;

[rpcinterface:supervisor]
supervisor.rpcinterface_factory =Supervisor.rpcinterface:make_main />  />[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock; použijte unix:// URL  pro unixový soket
 
[include]
files =/etc/supervisor/conf.d/*.conf
 
[program :php-fpm7.2]
command=/usr/sbin/php-fpm7.2 -F
numprocs=1
autostart=true
autorestart=true
 
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true
 

 Uložit a zavřít.
 

 Nyní vytvořte skript 'start.sh' pomocí t=vašeho editoru, bude obsahovat příkaz supervizor ke spuštění.
 
vim start.sh
 

 Vložte do něj následující konfiguraci.
 
#!/bin/sh
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf
 

 Uložit a zavřít.
 

 Udělejte skript 'start.sh' spustitelným.
 
chmod +x start.sh
 

 V důsledku toho byla vytvořena veškerá konfigurace pro náš vlastní obrázek Dockeru, níže jsou všechny konfigurace, které jsme vytvořili.
 
strom .
 

 Nyní jsme připraveni vytvořit nový vlastní obrázek založený na těchto konfiguracích.
 

 
 
Krok 3 – Vytvoření nového vlastního a spuštění nového kontejneru
 

 Chcete-li vytvořit vlastní bitovou kopii Dockeru, přejděte do adresáře projektu 'nginx-image' a spusťte příkaz 'docker build', jak je uvedeno níže.
 
docker build -t nginx-image .
 

 Příkaz stáhne základní obrázek Ubuntu 18.04 a vytvoří nový vlastní obrázek s názvem 'nginx-image.
 

 Po dokončení celého procesu zkontrolujte seznam dostupných bitových kopií Docker ve vašem systému pomocí následujícího příkazu.
 
docker image ls
 

 Níže je výsledek, který dostanete.
 

 
 

 Jak je vidět, byl vytvořen nový vlastní obrázek Dockeru 'nginx-image'.
 

 Dále spustíme nový kontejner Docker založený na 'nginx-image'.
 

 Na místním počítači vytvořte nový adresář s názvem 'webroot', který bude sloužit k ukládání všech webových souborů.
 
mkdir -p /webroot
 

 Nyní vytvořte nový kontejner s názvem test-container pomocí příkazu docker run níže.
 
docker run -d -v /webroot:/var/www/html -p 8080:80 --name test-container nginx-image
 

 Poznámka: 
 
 
--name test-container nginx-image =Vytvoříme nový kontejner s názvem 'test-container' na základě obrázku dockeru 'nginx-image'.
 
-p 8080:80 =kontejner testovacího kontejneru běžící na portu 8080 na hostitelském počítači.
 
-v /webroot:/var/www/html =adresář /webroot na hostitelském počítači přepíše adresář /var/www/html v kontejneru.
 
 

 Poté zkontrolujte všechny spuštěné kontejnery ve vašem systému pomocí následujícího příkazu.
 
docker ps
 

 Níže je výsledek, který dostanete.
 

 
 

 Výsledkem je, že nový kontejner s názvem 'test-container' na základě 'nginx-image' a odhalení portu 8080 je v provozu.
 
Krok 4 – Testování
 

 Abychom se ujistili, že kontejner běží správně, vytvoříme nový soubor index.html a phpinfo v kořenovém adresáři '/webroot' na hostitelském počítači. Protože adresář '/webroot' je připojen do adresáře kontejneru '/var/www/html'.
 

 Vytvořte soubor index.html v adresáři '/webroot' pomocí následujícího příkazu.
 
echo '
Nginx a PHP-FPM 7.2 uvnitř kontejneru Docker se základním obrázkem Ubuntu 18.04
'> /webroot/index.html
 

 Nyní otestujte přístup ke svému kontejneru pomocí příkazu curl na portu 8080.
 
curl server-ip:8080
curl -I server-ip:8080
 

 V důsledku toho získáte výchozí stránku index.html, kterou jsme právě vytvořili.
 

 
 

 Dále vytvořte nový soubor PHP 'info.php' v adresáři '/webroot', abyste se ujistili, že služba PHP-FPM běží.
 

 Pomocí následujícího příkazu vytvořte soubor 'info.php'.
 
echo ''> /webroot/info.php
 

 Dále otevřete webový prohlížeč a zadejte IP adresu svého serveru s portem '8080', za kterým následuje cesta k souboru 'info.php'.
 

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

 Nyní získáte stránku phpinfo, jak je uvedeno níže.
 

 
 

 Jak je vidět, 'test-container' je úspěšně načten skriptem PHP.
 

 V důsledku toho jsme úspěšně vytvořili nový vlastní obrázek Dockeru a na jeho základě jsme spustili nový kontejner s jakoukoli chybou.