今天为大家带来dockers镜像的学习

1.镜像是什么？

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

所有的应用，直接打包docker镜像，就可以直接跑起来！

2.如何得到镜像：

从远程仓库下载
朋友拷贝给你
自己制作一个镜像DockerFile

3.Docker镜像加载原理

UnionFS（联合文件系统）：
    Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件
    系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件
    系统下（unite several directories into a single virtualfilesystem）。Union文
    件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜
    像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把文件系统及叠加起来，这样最终的文件系统包含所有底层的文件和目录

Dcoker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

bootfs（boot file system）主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs（root file system），在bootfs之上。包含的就是典型Linux 系统中的 /dev，/proc，/bin，/etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

rootfs可以很小，只需要包合最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的Linux发行版， boots基本是一致的， rootfs会有差別，因此不同的发行版可以公用bootfs。

虚拟机是分钟级别，容器是秒级！

=================================
分层理解

下载一个镜像，注意观察下载的日志输出，可以看到是一层层的在下载 。

思考：为什么Docker镜像要采用这种分层的结构呢？

最大的好处，莫过于资源共享了！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。

查看镜像分层的方式可以通过docker image inspect 命令

docker image inspect redis:latest
[
    {
    //.............
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:764055ebc9a7a290b64d17cf9ea550f1099c202d83795aa967428ebdf335c9f7",
                "sha256:245c9d23f65373415922e53424032cabe7b282c5cf8f9f8070a7d1830fca6871",
                "sha256:ebef6caacb966ed54c0c3facf2288fa5124452f2c0a17faa1941625eab0ceb54",
                "sha256:0b7b774038f08ec329e4dd2c0be440c487cfb003a05fce87cd5d1497b602f2c1",
                "sha256:a71d36a87572d637aa446110faf8abb4ea74f028d0e0737f2ff2b983ef23abf3",
                "sha256:9e1fddfb3a22146392a2d6491e1af2f087da5e6551849a6174fa23051ef8a38f"
            ]
        },
        "Metadata": {
            "LastTagTime": "0001-01-01T00:00:00Z"
        }
    }
]
理解：

所有的docker镜像都起始于一个基础镜像层，当进行修改或者增加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举一个简单的例子，加入基于 centos:7 创建一个的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，就会在基础镜像层之上穿件第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。

在添加额外的镜像层的同时，镜像始终是保持当前所有镜像的组合，理解这一点非常重要。

这种情况下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新的镜像层添加到镜像当中。

Docker通过存储引擎（新版本采用快照机制）的方式来实心镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。

Linux 上可用的存储引擎有AUFS、Overlay2，Device Maper、Btrfs 以及 ZFS。顾名思义，每种存储引擎都基于Linux中对应的文件系统或者块设备技术，并且每种存储引擎都有其独有的性能特点。

Docker在Windows上仅支持windowsfiler 一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW[1]。

特点:

Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！

这一层就是我们通常说的容器层，容器之下的都叫镜像层。

4.commit镜像

docker commit 提交容器成为一个新的副本
# 命令和git原理类似
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]

实战测试

# 1、启动一个默认的tomcat
docker run -itd --name mytomcat -p 8080:8080 tomcat /bin/bash

# 2、发现这个默认的tomcat 是没有webapps应用，官方的镜像默认webapps下面是没有文件的！docker exec -it 容器id

# 3、拷贝文件进去

# 4、将操作过的容器通过commit**为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像。docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
docker commit -a="java" -m="add webapps app"  tomcat02:1.0

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比我们我们使用虚拟机的快照。

5.DockerFile介绍

dockerfile 是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

1、 编写一个dockerfile文件

2、 docker build 构建称为一个镜像

3、 docker run运行镜像

4、 docker push发布镜像（DockerHub 、阿里云仓库)

官方镜像一般都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！

6.DockerFile构建过程

基础知识：

1、每个保留关键字(指令）都是必须是大写字母

2、执行从上到下顺序

3、#表示注释

4、每一个指令都会创建提交一个新的镜像层，并提交！

Dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！

Docker镜像逐渐成企业交付的标准，必须要掌握！

DockerFile：构建文件，定义了一切的步骤，源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行产品。

Docker容器：容器就是镜像运行起来提供服务。

7.DockerFile常用指令

FROM                 # 基础镜像，一切从这里开始构建
MAINTAINER            # 镜像是谁写的， 姓名+邮箱
RUN                 # 镜像构建的时候需要运行的命令
ADD                 # 步骤，tomcat镜像，这个tomcat压缩包！添加内容 添加同目录
WORKDIR             # 镜像的工作目录
VOLUME                 # 挂载的目录
EXPOSE                 # 保留端口配置
CMD                 # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
ENTRYPOINT             # 指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD                 # 当构建一个被继承 DockerFile 这个时候就会运行ONBUILD的指令，触发指令。
COPY                 # 类似ADD，将我们文件拷贝到镜像中
ENV                 # 构建的时候设置环境变量！

================================================
实战测试

创建一个自己的centos
mkdir /dockerfile 
cd /dockerfile 

vim file1
# 1.编写Dockerfile文件
FROM centos:7
MAINTAINER hehe<12345@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echo "-----end----"
CMD /bin/bash

# 2、通过这个文件构建镜像
# 命令 docker build -f 非标准dockerfile名 -t 镜像名:[tag] .
docker build -f file1 -t mycentos:1 .
Successfully built f22b7b27d5d2
Successfully tagged mycentos:1

# 3、测试运行
docker images
docker run -it mycentos:1
对比：之前的原生的centos

8.CMD 和 ENTRYPOINT区别

CMD             # 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
ENTRYPOINT         # 指定这个容器启动的时候要运行的命令，可以追加命令
测试cmd

# 编写dockerfile文件
$ vim file2
FROM centos:7
CMD ["ls","-a"]
# 构建镜像
$ docker build -f file2 -t cmd-test .
# 运行镜像
$ docker run cmd-test

# 想追加一个命令 -l 成为ls -al
$ docker run cmd-test -l
docker: Error response from daemon: OCI runtime create failed:container_linux.go:349: starting container process caused "exec: \"-l\":executable file not found in $PATH": unknown.
ERRO[0000] error waiting for container: context canceled
# cmd的情况下 -l 替换了CMD["ls","-l"]。 -l 不是命令所有报错
测试ENTRYPOINT

# 编写dockerfile文件
$ vim file3
FROM centos:7
ENTRYPOINT ["ls","-a"]

docker build -f file3 -t entrypoint .
docker run entrypoint

# 我们的命令，是直接拼接在我们得ENTRYPOINT命令后面的
$ docker run entrypoint-test:0.1 -l
total 56
drwxr-xr-x 1 root root 4096 May 16 06:32 .
drwxr-xr-x 1 root root 4096 May 16 06:32 ..
-rwxr-xr-x 1 root root 0 May 16 06:32 .dockerenv
lrwxrwxrwx 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x 5 root root 340 May 16 06:32 dev
drwxr-xr-x 1 root root 4096 May 16 06:32 etc
drwxr-xr-x 2 root root 4096 May 11 2019 home
lrwxrwxrwx 1 root root 7 May 11 2019 lib -> usr/lib
lrwxrwxrwx 1 root root 9 May 11 2019 lib64 -> usr/lib64 ....
Dockerfile中很多命令都十分的相似，我们需要了解它们的区别，我们最好的学习就是对比他们然后测试效果！

========================================
实战：Tomcat镜像
1、准备镜像文件

准备tomcat 和 jdk到当前目录，编写好README 。

2、编写dokerfile

FROM centos:7 
MAINTAINER hehe<12345@qq.com>              #基础镜像，一切从这里构建
COPY README /usr/local/README                     #复制文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/        #复制解压
ADD apache-tomcat-9.0.54.tar.gz /usr/local/       #复制解压
RUN yum -y install vim 
ENV MYPATH /usr/local                             #设置环境变量
WORKDIR $MYPATH                                   #设置工作目录
ENV JAVA_HOME /usr/local/jdk1.8.0_231             #设置环境变量
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.54 #设置环境变量
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib  #设置环境变量 分隔符是：
EXPOSE 8080                                       #设置暴露的端口
CMD /usr/local/apache-tomcat-9.0.54/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.54/logs/catalina.out                          # 设置默认命令

3、构建镜像

# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:1 .

4、run镜像

$ docker run -d -p 8080:8080 --name tomcat01 -v /test:/usr/local/apache-tomcat-9.0.54/webapps/test -v /tomcatlogs/:/usr/local/apache-tomcat-9.0.54/logs mytomcat:1

5、访问测试

6、发布项目(由于做了卷挂载，我们直接在本地编写项目就可以发布了！)

发现：项目部署成功，可以直接访问！

以后开发的步骤：需要掌握Dockerfile的编写！大部分都是使用docker镜像来发布运行！

===============================================
发布自己的镜像

一、dockerhub公有仓库

1、地址 https://hub.docker.com/

2、确定这个账号可以登录

3、登录

$ docker login --help
Usage: docker login [OPTIONS] [SERVER]
Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.
Options:
-p, --password string Password
--password-stdin Take the password from stdin
-u, --username string Username
4、提交 push镜像.

# push自己的镜像到服务器上！
$ docker push diytomcat

# 会发现push不上去，因为如果没有前缀的话默认是push到 官方的library
# 解决方法
# 第一种 build的时候添加你的dockerhub用户名，然后在push就可以放到自己的仓库了
$ docker build -t hehe/mytomcat:1.0 .
# 第二种 使用docker tag #然后再次push
$ docker tag 容器id hehe/mytomcat:1.0 
#然后再次push
$ docker push hehe/mytomcat:1.0

提交的时候也是按照镜像的层级来提交的！

二、阿里云镜像服务

1. 登录阿里云Docker Registry
$ docker login --username=账号全名 registry.cn-zhangjiakou.aliyuncs.com
用于登录的用户名为阿里云账号全名，密码为开通服务时设置的密码。

您可以在访问凭证页面修改凭证密码。

2. 从Registry中拉取镜像
$ docker pull registry.cn-zhangjiakou.aliyuncs.com/lhy-test/mytomcat:[镜像版本号]

3. 将镜像推送到Registry
$ docker login --username=账号全名 registry.cn-zhangjiakou.aliyuncs.com
$ docker tag [ImageId] registry.cn-zhangjiakou.aliyuncs.com/lhy-test/mytomcat:[镜像版本号]
$ docker push registry.cn-zhangjiakou.aliyuncs.com/lhy-test/mytomcat:[镜像版本号]
 

谢谢大家持续关注我！