一文掌握Docker Compose

一、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重新构建应用,再次访问,会发现结果与上面完全相同。

6、 更新应用

我们修改本地的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

[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:数据卷,在它下面可以定义数据卷,然后挂载到不同的服务下去使用。

1、version

用于指定当前compose文件语法遵循哪个版本,下面这张表是不同的Compose文件版本兼容的Docker版本:

2、services

我们上面所说的所有服务的定义都是定义在services区域中,接下来,我们学习下services下常用的配置项

image

标明image的ID,这个image ID可以是本地也可以是远程的,如果本地不存在,compose会尝试pull下来
示例:

image: ubuntu
image: hub.dz11.com/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

3、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

4、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案例实践

1、部署一个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

docker-compose.yml内容如下:

version: '3'
services:
  weba:
    build: ./web
    expose:
    - 80

  webb:
    build: ./web
    expose:
    - 80

  webc:
    build: ./web
    expose:
    - 80

  haproxy:
    image: haproxy:latest
    volumes:
    - ./haproxy:/haproxy-override
    - ./haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
    links:
    - weba
    - webb
    - webc
    ports:
    - "80:80"
    - "70:70"
    expose:
    - "80"
    - "70"

启动docker-compose:

docker-compose up -d

通过验证,我们可以看到服务正常部署,访问http://127.0.0.1:80也可以完成服务的正常访问。但是在前面,我们讲过,weba和webb以及webc都是由同一个image创建而来,那么我们是否可以使用deploy配置项,直接配置三副本呢?

我们验证一下,修改docker-compose.yml内容如下:

version: '3'
services:
  web:
    build: ./web
    expose:
    - 80
    deploy:
      replicas: 3

  haproxy:
    image: haproxy:latest
    volumes:
    - ./haproxy:/haproxy-override
    - ./haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
    external_links:
    - compose-haproxy-web_web_1
    - compose-haproxy-web_web_2
    - compose-haproxy-web_web_3
    ports:
    - "80:80"
    - "70:70"
    expose:
    - "80"
    - "70"

执行docker-compose up -d:

root@ubuntu:~/trainning/compose-haproxy-web# docker-compose up -d
WARNING: Some services (web) use the 'deploy' key, which will be ignored. Compose does not support 'deploy' configuration - use `docker stack deploy` to deploy to a swarm.
compose-haproxy-web_web_1 is up-to-date
compose-haproxy-web_haproxy_1 is up-to-date

上面提示deploy不被支持,然后web也只启动了一个。这是为什么呢?

因为deploy在使用的时候,有一些限制,但你的compose文件中出现如下配置项时,deploy就无法使用:

  • build
  • cgroup_parent
  • container_name
  • devices
  • tmpfs
  • external_links
  • links
  • network_mode
  • restart
  • security_opt
  • stop_signal
  • sysctls
  • userns_mode

2、使用Docker Compose一键部署zabbix

version: '3'
services:
  mysql-server:
    hostname: mysql-server
    container_name: mysql-server
    image: mysql:5.7
    network_mode: host
    volumes:
      - /data/mysql5721/data:/var/lib/mysql
    command: --character-set-server=utf8
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix

  zabbix-web-nginx-mysql:
    hostname: zabbix-web-nginx-mysql
    container_name: zabbix-web-nginx-mysql
    image: zabbix/zabbix-web-nginx-mysql:alpine-3.4.11
    network_mode: host
    depends_on:
      - mysql-server
      - zabbix-server
    ports:
      - 80:80
    environment:
      DB_SERVER_HOST: 127.0.0.1
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix
      MYSQL_ROOT_PASSWORD: 123456
      ZBX_SERVER_HOST: 127.0.0.1
      PHP_TZ: Asia/Shanghai

  zabbix-server:
    hostname: zabbix-server-mysql 
    container_name: zabbix-server-mysql 
    image: zabbix/zabbix-server-mysql:alpine-3.4.11
    depends_on:
      - mysql-server
    network_mode: host
    ports:
      - 10051:10051
    environment:
      DB_SERVER_HOST: 127.0.0.1
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbix
      MYSQL_ROOT_PASSWORD: 123456

  zabbix-agent:
    hostname: zabbix-agent
    container_name: zabbix-agent
    image: zabbix/zabbix-agent:alpine-3.4.11
    network_mode: host
    environment:
      ZBX_HOSTNAME: monitor
      ZBX_SERVER_HOST: 127.0.0.1
标签:Docker 发布于:2019-10-20 14:24:20