【Docker】Docker快速入门-学习笔记

Docker

一、Docker的基本概念

Docker包括三个基本概念

镜像（Image）

好比java中的类
即用于创建Docker容器的一个静态的模板、定义

Docker镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）

镜像不包括任何动态数据，其内容在构建后也不会被改变

容器（Container）

好比java中的对象，一个类，就可以new出好几个对象
容器是独立运行的一个或一组应用，是镜像运行时的实体，容器可以被创建、启动、停止、删除、暂停等

容器实质就是一个运行的进程，并且是独立的，因为这个进程与宿主执行的进程（即操作系统中原有的进程）不同，容器进程运行于属于自己独立的命名空间，拥有自己的root文件系统、自己的网络配置、自己的进程空间，甚至自己的用户ID空间，是运行在一个隔离的环境里

因此容器看起来很像是一个虚拟机，可以简单的理解它就是一个阉割后的虚拟机（但其实不是虚拟机），虚拟机会占用操作系统很多资源，容器就好比一个虚拟机减去了其他不必要的资源占用，只保留足够运行应用的就行了

仓库（Registry）

存放镜像的仓库，就好比maven仓库存放着各种jar包
Docker仓库用来保存，Docker Hub（https://hub.docker.com）提供了庞大的镜像集合以供使用

公有Docker Registry
提供公开的Docker镜像给用户使用，最常用的即官方的Docker Hub
除此之外还有CoreOS的Quay.io，CoreOS相关镜像就存储在这里
还有Google的 Google Container Registry，Kubernetes的镜像使用的就是这个服务
在国内访问这些服务很慢，因此国内的一些云服务提供商提供了针对Docker Hub的镜像服务（Registry Mirror）这些镜像服务成为加速器，常见的有阿里云加速器、DaoCloud加速器等，使用加速器会直接从国内的地址下载Docker Hub镜像，速度快很多

国内也有一些云服务提供商提供类似的公开服务如：时速云镜像仓库、网易云镜像服务、DaoCloud镜像市场、阿里云镜像库等

私有Docker Registry
用户可以在本地搭建私有的Docker仓库，Docker官方提供了Docker Registry镜像，可以直接使用做为私有的Registry服务

开源的Docker Registry镜像只提供了Docker Registry API的服务端实现，足以支持docker命令，不影响使用，但不包含图形界面，已经镜像维护、用户管理、访问控制等高级功能，在官方的商业化版本Docker Trusted中，提供了这些功能

其他的一些概念

Docker客户端（Client）

Dokcer客户端通过命令行或者其他工具使用Docker API与Docker的守护进程进行通信

Docker主机（Host）

一个物理或虚拟机器用于执行Docker守护进程和容器

Docker Machine

Docker Machine是一个简化Docker安装的命令行工具，通过一个简单命令行既可在相应的平台上安装Docker，好比VirtualBox、Digital Ocean、Microsoft Azure

二、Docker引擎

Docker使用客户端-服务器（C/S）架构模式，使用远程API来管理和创建Docker容器
Docker引擎组件的流程如下图所示：

可以看到Docker以客户端的方式来管理网络、镜像、容器、数据卷

图中的Client（客户端）docker CLI、REST API、server docker daemon为Docker引擎的三个核心组件

docker CLI

表示Docker命令行接口，开发者可以在命令行中使用Docker相关指令与Docker守护进程进行交互，从而管理诸如image(镜像)、container(容器)、network(网络)和data volumes(数据卷)等实体

REST API

表示应用程序API接口，开发者通过该API接口可以与Docker的守护进程进行交互，从而指示后台进行相关操作

server docker daemon

表示Docker的服务端组件，他是Docker架构中运行在后台的一个守护进程，可以接收并处理来自命令行接口及API接口的指令，然后进行相应的后台操作

对于开发者而言，既可以使用编写好的脚本文件通过REST API来实现与Docker进程交互，又可以直接使用Docker相关指令通过命令行接口来与Docker进程交互，而其他一些Docker应用则是通过底层的API和CLI进行交互的

三、Docker的安装

Docker只能在Linux系统上安装，以在CentOS中安装为例
安装步骤即参考官方的文档：https://docs.docker.com/engine/install/centos/

Docker现分为两个分支：Docker CE（社区免费版本）、Docker EE（企业收费版）
这里安装Docker CE

1.安装前准备

（1）检验Linux内核版本，要求3.10以上版本

命令：uname -r

（2）卸载旧版本Docker，执行以下命令，若没安装过则跳过

（3）安装一些必要的工具

安装所需的软件包，yum-uitls提供了yum-config-manager应用，并且device-mapper-persistent-data和lvm2需要devicemapper存储驱动程序
以root运行命令：sudo yum install -y yum-utils device-mapper-persistent-data lvm2

（4）添加国内软件源信息，使Docker下载更快

官方的源为：yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo;

阿里云源（推荐）：sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo;

（5）更新yum缓存

输入命令：sudo yum makecache fast

（6）安装Docker CE

输入命令：sudo yum -y install docker-ce

（7）开启Docker后台服务

输入命令：sudo systemctl start docker

（8）检查是否安装并启动成功

输入命令：docker version

Docker服务端就安装完成了

四、配置Docker镜像加速器

由于国内网络原因，拉取Docker镜像会非常慢，因此我们可以配置镜像加速器来提升对Docker Hub的访问速度（就如使用maven时配置阿里云镜像）
Docker官方和国内很多云服务商都提供了加速服务：
1.Docker官方提供的中国 registry mirror
2.阿里云加速器
3.DaoCloud加速器

我们需要在 /etc/docker/daemon.json文件中配置，没有该文件则创建
这里我配置阿里云的镜像加速服务

（1）登录阿里云开发者账号，进入控制台，在左边菜单中找到【容器镜像服务】

（2）在【镜像工具】中找到【镜像加速器】，就可以看到加速器地址

（3）在**/etc/docker/daemon.json文件中以key，value**的形式配置该加速器地址

#递归创建/etc/docker/daemon.json并输入镜像加速配置
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://xxxx.mirror.aliyuncs.com"]
}
EOF

编辑完后重新加载daemon配置、重启docker服务

sudo systemctl daemon-reload
sudo systemctl restart docker

（4）检查加速器是否生效
命令输入：docker info
可以看到Registry Mirrors处已经变为阿里云的镜像地址

五、镜像管理

拉取Docker镜像

Docker运行容器前需要有本地对应的镜像，我们可以从Docker Hub网站中搜寻想要下载的镜像

例如我们想要下载一个Tomcat镜像

从镜像仓库获取镜像的命令为

#仓库地址不给则默认为官方的镜像仓库Docker Hub，但由于之前配置阿里云镜像加速器，所以默认是从阿里云的镜像仓库拉取
#镜像名为两段式名称即[用户名]/[软件名]
#标签不给则默认为latest（即最新）的版本
docker pull [选项] [docker仓库的域名/IP]:[端口号] [/xxx] [用户名/软件名(即镜像名)]:[标签(即版本号)]

我们从Docker Hub获取一个默认版本（latest）的Tomcat


我们也可以从Docker Hub网站中查询Tomcat的版本号，来pull指定版本的Tomcat

例如再pull一个tomcat8版本

列出本地已有的Docker镜像

#列出本地Docker镜像
docker images
#或
docker image ls

TAG——版本号
IMAGE ID——镜像ID
SIZE——镜像体积

镜像体积、Docker的多层存储结构

Docker Hub上的标识的镜像大小和本地列出镜像中的SIZE不一样（docker image ls），Docker Hub上标识的大小是指压缩后的大小，为了减少网络传输中的占用流量，下载和上传过程的镜像都是压缩后的，而本地列出的镜像（docker image ls）中的大小则是解压缩后的所占硬盘空间的大小

Docker镜像采用多层存储结构，每一层的jar包可以继承、复用，因此就算下载了不同版本的镜像，但由于可能本地已经拥有相同的基础镜像，就可以复用（拥有共同的层，相同的层只需要保存一份即可），本地列出的镜像（docker image ls）中的SIZE是指解压缩后各层的大小总和，实际中部分层可以复用，所以实际占硬盘的大小可能要比列表中的SIZE总和小的多，减少了对空间的占用、浪费

如下图，下载过程中也是逐层进行下载

删除本地镜像

要删除本地镜像前要确保此镜像目前没有被任何容器使用

docker image rm [选项] [镜像ID/镜像名/镜像摘要]
#常用
docker image rmi [镜像ID]

例如用镜像ID的方式删除本地latest版本的tomcat镜像

使用镜像ID可以用镜像短ID的方式（即只要输到能唯一区分是哪个ID的程度）

保存镜像

docker save [镜像名称] 

其他辅助命令

#列出本地镜像ID
docker images -q

#查看一个镜像的制作过程
docker history [镜像名称]

六、容器管理

容器与镜像的关系就好比面向对象编程中的对象和类，镜像是静态的，容器是独立运行的一个或一组应用，以及他们的运行环境

查看容器状态

#查看正在运行的容器
docker ps
#或
docker container ls

#查看所有的容器（包括运行和退出）
docker ps -a
#或
docker container ls -a

STATUS：Up表示正在运行、Exited表示已停止

创建同时启动一个容器

启动容器有两种方式：
1.基于镜像新建一个容器并启动
2.将终止状态（stopped）的容器重新启动

docker run [选项] [镜像名称]:[标签] [执行的命令]

#可选项：
#保持和docker容器内的交互，启动容器时，运行的命令结束后，容器依然存活，没有退出（默认会退出、即停止）
-i
#为容器的标准输入虚拟一个tty
-t
#后台运行的容器（守护进程）
-d
#容器在启动后，执行完程序或命令后就销毁（即容器停止后就自动删除）
--rm
#给容器起一个自定义名称
--name
#设置端口号，格式为：[宿主机提供对外访问的端口号]:[容器内部的端口号]
-p

示例：
启动一个Tomcat容器
（1）首先我们docker images查看当前本地是否有tomcat镜像，找到并得知tag为8

（2）我们直接启动一个tomcat容器docker run tomcat:8

会发现tomcat启动信息占满了控制台，因为此时是前台启动，若要后台启动则加上-d，接下来我们退出（终止）当前容器，并重新以后台启动，并自定义名称、设置相应端口号
（3）按Ctrl + C退出（终止）当前前台正在运行的容器
（4）可以删除该容器：docker rm [容器ID]（可以使用短ID）

（5）后台启动tomcat容器，命名为tomcat8080，设置宿主机对外提供访问端口为8080、在容器内部的端口为8080

docker run -d --name tomcat8080 -p 8080:8080 tomcat:8

停止正在运行的容器

#通过容器ID（可以使用短ID）或容器名称停止正在运行的指定容器
docker stop [容器ID/容器名称]

#停止所有正在运行的容器
docker stop $(docker ps -a -q)

启动已停止的容器

#通过容器ID（可以使用短ID）或容器名称启动已停止的指定容器
docker start [容器ID/容器名称]

删除容器

#通过容器ID（可以使用短ID）或容器名称删除指定容器
#只能删除已停止的容器，删除前需停止容器
docker rm [容器ID/容器名称]

#删除所有容器（需要先停止所有容器）
docker rm $(docker ps -a -q)

进入容器

#保持和docker容器内的交互
-i

#为容器的标准输入虚拟一个tty
-t

#进入容器进行操作，后面可以跟多个参数，这里主要说明-i、-t
#只用-i参数时，由于没有分配伪终端，界面没有我们熟悉的Linux命令提示符，但命令执行结果仍然可以返回
#当-i-t参数一起使用时，则可以看到我们属性的Linux命令提示符

#进入容器进行交互操作
docker exec -it [容器ID\容器名称] bash

#退出容器
exit

示例：
这里以Tomcat为例
（1）首先新建并启动一个Tomcat容器（或者已存在了停止的Tomcat容器则直接start启动）

（2）试着访问这个Tomcat服务，访问前首先确保宿主机的防火墙设置中是否对外开放了8080端口号firewall-cmd --list-ports

这里没有开放任何端口号，因此先开放

#永久开放端口号
#--permanent（表示永久生效，否则重启后失效）
firewall-cmd --permanent --zone=public --add-port=8080/tcp

开放后，就可以从外部访问到Tomcat服务器了

但是此时Http状态返回404，这是因为一般情况下Tomcat的webapps下会有一个默认访问的index.html页面，但是docker中为了为了节省服务器空间，优化删除了一些不必要的文件，接下来，我们进入Tomcat容器一探究竟

（3）进入Tomcat容器

#docker exec -it [容器ID/容器名称] bash

输入：ls -l查看Tomcat容器内文件目录列表
（注意：docker为了节省资源、空间，同时也删除了一些不重要的命令包诸如：ll）

进入到webapps目录下，发现确实没有任何文件（index.html等都被docker为了节省资源空间删除了）

（4）在Tomcat容器中webapps目录下创建index.html文件，并输入内容：test

echo "test" >> index.html

此时在外部访问Tomcat服务器，页面输出了“test”

（5）退出Tomcat容器

exit

宿主机与容器之间交换文件

#将容器中的文件拷贝到宿主机中（在宿主机命令行中操作）
docker cp [容器ID/容器名称]:[容器内文件路径] [宿主机存放文件路径]

#将宿主机中文件拷贝到容器中（在宿主机命令行中操作）
docker cp [宿主机内文件路径] [容器ID/容器名称]:[容器内存放文件路径] 

示例：
（1）将Tomcat容器中的webapps下的index.html拷贝到宿主机/root下
首先进入容器docker exec -it [容器ID/容器名称] bash，查看index.html文件路径为：/usr/local/tomcat/webapps/index.html


然后退出容器，在宿主机命令行下拷贝webapps下index.html至宿主机/root下

docker cp e:/usr/local/tomcat/webapps/index.html /root

（1）将宿主机/root下的a.txt文件拷贝至Tomcat容器中的webapps下

docker cp /root/a.txt e:/usr/local/tomcat/webapps

查看日志

docker logs [可选] [容器ID/容器名称]

#可选项：
#查看实时日志
-f
#查看日志产生的日期
-t
#指定输出日志开始日期（即只输出指定日期之后的日志）
#如：--since="2021-12-09"
--since
#查看末尾指定行的日志（默认10行）
#如：--tail=20（查看最后20行日志）
--tail

示例：
实时查看Tomcat容器的最后9条日志

docker logs -f --tail=9 [容器ID/容器名称]

七、数据卷（Volume）

问题

由于docker的文件系统的特性，通过镜像创建一个容器，容器一旦销毁，则容器内的数据也一并被删除，即容器中的数据不是持久化的，只存在在内存中，随着容器的销毁在内存中被清除

——不能在宿主机上很方便的访问容器中的文件
——无法在多个容器之间共享数据
——当容器删除时，容器中产生的数据将丢失

什么是数据卷

这就需要一种独立于容器、提供持久化的数据、可以服务于多个容器的机制
——这就是数据卷

数据卷特点

其生存周期独立于容器的生存周期

1、数据卷可以在容器之间共享、重用
2、对数据卷的修改会立马生效
3、对数据卷的更新不会影响镜像
4、数据卷默认会一直存在，即使容器被删除（独立于容器之外）

数据卷的使用

创建、挂载数据卷

使用数据卷有三种方式：
第一种：事先创建好数据卷，创建容器时去挂载这个数据卷
第二种：创建容器时直接挂载数据卷（跳过事先创建），若没有对应名称的数据卷，docker会自动帮你创建
（第一种和第二种方式数据卷创建后的数据存储目录默认在宿主机的/var/lib/docker/volumes/数据卷名称/_data下）
第三种：创建容器时指定一个路径作为数据卷的存储路径，同时去挂载

实际中推荐使用第二种或第三种方式

创建数据卷指令：

#数据卷创建后默认目录为：/var/lib/docker/volume/数据卷名称/_data
docker volume create [数据卷名称]

创建容器时挂载数据卷：

#创建容器同时去挂载数据卷，若数据卷不存在，Docker会自动帮你创建
docker run -v [数据卷名称]:[容器内部路径] [镜像ID/镜像名称]
#直接指定一个路径作为数据卷的存储位置去挂载
docker run -v [路径]:[容器内部路径] [镜像ID/镜像名称]

示例：
这里以Tomcat容器为例，创建数据卷与Tomcat容器下的webapps目录下进行挂载，首先我先进入一个已存在的Tomcat容器，查看wabapps目录的路径

即路径为：/usr/local/tomcat/webapps

（1）第一种方式：先创建一个名为cty1的数据卷，然后创建名为tomcat8081的容器同时挂载cty1
首先创建cty1数据卷：

可以看到默认的存储路径下有了刚刚创建的cty1
创建容器同时去挂载cty1

共享数据试验
在宿主机/var/lib/docker/volumes/cty1/_data下创建cty1test.txt并输入cty1

进入tomcat8081容器，查看webapps下是否有cty1test.txt文件并打开查看内容，并输入8081

可以发现可以共享数据，然后退出容器，在宿主机下也查看到了刚刚追加的内容8081

再创建一个名为tomcat8082的容器去挂载cty1数据卷，也能共享到数据

当停止、删除所有容器后，数据卷cty1依然存在，实现了持久化

（2）第二种方式：创建容器直接去挂载数据卷，跳过事先创建数据卷
创建一个名为tomcat8083的容器同时去挂载cty2数据卷（此时没有cty2数据卷）

可以看到cty2被自动创建了

（3）第三种方式：创建容器同时指定一个宿主机下的路径作为持久化数据存储路径进行挂载
创建一个名为tomcat8084的容器挂载/root

可以看到/root被作为数据卷的存储路径了

查看数据卷

#查看指定数据卷的具体信息
docker volume inspect [数据卷名称]
#查看全部数据卷
docker volume ls

删除数据卷

docker volume rm [数据卷名称]

八、docker安装和配置Nginx

（1）拉取nginx：docker pull nginx
（2）创建并运行容器：docker run -d --name nginx80 -p 80:80 nginx
（3）进入容器内部：docker exec -it nginx80 bash，找到nginx的配置文件

#查看nginx安装路径
whereis nginx

/etc/nginx为nginx的核心文件
/usr/share/nginx为nginx的html静态文件
（4）cd进入/etc/nginx，nginx的配置文件就在这个目录下

由于Docker为了节省资源空间，减去了很多命令，因此在容器内部编辑配置文件（集群、负载均衡设置）很不方便，因此我们利用数据卷的方式，将配置文件等一些经常需要修改的文件存放在数据卷中并和容器中对应的路径进行挂载，这样就可以在宿主机中进行编辑了
（5）宿主机中创建目录来作为数据卷
退出容器，在**/usr/local下先创建一个目录nginx**：mkdir -p /usr/local/nginx
然后再在这个目录下创建三个目录：

#用于存放静态html
mkdir -p /usr/local/nginx/html

#用于存放日志文件
mkdir -p /usr/local/nginx/logs

#用于存放配置文件
mkdir -p /usr/local/nginx/conf

（6）将容器内部中的/etc/nginx下的conf.d和nginx.conf文件拷贝到数据卷/usr/local/nginx/conf下

docker cp nginx80:/etc/nginx/conf.d /usr/local/nginx/conf
docker cp nginx80:/etc/nginx/nginx.conf /usr/local/nginx/conf

（7）删除原来的nginx容器，重新以挂载数据卷的形式创建并运行一个nginx容器

docker run -d --name nginx80 -p 80:80 -v /usr/local/nginx/html:/usr/share/nginx/html -v /usr/local/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /usr/local/nginx/conf/conf.d/default.conf:/etc/nginx/conf.d/default.conf -v /usr/local/nginx/logs:/var/log/nginx nginx

九、docker安装和配置MySql

（1）拉取mysql5.6版本：docker pull mysql:5.6
（2）创建并启动mysql容器，同时设置root用户密码

docker run -d --name mysql_3306 -p 3306:3306 -e MYSQL_ROOT_PASSWORD='root' mysql:5.6

（3）测试连接mysql数据库
首先进入容器内部：docker exec -it mysql_3306 bash
登录root用户：mysql -u root -p，回车后输入密码

（4）开放外部服务器远程访问的权限
登上mysql后，输入mysql命令：GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION;

（5）退出容器，宿主机设置防火墙开放端口3306

firewall-cmd --zone=public --add-port=3306/tcp --permanent

重启防火墙生效：firewall-cmd --reload

十、Docker定制镜像

镜像
当从镜像仓库中下载的镜像不能满足需求时，可以有两种方式来对镜像进行修改：
1.从已经创建的容器中更新镜像，并且提交这个镜像
2.使用Dockerfile指令来创建一个镜像

意义：
对于开发人员，可以对开发团队提供一个完全一致的开发环境
对于测试人员，可以直接拿开发时所构建的镜像测试
对于运维人员，可以实现快速部署、移植

Dockerfile定制镜像

镜像的定制实际就是定制每一层所添加的配置、文件
若我们把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题都会解决——这个脚本就是Dockerfile

Dockerfile：是一个文本文件，其内包含了一条条指令，每一条指令构建一层，即每一层指令的内容，就是描述该层应当如何构建

Dockerfile常用命令

FROM
#指定基础镜像
#任何镜像都会依赖一个基础镜像
#一般会是文件的第一个指令
#当前宿主机上基础镜像若不存在，则会去Docker Hub拉取

#使用格式：
#FROM [镜像名称]:[标签]
#FROM [镜像名称]@digest[校验码]

ENV
#用于为docker容器设置环境变量
#可以用docker inspect命令查看
#创建容器时也可以修改环境变量：docker run -env [key]=[value]

#使用格式：
#ENV JAVA_HOME /usr/local/jdk
#ENV JRE_HOME $JAVA_HOME/jre
#ENV CLASSPATH $JAVA_HOME/lib/:$JRE_HOME/lib/
#ENV PATH $PATH:$JAVA_HOME/bin/

MAINTAINER
#描述作者信息（逐渐废弃）
#改用LABEL替代MAINTAINER

LABEL
#使用格式：
#LABEL maintainer="作者信息"

#LABEL还可以描述其他信息，如版本号LABEL version="1.0"等

WORKDIR
#切换工作目录、跳转，相当于cd
#Docker默认工作目录是/
#除了RUN命令能使用cd来切换目录外，其他指令若想在指定目录下执行就得用WORKDIR
#RUN执行的cd命令也只能作用于当下的RUN，而WORKDIR改变目录是持久的

RUN
#用来执行命令行命令
#有两种格式：
#1.shell格式：RUN [命令]
#2.exec格式：RUN["可执行文件","参数1","参数2"]

#注：RUN cd xxx 是没有意义的，因为只能作用于当下的RUN，若要切换目录用WORKDIR

EXPOSE
#为容器打开指定要监听的端口以实现与外部通信

#使用格式：
#EXPOSE [端口]/[协议]
#协议默认为tcp
#如：EXPOSE 80/tcp EXPOSE 80/udp

COPY
#将宿主机中的文件复制到镜像中去
#src：原文件（支持通配符，通常使用相对路径）
#dest：目标路径（通常使用绝对路径）
#使用格式：
#COPY [src] [dest]

ADD
#类似COPY命令

VOLUME
#创建一个可以从本地主机或其他容器挂载的挂载点
#一般用来存放数据库或需要保存的数据
#只能定义docker管理的卷
#如：VOLUME /data/mysql 运行的时候会随机在宿主机目录下生成一个卷

定制镜像示例

demo1

创建一个镜像（基于Tomcat为基础镜像），并且在容器内部路径/usr/local/tomcat/webapps下创建一个目录名为ROOT，并且里面创建一个index.html，并写入hello world
（1）在宿主机/usr/local/docker/下创建一个空白目录名为demo1

mkdir -p /usr/local/docker/demo1

（2）在该目录下创建一个空文件名为Dockerfile（严格区分大小写，必须与官方的规范一致）

vim Dockerfile

（3）编写Dockerfile

（4）构建镜像，镜像名为demo，标签默认

#docker build 构建镜像
#-t 指定标签名称:标签，标签不写默认表示为是latest
#单独的“.”表示使用当前目录下的Dockerfile构建镜像
docker build -t demo1 .

因为Dockerfile文件中为4行指令，所以构建也分为了4步

构建完成

（4）创建并运行容器demo1，在外部访问

demo2

创建一个镜像（基于Tomcat为基础镜像），并且在容器内部路径/usr/local/tomcat/webapps下创建一个目录名为ROOT，并且创建容器时会去复制宿主机的一个图片到ROOT下，运行时能够访问这张图片
（1）在宿主机的/usr/local/docker/下创建demo2目录，准备一张图片1.jpeg在demo2下

mkdir -p /usr/local/docker/demo2

（2）在demo2下创建并编辑Dockerfile文件

vim Dockerfile

（3）构建镜像

docker build -t demo2 .

（4）创建并启动容器，访问

项目部署war包

（1）在宿主机/usr/local/docker/下创建一个空白目录命名为项目工程名称
（2）将war包压缩为zip文件，例如：nova1.0.zip，将压缩文件复制到刚刚新建的目录下
（3）创建、编辑镜像文件

FROM tomcat
WORKDIR /usr/local/tomcat/webapps/ROOT
#删除ROOT下所有文件（老版本tomcat中会有很多文件）
RUN rm -rf *
COPY nova1.0.zip /usr/local/tomcat/webapps/ROOT
#解压缩
RUN unzip nova1.0.zip
#删除多余压缩包
RUN rm -rf nova1.0.zip
#切换回工作目录
WORKDIR /usr/local/tomcat

镜像列表中，还可以看到一个特殊的镜像，这个镜像既没有仓库名，也没有标签，均为

这个镜像原本是有镜像名和标签的，例如一个镜像为tomcat:8，随着官方镜像的版本升级，本地重新pull tomcat:8的时候，就会重新下载一个名为tomcat:8的，所以为了避免新旧镜像重名、为了区分，就将旧的镜像名和标签命名为，这一类的镜像就称为虚悬镜像

docker pull 和 docker build 都会出现这种情况

一般来说，虚悬镜像已经失去了存在的价值，是可以随意删除的

删除虚悬镜像命令

docker image prune

十二、Docker部署Spring Boot项目

（1）准备一个springboot项目：demo-0.0.1-SNAPSHOT.jar
（2）在宿主机/usr/local/docker下新建一个工程名目录名为：sprintbootdemo
（3）将项目jar包复制到目录springbootdemo下
（4）在目录springbootdemo下新建并编辑Dockerfile

#基础镜像，即运行环境，以windows下环境为准，jdk8
FROM java:8
#创建tmp目录并持久化到Docker数据文件夹，因为springboot使用的内嵌Tomcat容器默认使用/tmp作为工作目录
VOLUME /tmp
#拷贝jar文件并重命名为demo.jar
ADD demo-0.0.1-SNAPSHOT.jar demo.jar
#并不是真正的发布端口，只是容器部署人员与建立image人员之间的交流，即建立镜像的人告诉容器部署人员容器应该映射哪个端口给外界
EXPOSE 7070
#容器启动时运行的命令，相当于我们在命令行中输入java -jar xxx.jar
#为了缩短容器的启动
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/demo.jar"]

（5）构建镜像，命名为springbootdemo

docker build -t springbootdemo .

（6）创建并启动容器，访问

docker run -d --name springbootdemo -p 7070:7070 springbootdemo

十三、IDEA整合Docker

相关设置

（1）服务器上docker配置对外开放远程访问

修改 /lib/systemd/system/docker.service 文件
将ExecStart的值改为：

#将端口号2375对外开放作为docker服务
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0.2375 -H unix://var/run/docker.sock

重新加载配置文件：systemctl daemon-reload
重启服务：systemctl restart docker.service
检查端口是否成功开启：netstat -nlpt
之间curl是否生效：curl http://127.0.0.1:2375/info

（2）服务器防火墙开放端口2375

#开放端口2375
firewall-cmd --zone=public --add-port=2375/tcp --permanent
#重启防火墙
firewall-cmd --reload
#查看开放端口列表
firewall-cmd --list-ports

（3）IDEA中使用docker插件，添加远程连接

一般都默认安装好了docker插件，没有则到【Plugins】中下载，然后在【Settings】-【Build,Execution,Deployment】中可以看到【Docker】菜单
然后点击“+”新建一个Docker连接，选择TCP，输入服务器地址加端口2375完成创建

IDEA中对服务器上的docker进行远程操作

选择要连接的docker，启动后便可连接上服务器上的docker，进行一系列的操作

删除镜像、容器

鼠标右击选中镜像、容器，点击【Delete】便可删除

创建并启动容器

鼠标右击，选择【Create Container】创建容器

停止、启动容器

查看容器、镜像信息

鼠标右击，选择【Inspect】

进入容器

鼠标右击，选择【Exec】

自动化部署 docker-maven-plugin持续集成插件

传统的过程
实际开发中，每一次的版本升级、部署都要人工地进行以下几步：
1.打包
2.把jar包复制到linux下
3.定制镜像Dockerfile
4.构建镜像Docker build
非常影响效率

docker-maven-plugin持续集成插件
现在我们使用docker-maven-plugin持续集成插件就可以自动帮助我们完成以上几步，通过简单地配置，自动生成镜像并推送到仓库中，大大提高了上线效率，同时能够快速动态扩容、快速回滚

（1）查看版本号：https://github.com/spotify/docker-maven-plugin

（2）在pom.xml的【build】-【plugins】标签下添加插件并配置

...
<groupId>com.flgroupId>
<artifactId>ctyartifactId>
<version>1.0.0version>
...
<build>
   <plugins>
        ...
        <plugin>
            <groupId>com.spotifygroupId>
            <artifactId>docker-maven-pluginartifactId>
            <version>1.2.2version>
            
            <configuration>
                
                
                <imageName>dockerdemo/${project.artifactId}imageName>
                
                <imageTags>
                    
                    <imageTag>${project.version}imageTag>
                imageTags>
                
                <baseImage>javabaseImage>
                
                <maintainer>ctyFLmaintainer>
                
                <workdir>/ROOTworkdir>
                
                <cmd>["java","-version"]cmd>
                
                <entryPoint>["java","-jar","${project.build.finalName}.jar"]entryPoint>

                

                
                <dockerHost>http://192.168.12.128:2375dockerHost>

                
                <resources>
                    <resource>
                        <targetPath>/ROOTtargetPath>
                        
                        <directory>${project.build.directory}directory>
                        
                        <include>${project.build.finalName}.jarinclude>
                    resource>
                resources>
            configuration>
        plugin>
        ...
    plugins>
build>

（3）命令行生成镜像

#clean 清除target下的文件
#package 打包
#docker:build 构建镜像
mvn clean package docker:build

可以在Docker管理界面中看到已经更新了镜像列表

接下来就可以进行创建运行容器等操作

（4）持续部署
后期项目升级，只需要更改镜像生成配置中的标签配置项（这里即项目版本号），然后再运行镜像生成命令：mvn clean package docker:build

一键自动部署

前面生成镜像时每次都需要去执行指令：mvn clean package docker:build
现在我们把docker:build集成到打包指令package中，就可以实现一键自动部署

将以下配置复制到pom.xml的docker-maven-plugin配置中

<executions>
	<execution>
		<id>build-imageid>
		<phase>packagephase>
		<goals>
			<goal>buildgoal>
		goals>
	execution>
executions>

此时，就只要双击maven的clean、package就可以生成镜像了

未完待续…