Docker入门笔记

学习视频

1.Docker概述

1.1虚拟化技术的分类

1. 硬件级的虚拟化，核心技术是Hypervisor,例如：VMWare
   

2. 操作系统级的虚拟化：它模拟的是运行在一个操作系统上的多个不同进程，并将其封装在一个密闭的容器里。
   

1.2 虚拟机和Docker的区别

特性	容器	虚拟机
启动	秒级	分钟级
磁盘空间	一般几十MB	一般10G
性能	接近原生	弱于原生
系统支持量	单机支持上千容器	一般几十个
操作系统	与宿主机共享OS	宿主机OS上运行虚拟机OS

2 Docker环境搭建

2.1 安装Docker

linux centos7

1. 查看是否安装了docker：yum list installed | grep docker
2. 卸载docker：yum remove docker名 -y(无需确认直接卸载)
3. 安装docker：yum install docker -y(无需确认直接安装)
4. 查看Docker版本：docker -v

2.2 启动Docker

1. 查看docker进程：ps -ef|grep docker
2. 启动docker：systemctl start docker
3. 如果启动失败报错Main PID: 2821 (code=exited, status=1/FAILURE)，修改docker配置文件：vim /etc/sysconfig/docker,在–selinux-enabled后添加false
4. 停止docker:systemctl stop docker
5. 重启docker:systemctl restart docker
6. 查看docker状态：systemctl status docker
7. 查看docker系统信息(docker启动时才有效)：docker info
8. 查看docker指令：docker
9. 查看某个命令的帮助信息：docker 命令 --help

2.3 Docker运行机制

Docker并不是容器，而时一个管理容器的引擎，
Docker的底层运行原理：
Docker服务启动->运行镜像得到容器(如果本地有镜像则运行本地镜像，如果本地没有镜像则到中央仓库中寻找镜像并下载)->容器中运行我们想要的程序

2.4运行第一个Docker容器

1. 启动docker引擎
2. 下载镜像，Docker运行一个容器需要本地存在有对应的镜像，如果本地没有镜像，Docker会到镜像仓库中下载（默认是DockerHub公共注册服务器中的仓库http://hub.docker.com)。
3. 搜索镜像:docker search 软件名，例如：docker search tomcat
   
4. 下载镜像：docker pull 软件名，例如：docker pull tomcat
5. 查看镜像：docker images
   

REPOSITORY	TAG	IMAGE ID	CATETED	SIZE
镜像仓库	标签	镜像ID(唯一)	创建时间	镜像大小

6. 运行镜像：docker run -d(后台运行) 镜像名(或者镜像ID) ,例如：docker run -d tomcat,
   如果报错有可能需要系统升级：yum update，这时启动的tomcat容器外界是无法访问的
7. 查看运行的容器：docker ps
   
8. 关闭容器：docker stop 容器ID
9. 端口映射：容器内的网络通信与宿主机之间是桥接模式，需要进行映射，-p参数是linux宿主机的端口映射到容器中：
   按端口映射启动容器：docker run -d -p 宿主机端口:容器端口 镜像名（镜像id）
   
   例如，启动tomcat容器：docker run -d -p 8080:8080 tomcat
10. 这是访问http://linunx宿主机ip:8080就可以访问tomcat，
    如果出现404可能是tomcat欢迎页面位置不正确，需要进入容器：docker exec -it [CONTAINER ID] /bin/bash，查看目录：ls -l，
    tomcat默认欢迎页面路径文件是
    webapps/ROOT/index.jsp
    而现在的路径是
    webapps.dist/ROOT/index.jsp
    因此需要修改文件夹名称
    mv webapps webapps2
    mv webapps.dist webapps
11. 如果启动docker引擎后关闭防火墙会导致无法运行镜像，需要重启docker
12. 进入docker容器：docker exec -it 容器id bash
    其中i表示交互式的，也就是标准输入流打开；t表示虚拟控制台
13. 查看容器中的目录：ls -l
14. 退出容器：exit

3 Docker核心组件

3.1 Docker架构

Docker使用客户端-服务器（C/S）架构模式，是以哦那个远程API来管理和创建Docker容器。

Docker容器通过Docker镜像来创建
镜像和容器的关系类似于面向对象编程中类和对象的关系

Docker	面向对象
镜像	类
容器	对象

3.2 Docker核心要素

镜像（Image）、容器（Container）、仓库（Repository)
Docker不是容器，而是管理容器的引擎。

3.2.1镜像

Docker的镜像就是一个只读的模板，可以用来创建Docker容器。
镜像是由很多层的文件系统叠加构成的，最下面是一个引导文件系统bootfs，第二次是一个root文件系统rootfs，root文件系统通常是某种操作系统，比如centos,Ubuntu。在root文件系统之上又有很多层文件系统，这些文件系统叠加在一个，构成docker中的镜像：
镜像的日常操作

1. 查看镜像：docker images
2. 搜索镜像：docker search 镜像名
3. 下载镜像：docker pull 镜像名:版本号
4. 运行镜像：docker run -d 镜像名
   -d:后台运行
   -p:端口映射启动，例：docker run -d -p 6379:6379 redis
5. 查看运行的容器：docker ps
6. 进入容器：docker exec -it 容器id bash
7. 离开容器：exit
8. 删除镜像：docker rmi 镜像名:版本号，例如：docker rmi redis:latest

3.2.2容器

容器时从镜像创建的运行实例。它可以被启动、停止、删除。每个容器都是相互隔离的、保证平台安全的。可以把他当做一个简易版的linux环境，包括root用户权限、进程空空、用户空间和网络空间和运行在其中的应用程序。
Docker利用容器来运行应用，镜像是只读的，容器在启动的时候创建一层可写层作最上层。
容器的日常操作

1. 通过镜像启动容器：docker run -d 镜像名
2. 查看容器：docker ps -a
   -a:查看所有容器
3. 停止容器：docker stop 容器id或容器名称
4. 开启容器：docker start 容器id或容器名称
5. 删除容器：docker rm 容器id或容器名称；删除容器时，容器必须时停止状态，否则会报错
6. 进入容器：docker exec -it 容器id或容器名称 bash
7. 查看容器信息：docker inspect 容器id或容器名称
8. 停止全部运行中的容器：docker stop $(docker ps -q)
9. 删除全部容器：docker rm $(docker ps -qa)
10. 停止并删除全部容器：docker rm -f $(docker ps -qa)
11. 查看容器日志：docker logs 容器id（容器停止状态也能察看）

3.2.3 仓库

仓库时集中存放镜像文件的场所，有时候会吧仓库和仓库注册服务器（Registry）看作同一个事物。实际上，仓库注册服务器上往往存放着对各仓库，每个仓库又包含了多个镜像，每个镜像有不同的标签（tag）：
仓库分为公开仓库（Public）和私有仓库(Private）两种形式；最大的公开仓库是DockerHub,用户也可以创建私有仓库；当用户创建了自己的镜像之后就可以使用push命令将他上传到公有或私有仓库，这样下次在另一台机器上使用这个镜像的时候，只需要从仓库上pull下来即可；
注：Docker仓库的概念和Git类似，注册服务器也类似于GitHub这样的托管服务；国内可以使用阿里云仓库。
根据是否是官方提供，可以将镜像分为两类：一种是基础镜像，或根镜像；另一个是用户创建的，叫用户镜像。

仓库的日常操作

1. 查找仓库中的镜像：docker search 软件名

4 Docker使用示例

4.1 Docker安装MySQL

1. 下载MySQL镜像：docker pull mysql
2. 运行MySQL镜像：docker run -p 3306:3306 -e MYSQL_DATABASE=workdb -e MYSQL_ROOT_PASSWORD=123456 -d mysql:latest
   -e:指定环境变量
   -p:映射端口
   -d:后台启动
3. 进入容器：docker exec -it 容器id bash
4. 查找MySQL位置：which mysql
5. 进入容器中的mysql：mysql -uroot -p,然后输入密码，可以操作容器中的mysql
6. 修改密码（可选操作）：ALTER USER ‘root’@‘localhost’ IDENTIFIED BY ‘123456’;
7. 授权远程登录访问：

CREATE USER 'wkcto'@'%' IDENTIFIED WITH mysql_native_password BY '123456';//创建wkcto用户
GRANT ALL PRIVILEGES ON *.* TO 'wkcto'@'%';//授权wkcto用户所有权限，任何ip都可以访问

4.2 Docker安装Nginx

1. 下载nginx镜像：docker pull nginx
2. 运行镜像：docker run -d -p 80:80 nginx
3. 进入容器：docker exec -it 容器id bash
4. nginx的主配置文件目录：/etc/nginx/nginx.conf
5. nginx的子配置文件目录：/etc/nginx/conf.d/*.conf
6. 将lunux宿主机中的文件拷贝到容器下：docker cp 文件路径 容器id:目标路径
7. 部署静态页面：
   • 在宿主机创建test.html文件
   • 查看nginx的子配置文件中location-root路径，要把test.html文件复制到这个路径中
   • 把test.html文件复制到容器中：docker cp /root/test.html f4c62bc8e6b6:/usr/share/nginx/html

4.3 Docker安装Zookeeper

1. 下载Zookeeper镜像：docker pull zookeeper
2. 运行镜像：docker run -p 2181:2181 -d zookeeper
3. 通过ZooInspector工具连接zookeeper

4.4 Docker安装ActiveMQ

1. 下载ActiveMQ：docker pull webcenter/activemq (activemq在DockerHub上没有官方版本)
2. 运行镜像：docker run -p 8161:8161 -d webcenter/activemq
3. 进入容器：docker exec -it b08b3d73b04c bash
4. 浏览器访问activemq

5 Docker自定义镜像

5.1 认识Dockerfile文件

Dockerfile用于构建Docker镜像，Dockerfile文件是由一行行命令语句组成，基于这些命令即可以构建一个镜像，
Dockerfile文件样例：

FROM XXX/jdk:8
MAINTAINER docker_user
ENV JAVA_HOME /usr/local/java
ADD apache-tomcat-8.0.32.tar.gz /usr/local/
RUN mv apache-tomcat-8.0.32 tomcat8
EXPOSE 8080
RUN CHMOD u+x /usr/local/tomcat8/bin/*.sh
CMD /usr/local/tomcat8/bin/catalina.sh start

5.2 Dockerfile的基本结构

一般的，Dockerfile分为四部分：
基础镜像信息；
维护者信息（可有可无）；
镜像操作指令；
镜像启动时执行指令；

5.3 Dockerfile指令（用的时候再查）

FROM

FROM指令是整个Dockerfile的入口，必须是第一条指令。其代表新制作镜像的基础镜像。

基础镜像可以自己制作，也可以从开源的仓库pull，例如dockerhub或是国内阿里云的免费仓库。

Docker中存在一种特殊的情况，就是不以任何基础镜像为基准，此时可以第一句话使用：

FROM scratch

来表示以空白镜像为基础，也就是直接将可执行文件复制进镜像。例如swarm、coreos/etcd等。
RUN指令

是dockerfile中最常用的指令之一。用来执行命令行上的命令。

• RUN的格式分为两种：

第一种：
shell格式：RUN<命令>，类似于直接在终端输入命令。例如：

RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/tomcat/welcome.html

第二种：
exec格式：RUN ["可执行文件", "参数1", "参数2"]。
RUN既然可以像在命令行那样工作，那么就也可以实现传参来运行指令：

Copy
FROM ubuntu:14.04

RUN apt-get update
RUN apt-get install -y gcc libc6-dev make
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz"
RUN mkdir -p /usr/src/redis
RUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1
RUN make -C /usr/src/redis
RUN make -C /usr/src/redis install

RUN一次就代表Dockerfile中的一层。而docker镜像的构建就是不断去完善每一层需要做的事情。而dockerfi对一个file中层数是有限制的，最大不超过127层。因此，RUN提供命令的串联功能，也就是允许每一层可包含多种操作，他们会按照书写顺序来依次执行。

• 那么上面的例子可以变为：

Copy
FROM ubuntu:14.04
RUN buildDeps='gcc libc6-dev make' \
    && apt-get update \
    && apt-get install -y $buildDeps \
    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \
    && mkdir -p /usr/src/redis \
    && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
    && make -C /usr/src/redis \
    && make -C /usr/src/redis install \
    && rm -rf /var/lib/apt/lists/* \
    && rm redis.tar.gz \
    && rm -r /usr/src/redis \
    && apt-get purge -y --auto-remove $buildDeps

换行用 \ ，注释用 # ，平时书写注意缩进来保证文件的可读性。上述例子中的最后一句还进行了无关文件的清理，进一步保证每一层的最优和最小。

注意事项：
镜像的初衷是进行功能的模块化，也是尽可能让每个容器干最少的事情，那么我们在书写dockerfile的时候要注意这个问题，每一层的东西确保是必须的，否则就不要进行安装或是拷贝。

MAINTAINER

指定作者

• 句法：

MAINTAINER <name>

LABEL

该指令是为镜像添加标签。

• 句法：

LABEL <key>=<value> <key>=<value> <key>=<value> ...

• 一个Dockerfile种可以有多个LABEL，如下：

LABEL multi.label1="value1" \
multi.label2="value2" \
other="value3"

说明：LABEL会继承基础镜像种的LABEL，如遇到key相同，则值覆盖

COPY指令

该指令用于将宿主机文件拷贝至镜像内的指定路径。

• 格式：

COPY <源路径>... <目标路径>
或
COPY ["<源路径1>",... "<目标路径>"]

也就是说，原路径可以有多个，而目标路径唯一。
注意事项：

1、可以使用符合GO规范的通配符，例如：COPY hom* /mydir/
2、目的路径可以是镜像内的绝对路径，也可以是相对于当前工作目录的相对路径。
3、COPY过来的文件权限与原始权限相同。如需更改，请用传统Liunx的chmod命令进行修改即可。

ADD高级复制

ADD的本质作用类似于COPY，但是其更复杂：

1、ADD过来的压缩包可以自动在目标路径下进行解压
2、原始路径可以是一个连接，ADD过程会尝试从该链接下载所需的文件到目的路径。
3、一般情况下，建议使用COPY而不是ADD，因为COPY过来的文件可以配合使用RUN来进行解压或是其他操作，搭配使用更灵活，且单条语句所负担的功能唯一。、

WORKDIR

该指令用于指定Dockerfile中该指令下面的操作所在的工作目录。

类似于 cd 命令。
CMD 服务启动指令

指定启动容器时执行的命令，每个Dockerfile只能有一条CMD命令，如果指定了多条命令，只有最后一条会被执行。如果用户启动容器时hiding了运行的命令，则会覆盖掉CMD指定的命令。

• 格式：

shell 格式：CMD <命令>
exec 格式：CMD ["可执行文件", "参数1", "参数2"...]
参数列表格式：CMD ["参数1", "参数2"...]。在指定了 ENTRYPOINT 指令后，用 CMD 指定具体的参数。

• 注意事项：

1、CMD中的启动参数可以被更新覆盖。例如：
Dockerfile中若是用CMD指定启动镜像时执行/bin/bash，那么在启动镜像时输入docker run -it ubuntu ./test.sh 则会用./test.sh命令来覆盖/bin/bash命令。
2、推荐使用exec格式的CMD书写。这类格式在解析时会被解析为 JSON 数组，因此一定要使用双引号 "，而不要使用单引号。
3、如果使用 shell 格式的话，实际的命令会被包装为 sh -c 的参数的形式进行执行。比如：CMD echo /java
在实际执行中，会将其变更为：
CMD [ "sh", "-c", "echo /java" ]

ENV设置环境变量

说是环境变量还不如说是一个全局变量。在前面定义，后面可以通过 $ 取值进行使用。

• 格式：

ENV <key> <value>
ENV <key1>=<value1> <key2>=<value2>...

例如可以指定一些包的版本号，这样更新镜像很方便，或是保存一些密码（该功能慎用，自己玩还是可以的）
**ARG 构建参数 **

语法形式: ARG <name>[=<default value>]

ARG和ENV效果类似，都是用来设置环境变量的。唯一 不同的是dockerfile中的ARG编译好后是不会出现在打开的容器内的。

ARG在dockerfile中创建一个全局参数，参数可以给定一个默认值，在编译时可以传参对其进行覆盖。如果ARG指令有默认值并且在构建期间没有接收到参数、则使用默认值。一个dockerfile中可以包含多个ARG参数。

docker build --build-arg <varname>=<value>

可以使用ARG或ENV指令来指定RUN指令可用的变量，如果ARG和ENV同时指定了一个相同名称的变量、则ENV设置的变量会覆盖ARG设置的变量。如下:

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 ENV CONT_IMG_VER v1.0.0
4 RUN echo $CONT_IMG_VER

使用 docker build --build-arg CONT_IMG_VER=v2.0.1 . 最终输出v1.0.0 。

一个ARG指令的有效范围在其定义的构建阶段内、如果要在多个阶段中都有效、则必须在每个阶段都使用ARG指令；与ARG不同 ENV设置参数的有效期为整个构建期内。

VOLUME 挂在共享卷

• 格式为：

VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>

Docker的使用原则除了每个容器干尽量少的事情外，还尽可能要求容器运行时应该尽量保持容器存储层不发生写操作，对于数据库类需要保存动态数据的应用，其数据库文件应该保存于卷(volume)中，也就是将本地磁盘的某一个目录挂载至容器内。同时这样的共享目录可以被多个不同的容器所使用。

除了可以在dockerfile中指定这一参数外，在运行启动容器时也可以附带这一参数来指定共享卷：

docker run -it --name container-test -h CONTAINER -v /data debian /bin/bash

上述命令也可以覆盖dockerfile中的目录设定。
USER 指定用户

在书写dockerfile时，某些层的操作若想切换用户名，可以使用该参数指定某些层的用户，并且是存在的用户名。

• 格式：USER <用户名>

如果以 root 执行的脚本，在执行期间希望改变身份，比如希望以某个已经建立好的用户来运行某个服务进程，不要使用 su 或者 sudo，这些都需要比较麻烦的配置，而且在 TTY 缺失的环境下经常出错。建议使用 gosu

# 建立 redis 用户，并使用 gosu 换另一个用户执行命令
RUN groupadd -r redis && useradd -r -g redis redis
# 下载 gosu
RUN wget -O /usr/local/bin/gosu "https://github.com/tianon/gosu/releases/download/1.7/gosu-amd64" \
    && chmod +x /usr/local/bin/gosu \
    && gosu nobody true
# 设置 CMD，并以另外的用户执行
CMD [ "exec", "gosu", "redis", "redis-server" ]

EXPOSE暴漏端口

• 句法：

EXPOSE <端口1> [<端口2>...]

EXPOSE 指令是声明运行时容器提供服务端口，这只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务。在 Dockerfile 中写入这样的声明有两个好处，一个是帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射；另一个用处则是在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。

要将 EXPOSE 和在运行时使用 -p <宿主端口>:<容器端口> 区分开来。-p，是映射宿主端口和容器端口，换句话说，就是将容器的对应端口服务公开给外界访问，而 EXPOSE 仅仅是声明容器打算使用什么端口而已，并不会自动在宿主进行端口映射。

5.4Dockerfile自定义镜像

5.4.1自定义jdk镜像

Dockerfile

FROM centos:latest //从centos:latest开始
MAINTAINER docker_user //指定维护者信息
ADD jdk-8u121-linux-x64.tar.gz /usr/local //把当前文件夹jdk包拷贝到容器中的/usr/local目录下
ENV JAVA_HOME /usr/local/jdk1.8.0_121 //配置java环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar //配置CLASSPATH，用冒号分隔
ENV PATH $PATH:$JAVA_HOME/bin //配置环境变量，用冒号分隔
CMD java -version //指定启动容器时执行的命令

1. 在宿主机创建docker文件夹
2. 创建Dockerfile文件，把上面的代码复制进去，删除注解
3. 把 jdk-8u121-linux-x64.tar.gz压缩包复制到docker文件夹
4. 构建镜像：docker build -t wkcto_jdk1.8.0_121 . （最后的点表示使用当前文件夹内的Dockerfile文件生成镜像）
5. 运行镜像：docker run wkcto_jdk1.8.0_121

5.4.2自定义tomcat镜像

Dockerfile

FROM wkcto_jdk1.8.0_121 //指定基础镜像
MAINTAINER wkcto //作者
ADD apache-tomcat-8.5.35.tar.gz /usr/local/ //复制当前文件夹内tomcat压缩包到指定路径下
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.35 //配置环境变量
ENV PATH $PATH:$CATALINA_HOME/lib:$CATALINA_HOME/bin //配置环境变量
EXPOSE 8080 //docker服务端暴露端口号
CMD /usr/local/apache-tomcat-8.5.35/bin/catalina.sh run //运行容器内tomcat

1. 在宿主机创建docker文件夹
2. 创建Dockerfile文件，把上面的代码复制进去，删除注解
3. 把 apache-tomcat-8.5.35.tar.gz压缩包复制到docker文件夹
4. 构建镜像：docker build -t wkcto-tomcat-8.5.35 . （最后的点表示使用当前文件夹内的Dockerfile文件生成镜像）
5. 运行镜像：docker run -d -p 8080:8080 wkcto-tomcat-8.5.35

5.4.3自定义MySQL镜像

Dockerfile

FROM centos:centos6 //指定基础镜像，centos7,8与6有很大不同，先使用centos6
MAINTAINER wkcto //作者信息
/** 因为centos6不再继续维护，所以需要运行一下5行，才能执行yum */
RUN sed -i "s|enabled=1|enabled=0|g" /etc/yum/pluginconf.d/fastestmirror.conf
RUN mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo https://www.xmpan.com/Centos-6-Vault-Aliyun.repo 
RUN yum clean all
RUN yum makecache

RUN yum install -y mysql-server mysql //run执行命令，自动确认安装mysql和mysql服务端
RUN /etc/init.d/mysqld start && \  //启动mysql，\表示换行
	mysql -e "grant all privileges on *.* to 'root'@'%' identified by '123456' WITH GRANT OPTION;"&&\ //授权所有ip，设置密码
	mysql -e "grant all privileges on *.* to 'root'@'localhost' identified by '123456' WITH GRANT OPTION;"&&\ //授权所有权限给root，设置密码
	mysql -uroot -p123456 -e "show databases;" //进入数据库服务端，展示数据库
EXPOSE 3306 //占用容器端口3306
CMD /usr/bin/mysqld_safe //启动mysql

1. 在宿主机创建docker文件夹
2. 创建Dockerfile文件，把上面的代码复制进去，删除注解
3. 构建镜像：docker build -t wkcto-mysql . （最后的点表示使用当前文件夹内的Dockerfile文件生成镜像）
4. 运行镜像：docker run -d -p 3306:3306 wkcto_mysql

5.4.4自定义redis镜像

Dockerfile

FROM centos:latest
MAINTAINER wkcto
RUN yum -y install epel-release && yum -y install redis && yum -y install net-tools
EXPOSE 6379
CMD /usr/bin/redis-server --protected-mode no

1. 构建镜像：docker build -t wkcto-redis .
2. 运行镜像：docker run -d -p 6379:6379 wkcto-redis

5.5 镜像发布到仓库

进入阿里云，控制台，搜索容器镜像服务

** 镜像加速**

复制 “registry-mirrors”: [“https://自己的阿里云加速地址.mirror.aliyuncs.com”]到/etc/docker/daemon.json文件中，不同用户加速地址不同。

进入个人版默认实例

创建命名空间

点击创建镜像仓库,镜像仓库右边的【管理】有【操作指南】

按照操作指南：

1. 登录阿里云镜像
2. push镜像
3. pull镜像

6.SpringBoot项目部署到Docker中

6.1部署springboot程序准备工作

1. 把开发的springboot程序打成jar包或者war包
2. 把打好的包上传到linux的某个目录下
3. 定义Dockerfile文件，用于创建项目镜像
   注意：
   springboot打war包的时候需要实现一个类
   

6.2Docker部署jar包SpringBoot程序

6.2.1定义jar包程序Dockerfile文件

FROM java
MAINTAINER wkcto
ADD demo-0.0.1-SNAPSHOT.jar /opt
RUN chmod +x /opt/demo-0.0.1-SNAPSHOT.jar //给这个包可执行权限
CMD java -jar /opt/demo-0.0.1-SNAPSHOT.jar

6.2.2 构建和运行jar包程序的镜像

构建镜像：docker build -t springboot-web-jar .
运行镜像：docker run -d -p 8080:8080 sprintboot-web

6.3Docker部署War包springboot程序

6.3.1定义war包程序的Dockerfile文件

FROM wkcto-tomcat-8.5.35
MAINTAINER wkcto
ADD demo-0.0.1-SNAPSHOT.war /usr/local/apache-tomcat-8.5.35/webapps
EXPOSE 8080
CMD /usr/local/apache-tomcat-8.5.35/bin/catalina.sh run

6.3.2构建和运行war包程序的镜像

构建镜像：docker build -t springboot-web-war .
运行镜像：docker run -d -p 9090:8080 springboot-web-war (因为jar包占用了8080端口，所以使用9090端口)
注意
项目工程名需要改成war包名

6.4修改容器保存

docker commit 容器id xxx(镜像名：tagxxx)
例如可以保存MySQL的库，表和和数据

docker容器内安装yum，vim等应用

apt-get update
apt-get install yum
apt-get install vim

参考文档

https://blog.youkuaiyun.com/qq_1365462762/article/details/80623524
https://blog.youkuaiyun.com/wangqingbang/article/details/90600057
https://blog.youkuaiyun.com/shxbl0/article/details/108953468
https://blog.youkuaiyun.com/whatday/article/details/86762264
https://www.cnblogs.com/xiao-xue-di/p/14229571.html
https://www.cnblogs.com/evescn/p/12470762.html
https://www.cnblogs.com/chinesern/p/8440206.html
https://blog.youkuaiyun.com/xnattack/article/details/111503741
https://blog.youkuaiyun.com/qq_25693315/article/details/87983711
https://blog.youkuaiyun.com/leohan163/article/details/108364195