Docker简介

1、是什么

docker是一个用来装应用的容器，就像杯子可以装水，笔筒可以放笔，书包可以放书

可以把hello word放在docker中，可以把网站放入docker中，可以把任何想得到的程序放在docker中

一句话：解决了运行环境和配置问题的软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术

为什么会有docker出现：

去哪下：
官网：docker官网
仓库：Docker Hub官网

2、Docker思想

1 集装箱

没有集装箱之前运输货物，东西零散容易丢失，有了集装箱之后货物不容易丢失，我们可以把货物想象成程序，目前我们要把程序部署到一台新的机器上，可能会启动不起来，比如少一些配置文件什么的或者少了什么数据，有了docker的集装箱可以保证我们的程序不管运行在哪不会缺东西

2 标准化

1. 运输方式
   docker运输东西有一个超级码头，任何地方需要货物都由鲸鱼先送到超级码头，然后再由鲸鱼从超级码头把货物送到目的地去。对应的技术来说，比如我们要把台式机的应用部署到笔记本上，我们可能选择用QQ发过去或者用U盘拷过去，docker就标准化了这个过程，我们只需在台式机上执行一个docker命令，把鲸鱼派过来，把程序送到超级码头去，再在笔记本上执行一个docker命令，然后由鲸鱼把程序从超级码头送到笔记本上去

2. 存储方式
   当我们把程序存储到笔记本上时，我们需要一个目录，且我们要记住这个目录，因为下次我们可能还要修改，有了docker之后我们就不用记住了程序在哪里了，我们使用的时候只需要一条命令就行了

3. API接口
   docker提供了一系列rest api的接口，包含了对docker也就是对我们的应用的一个启动停止查看删除等等，如当我们要启动tomcat时我们要执行startup命令，当我们要停止时要执行shutdown命令，如果不是tomcat，我们可能还需要一些别的命令。有了docker我们记docker的命令就可以对其进行操作

3 隔离

我们在使用虚拟机时有自己的cpu、硬盘、内存，完全感觉不到外面主机的存在，docker也差不多，不过它更轻量，我们创建虚拟机可能要几分钟，但是docker只需要一秒。

最底层的技术时 linux 一种内核的限制机制，叫做LXC。LXC是一种轻量级的容器虚拟化技术，最大效率的隔离了进程和资源，通过 cgroup,namespace 等限制，隔离进程组所使用的物理资源，比如 CPU,MEMORY 等等，这个机制在 7,8 年前已经加入到 linux 内核了，直到 2013 年 docker 出世的时候才火起来

3、Docker解决的问题

1 系统环境不一致

开发：我本地没问题；运维：服务器没问题。 这个问题就变成了皮球

如果一个应用要正常的启动起来需要什么？比如 java web 应用
需要一个操作系统，操作系统之上要 jdk、tomcat，我们的代码、配置文件

操作系统的改变可能会导致我们的应用开不起来，比如我们调用了某些系统命令
jdk 版本也可能导致程序的运行失败。比如class文件需要1.7 编译，我们装了个 1.6 的 jdk
tomcat 版本也能导致失败。比如旧的版本一些配置在新版本中不再支持
代码的话就比如应用了 C盘、D盘的一个文件，或者是用了系统的一些环境编码
配置的话我们可能少了某个配置文件等等

下面 docker 来了，它把操作系统、jdk、tomcat、代码、配置全部放到集装箱里，再打包放到鲸鱼上，由鲸鱼给我们送到服务器上，在我的机器上怎么运行，在别的机器上也怎么运行，不会有任何的问题。一句话就是 docker 解决了运行环境不一致所带来的问题

2 系统好卡,哪个哥们又写死循环了

如果有根别人共用服务器的同学可能有这样的体会，莫名其妙发现自己的程序挂了，一查原因要不是内存不够了，要不是硬盘满了，还有就是发现某个服务变慢了，甚至敲终端都比较卡，但是linux本身就是一个多用户的操作系统本身就可以供多个用户使用，docker的隔离性可以解决这个问题。

就算别人的程序还是死循环疯狂吃CPU，还是封装疯狂打日志把硬盘占满，还是内存泄漏，把内存占满，都不会导致我们的程序运行错误。因为docker在启动的时候就限定好了，它最大使用的CPU硬盘，如果超过了，就会 杀掉对应进程

3 双11来了,服务器撑不住了

大部分系统业务量并不是每天都比较平均的，特别是一些电商系统，每天总有那么几天业务量是平时的几倍甚至几十倍，如果按双11的规模去准备服务器那么对于平时的规模来说又是极大的浪费，所以就在节日前临时扩展机器，过完节再把多余的节点下线，这就给运维带来了非常大的工作量，一到过节就在各个机器上部署各种各样的服务，我们启动程序需要 java,tocmat 等等，并且还可能起不来还要调试，这是非常恶心的工作。

有了docker一切都变得美好了，只要点一下服务器就可以从10台变成100台甚至1000,1W台，都是分分钟的事情

为什么会这么快呢？都是用标准的方式把我们的程序运过来，下载过来，再用标准的方式把它运行起来，就可以做到只要在每台机器上都执行一两条命令，就可以让程序正常跑起来，并且不用担心有问题

4、Docker的基本组成

镜像就是上面说的集装箱，仓库就是超级码头，容器就是我们运行程序的地方。

docker运行程序的过程就是去仓库把镜像拉到本地，然后用一条命令把镜像运行起来变成容器

build：构建，就是构建镜像

ship：运输，运输镜像，从仓库和主机运输

run：运行的镜像就是一个容器

build,ship,run：和镜像、仓库、容器是一一对应的

1 镜像(image)

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

它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的root文件系统

相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于iava中new出来的实例对象

下图就是镜像的存储格式，这张图是分层的，最下面一层，上面也是一层层的好像集装箱罗列在一起。这就是镜像最直观的存储方式。

下面是操作系统的引导，上面是linux操作系统，再上面是一些相关的软件，如果是我们自己的程序，就可以是 tomcat,jdk，再往上是应用代码，每一层是我们自己都可以控制得，最上面一层先忽略不看，因为这是和容器有关的。

注意一点，docker镜像系统的每一层都是只读的，然后把每一层加载完成之后这些文件都会被看成是同一个目录，相当于只有一个文件系统。docker的这种文件系统被称之为镜像

2 容器(container)

1. 从面向对象角度
   Docker 利用容器(Container)独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似干一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台

2. 从镜像容器角度
   可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

在程序的运行过程中，如果要写镜像文件时，因为镜像的每一层都是只读的，它会把文件的每一层拷到文件的最上层，然后再对它进行修改，修改之后，当我们的应用读一个文件时会从顶层进行查找，如果没有才会找下一层

由于容器的最上一层是可以修改的，镜像是不能修改的，这样就能保证镜像可以生成多个容器独立运行，没有任何干扰

3 仓库(repository)

仓库(Repository)是集中存放镜像文件的场所。类似于 Maven 仓库，存放各种jar包的地方；github仓库，存放各种git项目的地方；

Docker公司提供的官方 reaistry 被称为DockerHub，存放各种镜像模板的地方

仓库分为公开仓库(Public)和私有仓库(Private)两种形式。
最大的公开仓库是 Docker Hub，存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

谁提供了这样的仓库呢？docker自己提供了，hub.docker.com，但是非常慢，为了解决这个问题，国内很多公司也在做自己的仓库。比较知名的是由网易蜂巢提供的 https://c.163yun.com/hub#/m/home/

小总结

需要正确的理解 仓库/镜像/容器 这几个概念：

Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

image文件可以看作是容器的模板。Docker根据image文件生成容器的实例。同一个image文件，可以生成多个同时运行的容器实例。

镜像文件：
image文件生成的容器实例，本身也是一个文件，称为镜像文件。

容器实例：
一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器

仓库：
就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。

5、Docker平台架构图解

1 图解

2 工作原理

Docker是一个 Client-Server 结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命今并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。可以对比mysql演示对比讲解

3 整体架构及底层通信原理简述

Docker是一个 C/S 模式的架构，后端是一个松耦合架构， 众多模块各司其职。

Docker运行的基本流程为：

1. 用户是使用DockerClient与DockerDaemon建立通信，并发送请求给后者。
2. Docker Daemon作为Docker架构中的主体部分，首先提供DockerServer的功能使其可以接受DockerClient的请求。
3. Docker Enaine执行Docker内部的一系列工作，每一项工作都是以一个Job的形式的存在。
4. Job 的运行过程中，当需要容器镜像时，则从Docker Reqistry中下载镜像，并通过镜像管理驱动 Graphdriver将下载镜像以Graph的形式存储。
5. 当需要为Docker创建网络环境时，通过网络管理驱动Networkdriver创建并配置Docker容器网络环境。
6. 当需要限制Docker容器运行资源或执行用户指令等操作时，则通过Execdriver来完成。
7. Libcontainer是一项独立的容器管理包，Network driver以及Execdriver都是通过Libcontainer来实现具体对容器进行的操作。

Docker安装

cent OS7 查看某应用是否安装的方法：

1. rpm包安装的，可以用rpm -qa看到，如果要查找某软件包是否安装，用 rpm -qa | grep “软件或者包的名字”
   rpm -qa | grep docker
   

2. yum方法安装的，可以用yum list installed查找，如果是查找指定包，命令后加 | grep “软件名或者包名”；
   yum list installed | grep docker
   

1、前提说明

Docker 要求 CentOS 系统的内核版本高于 3.10，查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker

通过uname -r 命令查看你当前的内核版本# uname -r

查看操作系统版本# cat /etc/redhat-release

2、安装步骤

卸载旧版本

yum remove docker \
           docker-client \
           docker-client-latest \
           docker-common \
           docker-latest \
           docker-latest-logrotate \
           docker-logrotate \
           docker-engine
1
2
3
4
5
6
7
8

停止docker服务：
systemctl stop docker 

卸载docker：
yum remove docker-ce docker-ce-cli containerd.io
删除文件：
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
1
2
3
4
5
6
7
8

yum安装gcc相关

yum -y install gcc
yum -y install gcc-c++
1
2

安装需要的软件包

安装yum-utils包

yum install -y yum-utils
1

设置stable镜像仓库

不推荐：按照官网要求执行如下命令，因为是外网，容易报错，连接超时

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
1

推荐：

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
1

更新yum软件包索引

yum makecache fast
1

安装Docker CE

yum -y install docker-ce docker-ce-cli containerd.io
1

启动docker

systemctl start docker
1

可使用命令查看：ps -ef|grep docker

停止 docker：
systemctl stop docker 
1
2

测试

docker version
1

docker的命令是 docker + run + 镜像
hello-world的镜像在本地库没有，就会去远程拉取到本地，然后运行实例

docker run hello-world
1

3、阿里云镜像加速

如果 docker 镜像仓库使用的是 阿里云，可以执行此列操作

阿里云

1. 注册一个属于自己的阿里云账户(可复用淘宝账号)

2. 获得加速器地址连接

   1. 登陆阿里云开发者平台
   2. 点击控制台
   3. 选择容器镜像服务
   4. 获取加速器地址
      

3. 粘贴脚本直接执行

   1. 直接粘
      

   2. 或者分步骤都行
      mkdir -p /etc/docker
vim /etc/docker/daemon.json

4. 重启服务器
   systemctl daemon-reload
systemctl restart docker

4、永远的HelloWorld

启动Docker后台容器(测试运行 hello-world)

当首次运行 docker run hello-world 时，会出现以下结果：

输出这段提示之后，hello world 就会停止运行，容器自动终止

run干了什么

5、为啥Docker比VM虚拟机快

比较 Docker 和传统虚拟化方式的不同之处：

• 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程
• 容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核且也 没有进行硬件虚拟 。因此容器要比传统虚拟机更为轻便。
• 每个容器之间互相隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源。

为啥Docker比VM虚拟机快：

1. Docker有着比虚拟机更少的抽象层
   由于docker不需要Hypervisor（虚拟机）实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
2. Docker利用的是宿主机的内核，而不需要加载操作系统OS内核
   当新建一个容器时docker不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻、加载操作系统内核返回等比较费时费资源的过程，当新建一个虚拟机时，虚拟机软件需要加载OS，返回新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返回过程因此新建一个docker容器只需要几秒钟。

Docker常用命令

1、帮助启动类命令

• 启动docker： systemctl start docker
• 停止docker： systemctl stop docker
• 重启docker： systemctl restart docker
• 查看docker状态： systemctl status docker
• 配置开机自启： systemctl enable docker
• 查看docker概要信息： docker info
• 查看docker总体帮助文档： docker --help
• 查看docker命令帮助文档： docker 具体命令 --help

2、镜像命令

2.1、docker images

docker images [OPTIONS] 列出本地主机上的镜像

OPTIONS说明：
-a ：列出本地所有的镜像（含历史映像层）
-q ：只显示镜像ID。

执行结果说明：

各个选项说明：

• REPOSITORY：表示镜像的仓库源
• TAG：镜像的标签 版本号
• IMAGE ID：镜像ID
• CREATED：镜像创建时间
• SIZE：镜像大小

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

2.2、docker search 某镜像名

docker search [OPTIONS] 镜像名字 从远程库搜寻镜像

OPTIONS说明：
--limit : 只列出N个镜像，默认25个
例如：docker search --limit 5 redis

执行结果说明：

2.3、docker pull 某镜像名

docker pull 镜像名字[:TAG] 下载镜像

默认标签 latest

如果没有指明 TAG 就是下载最新版， docker pull 镜像名字 等价于 docker pull 镜像名字:latest

2.4、docker system df

docker system df 查看 镜像 / 容器 / 数据卷 所占的空间

df -h 查看 Linux 硬盘占用空间

2.5、docker rmi 镜像名或ID

docker rmi 镜像名或ID 删除镜像

• 删除单个
  docker rmi -f 镜像ID
• 删除多个
  docker rmi -f 镜像名1:TAG 镜像名2:TAG
• 删除全部
  docker rmi -f $(docker images -qa)

虚悬镜像

仓库名、标签都是<none>的镜像，俗称虚悬镜像dangling image

如下：

3、容器命令

有镜像才能创建容器，这是根本前提（Docker里面需要再下载一个CentOS或者ubuntu镜像）

使用命令：

docker pull centos
或者
docker pull ubuntu
1
2
3

3.1 新建+启动容器

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

OPTIONS说明：
--name=容器新名字 ：为容器指定一个名称
-d ：后台运行容器并返回容器ID
也即启动守护式容器（后台运行）

-i ：以交互模式运行容器，通常与 -t 同时使用
-t ：为容器重新分配一个伪输入终端，通常与 -i 同时使用；
也即启动交互式容器（前台有伪终端，等待交互）
-P ：随机端口映射，大写P
p ：指定端口映射，小写p

启动交互式容器(前台命令行)

使用镜像 centos:latest 以交互模式启动一个容器，在容器内执行 /bin/bash 命令

参数说明：

• -i 交互式操作
• -t 终端
• centos 镜像名
• /bin/bash 放在镜像后的是命令，因为这里想有个交互式Shell，所以使用
• 要退出终端，直接输入 exit

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

docker ps [OPTIONS]

OPTIONS说明：
-a ：列出当前所有 正在运行 的容器+历史上运行过的
-l ：显示最近创建的容器
-n ：显示最近n个创建的容器，后跟数字 -n 2
-q ：静默模式，只显示容器编号

3.3 退出容器

两种退出方式

• exit
  run进去容器，exit退出，容器停止
  

• ctrl+p+q 键盘按键
  run进去容器，ctrl+p+q退出，容器不停止
  容器还活着如下
  

3.4 启动已停止运行的容器

docker start 容器ID或者容器名

进入正在运行的容器：docker exec -it 容器ID或者容器名 /bin/bash
/bin/bash 可以用 bash 代替

3.5 重启容器

docker restart 容器ID或者容器名

3.6 停止容器

docker stop 容器ID或者容器名

强制停止容器：docker kill 容器ID或容器名

3.7 删除已停止的容器

docker rm 容器ID 删除已停止的容器
若容器未停止，无法删除

强制删除：docker rm -f 容器ID

一次性删除多个容器实例
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm

4、重要

有镜像才能创建容器，这是根本前提（下载一个 Redis6.0.8 镜像演示）

4.1 启动守护式容器(后台服务器)

在大部分的场景下，我们希望 docker 的服务是在后台运行的，我们可以过 -d 指定容器的后台运行模式。

命令：docker run -d 容器名

例如：使用镜像 centos:latest 以后台模式启动一个容器，使用命令 docker run-dcentos
然后docker ps -a进行查看，会发现容器已经退出

问题：发现容器已经退出

很重要的要说明的一点：Docker容器后台运行，就必须有一个前台进程
容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的。
这个是docker的机制问题，比如你的web容器，我们以nginx为例，正常情况下，我们配置启动服务只需要启动响应的service即可。例如service
nginx
start。但是，这样做，nginx为后台进程模式运行，就导致docker前台没有运行的应用，这样的容器后台启动后，会立即自杀因为他觉得他没事可做了。
所以，最佳的解决方案是：将你要运行的程序以前台进程的形式运行，常见就是命令行模式，表示我还有交互操作，别中断

redis 前后台启动演示：

• 前台交互式启动
  docker run -it redis:6.0.8
  执行结果：
  
  以前台的方式启动，不能退出当前窗口，退出窗口，应用终止
• 后台守护式启动
  docker run -d redis:6.0.8
  
  redis 更适合这种后台启动

为什么 redis 后台启动后不会被杀掉，像 centos 一样？

因为 redis 本身启动就是个前台进程，而 web 服务启动后都是后台进程，centos 没有前台进程，所以会自杀

4.2 查看容器

查看容器日志
docker logs 容器ID

查看容器内运行的进程
docker top 容器ID

查看容器内部细节，输出是 json 格式
docker inspect 容器ID

4.3 进入正在运行的容器并以命令行交互

docker exec -it 容器ID bash 进入正在运行的容器并以命令行交互

docker attach 容器ID 重新进入

上述两个区别

• attach 直接进入容器启动命令的终端，不会启动新的进程
  用exit退出，会导致容器的停止。
  

• exec 是在容器中打开新的终端，并且可以启动新的进程
  用exit退出，不会导致容器的停止。
  

推荐大家使用 docker exec 命令，因为退出容器终端，不会导致容器的停止

4.4 从容器内拷贝文件到主机上

容器→主机
docker cp 容器ID:容器内路径 目的主机路径

4.5 导入和导出容器

1. export 导出 容器的内容留作为一个tar归档文件（对应import命令）
   docker export 容器ID > 文件名.tar ：将整个容器导出为 tar 包

2. import 导入 从tar包中的内容创建一个新的文件系统再导入为镜像（对应export）
   cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
   

5、总结常用命令

Docker镜像

1、是什么

镜像含义

是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是 image 镜像文件。

只有通过这个镜像文件才能生成Docker容器实例（类似Java中new出来一个对象）

分层的镜像

以 pull 为例，可以看到加载的镜像好像是一层一层的在下载

UnionFS（联合文件系统）

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

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

Docker镜像加载原理

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

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

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

平时安装 CentOS 都是很大内存，为什么 docker 只有几百M ？

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

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

镜像分层最大的一个好处就是共享资源方便复制迁移，就是为了复用。

比如说有多个镜像都从相同的base镜像构建而来，那么DockerHost只需在磁盘上保存一份 base 镜像

同时内存中也只需加载一份base镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

2、重点理解

Docker镜像层都是只读的，容器层是可写的

当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

所有对容器的改动（无论添加、删除、还是修改文件）都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的

3、Docker镜像commit操作案例

docker commit 提交容器副本使之成为一个新的镜像，使用如下命令：

docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

案例演示： ubuntu 安装 vim

centos 演示

1. 从Hub上下载 ubuntu 镜像到本地并成功运行

2. 原始的默认 Ubuntu 镜像是不带着 vim 命令的
   

3. 外网连通的情况下，安装vim
   docker 容器内执行以下两条命令：
   apt-get update 先更新我们的包管理工具
   apt-get -y install vim 然后安装需要的 vim

4. 安装完成后，commit 我们自己的新镜像
   是在容器外执行：
   docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
   

5. 启动我们的新镜像并和原来的对比
   

小总结

Docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。类似Java继承于一个 Base 基础类，自己再按需扩展

新镜像是从base镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层

本地镜像发布到阿里云

1、本地镜像发布到阿里云流程

2、镜像的生成方法

Docker镜像commit操作案例里面已经介绍过，基于当前容器创建一个新的镜像，新功能增强

docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]

OPTIONS 说明：
-a ：提交的镜像作者
-m ：提交时的说明文字
centos 示例：

后面的 DockerFile 章节会介绍第 2 种方法

3、将本地镜像推送到阿里云

阿里云开发者平台https://promotion.aliyun.com/ntms/act/kubernetes.html

创建仓库镜像

1. 选择控制台，进入容器镜像服务

2. 选择个人实例
   

3. 命名空间
   
   

4. 仓库名称
   

5. 进入管理界面获得脚本
   
   是自动生成的脚本，直接复制使用即可
   

将镜像推送到阿里云

1. 将镜像推送到阿里云 registry

2. 管理界面脚本
   这里要记住，登录的密码是要去设置的，不是你的阿里云密码，docker阿里云仓库是需要重新设置访问凭证的
   注意下面图中的星号即为密码的位置

3. 脚本实例
   –username 也可写成 -u
   密码是不显示的别敲错
   密码是在阿里云配置的，最好凭证固定密码和注册密码一致，然后在你的虚拟机数输入的密码和注册的密码一致
   这个密码不是阿里云的登录密码，要在容器镜像下面的访问凭证设置固定密码的
   

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

下载到本地

如下图

本地镜像发布到私有库

1、是什么

Docker Registry

官方Docker Hub地址，中国大陆访问太慢了且准备被阿里云取代的趋势，不太主流

Dockerhub、阿里云这样的公共镜像仓库可能不太方便，涉及机密的公司不可能提供镜像给公网，所以需要创建一个本地私人仓库供给团队使用，基于公司内部项目构建镜像。

Docker Registry 是官方提供的工具，可以用于构建私有镜像仓库

2、将本地镜像推送到私有库

1. 下载镜像Docker Registry
   使用命令：docker pull registry
   

2. 运行私有库Registry，相当于本地有个私有Docker hub
   docker run -d -p 5000:5000 -v /zzyyuse/myregistry/:/tmp/registry --privileged=true registry
   默认情况，仓库被创建在容器的 /var/lib/reqistry 目录下，建议自行用容器卷映射，方便于宿主机联调
   

3. 案例演示创建一个新镜像，ubuntu安装ifconfig命令

   1. 从Hub上下载ubuntu镜像到本地并成功运行

   2. 原始的Ubuntu镜像是不带着ifconfig命令的
      

   3. 外网连通的情况下，安装ifconfig命令并测试通过
      docker 容器内执行以下两条命令：
      apt-get update 先更新我们的包管理工具
      apt-get install net-tools 然后安装

   4. 安装完成后，commit 我们自己的新镜像
      记得是在容器外执行
      docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

   5. 启动我们的新镜像并和原来的对比

4. curl 验证私服库上有什么镜像
   curl-XGEThttp://192.168.111.162:5000/v2/_catalog
   这里的ip是宿主机的，ifconfig查看
   端口后面的路径是 docker 官方规定的镜像仓库的路径，详情见官网文档
   可以看到，目前私服库没有任何镜像上传过。。。。。。

5. 将新镜像 zzyyubuntu:1.2 修改符合私服规范的 Tag
   按照公式docker tag 镜像:Tag Host:Port/RepositoryTag
   

6. 修改配置文件使之支持 http
   vim 命令新增如下红色内容vim/etc/docker/daemonjson
   cat 命令查看修改后配置cat /etc/docker/daemon.json
   别无脑照着复制，reaistry-mirrors 配置的是国内阿里提供的镜像加速地址，不用加速的话访问官网的会很慢
   2个配置中间有个逗号"别漏了，这个配置是ison格式的。
   
   上述理由：docker默认不允许http方式推送镜像，通过配置选项来取消这个限制。====>修改完后如果不生效，建议重启docker

7. push推送到私服库
   docker push 192168.111162:5000/zzyyubuntu:1.2

8. curl验证私服库上有什么镜像2
   curl-XGEThttp://192.168.111.162:5000/v2/_catalog

9. pull到本地并运行
   curl -XGET http://registry:5000/v2/镜像名字/tags/list 这个可以查看镜像的tag
   docker pull 192168.111162:5000/zzyyubuntu:1.2
   

Docker容器数据卷

坑：容器卷记得加入--privileged=true

why？

Docker挂载主机目录访问如果出现cannot open directory:Permission denied

解决办法：在挂载目录后多加一个--privileged=true参数即可

如果是 CentOS7 安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为
在 SELinux 里面挂载目录被禁止掉了，如果要开启，我们一般使用 --privileaed=true 命令，扩大容器的权限解决挂载目录没有权限的问题，也即使用该参数，container 内的 root 拥有真正的 root 权限，否则，container 内的 root 只是外部的一个普通用户权限

回顾下上一讲的知识点，参数 -v

冒号左边是主机路径，右边为容器内的路径，后面的 true 表示放开权限

1、是什么

卷就是目录或文件，存在于一个或多个容器中，由 docker 挂载到容器，但不属于联合文件系统，因此能够绕过 Union File System 提供一些用于持续存储或共享数据的特性

卷的设计目的就是 数据的持久化 ，完全独立于容器的生存周期，因此 Docker 不会在容器删除时删除其挂载的数据卷

一句话：有点类似我们Redis里面的 rdb 和 aof 文件
将docker容器内的数据保存进宿主机的磁盘中

运行一个带有容器卷存储功能的容器实例：
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名

2、能干嘛

将运用与运行的环境打包镜像，run 后形成容器实例运行，但是我们对数据的要求希望是 持久化的

Docker 容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据自然也就没有了

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

特点：

1. 数据卷可在容器之间共享或重用数据
2. 卷中的更改可以直接实时生效，爽
   不是同步，就是挂载。直接写道挂载的目录内了，不是什么实时备份。
3. 数据卷中的更改不会包含在镜像的更新中
4. 数据卷的生命周期一直持续到没有容器使用它为止

3、数据卷案例

3.1 宿主vs容器之间映射添加容器卷

直接命令添加
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名

注意：
若主机内和容器内都没有此目录，Linux 会给你新建目录

查看数据卷是否挂载成功
docker inspect 容器ID

容器和宿主机之间数据共享

正常状态下是共享，并且容器内主动删除的话宿主机内数据也会被删除，不过容器被删除的话，宿主机文件还能保存下来，这时候就是起备份作用了

当容器停止之后，在主机里面进行了修改，再次启动容器，会发现容器里面也同步了修改，说明是双向挂载

3.2 读写规则映射添加说明

读写(默认)
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名
默认同上案例，默认就是rw
只读
容器实例内部被限制，只能读取不能写
docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名

3.3 卷的继承和共享

容器1完成和宿主机的映射

容器2继承容器1的卷规则
docker run -it --privileged=true --volumes-from 父类 --name u2 ubuntu

Docker常规安装简介

1、总体步骤

搜索镜像
拉取镜像
查看镜像
启动镜像
服务端口映射
停止容器
移除容器

2、安装tomcat

docker hub上面查找tomcat镜像
docker search tomcat
从docker hub上拉取tomcat镜像到本地
docker pull tomcat
docker images查看是否有拉取到的tomcat
使用tomcat镜像创建容器实例(也叫运行镜像)
docker run -it -p 8080:8080 tomcat
-p 小写，主机端口:docker容器端口
-P 大写，随机分配端口
i:交互
t:终端
d:后台
访问猫首页
问题
解决
可能没有映射端口或者没有关闭防火墙
把webapps.dist目录换成webapps
先成功启动tomcat
查看webapps 文件夹查看为空
免修改版说明
docker pull billygoo/tomcat8-jdk8
docker run -d -p 8080:8080 --name mytomcat8 billygoo/tomcat8-jdk8

3、安装mysql

docker hub上面查找mysql镜像
从docker hub上(阿里云加速器)拉取mysql镜像到本地标签为5.7
使用mysql5.7镜像创建容器(也叫运行镜像)
命令出处，哪里来的？
简单版
使用mysql镜像
建库建表插入数据
外部Win10也来连接运行在dokcer上的mysql容器实例服务
问题
插入中文数据试试
为什么报错?
docker上默认字符集编码隐患
删除容器后，里面的mysql数据如何办
容器实例一删除，你还有什么？
删容器到跑路。。。。。？
实战版
新建mysql容器实例
新建my.cnf
通过容器卷同步给mysql容器实例
重新启动mysql容器实例再重新进入并查看字符编码
再新建库新建表再插入中文测试
结论
假如将当前容器实例删除，再重新来一次，之前建的db01实例还有吗？trytry

4、安装redis

从docker hub上(阿里云加速器)拉取redis镜像到本地标签为6.0.8
入门命令
命令提醒：容器卷记得加入–privileged=true
在CentOS宿主机下新建目录/app/redis
mkdir -p /app/redis
将一个redis.conf文件模板拷贝进/app/redis目录下
/app/redis目录下修改redis.conf文件
默认出厂的原始redis.conf
使用redis6.0.8镜像创建容器(也叫运行镜像)
测试redis-cli连接上来
请证明docker启动使用了我们自己指定的配置文件
修改前
修改后
记得重启服务
测试redis-cli连接上来第2次

5、安装Nginx

见高级篇Portainer

Docker复杂安装详说

1、安装mysql主从复制

主从复制原理
默认你懂
主从搭建步骤
新建主服务器容器实例3307
进入/mydata/mysql-master/conf目录下新建my.cnf
vim my.cnf
修改完配置后重启master实例
docker restart mysql-master
进入mysql-master容器
docker exec -it mysql-master /bin/bash
mysql -uroot -proot
master容器实例内创建数据同步用户
CREATE USER ‘slave’@‘%’ IDENTIFIED BY ‘123456’;
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON . TO ‘slave’@‘%’;
新建从服务器容器实例3308
进入/mydata/mysql-slave/conf目录下新建my.cnf
vim my.cnf
修改完配置后重启slave实例
docker restart mysql-slave
在主数据库中查看主从同步状态
show master status;
进入mysql-slave容器
docker exec -it mysql-slave /bin/bash
mysql -uroot -proot
在从数据库中配置主从复制
主从复制命令参数说明
在从数据库中查看主从同步状态
show slave status \G;
在从数据库中开启主从同步
Subtopic
查看从数据库状态发现已经同步
主从复制测试
主机新建库-使用库-新建表-插入数据，ok
从机使用库-查看记录，ok

2、安装redis集群(大厂面试题第4季-分布式存储案例真题)

cluster(集群)模式-docker版
哈希槽分区进行亿级数据存储
面试题
1~2亿条数据需要缓存，请问如何设计这个存储案例
回答
单机单台100%不可能，肯定是分布式存储，用redis如何落地？
上述问题阿里P6~P7工程案例和场景设计类必考题目，
一般业界有3种解决方案
哈希取余分区
缺点那？？？
一致性哈希算法分区
是什么
能干嘛
提出一致性Hash解决方案。
目的是当服务器个数发生变动时，
尽量减少影响客户端到服务器的映射关系
3大步骤
算法构建一致性哈希环
服务器IP节点映射
key落到服务器的落键规则
优点
一致性哈希算法的容错性
一致性哈希算法的扩展性
缺点
一致性哈希算法的数据倾斜问题
小总结
哈希槽分区
是什么
哈希槽计算
3主3从redis集群扩缩容配置案例架构说明
见自己的processon笔记
开打步骤
3主3从redis集群配置
关闭防火墙+启动docker后台服务
systemctl start docker
新建6个docker容器redis实例
命令分步解释
docker run
创建并运行docker容器实例
–name redis-node-6
容器名字
–net host
使用宿主机的IP和端口，默认
–privileged=true
获取宿主机root用户权限
-v /data/redis/share/redis-node-6:/data
容器卷，宿主机地址:docker内部地址
redis:6.0.8
redis镜像和版本号
–cluster-enabled yes
开启redis集群
–appendonly yes
开启持久化
–port 6386
redis端口号
进入容器redis-node-1并为6台机器构建集群关系
进入容器
docker exec -it redis-node-1 /bin/bash
构建主从关系
一切OK的话，3主3从搞定
链接进入6381作为切入点，查看集群状态
链接进入6381作为切入点，查看节点状态
cluster info
cluster nodes
主从容错切换迁移案例
数据读写存储
启动6机构成的集群并通过exec进入
对6381新增两个key
防止路由失效加参数-c并新增两个key
查看集群信息
容错切换迁移
主6381和从机切换，先停止主机6381
6381主机停了，对应的真实从机上位
6381作为1号主机分配的从机以实际情况为准，具体是几号机器就是几号
再次查看集群信息
先还原之前的3主3从
先启6381
docker start redis-node-1
再停6385
docker stop redis-node-5
再启6385
docker start redis-node-5
主从机器分配情况以实际情况为准
查看集群状态
redis-cli --cluster check 自己IP:6381
主从扩容案例
新建6387、6388两个节点+新建后启动+查看是否8节点
进入6387容器实例内部
docker exec -it redis-node-7 /bin/bash
将新增的6387节点(空槽号)作为master节点加入原集群
检查集群情况第1次
重新分派槽号
检查集群情况第2次
槽号分派说明
为主节点6387分配从节点6388
检查集群情况第3次
主从缩容案例
目的：6387和6388下线
检查集群情况1获得6388的节点ID
将6388删除
从集群中将4号从节点6388删除
将6387的槽号清空，重新分配，本例将清出来的槽号都给6381
检查集群情况第二次
将6387删除
检查集群情况第三次

DockerFile解析

1、是什么

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。
概述
官网

构建三步骤
编写Dockerfile文件
docker build命令构建镜像
docker run依镜像运行容器实例

2、DockerFile构建过程解析

Dockerfile内容基础知识
1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2：指令按照从上到下，顺序执行
3：#表示注释
4：每条指令都会创建一个新的镜像层并对镜像进行提交
Docker执行Dockerfile的大致流程
（1）docker从基础镜像运行一个容器
（2）执行一条指令并对容器作出修改
（3）执行类似docker commit的操作提交一个新的镜像层
（4）docker再基于刚提交的镜像运行一个新容器
（5）执行dockerfile中的下一条指令直到所有指令都执行完成
小总结

3、DockerFile常用保留字指令

参考tomcat8的dockerfile入门
https://github.com/docker-library/tomcat
FROM
基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from
MAINTAINER
镜像维护者的姓名和邮箱地址
RUN
容器构建时需要运行的命令
两种格式
shell格式
exec格式
RUN是在 docker build时运行
EXPOSE
当前容器对外暴露出的端口
WORKDIR
指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
USER
指定该镜像以什么样的用户去执行，如果都不指定，默认是root
ENV
用来在构建镜像过程中设置环境变量
ADD
将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
COPY
类似ADD，拷贝文件和目录到镜像中。
将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
COPY src dest
COPY [“src”, “dest”]
<src源路径>：源文件或者源目录
<dest目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。
VOLUME
容器数据卷，用于数据保存和持久化工作
CMD
指定容器启动后的要干的事情
注意
Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
参考官网Tomcat的dockerfile演示讲解
官网最后一行命令
Subtopic
我们演示自己的覆盖操作
Subtopic
它和前面RUN命令的区别
CMD是在docker run 时运行。
RUN是在 docker build时运行。
ENTRYPOINT
也是用来指定一个容器启动时要运行的命令
类似于 CMD 指令，但是ENTRYPOINT不会被docker run后面的命令覆盖，
而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序
命令格式和案例说明
优点
在执行docker run的时候可以指定 ENTRYPOINT 运行所需的参数。
注意
如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

小总结

4、案例

自定义镜像mycentosjava8
要求
Centos7镜像具备vim+ifconfig+jdk8
JDK的下载镜像地址
官网
https://mirrors.yangxingzhen.com/jdk/
编写
准备编写Dockerfile文件
大写字母D
构建
docker build -t 新镜像名字:TAG .
注意，上面TAG后面有个空格，有个点
运行
docker run -it 新镜像名字:TAG
再体会下UnionFS（联合文件系统）
虚悬镜像
是什么
仓库名、标签都是的镜像，俗称dangling image
Dockerfile写一个
查看
docker image ls -f dangling=true
命令结果
删除
家庭作业-自定义镜像myubuntu
编写
准备编写DockerFile文件
构建
docker build -t 新镜像名字:TAG .
运行
docker run -it 新镜像名字:TAG

小总结

Docker微服务实战

1、通过IDEA新建一个普通微服务模块

建Module
docker_boot
改POM
写YML
主启动
业务类

2、通过dockerfile发布微服务部署到docker容器

IDEA工具里面搞定微服务jar包
编写Dockerfile
Dockerfile内容
将微服务jar包和Dockerfile文件上传到同一个目录下/mydocker
构建镜像
docker build -t zzyy_docker:1.6 .
打包成镜像文件
运行容器
访问测试

Docker网络

1、是什么

docker不启动，默认网络情况
ens33
lo
virbr0
docker启动后，网络情况
查看docker网络模式命令

2、常用基本命令

All命令
查看网络
docker network ls
查看网络源数据
docker network inspect XXX网络名字
删除网络
docker network rm XXX网络名字
案例

3、能干嘛

容器间的互联和通信以及端口映射

容器IP变动时候可以通过服务名直接网络通信而不受到影响

4、网络模式

总体介绍
bridge模式：使用–network bridge指定，默认使用docker0
host模式：使用–network host指定
none模式：使用–network none指定
container模式：使用–network container:NAME或者容器ID指定
容器实例内默认网络IP生产规则
说明
结论
docker容器内部的ip是有可能会发生改变的
案例说明
bridge
是什么
案例
说明
代码
docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8
两两匹配验证
host
是什么
案例
说明
代码
警告
docker run -d -p 8083:8080 --network host --name tomcat83 billygoo/tomcat8-jdk8
正确
docker run -d --network host --name tomcat83 billygoo/tomcat8-jdk8
无之前的配对显示了，看容器实例内部
没有设置-p的端口映射了，如何访问启动的tomcat83？？
none
是什么
禁用网络功能，只有lo标识(就是127.0.0.1表示本地回环)
案例
docker run -d -p 8084:8080 --network none --name tomcat84 billygoo/tomcat8-jdk8
container
是什么
案例
docker run -d -p 8085:8080 --name tomcat85 billygoo/tomcat8-jdk8
docker run -d -p 8086:8080 --network container:tomcat85 --name tomcat86 billygoo/tomcat8-jdk8
运行结果
案例2
Alpine操作系统是一个面向安全的轻型 Linux发行版
docker run -it --name alpine1 alpine /bin/sh
docker run -it --network container:alpine1 --name alpine2 alpine /bin/sh
运行结果，验证共用搭桥
假如此时关闭alpine1，再看看alpine2

自定义网络

过时的link
是什么
案例
before
案例
docker run -d -p 8081:8080 --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --name tomcat82 billygoo/tomcat8-jdk8
上述成功启动并用docker exec进入各自容器实例内部
问题
按照IP地址ping是OK的
按照服务名ping结果???
after
案例
自定义桥接网络,自定义网络默认使用的是桥接网络bridge
新建自定义网络
新建容器加入上一步新建的自定义网络
docker run -d -p 8081:8080 --network zzyy_network --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --network zzyy_network --name tomcat82 billygoo/tomcat8-jdk8
互相ping测试
问题结论
自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）
自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）
自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）

5、Docker平台架构图解

整体说明
整体架构