目录
1.初识Docker
1.1.Docker概念
1.2.安装Docker
1.3.docker架构
3.docker命令
3.1.进程相关命令
3.2.镜像相关命令
3.3.容器相关命令
4.Docker容器的数据卷
4.2配置数据卷
4.3配置数据卷容器
5.Docker应用部署
5.1.MySQL部署
5.2.Tomcat部署
5.3.Nginx部署
5.4.Redis部署
6.Dockerfifile
6.1. Docker镜像原理
6.2. 镜像制作
7.服务编排
7.1. 概念
7.2. Docker Compose
7.3 编排nginx+springboot
8.Docker私有仓库
8.1. 私有仓库搭建
8.2. 将镜像上传至私有仓库
1.初识Docker
学习运维和部署的一个工具Docker
问题分析：我们写的代码会接触到好几个环境：开发环境、测试环境以及生产环境：Docker.它可以解决有效解决开发环境和测试环境不一致的情况。
将开发产品和环境一起打包交给测试人员，生成容器这样一个概念，测试人员不再使用自己的测试环境测试，而是使用容器中的产品和环境进行测试，为了规避产品迁移引发的环境问题，我们把产品和产品依赖的相关环境一起打包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux 机器上，这样一个过程就是docker解决的问题。
容器是完全使用沙箱机制，相互隔离
容器性能开销极低。
1.1.Docker概念
Docker 是一个开源的应用容器引擎
诞生于 2013 年初，基于 Go 语言实现， dotCloud 公司出品（后改名为 Docker Inc ）
Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux 机器上。
容器是完全使用沙箱机制，相互隔离
容器性能开销极低。
Docker 从 17.03 版本之后分为 CE （Community Edition: 社区版） 和 EE （Enterprise Edition: 企版）
总结：docker是一种容器技术，他解决容器环境迁移问题
1.2.安装Docker
安装
Docker可运行在MAC、Windows、CentOS、UBUNTU等操作系统上，基于CentOS 7 安Docker。
官网： https://www.docker.com
# 1 、 yum 包更新到最新
yum update
# 2 、安装需要的软件包， yum-utils 提供 yum-config-manager 功能，另外两个是 devicemapper 驱动依赖的
yum install -y yum-utils device-mapper-persistent-data lvm2
# 3 、 设置 yum 源
# 官方源,网速太慢yum断连，不建议
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 阿里源，国内速度快 （本文设置这个源，安装成功）
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 4 、 安装 docker ，出现输入的界面都按 y (-y表示确认)
yum install -y docker-ce
# 5 、 查看 docker 版本，验证是否验证成功
docker -v
镜像加速器
阿里云镜像获取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors，登陆后，左侧菜单选中镜像加速器就可以看到你的专属阿里云镜像加速器地址了：
在 /etc/docker/daemon.json ，文件末尾增加如下内容
{ "registry-mirrors": ["https://你的
ID.mirror.aliyuncs.com"] }
开始安装：
虚拟机装的Centos7，linux 3.10 内核，docker官方说至少3.8以上，建议3.10以上（ubuntu下要linux内核3.8以上
1，root账户登录，查看内核版本如下
2，（可选）把yum包更新到最新(生产环境慎重！yum update会对软件包和内核升级，此处只是为了排除系统环境的影响
等会
3，安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的
4，设置yum源
5，可以查看所有仓库中所有docker版本，并选择特定版本安装
yum list docker-ce --showduplicates | sort -r
6，安装Docker，命令：yum install docker-ce-版本号，我选的是17.12.1.ce，如下
yum install docker-ce-17.12.1.ce
7， 启动Docker，命令：systemctl start docker，然后加入开机启动，如下
8，验证安装是否成功(有client和service两部分表示docker安装启动都成功了)
9.添加镜像加速器专属地址到docker的/etc/docker/daemon.json中
重启
1.3.docker架构
Docker架构分为三个部分，第一部分就是docker客户端相当于docker命令行，通过docker命令操作镜像或者容器，这些命令发送给宿主机host的守护进程daemon，这个daemon就相当于运行的docker，docker接收到命令后，如果操作的是镜像，从中央的docker hub中下载镜像。host又分为local和remote，这里有两个重点，一个是镜像image一个是容器container，镜像和容器的关系相当于类和对象，容器是由镜像产生的在宿主机中由沙箱机制独立存在，可以理解为独立运行的另外一个系统，这是docker的基本架构，它和maven很像，也是从中央仓库下载，如果不设置镜像加速器，就会从中央仓库下载，一般我们都是通过设置阿里云镜像加速器，从阿里云私服中获取镜像。
镜像 (Image ） ： Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。
容器（ Container ） ：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样， 镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
仓库（ Repository ） ：仓库可看成一个代码控制中心，用来保存镜像。
3.docker命令
3.1.进程相关命令
启动 docker 服务: systemctl start docker
停止 docker 服务: systemctl stop docker
重启 docker 服务: systemctl restart docker
查看 docker 服务状态: systemctl status docker
设置开机启动 docker 服务: systemctl enable docker
进入docker目录 cd /etc/docker
查看docker根路径 docker info | grep -i "docker root dir"
查看docker剩余空间 df -hl docker根路径 或者df -hl 这个需要自己找
查看docker镜像/容器/数据卷数 docker system df
删除所有停止的容器 docker system prune
3.2.镜像相关命令
镜像命令包括如下内容：查看镜像、搜索镜像 、拉取镜像 、删除镜像
查看镜像: 查看本地所有的镜像
docker images
docker images –q # 查看所用镜像的 id
搜索镜像:从网络中查找需要的镜像
docker search 镜像名称
docker search redis # 查找 redis 镜像
拉取镜像 : 从 Docker 仓库下载镜像到本地，镜像名称格式为 名称 : 版本号，如果版本号不指定则是最新的版本 lastest。
如果不知道镜像版本，可以去 Docker Hub 搜索对应镜像查看。
docker pull 镜像名称
docker pull redis # 下载最新版本 redis
docker pull redis:5.0 # 下载 5.0 版本 redis
删除镜像: 删除本地镜像
docker rmi 镜像 id # 删除指定本地镜像，或根据镜像名:版本号删除
docker images -q # 查看所有的镜像id列表
docker rmi `docker images -q` # 删除所有本地镜像(Esc下的飘号)
从Docker仓库拉取redis镜像到本地~
查看本地所有镜像
删除本地某个镜像
3.3.容器相关命令
查看容器、创建容器、进入容器、启动容器、停止容器、删除容器、查看容器信息
查看容器
docker ps # 查看正在运行的容器信息
docker ps –a # 查看所有容器信息
docker ps –aq # 查看所有容器的id
创建并启动容器
docker run 参数
参数说明：
-i ：保持容器运行。通常与 -t 同时使用。加入 it 这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭。
-t ：为容器重新分配一个伪输入终端，通常与 -i 同时使用。
-d ：以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用 docker exec 进入容器。退出后，容器不会关闭。
-it 创建的容器一般称为交互式容器， -id 创建的容器一般称为守护式容器
--name ：为创建的容器命名。
docker run -it --name=c1 centos:7 /bin/bash # 创建交互式容器
docker run -id --name=c2 centos:7 # 创建守护式容器
注意：交互式容器， exit 后容器自动关闭，守护式容器会在后台执行
进入容器
docker exec -it c2 /bin/bash # 进入容器
退出容器
exit
停止容器
docker stop 容器名称
启动容器
docker start 容器名称
删除容器 ：如果容器是运行状态则删除失败，需要停止容器才能删除
docker rm 容器名称 删除单个容器
docker ps –aq`
查看容器信息
docker inspect 容器名称
查看容器日志
docker logs 容器名
从docker仓库拉取centos7镜像，相当于在宿主机中(192.168.153.138)再创建个linux centos系统，
/bin/bash是一个初始化指令，相当于打开shell脚本，可以不写
查看宿主机中正在运行的容器，查看所有容器
交互式容器，exit后容器自动关闭，-id守护式容器会在后台执行。
进入指定的容器(已启动)
-it 创建的容器一般称为交互式容器，-id 创建的容器一般称为守护式容器，
-t为容器重新分配一个伪输入终端，-i：保持容器运行，
交互式容器在docker run创建启动后就会进入容器，exit退出后容器自动关闭，守护式容器启动后需要docker exec 进入容器，exit后容器还会在后台执行，docker stop来关闭容器
help命令查看有哪些参数组合
docker ps --help
docker run --help等
4.Docker容器的数据卷
思考：
Docker 容器删除后，在容器中产生的数据还在吗？
不再，因为容器是沙箱机制，删除后就不再了，怎么持久化容器数据，就需要在数据卷中完成，也就是在宿主机中写一个目录映射容器中的目录。
Docker 容器和外部机器可以直接交换文件吗？
外部机器不能直接访问容器，但外部机器可以访问宿主机，宿主机和容器是连接的。
容器之间想要进行数据交互？
使用数据卷。
数据卷概念
数据卷是宿主机中的一个目录或文件
当容器目录和数据卷目录绑定后，对方的修改会立即同步
一个数据卷可以被多个容器同时挂载
一个容器也可以被挂载多个数据卷
数据卷的作用
容器数据持久化
外部机器和容器间接通信
容器之间数据交换
4.2配置数据卷
创建启动容器时，使用 –v 参数 设置数据卷
docker run ... –v 宿主机目录 ( 文件 ): 容器内目录 ( 文件 ) ...
注意事项：
1. 容器目录必须是绝对路径
2. 如果目录不存在，会自动创建(宿主机目录和容器目录)
3. 可以挂载多个数据卷
演示数据卷持久化(-it交互式容器)
创建 c1 挂载宿主机目录 /root/data 到容器目录 /root/data_container
docker run -it --name=c1 -v /root/data:/root/data_container centos:7 /bin/bash
关闭容器，可以看到数据卷数据文件还在
docker stop c1
宿主机目录还在
删除容器 c1
docker rm c1
宿主机目录还在
重新恢复 c1
docker run -it --name=c1 -v ~/data:/root/data_container centos:7 /bin/bash
注意在容器中不能写 ~
演示一个容器挂载多个数据卷
docker run -it --name=c2 \
-v ~/data2:/root/data2 \
-v ~/data3:/root/data3 \
centos:7
两个容器挂载同一个数据卷
docker run -it --name=c3 -v /root/data:/root/data_container centos:7 /bin/bash
docker run -it --name=c4 -v /root/data:/root/data_container centos:7 /bin/bash
在一个容器中修改文件，看到另一个容器也跟着修改
演示容器持久化：
创建并启动centos镜像的容器c1，先docker ps -a查看所有docker中所有容器(开启/关闭)，发现有c1容器，那么需要systemctl stop c1关闭后，再docker rm c1 移除容器，才能重新创建重名的c1容器，并通过-v设置数据卷。-it创建的是交互式容器，启动后直接进入容器，查看到容器中存在data_container目录，
新建一个连接，查看宿主机中有data目录
在容器目录data_container中创建文件a.txt，在宿主机data目录中会同步，其操作的是同一个目录，操作的都是宿主机的数据卷目录。
验证能否持久化，因为c1是交互式容器，exit退出容器同时关闭容器，把c1删除，
此时宿主机的数据卷目录绑定的c1容器数据还在的
当我们重新创建启动容器c1，
数据仍在
演示一个容器挂载多个数据卷
~表示root目录，在宿主机中可以使用，但容器中只能使用绝对路径
\ 表示换行
下面通过centos:7镜像创建启动容器c2，并挂载(绑定/映射)宿主机的两个数据卷，先删除c2容器
容器绑定多个数据卷 换行写 也可以
下面查看宿主机的数据卷目录中数据是否同步
演示两个容器挂载同一个数据卷，那么这两个容器就可以交互了，对一个容器的修改，另一个容器也会同步，绑定宿主机数据卷后，对容器的操作其实就是对数据卷的操作。在c3容器中创建文件并填写数据后，c4容器也会及时同步。
创建c3容器并绑定数据卷目录/root/data1
新建new Tab,创建c4并绑定数据卷目录/root/data1
在c3容器中vi创建文件并填写数据后，c4容器也会及时同步。
c4同步
4.3配置数据卷容器
多容器进行数据交换，多个容器挂载同一个数据卷容器，完成数据交互
c1、c2容器不是和数据卷直接挂载，而是挂载在容器3上，c3就成为数据卷容器，c3需要挂载数据卷，即使c3容器关闭掉，也不影响c1、c2容器使用c3的用到的数据卷，这三个容器使用的是同一个数据卷。
1. 创建启动 c3 数据卷容器，使用 –v 参数 设置数据卷
docker run –it --name=c3 –v /volume centos:7 /bin/bash
这里没有指定宿主机目录，默认生成一个宿主机目录，/volume是c3容器目录(自定义)
docker inspect c3 # 查看 c3
2. 创建启动 c1 c2 容器，使用 –-volumes-from 参数 设置数据卷
docker run -it --name=c1 --volumes-from c3 centos:7 /bin/bash
docker run -it --name=c2 --volumes-from c3 centos:7 /bin/bash
c1 c2挂载c3的命令是volumes-from，通过挂载c3数据卷容器，让c1 c2使用c3使用的数据卷
演示
首先关闭所有的容器，然后删除所有容器(重名)
创建启动c3数据卷容器，没有指定宿主机目录，默认生成一个宿主机目录，/volume是c3容器目录(自定义)，centos:7是镜像
创建启动 c1 容器，使用 –-volumes-from挂载在c3数据卷容器
创建启动 c2 容器，使用 –-volumes-from挂载在c3数据卷容器
c2容器挂载在c3数据卷容器上，默认生成的宿主机数据卷目录和c3容器的/volume目录挂载，而c1 c2容器挂载在c3容器上，所以c1 c2上都会存在/volume目录，现在在c2容器/volume中创建文件，添加数据
查看c3 c1容器，对应的volume目录中都会同步数据a.txt
当数据卷容器c3关闭掉，不影响c1 c2容器使用数据卷
修改c1容器中/volume/a.txt内容，然后查看c2容器
然后查看c2容器，修改同步
容器c3是和宿主机数据卷目录绑定的，c3删除后，再重新创建启动挂载到之前的额宿主机数据卷仍可以使用。
数据卷小结
1. 数据卷概念
宿主机的一个目录或文件
2. 数据卷作用
容器数据持久化
客户端和容器数据交换
容器间数据交换
3. 数据卷容器
创建一个容器，挂载一个目录，让其他容器继承自该容器( --volume-from ) 。
通过简单方式实现数据卷配置和多容器间数据的交互。
5.Docker应用部署
5.0.外部机器如何访问宿主机容器提供的服务
容器内的网络服务和外部机器不能直接通信
外部机器和宿主机可以直接通信
宿主机和容器可以直接通信
当容器中的网络服务需要被外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的端口，从而间接访问容器的服务。
这种操作称为： 端口映射
5.1.MySQL部署
1. 搜索mysql镜像
docker search mysql
2. 拉取mysql镜像
docker pull mysql:5.6
3. 创建容器，设置端口映射、目录映射
# 在 /root 目录下创建 mysql 目录用于存储 mysql 数据信息
mkdir ~/mysql
cd ~/mysql
创建守护式容器c_mysql，设置端口映射
docker run -id \
-p 3307 :3306 \
--name = c_mysql \
-v $PWD /conf:/etc/mysql/conf.d \
-v $PWD /logs:/logs \
-v $PWD /data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD = 123456 \
mysql:5.6
docker run -p 13306:3306 --name my-mysql -v /usr/local/workspace/mysql/conf:/etc/mysql -v /usr/local/workspace/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.26
参数说明：
$PWD表示当前目录 -v容器与数据卷的挂载
-p 3307:3306 ：将容器的 3306 端口映射到宿主机的 3307 端口。
-v $PWD/conf:/etc/mysql/conf.d ：将主机当前目录下的 conf 挂载到容器的 /etc/mysql/my.cnf。配置目录
-v $PWD/logs:/logs ：将主机当前目录下的 logs 目录挂载到容器的 /logs 。日志目录
-v $PWD/data:/var/lib/mysql ：将主机当前目录下的 data 目录挂载到容器的 /var/lib/mysql 。数据目录
-e MYSQL_ROOT_PASSWORD=123456 ： 初始化 root 用户的密码。
4. 进入容器，操作mysql
docker exec -it c_mysql /bin/bash
mysql -uroot -p123456
show databases;
create database db1;
5. 使用外部机器连接容器中的mysql
演示：
搜索mysql镜像
拉取mysql镜像
创建mysql目录，创建容器，设置端口映射、目录映射
查看正在运行的容器，有c_mysql
进入c_mysql容器(就是一个mysql数据库文件),
连接c_mysql数据库
操作数据库
外部机器连接宿主机(虚拟机上的机器)上的mysql容器，新建一个连接
之前在c_mysql容器中创建的db1数据库
创建表
在宿主机的c_mysql容器中查看
5.2.Tomcat部署
1. 搜索tomcat镜像
docker search tomcat
2. 拉取 tomcat 镜像
docker pull tomcat
3. 创建容器，设置端口映射、目录映射
# 在 /root 目录下创建 tomcat 目录用于存储 tomcat 数据信息
mkdir ~/tomcat
cd ~/tomcat
docker run -id --name = c_tomcat \
-p 8080 :8080 \
-v $PWD :/usr/local/tomcat/webapps \
tomcat
参数说明：
-p 8080:8080 ： 将容器的 8080 端口映射到主机的 8080 端口
-v $PWD:/usr/local/tomcat/webapps ：将主机中当前目录挂载到容器的webapps
4. 使用外部机器访问 tomcat
演示
搜索tomcat镜像
拉取最新版本的镜像
创建/root/tomcat作为宿主机的数据卷目录，创建tomcat容器，挂载在宿主机数据卷目录
正在运行的容器
在数据卷中创建test/index.html
以后写的应用想往tomcat部署，直接拷贝给宿主机的数据卷tomcat目录中，
访问宿主机数据卷/root/tomcat中的项目
5.3.Nginx部署
1. 搜索 nginx 镜像
docker search nginx
2. 拉取 nginx 镜像(没有版本就是最新版)
docker pull nginx
3. 创建容器，设置端口映射、目录映射
# 在 /root 目录下创建 nginx 目录用于存储 nginx 数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在 ~/nginx/conf/ 下创建 nginx.conf 文件 , 粘贴下面内容
vim nginx.conf
user nginx;
worker_processes 1 ;
error_log /var/log/nginx/error.log warn;
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 ;
include /etc/nginx/conf.d/*.conf;
}
创建容器，端口映射，目录映射
docker run -id --name = c_nginx \
-p 80 :80 \
-v $PWD /conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD /logs:/var/log/nginx \
-v $PWD /html:/usr/share/nginx/html \
nginx
参数说明：
-p 80:80 ：将容器的 80 端口映射到宿主机的 80 端口。
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf ：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf 。配置目录
-v $PWD/logs:/var/log/nginx ：将主机当前目录下的 logs 目录挂载到容器的 /var/log/nginx 。日志目录
-v $PWD /html:/usr/share/nginx/html 是nginx部署目录
4. 使用外部机器访问 nginx
演示
创建 nginx 目录用于存储 nginx 数据信息
在~/nginx/conf/下创建nginx.conf配置文件，使用默认的nginx配置完文件
安装(创建启动)nginx容器
在数据卷目录/root/nginx中的部署目录html中，部署，它是nginx的部署目录
5.4.Redis部署
1. 搜索redis镜像
docker search redis
2. 拉取redis镜像
docker pull redis:5.0
3. 创建容器，设置端口映射d
docker run -id --name = c_redis -p 6379 :6379 redis:5.0
4. 使用外部机器连接 redis
./redis-cli.exe -h 192 .168.220.12 -p 6379
keys *
set name lxs
get name
演示：
拉取redis镜像
查看镜像
创建并启动c_redis容器
查看正在运行的容器
外部机器连接并添加数据
进入docker的redis容器，查看数据
6.Dockerfile
6.1. Docker镜像原理
思考：
Docker 镜像本质是什么？
Docker 中一个 centos 镜像为什么只有 200MB ，而一个 centos 操作系统的 iso 文件要几个个 G ？
Docker 中一个 tomcat 镜像为什么有 600MB ，而一个 tomcat 安装包只有 70 多 MB ？
操作系统组成部分：
进程调度子系统
进程通信子系统
内存管理子系统
设备管理子系统
文件管理子系统
网络通信子系统
作业控制子系统
Linux 文件系统由 bootfs 和 rootfs 两部分组成
bootfs ：包含 bootloader （引导加载程序）和 kernel （内核）
rootfs ： root 文件系统，包含的就是典型 Linux 系统中的 /dev ， /proc ， /bin ， /etc 等标准目录和文件
不同的 linux 发行版， bootfs 基本一样，而 rootfs 不同，如 ubuntu ， centos 等
docker 镜像原理
Docker 镜像是由特殊的文件系统叠加而成
最底端是 bootfs ，并使用宿主机的 bootfs
第二层是 root 文件系统 rootfs, 称为 base image
然后再往上可以叠加其他的镜像文件
统一文件系统（ Union File System ）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统。
一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像成为基础镜像。
当从一个镜像启动容器时， Docker 会在最顶层加载一个读写文件系统作为容器
回答问题
1. Docker 镜像本质是什么？
是一个分层文件系统
2. Docker 中一个 centos 镜像为什么只有 200MB ，而一个 centos 操作系统的 iso 文件要几个个 G ？
Centos 的 iso 镜像文件包含 bootfs 和 rootfs ，而 docker 的 centos 镜像复用操作系统的 bootfs ，只有 rootfs 和其他镜像层
3. Docker 中一个 tomcat 镜像为什么有 600MB ，而一个 tomcat 安装包只有 70 多 MB ？
由于 docker 中镜像是分层的， tomcat 虽然只有 70 多 MB ，但他需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat 镜像大小 600 多 MB
6.2. 镜像制作
6.2.1 容器转镜像
将容器转成新的镜像交给测试人员
docker commit 容器 id 镜像名称 : 版本号
将镜像压缩成压缩文件
docker save -o 压缩文件名称 镜像名称 : 版本号
压缩文件转成镜像
docker load –i 压缩文件名称
当我们在镜像上面创建可写容器后，可以将这个容器通过命令转成镜像，然后再把镜像压缩成压缩文件，然后这个压缩交给测试人员或者部署人员，部署或运维人员就可以将压缩文件转成镜像进行测试，对应的三个命令如上。
# 创建 tomcat 容器
docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat
# 进入 tomcat 容器
docker exec -it c_tomcat /bin/bash
# 创建 a.txt b.txt
cd ~
touch a.txt b.txt
# 容器转镜像
docker commit 28b8d4dc9744 lxs_tomcat:1.0
# 压缩镜像
docker save -o lxs_tomcat.tar lxs_tomcat:1.0
# 删除原来镜像
docker rmi lxs_tomcat:1.0
# 从压缩文件加载镜像
docker load -i lxs_tomcat.tar
# 产生镜像
docker run -it --name=new_tomcat lxs_tomcat:1.0 /bin/bash
# 进入查看内容
docker exec -it c_tomcat /bin/bash
# 可以看到 a.txt b.txt 存在，而 webapps/test 不存在
演示：
创建启动 tomcat容器 ，之前已经创建并启动，并且挂载在宿主机的数据卷目录/root/tomcat
现在进入c_tomcat容器，查看webapps下内容
现在在c_tomcat容器的webapps下创建test01,webapps目录是挂载在宿主机数据卷目录/root/tomcat
在c_tomcat容器的/root目录下创建a.txt和b.txt, 这个目录没有挂载
新开会话，在宿主机数据卷/root/tomcat中修改test中的index.html，添加内容：
<h2>hello docker tomcat 2</h2>
当然容器c_tomcat中的index.html也会同步
问题是，当容器转成镜像时，数据卷操作的数据是不会被存入镜像，也就是说，当把生成的镜像转成压缩包交给测试人员，测试人员解压后得到的镜像，获取其容器后，是不存在数据卷操作的数据的。下面测试
下面开始把c_tomcat容器转成一个镜像cbw_tomcat:1.0，在宿主机环境中转，不能在容器中转
然后将生成的镜像cbw_tomcat:1.0压缩成文件，(可以发给运维/测试人员)
先删除原来的镜像cbw_tomcat:1.0和容器c_tomcat， 假设当前会话是测试人员会话，测试人员拿到了容器转成镜像的压缩包，然后解压这个tar（从压缩文件加载镜像）
现在测试人员拿到了这个镜像，现在创建启动这个镜像的容器 ，进入tomcat容器。webapps下没有test，/root下有a.txt b.txt，
6.2.2 dockerfile制作镜像
概念
Dockerfile 是一个文本文件
包含了一条条的指令
每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
对于开发人员：可以为开发团队提供一个完全一致的开发环境
对于测试人员：可以直接拿开发时所构建的镜像或者通过 Dockerfile 文件构建一个新的镜像开始工作了
对于运维人员：在部署时，可以实现应用的无缝移植,只要对方系统支持docker
参考 Dochub 网址： https://hub.docker.com ，比如 centos 和 nginx 镜像
案例一：自定义centos7镜像
要求：
1. 默认登录路径为 /usr
2. 可以使用 vim
实现步骤
定义父镜像： FROM centos:7
定义作者信息： MAINTAINER cbw cbw @cbw.cn
执行安装 vim 命令： RUN yum install -y vim
定义默认的工作目录： WORKDIR /usr
定义容器启动执行的命令： CMD /bin/bash
通过 dockerfile 构建镜像： docker bulid –f dockerfifile 文件路径 –t 镜像名称 : 版本 .
具体代码
mkdir ~/docker-files
cd ~/docker-files
vim centos_dockerfile
dockerfile 具体内容
FROM centos:7
MAINTAINER cbw <cbw@cbw.cn>
RUN yum install -y vim
WORKDIR /usr
CMD /bin/bash
通过 dockerfile 构建镜像
docker build -f ./centos_dockerfile -t cbw_centos:1 .
-f ：镜像文件
-t ：新镜像名
. 寻址路径
进入看效果
docker run -it --name=c2 cbw_centos:1
演示：
官方的centos镜像，产生的centos容器默认的目录是根路径/，有vi命令，但没有vim命令
下面通过dockerfile基于centos:7镜像构建一个新的镜像，dockerfile中对新镜像定义，定义父镜像、添加vim指令、定义默认的工作目录等
已经有了镜像文件
下面通过镜像文件centos_dockerfile构建一个新镜像cbw_centos:1
查看镜像
创建并启动该镜像容器，查看默认路径是/usr，并且可以执行vim指令
案例二：发布springboot项目
定义父镜像： FROM java:8
定义作者信息： MAINTAINER cbw cbw @163.com
将 jar 包添加到容器： ADD springboot.jar app.jar
定义容器启动执行的命令： CMD ["java","-jar","app.jar"]
通过 dockerfile 构建镜像： docker build –f dockerfile 文件路径 –t 镜像名称 : 版本 .
FROM java:8
MAINTAINER cbw <cbw@163.com>
ADD springboot.jar app.jar
CMD ["java","-jar","app.jar"]
通过 dockerfile 构建镜像
docker build –f ./springboot_dockerfile –t app .
启动容器
docker run -id -p 9000:8080 app
演示
maven构建项目
输入cmd，进入dos窗口，输入java -jar hello-springboot-1.0-SNAPSHOT.jar运行项目
浏览器访问
下面将这个springboot通过dockerfile部署到容器中
首先将构建的项目拖拽到shell窗口中
修改简单点的项目名，这样我们要发布的springboot项目的jar文件准备好了
下面使用dockerfile文件发布项目到容器中，首先定义dockerfile文件springboot_dockerfile,添加
FROM java:8
MAINTAINER cbw <cbw@163.com>
ADD springboot.jar app.jar
CMD ["java","-jar","app.jar"]
通过dockerfile构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本 .
docker build -f ./springboot_dockerfile -t app .
docker run -id -p 9000:8080 app，容器可以不起名字，docker会起名字
docker run -id --name=spt -p 9000:8080 app
下面可以访问了
7.服务编排
7.1. 概念
微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启动停止，维护的工作量会很大。来看下我们日常工作：
要从 Dockerfile build image 或者去 dockerhub 拉取 image
要创建多个 container
要管理这些 container （启动停止删除）
通过服务编排可以大量简化上面的工作 服务编排：按照一定的业务规则批量管理容器
7.2. Docker Compose
Docker Compose 是一个编排多容器分布式部署的工具，提供命令集中管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：
1. 利用 Dockerfile 定义运行环境镜像
2. 使用 docker-compose.yml 定义组成应用的各服务
3. 运行 docker-compose up 启动应用
7.2.1. 安装Docker Compose
# Compose 目前已经完全支持 Linux 、 Mac OS 和 Windows ，在我们安装 Compose 之前，需要先安装 Docker 。下面我 们以编译好的二进制包方式安装在Linux 系统中。
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose- `uname -s` - `uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限
chmod + x /usr/local/bin/docker-compose
# 查看版本信息
docker-compose -version
7.2.2 卸载Docker Compose
# 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose
7.3 编排nginx+springboot
需求：使用 nginx 反向代理到 springboo 应用
服务编排案例：
这个案例有两个服务，一个是nginx服务，一个是上面用dockerfile部署的springboot服务，只需要提供对应的镜像，至于容器的创建启动等交给docker服务编排根据docker compose。
当我们访问nginx 80端口时候，提供nginx反向代理机制反向到springboot的8080端口
1. 创建 docker-compose 目录
mkdir ~/docker-compose
cd ~/docker-compose
2. 编写 docker-compose.yml 文件
version: '3'
services:
nginx:
image: nginx
ports:
- 80 :80
links:
- app
volumes:
- ./nginx/conf.d:/etc/nginx/conf.d
app:
image: app
expose:
- "8080"
3. 创建 ./nginx/conf.d 目录
mkdir -p ./nginx/conf.d
4. 在 ./nginx/conf.d 目录下 编写 app.conf 文件
server {
listen 80 ;
access_log off;
location / {
proxy_pass http://app:8080/hello;
}
}
5. 在 ~/docker-compose 目录下 使用 docker-compose 启动容器
docker-compose up -d # -d 表示已守护模式启动
6. 测试访问
演示：
首先创建文件夹存方服务编排的配置文件
编写服务编排的配置文件，内容：
版本随便写，services就是我们要编排的两个服务，分别是nginx服务和app服务(两个容器)，服务名称随便写，nginx服务来源于nginx镜像，app服务来自app镜像，nginx中通过宿主机的80端口映射nginx容器80端口，用links在当前容器(nginx)中连接其它容器(app)，也就是app容器，连接后，就可以使用app这个别名连接app容器，在数据卷volumes配置中，将宿主机数据卷目录与ngxin容器挂载，nginx做的反向代理的配置就是在宿主机数据卷目录中。在app服务中指定镜像和暴露端口
./nginx/conf.d中配置nginx的反向代理
先创建文件 -p 递归创建
./nginx/conf.d目录下编写app.conf文件，在这里监听80端口，当访问80端口，自动代理到http://app:8080/hello，这里可以使用app代替ip是因为在当前nginx容器下关联了app容器，如果使用ip地址的话，容器的动态启动产生的ip地址不一样
在~/docker-compose 目录下 使用docker-compose up 启动容器
docker-compose up -d # -d 表示以守护模式启动
首先查看没有容器已经启动
测试访问 http://192.168.153.139/hello
8.Docker私有仓库
Docker 官方的 Docker hub （ https://hub.docker.com ）是一个用于管理公共镜像的仓库，我们可以从上面拉 取镜像 到本地，也可以把我们自己的镜像推送上去。但是，有时候我们不希望将自己的镜 像放到公网当中， 那么这时我们就需要搭建自己的私有仓库来存储和管理自己的镜像
8.1. 私有仓库搭建
# 1 、拉取私有仓库镜像
docker pull registry
# 2 、启动私有仓库容器
docker run -id --name = registry -p 5000 :5000 registry
# 3 、打开浏览器 输入地址 http:// 私有仓库服务器 ip:5000/v2/_catalog ，看到 {"repositories":[]} 表示私有仓库 搭建成功
# 4 、修改 daemon.json
vim /etc/docker/daemon.json
# 在上述文件中添加一个 key ，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器 ip 修改为自己私有仓库服务器真实ip
{ "insecure-registries" :[ " 私有仓库服务器 ip:5000" ]}
{ "insecure-registries" :[ "192.168.153.139:5000" ]}
# 5 、重启 docker 服务
systemctl restart docker
docker start registry
# 打开浏览器 输入地址 http:// 私有仓库服务器 ip:5000/v2/_catalog ，看到 {"repositories":[]} 表示私有仓库 搭建成功
演示：
拉取私有仓库镜像，创建启动私有仓库
配置daemon.json
重启docker
启动私有仓库容器registry
访问
8.2. 将镜像上传至私有仓库
# 1 、标记镜像为私有仓库的镜像
docker tag centos:7 192.168.153.139 :5000/centos:7
# 2 、上传标记的镜像
docker push 192.168.153.139 :5000/centos:7
8.8.3. 从私有仓库拉取镜像
# 拉取镜像
docker pull 192.168.153.139 :5000/centos:7
拉取前先删除docker中镜像对应的标记镜像
