Ինչպես ստեղծել Docker Images Dockerfile-ով Ubuntu 22.04 LTS-ում

Այս ձեռնարկը գոյություն ունի ՕՀ-ի այս տարբերակների համար

• Ubuntu 22.04 (Jammy Jellyfish)
• Ubuntu 20.04 (Կիզակետային Fossa)
• Ubuntu 18.04 (Bionic Beaver)
• Ubuntu 16.04 (Xenial Xerus)

Այս էջում

1. Ներածություն Dockerfile հրամանին
2. Քայլ 1 - Տեղադրեք Docker-ը Ubuntu 22.04-ում
3. Քայլ 2 - Ստեղծեք Dockerfile և այլ կոնֆիգուրացիաներ
4. Քայլ 3 - Ստեղծեք նոր մաքսային և գործարկեք նոր կոնտեյներ
5. Քայլ 4 - Փորձարկում

Docker-ը օպերացիոն համակարգի մակարդակի վիրտուալացում է, որը հիմնականում ուղղված է մշակողների և համակարգի ադմինիստրատորներին: Docker-ը հեշտացնում է հավելվածների ստեղծումն ու տեղակայումը մեկուսացված միջավայրում:

Dockerfile-ը սկրիպտ է, որը պարունակում է հրամանների և հրահանգների հավաքածուներ, որոնք ավտոմատ կերպով կատարվում են մեկը մյուսի հետևից Docker միջավայրում՝ նոր Docker պատկեր ստեղծելու համար:

Այս ձեռնարկը ցույց կտա ձեզ, թե ինչպես ստեղծել ձեր սեփական Docker պատկերը՝ օգտագործելով Dockerfile: Մենք մանրամասն բացատրում ենք, թե ինչպես ստեղծել ձեր սեփական Docker պատկերը՝ օգտագործելով Dockerfile-ը:

Նախադրյալներ

Այս ուղեցույցի համար մենք կօգտագործենք Ubuntu 22.04-ը՝ 1 ԳԲ օպերատիվ հիշողությամբ, 25 ԳԲ ազատ սկավառակի տարածությամբ և 2 պրոցեսորով: Բացի այդ, մենք կօգտագործենք Ubuntu 22.04-ը որպես հիմնական պատկեր՝ անհատական Docker պատկերը ստեղծելու համար:

Ներածություն Dockerfile հրամանին

Dockerfile-ը սկրիպտ է, որը պարունակում է Docker պատկեր ստեղծելու բոլոր հրամանները: Dockerfile-ը պարունակում է բոլոր հրահանգները, որոնք կօգտագործվեն «docker build» հրամանով Docker պատկերը ստեղծելու համար:

Նախքան ձեր առաջին Dockerfile-ը ստեղծելը, դուք պետք է ծանոթ լինեք Dockerfile-ի հրահանգին: Ստորև բերված են Dockerfile-ի մի քանի հրահանգներ, որոնք դուք պետք է իմանաք:

ԸՆԹԱՑՔԻՑ

Սահմանեք բազային պատկերը նոր պատկերի համար, որը ցանկանում եք ստեղծել: FROM հրահանգը նախաստորագրելու է նոր build-stage-ը և պետք է տեղակայվի Dockerfile-ի վերևում:

LABEL

Այս հրահանգով դուք կարող եք ավելացնել լրացուցիչ տեղեկություններ ձեր Docker պատկերի մասին, ինչպիսիք են տարբերակը, նկարագրությունը, սպասարկիչը և այլն: LABEL հրահանգը բանալի-արժեք զույգ է, որը թույլ է տալիս ավելացնել բազմաթիվ պիտակներ և մի քանի տող արժեքներ:

ՎԱԶԵԼ

Այս հրահանգը օգտագործվում էր հրամանը կատարելու համար docker պատկերի կառուցման գործընթացում: Դուք կարող եք տեղադրել լրացուցիչ փաթեթներ, որոնք անհրաժեշտ են ձեր Docker պատկերների համար:

ԱՎԵԼԱՑՆԵԼ

ADD հրահանգն օգտագործվում է ֆայլերը, գրացուցակները կամ հեռավոր ֆայլերը URL-ից ձեր Docker պատկերներին պատճենելու համար՝ «src»-ից մինչև «dest» բացարձակ ճանապարհը: Նաև կարող եք կարգավորել ձեր ֆայլի լռելյայն սեփականությունը:

ENV

ENV հրահանգը սահմանում է շրջակա միջավայրի փոփոխական, որը կարող է օգտագործվել կառուցման փուլում և կարող է փոխարինվել նաև շատերի ներսում:

CMD

CMD հրահանգը սահմանում է լռելյայն հրամանը, որը պետք է կատարվի կոնտեյները գործարկելիս: Իսկ Dockerfile-ը պետք է պարունակի միայն մեկ CMD հրահանգ, և եթե կա մի քանի CMD, կգործարկվի վերջին CMD հրահանգը։

ԲԱՑԱՀԱՅՏԵԼ

Այս հրահանգը բացահայտում է կոնտեյների միացքը կոնկրետ ցանցային նավահանգիստների վրա գործարկման ժամանակ: Բացահայտված լռելյայն արձանագրությունը TCP-ն է, բայց դուք կարող եք նշել՝ TCP, թե UDP:

ARG

ARG հրահանգն օգտագործվում է փոփոխական սահմանելու համար, որը օգտագործողը կարող է փոխանցել ներկառուցված ժամանակին: Դուք կարող եք օգտագործել այս հրահանգը docker «build command» կառուցման ժամանակ՝ օգտագործելով «--build-arg variable=value» տարբերակը և կարող է փոխանցվել Dockerfile-ով: Բացի այդ, դուք կարող եք օգտագործել բազմաթիվ ARG Dockerfile-ում:

ENTRYPOINT

ENTRYPOINT հրահանգն օգտագործվում է սահմանելու առաջին և լռելյայն հրամանը, որը կկատարվի, երբ բեռնարկղը գործարկվի: Սահմանեք ձեր դիմումը սկսելու հրամանը ENTRYPOINT հրահանգով:

WORKDIR

WORKDIR հրահանգն օգտագործվում է ձեր Docker պատկերի լռելյայն աշխատանքային գրացուցակը սահմանելու համար: RUN, CMD, ENTRYPOINT և ADD հրահանգները հետևում են WORKDIR հրահանգին: Դուք կարող եք ավելացնել բազմաթիվ WORKDIR հրահանգներ ձեր Dockerfile-ում, և եթե չկա, այն կստեղծվի ավտոմատ կերպով:

ՕԳՏԱԳՈՐԾՈՂ

USER հրահանգը օգտագործվում է պատկերը գործարկելիս լռելյայն օգտագործողին կամ gid-ին սահմանելու համար: RUN-ը, CMD-ը և ENTRYPOINT-ը հետևում են Dockerfile-ում օգտագործողի հրահանգներին:

VOLUME

VOLUME հրահանգի գովազդը, որն օգտագործվում է կոնտեյների և հյուրընկալող մեքենայի միջև մուտքի/կապված գրացուցակը միացնելու համար:

Այժմ, եկեք սկսենք ստեղծել առաջին Dockerfile-ը:

Քայլ 1 - Տեղադրեք Docker-ը Ubuntu 22.04-ում

Նախքան Dockerfile ստեղծելը, մենք կտեղադրենք Docker-ը մեր Ubuntu 22.04 համակարգում, որը լռելյայն հասանելի է Ubuntu-ի պահոցում:

Թարմացրեք բոլոր փաթեթների ցանկը Ubuntu-ի պահոցում և տեղադրեք Docker-ը՝ օգտագործելով ստորև նշված apt հրամանը:

sudo apt update
sudo apt install docker.io

Ամբողջ տեղադրումն ավարտվելուց հետո գործարկեք Docker ծառայությունը և այն ավելացրեք համակարգի բեռնման մեջ:

systemctl start docker
systemctl enable docker

Այժմ ստուգեք Docker ծառայությունը՝ օգտագործելով ստորև նշված հրամանը:

systemctl status docker

Docker ծառայությունը գործում և աշխատում է Ubuntu 22.04-ում:

Հաջորդը, գործարկեք ստորև բերված docker հրամանը, որպեսզի համոզվեք, որ տեղադրումը ճիշտ է:

docker run hello-world

Ստորև ներկայացնում ենք այն արդյունքը, որը դուք կստանաք.

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/

Ինչպես երևում է, դուք ստանում եք Hello World հաղորդագրությունը Docker-ից, և Docker-ի տեղադրումը Ubuntu 22.04-ում հաջողությամբ ավարտվել է:

Քայլ 2 - Ստեղծեք Dockerfile և այլ կոնֆիգուրացիաներ

Այս քայլում մենք ձեզ ցույց կտանք, թե ինչպես կարելի է Dockerfile-ի միջոցով ձեր հավելվածի համար ստեղծել հատուկ Docker պատկեր: Մենք կստեղծենք նոր հարմարեցված Docker պատկեր՝ հիմնված Ubuntu 22.04 պատկերի վրա, PHP-FPM և Nginx ծառայությունների համար, այնուհետև գործարկենք նոր կոնտեյները պարզ phpinfo սկրիպտով:

Նախ, ստեղծեք նոր նախագծի գրացուցակ և ստեղծեք դատարկ Dockerfile:

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

Այժմ խմբագրեք «Dockerfile» սցենարը՝ օգտագործելով ձեր սեփական խմբագրիչը (այս օրինակի համար մենք օգտագործում ենք nano):

nano Dockerfile

Գծի վերևում ավելացրեք բազային պատկերի Ubuntu 22.04 պատկերը՝ օգտագործելով FROM հրահանգը, ինչպես ստորև:

# Download base image ubuntu 22.04
FROM ubuntu:22.04

Այժմ ավելացրեք մաքսային պատկերի մասին մանրամասն տեղեկություններ՝ օգտագործելով LABEL հրահանգը:

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

Մենք բաց կթողնենք հետտեղադրման ցանկացած ինտերակտիվ քայլ՝ apt փաթեթների տեղադրման համար՝ օգտագործելով «DEBIAN_FRONTEND=noninteractive» միջավայրի փոփոխականը:

# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive

Հաջորդը, գործարկեք «apt update» հրամանը, նախքան որևէ փաթեթ տեղադրելը:

# Update Ubuntu Software repository
RUN apt update

Այժմ տեղադրեք Nginx, PHP-FPM և վերահսկիչ փաթեթները: Ամբողջ տեղադրումն ավարտվելուց հետո հեռացրեք բոլոր փաթեթների քեշը` հարմարեցված պատկերի չափը նվազեցնելու համար:

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

Սահմանեք նոր միջավայրի փոփոխական, որը կարող է փոխանցվել հատուկ պատկերին:

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

Այժմ պատճենեք Nginx-ի լռելյայն կոնֆիգուրացիան «nginx_vhost» փոփոխականին, փոխարինեք PHP-ի «cgi.fix_pathinfo=1» կոնֆիգուրացիան «cgi.fix_pathinfo=0»-ով php.ini կազմաձևման ֆայլում, այնուհետև ավելացրեք «daemon off» տարբերակը: լռելյայն «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}

Պատճենեք հատուկ վերահսկիչի կոնֆիգուրացիան «supervisor_conf» փոփոխականում:

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

Ստեղծեք նոր գրացուցակ PHP-FPM sock ֆայլի համար, փոխեք «/var/www/html» վեբ արմատային գրացուցակի և «/run/php» PHP-FPM գրացուցակի սեփականության իրավունքը լռելյայն օգտագործողի «www-data»:

RUN mkdir -p /run/php
RUN chown -R www-data:www-data /var/www/html
RUN 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"]

Այժմ ավելացրեք «start.sh» սկրիպտը և սահմանեք կանխադրված կոնտեյների հրամանը՝ օգտագործելով CMD հրահանգը, ինչպես ստորև:

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

Եվ վերջինը, բացեք կանխադրված HTTP և HTTPS պորտերը կոնտեյների վրա՝ օգտագործելով EXPOSE հրահանգը:

# Expose Port for the Application 
EXPOSE 80 443

Պահպանել և փակել:

Ստորև ներկայացված է Dockerfile-ի ամբողջական սցենարը, որը մենք հենց նոր ստեղծեցինք:

# Download base image ubuntu 22.04
FROM ubuntu:22.04
# LABEL about the custom image
LABEL maintainer="[email "
LABEL version="0.1"
LABEL description="This is a custom Docker Image for PHP-FPM and Nginx."
# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive
# Update Ubuntu Software repository
RUN apt update
RUN apt upgrade -y
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor
RUN rm -rf /var/lib/apt/lists/*
RUN apt clean
    
# Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/8.1/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
RUN chown -R www-data:www-data /var/www/html
RUN 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

Հաջորդը, մենք կստեղծենք լրացուցիչ կոնֆիգուրացիա Nginx-ի, վերահսկիչի և start.sh սցենարի համար:

«Լռակյաց» Nginx վիրտուալ հոսթի կոնֆիգուրացիան կպարունակի PHP-FPM բաժինը: Փաստորեն, դուք կարող եք գործարկել PHP սկրիպտը՝ օգտագործելով Պատվերով պատկերը՝ առանց որևէ փոփոխության:

Ստեղծեք նոր Nginx «կանխադրված» վիրտուալ հոսթի կոնֆիգուրացիա ձեր խմբագրի հետ:

nano 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/php8.1-fpm.sock;
    }
}

Պահպանել և փակել:

Հաջորդը, մենք կստեղծենք «supervisrod.conf» կոնֆիգուրացիան, որը պարունակում է և՛ Nginx, և՛ PHP-FPM ծրագրեր, որոնք ավտոմատ կերպով կաշխատվեն:

Ստեղծեք «supervisrod.conf» ֆայլը՝ օգտագործելով ձեր խմբագրիչը:

nano supervisord.conf

Տեղադրեք հետևյալ կոնֆիգուրացիան դրա մեջ.

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

Պահպանել և փակել:

Այժմ ստեղծեք «start.sh» սկրիպտը՝ օգտագործելով խմբագիր, որը պարունակում է supervisord հրամանը սկսելու համար:

nano start.sh

Տեղադրեք հետևյալ կոնֆիգուրացիան դրա մեջ.

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

Պահպանել և փակել:

Դարձրեք «start.sh» սցենարը գործարկելի:

chmod +x start.sh

Արդյունքում ստեղծվել են մեր հատուկ Docker պատկերի բոլոր կոնֆիգուրացիան, ստորև ներկայացված են մեր ստեղծած բոլոր կոնֆիգուրացիան:

ls -la

Այժմ մենք պատրաստ ենք ստեղծել նոր անհատական պատկեր՝ հիմնված այս կազմաձևերի վրա:

Քայլ 3 - Ստեղծեք նոր մաքսային և գործարկեք նոր կոնտեյներ

Docker մաքսային պատկեր ստեղծելու համար գնացեք նախագծի գրացուցակ «nginx-image» և գործարկեք «docker build» հրամանը, ինչպես ստորև:

docker build -t nginx-image .

Հրամանը կներբեռնի Ubuntu 22.04-ի բազային պատկերը և կստեղծի նոր անհատական պատկեր՝ «nginx-image» անունով:

Ամբողջ գործընթացն ավարտվելուց հետո ստուգեք ձեր համակարգում առկա Docker պատկերի ցանկը՝ օգտագործելով հետևյալ հրամանը:

docker image ls

Ստորև ներկայացնում ենք այն արդյունքը, որը դուք կստանաք.

Ինչպես երևում է, ստեղծվել է նոր մաքսային Docker պատկեր «nginx-image»:

Հաջորդը, մենք կգործարկենք նոր Docker կոնտեյները՝ հիմնված «nginx-image»-ի վրա:

Ձեր տեղական մեքենայի վրա ստեղծեք նոր գրացուցակ՝ «/var/webroot» անունով, որը կօգտագործվի բոլոր վեբ ֆայլերը պահելու համար:

mkdir -p /var/webroot

Այժմ ստեղծեք նոր կոնտեյներ, որը կոչվում է test-container՝ օգտագործելով ստորև բերված docker run հրամանը:

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

Նշում.

• --name test-container nginx-image=Մենք ստեղծում ենք նոր կոնտեյներ՝ «test-container» անունով՝ հիմնված «nginx-image» դոկերի պատկերի վրա:
• -p 8080:80=փորձնական կոնտեյներ, որն աշխատում է 8080 նավահանգստի վրա հյուրընկալող մեքենայի վրա:
• -v /var/webroot:/var/www/html=/var/webroot գրացուցակը հյուրընկալող մեքենայի վրա վերագրեք /var/www/html գրացուցակը կոնտեյների վրա:

Դրանից հետո ստուգեք ձեր համակարգի բոլոր գործող կոնտեյներները՝ օգտագործելով հետևյալ հրամանը.

docker ps

Ստորև ներկայացնում ենք այն արդյունքը, որը դուք կստանաք.

Արդյունքում, նոր բեռնարկղը, որը կոչվում է «test-container», որը հիմնված է «nginx-image» և բացահայտում է 8080 նավահանգիստը, գործարկվում և աշխատում է:

Քայլ 4 - Փորձարկում

Ապահովելու համար, որ բեռնարկղը ճիշտ է աշխատում, մենք կստեղծենք նոր index.html և phpinfo ֆայլ հյուրընկալող մեքենայի'/webroot' արմատական գրացուցակում: Քանի որ «/var/webroot» գրացուցակը տեղադրված է «/var/www/html» կոնտեյների գրացուցակում:

Ստեղծեք index.html ֆայլը '/webroot' գրացուցակի վրա՝ օգտագործելով հետևյալ հրամանը:

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

Այժմ փորձարկեք մուտքը ձեր կոնտեյներ 8080 նավահանգստի վրա curl հրամանով:

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

Արդյունքում դուք կստանաք մեր նոր ստեղծած լռելյայն index.html էջը:

Հաջորդը, «/webroot» գրացուցակում ստեղծեք «info.php» նոր PHP ֆայլ՝ համոզվելու համար, որ PHP-FPM ծառայությունն աշխատում է:

Ստեղծեք «info.php» ֆայլը՝ օգտագործելով հետևյալ հրամանը.

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

Հաջորդը, բացեք ձեր վեբ բրաուզերը և մուտքագրեք ձեր սերվերի IP հասցեն «8080» պորտով, որին հաջորդում է «info.php» ֆայլի ուղին:

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

Այժմ դուք կստանաք phpinfo էջը, ինչպես ստորև:

Ինչպես երևում է, «test-container»-ը հաջողությամբ բեռնել է PHP սկրիպտը:

Եվ արդյունքում, մենք հաջողությամբ ստեղծեցինք նոր հարմարեցված Docker պատկեր և գործարկեցինք նոր կոնտեյները դրա հիման վրա առանց որևէ սխալի: