Docker 优化与拓展：数据卷、安全与容器编排工具

目次
六. Docker 数据卷管理及优化
1. 为什么要用数据卷
2. bind mount 数据卷
3. docker managed 数据卷
 4. 数据卷容器（Data Volume Container）
5. 备份与迁徙数据卷
七. Docker 的安全优化
1. 定名空隔断离的安全
2. 控制组资源控制的安全
3. 内核本领机制
4. Docker服务端防护
5. Docker的资源限定
5.1. 限定cpu利用
5.2. 限定内存利用
5.3. 限定docker的磁盘io
6. Docker的安全加固
6.1. Docker默认隔离性
6.2. 办理Docker的默认隔离性
6.3. 容器特权
6.4. 容器特权的白名单
八. 容器编排工具Docker Compose
1. Docker Compose 概述
2.告急功能
3.工作原理
5.Docker Compose 中的管理层
6. Docker Compose 的常用下令参数
7. Docker Compose 的yml文件
8. 服务（services）
9. 网络（networks）
10. 存储卷（volumes）
11. 企业示例

---

六. Docker 数据卷管理及优化

Docker 数据卷是一个可供容器利用的特殊目次，它绕过了容器的文件体系，直接将数据存储在宿主机 上。 如许可以实现以下几个告急的目的： 数据恒久化：纵然容器被删除或重新创建，数据卷中的数据仍然存在，不会丢失。 数据共享：多个容器可以同时挂载同一个数据卷，实现数据的共享和交互。 独立于容器生命周期：数据卷的生命周期独立于容器，不受容器的启动、制止和删除的影响。
1. 为什么要用数据卷

docker分层文件体系

• 性能差
  
• 生命周期与容器雷同
  

docker数据卷

• mount到主机中，绕开分层文件体系
  
• 和主机磁盘性能雷同，容器删除后依然保存
  
• 仅限当地磁盘，不能随容器迁徙
  

docker提供了两种卷

• bind mount
  
• docker managed volume
  

2. bind mount 数据卷

是将主机上的目次或文件mount到容器里。 利用直观高效，易于明白。 利用 -v 选项指定路径，格式 :-v选项指定的路径，假如不存在，挂载时会主动创建。

1. [root@node9 ~]# mkdir /lee
2. [root@node9 ~]# touch /lee/leefile{1..5}
3. [root@node9 ~]# ls /lee
4. leefile1  leefile2  leefile3  leefile4  leefile5
5. [root@node9 ~]# docker run -it --rm --name test \
6. > -v /lee:/data1:rw \
7. > -v /passwd:/data2/passwd busybox
8. / # ls
9. bin    data2  etc    lib    proc   sys    usr
10. data1  dev    home   lib64  root   tmp    var
11. / # ls data1
12. leefile1  leefile2  leefile3  leefile4  leefile5
13. / # touch data
14. data1/  data2/
15. / # touch data1/leefile6
16. / # ls /data1/
17. leefile1  leefile2  leefile3  leefile4  leefile5  leefile6

复制代码

3. docker managed 数据卷

• bind mount必须指定host文件体系路径，限定了移植性
  
• docker managed volume 不必要指定mount源，docker主动为容器创建数据卷目次
  
• 默认创建的数据卷目次都在 /var/lib/docker/volumes 中
  
• 假如挂载时指向容器内已有的目次，原有数据会被复制到volume中
  

1. [root@node9 volumes]# docker run -d --name mysql -e MYSQL_ROOT_PASSWORD='123' mysql:5.7
2. [root@node9 ~]# docker inspect mysql
3. "Mounts": [
4.             {
5.                 "Type": "volume",
6.                 "Name": "f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe",
7.                 "Source": "/var/lib/docker/volumes/f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe/_data",
8. [root@node9 ~]# ll /var/lib/docker/volumes/f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe/_data
9. total 188484
10. -rw-r----- 1 systemd-coredump input       56 Aug 30 23:49 auto.cnf
11. -rw------- 1 systemd-coredump input     1680 Aug 30 23:49 ca-key.pem
12. -rw-r--r-- 1 systemd-coredump input     1112 Aug 30 23:49 ca.pem
13. -rw-r--r-- 1 systemd-coredump input     1112 Aug 30 23:49 client-cert.pem
14. -rw------- 1 systemd-coredump input     1676 Aug 30 23:49 client-key.pem
15. -rw-r----- 1 systemd-coredump input     1318 Aug 30 23:50 ib_buffer_pool
16. -rw-r----- 1 systemd-coredump input 79691776 Aug 30 23:50 ibdata1
17. -rw-r----- 1 systemd-coredump input 50331648 Aug 30 23:50 ib_logfile0
18. -rw-r----- 1 systemd-coredump input 50331648 Aug 30 23:49 ib_logfile1
19. -rw-r----- 1 systemd-coredump input 12582912 Aug 30 23:50 ibtmp1
20. drwxr-x--- 2 systemd-coredump input     4096 Aug 30 23:50 mysql
21. lrwxrwxrwx 1 systemd-coredump input       27 Aug 30 23:50 mysql.sock -> /var/run/mysqld/mysqld.sock
22. drwxr-x--- 2 systemd-coredump input     8192 Aug 30 23:50 performance_schema
23. -rw------- 1 systemd-coredump input     1680 Aug 30 23:49 private_key.pem
24. -rw-r--r-- 1 systemd-coredump input      452 Aug 30 23:49 public_key.pem
25. -rw-r--r-- 1 systemd-coredump input     1112 Aug 30 23:49 server-cert.pem
26. -rw------- 1 systemd-coredump input     1680 Aug 30 23:49 server-key.pem
27. drwxr-x--- 2 systemd-coredump input     8192 Aug 30 23:50 sys
28. [root@node9 ~]# docker volume prune
29. WARNING! This will remove anonymous local volumes not used by at least one container.
30. Are you sure you want to continue? [y/N] y
31. Deleted Volumes:
32. d3479e5845a8d1727ab8d720f0559a7e2236d781548881991424912d09092ab0
33. f6b5d1ee9b388015614b4e9dc11d1536f25b24fd58a275c1de8af838e9ecf539
34. 019e1e41fa374c2e8edaa23ff1514f1ce9b18a3996328a494c3d880144c68cdb
35. 0f68c969b16834f2c39dd902da665f1613490effb0f90e2973c959a7e79ca6c3
36. 21462c947587b966ccab7728cf511045ba50fe745c065577894400509444c8d8
37. c4130c67aea4726435b4b4e7238163dd1f61eb10841b5746aa68083e084e0a59
38. 256e17e58358641e4b95929034f07cc96c2d7213c102a1045a3b721a0d857198
39. 42274ca5837354b644b3032b7beca24c40405d2df4f40b764323308b1060f4b8
40. 5b7ef29b670dde13fc187ca9f161daf3816ebd872c8dd36a309526450a74c46c
41. b256294b5a7be64fcfbb424f18e942617c4e5225b910bd2cffc0726d0e05c0d0
42. b6298e6e04b996e95ab337392ee9675f225e6a2407b64abad604e233c2d60738
43. c362eebbe748fa7cb5490eec5658460fb20106781c1325a743fdb5aa14e039a2
45. Total reclaimed space: 497.8MB
46. [root@node9 ~]# ls -l /var/lib/docker/volumes
47. total 32
48. brw------- 1 root root 253, 0 Aug 30 21:57 backingFsBlockDev
49. drwx-----x 3 root root     19 Aug 30 23:49 f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe
50. -rw------- 1 root root  65536 Aug 30 23:54 metadata.db
52. #临时卷
53. [root@node9 volumes]# touch
54. ad74662b8d6bb6fdcc6e82925ae9942b94bac5f9da4bd52b0a14ac451ae9ef75/_data/leefile
56. #清理未使用的 Docker 数据卷
57. [root@node9 ~]# docker volume prune
59. Note
60. 1. 在执行 docker volume prune 命令之前，请确保你确实不再需要这些数据卷中的数据，因为
61. 该操作是不可逆的，一旦删除数据将无法恢复。
62. 2. 如果有重要的数据存储在数据卷中，建议先进行备份，或者确保数据已经被妥善保存到其他地方。
64. #永久卷
65. #建立数据卷
66. [root@node9 ~]# docker volume create msyqldate
67. msyqldate
69. #查看卷
70. [root@node9 ~]# docker volume ls
71. DRIVER    VOLUME NAME
72. local     f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe
73. local     msyqldate
75. #使用建立的数据卷
76. [root@node9 ~]# docker run -d --rm --name mysql -e MYSQL_ROOT_PASSWORD='123' -v msyqldate:/var/lib/mysql mysql:5.7
77. cd5f6a15712a5b005481f7697da16389b77984e4dbe3e3de022469290e4ef935
78. [root@node9 ~]# docker inspect mysql
79. "Mounts": [
80.             {
81.                 "Type": "volume",
82.                 "Name": "msyqldate",
83.                 "Source": "/var/lib/docker/volumes/msyqldate/_data",
84.                 "Destination": "/var/lib/mysql",
85.                 "Driver": "local",
86.                 "Mode": "z",
87.                 "RW": true,
88.                 "Propagation": ""
89.             }
90.         ],
91. [root@node9 ~]# cd /var/lib/docker/volumes/msyqldate/_data
92. [root@node9 _data]# ls
93. auto.cnf         ibdata1      performance_schema
94. ca-key.pem       ib_logfile0  private_key.pem
95. ca.pem           ib_logfile1  public_key.pem
96. client-cert.pem  ibtmp1       server-cert.pem
97. client-key.pem   mysql        server-key.pem
98. ib_buffer_pool   mysql.sock   sys
99. [root@node9 _data]# docker stop mysql
100. mysql
101. [root@node9 _data]# docker ps -a
102. CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
103. [root@node9 _data]# ll /var/lib/docker/volumes/msyqldate/_data
104. total 176196
105. -rw-r----- 1 systemd-coredump input       56 Aug 31 00:06 auto.cnf
106. -rw------- 1 systemd-coredump input     1680 Aug 31 00:06 ca-key.pem
107. -rw-r--r-- 1 systemd-coredump input     1112 Aug 31 00:06 ca.pem
109. #管理数据卷
110. [root@node9 ~]# docker volume ls
111. DRIVER    VOLUME NAME
112. local     f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe
113. local     msyqldate
114. [root@node9 ~]# docker volume rm f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe
115. f1b497c3d2f4a933c02fa90851c80a38304bceb584f501f4e2621fc4b94679fe
116. [root@node9 ~]# docker volume ls
117. DRIVER    VOLUME NAME
118. local     msyqldate

复制代码

 4. 数据卷容器（Data Volume Container）

数据卷容器（Data Volume Container）是 Docker 中一种特殊的容器，告急用于方便地在多个容器之间共享数据卷。

1. #建立数据卷容器
2. [root@node9 ~]# docker volume create test
3. [root@node9 ~]# docker run -it --name test1 \
4. -v test1:/etc busybox
5. / # cd etc/
6. /etc # ls
7. /etc # exit
9. #重新打开一个会话,使用数据卷容器
10. [root@node9 ~]# cd /var/lib/docker/volumes/test1/_data/
11. [root@node9 _data]# ls
12. [root@node9 _data]# touch zhuzhuxia

复制代码

5. 备份与迁徙数据卷

1. #备份数据卷
2. #建立容器并指定使用卷到要备份的容器
3. [root@node9 ~]# docker run -it --name test --rm -v test:/data busybox
4. [root@node9 ~]# docker run -it --volumes-from test --rm --name test1 \
5. -v `pwd`:/backup busybox \    #再开一个会话  #把当前目录挂在到容器中用于和容器交互保存要备份的容器
6. tar zcf /backup/data1.tar.gz /data1 #备份数据到本地
8. #数据恢复
9. docker run -it --name test -v leevol1:/data1 -v `pwd`:/backup busybox /bin/sh -
10. c "tar zxf /backup/data1.tar.gz;/bin/sh"
11. / # ls
12. backup data1 etc lib proc sys usr
13. bin dev home lib64 root tmp var
14. / # cd data1/ #查看数据迁移情况
15. /data1 # ls
16. index.html leefile1

复制代码

七. Docker 的安全优化

Docker容器的安全性，很洪流平上依靠于Linux体系自身 评估Docker的安全性时，告急思量以下几个方面：

• Linux内核的定名空间机制提供的容器隔离安全
  
• Linux控制组机制对容器资源的控制本领安全。
  
• Linux内核的本领机制所带来的利用权限安全
  
• Docker步调（特殊是服务端）自己的抗攻击性。
  
• 其他安全加强机制对容器安全性的影响
  

1. #在rhel9中默认使用cgroup-v2 但是cgroup-v2中不利于观察docker的资源限制情况，所以推荐使用cgroup-v1
2. mount -t cgroup2  #没有相关信息就没开
3. [root@node9 ~]#grubby --update-kernel=/boot/vmlinuz-$(uname -r) \
4. --args="systemd.unified_cgroup_hierarchy=0
5. systemd.legacy_systemd_cgroup_controller"   #重启生效

复制代码

1. 定名空隔断离的安全

当docker run启动一个容器时，Docker将在背景为容器创建一个独立的定名空间。定名空间提供了最根本也最直接的隔离。 与捏造机方式相比，通过Linux namespace来实现的隔离不是那么彻底。 容器只是运行在宿主机上的一种特殊的历程，那么多个容器之间利用的就照旧同一个宿主机的利用体系内核。 在 Linux 内核中，有许多资源和对象是不能被 Namespace 化的，好比：磁盘等等。

1. [root@node9 ~]# docker run -d --name web1 nginx
2. 3c6b649a200fc56afafe9f47494903fe56e71cabcd534d6c9e6f8b5854f29cac
3. [root@node9 ~]# docker inspect web1 | grep Pid
4.             "Pid": 1733,
5.             "PidMode": "",
6.             "PidsLimit": null,
8. [root@node9 ~]# cd /proc/1733/ns/ #进程的namespace
9. [root@node9 ns]# ls
10. cgroup ipc mnt net pid pid_for_children time time_for_children user uts
11. [root@node9 ns]# ls -d /sys/fs/cgroup/memory/docker/3c6b649a200fs省略部分
12. 854f29cac/ #资源隔离信息
13. /sys/fs/cgroup/system.slice/docker-
14. ecb8abbbfc85bf3d62fc82afb3950ab6b6a2e80092738274a233bbb8db0c5ce2.scope
15. /sys/fs/cgroup/system.slice/docker.service
16. /sys/fs/cgroup/system.slice/docker.socket

复制代码

2. 控制组资源控制的安全

• 当docker run启动一个容器时，Docker将在背景为容器创建一个独立的控制组战略聚集。
  
• Linux Cgroups提供了许多有用的特性，确保各容器可以公平地分享主机的内存、CPU、磁盘IO等资源。
  
• 确保当发生在容器内的资源压力不会影响到本田主机体系和其他容器，它在防止拒绝服务攻击（DDoS）方面必不可少
  

1. [root@node9 ~]#  docker run -it --name test busybox #内存资源默认没有被隔离
2. / # free -m
3.               total        used        free      shared  buff/cache   available
4. Mem:           3697         371        2969          10         357        3099
5. Swap:          2072           0        2072
7. / # exit
8. [root@node9 ~]#  free -m
9.                total        used        free      shared  buff/cache   available
10. Mem:            3696         349        2989           9         357        3120
11. Swap:           2071           0        2071

复制代码

3. 内核本领机制

• 本领机制（Capability）是Linux内核一个强大的特性，可以提供细粒度的权限访问控制。
  
• 大部分情况下，容器并不必要“真正的”root权限，容器只必要少数的本领即可。
  
• 默认情况下，Docker接纳“白名单”机制，禁用“必须功能”之外的其他权限。
  

4. Docker服务端防护

• 利用Docker容器的焦点是Docker服务端，确保只有可信的用户才气访问到Docker服务。
  
• 将容器的root用户映射到本田主机上的非root用户，减轻容器和主机之间因权限提拔而引起的安全题目。
  
• 答应Docker 服务端在非root权限下运行，利用安全可靠的子历程来署理实行必要特权权限的利用。这些子历程只答应在特定范围内举行利用。
  

[root@docker ~]# ls -ld /var/lib/docker/ #默认docker是用root用户控制资源的
5. Docker的资源限定

Linux Cgroups 的全称是 Linux Control Group。

• 是限定一个历程组可以大概利用的资源上限，包罗 CPU、内存、磁盘、网络带宽等等。
  
• 对历程举行优先级设置、审计，以及将历程挂起和规复等利用。 Linux Cgroups 给用户袒暴露来的利用接口是文件体系
  
• 它以文件和目次的方式构造在利用体系的 /sys/fs/cgroup 路径下。
  
• 实行此下令查察：mount -t cgroup
  
• 在 /sys/fs/cgroup 下面有许多诸如 cpuset、cpu、 memory 如许的子目次，也叫子体系。
  
• 在每个子体系下面，为每个容器创建一个控制组（即创建一个新目次）。
  
• 控制组下面的资源文件里填上什么值，就靠用户实行 docker run 时的参数指定。
  

5.1. 限定cpu利用

1. #限制cpu的使用量
2. #提前下载镜像，直接拖入。
3. [root@node9 ~]# dcoker run -i ubuntu-latest.tar.gz
4. [root@node9 ~]#  docker run -it --rm --name test \
5. --cpu-period 100000 \ #设置 CPU 周期的长度，单位为微秒（通常为100000，即 100 毫秒）
6. --cpu-quota 20000 ubuntu #设置容器在一个周期内可以使用的 CPU 时间，单位也是微秒。
7. root@5797d76b20f5:/# dd if=/dev/zero of=/dev/null &
8. [1] 8
9. root@5797d76b20f5:/# top
10. top - 11:53:22 up 1 day, 1:58, 0 user, load average: 0.00, 0.00, 0.00
11. Tasks: 3 total, 2 running, 1 sleeping, 0 stopped, 0 zombie
12. %Cpu(s): 4.4 us, 6.0 sy, 0.0 ni, 89.5 id, 0.0 wa, 0.2 hi, 0.0 si, 0.0 st
13. MiB Mem : 3627.1 total, 558.1 free, 899.4 used, 2471.0 buff/cache
14. MiB Swap: 2063.0 total, 2062.0 free, 1.0 used. 2727.7 avail Mem
15. PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
16. 8 root 20 0 2736 1536 1536 R 20.0 0.0 0:00.92 dd
17. #使用cpu的百分比
18. 1 root 20 0 4588 3968 3456 S 0.0 0.1 0:00.03 bash
19. 9 root 20 0 8856 5248 3200 R 0.0 0.1 0:00.00 top
20. #在cgroup中查看docker的资源限制
21. [root@node9 ~]#  cat /sys/fs/cgroup/system.slice/docker-
22. 573150b6c2c90a53f9d75df77455a526ff14e93fb7304674c80307c51882e605.scope/cpu.max
23. 20000 100000
25. #限制cpu的优先级
26. #关闭cpu的核心，当cpu都不空闲下才会出现争抢的情况，为了实验效果我们可以关闭一个cpu核心
27. [root@node9 ~]#  echo 0 > /sys/devices/system/cpu/cpu1/online
28. [root@node9 ~]#  cat /proc/cpuinfo
29. processor : 0
30. vendor_id : GenuineIntel
31. cpu family : 6
32. model : 58
33. model name : Intel(R) Core(TM) i7-3770K CPU @ 3.50GHz
34. stepping : 9
35. microcode : 0x21
36. cpu MHz : 3901.000
37. cache size : 8192 KB
38. physical id : 0
39. siblings : 1
40. core id : 0
41. cpu cores : 1 ##cpu核心数为1
42. apicid : 0
43. initial apicid : 0
44. fpu : yes
45. fpu_exception : yes
46. cpuid level : 13
47. wp : yes
48. flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov
49. pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx rdtscp lm constant_tsc
50. arch_perfmon nopl xtopology tsc_reliable nonstop_tsc cpuid tsc_known_freq pni
51. pclmulqdq ssse3 cx16 pcid sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer aes
52. xsave avx f16c rdrand hypervisor lahf_lm pti ssbd ibrs ibpb stibp fsgsbase
53. tsc_adjust smep arat md_clear flush_l1d arch_capabilities
54. bugs : cpu_meltdown spectre_v1 spectre_v2 spec_store_bypass l1tf mds
55. swapgs itlb_multihit srbds mmio_unknown
56. bogomips : 7802.00
57. clflush size : 64
58. cache_alignment : 64
59. address sizes : 45 bits physical, 48 bits virtual
60. power management:
62. #开启容器并限制资源
63. [root@node9 ~]#  docker run -it --rm --cpu-shares 100 ubuntu #设定cpu优先
64. 级，最大为1024，值越大优先级越高
65. root@dc066aa1a1f0:/# dd if=/dev/zero of=/dev/null &
66. [1] 8
67. root@dc066aa1a1f0:/# top
68. top - 12:16:56 up 1 day, 2:22, 0 user, load average: 1.20, 0.37, 0.20
69. Tasks: 3 total, 2 running, 1 sleeping, 0 stopped, 0 zombie
70. %Cpu(s): 37.3 us, 61.4 sy, 0.0 ni, 0.0 id, 0.0 wa, 1.0 hi, 0.3 si, 0.0 st
71. MiB Mem : 3627.1 total, 502.5 free, 954.5 used, 2471.7 buff/cache
72. MiB Swap: 2063.0 total, 2062.3 free, 0.7 used. 2672.6 avail Mem
73. PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
74. 8 root 20 0 2736 1536 1536 R 3.6 0.0 0:16.74 dd
75. #cpu有限制被限制
76. 1 root 20 0 4588 3968 3456 S 0.0 0.1 0:00.03 bash
77. 9 root 20 0 8856 5248 3200 R 0.0 0.1 0:00.00 top
78. #开启另外一个容器不限制cpu的优先级
79. root@17f8c9d66fde:/# dd if=/dev/zero of=/dev/null &
80. [1] 8
81. root@17f8c9d66fde:/# top
82. top - 12:17:55 up 1 day, 2:23, 0 user, load average: 1.84, 0.70, 0.32
83. Tasks: 3 total, 2 running, 1 sleeping, 0 stopped, 0 zombie
84. %Cpu(s): 36.2 us, 62.1 sy, 0.0 ni, 0.0 id, 0.0 wa, 1.3 hi, 0.3 si, 0.0 st
85. MiB Mem : 3627.1 total, 502.3 free, 954.6 used, 2471.7 buff/cache
86. MiB Swap: 2063.0 total, 2062.3 free, 0.7 used. 2672.5 avail Mem
87. PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
88. 8 root 20 0 2736 1408 1408 R 94.0 0.0 1:09.34 dd
89. #cpu为被限制
90. 1 root 20 0 4588 3968 3456 S 0.0 0.1 0:00.02 bash
91. 9 root 20 0 8848 5248 3200 R 0.0 0.1 0:00.01 top

复制代码

5.2. 限定内存利用

1. #开启容器并限制容器使用内存大小
2. [root@node9 system.slice]# docker run -d --name test --memory 200M --memory-swap 200M nginx
3. #查看容器内存使用限制
4. [root@node9r ~]# cd /sys/fs/cgroup/memory/docker/d09100472de41824bf0省略部分
5. id96b977369dad843740a1e8e599f430/
6. [root@node9 d091004723d4de41824f6b38a7be9b77369dad843740a1e8e599f430]# cat
7. memory.limit_in_bytes
8. 209715200
9. [root@node9 d091004723d4de41824f6b38a7be9977369dad843740a1e8e599f430]# cat
10. memory.memsw.limit_in_bytes
11. 209715200
12. #测试容器内存限制，在容器中我们测试内存限制效果不是很明显，可以利用工具模拟容器在内存中写入数据
14. #需要一个工具提前下载；libcgroup-tools;libcgroup-0.41
15. dnf install *.rpm -y
16. #在系统中/dev/shm这个目录被挂在到内存中
17. [root@node9 ~]# docker run -d --name test --rm --memory 200M --memory-swap 200M nginx
18. f5017485d69b50cf2e294bf6c65fcd5e679002e25bd9b0eaf9149eee2e379eec
19. [root@node9 ~]# docker ps
20. [root@node9 ~]# cd /sys/fs/cgroup/memory/docker/d091004723d4de4182...
21. cat memory.memsw.limit_in_bytes
22. echo 209715200 > memory.memsw.limit_in_bytes
23. #也可以使用cgexec
24. [root@node9 cgroup]# cgexec -g
25. memory:docker/f5017485d69b50cf2e294bf6c65fcd5e679002e25bd9b0eaf9149eee2e379eec dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=150
26. 记录了150+0 的读入
27. 记录了150+0 的写出
28. 157286400字节（157 MB，150 MiB）已复制，0.0543126 s，2.9 GB/s
29. [root@node9 cgroup]# cgexec -g
30. memory:docker/f5017485d69b50cf2e294bf6c65fcd5e679002e25bd9b0eaf9149eee2e379eec dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=180
31. 记录了180+0 的读入
32. 记录了180+0 的写出
33. 188743680字节（189 MB，180 MiB）已复制，0.0650658 s，2.9 GB/s
34. [root@node9 cgroup]# cgexec -g
35. memory:docker/f5017485d69b50cf2e294bf6c65fcd5e679002e25bd9b0eaf9149eee2e379eec dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=120
36. 记录了120+0 的读入
37. 记录了120+0 的写出
38. 125829120字节（126 MB，120 MiB）已复制，0.044017 s，2.9 GB/s
39. [root@node9 cgroup]# cgexec -g
40. memory:docker/f5017485d69b50cf2e294bf6c65fcd5e679002e25bd9b0eaf9149eee2e379eec dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=200
41. 已杀死
43. #也可以自建控制器
44. [root@node9 ~]# mkdir -p /sys/fs/cgroup/memory/x1/
45. [root@node9 ~]# ls /sys/fs/cgroup/memory/x1/
46. cgroup.clone_children memory.kmem.tcp.max_usage_in_bytes
47. memory.oom_control
48. cgroup.event_control memory.kmem.tcp.usage_in_bytes
49. memory.pressure_level
50. cgroup.procs memory.kmem.usage_in_bytes
51. memory.soft_limit_in_bytes
52. memory.failcnt memory.limit_in_bytes memory.stat
53. memory.force_empty memory.max_usage_in_bytes
54. memory.swappiness
55. memory.kmem.failcnt memory.memsw.failcnt
56. memory.usage_in_bytes
57. memory.kmem.limit_in_bytes memory.memsw.limit_in_bytes
58. memory.use_hierarchy
59. memory.kmem.max_usage_in_bytes memory.memsw.max_usage_in_bytes
60. notify_on_release
61. memory.kmem.slabinfo memory.memsw.usage_in_bytes tasks
62. memory.kmem.tcp.failcnt memory.move_charge_at_immigrate
63. memory.kmem.tcp.limit_in_bytes memory.numa_stat
64. [root@node9 ~]# echo 209715200 > /sys/fs/cgroup/memory/x1/memory.limit_in_bytes
66. #内存可用大小限制
67. [root@node9 ~]# cat /sys/fs/cgroup/memory/x1/tasks #此控制器被那个进程调用
68. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=100
69. 记录了100+0 的读入
70. 记录了100+0 的写出
71. 104857600字节（105 MB，100 MiB）已复制，0.0388935 s，2.7 GB/s
72. [root@node9 ~]# free -m
73. total used free shared buff/cache available
74. Mem: 3627 1038 1813 109 1131 2589
75. Swap: 2062 0 2062
76. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=300
77. 记录了300+0 的读入
78. 记录了300+0 的写出
79. 314572800字节（315 MB，300 MiB）已复制，0.241256 s，1.3 GB/s
80. [root@node9 ~]# free -m
81. total used free shared buff/cache available
82. Mem: 3627 1125 1725 181 1203 2501
83. Swap: 2062 129 1933 #内存溢出部分被写入swap交换分区
84. [root@node9 ~]# rm -fr /dev/shm/bigfile
85. [root@node9 ~]# echo 209715200 >
86. /sys/fs/cgroup/memory/x1/memory.memsw.limit_in_bytes #内存+swap控制
87. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=200
88. 已杀死
89. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=199
90. 已杀死
91. [root@node9 ~]# rm -fr /dev/shm/bigfile
92. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=180
93. 记录了180+0 的读入
94. 记录了180+0 的写出
95. 188743680字节（189 MB，180 MiB）已复制，0.0660052 s，2.9 GB/s
96. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=190
97. 记录了190+0 的读入
98. 记录了190+0 的写出
99. 199229440字节（199 MB，190 MiB）已复制，0.0682285 s，2.9 GB/s
100. [root@node9 ~]# cgexec -g memory:x1 dd if=/dev/zero of=/dev/shm/bigfile bs=1M count=200
101. 已杀死

复制代码

5.3. 限定docker的磁盘io

1. [root@node9 ~]# docker run -it --rm \
2. --device-write-bps \ #指定容器使用磁盘io的速率
3. /dev/nvme0n1:30M \ #/dev/nvme0n1是指定系统的磁盘，30M即每秒30M数据
4. ubuntu
5. root@a4e9567a666d:/# dd if=/dev/zero of=bigfile #开启容器后会发现速度和设定不匹配，是因为系统的缓存机制
6. ^C592896+0 records in
7. 592895+0 records out
8. 303562240 bytes (304 MB, 289 MiB) copied, 2.91061 s, 104 MB/s
9. root@a4e9567a666d:/# ^C
10. root@a4e9567a666d:/# dd if=/dev/zero of=bigfile bs=1M count=100
11. 100+0 records in
12. 100+0 records out
13. 104857600 bytes (105 MB, 100 MiB) copied, 0.0515779 s, 2.0 GB/s
14. root@a4e9567a666d:/# dd if=/dev/zero of=bigfile bs=1M count=100 oflag=direct  #设定dd命令直接写入磁盘
15. 100+0 records in
16. 100+0 records out
17. 104857600 bytes (105 MB, 100 MiB) copied, 3.33545 s, 31.4 MB/s

复制代码

6. Docker的安全加固

6.1. Docker默认隔离性

在体系中运行容器，我们会发现资源并没有完全隔离开

1. [root@node9 ~]# free -m #系统内存使用情况
2. total used free shared buff/cache available
3. Mem: 3627 1128 1714 207 1238 2498
4. Swap: 2062 0 2062
5. [root@node9 ~]# docker run --rm --memory 200M -it ubuntu
6. root@e06bdc13b764:/# free -m #容器中内存使用情况
7. total used free shared buff/cache available
8. Mem: 3627 1211 1630 207 1239 2415
9. Swap: 2062
10. #虽然我们限制了容器的内容使用情况，但是查看到的信息依然是系统中内存的使用信息，并没有隔离开

复制代码

6.2. 办理Docker的默认隔离性

LXCFS 是一个为 LXC（Linux Containers）容器提供加强文件体系功能的工具。 告急功能

• 资源可见性： LXCFS 可以使容器内的历程看到正确的 CPU、内存和磁盘 I/O 等资源利用信息。在没有 LXCFS时，容器内看到的资源信息大概不正确，这会影响到在容器内运行的应用步调对资源的评估和管理。
  
• 性能监控： 方便对容器内的资源利用情况举行监控和性能分析。通过提供正确的资源信息，管理员和开辟职员可以更好地相识容器化应用的性能瓶颈，并举行相应的优化。
  

1. #安装lxcfs
2. #在rhel9中lxcfs是被包含在epel源中，我们可以直接下载安装包进行安装
3. [root@node9 ~]# ls lxcfs
4. lxcfs-5.0.4-1.el9.x86_64.rpm lxc-libs-4.0.12-1.el9.x86_64.rpm lxc-templates-
5. 4.0.12-1.el9.x86_64.rpm
6. [root@docker ~]# dnf install lxcfs/*.rpm
8. #运行lxcfs并解决容器隔离性
9. [root@node9 ~]# lxcfs /var/lib/lxcfs &
10. [root@node9 ~]# docker run -it -m 256m \
11. -v /var/lib/lxcfs/proc/cpuinfo:/proc/cpuinfo:rw \
12. -v /var/lib/lxcfs/proc/diskstats:/proc/diskstats:rw \
13. -v /var/lib/lxcfs/proc/meminfo:/proc/meminfo:rw \
14. -v /var/lib/lxcfs/proc/stat:/proc/stat:rw \
15. -v /var/lib/lxcfs/proc/swaps:/proc/swaps:rw \
16. -v /var/lib/lxcfs/proc/uptime:/proc/uptime:rw \
17. ubuntu
18. root@69ec0c67ff04:/# free -m

复制代码

6.3. 容器特权

在容器中默认情况下纵然我是容器的超等用户也无法修改某些体系设定，好比网络

1. [root@node9 ~]# docker run --rm -it busybox
2. / # whoami
3. root
4. / # ip a
5. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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. 22: eth0@if23: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
12.     link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
13.     inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
14.        valid_lft forever preferred_lft forever
15. / # ip a a 192.168.0.101/24 dev eth0
16. ip: RTNETLINK answers: Operation not permitted
17. / # 3
19. #这是因为容器使用的很多资源都是和系统真实主机公用的，如果允许容器修改这些重要资源，系统的稳定性会变的非常差;但是由于某些需要求，容器需要控制一些默认控制不了的资源，如何解决此问题，这时我们就要设置容器特权
20. [root@node9 ~]# docker run --rm -it --privileged busybox
21. / # id root
22. uid=0(root) gid=0(root) groups=0(root),10(wheel)
23. / # ip a a 192.168.0.100/24 dev eth0
24. / # ip a
25. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
26.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
27.     inet 127.0.0.1/8 scope host lo
28.        valid_lft forever preferred_lft forever
29.     inet6 ::1/128 scope host
30.        valid_lft forever preferred_lft forever
31. 24: eth0@if25: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
32.     link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
33.     inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
34.        valid_lft forever preferred_lft forever
35.     inet 192.168.0.101/24 scope global eth0
36.        valid_lft forever preferred_lft forever
37. / # fdisk -l
38. Disk /dev/nvme0n1: 40 GB, 42949672960 bytes, 83886080 sectors
39. 164482 cylinders, 255 heads, 2 sectors/track
40. Units: sectors of 1 * 512 = 512 bytes
42. Device       Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type
43. /dev/nvme0n1p1 *  4,4,1       1023,254,2        2048    2099199    2097152 1024M 83 Linux
44. /dev/nvme0n1p2    1023,254,2  1023,254,2     2099200   83886079   81786880 38.9G 8e Linux LVM
45. #如果添加了--privileged 参数开启容器，容器获得权限近乎于宿主机的root用户

复制代码

6.4. 容器特权的白名单

--privileged=true 的权限非常大，靠近于宿主机的权限，为了防止用户的滥用，必要增长限定，只提供给容器必须的权限。此时Docker 提供了权限白名单的机制，利用--cap-add添加须要的权限 capabilities手册所在：capabilities(7) - Linux manual page

1. #限制容器对网络有root权限
2. [root@node9 ~]# docker run --rm -it --name baimd --cap-add NET_ADMIN busybox
3. / # ip a
4. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 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. 26: eth0@if27: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
11.     link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
12.     inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
13.        valid_lft forever preferred_lft forever
14. / # ip a a 192.168.0.101/24 dev eth0    #网络可以设定
15. / # fdisk -l   #无法管理磁盘

复制代码

八. 容器编排工具Docker Compose

1. Docker Compose 概述

Docker Compose 是一个用于界说和运行多容器 Docker 应用步调的工具。 其是官方的一个开源项目，托管到github上.
网址：GitHub - docker/compose: Define and run multi-container applications with Docker
2.告急功能

• 界说服务： 利用 YAML 格式的设置文件来界说一组相干的容器服务。每个服务可以指定镜像、端口映射、情况变量、存储卷等参数。 比方，可以在设置文件中界说一个 Web 服务和一个数据库服务，以及它们之间的毗连关系。
  
• 一键启动和制止： 通过一个简朴的下令，可以启动或制止整个应用步调所包罗的全部容器。这大大简化了多容器应用的摆设和管理过程。 比方，利用 docker-compose up 下令可以启动设置文件中界说的全部服务，利用 docker-compose down 下令可以制止并删除这些服务。
  
• 服务编排： 可以界说容器之间的依靠关系，确保服务按照正确的次序启动和制止。比方，可以指定命据库服务必须在 Web 服务之前启动。 支持网络设置，使差别服务的容器可以相互通讯。可以界说一个自界说的网络，将全部相干的容器毗连到这个网络上。
  
• 情况变量管理： 可以在设置文件中界说情况变量，并在容器启动时通报给容器。这使得在差别情况（如开辟、测试和生产情况）中利用差别的设置变得更加轻易。 比方，可以界说一个数据库毗连字符串的情况变量，在差别情况中可以设置差别的值。
  

3.工作原理

1.读取设置文件： Docker Compose 读取 YAML 设置文件，剖析此中界说的服务和参数。
2.创建容器： 根据设置文件中的界说，Docker Compose 调用 Docker 引擎创建相应的容器。它会下载所需的镜像（假如当地没有），并设置容器的各种参数。
3.管理容器生命周期： Docker Compose 监控容器的状态，并在必要时启动、制止、重启容器。 它还可以处理处罚容器的故障规复，比方主动重启失败的容器。
5.Docker Compose 中的管理层

1.服务 (service) 一个应用的容器，实际上可以包罗多少运行雷同镜像的容器实例
2.项目 (project) 由一组关联的应用容器构成的一个完备业务单位，在 docker-compose.yml 文件中界说
3.容器（container）容器是服务的详细实例，每个服务可以有一个或多个容器。容器是基于服务界说的镜像创建的运行实例
6. Docker Compose 的常用下令参数

1. #修改vim参数
2. [root@node9 ~]# vim ~/.vimrc
3. set ts=2 sw=2 ai et
4. #set ts=2：设置制表符（tab）的宽度为 2 个空格。这意味着当你按下制表键时，Vim 会插入相当于 2 个空格的空白。set sw=2：设置自动缩进的宽度为 2 个空格。当你在新的一行进行缩进时，会按照这个宽度进行缩进。set ai：开启自动缩进功能。当你在新的一行输入代码时，Vim 会根据上一行的缩进自动进行缩进。set et：开启 “expandtab” 选项，这会使得制表符被扩展为空格。这样可以确保在不同的环境中，你的代码的缩进看起来都是一致的，不会因为不同系统对制表符的解释不同而产生差异。
6. #配置服务文件
7. [root@node9 ~]# mkdir test
8. [root@node9 test]# vim docker-compose.yml
9. searvices:
10.   web:
11.     image: nginx:latest
12.     ports:
13.       - "80:80"
14.   testnode:
15.     image: busybox:latest
16.     command: ["/bin/sh", "-c", "sleep 100000"]
17. 测试：docker ps
18. #服务一：wweb
19. 使用的镜像为 nginx:latest，这表示使用最新版本的 Nginx 镜像。
20. 映射了容器的 80 端口到主机的 80 端口，通过 "80:80" 的端口映射配置实现。这样可以通过主机的 80 端口访问到容器内运行的 Nginx 服务。
21. #服务二：testnode
22. 使用的镜像为 busybox:latest，BusyBox 是一个小巧但功能强大的工具集合，常用于简单的任务和测试。
23. 通过 command 指定了容器启动时执行的命令为 ["/bin/sh", "-c", "sleep 100000"]，这会使容器启动后进入一个睡眠状态，持续 100000 秒，可用于简单的测试或保持容器运行以便观察其他特性
24.   
25. #一.服务管理
26. #docker-compose up ：启动配置文件中定义的所有服务。可以使用 -d 参数在后台启动服务。可以使用-f 来指定yml文件
27. 例如： docker-compose up -d
28. [root@node9 test]# docker compose up -d
29. [+] Running 3/3
30. ✔ Network test_default       Created                                     0.1s
31. ✔ Container test-web-1       Started                                     0.5s
32. ✔ Container test-testnode-1  Started                                     0.3s
33. [root@node9 ~]# docker compose -f test/docker-compose.yml up -d
34. [+] Running 3/3
35. ✔ Network test_default Created 0.1s
36. ✔ Container test-web-1 Started 0.9s
37. ✔ Container test-db-1 Started
39. #docker-compose down ：停止并删除配置文件中定义的所有服务以及相关的网络和存储卷。
40. [root@node9 test]# docker compose down
41. [+] Running 2/2
42. ✔ Container test-wweb-1  Removed                                         0.1s
43. ✔ Network test_default   Removed                                         0.1s
45. #如果文件名修改了，就需要指定文件名。
46. [root@node9 test]# docker compose -f timinglee.yml down
48. #docker-compose start ：启动已经存在的服务，但不会创建新的服务。
49. [root@node9 test]# docker compose start   #必须在对应的目录
50. [+] Running 2/2
51. ✔ Container test-db-1 Started
52. ✔ Container test-web-1 Started
54. #docker-compose stop ：停止正在运行的服务
55. [root@node9 test]# docker compose stop
56. [+] Stopping 2/2
57. ✔ Container test-web-1       Stopped                                     0.1s
58. ✔ Container test-testnode-1  Stopped                                    10.1s
60. #docker-compose restart ：重启服务
61. [root@node9 test]# docker compose restart
62. [+] Restarting 2/2
63. ✔ Container test-testnode-1  Started                                    10.4s
64. ✔ Container test-web-1       Started                                     0.3s
66. #二.服务状态查看
67. #docker-compose ps ：列出正在运行的服务以及它们的状态，包括容器 ID、名称、端口映射等信息.
68. [root@node9 test]# docker compose ps
69. NAME              IMAGE            COMMAND                  SERVICE    CREATED         STATUS          PORTS
70. test-testnode-1   busybox:latest   "/bin/sh -c 'sleep 1…"   testnode   3 minutes ago   Up 57 seconds   
71. test-web-1        nginx:latest     "/docker-entrypoint.…"   web        3 minutes ago   Up 56 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp
73. #docker-compose logs ：查看服务的日志输出。可以指定服务名称来查看特定服务的日志。
74. [root@node9 test]# docker compose logs web
75. web-1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
76. web-1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
77. web-1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
79. #三.构建和重新构建服务（了解）
80. # docker-compose build ：构建配置文件中定义的服务的镜像。可以指定服务名称来只构建特定的服务。
81. [root@node9 ~]# mkdir /root/docker/
82. [root@node9 ~]# cd docker
83. [root@node9 docker]# cat xiaozhuzhu
84. FROM busybox:latest
85. RUN touch /leefile1
86. [root@node9 docker]# cat xiaofeifei
87. FROM busybox:latest
88. RUN touch /leefile2
89. [root@node9 test]# vim /test/docker-compose.yml
90. services:
91.   test1:
92.     image: 'test1'
93.     build:
94.       context: /root/docker
95.       dockerfile: xiaozhuzhu
96.     command: ['/bin/sh', '-c', 'sleep 3000']
97.     #restart: always   #出现问题重启。
98.     container_name: zhuzhuxia1
99.   test2:
100.     image: 'test2'
101.     build:
102.       context: /root/docker
103.       dockerfile: xiaofeifei
104.     command: ['/bin/sh', '-c', 'sleep 3000']
105.     #restart: always
106.     container_name: zhuzhuxia2
107. [root@node9 test]# docker compose up -d #构建services中的所有
108. [root@node9 test]# docker compose up -d --remove-orphans #清除正在运行的compose
109. [root@node9 test]# docker compose build test1 #只够建test1
111. #docker-compose up --build ：#启动服务并在启动前重新构建镜像。
112. [root@node9 test]# docker compose -f docker-compose.yml up -d #会去仓库拉去镜像
113. [+] Running 1/1
114. ! test1 Warning pull access denied for test1, repository does not exist or
115. may require 'docker login': denied: requested acces...
116. [root@docker test]# docker compose -f docker-compose.yml up --build #会先构建镜像后启动容器
118. #四.其他操作
119. 1. docker-compose exec ：在正在运行的服务容器中执行命令。
120. [root@node9 test]# docker compose exec -it test1 /bin/sh
122. 2. docker-compose pull ：拉取配置文件中定义的服务所使用的镜像。
123. [root@node9 test]# docker compose -f docker-compose.yml pull
124. [+] Pulling 2/2
125. ✔ test Pulled
126. ✔ ec562eabd705 Pull complete
128. 3. docker-compose config ：
129. 验证并查看解析后的 Compose 文件内容
130. [root@node9 test]# docker compose -f docker-compose.yml config
131. [root@node9 test]# docker compose -f test.yml config -q

复制代码

7. Docker Compose 的yml文件

Docker Compose 的 YAML 文件用于界说和设置多容器应用步调的各个服务。以下是一个根本的 Docker Compose YAML 文件结构及内容表明：
8. 服务（services）

1. 1. 服务名称（service1_name/service2_name 等）：
2. 每个服务在配置文件中都有一个唯一的名称，用于在命令行和其他部分引用该服务。
3. services:
4.   web:
5.     # 服务1的配置
6.   mysql:
7.     # 服务2的配置
9. 2. 镜像（image）：
10. 指定服务所使用的 Docker 镜像名称和标签。例如， image: nginx:latest 表示使用 nginx镜像的最新版本
11. services:
12.   web:
13.     image: nginx
14.   mysql:
15.     image: mysql:5.7
17. 3. 端口映射（ports）：
18. 将容器内部的端口映射到主机的端口，以便外部可以访问容器内的服务。例如， -"8080:80" 表示将主机的 8080 端口映射到容器内部的 80 端口。
19. services:
20.   web:
21.     image: timinglee/mario
22.     container_name: game #指定容器名称
23.     restart: always #docekr容器自动启动
24.     expose:
25.       - 1234 #指定容器暴露那些端口，些端口仅对链接的服务可见，不会映射到主机的端口
26.     ports:
27.       - "80:8080"
28. 测试：docker ps
29.       
30. 4. 环境变量（environment）：
31. 为容器设置环境变量，可以在容器内部的应用程序中使用。例如， VAR1: value1 设置环境变量 VAR1 的值为 value1
32. services:
33.   web:
34.     image: mysql:5.7
35.     environment:
36.       MYSQL_ROOT_PASSWORD: 123
38. 5. 存储卷（volumes）：
39. 将主机上的目录或文件挂载到容器中，以实现数据持久化或共享。例如， -
40. /host/data:/container/data 将主机上的 /host/data 目录挂载到容器内的
41. /container/data 路径。
42. services:
43.   test:
44.     image: busybox
45.     command: ["/bin/sh","-c","sleep 3000"]
46.     restart: always
47.     container_name: busybox1
48.     volumes:
49.       - /etc/passwd:/tmp/passwd:ro  #只读挂在本地文件到指定位置
51. 6. 网络（networks）：
52. 将服务连接到特定的网络，以便不同服务的容器可以相互通信
53. services:
54.   web:
55.     image: nginx
56.     container_name: webserver
57.     network_mode: bridge #使用本机自带bridge网络
58.   test:
59.     image: busybox
60.     container_name: webserver
61.     command: ["/bin/sh","-c","sleep10000000"]
62.     networks:
63.       - mynet1
64.       - mynet2
66. networks:
67.   mynet1:
68.     driver: bridge
69.   mynet2:
70.     driver: bridge
72. 7. 命令（command）：
73. 覆盖容器启动时默认执行的命令。例如， command: python app.py 指定容器启动时运行python app.py 命令
74. [root@node9 test]# vim busybox.yml
75. services:
76.   web:
77.     image: busybox
78.     container_name: busybox
79.     command: ["/bin/sh","-c","sleep 10000000"]

复制代码

9. 网络（networks）

界说 Docker Compose 应用步调中利用的网络。可以自界说网络名称和驱动步调等属性。默认情况下docker compose 在实行时会主动创建网路。

1. [root@node9 test]# vim  docker-compose.yml
2. services:
3.   test1:
4.     image: busybox:latest
5.     command: ["/bin/sh","-c","sleep 3000"]
6.     restart: always
7.     network_mode: default
8.     container_name: busybox1
9.   test2:
10.     image: busybox:latest
11.     command: ["/bin/sh","-c","sleep 3000"]
12.     restart: always
13.     container_name: busybox2
14.     networks:
15.       - mynet1
16.   test3:
17.     image: busybox:latest
18.     command: ["/bin/sh","-c","sleep 3000"]
19.     restart: always
20.     container_name: busybox3
21.     networks:
22.       - mynet2
24. networks:
25.   default:
26.     external: true  #指定外部资源网络名字
27.     name: bridge
28.   mynet1:
29.     driver: bridge #使用桥接驱动，也可以使用macvlan用于跨主机连接
30.   mynet2:
31.     ipam:
32.       driver: default
33.       config:
34.         - subnet: 172.28.0.0/16
35.           gateway: 172.28.0.254
36. [root@node9 test]# docker compose up -d
37. [root@node9 test]# docker network ls
38. [root@node9 test]# docker exec -it test2 sh
39. / # ifconfig
40. / # route -n

复制代码

10. 存储卷（volumes）

界说 Docker Compose 应用步调中利用的存储卷。可以自界说卷名称和存储位置等属性。

1. [root@node9 test]# vim  docker-compose.yml
2. services:
3.   test1:
4.     image: busybox:latest
5.     command: ["/bin/sh","-c","sleep 3000"]
6.     restart: always
7.     network_mode: default
8.     container_name: busybox1
9.   test2:
10.     image: busybox:latest
11.     command: ["/bin/sh","-c","sleep 3000"]
12.     restart: always
13.     container_name: busybox2
14.     networks:
15.       - mynet1
16.     volumes:
17.       - data:/data #挂在data卷
18.       - /etc/passwd:/tmp/passwd:ro #只读挂在本地文件到指定位置
19.   test3:
20.     image: busybox:latest
21.     command: ["/bin/sh","-c","sleep 3000"]
22.     restart: always
23.     container_name: busybox3
24.     networks:
25.       - mynet2
27. networks:
28.   default:
29.     external: true  #指定外部资源网络名字
30.     name: bridge
31.   mynet1:
32.     driver: bridge #使用桥接驱动，也可以使用macvlan用于跨主机连接
33.   mynet2:
34.     ipam:
35.       driver: default
36.       config:
37.         - subnet: 172.28.0.0/16
38.           gateway: 172.28.0.254
40. volumes:
41.   data:
42.     name: timinglee #指定建立卷的名字
43. [root@node9 test]# docker compose up -d
44. [root@node9 test]# docker inspect test2  #看mounts挂载
45. [root@node9 test]# docker exec -it test2 sh  #进入容器，看对应的目录。后续删掉了容器之后建立的卷还在。

复制代码

11. 企业示例

利用容器编排完成haproxy和nginx负载均衡架构实行

1. [root@node9 ~]# mkdir /var/lib/docker/volumes/conf
2. [root@node9 ~]# dnf install harpoxy -y --downloadonly --downloaddir=/mnt
3. rpm2cpio harpoxy-2.4.22-3el9_3.x86_64.rpm | cpio -id
4. [root@node9 ~]# ls
5. [root@node9 ~]# cd etc/
6. [root@node9 etc]# ls
7. [root@node9 ~]# cd harpoxy/
8. [root@node9 harpoxy]# ls
9. [root@node9 ~]# cp haproxy.cfg /var/lib/docker/volumes/conf/
10. [root@node9 ~]# cd /var/lib/docker/volumes/conf/
11. [root@node9 conf]# vim haproxy.cfg
12. ...
13. maxconn        3000
14. listen webcluster
15.         bind *:80
16.         balance roundrobin
17.         server web1 webserver1:80 check inter 3 fall 3 rise 5
18.         server web2 webserver2:80 check inter 3 fall 3 rise 5
19. ...
20. #提前下载haproxy的镜像。
21. [root@node9 ~]# docker pull haproxy:2.4  #看网络，注意版本，相差不大可以用。
22. [root@node9 ~]# docker load -i haproxy....
23. [root@node9 test]# vim  haproxy.yml  
24. services:
25.   web1:
26.     image: nginx:latest
27.     container_name: webserver1
28.     restart: always
29.     networks:
30.       - internel
31.     expose:
32.       - 80
33.     volumes:
34.       - data_web1:/usr/share/nginx/html
35.   web2:
36.     image: nginx:latest
37.     container_name: webserver2
38.     restart: always
39.     networks:
40.       - internel
41.     expose:
42.       - 80
43.     volumes:
44.       - data_web2:/usr/share/nginx/html
45.   haproxy:
46.     image: haproxy:2.3
47.     container_name: haproxy
48.     restart: always
49.     networks:
50.       - internel
51.       - extrnal
52.     volumes:
53.       - /var/lib/docker/volumes/conf/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg
54.     ports:
55.       - 80:80
57. networks:
58.   internel:
59.     driver: bridge
60.   extrnal:
61.     driver: bridge
62. volumes:
63.   data_web1:
64.     name: data_web1
65.   data_web2:
66.     name: data_web2
67. [root@node9 test]# docker compose -f haproxy.yml up -d
68. [root@node9 test]# docker compose ps
70. #建立发布文件
71. [root@node9 test]# echo webserver1 - joker:11111111111111111111 > /var/lib/docker/volumes/data_web1/_data/index.html
72. [root@node9 test]# echo webserver2 - joker:22222222222222222222 > /var/lib/docker/volumes/data_web2/_data/index.html
73. [root@node9 test]# netstat -antlupe | grep 80
74. [root@node9 test]# docker ps
75. #报错看日志
76. [root@node9 test]# docker logs haproxy | less
78. 测试：
79. #[root@node9 test]# curl 172.25.254.100  #出现轮询即可。

复制代码