Docker核心技术学习笔记

ゞ浴缸里的玫瑰 2023-06-18 08:59 8阅读 0赞

# Docker核心技术 #

### 文章目录 ###

*  Docker核心技术
 *   *  一 、Docker简介
     *  二、Docker安装
     *   *  前提说明
         *  Docker 的基本组成
         *  安装
         *   *  centos 7 安装docker
         *  启动hello-world
         *  底层原理
     *  三、Docker常用命令
     *   *  帮助命令
         *  镜像命令
         *  容器命令
         *  总结
     *  四、Docker 镜像
     *   *  \*\*1、镜像是什么？\*\*
         *  \*\*2、镜像特点\*\*
         *  \*\*3、Docker镜像commit操作补充\*\*
         *  4 、镜像生成的途径
         *  5、 镜像导入导出
         *  6、镜像推送到仓库
     *  五、Docker容器数据卷
     *   *  1、是什么
         *  2、能干嘛
         *  3、数据卷
         *  4、数据容器卷
     *  六、DockerFile解析
     *   *  1、是什么
         *  2、DockerFile构建过程解析
         *  3、DockerFile体系结构(保留字指令)
         *  4、案例
         *   *  4.1 Base镜像（scratch）
             *  4.2 自定义镜像
             *  4.3 CMD/ENTRYPOINT 镜像案例
             *  4.4 自定义镜像Tomcat9
             *  4.5 自定义nginx
         *  5、小总结
     *  七、Docker常用安装
     *   *  1、总体步骤
         *  2、安装Tomcat
         *  3、安装Mysql
         *  4、安装Redis
     *  八、本地镜像发布到阿里云
     *  九、Docker 私有Registry
     *   *  1、 Docker Registry 分类
         *  2、Registry 安装
         *  3、构建本地完整的私有仓库 - harbor
     *  十、Docker的系统资源限制及验正

思维导图： http://naotu.baidu.com/file/85634842b0e8e8630651d0fc5bf5b9a4

## 一 、Docker简介 ##

**问题**：为什么会出现docker呢？

**场景**：1、“在我机器上可以正常工作”问题。因为环境和配置不同，开发和运维会出现运行结果。

2、多台机器上需要部署一套代码（集群）。每一台都进行一次安装操作，过程繁琐耗时。

开发 | 运维

代码—> war | 部署

**解答**： 安装的时候，把**原始环境一模一样的复制**，开发和运维的环境和配置一样（不需要重新安装环境和更改配置）！

![平台耦合性][format_png]

**你今天的优势会被明天的趋势所取代！**

买书容易，看书难，搬家还麻烦！

## 二、Docker安装 ##

### 前提说明 ###

1、 CentOs Docker 安装

Docker 支持一下的CentOs版本：

*  CentOS 7 （64 bit）
 *  CentOS 6.5 （64 bit）或者更高版本

2、 前提条件

目前，CentOS仅发行版本中内核支持Docker。

Docker运行在CentOS 7上，要求系统为64位，系统内核为3.10+！

Docker运行在CentOS6.5或者更高版本的CentOS上，要求系统为64位，系统内核版本为2.6.32-431或者更高。

3、查看自己的内核

uname 命令打印当前系统相关信息。内核版本号、硬件架构、主机名称和操作系统类型等。

# uname -r

查看安装CentOS版本信息

# lsb_release -a
    # cat /etc/readhat-release

### Docker 的基本组成 ###

[几张图帮你理解 docker 基本原理及快速入门][docker]

![Docker构架][Docker]

**1、镜像（Image）**

Docker镜像就是一个**只读**的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器。

<table> 
 <thead> 
  <tr> 
   <th>Docker</th> 
   <th>面向对象</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>容器</td> 
   <td>对象</td> 
  </tr> 
  <tr> 
   <td>镜像</td> 
   <td>类</td> 
  </tr> 
 </tbody> 
</table>

**2、容器（container）**

Docker利用容器独立运行一个或一组应用。**容器是镜像创建的运行实例**。

它可以被启动、开始、停止、删除。每个容器都是互相隔离的、保证安全的平台。可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

**3、仓库（Repository）**

仓库是**集中存放镜像文件**的场所。仓库和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库包含多个镜像，每个镜像有不同的标签（Tag）。

仓库分为： 公开仓库（Public）和私有仓库（Private）

最大的公开仓库是 Docker Hub：https://hub.docker.com/

存在放数量庞大的镜像提供用户下载。国内公开的仓库有阿里云、网易云等。

**4、总结**

![总结][format_png 1]

### 安装 ###

配置 镜像加速，配置的时候CentOS 6.8和 7配置文件不同。

[Docker 安装][Docker 1]  
[Docker 安装清华][Docker 2]

配置 镜像加速：

# 阿里云
    sudo mkdir -p /etc/docker
    sudo tee /etc/docker/daemon.json <<-'EOF'
    { 
      "registry-mirrors": ["https://n7alqmf2.mirror.aliyuncs.com"]
    }
    EOF
    sudo systemctl daemon-reload
    sudo systemctl restart docker
    
    # 网易云
    { 
      "registry-mirrors": ["http://hub-mirror.c.163.com"]
    }

#### centos 7 安装docker ####

1、官网中文安装手册
    
    2、确定你是centos7及以上版本
    cat /etc/redhat-release
    
    3、yum安装gcc相关
    yum -y install gcc
    yum -y install gcc-c++
    gcc  -v
    
    4、卸载旧的docker版本
    
    5、安装需要的软件包
    
    6、设置stable 镜像仓库
    # 大坑
    sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
    报错：
    Errno 14 ： TCP connection reset by peer
    Errno 12 ： Timeout
    # 推荐
    sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    7、更新yum 软件包索引
    yum makecache fast
    
    8、安装docker ce
    yum -y install docker-ce
    
    9、启动docker
    systemctl start docker
    
    10、测试 
    docker version
    docker run  hello-world
    
    11、配置进行加速配置
    (1)、mkdir -p /etc/docker
    (2)、vim /etc/docker/daemon.json
    #### 网易云
    { "registry-mirrors":["http://hub-mirror.c.163.com"]}
    
    #### 阿里云
    { "registry-mirrors":["http://{自己的编码}.mirror.aliyuncs.com"]}
    # dufy aliyun
    { 
      "registry-mirrors": ["https://n7alqmf2.mirror.aliyuncs.com"]
    }
    
    (3)、systemctl daemon-reload
    (4)、systemctl restart docker
    
    12、停止docker服务
    systemctl stop docker
    13、卸载
    yum -y remove docker-ce
    rm -rf /var/lib/docker

### 启动hello-world ###

docker run hello-world ，先从本地找，如果本地不存在，则会从远程的仓库中 镜像pull 操作。（下载镜像）

run 启动容器。

![format_png 2][]

### 底层原理 ###

1、Docker是怎么工作的？

2、Docker为什么比VM快？

## 三、Docker常用命令 ##

### 帮助命令 ###

docker  version ： docker版本
    
    docker info ： docker详细信息描述
    
    docker --help ： docker 的帮助命令

### 镜像命令 ###

1、docker images

列出**本地主机**上的镜像

<table> 
 <thead> 
  <tr> 
   <th>REPOSITORY</th> 
   <th>TAG</th> 
   <th>IMAGE ID</th> 
   <th>CREATED</th> 
   <th>SIZE</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>表示镜像的仓库</td> 
   <td>镜像的标签</td> 
   <td>镜像ID</td> 
   <td>镜像创建时间</td> 
   <td>镜像大小</td> 
  </tr> 
 </tbody> 
</table>

同一个仓库源可以有多个TAG，代表这个仓库源的不同个版本，使用REPOSITORY:TAG来定义不同的镜像。如果不指定一个镜像的版本标签，例如使用Ubuntu，Docker默认使用ubuntu:latest镜像。

参数说明：

\-a ：列出本地所有的镜像（含中间映射层

\-q ： 只显示镜像ID

–digests ： 显示镜像的摘要信息

–no-trunc ： 显示完整的镜像信息

2、docker search XXX 某个镜像的名字

网站：https://hub.docker.com/

命令：docker search 【options】 镜像名字

\-s ： 列出收藏数不小于指定值的镜像，docker search -s 30 tomcat

–no-trunc ： 显示完整镜像描述

–automated ： 只列出 automated bulid 类型的镜像

3、docker pull 镜像名

docker pull tomcat == docker pull tomcat\[: TAG\] ，默认TAG为latest

4、docker rmi 镜像名字/镜像ID - 删除镜像

强制删除：-f

删除单个：docker rmi -f hello-world

删除多个：docker rmi -f hello-world nginx

删除全部：docker rmi -f $(docker images -qa)

?? 思考：结合git的学习心得，可以猜测docker 会有 docker commit /docker push?

### 容器命令 ###

**前提**：有镜像才能创建容器

1、新建并启动容器

# docker run [options] image [command] [arg...]
    options说明:有些是一个减号，有些是两个减号
    --name="容器新名字" ： 为容器指定一个名称
    -d ： 后台运行容器，并返回容器的ID，也即启动守护式容器
    -i ： 以交互模式运行容器，通常与 -t 同时使用  [重要]
    -t ： 为容器重新分配一个伪输入终端，通常与 -i 一起使用  [重要]
    -P ： （大写）随机端口映射
    -p ： （小写）指定端口映射，有以下四种格式
    	ip:hostPort:containerPort
    	ip::containerPort
    	hostPort:containerPort [重要]
    	containerPort

2、列出当前所有正在运行的容器

docker ps  [-a]
    -a ： 代表 所有容器，包括运行和非运行的容器。
    -l ： 显示最近创建的容器
    -n ： 显示最近n个创建的容器
    -q ： 静默模式，只显示容器编号
    --no-trunc : 不截断显示

3、容器的退出、启停

# 退出交互终端
    exit ： 容器停止退出
    ctrl+P+Q ： 容器不停止退出
    # 启动
    docker start container-name/container-id
    
    # 重启
    docker restart container-name/container-id
    
    # 停止
    docker stop container-name/container-id
    
    # 强制停止
    docker kill container-name/container-id

4、容器的删除

# 删除一个
    docker rm container-id
    -f ： 强制删除
    
    # 删除多个
    docker rm -f $(docker ps -a -q)
    docker ps -a -q | xargs docker rm # 上一个参数的结果集传递给下一个参数

**6、重要**

（1）、启动守护式容器

docker run -d 容器名

**注意**：使用后台模式启动一个镜像，使用docker ps -a 查看，发现容器已经退出。  
很重要的一点说明：**Docker 容器后台运行，就必须有一个前台进程**。  
容器运行的命令如果不是那些一直挂起的命令（如 top、tail）等，就是会自动退出的。

这个是Docker的机制问题，比如 你的web容器，我们以nginx 为例，正常情况下，我们配置启动服务只需要启动响应的Service即可。例如 service nginx start。但是，这样做，nginx为后台进行模式运行，就导致docker 前台没有运行的应用，这样的容器后台启动后，会立即自杀。因为他觉得他没事可做了。

所以，最佳的解决方案是： **将你要运行的程序以前台进程的形式运行。**

例子：
    docker run -d /bin/bash -c "while true;do echo hello centos;sleep 2;done"

（2）、查看容器日志

docker logs -f -t --tail 容器id
    -t：加入的时间戳
    -f：跟随最新的日志打印
    --tail：数字显示最后多少条

(3)、查看容器内运行的进程

docker top 容器id

（4）、查看容器内部细节

# docker 镜像是一层套一层
    docker inspect 容器id

（5）、进入正在运行的容器并以命令行交互

# docker exec -it 容器id bashShell
    docker exec -t 3d51887b06b6  ls -l /tmp
    
    docker exec -t 3d51887b06b6 /bin/bash
    
    # 重新进入docker attach 容器id
    docker attach 3d51887b06b6
    上述两个区别：
    - attach：直接进入容器启动命令的终端，不会启动新的进程
    - exec：在容器中打开新的终端，并可以启动新的进程

（6）、从容器内拷贝文件到主机上

# dcoker cp 容器id:容器内路径 目的主机路径
    # dcoker cp 目的主机路径 容器id:容器内路径

### 总结 ###

![Docker event state][]

不懂原理，你就是一个API调用工程师！

docker全部的命令 : http://www.runoob.com/docker/docker-command-manual.html

## 四、Docker 镜像 ##

> Docker 镜像就是一个千层饼，一层套一层。

### **1、镜像是什么？** ###

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

*  UnionFS（联合文件系统）

![UnionFS][]

*  Docker镜像加载原理

![Docker镜像加载原理][Docker 3]

*  分层的镜像

以pull 为例，一层一层的往下拉取。

*  为什么Docker镜像要采用这种分层的结构呢

最大的好处就是 - 共享资源。比如：有对个镜像都从相同的 base 进行构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份base镜像，就可以为所有的容器服务了。而且镜像的每一层都可以被共享。

![format_png 3][]

问题1：tomcat为什么那么大400多M？

实际上有多层文件构成，一层一层进行打包。

### **2、镜像特点** ###

Docker 镜像 都是只读的（类似鸡蛋- 蛋壳-》蛋清-》蛋黄），当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作 “容器层” ，“容器层”之下都叫 “镜像层”。

### **3、Docker镜像commit操作补充** ###

（1）、docker commit

# docker commit 提交容器副本使之成为一个新的镜像。
    
    docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名:[标签名]
    
    # 案例演示
    1、启动tomcat镜像 ，-p 8888代表是 docker的端口，8080 docker中 是tomcat的端口。
    docker run -p 8888:8080 tomcat
    -p：指定端口映射
    -P：随机端口映射
    
    2、故意删除tomcat容器的文档
    
    3、把没有文档的tomcat容器当作一个模板，提交commit
    
    4、启动新镜像 和 原来对比

### 4 、镜像生成的途径 ###

![format_png 4][]

### 5、 镜像导入导出 ###

![format_png 5][]

一次打包可以打包多个镜像。

docker save -o tomcatimage.gz dufy/tomcat:v0.9 dufy/tomcat:v1.0
    
    docker load -i tomcatimage.gz

### 6、镜像推送到仓库 ###

推送Docker hub、推送到阿里云，需要进行登录。dokcer login 、 docker logout

## 五、Docker容器数据卷 ##

### 1、是什么 ###

简单的说就是将Docker容器运行的一些数据结果保存起来（持久化+共享）。类似redis中的RDB和AOF。

Docker理念：

*  将应用与运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求希望是持久化的
 *  容器之间希望有可能共享数据

Docker 容器产生的数据，如果不通过docker commit 生成新的镜像，使得数据作为镜像的一部分保存下来，那么容器删除之后，数据自然也就没有了。

为了能保存数据在docker 中，我们使用数据卷。

### 2、能干嘛 ###

*  容器产生数据的持久化
 *  容器间继承 + 共享数据
 *  容器到主机，主机到容器之间的数据共享

### 3、数据卷 ###

（1）直接命令添加

注意： 数据卷的目录地址不能映射容器应用一样的目录名！

例如： tomcat /usr/local/tomcat/conf ，这个配置文件的目录不能进行映射。

# 添加命令 如果有Permission denied ，加 --privileged=true
    1、docker run -it -v /容器内目录 镜像名 # 此种方式会自动在宿主机中生成一个对应绑定的目录
    2、docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名
    
    例子： docker run -it -v /myDataVolume:/dataVloumeContainer centos
    -v ： 主机和容器之间数据共享
    
    # 查看数据卷是否挂载成功
    docker inspect 容器id
    
    # 容器和宿主机之间数据共享
    
    # 容器停止退出后，主机修改后数据是否同步
    容器 exit，主机修改文件后，容器启动后，数据可以进行同步。
    
    # 命令（带权限）写保护，
    docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
    - ro ： read only ,容器只可以读，不可写。

（2）、DockerFile添加

DockerFile : 镜像 --》DockerFile , 描述Docker的文件。

JavaEE : Hello.java —》Hello.class

# 1、根目录下新建一个myDocker 文件夹并进入
    mkdir myDcker
    # 2、可以在Dockerfile 中使用 VOLUME指令 来给镜像添加一个或多个数据卷
    VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
    说明：
    	出于可移植和分享的考虑，用 -v 主机目录:容器目录 这种方法不能够直接在Dockerfile中实现。
    	由于宿主机目录是依赖于特定宿主机的，并不能保证所有的宿主机上都存在这样特定目录。
    
    # 3、File构建
    vim Dockerfile
    ---------------------------------------------------------------
    # volume test
    FROM centos
    VOLUME ["/dataVolumeContainer","/dataVolumeContainer2"]
    CMD echo "finished ..."
    CMD /bin/bash
    ---------------------------------------------------------------
    
    # 4、bulid后生成镜像--》 获得一个新镜像 newcentos
    docker bulid -f /mydocker/Dockerfile -t newcentos/centos .
    
    -f: dockerFile 的意思,dockerfile 文件的目录地址
    
    # 5、run容器
    docker run -it newcentos/centos
    
    
    通过上述步骤，容器内的卷目录地址已经知道，对应的主机目录地址在哪呢？？
    -- 
    docker inspet 容器id ，查看默认的docker分配的宿主机目录  # 主机上会生成对应默认地址

（3）、备注

Docker 挂载主机目录Docker访问出现 cannot open directory ： Permission denied。

解决方法： 在挂载目录后多加一个 `--privileged=true` 参数。

### 4、数据容器卷 ###

（1）是什么？

命名的容器挂载数据卷，其他容器通过挂载这个（父容器）实现数据共享，挂载数据卷的容器，称之为数据卷容器。（活动硬盘挂活动硬盘，实现数据传递共享）

（2）总体介绍

根据上面学习的构建好的newcentos镜像为模板，并运行容器 dc01/dc02/dc03

运行的容器都具有容器卷 \["/dataVolumeContainer","/dataVolumeContainer2"\] 。

（3）容器间传递共享（–volumes-from）

# 1、先启动一个父容器dc01 ,在 dataVolumeContainer2 中新增内容
    docker run -it --name dc01 newcentos/centos
    cd /dataVolumeContainer2 
    touch dco1.txt
    
    # 2、dc02/dc03继承自dc01 ，使用--volumes-from ，使用同一个网络 --network:container:容器名称
    docker run -it --name dc02 --volumes-from dc01 newcentos/centos
    cd /dataVolumeContainer2 
    ll
    >  dco1.txt
    touch dco2.txt
    
    docker run -it --name dc03 --volumes-from dc01 newcentos/centos
    ll
    >  dco1.txt
    >  dco2.txt
    touch dco3.txt
    
    # 3、回到dc01可以看到02/03各自添加的都能共享
    三个实现传递和共享
    # 4、删除dc01，dc02修改后dc03可否访问
    docker rm -f dc01
    dco1.txt 是否还在？
    > 还在！
    
    docker attach dc02
    touch dco2_update.txt
    
    docker attach dc03
    ll
    > 也可以实现dc02和dc03之间数据共享
    # 5、删除dc02后dc03可否访问
    
    # 6、新建dc04 继承dc03 后，再删除dc03
    
    结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止。

## 六、DockerFile解析 ##

### 1、是什么 ###

Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

构建三步骤：

1、手动编写一个dockerfile文件，符合file的规范

2、进行bulid执行，获得一个自定义的镜像

3、进行run，启动这个自定义的镜像的容器

文件是什么样？

# 来自哪里
    FROM scratch 
    # 
    ADD centos-7-docker.tar.xz / 
    # 标签
    LABEL org.label-schema.schema-version="1.0" \
        org.label-schema.name="CentOS Base Image" \
        org.label-schema.vendor="CentOS" \
        org.label-schema.license="GPLv2" \
        org.label-schema.build-date="20181006"
    
    # Default command
    CMD ["/bin/bash"]

### 2、DockerFile构建过程解析 ###

**（1） dockerfile内容基础知识**

*  每条保留字指令 都必须为**大写字母**（最好大写）且后面要跟随 至少一个参数 ，参数和保留字直接要有空格
 *  指令按照从上到下，顺序执行
 *  ‘\#’ 表示注释
 *  第一个非注释行，必须是FROM 开始
 *  每条指令都会创建一个新的镜像层，并对镜像镜像提交
 *  要有工作目录，Dockerfile文件名首字母必须大写，所有依赖的包，也必须放入工作目录，或者工作目录的子目录，一定不能是工作目录的父目录。
 *  支持在工作目录中创建一个 .dockeringore,在打包时候不包含配置的文件列表，类似git的ingore

**（2）Docker执行Dockerfile的大致流程**

*  1、docker 从基础镜像运行一个容器
 *  2、执行一条指令并对容器作出修改
 *  3、执行类似docker commit的操作提交一个新的镜像层
 *  4、docker 在基于刚提交的镜像运行一个新容器
 *  5、执行Dockerfile中的下一条指令 直到所有指令 都执行完成

（3）小总结

![format_png 6][]

![format_png 7][]

### 3、DockerFile体系结构(保留字指令) ###

*  FORM ： 指定基准镜像，当前新的镜像是基于哪个镜像的，可以是任何可以用的镜像。默认情况在本地主机上查找，若不存在，这会从Docker hub Registry 上拉取。

![format_png 8][]

*  MAINTAINER： 作者和作者的邮箱，最新版本废弃，使用下面的LABEL 指令

![format_png 9][]

*  LABEL 指定各种各样的元数据。

![format_png 10][]

*  RUN ： 容器构建时候需要的命令

run中执行的命令必须是基础镜像中有的命令！

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tnjGEIyi-1575196281141)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112249\_700.png)\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5M9Tnyp-1575196281142)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112232\_995.png)\]

*  EXPOSE ：暴露容器对外服务的端口号，默认协议就是tcp

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fux2JLj8-1575196281143)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112200\_344.png)\]

*  WORKKDIR ：指定在创建容器后，终端默认登录的进来工作目录，一个落脚点
 *  ENV ：用来在构件镜像过程中设置环境变量
    
    ENV key value
    
    $key 或者 $\{key\} $\{key:-hello\} $\{key:+heloo\}

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pxnQTNKN-1575196281144)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112209\_725.png)\]

*  ADD ：将宿主机目录下的文件拷贝进镜像且 ADD命令会自动处理URL和解压tar压缩包

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5TvF4Y6q-1575196281147)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112156\_707.png)\]

*  COPY：类似ADD，拷贝文件和目录到镜像中。 COPY src dest / COPY \[“src”,“dest”\]

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-14jZuVxY-1575196281149)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112022\_133.png)\]

*  VOLUME：容器数据卷，用于数据保存和持久化工作，创建的时候自动创建

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvmsSIin-1575196281150)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112153\_948.png)\]

*  CMD ： 指定一个容器启动时要运行的命令；Dockerfile中可以有多个CMD指令，但只有最后一个生效。CMD会被docker run 之后的 参数替换

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-POup9sn0-1575196281151)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112248\_774.png)\]

*  ENTRYPOINT：指定一个容器启动时要运行的命令；ENTRYPOINT目的和CMD一样，都是在指定容器启动程序及参数，ENTRYPOINT会被 docker run 之后的 追加 ！

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QJaUrOIS-1575196281151)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811112309\_288.png)\]

*  ONBUILD：当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbulid被触发
 *  USER : 指定容器运行中的用户名或者UID

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rej0fLOd-1575196281152)(http://dufyun.gitee.io/images\_bed/images/qiniu/201811122248\_317.png)\]

*  healthCHeck ： 检查主进线的健康状态，可设定检查的时间
 *  SHELL : 默认是\[“bin/sh”,"-c"\] ，运行程序默认执行，知道即可。
 *  STOPSIGNAl：　停止信号，知道即可。
 *  ARG : build 的时候使用。–docker build --build-arg
 *  保留字运行的阶段

![DockerFile][]

### 4、案例 ###

运用知识的能力，执行力！

#### 4.1 Base镜像（scratch） ####

Docker Hub 中 99% 的镜像都是通过在base镜像中安装和配置需要的软件构件出来 的。

#### 4.2 自定义镜像 ####

*  1、编写
    
     *  Hub上默认centos的情况
     *  准备编写DockerFile文件
     *  myCentos内容DockerFile

#1、初始 centos 运行该镜像 进入时候默认路径是 / 
    #2、默认不支持 vim
    #3、默认不支持 ifconfig
    
    自定义mycentos ，使得我们自己的镜像具备如下：
     登录后修改默认路径
     vim 编辑器
     查看网络配置ifconfig支持
     
    ------
    
    from centos
    env mypath /tmp
    workdir $mypath
    
    run yum -y install vim
    run yum -y install net-tools
    
    expose 80
    
    cmd echo $mypath
    cmd echo "success..."
    cmd /bin/bash
     
    ------
    新建dockerfile文件

*  2、构建

> docker build -f dockerfile文件目录 -t 新镜像名字:TAG .
> 
> \-t ： 打标签，仓库名：标签

注意 . ,当前目录。

*  3、运行

> docker run -it mycentos:tag

*  4、列出镜像的变更历史

> docker history 镜像ID

#### 4.3 CMD/ENTRYPOINT 镜像案例 ####

都是指定一个容器启动时要运行的命令。CMD会替换最后运行的参数。ENTRYPOINT不会替换，进行追加（新的命令组合）。

# tocmat 演示 CMD 
    CMD ["catalina.sh","run"]
    docker run -p 7777:8080 tomcat ls -l
    # 这个时候tomcat不会自动启动tomcat
    
    -------------------------------------
    
    FROM centos
    RUN yum install -y curl
    CMD ["curl","s","http://ip.cn"]
    
    想看 请求头 curl -i
    
    制作ENTRYPOINT 版本的IP信息查询容器
    FORM centos
    RUN  yum -y install curl
    ENTRYPOINT ["curl","-s","http://ip.cn"]

# onbuild 案例
    FORM centos
    RUN  yum -y install curl
    ENTRYPOINT ["curl","-s","http://ip.cn"]
    ONBUILD RUN echo "some one extend me！，I am father image."
    
    定义为 ip_father
    
    FROM ip_father
    RUN yum install -y curl
    CMD ["curl","s","http://ip.cn"]

#### 4.4 自定义镜像Tomcat9 ####

# 1、创建一个目录，级联创建
    mkdir -p /dufy/mydockerfile/tomat9
    # 2、在上面的目录，创建一个c.txt，为了演示 copy 
    touch c.txt
    # 3、将JDK和tomcat安装的压缩包拷贝进上一步的目录 
    apapche-tomcat-9.tar.gz
    jdk-8u171-linux64.tar.gz
    
    # 4、在 /dufy/mydockerfile/tomat9 目录新建Dockerfile文件 
    -------------------------------------------------
    FROM centos
    MAINTAINER dufy@qq.com
    # 把宿主机当前上下文的 c.txt 拷贝到容器 /usr/local 路径下
    COPY c.txt /usr/local/cincontainer.txt
    # 把java 和 tomcat 添加到容器中
    ADD jdk-8u171-linux-x64.tar.gz /usr/local/
    ADD apache-tomcat-9.0.8.tar.gz  /usr/local/
    # 安装vim编辑器
    RUN yun -y install vim
    # 设置工作访问时候的workdir 路径。登录落脚点
    ENV mypath /usr/local
    WORKDIR $mypath
    # 配置java与tomcat 环境变量
    ENV JAVA_HOME /usr/local/jdk1.8.0_171
    ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
    ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8
    ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin:$CATALINA_BASE/bin
    # 容器运行时监控的端口
    EXPOSE 8080
    # 启动时运行tomcat
    # ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
    # CMD ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
    CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out
    -------------------------------------------------
    
    # 5、构建.当前Dockerfile 目录
    docker build Dockerfile -t image:tag .
    
    # 6、运行 run
    docker run -d -p 9080:8080 --name mytomcat9 -v /dufy/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test -v /dufy/mydockerfile/tomcat9/logs:/usr/local/apache-tomcat-9.0.8/logs --privileged=true image
    
    # 7、验证
    
    # 8、结合前述的容器卷，将测试的web服务test发布

#### 4.5 自定义nginx ####

FROM nginx:1.14-alpine
    LABEL 
    ENV NGX_DOC_ROOT='/data/web/html' 
    ADD entrypoint.sh /bin/
    ADD index.html $NGX_DOC_ROOT
    EXPOSE 80/tcp
    HEALTHCHECK --start-period=3s CMD wget -O - -q http://${IP:-0.0.0.0}:${PORT:-80}/
    CMD ["/usr/sbin/nginx","-g","daemon off"]
    ENTRYPOINT ["/bin/entrypoint.sh"] # 要使用双引号 ，不能用单引号
    
    entorypoint.sh
    #!/bin/sh
    cat  > /etc/nginx/conf.d/www.conf << EOF
    server {
    	server_name ${HONSTNAME};
    	lister ${IP:-0.0.0.0}:${PORT:-80};
    	root ${NGX_DOC_ROOT:-/usr/share/nginx/html};
    }
    EOF
    exec "$@" #脚本的所有参数
    chmod +x entrypoint.sh
    
    index.html
    
     
     docker run --name names --rm -P -e "PORT=8080" ngxin:v1.0-1
     netstat -tnl

### 5、小总结 ###

![format_png 11][]

## 七、Docker常用安装 ##

### 1、总体步骤 ###

*  搜索镜像
 *  拉取镜像
 *  查看镜像
 *  启动镜像-成为容器
 *  停止容器
 *  移除容器
 *  删除镜像

### 2、安装Tomcat ###

### 3、安装Mysql ###

（1）、从docker hub上面查找mysql镜像

（2）、从docker hub上 拉取 mysql镜像到本地

（3）、运行mysql镜像，启动一个mysql容器

docker run -p 3307:3306 --name mysql01 -v /dufy/mysql/conf:/etc/mysql/conf.d -v /dufy/mysql/logs:/logs -v /dufy/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6

![format_png 12][]

数据备份测试：

docker exec mysql服务容器id sh -c 'exec mysqldump --all-databases -uroot -p"123456"' > /dufy/all-databases.sql

### 4、安装Redis ###

（1）、从docker hub 拉取redis镜像到本地，下载tag 3.2

（2）、运行redis镜像创建容器

1、使用镜像
    docker run -p 6379:6379 -v /dufy/myredis/data:/data -v /dufy/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes
    
    2、在主机/dufy/myredis/conf/redis.conf 目录下新建redis.conf 文件
    vim /dufy/myredis/conf/redis.conf/redis.conf
    
    去掉 bind 绑定 主机
    3、测试redis-cli连接
    docker  exec -it 容器id redis-cli
    4、测试持久化文件生成
    shutdown ,dicker容器redis停止了
    
    cd  /dufy/myredis/data # 是否有备份文件

## 八、本地镜像发布到阿里云 ##

*  本地镜像发布到阿里云的流程

![format_png 13][]

*  镜像的生成方法

1、前面的Dockerfile ,编写完后 build 
    
    2、从容器创建一个新的镜像，docker commit [options] 容器id  [repository[:tag]] 
    -a：提交的镜像作者
    -m：提交时候的说明文字
    
    例子：
    docker commit -a dufy -m "new tomcat" 容器id myTomcat:1.0
    
    注：commit 需要容器在运行状态。

*  将本地镜像推送到阿里云

1、本地镜像素材原型
    2、阿里云开发者平台 -- http://dev.aliyun.com/search.html
    3、创建仓库镜像 
    	命名空间
    	仓库名称
    4、将镜像推送到registry 
    	-- 初次进入需要设置密码
    	-- 镜像名字要符合aliyun的要求
    5、公有云可以查询到
    6、查看详情

*  将阿里云上的镜像下载到本地

注： 镜像也可以推送到Docker hub上面。

## 九、Docker 私有Registry ##

### 1、 Docker Registry 分类 ###

Registry 用于保存Docker镜像，包括镜像 的 层次结构和元数据。

用户可以自建Registry，也可以使用官方的Docker hub.(此处类似 用户可以使用自建gitlab， 也可以使用github)

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Sponsor Registry</td> 
   <td>第三方的Registry，供客户和Docker社区使用</td> 
  </tr> 
  <tr> 
   <td>Mirror Registry</td> 
   <td>第三方的Registry，只让客户使用</td> 
  </tr> 
  <tr> 
   <td>Vendor Registry</td> 
   <td>由发布Docker 镜像的供应商提供的Registry</td> 
  </tr> 
  <tr> 
   <td>Private Registry</td> 
   <td>通过设有防火墙和额外安全层的私有实体提供的Registry</td> 
  </tr> 
 </tbody> 
</table>

Docker 拒绝使用http协议。

docker-distribution

### 2、Registry 安装 ###

yum info docker-registry
    
    yum install docker-registry
    
    rpm -ql docker-distribution
    
    cd /etc/docker/registry 
    config.yml # 使用默认配置即可
    
    
    ss -tnl
    
    
    docker tag 镜像名：tag  hostname:port/镜像名：tag
    
    docker push hostname:port/镜像名：tag
    #报错 默认不支持 http协议
    
    在daemon.json 加上 insecure-registries:["hostname:prot"]
    
    重启Docker 
    
    history
    
    !行数 # 执行历史命名
      
    # 查看上传的镜像
    cd /var/lib/registry/docker/registry
    
    
    # 下载上传到私有Registry的镜像

### 3、构建本地完整的私有仓库 - harbor ###

vmvare harbor

docker compose

github 有 harbor

lftp mget bye

yum -y install docker-compose 1.7+

## 十、Docker的系统资源限制及验正 ##

ＯＯＭＥ：　E代表异常。一旦发生OOME，任何进程都可能被杀死，包括docker daemon在内。为此Docker 特地调整了docker daemon 的OOME优先级，以免它被内核“正法”，但容器的优先级并未调整。

可以限制一个容器可用的内存。

--------------------

如果需要Docker相关的学习资料和视频，可以关注下方公众号获取。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hZmx5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]

[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTAyODIzMTVfMjM1LnBuZw?x-oss-process=image/format,png
[docker]: https://www.cnblogs.com/SzeCheng/p/6822905.html
[Docker]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5oYWluaXVibC5jb20vaW1hZ2VzLzIwMTYvYXJjaGl0ZWN0dXJlLmpwZw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTAyOTIyNDRfMzczLnBuZw?x-oss-process=image/format,png
[Docker 1]: https://docs.docker-cn.com/engine/installation/
[Docker 2]: https://mirrors.tuna.tsinghua.edu.cn/help/docker-ce/
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTAyOTIzMjZfNjU2LnBuZw?x-oss-process=image/format,png
[Docker event state]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMDE4MzlfNTAucG5n?x-oss-process=image/format,png
[UnionFS]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwMjIxNDlfNTI0LnBuZw?x-oss-process=image/format,png
[Docker 3]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwMjIxNTZfOTMyLnBuZw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMDE5NDRfMTQ0LnBuZw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMDIwMThfMzg2LnBuZw?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMDIwNTNfMzM4LnBuZw?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwMzE3MTJfMTA5LnBuZw?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwMzE3MTJfODM2LnBuZw?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMTIwMTVfNTQ0LnBuZw?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMTIwMThfNDU4LnBuZw?x-oss-process=image/format,png
[format_png 10]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTExMTIwMjBfNTgucG5n?x-oss-process=image/format,png
[DockerFile]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwMzE3MzJfNzUzLnBuZw?x-oss-process=image/format,png
[format_png 11]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwNDIzMjNfMTcyLnBuZw?x-oss-process=image/format,png
[format_png 12]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwNjIxMzFfOTAzLnBuZw?x-oss-process=image/format,png
[format_png 13]: https://imgconvert.csdnimg.cn/aHR0cDovL2R1Znl1bi5naXRlZS5pby9pbWFnZXNfYmVkL2ltYWdlcy9xaW5pdS8yMDE4MTEwNjIxNThfNzY0LnBuZw?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hZmx5dW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191201184255654.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9hZmx5dW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70