docker-compose的安装及使用_docker-compose安装

1、简介

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Compose 使用的三个步骤：

• 使用 Dockerfile 定义应用程序的环境。
• 使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
• 最后，执行 docker-compose up 命令来启动并运行整个应用程序。

docker-compose.yml 的配置案例如下（配置参数参考下文）：

# yaml 配置实例
version: '3'
services:
  web:
    build: .
    ports:
   - "5000:5000"
    volumes:
   - .:/code
    - logvolume01:/var/log
    links:
   - redis
  redis:
    image: redis
volumes:
  logvolume01: {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Compose重要概念：

• 服务service：容器，应用（redis，Nginx，mysql。。。）
• 项目project：一组关联的容器，例如一个博客由Nginx，mysql，redis组成

2、安装

1.下载docker compose：

sudo curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

#慢的话可以用这个
sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
1
2
3
4

2.授予权限：

sudo chmod +x /usr/local/bin/docker-compose
1

3.测试安装结果

docker-compose --version
1

3、使用

1. 定义python应用

1.创建工程目录

mkdir composetest
cd composetest
1
2

2.在composetest目录下创建python flask应用 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个例子中，redis是应用程序网络上redis容器的主机名。我们使用Redis的默认端口，6379.

3.创建python 需求文件 requirements.txt

flask
redis
1
2

2.创建Dockerfile文件

在这一步中，您将编写一个构建Docker映像的Docker文件。该映像包含Python应用程序所需的所有依赖项，包括Python本身。

1.在项目目录中，创建一个名为Dockerfile并粘贴以下内容:

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]
1
2
3
4
5
6
7
8
9
10

2.Dockerfile文件告诉docker了如下信息：

• 从Python 3.7映像开始构建映像。
• 将工作目录设置为/code.
• 设置使用的环境变量flask命令。
• 安装gcc和其他依赖项
• 复制requirements.txt并安装Python依赖项。
• 将元数据添加到图像中，以描述容器正在侦听端口5000
• 复制当前目录.到工作目录的项目中.在图像中。
• 将容器的默认命令设置为flask run.

3.定义docker-compose脚本

1.创建docker-compose.yml文件，并在里面定义服务，内容如下：

version: "3"
services:
  web:
    build: .
    ports:
      - "8000:5000"
  redis:
    image: "redis:alpine"
1
2
3
4
5
6
7
8

2.这个compose文件定义了两个服务，即定义了web和redis两个容器:

• web容器：
  • 使用Dockerfile构建映像
  • 将容器上的暴露端口5000映射到主机上的端口8000。 我们使用Flask Web服务器的默认端口5000
• redis容器：
  • redis服务使用从Docker Hub提取的官方redis镜像

4.使用Compose构建并运行

在目录composetest下执行docker-compose.yml文件：

docker-compose up

# 若是要后台运行： $ docker-compose up -d
# 若不使用默认的docker-compose.yml 文件名：
docker-compose -f server.yml up -d

#停止
docker-compose down
1
2
3
4
5
6
7
8

5.添加文件绑定挂载

可以通过 volumes 关键字实现物理主机目录挂载到容器中的功能（不需要创建镜像时将代码打包进镜像，而是通过volums动态挂载，容器和物理host共享数据卷）

version: "3"
services:
  web:
    build: .
    ports:
      - "8000:5000"
    volumes:
      - .:/code
    environment:
      FLASK_ENV: development
  redis:
    image: "redis:alpine"
1
2
3
4
5
6
7
8
9
10
11
12

新的volumeskey将主机上的项目目录(当前目录)挂载到/code在容器内部，允许您动态修改代码，而不必重新构建映像。这environment键设置FLASK_ENV环境变量，它告诉flask run以开发模式运行并在更改时重新加载代码。这种模式只应在开发中使用。

6.重新构建和运行应用程序

在项目目录中，键入docker-compose up使用更新的合成文件构建应用程序，并运行它。

检查Hello World消息，并刷新以查看计数增量。

7.更新应用程序

因为现在使用卷将应用程序代码装载到容器中，所以您可以对其代码进行更改并立即看到更改，而不必重新构建映像。

将问候语更改并在app.py保存它。例如，更改Hello World!消息发送至Hello from Docker!:

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

在浏览器中刷新应用程序。问候语应该被更新，并且计数器应该仍在递增。

4、yaml配置编写规则

1.docker-compose.yml核心：

#3层！
version: '' #版本
service: #服务
	服务1：web
		#服务配置
		image
		build
		network
		...
	服务2：redis
		...
	服务3：nginx
		...
#其他配置 网络/卷，全局配置
volmues:
network:
configs:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.常用服务配置参考

build

build 可以指定包含构建上下文的路径：

version: '2'
services:
  webapp:
    build: ./dir
1
2
3
4

或者，作为一个对象，该对象具有上下文路径和指定的Dockerfile文件以及args参数值：

version: '2'
services:
  webapp:
    build:
      context: ./dir
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1
1
2
3
4
5
6
7
8

webapp服务将会通过./dir目录下的Dockerfile-alternate文件构建容器镜像。
如果你同时指定image和build，则compose会通过build指定的目录构建容器镜像，而构建的镜像名为image中指定的镜像名和标签。

build: ./dir
image: webapp:tag
1
2

这将由./dir构建的名为webapp和标记为tag的镜像。

context

包含Dockerfile文件的目录路径，或者是git仓库的URL。
当提供的值是相对路径时，它被解释为相对于当前compose文件的位置。 该目录也是发送到Docker守护程序构建镜像的上下文。

dockerfile

备用Docker文件。Compose将使用备用文件来构建。 还必须指定构建路径。

args

添加构建镜像的参数，环境变量只能在构建过程中访问。
首先，在Dockerfile中指定要使用的参数：

ARG buildno
ARG password
 
RUN echo "Build number: $buildno"
RUN script-requiring-password.sh "$password"
1
2
3
4
5

然后在args键下指定参数。 你可以传递映射或列表：

build:
  context: .
  args:
    buildno: 1
    password: secret
 
build:
  context: .
  args:
    - buildno=1
    - password=secret
1
2
3
4
5
6
7
8
9
10
11

注意：YAML布尔值（true，false，yes，no，on，off）必须用引号括起来，以便解析器将它们解释为字符串。

image

指定启动容器的镜像，可以是镜像仓库/标签或者镜像id（或者id的前一部分）

image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd
1
2
3
4
5

如果镜像不存在，Compose将尝试从官方镜像仓库将其pull下来，如果你还指定了build，在这种情况下，它将使用指定的build选项构建它，并使用image指定的名字和标记对其进行标记。

container_name

指定一个自定义容器名称，而不是生成的默认名称。

container_name: my-web-container
1

由于Docker容器名称必须是唯一的，因此如果指定了自定义名称，则无法将服务扩展到多个容器。

volumes

卷挂载路径设置。可以设置宿主机路径 （HOST:CONTAINER） 或加上访问模式 （HOST:CONTAINER:ro）,挂载数据卷的默认权限是读写（rw），可以通过ro指定为只读。
你可以在主机上挂载相对路径，该路径将相对于当前正在使用的Compose配置文件的目录进行扩展。 相对路径应始终以 . 或者 … 开始。

volumes:
  # 只需指定一个路径，让引擎创建一个卷
  - /var/lib/mysql
 
  # 指定绝对路径映射
  - /opt/data:/var/lib/mysql
 
  # 相对于当前compose文件的相对路径
  - ./cache:/tmp/cache
 
  # 用户家目录相对路径
  - ~/configs:/etc/configs/:ro
 
  # 命名卷
  - datavolume:/var/lib/mysql
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

但是，如果要跨多个服务并重用挂载卷，请在顶级volumes关键字中命名挂在卷，但是并不强制，如下的示例亦有重用挂载卷的功能，但是不提倡。

version: "3"
 
services:
  web1:
    build: ./web/
    volumes:
      - ../code:/opt/web/code
  web2:
    build: ./web/
    volumes:
      - ../code:/opt/web/code
1
2
3
4
5
6
7
8
9
10
11

注意：通过顶级volumes定义一个挂载卷，并从每个服务的卷列表中引用它， 这会替换早期版本的Compose文件格式中volumes_from。

version: "3"
 
services:
  db:
    image: db
    volumes:
      - data-volume:/var/lib/db
  backup:
    image: backup-service
    volumes:
      - data-volume:/var/lib/backup/data
 
volumes:
  data-volume:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

command

覆盖容器启动后默认执行的命令。

command: bundle exec thin -p 3000
1

该命令也可以是一个类似于dockerfile的列表：

command: ["bundle", "exec", "thin", "-p", "3000"]
1

links

链接到另一个服务中的容器。 请指定服务名称和链接别名（SERVICE：ALIAS），或者仅指定服务名称。

web:
  links:
   - db
   - db:database
   - redis
1
2
3
4
5

在当前的web服务的容器中可以通过链接的db服务的别名database访问db容器中的数据库应用，如果没有指定别名，则可直接使用服务名访问。

链接不需要启用服务进行通信 - 默认情况下，任何服务都可以以该服务的名称到达任何其他服务。 （实际是通过设置/etc/hosts的域名解析，从而实现容器间的通信。故可以像在应用中使用localhost一样使用服务的别名链接其他容器的服务，前提是多个服务容器在一个网络中可路由联通）

links也可以起到和depends_on相似的功能，即定义服务之间的依赖关系，从而确定服务启动的顺序。

depend on

depends_on表示服务之间的启动和关闭依赖关系

• 组合实现必须按照依赖顺序创建服务。在下面的例子中，db和redis都是在web之前创建
• 组合实现必须按照依赖顺序移除服务。在下面的例子中，先移除web后再移除db和redis

services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres
1
2
3
4
5
6
7
8
9
10

expose

暴露端口，但不映射到宿主机，只被连接的服务访问。 仅可以指定内部端口为参数

expose:
 - "3000"
 - "8000"
1
2
3

ports

暴露端口信息。
常用的简单格式：使用宿主：容器 （HOST:CONTAINER）格式或者仅仅指定容器的端口（宿主将会随机选择端口）都可以。

注意：当使用 HOST:CONTAINER 格式来映射端口时，如果你使用的容器端口小于 60 你可能会得到错误得结果，因为 YAML 将会解析 xx:yy 这种数字格式为 60 进制。所以建议采用字符串格式。

简单的短格式：

ports:
 - "3000"
 - "3000-3005"
 - "8000:8000"
 - "9090-9091:8080-8081"
 - "49100:22"
 - "127.0.0.1:8001:8001"
 - "127.0.0.1:5000-5010:5000-5010"
 - "6060:6060/udp"
1
2
3
4
5
6
7
8
9

长格式：

ports:
  - target: 80
    published: 8080
    protocol: tcp
    mode: host
1
2
3
4
5

target：容器内的端口
published：物理主机的端口
protocol：端口协议（tcp或udp）
mode：host 和ingress 两总模式，host用于在每个节点上发布主机端口，ingress 用于被负载平衡的swarm模式端口。

restart

no是默认的重启策略，在任何情况下都不会重启容器。 指定为always时，容器总是重新启动。 如果退出代码指示出现故障错误，则on-failure将重新启动容器。

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped
1
2
3
4

environment

添加环境变量。 你可以使用数组或字典两种形式。 任何布尔值; true，false，yes，no需要用引号括起来，以确保它们不被YML解析器转换为True或False。
只给定名称的变量会自动获取它在 Compose 主机上的值，可以用来防止泄露不必要的数据。

environment:
  RACK_ENV: development
  SHOW: 'true'
  SESSION_SECRET:
 
environment:
  - RACK_ENV=development
  - SHOW=true
  - SESSION_SECRET
1
2
3
4
5
6
7
8
9

注意：如果你的服务指定了build选项，那么在构建过程中通过environment定义的环境变量将不会起作用。 将使用build的args子选项来定义构建时的环境变量。

pid

将PID模式设置为主机PID模式。 这就打开了容器与主机操作系统之间的共享PID地址空间。 使用此标志启动的容器将能够访问和操作裸机的命名空间中的其他容器，反之亦然。即打开该选项的容器可以相互通过进程 ID 来访问和操作。

pid: "host"
1

dns

配置 DNS 服务器。可以是一个值，也可以是一个列表。

dns: 8.8.8.8
dns:
  - 8.8.8.8
  - 9.9.9.9
1
2
3
4

5、实战部署WP博客

1.创建一个空目录

cd /docker
mkdir wp
cd wp
1
2
3

2.创建一个docker-compose.yml

version: "3"
    
services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    
  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    volumes:
      - wordpress_data:/var/www/html
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
volumes:
  db_data: {}
  wordpress_data: {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

docker卷db_data和wordpress_data保存WordPress对数据库的更新，以及已安装的主题和插件

WordPress Multisite只在80和443端口上工作

3.构建项目

docker-compose up
1

4.安装

• 访问：http://ip:8000完成博客的安装

5.关闭和清理

• 命令docker-compose down删除容器和默认网络，但保留你的WordPress数据库。
• 命令docker-compose down --volumes删除容器、默认网络和WordPress数据库。

6、实战部署springboot

1.创建springboot项目

编写Controller

@RestController
public class UserController {
    
    @Autowired
    StringRedisTemplate redisTemplate;

    @GetMapping("get")
    public String get(){
        return "times:" + redisTemplate.opsForValue().increment("views");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12

编写application

spring:
  application:
    name: myapp
  redis:
    host: redis
server:
  port: 8080
1
2
3
4
5
6
7

2.编写Dockerfile

FROM java:8

COPY *.jar /app.jar

EXPOSE 8080

ENTRYPOINT ["java","-jar","/app.jar"]
1
2
3
4
5
6
7

3.编写docker-compose.yml

version: '3'
services:
  satoken:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - redis
  redis: 
    image: redis
1
2
3
4
5
6
7
8
9
10

4.准备

• 打包：mvn clean package
• 将jar包、Dockerfile和docker-compose.yml文件上传到服务器

5.启动

• docker-compose up
• 重新构建：docker-compose up --build