Docker学习

一：Docker 简介

　　Docker 是一个开源的容器引擎，可以轻松的为任何应用创建一个轻量级的、可移植的、自给自足的容器。开发者和系统管理员在笔记本上编译测试通过的容器可以批量地在生产环境中部署，包括 VMs（虚拟机）、bare metal、OpenStack 集群、云端、数据中心和其他的基础应用平台。容器是完全使用沙箱机制，相互之间不会有任何接口。

1：Docker特点

　　Docker通俗的讲，是服务器中高性能的虚拟机，可以将一台物理机虚拟N多台虚拟机的机器，互相之间隔离，互不影响

1：容器将应用打包成标准化单元，用于交付、部署；
2：容器及包含了软件运行所需的所有环境，而且非常轻量级
3：容器化的应用程序，可以在任何Linux环境中始终如一的运行
4：容器化的应用程序，具备隔离性，这样多团队可以共享同一Linux系统资源

2：Docker与VM ware比较

特性    　　　　　容器    　　　　　　虚拟机
启动    　　　　　秒级    　　　　　　分钟级
硬盘使用    　　 一般为MB    　　　　一般为GB
性能    　　　　接近原生硬件    　　   弱鸡
系统支持量    单机可跑几十个容器    单机几个虚拟OS
运行环境    　  主要在Linux    　　 主要在window

相同：容器和虚拟机都是虚拟化技术，具备资源隔离和分配优势
不同：
　　  容器虚拟化的是操作系统，虚拟机虚拟化的是硬件
　　  传统虚拟机可以运行不同的操作系统，容器主要运行同一类操作系统(Linux)

 3：Docker 基本概念

**宿主机：
　　安装Docker守护进程的Linux服务器，称之为宿主机；
**镜像（Image）：
　　Docker 镜像，就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 
　　最小系统的 root 文件系统。
**容器（Container）：
　　镜像运行之后的实体，镜像和容器的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，
　　容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
**仓库（Repository）：
　　仓库可看成一个代码控制中心，用来保存镜像。

 二：Docker安装与启动

　　Docker官方建议在Ubuntu中安装，因为Docker是基于Ubuntu发布的，而且一般Docker出现的问题Ubuntu是最先更新或者打补丁的。在很多版本的CentOS中是不支持更新最新的一些补丁包的。由于我当前环境都使用的是CentOS，因此这里我们将Docker安装到CentOS上。注意：这里建议安装在CentOS7.x以上的版本，在CentOS6.x的版本中有Bug

1：安装

注：如果不是管理员登录请为每行命令的前面加上 sudo
1：yum 包更新到最新
    sudo yum update
2：安装需要的软件包（正常是已经有此依赖了），yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的
    yum install -y yum-utils device-mapper-persistent-data lvm2
3：为了更快下载，设置yum源为阿里云
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4：安装Docker
    yum install docker-ce
5：安装过后查看Docker版本
    docker -v
最终打印：
    [root@VM-8-15-centos ~]# docker -v
    Docker version 20.10.2, build 2291f61

2：Docker守护进程相关命令

注：systemctl命令是系统系统服务管理器指令
1：启动Docker
    systemctl start docker
2：停止Docker
    systemctl stop docker
3：重启Docker
    systemctl restart docker
4：查询Docker状态
    systemctl status docker
5：设置开机自启Docker
    systemctl enable docker
6：查询安装的Docker详细信息
    docker info

[root@VM-8-15-centos ~]# docker info
Client:
  Context:    default
  Debug Mode: false
  Plugins:
    app: Docker App (Docker Inc., v0.9.1-beta3)
    buildx: Build with BuildKit (Docker Inc., v0.5.1-docker)

Server:
  //当前系统容器总数
  Containers: 0
    //运行的容器总数
    Running: 0
    //暂停的容器总数
    Paused: 0
    //停止的容器总数
    Stopped: 0
  //镜像总数
  Images: 0
  //Docker版本
  Server Version: 20.10.2
  //存储驱动为overlay2,docker的镜像是分层构建，联合挂载。而分层构建，联合
  //挂载要求必须使用特殊的文件系统才能实现，这里的实现有aufs和overlay2两种方式。
  Storage Driver: overlay2
    Backing Filesystem: extfs
    Supports d_type: true
    Native Overlay Diff: true
  Logging Driver: json-file
  Cgroup Driver: cgroupfs
  Cgroup Version: 1
  Plugins:
    Volume: local
    Network: bridge host ipvlan macvlan null overlay
    Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
  Swarm: inactive
  Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc
  Default Runtime: runc
  Init Binary: docker-init
  containerd version: 269548fa27e0089a8b8278fc4fc781d7f65a939b
  runc version: ff819c7e9184c13b7c2607fe6c30ae19403a7aff
  init version: de40ad0
  Security Options:
    seccomp
       Profile: default

  //本机系统内核版本
  Kernel Version: 3.10.0-1127.19.1.el7.x86_64
  //本机操作系统
  Operating System: CentOS Linux 7 (Core)
  //本机系统类型
  OSType: linux
  //本机系统架构
  Architecture: x86_64
  //本机cpu总数
  CPUs: 1
  //本机总内存
  Total Memory: 1.795GiB
  //本机昵称
  Name: VM-8-15-centos
  ID: ZAAJ:3BOI:VZDO:VE63:N54K:EPG6:ENFA:DOFR:SLVC:JIUL:JPVL:7MZ2
  //docker安装目录
  Docker Root Dir: /var/lib/docker
  Debug Mode: false
  //docker的中心仓库地址 下载死慢
  Registry: https://index.docker.io/v1/
  Labels:
  Experimental: false
  Insecure Registries:
    127.0.0.0/8
  //是否启用实时恢复
  Live Restore Enabled: false

 3：Docker镜像加速

 　　我们默认下载镜像是从 https://hub.docker.com/ 进去直接搜索无需登录，但是使用此链接下载docker镜像太慢；所以我们就要镜像加速；中国科学技术大学(ustc)是老牌的linux镜像服务提供者了，还在遥远的ubuntu 5.04版本的时候就在用。ustc的docker镜像加速器速度很快。ustc docker mirror的优势之一就是不需要注册，是真正的公共服务。https://lug.ustc.edu.cn/wiki/mirrors/help/docker

1：编辑docker的配置文件设置镜像下载路径
    vim /etc/docker/daemon.json
2：编辑当前文件，设置下载镜像路径，有2种镜像选一种
    //使用阿里镜像
    { 
        "registry-mirrors": ["https://3ad96kxd.mirror.aliyuncs.com"] 
    }
    //或者使用中科大镜像
    {
        "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
    }
3：如果你想自己注册阿里镜像，你们可以自己去注册，会给你分配一个免费docker镜像加速地址
4：配置完成后刷新配置文件
    sudo systemctl daemon-reload
5：有必要的重写启动docker
    sudo systemctl restart docker

 三：Docker镜像常用命令

1：镜像相关命令

1：查看本地下载的所以镜像
    docker images
2：中心仓库搜索查找的镜像 [ 保证docker可联网 ]
    docker search  镜像名称[:tag]
3：拉取中心仓库指定镜像
    docker pull 镜像名称[:tag]
4：删除本地镜像 可根据ID或name
    docker rmi 镜像ID
5：删除本地全部镜像
    docker rmi `docker images -q`

//查看本地下载的所以镜像
[root@VM-8-15-centos ~]# docker images
 镜像名称   镜像标签      镜像ID      镜像创建时间     镜像大小
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
mysql        5.7       cc8775c0fe94   47 hours ago   449MB
centos       8         300e315adb2f   5 weeks ago    209MB

//中心仓库搜索查找的镜像
//拉取镜像:从Docker仓库下载镜像到本地，镜像名称格式为 名称:版本号，
//不指定版本号则是最新的版本 如：mysql:latest 最新版本
//如果不知道镜像版本，可以去docker hub 搜索对应镜像查看。
[root@VM-8-15-centos ~]# docker search mysql
名称                   镜像描述           用户评价  是否官方构建发布    自动构建
NAME                 DESCRIPTION          STARS     OFFICIAL        AUTOMATED
mysql                MySQL is a widely…   10380     [OK]            
mariadb              MariaDB is a comm…   3848      [OK]            
mysql/mysql-server   Optimized MySQL S…   758                       [OK]
percona              Percona Server is…   519       [OK]            

拉取中心仓库指定镜像 这里mysql版本我已经下载过了，所以无法再次下载
[root@VM-8-15-centos ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
Digest: sha256:e08834258fcc0efd01df358222333919df53d4a0d9b2a54da05b204b822e3b7b
Status: Image is up to date for mysql:5.7
docker.io/library/mysql:5.7

//删除指定镜像
[root@VM-8-15-centos ~]# docker rmi mysql:5.7
//删除全部镜像
[root@VM-8-15-centos ~]# docker rmi `docker images -q`

四：Docker容器常用命令 

1：容器基本操作

1：创建容器命令语法
    docker run -参数 [--name=镜像名称] 镜像名称:镜像标签 [/bin/bash]
    具体参数：
    -i：表示运行容器
    -t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去
        即分配一个伪终端(如果只加it两个参数，创建后就会自动进去容器)
    -d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器）
    --name :为创建的容器命名。
    -v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多
        个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上
    -p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射

进入容器之后，初始化执行的命令：/bin/bash；可写可不写
2：交互式容器 ==> 就是创建一个容器并直接进入该容器
    docker run -ti [--name=镜像名称] 镜像名称:镜像标签 [/bin/bash]
3：守互式容器 ==> 就是创建一个容器运行，但并不会直接进入
    docker run -di [--name=镜像名称] 镜像名称:镜像标签 [/bin/bash]
4：登录容器 登录为/bin/bash命令的必须加上此命令
    docker exec -it 容器名称或容器ID /bin/bash
5：退出容器
    exit
6：查询正在运行的容器
    docker ps -参数
    具体参数：  
        -a :显示所有的容器，包括未运行的
        -f :根据条件过滤显示的内容
        -l :查看最后一次运行的容器
        -n :列出最近创建的n个容器
7：查看停止的容器
    docker ps -f status=exited
8：停止容器
    docker stop 容器名称（或者容器ID）
9：启动容器
    docker start 容器名称（或者容器ID）
10：删除容器
　　 docker rm 容器名称（容器ID） 

//创建守护式容器
[root@VM-8-15-centos ~]# docker run -di --name=con_centos8A centos:8 /bin/bash
1b1a73978ae80b2e248a7afff0d594a9ae5ac00d8012abe14df9472d5e13c4a3
//创建交互式容器
[root@VM-8-15-centos ~]# docker run -ti --name=con_centosAB centos:8 /bin/bash
//直接进入容器了，退出容器
[root@e0ffb51ddfe3 /]# exit
exit
//查询全部容器
[root@VM-8-15-centos ~]# docker ps -a
  容器ID    镜像名称：镜像标签  命令模式     创建时间     容器状态 up代表上线        端口     名称
CONTAINER ID   IMAGE         COMMAND      CREATED        STATUS                 PORTS   NAMES
e0ffb51ddfe3   centos:8      "/bin/bash"  17 seconds ago Exited (0) 9 seconds ago     con_centosAB
1b1a73978ae8   centos:8      "/bin/bash"  43 seconds ago Up 42 seconds                con_centos8A
//进入容器
[root@VM-8-15-centos ~]# docker exec -it 1b1a739 /bin/bash
//退出容器
[root@1b1a73978ae8 /]# exit
exit
//启动容器
[root@VM-8-15-centos ~]# docker start e0ffb51d
e0ffb51d  
//查询运行容器
[root@VM-8-15-centos ~]# docker ps 
CONTAINER ID   IMAGE      COMMAND       CREATED              STATUS         PORTS     NAMES
e0ffb51ddfe3   centos:8   "/bin/bash"   About a minute ago   Up 7 seconds             con_centosAB
1b1a73978ae8   centos:8   "/bin/bash"   2 minutes ago        Up 2 minutes             con_centos8A
//停止容器
[root@VM-8-15-centos ~]# docker stop e0ffb51dd
e0ffb51dd
//删除ID为e0ffb51ddfe容器  id可以写一般，如果写一个字母的ID 不存在冲突也是可以的
[root@VM-8-15-centos ~]# docker rm e0ffb51ddfe
e0ffb51ddfe
[root@VM-8-15-centos ~]# docker ps -a
CONTAINER ID   IMAGE      COMMAND       CREATED         STATUS         PORTS     NAMES
1b1a73978ae8   centos:8   "/bin/bash"   3 minutes ago   Up 3 minutes             con_centos8A
[root@VM-8-15-centos ~]# 

2：宿主机和容器之间的文件拷贝

友情提醒别再容器里面操作这些命令，因为压根没有docker
宿主机与容器之间的文件拷贝
1：从把宿主机的文件拷贝到容器
                宿主机文件    容器名 : 目标文件夹
    docker cp /root/aaa.txt con_centos8A:/root
2：把容器中的文件拷贝到宿主机
                容器名 : 目标文件夹        宿主机文件
    docker cp con_centos8A:/root/bbb.txt /root

3：查看容器基本信息及IP地址

1：查询容器具体信息
    docker inspect 容器名称（容器ID）
2：直接查询容器里面的IP地址信息
    docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

 五：Docker数据卷

1：数据卷概述

　　考虑到容器的隔离性问题我们发现Docker容器被删除后，在容器里的产生的数据还在吗？Docker容器和外部机器可以直接交换文件吗？还有就是我们只能使用上面介绍的docker cp...来回的在容器和宿主机之间拷贝文件吗？

　　其实数据卷是宿主机中的一个目录或文件，当容器目录和数据卷目录绑定后，对方的修改会立即同步；一个数据卷可以被多个容器同时挂载，一个容器也可以被挂载多个数据卷，这和Vue中的双向绑定一样，双方有一方变化都会影响另一方

　　数据卷作用：1 容器数据持久化；2 外部机器和容器间接通信；3 容器之间数据交换

 2：数据卷配置方式

（1）：一个容器挂载一个或多个数据卷

命令：docker run ... –v 宿主机目录(文件):容器内目录(文件) ... 
注意事项：
　　 0：数据卷就是宿主机的指定文件夹
    1：目录必须是绝对路径
    2：如果宿主机目录不存在，会自动创建
    3：可以挂载多个数据卷   如： docker run ... -v ***:*** -v ***:*** ...
示例：docker run -di -v /root/host_data1:/root/con_data --name=con_centos8C centos:8 /bin/bash 

（2）：多个容器挂载一个数据卷

示例：docker run -di -v /root/host_data1:/root/conD_data --name=con_centos8D centos:8
示例：docker run -di -v /root/host_data1:/root/conE_data --name=con_centos8E centos:8

（3）：多个容器挂载一个容器上面（这里的被挂载的容器挂载一个数据卷）

创建启动c_centosA数据卷容器，使用 –v 参数 设置数据卷
容器A：docker run -di -v /root/host_data:/root/c_dataA --name=c_centosA centos:8
创建启动 c_centosB c_centosC 容器，使用 –-volumes-from 参数 设置数据卷
容器B：docker run -di --volumes-from c_centosA --name=c_centosB centos:8
容器C：docker run -di --volumes-from c_centosA --name=c_centosC centos:8

容器A：docker run -di -v /root/host_data:/root/c_dataA --name=c_centosA centos:8
9273eb53444167fbdab0a436d7e8a41c2bb51d3ef08266c76acecf1d67a56248
容器B：docker run -di --volumes-from c_centosA --name=c_centosB centos:8
822a7029a67ea407f97bb1a723635fadf156aec129ca6a77b7601d132aae1312
容器C：docker run -di --volumes-from c_centosA --name=c_centosC centos:8
90539993fbaf11603829ec75a3f07af073d2e950d3d5c50789f99724816fa9f3

//查询全部容器
[root@VM-8-15-centos ~]# docker ps -a
CONTAINER ID   IMAGE      COMMAND       CREATED              STATUS              PORTS     NAMES
90539993fbaf   centos:8   "/bin/bash"   About a minute ago   Up About a minute             c_centosC
822a7029a67e   centos:8   "/bin/bash"   2 minutes ago        Up 2 minutes                  c_centosB
9273eb534441   centos:8   "/bin/bash"   2 minutes ago        Up 2 minutes                  c_centosA
//查询宿主机数据卷
[root@VM-8-15-centos ~]# ls /root
host_data
//进入 c_centosA容器 我用前两位ID进入的
[root@VM-8-15-centos ~]# docker exec -ti 90 /bin/bash
//查询被挂载的 c_dataA 文件夹
[root@90539993fbaf ~]# ls /root
anaconda-ks.cfg  anaconda-post.log  c_dataA  original-ks.cfg
[root@90539993fbaf ~]# exit
exit
//进入 c_centosB容器 我用前两位ID进入的
[root@VM-8-15-centos ~]# docker exec -ti 82 /bin/bash
//查询被挂载的 c_dataA 文件夹 
[root@822a7029a67e /]# ls /root
anaconda-ks.cfg  anaconda-post.log  c_dataA  original-ks.cfg
[root@822a7029a67e /]# exit
exit
//进入 c_centosC容器 我用前两位ID进入的
[root@VM-8-15-centos ~]# docker exec -ti 92 /bin/bash
//查询被挂载的 c_dataA 文件夹
[root@9273eb534441 /]# ls /root
anaconda-ks.cfg  anaconda-post.log  c_dataA  original-ks.cfg

 六：在Docker中部署应用

1：Docker中MySQL部署

1：搜索MySQL镜像
    官方镜像   docker search mysql
2：拉取MySQL镜像
    docker pull mysql:5.7
3：创建容器、设置端口映射、设置数据卷
    docker run -di --name=c_mysql -p 3306:3306 -v /root/mysql/logs:/logs -v /root/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=1234 mysql:5.7
        -p 3307:3306：
            将容器的 3306 端口映射到宿主机的 3306 端口   宿主机端口：容器端口
        -v /root/mysql/logs:/logs：
            将主机目录(/root/mysql)下的 logs 目录挂载到容器中的 /logs。日志目录
        -v /root/mysql/data:/var/lib/mysql ：
            将主机目录(/root/mysql)下的data目录挂载到容器的 /var/lib/mysql 。数据目录
        -e MYSQL_ROOT_PASSWORD=1234：初始化 root 用户的密码。
4：进入容器操作mysql
    docker exec -ti c_mysql /bin/bash
5：在容器内部登录数据库
    mysql -uroot -p1234
6：个人笔记本连接Docker容器部署的MySQL
    mysql -h ip地址 -P 3306 -uroot -p1234

# 创建数据库
create database if not exists demo_school charset gbk;
# 创建表 
use demo_school;
# 创建学生表
create table if not exists student (
    sid int(11) primary key auto_increment,           
    sname varchar(5) not null,                        
    ssex enum('男','女') default '男',                
    sage tinyint(11) unsigned not null default 20,    
    scredit double(3,1) default 60.0,                 
    smoney decimal(4,1) default 0,                    
    saddress varchar(10),                             
    senrol date  default  '2020-12-12'      
)charset gbk;
# 添加学生数据
insert into student(sid,sname,saddress)values
(1 ,"王生安","安徽六安"),(2 ,"李鑫灏","安徽合肥"),
(3 ,"薛佛世","安徽蚌埠"),(4 ,"蔡壮保","安徽安庆"),
(5 ,"钱勤堃","安徽合肥"),(6 ,"潘恩依","安徽合肥"),
(7 ,"陈国柏","安徽六安"),(8 ,"魏皑虎","安徽六安"),
(9 ,"周卓浩","安徽六安"),(10,"汤辟邦","安徽六安"),
(11,"张顺谷","安徽淮南"),(12,"张悌斯","安徽淮南"),
(13,"张灶冲","安徽蚌埠"),(14,"章晞旺","安徽淮南");
# 开始更新数据 对表进行完善
update student set 
ssex=ceil(rand()*2),sage=ceil(rand()*5+20),
scredit=floor(rand()*100),smoney=(rand()*999),
senrol=concat(ceil(rand()*3+2017),'-' , ceil(rand()*12) , '-',ceil(rand()*20));
# 查询数据
select * from student limit 5;
select '数据插入完成 OK' as success;

注：MySQL中的字符编码问题解决

// 其实我们在往数据库插入中文数据时会乱码，这就牵扯到字符集的问题
// 下面这个是我装好的数据库编码，按照正常我们接下来就设置编码
// 我准备直接修改配置文件，这样不用我们每次启动都要设置编码了
mysql> show variables like '%character%';
+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client     | latin1                     |
| character_set_connection | latin1                     |
| character_set_database   | latin1                     |
| character_set_filesystem | binary                     |
| character_set_results    | latin1                     |
| character_set_server     | latin1                     |
| character_set_system     | utf8                       |
| character_sets_dir       | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)
MySQL数据库的配置文件都在 /etc/mysql 里面
MySQL数据库数据文件都在 /var/lib/mysql里面

//修改 /etc/mysql/my.cnf
# 添加如下内容
[mysqld]
character-set-server=gbk
[client]
default-character-set=gbk
[mysql]
default-character-set=gbk

//奥，对了想起来在容器里面是没有 vi 和vim 编辑器的 我们得先安装
    apt-get update       #更新
    apt-get install vim  #安装vim
修改好就保存文件就行  最好重启容器 在容器内部操作有中文乱码现象，我们使用本地连接方式连接就可以了

 2：Docker中Tomcat部署

1：搜索Tomcat镜像
    官方镜像   docker search tomcat:9
2：拉取Tomcat镜像
    docker pull tomcat:9
3：创建容器、设置端口映射、设置数据卷
    docker run -di --name=c_tomcat -p 8080:8080 -v /root/tomcat/webapps:/usr/local/tomcat/webapps tomcat:9
4：向Tomcat中部署服务 扔一个war包放到 /usr/local/tomcat/webapps 下 后面有介绍
5：使用外部机器访问Tomcat，测试部署服务

注：向Tomcat中部署服务

　　我们在部署war包之前先检测当前Tomcat容器内部是否存在JDK（一般下载都会自带一个）；在容器内部 cd /usr/local 命令查看是否有jdk，或者使用 java --version 命令查看是否有java，如果没有的话大家安装一个JDK，然后解压到容器里面，并设置一下 vim /etc/profile 设置java环境变量

1：首先使用 java --version 查看是否存在java
2：把下载的JDK解压到容器内部的 /usr/local/ 目录下
    tar -zxvf 压缩包 
3：更改环境变量文件
    vim /etc/profile  
    把下面这3句加到文件里
    export JAVA_HOME=当前你解压得到的jdk具体位置
    export PATH=$JAVA_HOME/bin:$PATH
    export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

补充：没有vi 或者vim的容器执行如下命令
    apt-get update       #更新
    apt-get install vim  #安装vim

　　有了java环境后，我们就得部署war包到tomcat里面的，因为我们在创建Tomcat容器的时候设置了数据卷，所以我们只要把war包导入宿主机的 /root/tomcat/webapps 目录下即可，通过双向绑定，自动更改容器内部的webapps文件夹；导入后无需解压，容器自动解压；还要就是如果要进入tomcat容器要使用docker exec  -ti tomcat容器名 /bin/bash 

七：Docker镜像原理

 　　我们来思考这样一个问题，为什么Dcoker中centos镜像只要200MB左右，而centos操作系统的IOS镜像却几个G？还有就是一个Docker中tomcat镜像只有500MB，但是一个tomcat安装包却只有10MB左右？为了可以理解，我们就得剖析原理　

　　其实Linux文件系统由bootfs和rootfs两部分组成(fs == file system)
　　　　bootfs：包含bootloader（引导加载程序）和 kernel（内核）
　　　　rootfs： root文件系统，包含的就是典型 Linux 系统中的/dev，/proc，/bin，/etc等标准目录和文件
　　不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等

 

 八：迁移与备份

1：容器保存为镜像

　　我们可以把容器保存为镜像，因为有些被创建的容器里面有我们自定义的项目环境，比如我有个tomcat镜像被我创建了容器，而且再这tomcat容器内部我又安装了指定的java环境，所以我们针对需求要把此容器保存成镜像

　　docker  commit  { 要保存的容器名称 }  { 保存后的镜像名称[:版本] }

// 创建tomcat容器
    docker run -di --name=c_tomcat -p 8080:8080 -v /root/tomcat/webapps:/usr/local/tomcat/webapps tomcat:9
// 查询容器
    [root@VM-8-15-centos ~]# docker ps -a
CONTAINER ID IMAGE     COMMAND           CREATED         STATUS        PORTS           NAMES
5bdf97db8680 tomcat:9  "catalina.sh run" 6 seconds ago   Up 5 seconds  省略太长了8080  c_tomcat

// 把容器保存为镜像 版本不指定默认为latest 最新发布的意思
    docker commit c_tomcat my_tomcat:1.0

// 查询镜像
    [root@VM-8-15-centos ~]# docker images
        REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
        my_tomcat    1.0       155705c88219   6 seconds ago   649MB
        tomcat       9         040bdb29ab37   47 hours ago    649MB

2：镜像备份

　　我们把容器保存为镜像后不是就完事了，假如你开发完产品以后得给测试吧，你们两个运行环境还不同，这时候就得把我们之前保存好的镜像再次备份发给测试；注：下面的 -o 代表Object 目标的意思，就是我们备份后的文件名

　　docker save -o { 备份后的文件名.tar }  { 要备份的镜像 }

// 查询镜像
    [root@VM-8-15-centos ~]# docker images
        REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
        my_tomcat    1.0       155705c88219   6 seconds ago   649MB
        tomcat       9         040bdb29ab37   47 hours ago    649MB
// 备份镜像 这里的名称最好保持一致 备份后的文件夹一定要加上.tar
    docker save -o my_tomcat.tar my_tomcat:1.0
// 查询文件
    [root@VM-8-15-centos ~]# ls 
    mysql  my_tomcat.tar  tomcat  webapps

// 注：把容器保存为镜像，把镜像保存为文件，我们要知道，这个被再次加载到容器里面，
// webapps里面的文件是不存在的，只是一个环境被备份打包

3：镜像恢复与迁移

　　我们接到同事或者其他人给我们一个Docker镜像，就是我们上面2步的操作，我们要把获得到的镜像加载到我们的Docker里面，然后创建容器，这样我们就可以得到一个和同事一模一样的运行环境了

　　docker load -i { 要加载的镜像名称 }

// 查询文件
    [root@VM-8-15-centos ~]# ls 
    mysql  my_tomcat.tar  tomcat  webapps
// 加载镜像
    docker load -i my_tomcat.tar
    4ee7b60fcd59: Loading layer [========================>]   51.2kB/51.2kB
    Loaded image: my_tomcat:1.0
// 查询镜像 为了效果把之前保存的镜像删除
    docker images
    REPOSITORY   TAG   IMAGE ID       CREATED          SIZE
    my_tomcat    1.0   155705c88219   20 minutes ago   649MB
    tomcat       9     040bdb29ab37   47 hours ago     649MB

 九：Dockerfile构建镜像

1：Dockerfile简介

 　　其实Dockerfile是一个文本文件，里面包含了构建镜像文件的指令，每条指令构建一层，最终构建出一个新的镜像；它不是把环境迁移，而是把那些如jdk、tomcat、redis等镜像环境用指令表示，拿到此Dockerfile文件的人只要build构建一下，然后联网自动下载这些环境

1：对于开发人员：可以为开发团队提供一个完全一致的开发环境
2：对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像，直接开始工作
3：对于运维人员：在部署时，可以实现应用的无缝移植

注：Dockerfile文件命令 【重要】

 2：使用Dockerfile制作一个SpringBoot.jar的镜像

 　　我们首先准备一个SpringBoot构建的一个 .jar 的项目，接下来把SpringBoot.jar 的项目部署到docker镜像里并创建容器；构建docker镜像的是Dockerfile文件，Dockerfile文件与SpringBoot文件必须存放在同一个目录

（1）：创建Dockerfile文件并设置命令

1：在IDEA中编辑Dockerfile文件，无后缀
    # 定义基础的镜像 如果多个基础镜像就多写几个FROM ...
    FROM java:8
    # 定义作者信息 有邮箱也可以写在后面
    MAINTAINER xiaofeng
    # 添加SpringBoot.jar的项目到镜像里 第一个参数为项目 第二个参数为自己起的名字
    ADD SpringBootJarDemo.jar demo.jar
    # 定义当前镜像启动容器时执行的命令
    CMD java -jar demo.jar 

    # 注:假设导入FROM java:8 和 FROM tomcat:9  正好tomcat里面有jdk环境，就会直接使用tomcat
    # 里面的

（2）：在有Docker环境中构建镜像

 　　docker build -f { Dockerfile具体文件路径 }  -t { 镜像名称:版本 }  { 构建项目文件的路径 }

1：上传到到带有Docker环境的机器上 这里我只有宿主机上有docker环境
    [root@VM-8-15-centos ~]# ls 
    Dockerfile  SpringBootJarDemo.jar 
2：在Docker环境下构建镜像  当前要构建的项目在当前目录 ./ 
     docker build -f ./Dockerfile -t demo_spring_boot:1.0 ./
     # -f:指定要使用的Dockerfile路径；
     # -t:镜像的名字及标签，通常 name:tag 或者 name 格式,不设置为latest
3：正常创建容器即可

 十：搭建Docker私服

　　Docker官方的Docker hub（https://hub.docker.com）是一个用于管理公共镜像的仓库，我们可以从上面拉取镜像到本地，也可以把我们自己的镜像推送上去。但是，有时候我们的服务器无法访问互联网，或者你不希望将自己的镜 像放到公网当中，那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。

 1：私有仓库的搭建

　　创建私有仓库和我们平时下载镜像和创建容器差不多，在本地Docker搭建私有仓库

1：拉取私用仓库镜像
    docker pull registry
2：仓库镜像构建成私有仓库容器
    docker run -di --name=my_registry -p 5000:5000 registry:latest
3：测试私有仓库是否搭建完成
    浏览器输入：http://ip地址:5000/v2/_catalog
    看到{"repositories":[]} 表示私有仓库搭建成功

4：修改daemon.json配置,为了用于docker 信任私有仓库地址；
   注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
    {
        "insecure-registries":["私有仓库服务器ip:5000"]
    }
5：重启docker  如果重启错了很大可能时daemon.json修改错了
    systemctl restart docker  //重启docker容器
    docker start my_registry  //重启docker里的仓库容器

2：将镜像上传至私有仓库

（1）：标记镜像为私有仓库镜像

 　　docker tag { 镜像名称:标签 }  { 私有仓库ip : 端口 }/{ 私有镜像仓库中的名称 ： 标签 }

（2）：上传标记的镜像

　　docker push { 私有仓库ip : 端口 }/{ 私有镜像仓库中的名称 : 标签 }

1：随便创建一个容器然后封装成自己的镜像
    docker run -di --name=my_mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=1234 mysql:5.7
    docker commit my_mysql mysql_old:2.0
2：查询镜像
    [root@VM-8-15-centos ~]# docker images
    REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
    mysql_old    2.0       ba24e436e77c   6 seconds ago   449MB
    mysql        5.7       cc8775c0fe94   3 days ago      449MB
    registry     latest    678dfa38fcfa   4 weeks ago     26.2MB

3：标记镜像为私有仓库镜像
    docker tag mysql_old:2.0 192.168.28.12:5000/r_mysql:2.0

4：查询镜像
    [root@VM-8-15-centos ~]# docker images
    REPOSITORY                 TAG       IMAGE ID       CREATED         SIZE
    192.168.28.12:5000/r_mysql 2.0       ba24e436e77c   3 minutes ago   449MB
    mysql_old                  2.0       ba24e436e77c   3 minutes ago   449MB
    mysql                      5.7       cc8775c0fe94   3 days ago      449MB
    registry                   latest    678dfa38fcfa   4 weeks ago     26.2MB

5：上传标记镜像 这里的mysql:2.0必须和标记镜像为私有仓库镜像设置的名称一样；出现上传样式就上传了
    docker push 192.168.28.12:5000/r_mysql:2.0

6：访问 出现我们上传的名称 如这里为mysql
    http://192.168.28.12:5000/v2/_catalog

（3）：从私有仓库拉取镜像

　　docker pull { 私有仓库ip : 端口 }/{ 私有镜像仓库中的名称 : 标签 }

1：首先删除那个带ip地址的镜像，因为我后面要从私有仓库拉
    [root@VM-8-15-centos ~]# docker images
    REPOSITORY                   TAG       IMAGE ID       CREATED         SIZE
    mysql                        5.7       cc8775c0fe94   3 days ago      449MB
    registry                     latest    678dfa38fcfa   4 weeks ago     26.2MB

2：拉取私有仓库镜像
     docker pull 192.168.28.12:5000/r_mysql:2.0

3：最终查询
    [root@VM-8-15-centos ~]# docker images
    REPOSITORY                   TAG       IMAGE ID       CREATED         SIZE
    192.168.28.12:5000/r_mysql   2.0       4159b210aae9   9 minutes ago   449MB
    mysql                        5.7       cc8775c0fe94   3 days ago      449MB
    registry                     latest    678dfa38fcfa   4 weeks ago     26.2MB

 .