第十二,十三周第12个容器架构

容器架构

Iaas Paas Saas

• iaas ：基础设施即服务 Infrastructure-as-a-Service

• paas：平台即服务 Platform-as-a-Service

• saas：软件即服务 Software-as-a-Service

• caas：容器及服务 介于IAAS和PAAS之间

• IAAS,PAAS,SAAS这些服务，用于帮助人们更快实现目标（搭建环境，使用产品）

• 从左到右，人们需要管理与维护的地方越来越少，人们可以把重点关注在使用/应用上

• IAAS平台：基础设施，阿里云，云厂商

• PAAS平台：服务/运行环境是ok ,公有云，负载均衡SLB

• SAAS平台：服务已经准备好，您直接使用，具体产品，

什么是容器

• 容器是隔离的环境中运行的一个进程，如果进程结束，容器就会停止
• 容器的隔离环境，拥有自己的ip地址，系统文件，主机名，进程管理

容器vs虚拟机

	虚拟机	容器
优点	1.使用简单 2.也有成熟管理工具，vmware,esxi,KVM,Openstack。3.可以随意定制。4.启动虚拟机要经过linux启动流程	1.快速部署2.大部分环境都有现成的镜像。3.让我们不再关注系统基础设施，升级，优化。4.不依赖硬件。5.启动容器秒级启动。6.相当于一个进程
缺点	1.需要硬件支持虚拟化技术。2.资源利用率不高。3.同一台虚拟机泡多个服务，可能有冲突。4.占资源较多。5.升级，快速扩容，快速部署，回滚不方便	1.使用较为复杂。2.共享;linux系统内核，推荐使用较新的linux内核

docker极速上手指南

• 安装docker环境，docker-ce(开源)，docker-ee(企业版)
• 从1.13开始改成年-月版本命名方式

配置docker源（用于安装docker）

yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sed -i 's+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo
yum install -y docker-ce

mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://bjjtv7cs.mirror.aliyuncs.com"]#docker下载镜像加速#
}
EOF
systemctl daemon-reload
systemctl restart docker
systemctl enable docker
ps -ef |grep docker

#命令补全
yum install -y bash-completion bash-completion-extras

docker. c/s架构

• cs client/server. 客户端/服务端

• docker 服务端：docker deamon 叫dockerd （守护进程）

• docker 客户端：docker命令（下载镜像，运行容器。。）

• docker pull nginx 下载nginx镜像到本地仓库

  • 如果本地仓库有则提示镜像已经下载
  • 如果本地没有，则docker服务端访问远程仓库，下载镜像到本地

• docker run -d -p 80;80 nginx

  • -d 容器后台运行
  • -p 端口映射
  • nginx 镜像名字

docker run -d -p 80:80 nginx
docker客户端找dockerd服务端,问是否有nginx镜像
如果有,则启动这个镜像,后台运行,访问容器端口是80端口.
如果没有,则从远程仓库下载镜像,启动这个镜像,后台运行,访问
容器端口是80端口. 1. 提示你本地没有nginx镜像 nginx:latest最新版

Unable to find image 'nginx:latest' locally
2. 找远程仓库下载
 latest: Pulling from library/nginx
 a2abf6c4d29d: Pull complete
 a9edb18cadd1: Pull complete
 589b7251471a: Pull complete
 186b1aaa4aa6: Pull complete
 b4df32aa5a72: Pull complete
 a0bcbecc962e: Pull complete
 3. 运行镜像,成为docker容器.
 Digest: 
sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f76
2b011a10c54a66cd53c9b31
 Status: Downloaded newer image for nginx:latest
 9020c66ace48effa904063f84c664535b8cc3aa2b95535df438c9f2f4952cc35
 
 4.查看镜像
 
 docker images
 REPOSITORY   TAG       IMAGE ID       CREATED    SIZE
 nginx       latest   605c77e624dd   4 months ago   141MB

 5.查看容器

docker ps

 6. 访问10.0.0.81:80--->容器的80端口

• 注意事项：在此处使用到了docker -p 端口映射公共，需要使用iptables的nat功能，需要开启系统内核转发功能

[[email protected] ~]# tail -1 /etc/sysctl.conf
net.ipv4.ip_forward = 1
[[email protected] ~]# sysctl -p
net.ipv4.ip_forward = 1

docker的镜像管理

镜像管理核心指令：

docker命令	指定功能	详细功能
docker	image	ls

• docker image ls (docker images) 查看下载的镜像
• docker search 搜索镜像，优先选官方，starts数量多
• docker pull 拉取镜像（下载镜像）注意版本
• docker push 推送镜像（上传镜像）
• docker load. 导入镜像
  • 例如：docker load -i docker_nginx.tar.gz
• docker save. 导出镜像
  • 例如： docker save centos:7 -o docker_centos7.tar.gz
• docker images. 查看镜像列表
• docker rmi 删除镜像
• docker tage 给镜像打标签

search 搜索镜像

• 命令行通过docker search 搜索

1 docker search php 
2 未来使用中我们关注
3 是否为官方:offical 是否有 OK
4 STARS数量:选择数量多的.

• 直径在hub.docker.com官网搜索
• 下载指定的镜像版本

- nginx为例
  - 下载nginx最新版本： nginx:latest
  - 下载nginx最新稳定版本：nginx:stable
  - 下载nginx指定的版本： nginx:1.20.2 
  - nginx镜像默认的系统是debian系统
  - docker pull nginx:1.20.2-alpine 使用alpine系统（linux的mini版）更加节约空间

[[email protected] ~]# docker images
REPOSITORY   TAG             IMAGE ID       CREATED       SIZE
nginx       latest         605c77e624dd   4months ago   141MB
nginx        1.20.2         50fe74b50e0d   4months ago   141MB
nginx        1.20.2-alpine   373f8d4d4c60   6months ago   23.2MB

docker常用的系统及简单命令

docker镜像使用系统
ubuntu	都可以做镜像系统
debian	都可以做镜像系统
centos	都可以做镜像系统	最大
alpine	镜像非常小（命令，依赖精简）

pull下载镜像

• docker image pull (简写 docker pull)
• 例如
  • docker pull nginx
  • docker pull nginx
  • docker pull nginx:1.20.2
  • docker pull nginx:1.20.2-alpine
• docker pull bitnami/nginx 用户名/软件名:版本信息个人仓库

push 上传镜像

• 未来我们自己搭建镜像仓库使用
• 把镜像上传到dockerhub(docker仓库)

save docker镜像导出/保存

docker	image	save	镜像id(单个或多个)	-o 压缩包名字

• docker image save 373f8d4d4c60 -o nginx-1.20.2-alpine.tar.gz

• docker image save nginx:1.20.2 -o nginx_name-1.20.2.tar.gz

• 温馨提示：如果镜像id导出镜像，然后在导入镜像，镜像的名字为none.

• 企业生产环境应用建议：id和名字的使用规则

  • 删除镜像或容器的时候一般用id。
  • 进行其他操作，可以使用名字，名字可以tab出来

load docker镜像导入

docker	image	load	-i	镜像压缩包名字

• docker image load -i nginx_name-1.20.2.tar.gz
• docker image load -i nginx-1.20.2-alpine.tar.gz

[[email protected] ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED      SIZE
          373f8d4d4c60   6 months ago  23.2MB
nginx       1.20.2     50fe74b50e0d   6 months ago  23.2MB

生产环境实战建议：

• 小规模使用可以通过sl大法实现环境批量部署/迁移
• 大规模使用镜像上传到本地镜像仓库

ls 查看镜像

查看docker镜像
docker	image	ls
docker	images

rm 删除镜像

删除镜像
docker	image	rm
docker	rmi

docker save nginx:1.20.2 -o nginx-1.20.2.tar.gz。先打包备份好再删
docker image rm nginx:1.20.2

温馨提示

• 通过名字或镜像的id删除镜像，推荐使用镜像id
• 删除的镜像，不能有容器使用

tag标签

docker镜像打标签
docker	image	tag
docker	tag

• 给镜像起一个新的名字相当于创建一个硬连接（非改名）

docker image tag nginx:1.20.2-alpine nginx:1.20.2-alpine-mini docker image tag nginx:1.20.2-alpine oldboyedu_nginx:1.20.2-apline

docker tag 企业应用场景

• 给镜像起名，使用这个新名字的镜像启动容器
• 把这个镜像通过修改tag可以上传本地镜像仓库中

prune 清除无效镜像

docker	image	prune

• 名字和tag是none
• 未来我们定期清理这些镜像

build用于构建镜像

inspect用于检查镜像信息

• 很少用于查看镜像信息
• 未来大部分查看容器内容

docker 的容器管理

• docker container XXX

• docker ps 看容器列表。

  • -a 查看所有容器

• docker run 创建并运行容器

  • -d 进入后台运行
  • -it 运行同时进入容器创建一个终端
  • -p. 端口映射

• docker create 创建容器

  • –name 指定进程名字

• docker start 启动容器

• docker stop 停止容器

• docker restart 重启容器

• docker kill. 强制停止容器

• docker rm 删除容器

  • -f. 强制删除所有容器
  • 批量删除所有容器 docker rm -f docker ps -a -q

• docker exec. 进入正在运行的容器（分配一个新的终端）

  • 例子: docker exec -it 容器id/容器名字 /bin/bash(/bin.sh)

• docker attach 进入正在运行的容器（使用相同的终端），偷偷里看的快捷键为ctrl + p. ; ctrl + q 不能用ctrl+c

• docker cp 与宿主机传文件

• docker commit 创建镜像

run 运行容器

运行容器
docker	container	run
docker	run

• docker container run 过程
  • 1.是否有这个镜像如果没有docker image pull 下载镜像
  • 2.下载完成，创建容器，docker container create
  • 3.启动容器 docker container start

docker container run [OPTIONS]   IMAGE [COMMAND] [ARG..]
docker container run -d -p 80:80 nginx

docker run指令的选项[options]
-d	让容器后台运行并输出容器id
-p	容器与宿主机端口映射。宿主机端口：容器端口
-i	interactive 进入交互模式，进入这个镜像中，一般与-t一起使用 -it
-t	分配一个终端（入口）
–name	给容器指定一个名字方便管理
-v	挂载数据卷

• 创建容器centos7.9并进入容器

docker run -d -it --name "oldboyedu_lidao-c7.9"centos:centos7.9.2009

• 运行命令行变了
• 运行容器并进入

• 检查了下容器信息

• 退出后的容器消失了
  • 运行中的容器需要在容器中持续运行某个指令或服务（前台）
  • 要在容器中有个命令/服务，把这个容器阻塞/卡住
• 容器运行sleep9

docker container run [OPTIONS]  IMAGE [COMMAND] [ARG....]
docker container run -d -p 80:80  nginx
docker container run -d --name"kiku_c79_v667" centos:centos7.9.2009  sleep 9

温馨提示

• 容器想要放在后台（-d）一直运行的话，那么容器的初始命令，必须夯住（阻塞/前台运行），否则容器就会退出

前台运行
nginx -g 'daemon off;'   nginx前台运行. 
/usr/sbin/php-fpm --nodaemonize 
php前台运行. 
/usr/sbin/sshd -D               ssh前台运行. 
java -jar xxx.jar               java前台运行.

ps 查看已经创建的容器

• docker container ps

• docker container list

• docker container ls

• docker ps

• 1.docker ps 简易使用

• 主要关注：容器id ，容器命令，容器状态，容器端口映射

• 2.让docker ps 显示完整的纤细，不要省略（一般指的命令部分）

• 选项 --no-trunc (docker ps --no-trunc)

• 3.显示所有容器

• 选项 -a （docker ps -a）

• 4.过滤出所有运行中的容器的id

• -q. (docker ps -q)

• docker ps |awk ‘NR>1 {print $1}’

docker sp 选项小结

选项小结
-a	显示所有状态的容器，默认只显示运行中的
-q	限制显示容器id。
–no-trunc	显示完整信息
-f	显示指定状态进程。docker ps -aq -f ‘status=exited’

create,start,stop,restart指令

docker run == pull,create,start

温馨提示

• 一般会使用 docker run 而不是使用 create,start

创建容器

• docker container create --name “oldboyedu_ngx_create” nginx:1.20.2-alpine

启动容器

• docker container start oldboyedu_ngx_create

关闭容器

• docker container stop oldboyedu_ngx_create

重启镜像

• docker container restart oldboyedu_ngx_create

kill 结束容器

• docker container kill
• docker kill

rm 删除容器（危险）

• docker container rm
• docker rm

1.删除所有容器。

• docker rm `docker ps -aq`(docker ps -aq 显示所有状态的容器的id)

• docker rm -f `docker ps -aq`. 强制删除（如果容器运行中也会被删除）

2.删除已经关闭的容器然后删除

• docker rm `docker ps -a |grep Exited|awk ‘NR>1{print $1}’`
• docker rm `docker ps -a |awk ‘/Exited/{print $1}’`
• docker rm -aq -f ‘status=exited’

更多ps规则

https://docs.docker.com/engine/reference/commandline/ps/

exec,attach连接容器

docker exec 与docker attach区别

docker exec：会产生新的进程，在一个正在运行的容器中运行命令（进程）。

docker attach：将本地标准输入输出连接一个运行的容器，不会产生新的进程。而是将本地的stdin,stdout,error stream连接到正在运行的容器

exec

• docker container exec
• docker exec

进入已经运行的容器中

1.启动容器
docker run -d --name "kiku_nginx" -p 80:80 nginx:1.20.2-alpine
2.连接进入容器
docker exec -it kiku_nginx /bin/sh  #如果/bin/bash不能用就用/bin/sh
3.修改nginx首页文件
echo docker01.kiku.cn >/usr/share/nginx/html/index.html
4.浏览器访问

温馨提示

• 为何连接容器后，要执行/bin/bash或/bin/sh
  • 进入容器后命令环境（命令解释器），输入命令。

数据库环境启动与进入

1.创建mysql容器,并设置root密码为Kiku05
docker run -d --name "kiku_mysql5.7" -e MYSQL_ROOT_PASSWORD=Kiku05 mysql:5.7-debian
2.直接进入数据库中
docker exec -it kiku_mysql5.7 mysql -uroot -pKiku05
这里是mysql是mysql的客户端

温馨提示

• docker run -e 表示指定容器中的变量和值 key=value

attach

• attach 连接容器的时候共用一个终端/连接，已经有的终端

两个窗口连接是必须是运行的容器
1.窗口01 前台运行容器
docker run  -it   --name "kiku_c7.9-attch-v2"centos:centos7.9.2009
2.窗口02 连接运行的容器
docker attch   kiku_c7.9-attch-v2
退出 必须用 ctrl + p 然后ctrl +q

cp宿主机与容器传输数据

• 宿主机到容器上传。docker cp 源的路径 目标容器:容器中的路径

• 宿主机到容器下载。docker cp 目标容器:容器中的路径。源的路径

案例01: /etc/hosts---->容器的/tmp/目录下

1.上传一个文件
docker cp /etc/hosts kiku_nginx:/tmp/
2.检查
docker exec -it kiku_nginx  /bin/sh
/ # ls -l /tmp/
total 4 
 -rw-r--r--    1 root     root           311 Apr  204:26 hosts

commit 创建镜像

• 根据容器创建镜像
• docker container commit
• docker commit

1.检查要处理的容器
2.根据容器创建镜像
3.检查镜像
4.使用新的镜像

查看容器状态top ,stats

• top 查看容器中的进程信息
• stats显示容器信息内存，磁盘

docker	container	top
docker	top
docker	container	stats
docker	stats

• 查看容器中的进程信息
• 这里的pid显示的是宿主机的进程id
• 查看容器占用的资源情况

stats里面主要信息含义

• MEM USAGE/LIMIT 容器占用的内存大小/内存限制（默认没有限制）
• NET I/O 网络数据 输入/输出。 Input（进入容器中）Output（离开容器用户访问80）
• BLOCKE I/O 磁盘读写
• PIDS 进程和线程数量

inspect 查看容器各个指标，通过json格式显示

• 用于获取docker容器的基本信息，容器名字，id，ip地址
• 输出json

#表现形式
[]或{}
"key":"value"
建 ：值

• 未来使用docker insperct建议

• 应用场景：用它取出docker的基本信息

  • docker inspect + cid或容器名字。+ 三剑客过滤
  • docker inspect + jq工具（没有要用yum下载，要配合管道过滤）
  • docker inspect --format={{.key}}. （如果多层 .最外层key.想要的key）
    • 取qi方法. docker inspect --format {{.NetworkSettings.IPAddress}} vol_nginx

• 通过jq取对应内容，接上管道使用

[root@docker01 ~]# docker inspect vol_nginx | jq .[].State
{
  "Status": "running",
  "Running": true,
  "Paused": false,
  "Restarting": false,
  "OOMKilled": false,
  "Dead": false,
  "Pid": 6422,
  "ExitCode": 0,
  "Error": "",
  "StartedAt": "2022-05-23T09:41:18.489491593Z",
  "FinishedAt": "0001-01-01T00:00:00Z"
}

• 取ip号码

#jq取值
[root@docker01 ~]# docker inspect vol_nginx | jq .[].NetworkSettings.IPAddress
"172.17.0.2"

[root@docker01 ~]# docker inspect --format {{.NetworkSettings.IPAddress}}  vol_nginx
172.17.0.2

• 取端口

#jq取值
[root@docker01 ~]# docker inspect vol_nginx | jq '.[].NetworkSettings.Ports."80/tcp"'
[
  {
    "HostIp": "0.0.0.0",
    "HostPort": "80"
  },
  {
    "HostIp": "::",
    "HostPort": "80"
  }
]

#json取值
[root@docker01. ~]# docker inspect  --format {{.NetworkSettings.Ports}} vol_nginx
map[80/tcp:[{0.0.0.0 80} {:: 80}]]

• 用于查看容器，查看镜像信息
• 用于取出对应指标，然后进行监控的操作

端口映射

• 应用场景：未来容器需要被外境访问（80端口）需要暴露在外界一个端口
• 用户通过端口访问容器中的某个端口
• docker通过-p选项实现
• 本质是通过iptables nat规则实现的.nat表中创建了docker自定义的链
• 如docker run -d --name “kiku_nginx_1.20.2-apline” -p 8888:80 nginx:1.20.2-apline

背后做了什么

• 添加了对应防火墙规则
• -A DOCKER ! -i docker0 -p tcp -m tcp --dport 8888 -j DNAT --to-destination 172.17.0.10:80
• 需要自己开启内核转发

[root@docker01 ~]# docker run -d --name "kiku_nginx_1.20.2-apline" -p 8888:80 nginx:1.20.2-alpine
5a06cf4be1ac09f2780149355fd1d93d33d3601a7f5f6e6acfd45518457a0d21
[root@docker01 ~]# ss -lntup |grep 8888
tcp    LISTEN     0      128       *:8888                  *:*                   users:(("docker-proxy",pid=8554,fd=4))
tcp    LISTEN     0      128    [::]:8888               [::]:*                   users:(("docker-proxy",pid=8559,fd=4))
[root@docker01 ~]#

端口映射案例

docker run 端口映射的选项	例子及含义
-p(小写字母) 宿主机端口：容器中的端口	-p 80:80 一对一端口映射
-p :容器中的端口	-p :80 表示宿主机端口随机，很少用
-p 端口范围：端口范围	-p 80-88:80-88 范围端口映射
-P(大写的字母)	随机的宿主机和容器端口范围
-p 宿主机ip：宿主机端口：容器端口	-p 172.16.1.81:12306:80

一对一端口映射

docker run -d --name "kiku_nginx" -p 80:80 nginx:1.20.2-alpine

映射多个端口

• 映射8080,8081,8082到容器

docker run -d --name "kiku_nginx" -p 8080-8082:8080-8082 nginx:1.20.2-alpine

ip绑定端口

• 显示用户只能通过宿主机的某个网卡连接这个端口
• 安全防护作用

docker run -d --name "kiku_bind_ip" -p 172.16.1.81:12306:80 nginx:1.20.2-alpine

数据卷挂载

• 这里我们想个问题,创建了一个容器,容器里面存放很多代码,数据,软件包等等信息,不小心删除容器 rm -f .
• 重新创建名字相同的容器,问数据还有没有?
• 如何解决数据持久化问题? 数据卷(挂载),让数据永久保存在宿主机中.

实战

• 不使用数据卷，数据会丢失
• 数据卷 -v选项
• docker run -v 指定要挂载的目录/文件

挂载文件 宿主机/app/docker/code/ 挂载到容器/usr/share/nginx/html/

1.
mkdir -p /app/docker/{coder,conf,data}
2.
docker run -d --name "nginx_volume_dir" -v /app/docker/code/:/usr/share/nginx/html -p 80:80 nginx:1.20.2-alpine

• 查看数据卷

docker inspect nginx:1.20.2-alpine |jq [].HostConfig.Binds

案例一：挂载代码目录，配置文件目录

• 用数据卷挂载：代码目录
• 用数据卷挂载：配置文件，配置文件目录
• 用数据卷挂载：数据目录（数据库）
• 还可以用于日志

1.创建相关目录
app/docker/code/restart
app/docker/nginx/conf/nginx.conf
/app/docker/nginx/conf/conf.d
2.挂载
docker run -d --name "restart_nginx_80" -p 80:80 \
-v /app/docker/code/restart:/usr/share/nginx/html/ \
-v /app/docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /app/docker/nginx/conf/conf.d/:/etc/nginx/conf.d \
nginx:1.20.2-alpine
3.修改配置文件

[root@docker01 /app/docker/nginx/conf/conf.d]# cat restart.kiku.conf
server{
 listen 80;
 listen [::]:80;
 server_name localhost;
 location / {
  root /usr/share/nginx/html/;
  index index.html index,html;
}
  error_page 500 502 503 504 /50x.html;
  location = /50x.html {
   root /usr/share/nginx/html;
}
   location ~* \.(js|css)$ {
   expires 30d;
   root /usr/share/nginx/html/;
   index index.html index,html;
}
}

4.测试

案例二：创建数据卷

• 应用场景：只关注容器中的数据不丢，不关注数据具体放在哪里

1.创建数据卷
docker volume create sunlogdata
2.查看数据卷
[[email protected] ~]# docker volume ls
DRIVER    VOLUME NAME
local     4c884a6abd6ca039a5d22c8c1077c1be4ae2ad1664921eb3b4701461a31a59fe
local     9cca42dbc4307559c86e6660993f63f2338ba8d02ce01ccbc187a983a26d3cd7
local     sunlogdata

[[email protected] ~]# tree /var/lib/docker/volumes/sunlogdata/
/var/lib/docker/volumes/sunlogdata/
└── _data

1 directory, 0 files

3.挂载数据卷
docker run -d --name "nginx_vol_sunlogdata" -p 80:80 -v sunlogdata:/var/log/nginx/ nginx:1.20.2-alpine


4.查看
ls -l /var/log/docker/volumes/sunlogdata/_data/

注意：
nginx容器的日志默认是输出到docker标准输出和错误输出的，而不是存放在文件中。
未来看日志的时候，不用今日容器，然后tail/less使用命令插卡吗
直接使用docker logs 容器id/名字。就可以看日志。相当于查看access.log或error.log

随机数据卷（使用较少）

docker run -d --name "nginx_vol_kikuylogdata"  -p :80 -v :/var/log/nginx/  nginx:1.20.2-alpine

数据卷更多用法

https://docs.docker.com/storage/volumes/

容器自动化

• docker. 镜像，容器，端口映射，数据卷挂载
• 创建一个tengine镜像（手动），自动（dockerfiler）

手动创建tengine镜像

手动编译流程

• 下载并启动ubuntu:20.04 容器 叫 ubt_tengine_2.3.3
• 配置apt源
• 下载软件包
• 编译安装三部曲
• 启动与测试
• 清理痕迹
• 生成镜像

下载ubuntu:20.04 容器 叫ubt_tengine_2.3.3

docker run -it --name "ubt_tengine_2.3.3" ubuntu:20.04 /bin/bash 

配置atp源

sed -ri 's#archive.ubuntu.com|security.ubuntu.com#mirrors.aliyun.com#g'   /etc/apt/sources.list
apt update

下载软件包

#下载常用工具
apt-get install -y wget
#下载tengine软件包
wget -P /tmp/ http://tengine.taobao.org/download/tengine-2.3.3.tar.gz
#解压并进入目录
tar xf /tmp/tengine-2.3.3.tar.gz
cd /tmp/tengine-2.3.3/

编译安装三部曲

• ./configure
• make
• make install

#1.安装依赖
apt-get install -y libssl-dev make gcc pcre2-utils libpcre3-dev zlib1g-dev

#2.进行配置
./configure --prefix=/app/tools/tengine-2.3.3/  \
--user=nginx \
--group=nginx \
--with-http_ssl_module \
--with-http_v2_module   \
--with-http_realip_module \
--with-http_stub_status_module \
--with-http_mp4_module \
--with-stream  \
--with-stream_ssl_module   \
--with-stream_realip_module   \
--add-module=modules/ngx_http_upstream_check_module/ \
--add-module=modules/ngx_http_upstream_session_sticky_module

echo $?
#3.编译
make

echo $?
#4.编译安装
make install

echo $?
#5.检查
/app/tools/tengine-2.3.3/sbin/nginx -V

首尾，启动，测试

#添加用户nginx
groupadd nginx
useradd -g nginx nginx

#创建安装目录软连接
ln -s /app/tools/tengine-2.3.3 /app/tools/tengine

#创建命令软连接
ln -s /app/tools/tengine/sbin/nginx /sbin
nginx -V

#启动与本地测试
echo 'docker tengine' > /app/tools/tengine/html/index.html
curl loaclhost

清理镜像

1.清理代码包，解压目录
rm -fr /tmp/*
2.清理apt/yum缓存
rm -fr /var/cache/*
3.其他的清理，逐步测试

生成镜像

docker commit ubt_tengine_2.3.3 tengine:2.3.3-v1_not_you

运行容器

• 运行容器注意要有一个服务在前台阻塞
• 这个容器没有配置需要手动
• nginx -g 用于命令中指定配置文件中的选项/指令，要以分号结尾
• daemon off 关闭守护进程模式，前台运行

1.启动服务
docker run -d --name "tengine-2.3.3-not_opt_v1" -p 80:80 tengine:2.3.3-v1_not_you  nginx -g 'daemon off;'

2.检查
curl 10.0.0.81:80

关于日志

docker logs
-t  显示时间
-n  输出的倒数几行
-f  持续输出到屏幕
--since string   时间戳之后的日志
--until string   时间戳之前的日志

• /app/tools/tengine/logs/ 存放在容器中
• 关于日志的处理
  • 日志目录挂载到宿主机的某一个目录中
  • 把日志软连接到/dev/stdout 和/dev/stderr中。未来可以通过docker logs 查看日志.
  • 这样的话docker logs找的就是 /app/tools/tengine/logs/access.log 然后软连接到/dev/stdout里面标准输出到屏幕

ln -s /dev/stdout /app/tools/tengine/logs/access.log  #访问日志stdout标准输出

ln -s /dev/stderr /app/tools/tengine/logs/error.log  #错误日志stderr标准输出

自动实现dockerfile实现

• dockerfile概述
• 我们目前都是手动拉取镜像,手动进行配置,手动安装依赖,手动编译安装,创建用户…,这个过程类似于命令行使用ansible模块（繁琐，不方便重复执行）
• 书写Dockerfile把之前手动创建自定义镜像的过程,通过Dockerfile里面的指令实现.类似于书写playbook.
• Dockerfile用于根据要求自动创建镜像

Dockerfile格式

• Dockerfile使用

1.使用目录Dockerfile
[[email protected] /server/dockfile/01-centos-nginx]# cat Dockerfile
FROM centos:7
LABEL author="kiku"

RUN curl  -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
RUN curl  -o /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
RUN yum -y install nginx
RUN rm -rf /usr/share/nginx/html/index.html
RUN echo 'oldboyedu linux' > /usr/share/nginx/html/index.html

CMD ["nginx","-g","daemon off;"]

2.根据Dockerfile构建镜像
 docker build . -t 'nginx:1.20.2-centos7'
 
3.运行
docker run  -d --name 'nginx-1.20.1-centos7-01'  -p 81:80  nginx:1.20.2-centos7

4.调试

Dockerfile 中的指令

• 都是大写的

Dockerfile指令	含义	应用	建议
Dockerfile开头部分
FROM	指定基本镜像类似于docker pull 下载镜像	FROM ubuntu:20.04	尽量写 镜像名:tag 的形式详细标注版本号
LABEL	用于指定容器属性信息，作者，维护者，个人联系方式	LABEL maintainer=“kiku [email protected]”	推荐使用LABEL,不推荐使用下面的MAINTAINER
MAINTAINER	不再使用，推荐使用LABEL
ENV/ARG	用于创建Dockerfile中使用的容器ENVG构建和运行都有效(ARG在容器运行后失效)	ENV Tengine_Version空格2.3.3	软件版本可以创建使用变量
Dockerfile中间部分
RUN	制作镜像过程中需要的执行命令，通常系统配置,服务配置,部署。但不能出现阻塞当前终端的命令。	RUN 系统命令即可.	不建议使用连续多个RUN.合并多个RUN
ADD	可以把指定文件或目录拷贝到容器中(指定目录),压缩包解压.相对于当前目录.	ADD restart.tar.gz空格/app/code/restart/	拷贝压缩包使用
COPY	可以把指定文件或目录拷贝到容器中(指定目录),不支持自动解压.相对于当前目录.	COPY nginx.conf空格/etc/nginx/nginx.conf	拷贝文件或目录.
WORKDIR	指定容器的默认目录	WORKDIR /tmp/	一般用于配合ADD,COPY需要书写容器中路径指令.Dockerfile中使用相对路径操作容器.
VOLUME	挂载数据卷	VOLUME /usr/share/nginx/html	创建随机数据卷挂载容器的目录.未来推荐docker run的时候指定 -v即 可
Dockerfile结尾部分书写的内容分
EXPOSE	指定镜像要对外暴露的端口	EXPOSE 80	用于指定一个或多个容器的端口.未来这个端口可以被-P识别. xxxx:80
CMD	用于指定容器的入口命令入口命令可以在docker run的时候被替换	CMD [“命令”,“参数01”,“参数02”]. CMD [“nginx”,“-g”,“daemon off;”]	大部分都会使用CMD.
ENTRYPOINT	用于指定容器的入口命令入口命令不可以在docker run的时候被替换，dockerrun指定的时候仅仅作为命令的参数而已.	ENTRYPOINT [“executable”,“param1”, “param2”]	使用不多.

• 更多指令https://docs.docker.com/engine/reference/builder/
• 核心指令
  • FROM
  • LABEL
  • RUN
  • COPY
  • EXPOSE
  • CMD

编译tengine变成Dockerfile

• Docker书写流程

• 手动创建镜像

• 把对应的步骤通过Dockerfile实现

1.创建对应文件  对应目录
/server/dockerfile/tengine-ubu
root@docker tengine-ubu]# echo dockerfile.kiku.cn >index.html
[root@docker tengine-ubu]# ll
总用量 8
-rw-r--r-- 1 root root 1390 5月  24 22:19 Dockerfile
-rw-r--r-- 1 root root   26 5月  24 21:30 index.html

2.创建Dockerfile
[root@docker tengine-ubu]# cat Dockerfile
FROM ubuntu:20.04
LABEL maintainer='kiku [email protected]' author='kiku'
#####make tengine######
RUN  sed -ri 's#archive.ubuntu.com|security.ubuntu.com#mirrors.aliyun.com#g'   /etc/apt/sources.list \
  && apt-get update \
  && apt-get install -y wget libssl-dev make gcc pcre2-utils libpcre3-dev zlib1g-dev \
  && wget -P /tmp/ http://tengine.taobao.org/download/tengine-2.3.3.tar.gz \
  && cd /tmp \
  && tar xf tengine-2.3.3.tar.gz \
  && cd tengine-2.3.3/ \
  && ./configure --prefix=/app/tools/tengine-2.3.3/  \
     --user=nginx \
     --group=nginx \
     --with-http_ssl_module \
     --with-http_v2_module   \
     --with-http_realip_module \
     --with-http_stub_status_module \
     --with-http_mp4_module \
     --with-stream  \
     --with-stream_ssl_module   \
     --with-stream_realip_module   \
     --add-module=modules/ngx_http_upstream_check_module/ \
     --add-module=modules/ngx_http_upstream_session_sticky_module \
  && make \
  && make install \
  && groupadd nginx \
  &&  useradd -g nginx nginx \
  && ln -s /app/tools/tengine-2.3.3 /app/tools/tengine \
  && ln -s /app/tools/tengine/sbin/nginx /sbin
#####clean for tengine#######
RUN  rm -fr /tmp/* \
  && rm -fr /var/cache/*
#####copy index.html#########
COPY index.html /app/tools/tengine/html/index.html
######port80################
EXPOSE 80

#######CMD ##################
CMD ["nginx","-g","daemon off;"]
3.创建镜像
docker build -t "tengine:2.3.3-dockerfile" .
4.运行镜像检查
[root@docker tengine-ubu]# docker run -d --name "tengine_2.3.3-dockerfile" -p 80:80 tengine:2.3.3-dockerfile
f6a1852360e93ee7d6cfe0e8bcc9a2477c8afd7a58141aefcd605a051901e7f3

docker自动化

案例02 使用变量

[root@docker tengine-ubu]# cat Dockerfile
FROM ubuntu:20.04
LABEL maintainer='kiku [email protected]' author='kiku'
#####ENV vars#########
ENV  Web_User="nginx"
ENV  Web_Server="tengine"
ENV  Web_Version="2.3.3"
ENV  Server_Dir="/app/tools/tengine-2.3.3/"
EVN  Server_Dir_Soft="/app/tools/tengine"
#####make tengine######
RUN  sed -ri 's#archive.ubuntu.com|security.ubuntu.com#mirrors.aliyun.com#g'   /etc/apt/sources.list \
  && apt-get update \
  && apt-get install -y wget libssl-dev make gcc pcre2-utils libpcre3-dev zlib1g-dev \
  && wget -P /tmp/ http://tengine.taobao.org/download/${Web_Server}-${Web_Version}.tar.gz \
  && cd /tmp \
  && tar xf ${Web_Server}-${Web_Version}.tar.gz \
  && cd ${Web_Server}-${Web_Version}/ \
  && ./configure --prefix=/app/tools/${Web_Server}-${Web_Version}/  \
     --user=${Web_User} \
     --group=${Web_User} \
     --with-http_ssl_module \
     --with-http_v2_module   \
     --with-http_realip_module \
     --with-http_stub_status_module \
     --with-http_mp4_module \
     --with-stream  \
     --with-stream_ssl_module   \
     --with-stream_realip_module   \
     --add-module=modules/ngx_http_upstream_check_module/ \
     --add-module=modules/ngx_http_upstream_session_sticky_module \
  && make \
  && make install \
  && groupadd ${Web_User} \
  &&  useradd -g ${Web_User} ${Web_User} \
  && ln -s ${Server_Dir} ${Server_Dir_Soft} \
  && ln -s ${Server_Dir_Soft}/sbin/nginx /sbin
#####clean for tengine#######
RUN  rm -fr /tmp/* \
  && rm -fr /var/cache/*
#####copy index.html#########
COPY index.html ${Server_Dir_Soft}/html/index.html
######port80################
EXPOSE 80

#######CMD ##################
CMD ["nginx","-g","daemon off;"]

CMD与ENTRYPOINT

CMD与ENTRYPOINT,目前大部分使用CMD即可.

支持mysql和redis 的php

FROM php:7.4.29-fpm-alpine
LABEL Description='Extension gd mysqli pdo-mysql redis' Author='kiku'

ENV URL https://pecl.php.net/get/redis-5.3.7.tgz
ENV DIR /usr/src/php/ext/

RUN     sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories \
     && apk add zlib-dev libpng-dev libwebp-dev libjpeg-turbo-dev freetype-dev \
     && docker-php-source extract \
     && wget -P /tmp ${URL} \
     && tar xf /tmp/redis-5.3.7.tgz -C ${DIR}/ \
     && mv ${DIR}/redis-5.3.7 ${DIR}/redis \
     && cd ${DIR}/gd \
     && docker-php-ext-configure gd \
        --enable-gd \
        --with-webp \
        --with-jpeg \
        --with-freetype \
     && docker-php-ext-install gd \
     && cd ${DIR} \
     && docker-php-ext-install mysqli \
     && docker-php-ext-install pdo_mysql \
     && docker-php-ext-install redis \
     && addgroup -g 101 nginx \
     && adduser -s /sbin/nologin -D -S -H -u 101 -G nginx nginx \
     && sed -i 's#www-data#nginx#g' /usr/local/etc/php-fpm.d/www.conf \
     && rm -fr /var/cache/* /tmp/* /usr/src/php

EXPOSE 9000

CMD ["php-fpm"]

多服务镜像nginx+php

1.创建的目录
[root@docker php-nginx]# ll
总用量 30948
-rw-r--r-- 1 root root      659 5月  25 21:23 Dockerfile
-rwxr-xr-x 1 root root       43 5月  25 17:20 entrypoint.sh
-rw-r--r-- 1 root root 14056586 5月  25 21:14 kodexp01.tar.gz
-rw-r--r-- 1 root root      319 5月  25 16:02 kod.kiku.cn.conf
-rw-r--r-- 1 root root      653 5月  25 16:02 nginx.conf
-rw-r--r-- 1 root root 17614731 5月  25 16:21 php7.2.34-kiku.tar.gz

2.Dockerfile的内容
[root@docker php-nginx]# cat Dockerfile
FROM centos:7
LABEL author=kiku nginx_ver=1.20.2 php_ver=7.2.34
ENV Php_Tar="php7.2.34-kiku6.tar.gz"
ADD ${Php_Tar} /tmp/
ADD kodexp01.tar.gz  /app/code/kod/
COPY entrypoint.sh /
COPY nginx.conf /etc/nginx/nginx.conf
COPY kod*.conf /etc/nginx/conf.d/
RUN   curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo \
   && curl -o /etc/yum.repos.d/repel.repo http://mirrors.aliyun.com/repo/epel-7.repo \
   && yum install  -y nginx \
   && yum localinstall -y /tmp/php7.2.34-kiku/*.rpm \
   && sed -i 's#apache#nginx#g' /etc/php-fpm.d/www.conf \
   && rm -fr /tmp/* /var/cache/*
EXPOSE 80 9000
CMD ["/entrypoint.sh"]

3.entrypoint.sh内容
[root@docker php-nginx]# cat entrypoint.sh
#!/bin/bash
php-fpm
nginx -g "daemon off;"

4.kod.oldboylinux.cn.conf 内容
[root@docker php-nginx]# cat kod.kiku.cn.conf
server {
  listen 80;
  server_name kod.kiku.cn;
  root /app/code/kod;
  location / {
    index index.php;
  }

  location ~ \.php$ {
    fastcgi_pass 127.0.0.1:9000;
    fastcgi_index  index.php;
    fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
    include        fastcgi_params;

  }

}

5.nginx.conf内容
[root@docker php-nginx]# cat nginx.conf
user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;
    ##
    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}
[root@docker php-nginx]#

⚠️我的站点目录打包的是已经chown完毕的

6.创建镜像
docker build -t web:nignx_php_v3

多阶段提交

在1个dockerfile中使用多个FROM。以减少最终镜像的大小

FROM x x x AS temp (起一个别名)

FROM XXX

COPY --from=temp /app/ /app/. (引用别名中的什么文件)

• tengine+restart项目多阶段提交

  • 创建镜像的时候起一个别名。FROM XXX AS temp
  • 对中间镜像进行操作，下载依赖，下载软件包，编译
  • 创建镜像 FROM ubuntu 20:40
  • 把中间镜像的命令，配置文件/目录复制到最终镜像中COPY --from=temp …
  • 复制代码
  • EXPOSE 80 设置入口指令CMD

FROM ubuntu:20.04 AS temp
LABEL maintainer='[email protected]' author='kiku'

#####make tengine######
RUN  sed -ri 's#archive.ubuntu.com|security.ubuntu.com#mirrors.aliyun.com#g'   /etc/apt/sources.list \
  && apt-get update \
  && apt-get install -y wget libssl-dev make gcc pcre2-utils libpcre3-dev zlib1g-dev \
  && wget -P /tmp/ http://tengine.taobao.org/download/tengine-2.3.3.tar.gz \
  && cd /tmp \
  && tar xf tengine-2.3.3.tar.gz \
  && cd tengine-2.3.3/ \
  && ./configure --prefix=/app/tools/tengine-2.3.3/  \
     --user=nginx \
     --group=nginx \
     --with-http_ssl_module \
     --with-http_v2_module   \
     --with-http_realip_module \
     --with-http_stub_status_module \
     --with-http_mp4_module \
     --with-stream  \
     --with-stream_ssl_module   \
     --with-stream_realip_module   \
     --add-module=modules/ngx_http_upstream_check_module/ \
     --add-module=modules/ngx_http_upstream_session_sticky_module \
  && make \
  && make install \
  && groupadd nginx \
  &&  useradd -g nginx nginx \
  && ln -s /app/tools/tengine-2.3.3 /app/tools/tengine \
  && ln -s /app/tools/tengine/sbin/nginx /sbin
####################
FROM ubuntu:20.04
COPY --from=temp /app/ /app/
RUN  sed -ri 's#archive.ubuntu.com|security.ubuntu.com#mirrors.aliyun.com#g'   /etc/apt/sources.list \
  && apt-get update \
  && apt-get install -y wget libssl-dev  pcre2-utils libpcre3-dev zlib1g-dev \
  && groupadd nginx \
  && useradd -g nginx nginx \
  && ln -s /app/tools/tengine/sbin/nginx /sbin

#######make image######
ENV Web_Code_File="restart.tar.gz"
RUN rm -fr /usr/share/tengine/html/*
ADD ${Web_Code_File}  /usr/share/nginx/html/
######image you########
EXPOSE 80
CMD ["nginx","-g","daemon off;"]

• 构建与运行

docker build -t tengine:restart-2.3.3-mini .

docker run  -d --name "tengine_restart_v1" tengine:restart-2.3.3-mini

• 访问浏览器

容器互联–link

–link 是用于容器连接其他容器的选项，其他容器要运行中才行。

案例分离式 nginx+php

–link用于容器之间连接nginx---->php , php—>db

• docker镜像架构分层次
• 基础：系统
• 服务：nginx ,php,tomcat,jdk…
• 业务：kodexp

1.创建目录
 root@docker kodexp]# ll
总用量 12
drwxrwxrwx 7 root root 4096 5月  25 17:06 code
drwxr-xr-x 2 root root 4096 5月  25 23:05 conf
drwxr-xr-x 2 root root 4096 5月  25 22:40 data


2.拉去相关镜像
php:7-fpm-alpine3.15
nginx:1.20.2-alpine
3.在目录中填入相关的配置文件
[root@docker kodexp]# tree -L 1 conf/
conf/
├── kod.kiku.conf    ##里面要把 fastcgi_pass php:9000; 改了
├── nginx.conf  
└── www.conf

[root@docker kodexp]# cat conf/www.conf
[www]
user = www-data
group = www-data
listen = 0.0.0.0:9000
pm = dynamic
pm.max_children = 5
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3

[root@docker kodexp]# tree -L 1 code/
code/     #要chmod -R 777 code/
├── app
├── ChangeLog.md
├── config
├── data
├── index.php
├── plugins
├── README.MD
└── static
4.启动镜像
docker run -d --name "kodexp_php" \
-v /server/kodexp/conf/www.conf:/usr/loacl/etc/php-fpm.d/www.conf \
-v /server/kodexp/code:/app/code/kod \
php:7-fpm-alpine3.15

docker run -d --name "kodexp_nginx" -p 80:80 \
--link kodexp_php:php \
-v /server/kodexp/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /server/kodexp/conf/kod.kiku.cn.conf:/etc/nginx/conf.d/kod.kiku.cn.conf \
-v /server/kodexp/code:/app/code/kod/ \
nginx:1.20.2-alpine

总结

• 手动创建镜像

• Dockerfile格式

  • 第一部分-用于指定使用的镜像，设置镜像属性，设置变量
  • 第二部分-对镜像处理
  • 第三部分-指定端口，指定入口命令/脚本。

• Dockerfile指令

  • 第一部分用于指定使用的镜像，设置镜像属性，设置变量

    • FROM ubuntu:20.04
    • LABEL author=“kiku”
    • ENV Server_Version 2.3.3

  • 第二部分-对镜像处理

    • RUN
    • COPY
    • ADD
    • WORKDIR. 修改容器当前目录
    • VOLUME。给容器内部的目录，设置随机数据卷，持久化，未来通过docker run -v
    • USER。运行程序是使用的用户

  • 第三部分-指定端口，指定入口命令/脚本

    • EXPOSE 方便查看得知容器端口 -p随机端口 -p :expose的端口。。。
    • CMD
    • ENTRYPOINT

docker compose

• 单机编排工具
• docker compose+docker swarm 实现集群管理，未来我们通过k8s实现集权管理
• docker三剑客：docker machine (管理虚拟机)，dcoker compose(容器编排)，docker swarm (集群)
• docker compose 需要单独安装（epel源中就有）

compose极速上手指南

• yum install -y docker-compose

• 环境准备

  • mkdir -p /server/compose/01-run-nginx

支持的文件名字

compose.yaml

compose.yml

docker-compose.yaml

docker-compose.yml

文件格式

1.书写格式
[root@docker compose]# cat php-nginx01/docker-compose.yml
version: "3.3"
services:
  web_ngx:
    image: "nginx:1.20.2-alpine"
    links:
      - web_php
    ports:
      - "8000:80"
  web_php:
    image: "php:7-fpm"
    
2.启动命令一定要在当前目录内
docker-compose up -d

docker-compose命令格式

• 容器
  • up -d up=run。创建容器启动的时候后台运行 docker run -d
  • stop/start/restart. 关闭，开启，重启容器
  • ps. 查看容器运行情况，只有-q 选项
  • top 容器进程信息
  • logs 容器日志
  • rm 删除容器
• 镜像
  • images 查看镜像

⚠️如果docker-compose简单修改端口,数据卷.docker-compose up -d 会自动识别,重新创建容器.

⚠️如果容器的名字也改了会造成新旧容器端口冲突会失败，可以 docker-compose up -d --remove-orphans

compose文件的常用指令

• 挂载数据卷
• 容器之间的依赖，先后顺序
• depends_on: 依赖，先启动指定的容器然后再启动当前容器.
• volumes:数据卷
• 其他看官网:https://docs.docker.com/compose/compose-file/compose-file-v3

docker镜像仓库

本地私有仓库极速上手指南

• 安装，配置，使用
• 环境规划

cat >> /etc/hosts<

• 下载registry. docker pull registry
• 配置（docker服务端准许使用http）(未来使用私有镜像仓库都要配置)
• 使用启动registry未来可以docker compose实现指定端口5000 挂载映射容器中的/var/lib/registry/
• 测试上传

1.下载registry.        
docker pull  registry
2.配置（docker服务端准许使用http）(未来使用私有镜像仓库都要配置)
[root@docker01 ~]# cat  /etc/docker/daemon.json
{
  "registry-mirrors": ["https://bjjtv7cs.mirror.aliyuncs.com"],
  "insecure-registries":["reg.linux.cn:5000"]
}
3.使用启动registry未来可以docker compose实现指定端口5000 挂载映射容器中的/var/lib/registry/
docker run -d --name "registry01" -p 5000:5000 -v /var/lib/registry  --restart=always registry:latest
4.测试上传 （上传的要先给打好标签）然后推送到私有仓库
 docker tag mysql:5.7-debian reg.linux.cn:5000/kiku/mysql:5.7-debian

 docker push reg.linux.cn:5000/kiku/mysql:5.7-debian

从私有仓库下载

docker pull reg.linux.cn:5000/kiku/mysql:5.7-debian

• 实现registry镜像私有仓库即可
• 补充：-v 随机挂载容器中的/data/registry/:/var/lib/registry/目录.
• 自己把启动registry写成docker compose

彩蛋

安装ansible部署 docker

#devops机器
python3的ansible
yum install -y python3-pip rust
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade pip
pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip3 install  setuptools_rust
pip3 install  ansible
pip3 install docker==2.6.1

#docker01 docker02机器
yum install -y python3-pip 
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade pip
pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip3 install docker==2.6.1

#删除下载的依赖docker
pip3 uninstall docker

检查安装成功命令
devops机器:  
pip3 list |egrep 'ansible|docker' 
docker01 docker02  pip3 list |grep docker 
有显示即可.

部署docker的重启策略

##容器重启
docker run --restart=always
docker run --restart=unless-stopped
###
no    默认重启策略：永不重启
on-failure 异常退出，重启docker均重启，若不置指定max-retries,表示重启次数不上线，等效于always
on-failure:3 异常退出，重启docker有条件重启(3次之后不在重启)
unless-stopped 异常退出会自动重启，除非停止docker服务之前容器已被停止，否则每次启动容器时均会重启容器
always 总是重启

docker 底层原理

namespace

Linux Namespace是Linux系统提供的一种资源隔离机制，可实现系统资源隔离的列表如下:
	IPC:
		用于隔离进程间通信。
	MNT:
		用于隔离文件系统和提供硬盘挂载点。
	NET:
		用于隔离网络。
	PID:
		用于隔离进程ID。
	User:
		用于隔离用户和用户组。
	UTS:
		用于隔离HostName和DomianName。

cgroup

全称Linux Control Group， 是Linux内核的一个功能，用来限制，控制与分离一个进程组群的资源（如CPU、内存、磁盘输入输出等）。

OverlayFS

联合文件系统,是一种堆叠文件系统,它依赖并建立在其它的文件系统之上

copy on write 写时复制

docker inspect 容器. 查看overlay2

overlayFS