Cách tạo Docker Images bằng Dockerfile trên Ubuntu 16.04 LTS

[theanh]

Docker là công nghệ ảo hóa cấp hệ điều hành chủ yếu dành cho các nhà phát triển và quản trị viên hệ thống. Docker giúp tạo và triển khai các ứng dụng dễ dàng hơn trong môi trường biệt lập. Dockerfile là một tập lệnh chứa các tập hợp lệnh và hướng dẫn sẽ được tự động thực hiện theo trình tự trong môi trường docker để xây dựng một hình ảnh docker mới.

Trong hướng dẫn này, tôi sẽ chỉ cho bạn cách tạo hình ảnh docker của riêng bạn bằng adockerfile. Tôi sẽ giải thích chi tiết về tập lệnh dockerfile để bạn có thể xây dựng tập lệnh dockerfile của riêng mình.

Điều kiện tiên quyết

• Máy chủ Linux - Tôi sẽ sử dụng Ubuntu 16.04 làm máy chủ lưu trữ và Ubuntu 16.04 làm ảnh cơ sở docker.
• Quyền root.
• Hiểu lệnh Docker

Giới thiệu về lệnh Dockerfile​

Dockerfile là tập lệnh chứa tập hợp các lệnh dockerfile và lệnh hệ điều hành (ví dụ: lệnh Linux). Trước khi tạo dockerfile đầu tiên, bạn nên làm quen với lệnh dockerfile.

Dưới đây là một số lệnh dockerfile bạn phải biết:

TỪ

Hình ảnh cơ sở để xây dựng hình ảnh mới. Lệnh này phải nằm trên đầu tệp docker.

MAINTAINER

Tùy chọn, lệnh này chứa tên của người duy trì hình ảnh.

RUN

Được sử dụng để thực thi lệnh trong quá trình xây dựng hình ảnh docker.

ADD

Sao chép tệp từ máy chủ lưu trữ sang hình ảnh docker mới. Có một tùy chọn để sử dụng URL cho tệp, sau đó docker sẽ tải tệp đó xuống thư mục đích.

ENV

Định nghĩa một biến môi trường.

CMD

Được sử dụng để thực thi các lệnh khi chúng ta xây dựng một container mới từ hình ảnh docker.

ENTRYPOINT

Định nghĩa lệnh mặc định sẽ được thực thi khi container đang chạy.

WORKDIR

Đây là chỉ thị để lệnh CMD được thực thi.

USER

Đặt người dùng hoặc UID cho container được tạo bằng hình ảnh.

VOLUME

Cho phép truy cập/thư mục được liên kết giữa container và máy chủ.

Bây giờ chúng ta hãy bắt đầu tạo dockerfile đầu tiên của mình.

Bước 1 - Cài đặt Docker​

Đăng nhập vào máy chủ của bạn và cập nhật kho lưu trữ phần mềm.

ssh [emailprotected]
apt-get update

Cài đặt docker.io bằng lệnh apt này:

apt-get install docker.io

Khi quá trình cài đặt hoàn tất, hãy khởi động dịch vụ docker và cho phép dịch vụ này khởi động khi khởi động:

systemctl start docker
systemctl enable docker

Docker đã được cài đặt và đang chạy trên hệ thống.

Bước 2 - Tạo Dockerfile​

Trong bước này, chúng ta sẽ tạo một thư mục mới cho dockerfile và xác định những gì chúng ta muốn làm với dockerfile đó.

Tạo một thư mục mới và một dockerfile mới và trống bên trong thư mục đó.

mkdir ~/myimages 
cd myimages/
touch Dockerfile

Tiếp theo, hãy xác định những gì chúng ta muốn làm với hình ảnh tùy chỉnh mới của mình. Trong hướng dẫn này, tôi sẽ cài đặt Nginx và PHP-FPM 7 bằng hình ảnh docker Ubuntu 16.04. Ngoài ra, chúng ta cần Supervisord, vì vậy chúng ta có thể khởi động Nginx và PHP-FPM 7 trong một lệnh.

Chỉnh sửa 'Dockerfile' bằng vim:

nanoDockerfile

Ở đầu tệp, thêm một dòng có hình ảnh cơ sở (Ubuntu 16.04) mà chúng ta muốn sử dụng.

#Tải xuống hình ảnh cơ sở ubuntu 16.04
TỪ ubuntu:16.04

Cập nhật kho lưu trữ phần mềm Ubuntu bên trong dockerfile bằng lệnh 'RUN'.

# Cập nhật kho lưu trữ phần mềm Ubuntu
CHẠY apt-get update

Sau đó, cài đặt các ứng dụng mà chúng ta cần cho hình ảnh tùy chỉnh. Cài đặt Nginx, PHP-FPM và Supervisord từ kho lưu trữ Ubuntu bằng apt. Thêm lệnh RUN để cài đặt Nginx và PHP-FPM.

# Cài đặt nginx, php-fpm và supervisord từ kho lưu trữ ubuntu
RUN apt-get install -y nginx php7.0-fpm supervisor && \
 rm -rf /var/lib/apt/lists/*

Ở giai đoạn này, tất cả các ứng dụng đã được cài đặt và chúng ta cần cấu hình chúng. Chúng ta sẽ cấu hình Nginx để xử lý các ứng dụng PHP bằng cách chỉnh sửa cấu hình máy chủ ảo mặc định. Chúng ta có thể thay thế tệp cấu hình mới của mình hoặc có thể chỉnh sửa tệp cấu hình hiện có bằng lệnh 'sed'.

Trong hướng dẫn này, chúng ta sẽ thay thế cấu hình máy chủ ảo mặc định bằng cấu hình mới bằng lệnh dockerfile 'COPY'.

#Định nghĩa biến ENV
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

# Bật php-fpm trên cấu hình máy chủ ảo nginx
SAO CHÉP mặc định ${nginx_vhost}
CHẠY sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
 echo "\ndaemon off;" >> ${nginx_conf}

Tiếp theo, cấu hình Supervisord cho Nginx và PHP-FPM. Chúng tôi sẽ thay thế cấu hình Supervisord mặc định bằng cấu hình mới bằng lệnh 'COPY'.

#Sao chép cấu hình Supervisor
SAO CHÉP Supervisord.conf ${supervisor_conf}

Bây giờ hãy tạo một thư mục mới cho tệp sock php-fpm và thay đổi chủ sở hữu của thư mục /var/www/html và thư mục PHP thành www-data.

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

Tiếp theo, hãy định nghĩa volume để chúng ta có thể gắn các thư mục được liệt kê bên dưới vào máy chủ.

# Cấu hình volume
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]

Cuối cùng, hãy thiết lập lệnh container mặc định 'CMD' và mở cổng cho HTTP và HTTPS. Chúng ta sẽ tạo một tệp start.sh mới cho lệnh 'CMD' mặc định khi container đang khởi động. Tệp chứa lệnh 'supervisord' và chúng ta sẽ sao chép tệp vào ảnh mới bằng lệnh dockerfile 'COPY'.

# Cấu hình Dịch vụ và Cổng
COPY start.sh /start.sh
CMD ["./start.sh"]

EXPOSE 80 443

Lưu tệp và thoát.

Sau đây là Dockerfile hoàn chỉnh trong một phần:

#Tải xuống ảnh cơ sở ubuntu 16.04
TỪ ubuntu:16.04
 
# Cập nhật kho lưu trữ phần mềm
CHẠY apt-get update
 
# Cài đặt nginx, php-fpm và supervisord từ kho lưu trữ ubuntu
CHẠY apt-get install -y nginx php7.0-fpm supervisor && \
 rm -rf /var/lib/apt/lists/*
 
#Định nghĩa biến ENV
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
 
# Bật php-fpm trên cấu hình máy chủ ảo nginx
SAO CHÉP mặc định ${nginx_vhost}
CHẠY sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
 echo "\ndaemon off;" >> ${nginx_conf}
 
#Sao chép cấu hình giám sát
SAO CHÉP supervisord.conf ${supervisor_conf}
 
CHẠY mkdir -p /run/php && \
 chown -R www-data:www-data /var/www/html && \
 chown -R www-data:www-data /run/php
 
# Cấu hình ổ đĩa
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
 
# Cấu hình dịch vụ và cổng
COPY start.sh /start.sh
CMD ["./start.sh"]
 
EXPOSE 80 443

Bây giờ bên trong thư mục 'Dockerfile' của chúng ta, hãy tạo một tệp cấu hình mới cho máy chủ ảo có tên là 'default', một tệp cấu hình giám sát 'supervisord.conf' và một tập lệnh cấu hình dịch vụ 'start.sh'.

vim default

Dán cấu hình máy chủ ảo mặc định bên dưới:

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;
 }
 
 # từ chối quyền truy cập vào các tệp .htaccess, nếu gốc tài liệu của Apache
 # đồng ý với gốc tài liệu của nginx
 #
 #location ~ /\.ht {
 # deny all;
 #}
}

Tệp cấu hình Supervisord:

vim supervisord.conf

Dán cấu hình bên dưới:

[unix_http_server]
file=/dev/shm/supervisor.sock ; (đường dẫn đến tệp socket)
 
[supervisord]
logfile=/var/log/supervisord.log ; (tệp nhật ký chính; mặc định là $CWD/supervisord.log)
logfile_maxbytes=50MB ; (số byte tối đa của tệp nhật ký chính b4 luân chuyển; mặc định là 50MB)
logfile_backups=10 ; (số lượng bản sao lưu luân chuyển tệp nhật ký chính; mặc định là 10)
loglevel=info ; (mức nhật ký; thông tin mặc định; những mục khác: gỡ lỗi, cảnh báo, theo dõi)
pidfile=/tmp/supervisord.pid ; (tệp pid của giám sát viên; mặc định là supervisord.pid)
nodaemon=false ; (bắt đầu ở chế độ nền trước nếu đúng; mặc định là sai)
minfds=1024 ; (tối thiểu là avail startup file descriptors; mặc định là 1024)
minprocs=200 ; (tối thiểu là avail process descriptors; mặc định là 200)
user=root ;
 
; phần bên dưới phải nằm trong tệp cấu hình để RPC
; (supervisorctl/giao diện web) hoạt động, có thể thêm các giao diện bổ sung
; bằng cách định nghĩa chúng trong các rpcinterface riêng biệt: các phần
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
 
[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; sử dụng URL unix:// cho ổ cắm unix
 
; Phần [include] chỉ có thể chứa cài đặt "tệp". Cài đặt
; này có thể liệt kê nhiều tệp (phân tách bằng khoảng trắng hoặc
; dòng mới). Nó cũng có thể chứa các ký tự đại diện. Tên tệp được
; diễn giải là tương đối với tệp này. Các tệp được bao gồm *không thể*
; bao gồm các tệp riêng lẻ.
 
[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

Tệp Start.sh.

vim start.sh

Dán cấu hình bên dưới:

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

Lưu và thoát

Tạo start.sh có thể thực thi bằng lệnh chmod:

chmod +x start.sh

Lưu tệp và thoát.

Bước 3 - Xây dựng Docker Image mới và Tạo Container mới dựa trên Docker Image đó​

Dockerfile và tất cả các tệp cấu hình cần thiết đã được tạo, bây giờ chúng ta có thể xây dựng một Docker Image mới dựa trên Ubuntu 16.04 và Dockerfile của chúng ta bằng lệnh docker bên dưới:

docker build -t nginx_image .

Khi lệnh hoàn tất thành công, chúng ta có thể kiểm tra image mới 'nginx_image' bằng lệnh docker bên dưới:

docker images

Sau đó, chúng ta có thể thử tạo một container mới dựa trên nginx_images. Và trước khi tạo container mới, chúng ta có thể tạo thư mục mới trên máy chủ cho dữ liệu webroot.

mkdir -p /webroot

Bây giờ hãy chạy container mới bằng lệnh bên dưới:

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

Sau đó, chúng ta có thể kiểm tra xem container mới có tên hakase dựa trên 'nginx_image' có đang chạy hay không:

docker ps

Lưu ý:

• --name hakase nginx_image = Chúng ta tạo một container mới có tên 'hakase', dựa trên docker image 'nginx_images'.
• -p 80:80 = hakase container đang chạy trên cổng 80 trên máy chủ.
• -v /webroot:/var/www/html = thư mục /webroot trên máy chủ, hãy viết lại thư mục /var/www/html trên vùng chứa.

Vùng chứa mới dựa trên nginx_image đang chạy mà không có lỗi.

Bước 4 - Kiểm tra Nginx và PHP-FPM trong Vùng chứa​

Thử tạo tệp index.html mới trong thư mục /webroot bằng lệnh echo:

echo '[HEADING=1]Nginx và PHP-FPM 7 bên trong Vùng chứa Docker[/HEADING]' > /webroot/index.html

Kiểm tra bằng lệnh curl bằng cách truy cập địa chỉ IP của máy chủ.

curl 192.168.1.250
curl -I 192.168.1.250

Chúng ta sẽ thấy kết quả bên dưới.



Tiếp theo, kiểm tra xem PHP-FPM 7.0 có đang chạy không bằng cách tạo một tệp phpinfo mới trong thư mục /webroot trên máy chủ.

echo '' > /webroot/info.php

Mở trình duyệt web và nhập địa chỉ IP của máy chủ:

http://192.168.1.248/info.php

Bây giờ bạn có thể thấy đầu ra của tệp phpinfo.



hình ảnh docker mới 'nginx_image' đã được tạo thành công, bây giờ chúng ta có thể tạo thêm nhiều container dựa trên hình ảnh đó.

Tham khảo​

• https://docs.docker.com/engine/reference/builder/https://docs.docker.com/engine/reference/builder/?utm_source=diendancongnghe.com
• https://github.com/ngineered/nginx-php-fpmhttps://github.com/ngineered/nginx-php-fpm?utm_source=diendancongnghe.com
• https://github.com/docker-library/wordpress/