一文掌握Docker Compose

本文轉載自查看原文 2018-08-05 16:02 1812 Docker/ docker-compose/ docker

Docker Compose介紹
Docker Compose安裝
Docker Compose基本示例
Docker Compose常用命令說明
Docker Compose文件詳解
- version
- services
  - image
  - build
  - command
  - links
  - external_links
  - ports
  - expose
  - environment
  - env_file
  - depends_on
  - deploy
  - healthcheck
  - network_mode
  - dns
- networks
- volumes
Docker Compose案例實踐
- 部署一個web集群
- 使用Docker Compose一鍵部署zabbix

Docker Compose介紹

Docker Compose是一個定義和運行多容器應用的單機編排工具。通過Docker Compose你可以使用一個單一的YAML文件來配置多個應用服務，通過一條命令，就可以將所有配置的服務全部啟動起來。

使用Docker Compose的三個步驟：

使用Dockerfile定義環境，這樣可以確保其在任意地方運行
使用docker-compose.yml文件定義服務，這樣它們就可以在獨立環境中一起運行
運行docker-compose up使用docker-compose啟動所有應用

Docker Compose可以管理應用的整個生命周期：

啟動、停止、重建服務
查看服務的運行狀態
流式輸出服務日志
對服務執行一次性命令

Docker Compose安裝

二進制安裝：

下載地址：https://github.com/docker/compose/releases

pip安裝：

pip install docker-compose

Docker Compose基本示例

1、基本文件及目錄設置

mkdir composetest
cd composetest

在上面的目錄中創建一個app.py文件，內容如下：

import time

import redis
from flask import Flask


app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", debug=True)

再創建一個pip.conf文件，內容如下：

[global]
index-url = https://mirrors.aliyun.com/pypi/simple/

[install]
trusted-host=mirrors.aliyun.com

2、創建一個Dockerfile

仍然在composetest目錄中創建一個Dockerfile，內容如下：

FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

3、通過docker-compose.yml定義服務

docker-compose.yml內容如下：

version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

這個文件定義了兩個服務：web和redis。

web服務使用當前目錄的Dockerfile進行構建，並且映射web服務的5000端口到宿主機5000端口。
redis服務使用一個公共的redis鏡像。

4、通過Docker Compose構建並啟動服務

docker-compose up

這個時候可以通過http://127.0.0.1:5000來訪問這個web服務。

5、修改Compse文件，添加一個掛載點

修改docker-compose.yml，內容如下：

version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
    volumes:
     - .:/code
  redis:
    image: "redis:alpine"

添加了一個volumes配置項，將當前目錄掛載至web容器的/code目錄下。

然后我們通過docker-compose up重新構建應用，再次訪問，會發現結果與上面完全相同。

7、更新應用

我們修改本地的app.py，修改Hello World!為Hello from Dokcer，如下：

return 'Hello from Docker! I have been seen {} times.\n'.format(count)

這個時候再次訪問http://127.0.0.1:5000，發現訪問內容也隨之修改。

這是因為在上面我們將本地目錄掛載進了容器，我們修改本地的app.py就相當於修改了容器內的文件。

Docker Compose常用命令說明

在上面的一個簡單示例中，我們已經使用了docker-compose up來啟動一個docker-compose.yml文件定義的服務。我們剛剛通過docker-compose up雖然啟動了服務，當是docker-compose指令卻在前台執行，如果需要將其放入后台運行，可以使用-d參數：

docker-compose up -d

docker-compose up還可以使用--scale參數實現服務的擴縮容：

[root@app composetest]# docker-compose up -d --scale web=2
Recreating composetest_web_1 ... 
Recreating composetest_web_1 ... done
Creating composetest_web_2   ... done

還可以通過-f選項指定compose文件：

[root@app tranning]# docker-compose -f test-compose.yml up -d
Creating network "tranning_default" with the default driver
Creating network "tranning_frontend" with the default driver
Creating network "tranning_backend" with the default driver
Creating tranning_visualizer_1 ... done
Creating tranning_redis_1      ... done
Creating tranning_worker_1     ... done
Creating tranning_db_1         ... done
Creating tranning_result_1     ... done
Creating tranning_vote_1       ... done

需要說明的是，如果使用自動擴容，則web服務不能做端口映射，否則會出現端口沖突的情況

下面我們說一說其他常用的docker-compose命令：

docker-compose ps

[root@app composetest]# docker-compose ps 
       Name                      Command               State           Ports         
-------------------------------------------------------------------------------------
composetest_redis_1   docker-entrypoint.sh redis ...   Up      6379/tcp              
composetest_web_1     python app.py

docker-compose stop

[root@app composetest]# docker-compose stop
Stopping composetest_redis_1 ... done
Stopping composetest_web_1   ... done

[root@app composetest]# docker-compose stop web
Stopping composetest_web_1 ... done

docker-compose start

[root@app composetest]# docker-compose start
Starting web   ... done
Starting redis ... done

[root@app composetest]# docker-compose start web
Starting web ... done

docker-compose restart

[root@app composetest]# docker-compose restart
Restarting composetest_web_1   ... done
Restarting composetest_redis_1 ... done

docker-compose run [command]

[root@app composetest]# docker-compose run web env
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=72ad8a0682b7
TERM=xterm
LANG=C.UTF-8
GPG_KEY=97FC712E4C024BBEA48A61ED3A5CA953F73C700D
PYTHON_VERSION=3.4.9
PYTHON_PIP_VERSION=18.0
HOME=/root

docker-compose down

[root@app composetest]# docker-compose down
Stopping composetest_redis_1 ... done
Stopping composetest_web_1   ... done
Removing composetest_redis_1 ... done
Removing composetest_web_1   ... done
Removing network composetest_default

通過--volumes還要以刪除自動掛載的容器卷

docker-compose build

默認情況下，我們寫好了Dockerfile，第一次通過docker-compose啟動的時候，會自動完成構建，但如果隨后Dockerfile發生了改動，再次通過docker-compose來啟動實現更新的話，docker-compose不會再次自動構建鏡像，而是復用第一次生成的鏡像，如果希望鏡像能夠被重新構建，需要單獨執行docker-compose build

docker-compose top

[root@app composetest]# docker-compose top
composetest_redis_1
UID    PID    PPID    C   STIME   TTY     TIME         CMD     
---------------------------------------------------------------
100   89653   89634   0   23:26   ?     00:00:00   redis-server

composetest_web_1
UID     PID    PPID    C   STIME   TTY     TIME                 CMD             
--------------------------------------------------------------------------------
root   89635   89619   0   23:26   ?     00:00:00   python app.py               
root   89742   89635   0   23:26   ?     00:00:00   /usr/local/bin/python app.py

其它

docker-compose rm       # 通過這種方式也能刪除指定服務，但不會刪除網絡和volumes
docker-compose kill     # 強制殺死一個服務
docker-compose logs     # 用於查看日志

Docker Compose文件詳解

通過之前的示例，其實我們可以看到，所有服務的管理，都是依靠docker-compose.yml文件來實現的。那么我們接下來就詳細說一說docker-compose.yml文件中的常用指令。

compose文件使用yml格式，docker規定了一些指令，使用它們可以去設置對應的東西，主要分為了四個區域：

version：用於指定當前docker-compose.yml語法遵循哪個版本
services：服務，在它下面可以定義應用需要的一些服務，每個服務都有自己的名字、使用的鏡像、掛載的數據卷、所屬的網絡、依賴哪些其他服務等等。
networks：應用的網絡，在它下面可以定義應用的名字、使用的網絡類型等。
volumes：數據卷，在它下面可以定義數據卷，然后掛載到不同的服務下去使用。

version

用於指定當前compose文件語法遵循哪個版本，下面這張表是不同的Compose文件版本兼容的Docker版本：
docker-compse

services

我們上面所說的所有服務的定義都是定義在services區域中，接下來，我們學習下services下常用的配置項

image

標明image的ID，這個image ID可以是本地也可以是遠程的，如果本地不存在，compose會嘗試pull下來
示例：

image: ubuntu
image: hub.breezey.top/library/tomcat:8

build

該參數指定Dockerfile文件的路徑，compose會通過Dockerfile構建並生成鏡像，然后使用該鏡像
示例：

build: /path/to/build/dir

command

重寫默認的命令，或者說指定啟動容器的命令
示例：

command: "/run.sh"

links

鏈接到其他服務中的容器，可以指定服務名稱和這個鏈接的別名，或者只指定服務名稱
示例：

links:
  - db
  - db:database
  - redis

此時，在容器內部，會在/etc/hosts文件中用別名創建幾個條目，如下：

172.17.2.100 db
172.17.2.100 database
172.17.2.100 redis

external_links

鏈接到compose外部啟動的容器，特別是對於提供共享和公共服務的容器。在指定容器名稱和別名時，external_links遵循着和links相同的語義用法
示例：

external_links:
  - redis_1
  - project_db_1: mysql
  - project_db_2: postgresql

ports

暴露端口，指定宿主機到容器的端口映射，或者只指定容器的端口，則表示映射到主機上的隨機端口
注：當以主機:容器的形式來映射端口時，如果使容器的端口小於60，那可能會出現錯誤，因為YAML會將 xx:yy這樣格式的數據解析為六十進制的數據，基於這個原因，時刻記得要將端口映射明確指定為字符串
示例：

ports:  
 - "3000"  
 - "8000:8000"  
 - "49100:22"  
 - "127.0.0.1:8001:8001"

expose

暴露端口，但不需要建立與宿主機的映射，只是會向鏈接的服務提供
示例：

expose:
  - "3000"
  - "8000"

environment

加入環境變量，可以使用數組或者字典，只有一個key的環境變量可以在運行compose的機器上找到對應的值
示例：

environment:
  RACK_ENV: development
  SESSION_SECRET：

environment:
  - RACK_ENV: development
  - SESSION_SECRET：

env_file

從一個文件中引入環境變量，該文件可以是一個單獨的值或者一個列表，如果同時定義了environment，則environment中的環境變量會重寫這些值
示例：

env_file:
  - env

cat env
RACK_ENV: development

depends_on

定義當前服務啟動時，依賴的服務，當前服務會在依賴的服務啟動后啟動

depends_on:
  - redis

deploy

該配置項在version 3里才引入，用於指定服務部署和運行時相關的參數

version: '3'
services:
  redis:
    image: redis:alpine
    deploy:
      replicas: 6
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure

下面是deploy中常用參數的說明

replicas

指定副本數：

version: '3'
services:
  worker:
    image: dockersamples/examplevotingapp_worker
    deploy:
      replicas: 6

restart_policy

指定重啟策略：

version: "3"
services:
  redis:
    image: redis:alpine
    deploy:
      restart_policy:
        condition: on-failure   #重啟條件：on-failure, none, any
        delay: 5s   # 等待多長時間嘗試重啟
        max_attempts: 3 #嘗試的次數
        window: 120s    # 在決定重啟是否成功之前等待多長時間

update_config

定義更新服務的方式，常用於滾動更新

version: '3.4'
services:
  vote:
    image: dockersamples/examplevotingapp_vote:before
    depends_on:
      - redis
    deploy:
      replicas: 2
      update_config:
        parallelism: 2  # 一次更新2個容器
        delay: 10s  # 開始下一組更新之前，等待的時間
        failure_action：pause  # 如果更新失敗，執行的動作：continue, rollback, pause，默認為pause
        max_failure_ratio： 20 # 在更新過程中容忍的失敗率
        order: stop-first   # 更新時的操作順序，停止優先（stop-first，先停止舊容器，再啟動新容器）還是開始優先（start-first，先啟動新容器，再停止舊容器），默認為停止優先，從version 3.4才引入該配置項

resources

限制服務資源：

version: '3'
services:
  redis:
    image: redis:alpine
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 50M
        reservations:
          cpus: '0.25'
          memory: 20M

healthcheck

執行健康檢查

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]   # 用於健康檢查的指令
  interval: 1m30s   # 間隔時間
  timeout: 10s  # 超時時間
  retries: 3    # 重試次數
  start_period: 40s # 啟動多久后開始檢查

network_mode

網絡類型，可指定容器運行的網絡類型
示例：

network_mode: "bridge"
network_mode: "host"
network_mode: "none"

dns

自定義dns服務
示例：

dns: 8.8.8

dns:
  - 223.5.5.5
  - 223.6.6.6

networks

網絡決定了服務之間以及服務和外界之間如何去通信，在執行docker-compose up的時候，docker會默認創建一個默認網絡，創建的服務也會默認的使用這個默認網絡。服務和服務之間，可以使用服務的名字進行通信，也可以自己創建網絡，並將服務加入到這個網絡之中，這樣服務之間可以相互通信，而外界不能夠與這個網絡中的服務通信，可以保持隔離性。

在networks中定義一個名為app_net，類型為driver的網絡：

version: '2'

services:
  app:
    image: busybox
    command: ifconfig
    networks:
      app_net:
        ipv4_address: 172.16.238.10

networks:
  app_net:
    driver: bridge
    enable_ipv6: true
    ipam:
      driver: default
      config:
      - subnet: 172.16.238.0/24
        gateway: 172.168.238.254

volumes

version: "3.2"
services:
  web:
    image: nginx:alpine
    volumes:
      - type: volume
        source: mydata
        target: /data
        volume:
          nocopy: true
      - type: bind
        source: ./static
        target: /opt/app/static

  db:
    image: postgres:latest
    volumes:
      - "/var/run/postgres/postgres.sock:/var/run/postgres/postgres.sock"
      - "dbdata:/var/lib/postgresql/data"

volumes:
  mydata:
  dbdata:

Docker Compose案例實踐

部署一個web集群

項目說明

這是一個典型的web項目，由一個haproxy容器加三個web容器組成。haproxy在前端充當負載均衡器，反向代理到后台三個服務服務。

基本目錄結構

首先創建一個compose-haproxy-web的目錄，然后在目錄里面，創建兩個子目錄：haproxy和web。

在web目錄里包含三個文件： Dockerfile、index.py、index.html

在haproxy目錄里包含一個文件： haproxy.cfg

目錄結構如下：

compose-haproxy-web/
├── docker-compose.yml
├── haproxy
│   └── haproxy.cfg
└── web
    ├── Dockerfile
    ├── index.html
    └── index.py

2 directories, 5 files

web目錄下的index.py提供一個簡單的http服務，打印出訪問者的ip和實際的本地IP，內容如下：

#!/usr/bin/python
#authors: yeasy.github.com
#date: 2013-07-05
import sys
import BaseHTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
import socket
import fcntl
import struct
import pickle
from datetime import datetime
from collections import OrderedDict

class HandlerClass(SimpleHTTPRequestHandler):
  def get_ip_address(self,ifname):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    return socket.inet_ntoa(fcntl.ioctl(
      s.fileno(),
      0x8915, # SIOCGIFADDR
      struct.pack('256s', ifname[:15])
    )[20:24])
  def log_message(self, format, *args):
    if len(args) < 3 or "200" not in args[1]:
      return
    try:
      request = pickle.load(open("pickle_data.txt","r"))
    except:
      request=OrderedDict()
    time_now = datetime.now()
    ts = time_now.strftime('%Y-%m-%d %H:%M:%S')
    server = self.get_ip_address('eth0')
    host=self.address_string()
    addr_pair = (host,server)
    if addr_pair not in request:
      request[addr_pair]=[1,ts]
    else:
      num = request[addr_pair][0]+1
      del request[addr_pair]
      request[addr_pair]=[num,ts]
    file=open("index.html", "w")
    file.write("<!DOCTYPE html> <html> <body><center><h1><font color=\"blue\" face=\"Georgia, Arial\" size=8><em>HA</em></font> Webpage Visit Results</h1></center>");
    for pair in request:
      if pair[0] == host:
        guest = "LOCAL: "+pair[0]
      else:
        guest = pair[0]
      if (time_now-datetime.strptime(request[pair][1],'%Y-%m-%d %H:%M:%S')).seconds < 3:
        file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"red\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"blue\">"+guest+"</font>&gt to WebServer &lt<font color=\"blue\">"+pair[1]+"</font>&gt</p>")
      else:
        file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"maroon\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"navy\">"+guest+"</font>&gt to WebServer &lt<font color=\"navy\">"+pair[1]+"</font>&gt</p>")
    file.write("</body> </html>");
    file.close()
    pickle.dump(request,open("pickle_data.txt","w"))

if __name__ == '__main__':
  try:
    ServerClass = BaseHTTPServer.HTTPServer
    Protocol = "HTTP/1.0"
    addr = len(sys.argv) < 2 and "0.0.0.0" or sys.argv[1]
    port = len(sys.argv) < 3 and 80 or int(sys.argv[2])
    HandlerClass.protocol_version = Protocol
    httpd = ServerClass((addr, port), HandlerClass)
    sa = httpd.socket.getsockname()
    print "Serving HTTP on", sa[0], "port", sa[1], "..."
    httpd.serve_forever()
  except:
    exit()

web目錄下index.html文件是一個空文件，在程序啟動之后會用到。

web目錄下Dockerfile內容如下：

FROM python:2.7
WORKDIR /code
ADD . /code
EXPOSE 80
CMD python index.py

haproxy目錄下的haproxy.cfg內容如下：

global
    log 127.0.0.1 local0
    log 127.0.0.1 local1 notice

defaults
    log global
    mode http
    option httplog
    option dontlognull
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

listen stats
    bind 0.0.0.0:70
    stats enable
    stats uri /

frontend balancer
    bind 0.0.0.0:80
    mode http
    default_backend web_backends

backend web_backends
    mode http
    option forwardfor
    balance roundrobin
    server weba weba:80 check
    server webb webb:80 check
    server webc webc:80 check
    option httpchk GET /
    http-check expect status 200

配置docker-compose