1.Docker 简介
Docker 是一个开源的容器引擎，它可以帮助我们更快地交付应用。Docker 可将应用程序和基础设施层隔离，并且能将基础设施当作程序一样进行管理。使用 Docker，可更快地打包、测试以及部署应用程序，并可减少从编写到部署运行代码的周期。
Docker 官方网站：https://www.docker.com/
1.1、Docker 版本
1、Docker EE（企业版）
Docker EE 由公司支持，可在经过认证的操作系统和云提供商中使用，并可运行来自 Docker Store 的、经过认证的容器和插件。
2、Docker CE（免费版）
Docker CE 是免费的 Docker 产品的新名称，Docker CE 包含了完整的 Docker 平台，非常适合开发人员和运维团队构建容器 APP
1.2、 Docker 架构
1.2.1、Docker daemon（Docker 守护进程）
Docker daemon 是一个运行在宿主机（DOCKER_HOST）的后台进程。我们可通过 Docker 客户端与之通信。
1.2.2、Client（Docker 客户端）
Docker 客户端是 Docker 的用户界面，它可以接受用户命令和配置标识，并与 Docker daemon 通信。图中，docker build 等都是 Docker 的相关命令。
1.2.3、 Images（Docker 镜像）
Docker 镜像是一个只读模板，它包含创建 Docker 容器的说明。它和系统安装光盘有点像— —我们使用系统安装光盘安装系统，同理，我们使用 Docker 镜像运行 Docker 镜像中的程序。
1.2.4、 Container（容器）
容器是镜像的可运行实例。镜像和容器的关系有点类似于面向对象中，类和对象的关系。
我们可通过 Docker API 或者 CLI 命令来启停、移动、删除容器。
1.2.5、 Registry（仓库）
Docker Registry 是一个集中存储与分发镜像的服务。我们构建完 Docker 镜像后，就可在当前
宿主机上运行。但如果想要在其他机器上运行这个镜像，我们就需要手动拷贝。此时，我们可借助 Docker Registry 来避免镜像的手动拷贝。
一个 Docker Registry 可包含多个 Docker 仓库；每个仓库可包含多个镜像标签；每个标签对
应一个 Docker 镜像。这跟 Maven 的仓库有点类似，如果把 Docker Registry 比作 Maven 仓库
的话，那么 Docker 仓库就可理解为某 jar 包的路径，而镜像标签则可理解为 jar 包的版本号。
Docker 安装启动
2.1、运行安装环境
采用 Linux 操作系统，版本为：Centos7.0 64 位
Docker 采用 CE 版：18.06.0.ce-3
2.2、 Docker 安装过程
2.2.1、 下载 Docker-CE rpm 安装包
https://download.docker.com/linux/centos/7/x86_64/stable/Packages/
注意下载版本要和操作系统版本对应。
docker-ce-18.06.2.ce-3.el7.x86_64.rpm
2.2.2、 安装 Docker
执行命令:yum install -y docker-ce-18.06.2.ce-3.el7.x86_64.rpm
注意：确保 linux 服务器处于联网状态。
2.2.3、 启动与停止 Docker
启动 docker：systemctl start docker
停止 docker：systemctl stop docker
重启 docker：systemctl restart docker
查看 docker 状态：systemctl status docker
2.2.3、 验证 Docker 是否安装成功
执行命令：docker info
查看返回信息，能否查看到 Docker 相关信息
到此，Docker 安装完毕！
Docker 配置镜像加速器
国内访问 Docker Hub 的速度很不稳定，有时甚至出现连接不上的情况。我们来为 Docker 配置镜像加速器，从而解决这个问题。目前国内很多云服务商都提供了镜像加速的服务。
常用的镜像加速器有：阿里云加速器、DaoCloud 加速器等。各厂商镜像加速器的使用方式大致类似，笔者以阿里云加速器为例进行讲解。
注册阿里云账号后，即可在阿里云控制台（https://cr.console.aliyun.com/#/accelerator）看到类似如下的页面。
3.1、编辑：/etc/docker/daemon.json
{
“registry-mirrors”: [“https://w5z91a3d.mirror.aliyuncs.com”]
}
3.2、修改保存后输入如下命令重启 Docker 守护进程和服务
systemctl daemon-reload
systemctl restart docker
Docker 镜像操作常用指令
4.1、搜索镜像
可使用 docker search 命令搜索存放在 Docker Hub 中的镜像
执行命令：docker search tomcat
列说明：
NAME：仓库名称
DESCRIPTION：镜像描述
STARS：用户评价，反应一个镜像的受欢迎程度
OFFICIAL：是否官方
AUTOMATED：自动构建，表示该镜像由 Docker Hub 自动构建流程创建的
4.2、下载镜像
使用命令 docker pull 命令即可从 Docker Registry 上下载镜像。
执行命令 1：docker pull java
执行该命令后，Docker 会从 Docker Hub 中的 java 仓库下载最新版本的 Java 镜像
执行命令 2：docker pull daocloud.io/library/java:8u40-b09
执行该命令后，Docker 会从从指定的 Docker Registry 中下载标签为 8 的 Java 镜像。
4.3、列出本地镜像
使用 docker images 命令即可列出已下载的镜像。
执行命令：docker images
执行该命令后，将会看到类似于如下的表格：
REPOSITORY：镜像所在的仓库名称
TAG：镜像标签
IMAGE ID：镜像 ID
CREATED：镜像的创建日期（不是获取该镜像的日期）
SIZE：镜像大小
这些镜像都是存储在 Docker 宿主机的/var/lib/docker 目录下
4.4、删除本地镜像
使用 docker rmi 命令即可删除指定镜像。
执行命令 1：docker rmi hello-world
执行以上指令，就会删除 hello-world 这个镜像
注意：已经使用镜像创建过容器的不能删除
执行命令 2：docker rmi -f $(docker images)
执行以上指令，就会删除全部镜像
4.5、保存镜像
使用 docker save 即可保存镜像。
执行命令：docker save -o centos7.tar centos:7
-o 参数后面跟要把镜像保存的文件路径和名称
4.6、加载镜像
使用 docker load 即可加载镜像
执行命令：docker load -i centos7.tar
-i 参数后面跟要加载的文件路径和名称
Docker 容器操作常用指令
5.1、新建并启动容器
使用以下 docker run 命令即可新建并启动一个容器。该命令是我们最常用的命令了，它有很多选项，下面列举一些常用的选项。
① -i 选项：表示运行容器
② -d 选项：表示后台运行
③ -t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。
④ -P 选项：随机端口映射
⑤-p 选项：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个－p 做多个端口映射
⑥–name ：指定容器的名称
⑦ –network 选项：指定网络模式，该选项有以下可选参数：
–network=bridge： 默认选项，表示连接到默认的网桥。
–network=host：容器使用宿主机的网络。
–network=container:NAME_or_ID：告诉 Docker 让新建的容器使用已有容器的网络配置。
–network=none：不配置该容器的网络，用户可自定义网络配置。
执行命令 1：docker run java /bin/echo ‘Hello World’
终端会打印 Hello World 的字样，跟在本地直接执行/bin/echo ‘Hello World’ 一样
执行命令 2：docker run -it --name=mycentos centos:7 /bin/bash
就能启动一个 Centos 容器，并进入到容器的命令行终端。在本例 2 个参数，含义如下：
-t #容器启动后会进入其命令行
-i #运行容器
–name #指定容器的名字
执行命令 3：docker run -d -p 91:80 nginx
就能启动一个 Nginx 容器。在本例中，我们为 docker run 添加了 2 个参数，含义如下：
-d # 后台运行
-p 宿主机端口:容器端口 # 开放容器端口到宿主机端口
5.2、列出容器
使用 docker ps 命令即可列出运行中的容器。执行该命令后，可看到类似于如下的表格。
执行命令：docker ps
如需列出所有容器（包括已停止的容器），可使用-a 参数；只查看已经退出的容器使用-q参数
该表格包含了七列，含义如下：
① CONTAINER_ID：表示容器 ID。② IMAGE：表示镜像名称。③ COMMAND：表示启动容器时运行的命令。
④ CREATED：表示容器的创建时间。
⑤ STATUS：表示容器运行的状态。Up 表示运行中，Exited 表示已停止。
⑥ PORTS：表示容器对外的端口号。
⑦ NAMES：表示容器名称。该名称默认由 Docker 自动生成，也可使用 docker run 命令的– name 选项自行指定。
5.3、停止容器
使用 docker stop 命令，即可停止容器
执行命令：docker stop 784fd3b294d7
其中 784fd3b294d7 是容器 ID，当然也可使用 docker stop 容器名称 来停止指定容器。
5.4、强制停止容器
可使用 docker kill 命令停止一个或更多运行着的容器。
执行命令：docker kill 784fd3b294d7
5.5、启动已经停止容器
使用 docker start 命令，即可启动已经停止的容器。
执行命令：docker start 784fd3b294d7
其中 784fd3b294d7 是容器 ID，当然也可使用 docker stop 容器名称 来启动指定容器。
5.6、重启容器
可使用 docker restart 命令重启一个容器。该命令实际上是先执行了 docker stop 命令，然后执行了 docker start 命令。
执行命令：docker restart 784fd3b294d7
5.7、进入容器
一些时候，我们可能需要进入运行中的容器。
1 使用 docker exec 命令进入容器
执行命令：docker exec -it 784fd3b294d7 /bin/bash
5.8、拷贝文件到容器
如果我们需要将文件拷贝到容器内可以使用 docker cp 命令
执行命令 1：docker cp /usr/local/1.txt c1:/usr/local
参数说明：需要拷贝的文件或目录 容器名称:容器目录
执行以上命令即可把本地文件拷贝到容器指定目录。
执行命令 2：docker cp c1:/usr/local/1.txt /usr/local
参数说明：容器名称:容器目录 需要拷贝的文件或目录
执行以上命令即可把容器中的文件拷贝到宿主机指定目录。
5.9、目录挂载
我们可以在创建容器的时候，将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器。
docker run -di -v /usr/local/myhtml:/usr/local/myhtml --name=mycentos2 centos:7
参数说明：创建容器 添加-v 参数 后边为 宿主机目录:容器目录
如果你共享的是多级的目录，可能会出现权限不足的提示。
这是因为 CentOS7 中的安全模块 selinux 把权限禁掉了，我们需要添加参数 --privileged=true
来解决挂载的目录没有权限的问题
docker run -di -v /usr/local/myhtml:/usr/local/myhtml --privileged=true --name=mycentos2 centos:7
5.10、删除容器
使用 docker rm 命令即可删除指定容器。
执行命令 1：docker rm 784fd3b294d7
删除指定容器，该命令只能删除已停止的容器，如需删除正在运行的容器，可使用-f 参数。
执行命令 2：docker rm -f $(docker ps -a -q)
删除所有的容器。
5.11、导入、导出容器
将容器导出成一个压缩包文件。
执行命令：docker export --output=“latest.tar” centos1
使用 docker import 命令即可从归档文件导入内容并创建镜像。
执行命令：docker import nginx2.tar nginx
5.12、查看容器 ip
我们可以通过以下命令查看容器运行的各种数据
执行命令 1：docker inspect mycentos2
也可以直接执行下面的命令直接输出 IP 地址
执行命令 2： docker inspect --format=‘{{.NetworkSettings.IPAddress}}’ mycentos2
5.13、查看容器日志
docker logs [options] 容器获取容器的日志
docker logs --tail=“10” mytest
//–tail=“10” 查看最后 10 行
5.14、退出容器
退出容器，只需要在容器内输入命令 exit
java 开发者 Docker 常用镜像容器创建
6.1、jdk 部署
6.1.1、 拉取 jdk 镜像
执行命令：docker pull java:8
6.1.2、 创建 jdk 容器
执行命令： docker run -di --name jdk1 java:8
说明：jdk 安装的是 openjdk，具体安装路径是：/usr/lib/jvm/java-1.8.0-openjdk-amd64
6.2、mysql 部署
6.2.1、 拉取 mysql 镜像
执行命令：docker pull mysql:5.7
6.2.2、 创建 mysql 容器
执行命令：docker run -di --name=offcn_mysql -p 33306:3306 -e MYSQL_ROOT_PASSWORD=123456 -e MYSQL_DATABASE=springcloud01 mysql
-p 代表端口映射，格式为 宿主机映射端口:容器运行端口
-e 代表添加环境变量 MYSQL_ROOT_PASSWORD 是 root 用户的登陆密码
-e MYSQL_DATABASE=springcloud01 指定跟随容器一起创建数据库 springcloud01
6.2.3、 连接 mysql 容器数据库
远程连接 mysql 数据库只需要使用宿主机 ip 和端口 33306 就可以
6.2.4、 解决 mysql 数据库乱码问题
从 mysql 容器拷贝 mysql 配置文件
docker cp db1:/etc/mysql/mysql.conf.d/mysqld.cnf .
在宿主机修改配置文件 mysqld.cnf
[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
拷贝配置文件到容器
docker cp mysqld.cnf db1:/etc/mysql/mysql.conf.d/mysqld.cnf
重启 mysql
systemctl restart mysqld
登录 mysql：mysql -uroot -p123
查看 mysql 编码状态
mysql> show variables like ‘character_set_%’;
6.3、tomcat 部署
6.3.1、 拉取 tomcat 镜像
执行命令：docker pull tomcat:8.5-jre8
6.3.2、 创建 tomcat 容器
执行命令：docker run -di --name= tomcat1 -p 9000:8080 tomcat:8.5-jre8
6.4、nginx 部署
6.4.1、 拉取 nginx 镜像
执行命令：docker pull nginx
6.4.2、 创建 nginx 容器
执行命令：docker run -di --name=n1 -p 89:80 nginx
Dockerfile 入门
Dockerfile 是由一系列命令和参数构成的脚本，这些命令应用于基础镜像（centos 或者ubuntu，即操作系统级别的镜像）并最终创建一个新的镜像。
1、对于开发人员：可以为开发团队提供一个完全一致的开发环境；
2、对于测试人员：可以直接拿开发时所构建的镜像或者通过 Dockerfile 文件构建一个新的镜像开始工作了；
3、对于运维人员：在部署时，可以实现应用的无缝移植。
7.1、Dockerfile 常用命令
命令 作用
FROM image_name:tag 定义了使用哪个基础镜像启动构建流程
MAINTAINER user_name 声明镜像的创建者
ENV key value 设置环境变量 (可以写多条)，可以在创建容器的时候传递 参数给容器
RUN command 是 Dockerfile 的核心部分，执行系统指令(可以写多条)
ADD source_dir/file dest_dir/file 将宿主机的文件复制到容器内，如果是一个压缩文件，将 会在复制后自动解压
COPY source_dir/file dest_dir/file 和 ADD 相似，但是如果有压缩文件并不能解压
WORKDIR path_dir 设置工作目录
CMD 指定容器启动时运行的命令
7.2、Dockerfile 搭建 jdk 环境
第一步:在宿主机创建 jdk 存储目录
mkdir /usr/local/dockerjdk
第二步：下载 jdk-8u131-linux-x64.tar.gz 并上传到服务器（宿主机）中的/usr/local/dockerjdk 目录
第三步：在/usr/local/dockerjdk 目录下创建文件 Dockerfile
vi Dockerfile
FROM centos:7 #设置基础镜像名称 MAINTAINER wh #设置镜像作者 WORKDIR /usr #设置工作目录 RUN mkdir /usr/local/java #在镜像创建目录 ADD jdk-8u131-linux-x64.tar.gz /usr/local/java/ #复制宿主机 jdk 安装包到镜像（自动解压） ENV JAVA_HOME /usr/local/java/jdk1.8.0_131 #设置环境变量 JAVA_HOME ENV CLASSPATH $JAVA_HOME/lib #设置环境变量 CLASSPATH ENV PATH
J
A
V
A
H
O
M
E
/
b
i
n
:
JAVA_HOME/bin:
JAVAHOME/bin:PATH #设置环境变量 PATH
第四步：执行命令构建镜像
docker build -t=‘jdk1.8’ .
注意后边的空格和点（.表示当前目录，也就是 Dockerfile 所在目录），不要省略
第五步：查看镜像是否建立完成
docker images
7.3、Dockerfile 搭建 tomcat 环境镜像
第一步:在宿主机创建 tomcat 存储目录
mkdir /usr/local/dockertomcat
第二步：上传安装包到服务器
下载 jdk-8u131-linux-x64.tar.gz、apache-tomcat-8.5.15.tar.gz 并上传到服务器（宿主机）中的 /usr/local/dockertomcat 目录
第三步：在/usr/local/dockertomcat 目录下创建文件 Dockerfile
vi Dockerfile
FROM centos:7 #设置基础镜像名称 MAINTAINER ujiuye #设置镜像作者 WORKDIR /usr #设置工作目录 RUN mkdir /usr/local/app #在镜像创建目录 ADD jdk-8u131-linux-x64.tar.gz /usr/local/app/ #复制宿主机 jdk 安装包到镜像（自动解 压） ADD apache-tomcat-8.5.15.tar.gz /usr/local/app/ ENV JAVA_HOME /usr/local/app/jdk1.8.0_131 #设置环境变量 JAVA_HOME ENV CATALINA_HOME /usr/local/app/apache-tomcat-8.5.15 ENV CLASSPATH $JAVA_HOME/lib #设置环境变量 CLASSPATH ENV PATH
J
A
V
A
H
O
M
E
/
b
i
n
:
JAVA_HOME/bin:
JAVAHOME/bin:CATALINA_HOME/bin:$PATH#设置环境变量 PATH EXPOSE 8080 #暴露 8080 端口
CMD [“/usr/local/app/apache-tomcat-8.5.15/bin/catalina.sh”,“run”] #容器启动时运行 tomcat
第四步：执行命令构建镜像
docker build -t=‘tomcat8.5’ .
注意后边的空格和点（.表示当前目录），不要省略
第五步：查看镜像是否建立完成
docker images
第六步：使用镜像创建运行容器
docker run -di --name=t1 -p 8081:8080 tomcat8.5
第七步：访问测试 tomcat
http://ip:8081
7.5、Dockerfile 创建微服务 java 镜像
第一步、编译工程 EurekaServer01 执行构建指令
注意：EurekaServer01 服务器单独部署，暂不使用集群，需要修改属性配置文件
#服务器端口号
server:
port: 8888
#应用名称
spring:
application:
name: EurekaServer01
#是否将自己注册到 Eureka 服务中，本身就是所有无需注册
eureka:
client: register-with-eureka: false
#是否从 Eureka 中获取注册信息
fetch-registry: false
#EurekaServer 注册中心地址
service-url:
defaultZone: http://localhost:${server.port}/eureka
得到构建好的 jar 包：EurekaServer01-0.0.1-SNAPSHOT.jar
注意：pom.xml 一定要增加 springboot 的 maven 编译插件，要不然打包不能使用
org.springframework.boot
spring-boot-maven-plugin
第二步:在宿主机创建 jar 存储目录
mkdir /usr/local/dockerspringboot
上传编译构建好的 jar 包 EurekaServer01-0.0.1-SNAPSHOT.jar 到该目录
第三步：在/usr/local/dockerspringboot 目录下创建文件 Dockerfile
vi Dockerfile
基于哪个镜像
FROM java:8
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar
ADD EurekaServer01-0.0.1-SNAPSHOT.jar /app.jar
声明需要暴露的端口
EXPOSE 8888
配置容器启动后执行的命令
CMD [“java”,“-jar”,“/app.jar”]
第四步：执行命令构建镜像
docker build -t=‘springboot1’ .
注意后边的空格和点（.表示当前目录），不要省略
第五步：查看镜像是否建立完成
docker images
第六步：使用镜像创建运行容器
docker run -di --name=s1 -p 8888:8888 springboot1
第七步：访问测试
http://ip:8888
使用 Nexus 搭建 Docker 镜像私有仓库
Docker 镜像创建好了，怎么样实现在不同的用户和服务器之间共享镜像，Docker 官方提供
了 DockerHub 可以允许用户把自己创作的镜像上传到服务器，但是对于包含企业私有应用的镜像不允许暴露给公共用户，这个时候就需要企业搭建自己的私有镜像存储仓库。
nexus 是一款非常优秀的私有仓库搭建软件，可以很方便的搭建私有镜像仓库。
https://www.sonatype.com/download-oss-sonatype下载地址：https://www.sonatype.com/download-oss-sonatype
8.1、安装 Nexus
1、安装 nexus 需要首先安装 jdk 环境
java -version
2、上传 nexus 安装包到服务器
nexus-3.15.2-01-unix.tar.gz
3、创建目录、解压缩 nexus
mkdir /usr/local/nexus
tar xvf nexus-3.15.2-01-unix.tar.gz -C /usr/local/nexus
4、启动 nexus
cd /usr/local/nexus/nexus-3.15.2-01/bin
./nexus start
5、启动后稍等大于 1 分钟，查看端口监听
netstat -antp|grep 8081
6、开放防火墙端口
firewall-cmd --add-port=8081/tcp --permanent
firewall-cmd --reload
8.2、访问配置 Nexus
1、访问地址 http://ip:8081
出现登陆框，输入账号 admin 密码 admin123
登录成功
2、配置 nexus 创建 Docker 私有仓库
进入系统设置界面
点击 Repositories
点击创建仓库（Create Repository）
选择要创建的仓库类型（docker(hosted)）
配置 docker 仓库信息
查看仓库详情
仓库地址：192.168.0.109:8086
仓库账号: admin
密码: admin123
8.3、配置 Docker 服务器连接到 Nexus 私有仓库
1、修改 /etc/docker/daemon.json 配置 docker 私有仓库
编辑：/etc/docker/daemon.json
{
“registry-mirrors”: [“https://w5z91a3d.mirror.aliyuncs.com”], “insecure-registries”:[“192.168.0.109:8086”], “live-restore”: true }
2、刷新守护进程、重启 dcker
systemctl daemon-reload
systemctl restart docker
8.4、连接 docker 私服镜像仓库及使用
1、登录私服镜像仓库
docker login 192.168.0.109:8086
输入账号:admin
密码:admin123
提示，Login Succeeded 表示登录成功
2、为镜像打一个 tag 标签
在上传镜像之前需要先打一个 tag，用于版本标记。
格式是这样的：
docker tag :/:
例如：
docker tag tomcat8.5 192.168.0.109:8086/tomcat:8.5
3、上传镜像
docker push 192.168.0.109:8086/tomcat:8.5
4、下载镜像
从私服中下载镜像也很简单，执行以下命令即可
docker pull 192.168.0.109:8086/tomcat:8.5
注意：确保 docke 服务器和私服在同一网段、或者能够进行通信。
5、搜索镜像
搜索镜像也与之前的类似，如下：
docker search 192.168.0.109:8086/tomcat
就可以搜索带有 tomcat 的镜像了：
Maven Docker 插件构建 Docker 镜像
Maven 是一个强大的项目管理与构建工具。可以使用 Maven 构建 Docker 镜像，那么我们的工作能得到进一步的简化。
https://github.com/spotify/docker-maven-plugin插件地址：https://github.com/spotify/docker-maven-plugin
9.1、maven Docker 插件构建 Docker 镜像入门
第一步：修改项目 EurekaServer 的 pom.xml
com.spotify
docker-maven-plugin
0.4.13
offcn/microservice-discovery-eureka:0.0.1
java:8
[“java”, “-jar”, “/${project.build.finalName}.jar”]
/
p
r
o
j
e
c
t
.
b
u
i
l
d
.
d
i
r
e
c
t
o
r
y
<
/
d
i
r
e
c
t
o
r
y
>
<
i
n
c
l
u
d
e
>
{project.build.directory}
project.build.directory
第二步：把项目文件上传到 linux 宿主机目录/usr/local
第三步：下载并上传 jdk、maven 的安装包到 linux 服务器
jdk-8u131-linux-x64.tar.gz
apache-maven-3.6.0-bin.tar.gz
第四步：安装 jdk
（1）、tar xvf jdk-8u131-linux-x64.tar.gz -C /usr/local/
（2）、cd /usr/local
（3）、mv jdk1.8.0_131 jdk
（4）、vi /etc/profile
#在最后添加
export JAVA_HOME=/usr/local/jdk
export CLASSPATH=$JAVA_HOME/lib:.
export PATH=
J
A
V
A
H
O
M
E
/
b
i
n
:
JAVA_HOME/bin:
JAVAHOME/bin:PATH
#重新加载配置文件
（5）、source /etc/profile
（6）测试 jdk 是否安装成
java -version
第五步：安装 maven
（1）、tar xvf apache-maven-3.6.0-bin.tar.gz -C /usr/local/
（2）、cd /usr/local
（3）、mv apache-maven-3.6.0 maven
（4）、vi /etc/profile
#在最后添加
export MAVEN_HOME=/usr/local/maven
export PATH=
M
A
V
E
N
H
O
M
E
/
b
i
n
:
MAVEN_HOME/bin:
MAVENHOME/bin:PATH
#重新加载配置文件
（5）、source /etc/profile
（6）测试 maven 安装
执行命令: mvn -v
第六步：编译构建项目
切换到测试 JAVA 项目目录
cd /usr/local/EurekaServer
执行编译指令：
mvn clean -Dmaven.test.skip=true package docker:build
我们会发现终端输出类似于如下的内容：
第七步：查看镜像
执行命令: docker images
第八步：使用镜像创建运行容器
docker run -di --name=e2 -p 8889:8888 offcn/microservice-discovery-eureka:0.0.1
第九步：访问测试
http://ip:8889
9.2 、 maven Docker 插件构建 Docker 镜像，自定义 DockerFile
之前的示例，我们直接在 pom.xml 中设置了一些构建的参数。很多场景下，我们希望使用 Dockerfile 更精确、有可读性地构建镜像。
下面我们带领大家看一下如何使用 Dockerfile 基于 Maven 插件构建镜像。
第一步：首先我们在项目的 src/main/docker 目录下，新建一个 Dockerfile 文件
基于哪个镜像
FROM java:8
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar ADD EurekaServer01-0.0.1-SNAPSHOT.jar /app.jar
声明需要暴露的端口
EXPOSE 8888
配置容器启动后执行的命令
CMD [“java”,“-jar”,“/app.jar”]
第二步：修改 pom.xml,修改 maven Docker 插件
com.spotify
docker-maven-plugin 0.4.13
offcn/microservice-discovery-eureka:0.0.1
${project.basedir}/docker
/
${project.build.directory}
${project.build.finalName}.jar
第三步：上传到 linux 服务器重新执行编译构建，即可根据 Dockerfile 生成镜像
切换到测试 JAVA 项目目录
cd /usr/local/EurekaServer
执行编译构建指令：
mvn clean -Dmaven.test.skip=true package docker:build
9.3、maven Docker 插件构建并推送镜像到 Docker 私有仓库
前文我们使用 docker push 命令实现了镜像的推送，我们也可使用 Maven 插件推送镜像。我们不妨使用 Maven 插件推送一个 Docker 镜像到 Docker 私有仓库。
第一步：修改 Maven 的全局配置文件 setttings.xml
在其中添加以下内容，配置 Docker 私有仓库的用户信息。
docker-hub
admin
admin123
hk109@139.com
第二步：修改项目 EurekaServer01 的 pom.xml
com.spotify
docker-maven-plugin 0.4.13
192.168.188.1:8086/microservice-discovery-eureka:0.0.2
${project.basedir}/src/main/docker
/
${project.build.directory}
${project.build.finalName}.jar
docker-hub
serverId:必须和 maven 配置文件设置的 server 节点的 id 一致
第三步：执行以下命令，添加 pushImage 的标识，表示推送镜像
mvn clean -Dmaven.test.skip=true -DpushImage package docker:build
执行完毕，查看 Docker 私服已经上传成功镜像
手动发布部署微服务项目到 Docker
10.1、项目工程发布镜像规划
按照项目 EurekaServer01 的配置方式把相关项目都发布成镜像
序号 项目名称 镜像名称
1 EurekaServer01 192.168.188.138:8086/microservice-discovery-eureka:0.0.1
2 ConfigServer001 192.168.188.138:8086/microservice-config-server:0.0.1
3 ZuulGateWay 192.168.188.138:8086/microservice-zuul-gateway:0.0.1
4 UserProvdier01 192.168.188.138:8086/microservice-provdier-service:0.0.1
5 UserWeb04 192.168.188.138:8086/microservice-user-web:0.0.1
注意因为 EurekaServer01 和 EurekaServer02 只是端口和配置不同，没必要单独创建 2 个独立镜像，仅仅需要在 Docker 镜像创建容器的时候传递相关参数即可。
同理 ConfigServer001、ConfigServer002 也公用一个镜像。
UserProvdier01、UserProvdier02 也公用一个镜像。
10.2、项目工程发布镜像配置
10.2.1、项目 EurekaServer01
一、在项目根目录创建 docker 目录，创建 Dockerfile 文件
基于哪个镜像
FROM java:8
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar COPY EurekaServer01-*.jar /app.jar
声明需要暴露的端口
EXPOSE 8888
#配置环境变量，接受外部传递参数
#启动端口
ENV PORT=“”
#注册中心地址
ENV EUREKA=“”
配置容器启动后执行的命令
ENTRYPOINT [“sh”,“-c”,“java $PORT $EUREKA -jar /app.jar”]
二、修改 pom.xml,修改 maven Docker 插件
com.spotify
docker-maven-plugin 0.4.13
192.168.188.138:8086/microservice-discovery-eureka:0.0.1
${project.basedir}/docker
/
${project.build.directory}
${project.build.finalName}.jar
docker-hub
10.2.2、项目 ConfigServer001
一、在项目根目录创建 docker 目录，创建 Dockerfile 文件
基于哪个镜像
FROM java:8
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar COPY ConfigServer001-*.jar /app.jar
声明需要暴露的端口
EXPOSE 8888
#配置环境变量，接受外部传递参数
#启动端口
ENV PORT=“”
#注册中心地址
ENV EUREKA=“”
配置容器启动后执行的命令
ENTRYPOINT [“sh”,“-c”,“java $PORT $EUREKA -jar /app.jar”]
二、修改 pom.xml,修改 maven Docker 插件
com.spotify
docker-maven-plugin 0.4.13
192.168.188.138:8086/microservice-config-server:0.0.1
${project.basedir}/docker
/
p
r
o
j
e
c
t
.
b
u
i
l
d
.
d
i
r
e
c
t
o
r
y
<
/
d
i
r
e
c
t
o
r
y
>
<
i
n
c
l
u
d
e
>
{project.build.directory}
project.build.directory
docker-hub
10.2.3、项目 ZuulGateWay
一、在项目根目录创建 docker 目录，创建 Dockerfile 文件
基于哪个镜像
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar COPY ZuulGateWay-*.jar /app.jar
声明需要暴露的端口
#配置环境变量，接受外部传递参数
#启动端口
ENV PORT=“”
#注册中心地址
ENV EUREKA=“”
配置容器启动后执行的命令
ENTRYPOINT [“sh”,“-c”,“java $PORT $EUREKA -jar /app.jar”]
二、修改 pom.xml,修改 maven Docker 插件
com.spotify
docker-maven-plugin 0.4.13
192.168.188.138:8086/microservice-zuul-gateway:0.0.1
${project.basedir}/docker
/
${project.build.directory}
${project.build.finalName}.jar
docker-hub
10.2.4、项目 UserProvdier01
一、在项目根目录创建 docker 目录，创建 Dockerfile 文件
基于哪个镜像
FROM java:8
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar
COPY UserProvdier01-*.jar /app.jar
声明需要暴露的端口
EXPOSE 8888
#配置环境变量，接受外部传递参数
#监听端口
ENV PORT=“”
#应用名称，用来前端显示用，不是 serviceId
ENV APPLICATION=“”
#注册中心地址
ENV EUREKA=“”
配置容器启动后执行的命令
ENTRYPOINT [“sh”,“-c”,“java $PORT $APPLICATION $EUREKA -jar /app.jar”]
二、修改 pom.xml,修改 maven Docker 插件
com.spotify
docker-maven-plugin 0.4.13
192.168.188.138:8086/microservice-provdier-service:0.0.1
${project.basedir}/docker
/
${project.build.directory}
${project.build.finalName}.jar
docker-hub
三、bootstrap.yml 配置文件内容
spring:
cloud:
config:
discovery:
enabled: true
service-id: CONFIG-SERVER
profile: dev
label: master
四、项目在 git 存储的配置文件
ProviderVersion: UserProvider0.0.1
spring:
datasource:
url: jdbc:mysql://db1:3306/springboot-005?serverTimezone=GMT%2B8
username: root
password: 123
driver-class-name: com.mysql.cj.jdbc.Driver
jpa:
hibernate:
ddl-auto: update
show-sql: true
application:
name: UserProvider
management:
endpoints:
web:
exposure:
include: refresh,health,info
注意：配置文件级别 本地配置文件—》-D 参数注入配置文件----》远程配置中心配置文件，
级别越来越高。
10.2.5、项目 UserWeb06
一、在项目根目录创建 docker 目录，创建 Dockerfile 文件
基于哪个镜像
FROM java:8
拷贝文件到容器，也可以直接写成 ADD xxxxx.jar /app.jar
COPY UserWeb06-*.jar /app.jar
声明需要暴露的端口
EXPOSE 8888
#配置环境变量，接受外部传递参数
#监听端口
ENV PORT=“”
#应用名称
ENV APPLICATION=“”
#注册中心服务器地址
ENV EUREKA=“”
配置容器启动后执行的命令
ENTRYPOINT [“sh”,“-c”,“java $PORT $APPLICATION $EUREKA -jar /app.jar”]
二、修改 pom.xml,修改 maven Docker 插件
com.spotify
docker-maven-plugin 0.4.13
192.168.188.138:8086/microservice-user-web:0.0.1
${project.basedir}/docker
/
${project.build.directory}
${project.build.finalName}.jar
docker-hub
三、bootstrap.yml 配置文件内容
spring:
application:
name: UserWeb06
cloud:
config:
discovery:
enabled: true
service-id: CONFIG-SERVER
profile: dev
label: master
10.3、编译工程创建镜像
一、上传项目 EurekaServer01 到 Linux 服务器目录：/usr/local/springboot/EurekaServer01
二、执行编译、打包、构建 docker 镜像指令
进入当前项目目录
cd /usr/local/springboot/EurekaServer01
编译、打包、发布 Docker 镜像指令：
mvn clean -Dmaven.test.skip=true -DpushImage package docker:build
查看镜像：
docker images
三、其他项目
其他项目 ConfigServer001、ZuulGateWay、UserProvdier01、UserWeb06 也和上面一样，上传，然后进入项目目录执行编译、打包、构建 Docker 镜像指令。
最终 5 个镜像全部创建 ok
10.5、搭建实际运行项目
一：项目架构图
二：创建 docker 网络
根据上面的架构图，本次需要创建一个用户自定义网络：
Docker 指令:
docker network create mynet
查看 docker 网络指令：
docker network ls
构建网络成功后，所有加入到该用户自定义网络的容器即可通过容器名称相互连接。
三：创建运行 docker 容器
容器名称 类型 对应镜像
eureka1 注册中心 192.168.188.138:8086/microservice-discovery-eureka:0.0.1
容器创建指令：
docker run #创建容器指令
-di # d 守护式容器、i 运行容器
--name=eureka1 # 容器名称
--network=mynet #容器加入用户自定义网络 mynet
-e PORT="-Dserver.port=10086" #指定环境参数--Eureka 注册中心服务启动监听端口
#指定环境参数–Eureka 注册中心地址（高可用架构）
-e EUREKA=“-Deureka.client.service-url.defaultZone=http://eureka2:10087/eureka”
-p 10086:10086 #容器端口号映射
192.168.188.138:8086/microservice-discovery-eureka:0.0.1 #镜像名称
eureka2 注册中心 192.168.188.138:8086/microservice-discovery-eureka:0.0.1
容器创建指令：
docker run #创建容器指令
-di # d 守护式容器、i 运行容器
–name=eureka2 # 容器名称
–network=mynet #容器加入用户自定义网络 mynet
-e PORT=“-Dserver.port=10087” #指定环境参数–Eureka 注册中心服务启动监听端口
#指定环境参数–Eureka 注册中心地址（高可用架构，互相指向对方）
-e EUREKA=“-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka”
-p 10087:10087 #容器端口号映射
192.168.188.138:8086/microservice-discovery-eureka:0.0.1 #镜像名称
config1 配置中心 192.168.188.138:8086/microservice-config-server:0.0.1
容器创建指令：
docker run
-di
–name=config1
–network=mynet
#指定环境参数–配置中心服务启动监听端口
-e PORT=“-Dserver.port=7001”
#指定 Eureka 注册中心地址（高可用架构）
-e
EUREKA="-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka,http://eureka2:1008
7/eureka"
-p 7001:7001
192.168.188.138:8086/microservice-config-server:0.0.1
config2 配置中心 192.168.188.138:8086/microservice-config-server:0.0.1
容器创建指令：
docker run
-di
–name=config2
–network=mynet
#指定环境参数–配置中心服务启动监听端口
-e PORT=“-Dserver.port=7002”
#指定 Eureka 注册中心地址（高可用架构）
-e
EUREKA="-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka,http://eureka2:1008
7/eureka"
-p 7002:7002
192.168.188.138:8086/microservice-config-server:0.0.1
db1 mysql 数据库 mysql:5.7
容器创建指令：注意创建容器后需要修改配置文件解决中文乱码问题
docker run
-di
–name=db1
–network=mynet
-p 3306:3306
#mysq 数据库密码
-e MYSQL_ROOT_PASSWORD=123456
#初始化 mysql 数据库
-e MYSQL_DATABASE=jpa001
#镜像名称
mysql:5.7
gateway 服务网关 192.168.188.138:8086/microservice-zuul-gateway:0.0.1
容器创建指令：
docker run
-di
–name=gateway
–network=mynet
-e PORT=“-Dserver.port=80”
-e
EUREKA="-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka,http://eureka2:1008
7/eureka"
-p 80:80
192.168.188.138:8086/microservice-zuul-gateway:0.0.1
provider1 服务提供方 192.168.188.138:8086/microservice-provdier-service:0.0.1
容器创建指令：
docker run -di
–name=provider1 --network=mynet
-e PORT=“-Dserver.port=8001” #监听端口
-e APPLICATION=“-Dspring.application.name=UserProvider01” #应用名称用于 github 查找对应配
置文件
-e
EUREKA="-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka,http://eureka2:1008
7/eureka"
-p 8001:8001
192.168.188.138:8086/microservice-provdier-service:0.0.1
Github 对应配置文件 UserProvdier01-test.properties 内容：
#服务器端口号
#server.port=8001
#应用名称
spring.application.name=UserProvider
#配置显示给消费者的服务器端标识信息
ProviderVersion=UserProvider01
#数据库 jdbc 连接 url 地址,serverTimezone 设置数据库时区东八区
spring.datasource.url=jdbc:mysql://db1:3306/springcloud01?serverTimezone=GMT%2B8
#数据库账号
spring.datasource.username=root
#数据库密码
spring.datasource.password=123456
#指定数据库驱动
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#第一次加载 JPA 时根据 model 类会自动建立起表的结构（前提是先建立好数据库
#以后加载 JPA 时根据 model 类自动更新表结构
spring.jpa.hibernate.ddl-auto=update
#显示 JPA 执行的 sql 语句
spring.jpa.show-sql=true
provider2 服务提供方 192.168.188.138:8086/microservice-provdier-service:0.0.1
容器创建指令：
docker run -di --name=provider2 --network=mynet
-e PORT=“-Dserver.port=8002” #监听端口
#应用名称用于 github 查找对应配置文件
-e APPLICATION=“-Dspring.application.name=UserProvider02”
-e
EUREKA="-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka,http://eureka2:1008
7/eureka"
-p 8002:8002
192.168.188.138:8086/microservice-provdier-service:0.0.1
Github 对应配置文件 UserProvdier02-test.properties 内容：
#服务器端口号
#server.port=8002
#应用名称
spring.application.name=UserProvider
#配置显示给消费者的服务器端标识信息
ProviderVersion=UserProvider02
#数据库 jdbc 连接 url 地址,serverTimezone 设置数据库时区东八区
spring.datasource.url=jdbc:mysql://db1:3306/springcloud01?serverTimezone=GMT%2B8
#数据库账号
spring.datasource.username=root
#数据库密码
spring.datasource.password=123456
#指定数据库驱动
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#第一次加载 JPA 时根据 model 类会自动建立起表的结构（前提是先建立好数据库
#以后加载 JPA 时根据 model 类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行
spring.jpa.hibernate.ddl-auto=update
#显示 JPA 执行的 sql 语句
spring.jpa.show-sql=true
userweb 服务消费者 192.168.188.138:8086/microservice-user-web:0.0.1
docker run -di --name=userweb --network=mynet
-e PORT=“-Dserver.port=9001”
-e APPLICATION=“-Dspring.application.name=UserWeb06” #应用名称用于 github 查找对应配置
文件
-e
EUREKA="-Deureka.client.service-url.defaultZone=http://eureka1:10086/eureka,http://eureka2:1008
7/eureka"
-p 9001:9001
192.168.188.138:8086/microservice-user-web:0.0.1
四：查看 docker 容器输出日志
通过指令：docker logs -f -t --tail 10 provider1
就可以查看对应的容器日志输出
五：测试运行
访问:http://192.168.188.138:9001
文章来源
发表评论