[关闭]
@octopus 2020-09-14T10:36:11.000000Z 字数 29252 阅读 1342

docker

docker

Image

1

1. 操作系统的组成

由此可见对于不同的 linux 发行版，bootfs 基本是一致的，rootfs 会有差别,因此不同的发行版可以公用 bootfs。所以在docker下载一个操作系统image很小，是因为不带 kernel。

2. 什么是 Image

3. 获取 Image

docker hub

可以通过自定义 dockerfile 生成 image，也可以使用已有的image，从 registry（仓库）中获取。docker hub 是 docker 提供的免费仓库。

  1. // 拉取镜像，14.04版本的ubuntu
  2. docker pull ubuntu:14.04

Container

1

1. 什么是 container

  1. docker run hello-world

2. docker image build 原理

Docker 网络

linux 网络的命名空间（network namespace）

  1. # 启动一个容器 test1，在后台一直运行
  2. > docker run -d --name test1 centos /bin/sh -c "while true;do sleep 3600;done"
  4. # 交互式进入容器中
  5. > docker exec -it 14a7a82f5351 /bin/sh
  7. # 查看网络信息
  8. > ip a
  10. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  11.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  12.     inet 127.0.0.1/8 scope host lo
  13.        valid_lft forever preferred_lft forever
  14. 8: eth0@if9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
  15.     link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  16.     inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
  17.        valid_lft forever preferred_lft forever
  1. # 启动一个容器 test2，后台运行
  2. > docker run -d --name test2 centos /bin/sh -c "while true;do sleep 3600;done"
  4. # 查看网络信息
  5. > docker exec a566bb8 ip a
  7. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  8.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  9.     inet 127.0.0.1/8 scope host lo
  10.        valid_lft forever preferred_lft forever
  11. 10: eth0@if11: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
  12.     link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  13.     inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
  14.        valid_lft forever preferred_lft forever
  16. # 退出容器 
  17. > exit    
  1. # 查看本地网络
  2. > ip a
  4. lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  5.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  6.     inet 127.0.0.1/8 scope host lo
  7.        valid_lft forever preferred_lft forever
  8.     inet6 ::1/128 scope host 
  9.        valid_lft forever preferred_lft forever
  10. 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
  11.     link/ether 52:54:00:39:01:f8 brd ff:ff:ff:ff:ff:ff
  12.     inet 172.21.0.3/20 brd 172.21.15.255 scope global eth0
  13.        valid_lft forever preferred_lft forever
  14.     inet6 fe80::5054:ff:fe39:1f8/64 scope link 
  15.        valid_lft forever preferred_lft forever
  16. 3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
  17.     link/ether 02:42:17:d2:ba:aa brd ff:ff:ff:ff:ff:ff
  18.     inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
  19.        valid_lft forever preferred_lft forever
  20.     inet6 fe80::42:17ff:fed2:baaa/64 scope link 
  21.        valid_lft forever preferred_lft forever
  22. 9: vethbaa637c@if8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
  23.     link/ether 8a:2f:81:f0:3d:d9 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  24.     inet6 fe80::882f:81ff:fef0:3dd9/64 scope link 
  25.        valid_lft forever preferred_lft forever
  26. 11: vethd1ba402@if10: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
  27.     link/ether 02:82:da:12:b0:2d brd ff:ff:ff:ff:ff:ff link-netnsid 1
  28.     inet6 fe80::82:daff:fe12:b02d/64 scope link 
  29.        valid_lft forever preferred_lft forever

1

可以看到，每创建一个容器，就创建了一个 network namespace，不同容器的网络环境是隔离的，与本地环境也是隔离的，各自有各自的ip。 在 test1 与 test2 中可以互相 ping 通，互相通信，在本地也能与两个 container 互通。原理是什么，怎么实现的？

模拟两个命名空间的通信 / 容器与宿主机的通信

1. 创建本地的网络命名空间

  1. > ip netns add test1    # 创建一个本地网络命名空间，名字是 test1
  2. > ip netns add test2
  3. > ip netns list         # 列出本地网络命名空间
  4.     test1
  5.     test2
  7. > ip netns delete test1 # 这步不必运行，只是写出删除ns的方法。
  9. > ip netns exec test1 ip a  # 查看test1网络环境
  10.     1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN group default qlen 1000
  11.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  13. # 可以看到现在 test1 的网络只有一个 lo 回环口，状态是 down，没有运行
关于 ip link:
- 1.查看
    ip link 操作网络7层中的链路层，只能看链路层的状态，看不到ip地址
- 2.启用、禁用接口
    ip link set device down   禁用指定接口
    ip link set device up    启用指定接口
    比如禁用eth0就是ip link set eth0 down

  1. # 使用 ip link 将 lo 启动
  2. > ip netns exec test1 ip link set dev lo up
  3. > ip netns exec test1 ip a
  4.     1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  5.         link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  6.         inet 127.0.0.1/8 scope host lo
  7.            valid_lft forever preferred_lft forever
  8.         inet6 ::1/128 scope host 
  9.            valid_lft forever preferred_lft forever
  11. # lo 的状态就变为 UNKNOWN ,是因为单个端口是无法完全 up 起来，像网线一样需要有另一端进行连接，是一对。

2. 准备 veth-pair 接口

1

    veth-pair 就是一对的虚拟设备接口，和 tap/tun 设备不同的是，它都是成对出现的。一端连着协议栈，一端彼此相连着。 
    它的作用很简单，就是要把从一个 network namespace 发出的数据包转发到另一个 namespace。

  1. # 在本地创建一对 Veth 接口
  2. > ip link add veth-test1 type veth peer name veth-test2
  3. > ip a
  5. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  6.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  7.     inet 127.0.0.1/8 scope host lo
  8.        valid_lft forever preferred_lft forever
  9.     inet6 ::1/128 scope host 
  10.        valid_lft forever preferred_lft forever
  11. 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
  12.     link/ether 52:54:00:39:01:f8 brd ff:ff:ff:ff:ff:ff
  13.     inet 172.21.0.3/20 brd 172.21.15.255 scope global eth0
  14.        valid_lft forever preferred_lft forever
  15.     inet6 fe80::5054:ff:fe39:1f8/64 scope link 
  16.        valid_lft forever preferred_lft forever
  17. 3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
  18.     link/ether 02:42:17:d2:ba:aa brd ff:ff:ff:ff:ff:ff
  19.     inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
  20.        valid_lft forever preferred_lft forever
  21.     inet6 fe80::42:17ff:fed2:baaa/64 scope link 
  22.        valid_lft forever preferred_lft forever
  23. 9: vethbaa637c@if8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
  24.     link/ether 8a:2f:81:f0:3d:d9 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  25.     inet6 fe80::882f:81ff:fef0:3dd9/64 scope link 
  26.        valid_lft forever preferred_lft forever
  27. 11: vethd1ba402@if10: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default 
  28.     link/ether 02:82:da:12:b0:2d brd ff:ff:ff:ff:ff:ff link-netnsid 1
  29.     inet6 fe80::82:daff:fe12:b02d/64 scope link 
  30.        valid_lft forever preferred_lft forever
  31. 12: veth-test2@veth-test1: <BROADCAST,MULTICAST,M-DOWN> mtu 1500 qdisc noop state DOWN group default qlen 1000
  32.     link/ether d2:6b:17:27:8c:21 brd ff:ff:ff:ff:ff:ff
  33. 13: veth-test1@veth-test2: <BROADCAST,MULTICAST,M-DOWN> mtu 1500 qdisc noop state DOWN group default qlen 1000
  34.     link/ether 6a:68:78:cc:00:2e brd ff:ff:ff:ff:ff:ff
  36. # 12 13 就是刚才新建的一对 veth 接口

3. 将 veth-pair 接口分别添加到两个命名空间中

  1. # 将 veth 接口的一端添加到 test1 命名空间中
  2. > ip link set veth-test1 netns test1
  4. # 查看 test1 的网络链路
  5. > ip netns exec test1 ip link
  7. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
  8.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  9. 13: veth-test1@if12: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
  10.     link/ether 6a:68:78:cc:00:2e brd ff:ff:ff:ff:ff:ff link-netnsid 0
  12. # 会发现 test1 中多了一个 veth-test1@if12 接口
  13. # 同时查看本地 ip link，发现 veth-test1 已经没有了。
  14. > ip link
  15. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
  16.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  17. 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT group default qlen 1000
  18.     link/ether 52:54:00:39:01:f8 brd ff:ff:ff:ff:ff:ff
  19. 3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP mode DEFAULT group default 
  20.     link/ether 02:42:17:d2:ba:aa brd ff:ff:ff:ff:ff:ff
  21. 9: vethbaa637c@if8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP mode DEFAULT group default 
  22.     link/ether 8a:2f:81:f0:3d:d9 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  23. 11: vethd1ba402@if10: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP mode DEFAULT group default 
  24.     link/ether 02:82:da:12:b0:2d brd ff:ff:ff:ff:ff:ff link-netnsid 1
  25. 12: veth-test2@if13: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
  26.     link/ether d2:6b:17:27:8c:21 brd ff:ff:ff:ff:ff:ff link-netnsid 2
  28. # 同时向 test2 中加入接口 veth-test2
  29. > ip link set veth-test2 netns test2

4. 启动 veth-pair 接口，并分配 ip 地址，互相请求

  1. # 这样 veth 的两端就布置好了，接下来把两端接口启动，并为接口分配 ip 地址
  2. > netns exec test1 ip link set dev veth-test1 up
  3. > ip netns exec test2 ip link set dev veth-test2 up
  4. > ip netns exec test1 ip addr add 192.168.1.1/24 dev veth-test1
  5. > ip netns exec test2 ip addr add 192.168.1.2/24 dev veth-test2
  7. # 查看命名空间 test1 的网络信息
  8. > ip netns exec test1 ip a
  10. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  11.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  12.     inet 127.0.0.1/8 scope host lo
  13.        valid_lft forever preferred_lft forever
  14.     inet6 ::1/128 scope host 
  15.        valid_lft forever preferred_lft forever
  16. 13: veth-test1@if12: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
  17.     link/ether 6a:68:78:cc:00:2e brd ff:ff:ff:ff:ff:ff link-netnsid 1
  18.     inet 192.168.1.1/24 scope global veth-test1
  19.        valid_lft forever preferred_lft forever
  20.     inet6 fe80::6868:78ff:fecc:2e/64 scope link 
  21.        valid_lft forever preferred_lft forever
  23. # 发现他的 status 是 up 并且已经配置上了 ip 地址，test2 也是同理，并且二者可以互通。
  24. > ip netns exec test1 ping 192.168.1.2
  26. PING 192.168.1.2 (192.168.1.2) 56(84) bytes of data.
  27. 64 bytes from 192.168.1.2: icmp_seq=1 ttl=64 time=0.056 ms
  28. 64 bytes from 192.168.1.2: icmp_seq=2 ttl=64 time=0.044 ms

总结

1

用容器名访问其他容器

需求：在容器1中启动mysql服务器，在容器2中连接，容器2并不知道容器1的ip，想通过容器名即可访问，如：host = containet1:3306

  1. # 用 --link 指定绑定ip，相当于 host 名->ip 的绑定
  2. > docker run -d --name test2 --link test1 centos /bin/bash -c "while true; do sleep 3600; done"
  4. > ping test1
  6. PING test1 (172.17.0.2) 56(84) bytes of data.
  7. 64 bytes from test1 (172.17.0.2): icmp_seq=1 ttl=64 time=0.068 ms
  8. 64 bytes from test1 (172.17.0.2): icmp_seq=2 ttl=64 time=0.055 ms
  10. # 注意 link 是单向的， test2 绑定了 test1的地址，但 test1 没有绑定 test2，所以 test1 中无法用 test2 的名字来直接 ping 通

新建桥接网络

还有一种情况也可以实现，即自定义桥接接口，将容器都绑定到同一个桥接接口上，则可互相用名字访问，同一个容器可绑定多个桥接接口。

yum install -y bridge-utils # 安装查看桥接网络设备工具

  1. # 查看本地所有的网络设备
  2. > docker network ls
  4. NETWORK ID          NAME                DRIVER              SCOPE
  5. 89a165910cb3        bridge              bridge              local
  6. 154e5b3bdf2b        host                host                local
  7. fef1a552d8c9        none                null                local
  9. # bridge 类型的就是 docker0，前面提到过，容器的 veth 连接本地的一端默认就是连接到 docker0 上的。

host 与 none 类型的接口并不常用，连接到 none 的容器是独立的命名空间，只有 lo 回环接口。连接到 host 是与本地宿主机共享命名空间，ip a 显示的与宿主机的 ip a 一模一样，可能会有端口冲突问题。

  1. # 新建一个 bridge 接口( -d 表示设备类型)
  2. > docker network create -d bridge my-bridge
  4. > sudo docker network ls
  6. NETWORK ID          NAME                DRIVER              SCOPE
  7. 89a165910cb3        bridge              bridge              local
  8. 154e5b3bdf2b        host                host                local
  9. 91d3b1e839ce        my-bridge           bridge              local
  10. fef1a552d8c9        none                null                local
  12. # 用 brctl 命令查看所有桥接接口（brctl需要yum安装）
  13. > brctl show
  15. bridge name         bridge id           STP enabled     interfaces
  16. br-91d3b1e839ce     8000.0242a89aae58   no              
  17. docker0             8000.024217d2baaa   no              vethd68e0d0
  18.                                                         vethbaa637c
  20. # 可以看到有一个新接口 br-91d3b1e839ce id 和 docker network 中的吻合，它此时没有接口绑定（查看interfaces）。

启动新容器，并绑定新的桥接网络

  1. # 用 --network 指定要绑定的接口，默认会绑定到 docker0 上
  2. > docker run -d --name test3 --network my-bridge centos /bin/bash -c "while true; do sleep 3600; done"
  4. # 查看桥接设备，br-91d3b1e839ce 上已经有接口绑定
  5. > brctl show
  7. bridge name         bridge id           STP enabled     interfaces
  8. br-91d3b1e839ce     8000.0242a89aae58   no              veth030ca97
  9. docker0             8000.024217d2baaa   no              vethd68e0d0
  10.                                                         vethbaa637c
  11. # 将 test2 （现绑定在docker0上）也绑定到新桥接接口上
  12. > sudo docker network connect my-bridge test2
  14. # 可以看到 test2 容器有两个网络接口
  15. > docker exec test2 ip a
  17. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
  18.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  19.     inet 127.0.0.1/8 scope host lo
  20.        valid_lft forever preferred_lft forever
  21. 14: eth0@if15: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
  22.     link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  23.     inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
  24.        valid_lft forever preferred_lft forever
  25. 19: eth1@if20: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
  26.     link/ether 02:42:ac:12:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
  27.     inet 172.18.0.3/16 brd 172.18.255.255 scope global eth1
  28.        valid_lft forever preferred_lft forever
  30. # 连接在同一自定义桥接接口上的两个容器可以通过名字互ping通
  31. > docker exec test2  ping test3
  33. PING test3 (172.18.0.2) 56(84) bytes of data.
  34. 64 bytes from test3.my-bradge (172.18.0.2): icmp_seq=1 ttl=64 time=0.048 ms
  35. 64 bytes from test3.my-bradge (172.18.0.2): icmp_seq=2 ttl=64 time=0.061 ms

端口映射

需求：启动一个nginx容器，映射到本地的 80 端口，使访问本地 80 端口时可以转发到容器中的 nginx 进行处理

  1. > docker pull nginx
  2. > docker run --name web -d -p 80:80 nginx 
  3. # -d 后台运行
  4. # -p 端口映射到本地。第一个 80 是容器中的 80 端口，第二个是指映射到本地的 80 端口
  6. > curl 127.0.0.1
  8. <title>Welcome to nginx!</title>

多机容器通信

etcd + docker overlay 网络

Docker 持久化数据存储

需求：启动一个 mysql 容器，但是数据表/数据不想因容器的停止删除而消失。

mysql 默认挂载的匿名卷

  1. ...
  3. VOLUME /var/lib/mysql
  5. ...
  7. EXPOSE 3306
  8. CMD ["mysqld"]
VOLUME 即把容器中 /var/lib/mysql 目录挂载到宿主机的匿名卷下，实现数据持久化。具体位置因 docker 版本不同而改变。当前测试环境下，docker 会把匿名卷默认绑定到 /var/lib/docker/volumes/ 下。

  1. # 启动一个 mysql 容器，指定 root 密码为 123（-e MYSQL_ROOT_PASSWORD=123）
  2. > docker run -d -e MYSQL_ROOT_PASSWORD=123 mysql
  4. # 查看本地 volume
  5. > docker volume ls
  7. DRIVER              VOLUME NAME
  8. local               3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c
  10. # 查看 volume 详细信息
  11. > docker volume inspect 3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c
  13. [
  14.     {
  15.         "CreatedAt": "2020-09-06T11:29:42+08:00",
  16.         "Driver": "local",
  17.         "Labels": null,
  18.         "Mountpoint": "/var/lib/docker/volumes/3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c/_data",
  19.         "Name": "3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c",
  20.         "Options": null,
  21.         "Scope": "local"
  22.     }
  23. ]
  25. # 根据 Mountpoint 可以看到容器数据实际挂在到了本地的 /var/lib/docker/volumes/3472...
  27. # 停止删除容器后，docker volume 不会被删除。
  28. > docker volume rm 3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c

假如有一个 mysql 容器，生成了持久化数据，被停止删除后，第二个新的 mysql 容器想使用之前的数据，就要指定挂载位置。

  1. # 先去 mysql dockerfile 中了解到， volumn 挂载目录是 /var/lib/mysql
  2. # 然后指定已有的数据卷作为挂载目录
  3. docker run -d -v 3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123 mysql

这样就会发现，匿名卷名字太长，也没有辨识度，所以最好在一开始就指定 -v new_name ，当发现 new_name 不存在，就会将 new_name 作为匿名卷名。

  1. # 启动 mysql 容器1，指定挂载目录名为 mysql
  2. > docker run -d -v mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123 mysql
  4. > docker volume ls
  5. DRIVER              VOLUME NAME
  6. local               mysql
  8. > docker volume inspect mysql
  9. [
  10.     {
  11.         "CreatedAt": "2020-09-06T12:15:11+08:00",
  12.         "Driver": "local",
  13.         "Labels": null,
  14.         "Mountpoint": "/var/lib/docker/volumes/mysql/_data",
  15.         "Name": "mysql",
  16.         "Options": null,
  17.         "Scope": "local"
  18.     }
  19. ]
  21. # 进行建库建表插入数据等等操作后...
  23. # 启动 mysql 容器2，使用之前的数据
  24. > docker run --name mysql2 -d -v mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123 mysql

Docker Compose

为什么要使用 docker compose

部署 WordPress 

  1. # 启动 mysql 
  2. docker run -d --name mysql -v mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123 -e MYSQL_DATABASE=wordpress mysql
  4. #启动 wordpress
  5. docker run -d -e WORDPRESS_DB_HOST=mysql:3306 --link mysql -p 8080:80 wordpress

当一个 app 依赖太多容器的时候，在部署/管理/停止都很难维护，如果能将 app 依赖的容器分组，统一管理就很方便，Docker Compose 登场。

  • docker compose 是一个工具
  • 这个工具可以通过一个 yml 文件定义多容器的 docker 应用
  • 通过一条命令就可以根据 yml 文件的定义去创建或者管理多个容器

docker compose 三大概念

Services

  1. services:
  2.     db:                                 # 容器的名字
  3.         image: mysql:latest             # 依赖外部镜像mysql
  4.         volumes:
  5.             - "db-data:/var/lib/mysql"   # 相当于 -v
  6.         network:
  7.             - new-bridge                    # 相当于 --network
  1. services:
  2.     worker:
  3.         build: ./worker
  4.         links:                  # 通常不会这样使用，仅限于有依赖外部容器时
  5.             - db
  6.             - redis
  7.         network:
  8.             - new-bridge

Volume

  1. volumes:
  2.     db-data:
  4. # 等于运行语句：docker volume create db-data

Network

  1. networks:
  2.     new-bridge:
  3.         driver: bridge
  4.     other-bridge:
  5.         driver: bridge
  7. # 等于运行语句：docker network create -d bridge new-bridge

通过 docker compose 部署 WordPress

不同版本的 copmpse 对应的 version 与 yml 语法不同，详见 http://docs.docker.com/compose/compose-file/#upgrading

  1. # docker-compose.yml
  3. version: "3.1"  
  4. services:
  6.     wordpress:
  7.         image: wordpress
  8.         ports:
  9.             - 8080:80
  10.         environment:
  11.             WORDPRESS_DB_HOST: mysql
  12.             WORDPRESS_DB_PASSWORD: root
  13.         networks:
  14.             - new_bridge
  16.     mysql:
  17.         image: mysql
  18.         environment:
  19.           MYSQL_DATABASE: wordpress
  20.           MYSQL_PASSWORD: 123
  21.         volumes:
  22.           - db_data:/var/lib/mysql
  23.         networks:
  24.             - new_bridge
  26. volumes:
  27.     db_data:
  29. networks:
  30.     new_bridge:
  31.         driver: bridge

启动

windows 与 mac 默认已经安装了docker-compose，linux 需要手动下载安装。

# linux
> sudo curl -L "https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 授权
> chmod 777 /usr/local/bin/docker-compose

  1. # 自动在当前目录寻找名为 docker-compose.yml 的配置文件来启动容器和安装服务。
  2. > docker-compose up
  4. # 名字不为默认的 docker-compose.yml 的配置文件要指定
  5. > docker-compose -f xxx.yml up

开始 & 停止 & 停止并删除 & 进入容器

  1. # 查看所有docker-compose服务
  2. > docker-compose ps
  3. > docker-compose ps -d      # 后台
  5. # 停止
  6. > docker-compose stop
  8. # 开始 
  9. > docker-compose start
  11. # 停止并删除
  12. > docker-compose down
  14. # 进入容器
  15. > docker-compose exec mysql bash

Swarm 集群

相关概念

Swarm在调度(scheduler)节点（leader节点）运行容器的时候，会根据指定的策略来计算最适合运行容器的节点，目前支持的策略有：spread, binpack, random.

相关命令

  1. docker swarm：集群管理，子命令有init, join, leave, update。（docker swarm --help查看帮助）
  3. docker service：服务创建，子命令有create, inspect, update, remove, tasks。（docker service--help查看帮助）
  5. docker node：节点管理，子命令有accept, promote, demote, inspect, update, tasks, ls, rm。（docker node --help查看帮助）

部署

为了方便学习和实验，环境可以使用 play with docker ，缺点是环境只能保存4小时

准备环境

IP：192.168.0.1 主机名：manager 担任角色：swarm manager
IP：192.168.0.2 主机名：node1 担任角色：swarm node
IP：192.168.0.3 主机名：node2 担任角色：swarm node

初始化 manager

  1. # manager
  2. > docker swarm init --advertise-addr 192.168.0.1
  4. # 提示
  5. Swarm initialized: current node (nndlldwxemn7du1hjxzq33myp) is now a manager.
  7. To add a worker to this swarm, run the following command:
  9.     docker swarm join --token SWMTKN-1-2gmziwwne7h4tfbt4eh4j3z5x7fa9r9gtg53pe1a1ffg1wszu1-0bamqmlqejn48ncp5ghk6gpns 192.168.0.1:2377
  11. To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

部署 work 节点

根据提示，如果要部署 work 节点，就在 work 节点上运行

  1. docker swarm join --token SWMTKN-1-2gmziwwne7h4tfbt4eh4j3z5x7fa9r9gtg53pe1a1ffg1wszu1-0bamqmlqejn48ncp5ghk6gpns 192.168.0.1:2377
  1. # 节点1
  2. > docker swarm join --token SWMTKN-1-2gmziwwne7h4tfbt4eh4j3z5x7fa9r9gtg53pe1a1ffg1wszu1-0bamqmlqejn48ncp5ghk6gpns 192.168.0.1:2377
  3. This node joined a swarm as a worker.
  5. # 节点2
  6. > docker swarm join --token SWMTKN-1-2gmziwwne7h4tfbt4eh4j3z5x7fa9r9gtg53pe1a1ffg1wszu1-0bamqmlqejn48ncp5ghk6gpns 192.168.0.1:2377
  7. This node joined a swarm as a worker.

在 manager 上查看所有节点

注意 docker node ls 只能在 manager 中运行，查看

  1. > docker node ls
  3. ID                            HOSTNAME    STATUS     AVAILABILITY    MANAGER STATUS      ENGINE VERSION
  4. nndlldwxemn7du1hjxzq33myp *   node1       Ready      Active          Leader              19.03.11
  5. ghcm5w5mtxmscmh1eauz988tt     node2       Ready      Active                              19.03.11
  6. tecycccl80lsub2maw7fyt0jp     node3       Ready      Active                              19.03.11

Service

创建 Service

用 swarm 创建容器，就是创建 Service，因为 swarm 会根据指定的策略来计算最适合运行容器的节点，所以不能用 docker run 来随便启一个容器，要用 swarm 命令来创建Service（容器）

  1. > docker service create --name mysql -d -e MYSQL_ROOT_PASSWORD=123 mysql

查看 Service 信息

可以查看 Service 状态、运行在哪台服务器上

  1. > docker service ps mysql           # --name 指定的 service 名
  3. ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE            ERROR               PORTS
  4. d5m5hnjsfk7e        mysql.1             mysql:latest        node1               Running             Running 57 seconds ago
  6. # 服务跑在 node1 上

水平扩展 sevice

  1. # 水平扩展 3 个 mysql 服务
  2. > docker service scale=3
  1. > docker service ls
  3. ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
  4. 9sgbsqhez1j6        mysql               replicated          0/1                 mysql:latest

删除 Service

  1. docker service rm mysql

部署 wordpress

创建 overlay 网络

  1. # manager
  2. > docker network create -d overlay demo
  4. # manager 查看网络
  5. > docker network ls
  7. NETWORK ID          NAME                DRIVER              SCOPE
  8. 4deb8704d751        bridge              bridge              local
  9. xmr31rtdnhqv        demo                overlay             swarm
  10. fae16beabc0f        docker_gwbridge     bridge              local
  11. 88e0da999c0d        host                host                local
  12. 63gq7lykqe20        ingress             overlay             swarm
  13. b1b0a7aa9ea7        none                null                local
  15. # node1 & node2 查看网络
  16. > docker network ls
  18. NETWORK ID          NAME                DRIVER              SCOPE
  19. 4deb8704d751        bridge              bridge              local
  20. fae16beabc0f        docker_gwbridge     bridge              local
  21. 88e0da999c0d        host                host                local
  22. 63gq7lykqe20        ingress             overlay             swarm
  23. b1b0a7aa9ea7        none                null                local

在 manager 上创建的 overlay 并不会同步到其他节点上。

创建 mysql 服务

  1. # manager
  2. > docker service create --name mysql --env MYSQL_ROOT_PASSWORD=123 --env MYSQL_DATABASE=wordpress --network demo --mount type=volume,source=mysql-data,destination=/var/lib/mysql mysql

注意用 service 创建的服务，以前的 docker run -e xxx -v xxx 中设置环境变量用 -e 就要变成 --env ，设置卷使用的 -v mysql-data:/var/lib/mysql 要变成 --mount type=volume,source=mysql-data,destination=/var/lib/mysql

创建 wordpress 服务

  1. # manager
  2. > docker service create --name wordpress -p 80:80 --network=demo --env WORDPRESS_DB_HOST=mysql --env WORDPRESS_DB_PASSWORD=123 wordpress

访问网站

manager_ip:80   ok
node1_ip:80     ok
node2_ip:80     ok

查看各个节点的网络

  1. # manager 查看网络
  2. > docker network ls
  4. NETWORK ID          NAME                DRIVER              SCOPE
  5. 4deb8704d751        bridge              bridge              local
  6. xmr31rtdnhqv        demo                overlay             swarm
  7. fae16beabc0f        docker_gwbridge     bridge              local
  8. 88e0da999c0d        host                host                local
  9. 63gq7lykqe20        ingress             overlay             swarm
  10. b1b0a7aa9ea7        none                null                local
  12. # node1
  13. > docker network ls
  15. NETWORK ID          NAME                DRIVER              SCOPE
  16. 4deb8704d751        bridge              bridge              local
  17. xmr31rtdnhqv        demo                overlay             swarm
  18. fae16beabc0f        docker_gwbridge     bridge              local
  19. 88e0da999c0d        host                host                local
  20. 63gq7lykqe20        ingress             overlay             swarm
  21. b1b0a7aa9ea7        none                null                local
  23. # node2
  24. > docker network ls
  26. NETWORK ID          NAME                DRIVER              SCOPE
  27. ca3d7f954ec2        bridge              bridge              local
  28. 9974b890ab6e        docker_gwbridge     bridge              local
  29. 7ccd52d74607        host                host                local
  30. 63gq7lykqe20        ingress             overlay             swarm
  31. 03f3304afa87        none                null                local

manager 与 node1 同步了 名为 demo 的 overlay 网络（mysql 与 wordpress 分别运行在 manager 与 node1 上），而 node2 没有同步 overlay。但是三个节点服务器都可以正常通过各自 ip:80 访问 wordpress 网站。那么 swarm 集群的通信原理是什么呢？

RoutingMesh - Ingress 网络

以请求 3个节点中没有任何服务的 node3节点为例，node3 中没有任何服务，node1 & node2 中启动了水平扩展的 wordpress 服务，node1 中有 mysql 服务。

  1. > iptables -nL -t mangle    # 查看 iptabls 的转发规则
  3. target     prot opt source               destination         
  4. DNAT       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:80 to:172.20.0.2:80
  6. > ip a
  8. docker_gwbridge: 
  9.     inet 172.20.0.1/16
  1. > nsenter --net=/var/run/docker/netns/ingress_sbox  # 进入命名空间
  3. > iptables -nL -t mangle
  5. target     prot opt source               destination         
  6. MARK       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:80 MARK set 0x10b
  8. > ipvsadm -l
  10. IP Virtual Server version 1.2.1 (size=4096)
  11. Prot LocalAddress:Port Scheduler Flags
  12.   -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
  13. FWM  271 rr
  14.   -> 10.0.0.27:0                  Masq    1      0          0         
  16.   -> 10.0.0.28:0                  Masq    1      0          0

DNS + VIP + iptables + LVS

  1. > nslookup mysql    # 10.0.0.1
  3. # 查看真实转发 ip 
  4. > nslookup tasks.mysql      # 列出所有 mysql 所在节点的虚拟 ip

总结：
容器与容器之间通过 overlay 网络实现通信
服务与服务间通过 Ingress 实现通信

swarm + docker compose 部署

docker-compose.yml

docker compose 要运行在 swarm 上，有一个重要的配置项：deploy。该配置项是 docker compose 3.0以上版本才支持。deploy 重点参数：

  1. # docker-compose.yml
  3. version: "3.1"  
  4. services:
  6.     web:
  7.         image: wordpress
  8.         ports:
  9.             - 8080:80
  10.         environment:
  11.             WORDPRESS_DB_HOST: mysql
  12.             WORDPRESS_DB_PASSWORD: root
  13.         networks:
  14.             - new_network
  15.         deploy:
  16.             model:replicated
  17.             replicas:3
  19.     mysql:
  20.         image: mysql
  21.         environment:
  22.           MYSQL_DATABASE: wordpress
  23.           MYSQL_PASSWORD: 123
  24.         volumes:
  25.           - db_data:/var/lib/mysql
  26.         networks:
  27.             - new_network
  28.         deploy:
  29.             model:global
  30.             placement:
  31.                 constrints:
  32.                     - node.role == manager
  34. volumes:
  35.     db_data:
  37. networks:
  38.     new_network:
  39.         driver: overlay

docker stacks

在 swarm 上用 compose 安装服务要使用 docker stacks 命令

  1. docker stack deploy name --compose-file=docker-compose.yml

Dockerfile

1. From

  1. FROM scratch    // 无base image，制作的就是一个base image
  2. FROM centos     // 使用 centos 作为 base image
  3. FROM ubuntu:14.04

注意，最好使用官方的 image 作为 base image

2. Label

  1. LABEL maintainer = "zy@gmail.com"
  2. LABEL version = "1.0"
  3. LABEL description = "this is description"

3. Run

  1. RUN yum update && yum -y install vim \
  2.     python-dev

4. Workdir

  1. WORKDIR /test       # 如果没有该目录则会自动创建
  2. WORKDIR demo
  3. RUN pwd             # 结合上两条，应该输出 /test/demo

注意最好不要使用 RUN cd，尽量使用绝对目录。

5. Add & Copy

  1. # 当前文件夹下有一个文件 hello.php，和一个 test.tar.gz
  2. ADD hello.php /         # 添加到image的跟目录
  3. ADD test.tar.gz /       # 解压缩 test.tar.gz 并添加到跟目录
  4. WORKDIR /root
  5. ADD hello.php test/     # 文件会被放在：/root/test/hello.php
  7. COPY hello.php /        # copy 的使用方式与 add 完全一致

大部分情况下，copy 优于 add。
add 除了有 copy 的功能，还有解压功能
添加远程文件请用 wget 或 curl

6. ENV

  1. ENV MYSQL_VERSION 5.6   
  2. RUN apt-get install -y mysql-server = "${MYSQL_VERSION}"

尽量多用 ENV ，可以增加可维护性

7. CMD

  1. CMD echo "hello docker"
  3. > docker run image            # hello docker
  4. > docker run image /bin/bash  # 不会输出hello docker，因为指定了其他命令

如果docker run 指定了其他命令，CMD命令将被忽略
如果定义了多个 CMD ，则只有最后一个会被执行

8. Entrypoint

  1. COPY entrypoint.sh /usr/local/bin/
  2. ENTRYPOINT ["entrypoint.sh"]
  4. EXPOSR 27017
  5. CMD ["mongod"]

Entrypoint 不会被忽略，一定会被执行

9. Entrypoint + CMD 实现启动容器时传参数

  1. FROM ubuntu
  2. RUN apt-get install -y stress   
  3. ENTRYPOINT ["/usr/bin/stress"]      # 启动时一定会运行的命令
  4. CMD []                              # 启动后执行，空则会收集参数
  7. > docker run -it xxx/stress --vm 1 --verbose

10. VOLUME

  1. VOLUME /var/lib/mysql

内网私有docker仓库搭建

1. 前期准备

2. 搭建 docker 仓库

  1. docker run -d -p 5000:5000 --restart=always --name registry registry:2

3. 用户主机配置信任私有仓库

  1. > vim /etc/docker/daemo.json
  3.     {
  4.       "insecure-registries" : ["196.168.0.1:5000"]
  5.     }
  7. > vim /etc/systemd/system/docker.service.d
  8.     EnvironmentFile=/etc/docker/daemo.json      # 新加一行环境文件
  10. > systemctl restart docker  # 重启docker

4. 用户主机创建镜像并推送

  1. docker build -t 196.168.0.1:5000/test .
  2. docker push 196.168.0.1:5000/test

命令

docker pull

  1. > docker pull ubuntu:14.04

docker image ls / docker images

  1. > docker image ls 
  3. REPOSITORY    TAG     IMAGE ID       CREATED         SIZE
  4. hello-world   latest  bf756fb1ae65   8 months ago    13.3kB

docker image rm image_id / docker rmi image_id

  1. docker image rm bf756fb1ae65

docker image build / docker build

  1. // vim Dockerfile
  2. From centos
  3. Run yum -y install vim
  5. // -t 标签 . 表示在当前路径寻找 dockerfile
  6. > docker image build -t centos_vim .

docker image push / docker push

  1. docker push cnoctopus/hello-world:latest
  • 注意，镜像的 tag 必须以用户名/开头，不然没有权限。
  • 不推荐直接推自己 build 的 image，因为会有安全性问题。建议在 docker hub 绑定 github 仓库，然后提交 dockerfile 到 github，docker会自动从绑定的 github 仓库拉取 dockerfile 并生成 image，其他人可以看到 dockerfile，image又是官方生成，安全性提高。

docker container commit / docker commit

  1. docker container commit container_name image_name:tag

docker run

  1. docker run hello-world
  2. docker run -d hello-world       # -d 在后台运行
  1. # 容器使用的总内存数 = memory + memory-swap
  2. # memory-swap 默认等于 memory 的大小
  3. docker run --memory=200M hello-world        # 即总可用内存为400M
  1. docker run --name test -e REDIS_HOST=196.168.0.1 centos ...
  2. # 进入容器，使用 env 命令可以查看所有环境变量
  1. # 以 nginx 为例，启动一个 nginx 容器
  2. > docker run --name nginx -d -p 80:80 nginx
  4. # 查看是否正常运行
  5. > curl 127.0.0.1
  7. <title>Welcome to nginx!</title>
  9. # 查看 nginx dockerfile 可知，index.html 等网站文件是放在 /usr/share/nginx/html/ 中，进入 bash 内部查看：
  10. > docker exec -it nginx /bin/bash
  11. > ls /usr/share/nginx/html/
  13. 50x.html  index.html
  15. # 已知开发目录在本地的 /root/tmp/ ，通过 -v 来将目录挂载到 容器的 /usr/share/nginx/html/ 实现数据同步。
  16. > docker run --name nginx -v /root/tmp:/usr/share/nginx/html -d -p 80:80 nginx
  17. > ls /root/tmp      # 空
  18. > docker exec nginx ls /usr/share/nginx/html    # 空
  20. # 所以，挂载后，本地目录会覆盖容器目录，因为本地目录原本是空的，那么容器中的目标目录也会用本地同步，最后变成空目录。
  22. > curl 127.0.0.1
  23. <title>403 Forbidden</title>
  25. # 在本地新建 index.html，输出 hello world
  26. > echo "hello world" > /root/tmp/index.html
  28. # 查看容器挂载的目录
  29. > docker exec nginx ls /usr/share/nginx/html
  30. index.html
  32. > curl 127.0.0.1
  33. hello world

docker exec

  1. docker exec -it container_id /bin/bash  # 交互式运行/bin/bash进入容器bash
  3. docker exec -it container_id python # 交互式进入容器运行python命令
  5. docker exec -it container_id ip a   # 查看运行容器的ip

docker container ls -a / docker ps -a

  1. // 只列出当前在运行容器
  2. docker container ls
  4. // 在运行与已退出容器全部列出
  5. docker container ls -a
  8. CONTAINER ID   IMAGE         COMMAND   CREATED         STATUS  ...
  9. ca8993563d84   hello-world   "/hello"  a minute ago    Exited  ...

docker container stop / docker stop

  1. docker container stop container_id

docker container rm container_id / docker rm container_id

  1. docker container rm ca8993563d84
  1. docker rm -f ca8993563d84
  1. docker rm $(docker container ls -f "status=exited" -q)

docker inspect

  1. docker inspect container_id

docker logs

  1. docker logs container_id

docker network ls

  1. > docker network ls
  3. NETWORK ID          NAME                DRIVER              SCOPE
  4. 89a165910cb3        bridge              bridge              local
  5. 154e5b3bdf2b        host                host                local
  6. fef1a552d8c9        none                null                local

docker network inspect

  1. > docker network inspect 89a165910cb3       # 网络id
  3. [
  4.     {
  5.         "Name": "bridge",
  6.         "Id": "89a165910cb3bb6dab7a33d922f72204b046bcb11e60c19387661272b84a7ed6",
  7.         "Created": "2020-09-01T11:44:23.590643816+08:00",
  8.         "Scope": "local",
  9.         "Driver": "bridge",
  10.         "EnableIPv6": false,
  11.         "IPAM": {
  12.             "Driver": "default",
  13.             "Options": null,
  14.             "Config": [
  15.                 {
  16.                     "Subnet": "172.17.0.0/16"
  17.                 }
  18.             ]
  19.         },
  20.         "Internal": false,
  21.         "Attachable": false,
  22.         "Ingress": false,
  23.         "ConfigFrom": {
  24.             "Network": ""
  25.         },
  26.         "ConfigOnly": false,
  27.         "Containers": {
  28.             "14a7a82f5351a018467e9af926640618569b38ebc874832810ca15f8d14de395": {
  29.                 "Name": "test1",
  30.                 "EndpointID": "f91fecf0c4fd3d6014bc167101e7e65cb3dfbe17f4c7901273a2f2be7553c143",
  31.                 "MacAddress": "02:42:ac:11:00:02",
  32.                 "IPv4Address": "172.17.0.2/16",
  33.                 "IPv6Address": ""
  34.             }
  35.         },
  36.         "Options": {
  37.             "com.docker.network.bridge.default_bridge": "true",
  38.             "com.docker.network.bridge.enable_icc": "true",
  39.             "com.docker.network.bridge.enable_ip_masquerade": "true",
  40.             "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
  41.             "com.docker.network.bridge.name": "docker0",
  42.             "com.docker.network.driver.mtu": "1500"
  43.         },
  44.         "Labels": {}
  45.     }
  46. ]

docker volume ls

  1. > docker volume ls
  3. DRIVER              VOLUME NAME
  4. local               3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c

docker volume inspect

  1. # docker volume inspect volume_id
  2. > docker volume inspect 3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c
  4. [
  5.     {
  6.         "CreatedAt": "2020-09-06T11:29:42+08:00",
  7.         "Driver": "local",
  8.         "Labels": null,
  9.         "Mountpoint": "/var/lib/docker/volumes/3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c/_data",
  10.         "Name": "3472d769f942f7de34a8d344553584df900572252807996044d5d3d8d4c2fb3c",
  11.         "Options": null,
  12.         "Scope": "local"
  13.     }
  14. ]
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注