iFrame là gì? iFrame ( inline Frame) là một trang html được nhúng vào một trang html khác trên website. Thẻ iFrame thường được sử dụng để chèn nội dùng từ source khác, giống như các link ảnh, quảng cáo, .. Vì thế mà hacker có thể lợi dụng để insert mã iFrame với source bên ngoài và thực hiện ý đồ mong muốn.

Phương thức mà hacker khai thác khi người dùng click vào link được nhúng ở trên còn gọi là Clickjacking

Để hạn chế, hoặc chặn việc sử dụng iframe, chúng ta có thể sử dụng tham số “X-Frame-Options” HTTP response header trong cấu hình web server

Với X-Frame-Options, chúng ta có 3 giá trị có thể được áp dụng

X-Frame-Options: deny
X-Frame-Options: sameorigin
X-Frame-Options: allow-from uri

Nội dung các giá trị ở trên:

  • deny: Chặn toàn bộ việc đọc dữ liệu từ các trang có gắn frame, iframe

  • sameorigin: Chỉ cho phép đọc dữ liệu từ frame, iframe trong cùng domain

  • allow-from uri: Trang có thể thể đọc dữ liệu từ uri được định nghĩa (ví dụ allow-from uri: http://example.com)

Thiết lập X-Frame-Options trên một số web server phổ biến hiện nay

– Nginx

Tham số X-Frame-Options có thể them vào block http, server hoặc location trong tệp tin cấu hình nginx. Trong phạm vi ứng dụng đến toàn web server, tôi sẽ cấu hình vào block http{ } trong tệp tin cấu hình chính của nginx

add_header X-Frame-Options sameorigin;

Kiểm tra thông tin response header

nginx-frame-options

– Apache

Thêm đoạn sau vào tệp tin cấu hình chính Apache (ví dụ httpd.conf)

Header always set X-Frame-Options "sameorigin"

Kiểm tra thông tin response header

apache-x-frame-options

 

 

Advertisements

Ở phần trước chúng ta thiết lập cấu hình replica set MongoDB.  Trong phần này, chúng ta sẽ cấu hình Laravel website kết nối cơ sở dữ liệu MongoDB trong trường hợp replication.

Trước khi vào phần cấu hình chúng ta làm rõ một số thông tin tùy chọn read, write trong MongoDB.

Trong MongoDB replication thì chỉ có 01 máy chủ ( là primary) được quyền write, còn tùy chọn read thì Mongodb có 05 chế độ :

  • primary: Là chế độ read mặc định, mà tất cả thao tác read đến primary
  • primaryPreferred: Tất cả yêu cầu read đều từ primary, nhưng primary unvailable thì nó sẽ chuyển hướng read sang secondary
  • secondary: Tất cả yêu cầu read đến secondary
  • secondaryPreferred: Tất cả yêu cầu read đều từ secondary, nhưng secondary unvailable thì nó sẽ chuyển hướng read sang primary
  • nearest: Yêu cầu read từ replica set members mà có least network latency (độ trễ thấp nhất, không phân biệt primary và secondary)

Reference read: https://docs.mongodb.com/manual/reference/read-preference/

Cấu hình kết nối database

web server with mongodb replication

Trên web server, chúng ta thực hiện cấu hình Laravel kết nối cơ sở dữ liệu mongodb với một số thông tin sau:

  • Mongodb replication mà chúng ta thiết lập có ID là “mongo_rep”

  • Tùy thuộc vào nhu cầu sử dụng để chúng ta thiết lập tùy chọn read cho phù hợp. Ví dụ, chúng ta sẽ thiết lập ưu tiên read từ secondary, khi secondary mà unavailable thì sẽ chuyển hướng read sang primary. Trong trường hợp này, chúng ta sẽ vào giá trị là “secondaryPreferred”

  • database name: example

  • user/pass: keepwalking/P@ssw0rd

Thực hiện cấu hình cho website example.local, với thư mục chứa source code “/var/www/example“, ta thực hiện như sau:

  • Sửa nội dung sau trong tệp tin database.php
vim /var/www/example/config/database.php
        'mongodb' => array(
            'driver'   => 'mongodb',
            'host'     => ['mongo01', 'mongo02'],
            'port'     => env('DB_PORT', 27017),
            'database' => env('DB_DATABASE'),
            'username' => env('DB_USERNAME'),
            'password' => env('DB_PASSWORD'),
            'options'  => array(
                'replicaSet' => 'mongo_rep',
                'readPreference' => 'secondaryPreferred',
                )
        ),
  • Chỉnh sửa tệp tin .env và thêm thông tin database, user và pass
DB_CONNECTION=mongodb
DB_HOST=
DB_PORT=27017
DB_DATABASE=example
DB_USERNAME=keepwalking
DB_PASSWORD=P@ssw0rd

Thực hiện stop/start từng mongodb server để kiểm tra quá trình read/write database

Nagios gửi cảnh báo qua Telegram

Posted: Tháng Mười 4, 2018 in Monitor
Thẻ:,

Chúng ta vẫn thường sử dụng các phương pháp gửi cảnh báo truyền thống như: Email, SMS. Hiện nay, với sự phát triển của OTT, việc sử dụng bot của nó để gửi nhận cảnh báo rất phổ biến. Hôm nay, mình note lại hướng dẫn gửi cảnh báo từ Nagios qua Telegram

Các bước thực hiện như sau:

1. Tạo Telegram Bot

Step1: Sử dụng tài khoản Telegram, sau đó tìm @BotFather

telegram01.png

Step2: Thực hiện tạo bot

  • Gõ lệnh /newbot

  • Định nghĩa tên cho boot, ví dụ: Nagios-notify

  • Định nghĩa username cho bot (kết thúc username là bot, hoặc _bot), ví dụ: keepwalkingbot

Sau khi kết thúc việc tạo username cho bot, thì @BotFather sẽ thông báo việc tạo thành công và gửi token cho việc truy cập HTTP API. Lưu Token và username

telegram02.png

  • Tìm và add bot @keepwalkingbot vào contact của người sẽ gửi notify (ví dụ tôi dùng tài khoản telegram của tôi là @keepwalking86 để nhận message từ @keepwalkingbot)

  • Xác định giá trị chat_id

Đầu tiên, người dùng mà sẽ cần gửi message /my_id đến bot (@keepwalkingbot)

Sau đó vào đường dẫn URL sau: “https://api.telegram.org/bot_ten_token/getUpdates

Thay với giá trị token mà chúng ta đã có ở trên: “666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw”

Chúng ta sẽ truy cập URL như sau:

https://api.telegram.org/bot666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw/getUpdates

Chúng ta nhận giá trị HTTP API như sau:

{"ok":true,"result":[{"update_id":670165881,
"message":{"message_id":3,"from":{"id":688042548,"is_bot":false,"first_name":"Keep","last_name":"Walking","username":"Keepwalking86","language_code":"en-US"},"chat":{"id":688042548,"first_name":"Keep","last_name":"Walking","username":"Keepwalking86","type":"private"},"date":1538623182,"text":"/start","entities":[{"offset":0,"length":6,"type":"bot_command"}]}},{"update_id":670165882,

Như vậy giá trị id của user @keepwalking86 là: “id”:688042548

Chúng ta sẽ sử dụng giá trị ID “688042548” cho việc gửi message từ bot

2 Download Telegram-notify php script

  • Download tại: telegram-notify

  • Giải nén vào thư mục /usr/local/nagios/sbin

  • Phân quyền thư mục telegram-notify

chown nagios:nagios -R /usr/local/nagios/sbin/telegram-notify/log/ 
chmod 775 -R /usr/local/nagios/sbin/telegram-notify/log/ 
chown root:root /usr/local/nagios/sbin/telegram-notify/log/.htaccess
  • Kiểm tra gửi message bằng command

Sử command bằng php script, thực hiện test như sau:

/usr/bin/php /usr/local/nagios/sbin/telegram-notify/telegram-bot.php "688042548" "666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw" 1 "Notify: NOTIFICATIONTYPE 0XzXZ0 Host: HOSTNAME 0XzXZ0 Service: SERVICEDESC 0XzXZ0 Date: SHORTDATETIME 0XzXZ0 Info: SERVICEOUTPUT"

Trong đó:

688042548: là Telegram ID của tôi (@keepwalking86) là người sẽ nhận message

666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw: Là token key của @keepwalkingbot nhận được ở trên

Kết quả thực hiện test:

telegram04

 

3 Cấu hình Nagios server

Step1: Định nghĩa command sẽ sử dụng

Thêm nội dung sau vào tệp “/usr/local/nagios/etc/objects/command.cfg”

# 'notify-service-telegram' command definition
define command{
command_name notify-service-telegram
command_line /usr/bin/php /usr/local/nagios/sbin/telegram-notify/telegram-bot.php "688042548" "666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw" 1 "Notify: $NOTIFICATIONTYPE$ 0XzXZ0 Host: $HOSTNAME$ 0XzXZ0 Service: $SERVICEDESC$ 0XzXZ0 Date: $SHORTDATETIME$ 0XzXZ0 Info: $SERVICEOUTPUT$"
}
# 'notify-host-telegram' command definition
define command{
command_name notify-host-telegram
command_line /usr/bin/php /usr/local/nagios/sbin/telegram-notify/telegram-bot.php "688042548" "666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw" 1 "Notify: $NOTIFICATIONTYPE$ 0XzXZ0 Host: $HOSTNAME$ 0XzXZ0 Date: $SHORTDATETIME$ 0XzXZ0 Info: $HOSTOUTPUT$"
}

Một số giá trị cần biết:

Telegram-bot: @keepwalkingbot

0XzXZ0 – line break character

688042558: Telegram ID người nhận message; Nếu có nhiều Telegram users nhận message, chúng ta thay giá ID với biến “”$_CONTACTTELEGRAM$” . Chúng ta sẽ khai báo giá trị “$_CONTACTTELEGRAM$” gồm nhiều telegram id.

666928423:AAG497LAbO094UbemLZXZFuFBlZsuJaG8vw: Token key của bot

Step2: Định nghĩa contact nhận message

Thêm nội dung sau vào tệp “/usr/local/nagios/etc/objects/contact.cg

#Define contact for only Telegram
define contact{
 contact_name telegram ; Short name of user
 use generic-contact ; Inherit default values from generic-contact template (defined above)
 alias telegram Admin ; Full name of user
 _telegram 688042548 #Ở đây ta có thêm nhiều contact nhận message
 service_notifications_enabled 1
 host_notifications_enabled 1
 host_notification_commands notify-host-telegram
 service_notification_commands notify-service-telegram
 service_notification_period 24x7
 host_notification_period 24x7
 service_notification_options c,w,r
 host_notification_options d,u,r
 }
define contactgroup{
 contactgroup_name sysadmins
 alias System Admins
 members dungnv,telegram
 }

Thông tin ở cấu hình trên, ta định nghĩa contact_name là telegram, với telegram id là 688042548, và add contact_name telegram vào group “sysadmins”

Step3: Cấu hình Services, Hosts

Cấu hình các services hoặc hosts mà khi gặp warning hoặc critical thì Telegram bot sẽ gửi message cảnh báo cho người dùng Telegram.

Ví dụ thiết lập nhận message cho host vmware esxi, thêm nội dung sau vào tệp cấu hình esxi.cfg trên Nagios server

define host{
use linux-server
host_name ESXi05_192.168.10.205
alias ESXi05_192.168.10.205
address 192.168.10.205
contact_groups sysadmins
}

Step4: Restart nagios và kiểm tra nhận message

Khởi động lại service nagios: service nagios restart

Kiểm tra message từ telegram

telegram05

Chúng ta thấy, tài khoản Telegram đã nhận được cảnh báo từ @keepwalkingbot gửi đến

 

Docker compose

Posted: Tháng Chín 24, 2018 in Container, Docker
Thẻ:, ,

Trong phần trước “Cơ bản Docker“, chúng ta sử dụng Dockerfile để build image và sau đó chạy từng container. Phần này, chúng ta sử dụng Docker Compose.

Docker Compse là công cụ dùng để định nghĩa và chạy nhiều containers cùng lúc. Ví dụ để chạy stack LEMP, thay vì chạy từng container như nginx, mysql và php, chúng ta sử dụng Compose để tạo và chạy toàn bộ stack cùng lúc.

1. Cài đặt Docker-compose

Truy cập: https://github.com/docker/compose/releases để download version docker-compose phù hợp

curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

2. Tham số dùng trong docker-compose

Với Docker Compose, chúng ta sử dụng một tệp tin YAML để cấu hình ứng dụng. Một số tham số trong tệp tin cấu hình thường được sử dụng:

  • version: chỉ ra phiên bản docker-composer sẽ sử dụng. Tùy thuộc Docker version mà khai báo version phù hợp trong tệp tin docker compose.

  • services: Định nghĩa các service sẽ chạy. Mỗi service gồm thông tin cấu hình mà sẽ được áp dụng cho mỗi container.

  • build: sử dụng để build image từ Dockerfile

  • image: Nếu không sử dụng tham số “build” thì sử dụng tham số image để build image nếu image từ local hoặc nếu chưa có sẵn ở local thì nó sẽ pull về.

  • volumes: Mount thư mục giữa host machine và container

  • ports: nat port từ host machine vào container

  • environment: sử dụng các môi trường được định nghĩa trong image

  • depends_on: được dùng để chỉ ra sự phụ thuộc service này vào service khác

Chúng ta có thể tham khảo thêm các tham số dùng cho tệp tin docker compose tại: https://docs.docker.com/compose/compose-file/

3. Tạo project

Quá trình tạo và chạy một project với Docker composer qua 4 bước:

  • Setup môi trường cho project: như thư mục chứa project, thư mục chứa sourcecode, database, ..

  • Tạo các tệp Dockerfile để build Docker images

  • Định nghĩa các services dùng để chạy App trong tệp tin docker compose

  • Build và chạy App với Docker Compose

3.1 wordpress project

Trong phần hướng dẫn  wordpres project trong phần doc trên trang chủ Docker, có hướng chúng ta cách tạo docker compose cho wordpress project, sử dụng 2 images có sẵn là: mysql:5.7 và wordpress.

Để hiểu rõ hơn quá trình start mỗi service và tạo các containers, chúng ta tự cấu hình và build lại các images và tạo các Dockerfile có cấu trúc rõ ràng.

Các bước tạo wordpress project như sau:

– Tạo thư mục chứa project

mkdir ~/wordpress
cd ~/wordpress
mkdir -p {wordpress,mariadb} #Thư mục chứa tệp tin cấu hình Dockerfile
mkdir -p {web_app,db_data} #Thư mục chứa source code và database

– Tạo các Dockerfile

Chúng ta sẽ tạo 02 tệp Dockerfile dùng cho build 02 images từ base image: mariadb và wordpress.

cd ~/wordpress/wordpress
cat >Dockerfile <<EOF
FROM wordpress
CMD ["apache2-foreground"]
EXPOSE 80
EOF
cd ~/wordpress/mariadb
cat >Dockerfile <<EOF
FROM mariadb
CMD ["mysqld"]
EXPOSE 3306
EOF

– Tạo tệp tin docker-compose.yml

cd ~/wordpress
cat >docker-compose.yml << EOF
version: "3"
services:
    webapp:
        depends_on:
          - db
        build: ./wordpress
        ports:
          - 8080:80
        restart: always
        volumes:
          - ./web_code:/var/www/html
        environment:
          WORDPRESS_DB_NAME: wordpress
          WORDPRESS_DB_HOST: db:3306
          WORDPRESS_DB_USER: wordpress
          WORDPRESS_DB_PASSWORD: P@ssw0rd
          WORDPRESS_TABLE_PREFIX: wp_
    db:
        build: ./mysql
        volumes:
          - ./db_data:/var/lib/mysql
        restart: always
        environment:
          MYSQL_ROOT_PASSWORD: P@ssw0rd
          MYSQL_DATABASE: wordpress
          MYSQL_USER: wordpress
          MYSQL_PASSWORD: P@ssw0rd   
EOF

Tệp cấu hình docker-compose.yml ở trên gồm 02 services: db và webapp

Một số tham số chính trong tệp cấu hình:

  • depends_on:  xác định webapp service sẽ phụ thuộc vào db service. Tham số “depends_on” xác định thứ tự ưu tiên service sẽ bắt đầu trước. Trong tệp tin docker compose ở trên thì db service sẽ start trước , tiếp mới đến webapp service. Để thấy rõ quá trình này chúng ta có thể xem quá trình chạy docker compose ở hình dưới

–  build: để build images từ thư mục chứa Dockerfile thành container.  Chúng ta chỉ nat port 8080 từ host vào 80 của container.

  • volumes: Để mount sourcecode và database giữa docker host và container

  • environment: Gọi các biến mà được định nghĩa ở các images gốc mariadb và wordpress

– Khởi tạo và chạy

docker-compose up -d

Quá trình chạy docker compose như sau:

build by docker-compose

Liệt kê containers vừa build và up, sử dụng “docker ps

docker ps

  • Kiểm tra ứng dụng wordpress

Sử dụng web browser và kiểm tra ứng dụng wordpress đã chạy chưa

http://your-ip-address:8080/

Nếu wordpress chạy thì nó sẽ redirect sang: http://your-ip-address:8080/wp-admin/install.php để bắt đầu quá trình tạo cấu hình wordpress như hình dưới

wordpress

3.2 Nodejs MongoDB

Chúng ta tiếp tục một project nữa, sử dụng docker compose tạo các container để chạy app sử dụng nodejs và cơ sở dữ liệu mongodb

– Step1: Tạo thư mục chứa project

mkdir nodejs-mongodb/{app,database,mongo,node}

Thư mục app,database dùng chứa dữ liệu sourcecode,database. Copy source code vào thư mục “nodejs-mongodb/app”

Thư mục mongo,node chứa tệp tin Dockerfile dùng để build images nodejs và mongodb

–  Step2: Tạo các tệp tin Dockerfile

Tạo tệp tin Dockerfile để build image cho nodejs

cd nodejs-mongodb/node
cat >Dockerfile <<EOF
FROM node:latest
WORKDIR /home/node/app
#update latest npm to fix vulnerabilities
RUN npm i npm@latest -g
RUN npm install -g express-generator
COPY app/package.json /home/node
RUN cd /home/node && npm install
CMD ["npm", "start"]
EXPOSE 3000
EOF

Tạo tệp Dockerfile để build image cho mongodb

cd nodejs-mongodb/mongo
cat >Dockerfile <<EOF
FROM mongo:3.6
WORKDIR /data/db
CMD ["mongod"]
EXPOSE 27017
EOF

– Step3: Tạo tệp tin docker-compose.yml

Bây giờ chúng ta sẽ tạo tệp tin docker-compose.yml để build và run các containers

cd nodejs-mongodb
cat >docker-compose.yml <<EOF
version: "3"
services:
  web:
    depends_on:
      - db
    build: ./node
    restart: always
    ports:
      - 3030:3000
    volumes:
      - ./app:/home/node/app
    hostname: node01
    domainname: example.local
  db:
    build: ./mongo
    restart: always
    ports:
      - 27017:27017
    volumes:
      - ./database:/data/db
    hostname: mongo01
    domainname: example.local
EOF

Tệp docker-compose.yml ở trên gồm 02 service: web và db

service web gồm một số directive sau:

  • depends_on: kết nối và sử dụng database là service “db”

  • build: chúng ta sẽ build một image mới, với đường dẫn chứa Dockerfile trong ./node và sử dụng image này để tạo nodejs container

  • ports: Chúng ta NAT port 3030 vào trong port 3000 của nodejs

  • volumes: dùng mount sourcecode giữa docker host và container

service db: chúng ta sẽ build một image mới, với đường dẫn chứa Dockerfile trong ./mongo và sử dụng image này để tạo mongodb container

Note: để app nodejs có thể kết nối đến mongodb container thì chúng ta sẽ kết nối thông qua tên của service, trong trường hợp này là “db”. Ví dụ:

var db = monk('db:27017/nodejs');

– Step4: Khởi tạo và chạy

docker-compose up -d

Xem thêm về project tại: https://github.com/keepwalking86/nodejs-mongodb

3.3 Chat App Project

Ở project này chúng ta sẽ sử dụng docker compose để build và run 03 containers: node, mongodb và redis

Ở project này chúng ta đã có web_app với dữ liệu có sẵn. Vì thế trong cấu hình chúng ta sẽ mount thư mục chứa web_app vào container

Thông tin sử dụng docker compose để tạo “Chat App” này, mình có đẩy lên github

https://github.com/keepwalking86/chat_app

Cơ bản về Docker

Posted: Tháng Tám 20, 2018 in Container, Docker
Thẻ:,

Công ty chỉ có 02 người dùng Docker =)) ( Mình và 1 thằng Dev). Thỉnh thoáng dùng đến, nên thỉnh thoáng lại quên à :D. Giờ đành viết mấy bài note tìm lại kiến thức cho dễ. Các bài viết về Docker chủ yếu là ở mức basic, làm nền tảng cho các CICD sau này

1. Một số khái niệm

Trước khi dùng thì biết nó là cái gì tí nhỉ?

Docker là platform mà sử dụng các container để phát triển, triển khai và chạy các ứng dụng một cách nhanh chóng mà không làm tác động tới môi trường hiện tại của máy.

Container sử dụng để triển khai các ứng dụng thì được gọi là containerization.

Container được tạo thành khi chạy một image. Image  gồm các thành phần cần thiết để chạy một ứng dụng – code, runtime, các biến, các tệp cấu hình

docker

2. Cài đặt Docker

Cài đặt trên CentOS/Ubuntu, thực hiện đơn giản với sh script

curl -sSL https://get.docker.com/ | sudo sh

Tạo tài khoản người dùng để sử dụng docker

sudo usermod -aG docker `whoami`

Start docker và cho phép chạy cùng OS

systemctl start docker.service
systemctl enable docker.service

Kiểm tra phiên bản Docker

docker version
Client:
Version: 18.06.0-ce
API version: 1.38
Go version: go1.10.3
Git commit: 0ffa825
Built: Wed Jul 18 19:11:02 2018
OS/Arch: linux/amd64
Experimental: false

Server:
Engine:
Version: 18.06.0-ce
API version: 1.38 (minimum version 1.12)
Go version: go1.10.3
Git commit: 0ffa825
Built: Wed Jul 18 19:09:05 2018
OS/Arch: linux/amd64
Experimental: false

3. Các thao tác với image

  • Tải image từ docker hub về máy
$docker pull <image_name>
  • Liệt kê các images trên local
$docker images
  • Xóa một image
$docker rmi <image_name>
$docker rmi <image_id>
  • Xóa all images
$docker rmi -f $(docker images -qa)`
  • Tìm images trong docker hub
$docker search <image_name>
  • Xem thông tin chi tiết về image
$docker image inspect <image_name>
  • Xem lịch sử các commit của image
$docker history <image_name>
  • Đánh lại ​tag của một image
$docker tag <image_name:version> <image_name:new_version>
$docker tag centos:lastest centos:7
  • Upload image
    Sử dụng tạo image mới ở local host
$docker tag <image_name:version> <ten_repo>/<image_name:new_version>
$docker tag nginx keepwalking/nginx:1.13

-Push Images To Docker Hub (giả sử push image keepwalking/docker-leamp)

  • Tạo tài khoản trên docker hub : https://hub.docker.com
  • Tạo repository (Nếu không tạo, thì khi push nó sẽ tự tạo)

vd: https://hub.docker.com/r/keepwalking/docker-leamp/

#Login
docker login
#Show images
docker images
#Tag keepwalking/docker-leamp image
docker tag keepwalking/docker-leamp keepwalking/docker-leamp
#push image
docker push keepwalking/docker-leamp

4. Các thao tác với container

– Tạo một container
Contain được tạo từ image. Nếu image chưa có sẵn trên host thì docker sẽ pull image về từ docker hub

docker run <image_name>
docker run centos

– Thao tác với một container với chế độ tương tác
Sử dụng tùy chọn ‘-it‘ (-i: interactive, -t: tty)

docker run -it <image_name> /bin/bash

– Chạy container trong chế độ background như một daemon
Thông thường, khi tạo một container với các tùy chọn trước thì sau khi tạo xong hoặc thoát container thì ngay lập tức container đó sẽ dừng hoạt động. Trong một số trường hợp ta sẽ cần các container chạy ngầm, trong trường hợp này ta sử dụng tùy chọn ‘-d’

docker run -d <image_name>
docker run -d centos

– Thao tác với một container đã tồn tại
Khi đã một container đang ở trạng thái UP (sử dụng lệnh ‘docker ps‘ để kiểm tra) thì ta có thể truy cập vào để thao tác, chứ không cần tạo mới container và chạy lại từ đầu
Để truy cập vào trong container đã UP ta dùng lệnh:

docker exec -it <container_id> /bin/bash
docker exec -it eb6a2df60f20 /bin/bash

– Chỉ định lượng RAM và CPU cho một container
Một container có thể chỉ định lượng RAM và CPU khi tạo

docker run -d -p 4000:80 --name webserver --memory 400m --cpus 0.5 httpd

– Đặt tên cho một container khi khởi tạo
Thay vì để sinh tự động container name khi khởi tạo, chúng ta tự đặt container name với tùy chọn tham số –name

docker run --name <new_container> <image_name>
docker run --name lemp_centos centos

– Nat port từ host machine vào container (sử dụng -p)
Để NAT port vào container ta sử dụng tham số -p

docker run -p host_port:container_port container_id
$docker run -d -p 8080:80 keepwalking/nginx

– Cũng sử dụng tham số -p để NAT nhiều ports

docker run -p 8080:80 3307:3306 keepwalking/lamp

– Liệt kê các container đang có trên host (gồm đang chạy và đã dừng)

docker ps -a

– Liệt kê các container đang up

docker ps

– Xóa một container

docker rm <container_id>

– Xóa toàn bộ container
Trước khi xóa all containers, chúng ta cần stop all container trước khi thực hiện lệnh xóa

#Stop all containers
docker stop `docker ps -aq`
#Delete all containers
docker rm docker ps -aq
#Có thể sử dụng tham số -f (force) thay vì phải stop container trước khi xóa
docker rm -f `docker ps -aq`
  • Xem thông tin chi tiết về một container
docker inspect <container_id>
  • Kiểm tra port của một container
docker port <container_id>
  • Để xem log của một container ta sử dụng lệnh:
docker logs -f <name_or_container_id>
  • Commit một container thành image (sử dụng trên localhost)
docker commit <container_name> <repo_name>/<image_name:version>
docker start/stop/restart <container_id>

5. Tạo một Dockerfile

5.1 Khái quát Dockerfile

Dockerfile là một tệp tin gồm tập hợp các chỉ thị, mà khi docker gọi tệp tin đó, nó có thể tự động tạo thành các image.
Một số chỉ thị cần biết:
FROM
Là base image để chúng ta tiến hành build một image mới. Chỉ thị này phải được đặt trên cùng của Dockerfile
FROM <image> [AS <name>]
FROM <image>[:<tag>] [AS <name>]
FROM <image>[@<digest>] [AS <name>]
MAINTAINER
Chứa thông tin của tác giả tiến hành build image (Chỉ thị này là tùy chọn, có thể có hoặc không)
RUN
Chỉ thị này được dùng khi muốn cài đặt cái gói bổ sung trong quá trình build image
RUN <command>
RUN [“executable”, “param1”, “param2”]
COPY
Chỉ thị này dùng để copy tệp tin hoặc thư mục mới từ source (src) và chuyển đến  destination (dest) trong hệ thống tệp tin của container.
Source ở đây có thể là đường dẫn local host hoặc URL.
COPY có 2 forms:
COPY [–chown=<user>:<group>] <src>… <dest>
COPY [–chown=<user>:<group>] [“<src>”,… “<dest>”] (yêu cầu đường dẫn chứa khoảng trắng)
ENV
Định nghĩa các biến môi trường
ENV <key> <value>
ENV <key>=<value> …
EXPOSE
Chỉ thị này dùng khai báo các listen port của container
EXPOSE <port> [<port>/<protocol>…]
Kết hợp với tham số -p để expose port của container ra bên ngoài (NAT port)
CMD
Là chỉ thị cho biết lệnh nào được thực hiện mỗi khi khởi tạo container. Trong Dockerfile chỉ có duy nhất một chỉ thị CMD
CMD [“executable”,”param1″,”param2″] (exec form, this is the preferred form)
CMD [“param1″,”param2”] (as default parameters to ENTRYPOINT)
CMD command param1 param2 (shell form)
ENTRYPOINT
ENTRYPOINT [“executable”, “param1”, “param2”] (exec form, preferred)
ENTRYPOINT command param1 param2 (shell form)
Chỉ thị ENTRYPOINT cho phép cấu hình một container mà chạy như một lệnh thực thi. ENTRYPOINT sẽ ghi đè lên các phần tử mà được sử dụng bởi chỉ thị CMD.
vd: docker run -it centos top -H
Tương tác CMD và ENTRYPOINT
Cả 2 chỉ thị đều xác định lệnh nào được thực hiện khi chạy một container.
Có vài quy tắc trong sự tương tác giữa 2 chỉ thị:
– Tối thiểu sẽ có 1 chỉ thị được chỉ định trong Dockerfile (tất nhiên là có thể 2 chỉ thị đều xuất hiện trong Dockerfile)
– ENTRYPOINT được định nghĩa khi sử dụng container như một lệnh thực thi
– CMD được sử dụng như một cách để xác định các tham số mặc định cho chỉ thị ENTRYPOINT hoặc thực thi một lệnh ad-hoc trong một container
– CMD sẽ bị ghi đè khi chạy container với các tham số xen kẽ.
VD về CMD & ENTRYPOINT trong Dockerfile:
ENTRYPOINT [“/usr/sbin/apache2ctl”]
CMD [“-D”, “FOREGROUND”]
ADD
Chỉ thị ADD dùng để copy tệp tin, thư mục hoặc tệp tin với URL từ source (src) và thêm chúng đến đường dẫn đích (dest) trong hệ thống tệp tin của image.
ADD có 2 forms:
ADD [–chown=<user>:<group>] <src>… <dest>
ADD [–chown=<user>:<group>] [“<src>”,… “<dest>”] (this form is required for paths containing whitespace)
Note: Để ý là sự khác nhau giữa COPY/ADD. COPY hỗ trợ copy chỉ đường dẫn local; còn ADD có thể hỗ trợ copy được tệp tin nén .tar và hỗ trợ đường dẫn URL.
WORKDIR
Là chỉ thị dùng để thiết lập thư mục làm việc. Nó giống home directory, trong trường hợp này là home directory của container. Khi gọi WORKDIR nó sẽ tạo ra thư mục ngay lần gọi đầu và truy cập đến nó như home directory.
Nó có thể được dùng nhiều lần trong một Dockerfile.
`WORKDIR /path/to/workdir`
###USER
Được sử dụng để thiết lập user để  sử dụng khi chạy image and cho một số chỉ thị: RUN, CMD & ENTRYPOINT trong Dockerfile.
VOLUME
Dùng để  mount file/directories giữa host và container. Mục đích của VOLUME là:
  • Giữ được dữ liệu khi container bị remove
  • Chia sẻ dữ liệu giữa host và container
  • Chia sẻ dữ liệu giữa các container
Tham khảo thêm về các chỉ thị: https://docs.docker.com/engine/reference/builder/

5.2 Thực hiện build image với Dockerfile

Chúng ta build thử gói cài đặt nginx trên centos:7 base image (CentOS7:nginx)
Tạo tệp tin Dockerfile với nội dung sau:
FROM centos:7
MAINTAINER KeepWalking
RUN yum -y install epel-release && yum -y install nginx
#Running with FOREGROUND
CMD ["nginx", "-g", "daemon off;"]
Chạy Nginx ở chế độ FOREGROUND ( mặc định thì nginx chạy ở chế độ BACKGROUND – daemon on)
– Build image
docker build -t keepwalking/CentOS7-Nginx .
– Run container
docker run -it -p 8080:80 KeepWalking/CentOS7-Nginx

6. export/save/load container

Export container thành image
docker export wordpress1 > wordpress.tar
Import image từ tệp đã xuất
docker import wordpress.tar wordpress:xxx
Save image như tệp nén tar
docker save -o mongodb.tar mongodb:xxx
Load image từ tệp tar
docker load < mongodb.tar​