临窗旋墨-Docker快速入门部署SpringBoot，idea集成docker实现镜像等

Docker快速入门部署SpringBoot，idea集成docker实现镜像等

共5 个小时13分钟

Docker中文社区、Docker中文文档

一些问题★:

docker run不时候要修改容器的默认端口号, 不然网络不通;
IDEA 配置dockerca的时候disconnected before any data was received:
配置白名单的时候需要加入服务器自身的ip;echo subjectAltName =IP:139.129.118.96,IP:0.0.0.0>> extfile.cnf
★★上传到远程服务器的时候一定要上加TLSv1.2；mvn clean package docker:build -Djdk.tls.client.protocols=TLSv1.2
不然会报证书扩展名错误 [extension (5) should not be presented in certificate_request]

1 docker前言和入门

什么是docker
为什么学习docker
怎么用docker

互联网时代:高可用高并发高性能

解决方案:水平扩展(不断加服务器) , 满足高并发.

分布式服务架构 + 微服务

解决方案: dubbo/springcloud + springboot
网格化:Lstio

maven:

统一jar包管理
统一结构化目录

Docker

运维部署
统一的运行环境

2 docker简介-入门

2.1 什么是docker

一个开源的应用容器引擎, 基于go语言, 并遵从Apache2.0协议
可以让开发者打包应用以及依赖包到一个轻量级/可移植容器中, 然后发布到任何流行的linux及其上, 也可以实现虚拟化
容器完全使用沙箱机制,相互之间不糊有任何接口, 更重要的是容器性能开销极低.

2.2 为什么用docker

简化程序:
避免选择恐惧症:
节省开支
持续交付和部署
更轻松的迁移

2.3 docker的应用场景

web应用的自动化打包和发布
自动化测试和持续集成 , 发布
在服务型环境中部署和调整数据库或其他后台应用
从头不变异或者扩展现有OpenShift或Cloud Foundry 来大剑自己的PasS环境

IaaS:Infrastrcure as a service  基础设施即服务
PaaS:Platform as a service  平台即服务
SaaS:Software as a service  软件即服务

3 docker和虚拟机的区别

实现原来技术不同
1. 硬件虚拟化技术
2. 系统级别的虚拟化
使用资源不同
1. 独占分配的资源
2. 共享操作系统内核, 不同的容器之间可共享系统资源
场景不同
1. 资源完全隔离
2. 进程实例

特性	容器	虚拟机
启动	秒级	分钟级
硬盘使用	一般为MB	一般为GB
性能	接近原生	弱于
形同支持量	单机支持上千个容器	一般几十个

Docker 总结

领先的容器平台
Google 公司 go语言
自动执行重复性任务
方便的创建和使用容器. 容器即可版本管理复制分享修改,就和管理代码一样
镜像提供了除内核外完整的运行时环境,确保了环境的一致性
启动更快
隔离性
迁移方便
持续交付和部署

04 Docker基本概念 - 入门

镜像容器仓库

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

docker镜像Images:用于创建docker容器的模板
docker容器container:容器是独立运行的一个或一组应用
docker主机host:一个物理或虚拟机用于执行docker守护进程和容器
docker客户端client:docker客户端通过命令行或其他工具使用docker API与docker守护进程进行通信
docker仓库repostory: 用来保存镜像,类似代码仓库.docker hub提供了庞大的景象集合供使用.
docker machine:一个简化的docker安装的命令行工具,通过一个简单的命令行即可在相应的平台上安装docker,如Vbox,digital ocean,microsoft azure.

docker镜像仓库:

分层存储

05 docker仓库: - 入门

保存镜像

公有仓库:

Docker Hub
阿里云的
daocloud
网易云的

私有仓库

官方提供了docker registry 镜像

06-Docker安装 - 入门

官方提供的安装教程:

移除求版本
安装一些必要的系统工具
添加软件源信息
更新yum缓存 sudo yum update
- yum list installed |grep docker
- yum -y remove docker-ce.x86_64
安装docker-ce sudo yum install docker-ce
启动 sudo systemctl start docker
配置文件修改后生效:sudo systemctl daemon-reload
重启 sudo systemctl restart docker
停止 sudo systemctl stop docker
- 先关闭 systemctl stop docker.socket
查看: docker version
查看一些信息如镜像是否生效 : docker info
测试: sudo docker run hello-world
卸载:
- sudo yum remove docker-ce
- sudo rm -rf /var/lib/docker
docker ps 查看运行的容器

[07-docker镜像加速器:官方和阿里云配置- 入门](https://www.bilibili.com/video/BV1xJ411W7Rg?p=7&spm_id_from=pageDriver

)

docker官方提供的中国registry mirror
- Configure the Docker daemon
  Either pass the --registry-mirror option when starting dockerd manually, or edit /etc/docker/daemon.json and add the registry-mirrors key and value, to make the change persistent.
```
{
  "registry-mirrors": ["https://<my-docker-mirror-host>"]
}
```
阿里云加速器
- 个人账号- 控制台 - 云原生 - 镜像加速器
daocloud加速器

08-docker 获取镜像 - 入门

搜索镜像
1. 官网直接搜索
2. docker search tomcat
pull镜像
1. docker pull [选项] [Docker Registry 地址[:端口]/] 仓库名[:标签]
2. docker pull tomcat:版本号 (不写版本号则laster版本)

09 docker 列出镜像

docker image ls docker images
docker images -q :查看id

虚悬镜像 dangling image<none>

没有仓库名, 也没有标签,均为<none>
docker pull 或docker build 等会产生旧镜像为<none>
虚悬镜像一般没有存在的价值,可以删除 docker image prune

10 删除镜像

删除前须确认没有被任何容器使用

docker image rm [选项] <镜像1> [<镜像2>....]
删除本地镜像
docker image rmi 镜像id

11 docker容器

1 查看容器状态

docker ps 
docker ps -a    //全部容器 包括运行和退出的
docker container ls
docker container ls -a

2 docker 启动容器

docker run --rm -d --name tomcat001 -p 10082:8080 tomcat
-i  保持docker和同容器内的交互,启动容器时候,运行的命令经书后,容器依然存活,没有退出 (默认是会退出的)
   以交互模式运行容器，通常与 -t 同时使用；
-t 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
-d 后台运行容器
--rm 容器启动后 执行完成停止命令 或程序后就销毁
--name 给容器起个名字
-p 宿主机:内部端口

5 停止容器

docker start <id> // 停止正在运行的容器 或者ctrl +c
docker container stop <id|name>

6启动那个已经终止的容器

docker start <id>

7 重启已经关闭的容器

docker restart <id>

8关闭和删除容器

docker rm <id>

13Docker 进入容器 docker exec

docker exec -it 容器id(name ) bash
-i -t 参数
退出: exit

14 docker容器复制在宿主机和容器间交换文件 cp

docker cp [options] container:path localpath 容器复制到宿主机
docker cp [options] localpath container:path 宿主机复制到容器中

# 复制到容器
docker cp /data/files2.jpeg  tomcat001:/usr/local/tomcat/webapps/ROOT/1.jpeg
# 把容器中的复制出来
docker cp tomcat001:/usr/local/tomcat/webapps/ROOT/index.jsp ./
# 修改后再复制回去
docker cp index.jsp tomcat001:/usr/local/tomcat/webapps/ROOT/

15 docker 查看日志 docker logs 容器name/id

docker logs 容器id/name
docker logs -f -t --since="2021-06-04" --tail=10 tomcat004
—since :指定输出日志的开始日期
-f 查看实时日志
-t 查看日志的产生日期
-tail=10 查看最后10条日志
tomcat004 容器ming

16 基础案例总结

将项目test项目页面,用docker的方式部署到tomcat服务器上
要求集群的方式部署三台

1. 上传项目
2. 关闭已经启动的tomcat
docker stop id1 id2
docker ps -a
docker rm id
docker images 
docker run --rm -d --name test1 -p8080:8080 tomcat
docker run --rm -d --name test2 -p8081:8081 tomcat
docker run --rm -d --name test3 -p8082:8082 tomcat
docker exec -it test1 base
docker cp test test1:/usr/local/tomcat/test1/webapps/

17 docker数据卷

docker stop id 会销毁 —rm 启动的容器的文件/

数据卷: 一个可供一个或多个容器使用的特殊目录

数据卷特性:

数据卷可以在容器之间共享和重用
对数据卷的修改会立马生效
对数据卷的更新,不会影响镜像
数据卷默认会一直存在,即使容器被删除

18 数据卷实例

创建一个数据卷 docker volume create vol1

docker volume create vol1
查看所有的数据卷 docker volume ls
查看volume信息 docker inspect vol1
启动容器并挂在数据卷 -v 宿主机目录容器id:docker目录

docker run --rm -d --name test1 -p8080:8080 -v /data/docker/test110 test1:/usr/local/webapps/test001   tomcat

19 nginx 安装

docker pull nginx
docker run --name nginx8001 -p 8001:80 -d nginx

nginx的一些默认路径

配置路径 /etc/nginx
pid目录: /var/run/[nginx.pid]
错误日志:/var/log/nginx/[error.log]
访问日志: /var/log/nginx/access.log
默认站点目录:/ usr/share/nginx/html

docker run --rm -d -p 8001:80 --name nginx8001 \
  -v /data/docker-data/vo1001/nginx8001/html:/usr/share/nginx/html \
  -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
  -v /data/docker-data/vo1001/nginx8001/logs:/var/log/nginx \
  nginx

docker run --rm -d -p 8081:80 --name nginx-test-web \
  -v /home/nginx/www:/usr/share/nginx/html \
  -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
  -v /home/nginx/logs:/var/log/nginx \
  nginx

命令说明：
—rm：容器终止运行后，自动删除容器文件。
-p 8081:80：将容器的 80 端口映射到主机的 8082 端口.
—name nginx-test-web：将容器命名为 nginx-test-web
-v /home/nginx/www:/usr/share/nginx/html：将我们自己创建的 www 目录挂载到容器的 /usr/share/nginx/html。
-v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf：将我们自己创建的 nginx.conf 挂载到容器的 /etc/nginx/nginx.conf。
-v /home/nginx/logs:/var/log/nginx：将我们自己创建的 logs 挂载到容器的 /var/log/nginx。

20 mysql安装

官网查看: https://hub.docker.com/
下载镜像: docker pull mysql:5.7

创建并启动mysql

docker run -d --name mysql5.7-3308 -p 3308:3306 -e MYSQL_ROOT_PASSWORD='root' mysql:5.7

外部登录: mysql -h 127.0.0.1 -P 3308 -uroot -p
内部登录
- docker exec -it mysql5.7-3308 bash
- mysql -uroot -p
授权远程访问:
grant all privileges on *.* to 'root'@'%' identified by 'root' with grant option;
flush privileges;

21 dockerfile 定制镜像

两种方式对镜像进行修改:

从已经创建的容器中更新镜像,并且提交这个景象
使用dockerfile指令来创建一个新的镜像

对于开发人员, 可以为开发团队一共一个完全一致的开发环境
对于测试人员, 可以直接拿开发时所构建的镜像测试
对于运维人员,在部署时吗可以实现快速部署, 移植.

dockerfile 定制镜像

镜像的定制实际上就是定制每一层锁添加的配置, 文件.

把每一层修改, 安装, 构建, 操作的命令都写入一个脚本, 用这个脚本来构建,定制镜像, 那么之前提及的无法重复,的问题, 体积的问题就都会解决. 这个脚本就是Dockerfile.

Dockerfile是一个文本文件, 其内包含一条条指令(Instruction), 每一条指令构建一层, 因此每一条指令的内容, 就是描述该层应当如何构建.

22 dockerfile构建镜像1 以及常用命令

dockerfile 常用命令

from 指定基础镜像

基础镜像不存在会在docker hub上拉取(一般会是文件的第一个指令)
使用格式:
FROM <镜像>:[tag]
FROM <镜像>@digest[校验码]
当前主机没有此镜像时, 会自动去官网hub下载

maintainer: 提供dockerfile制作者提供的版本信息

[逐渐废弃]
LABEL — 替代MAINTAINER
具体使用:
LABEL maintainer=”作者信息”

使用格式:

MAINTAINER "lcxm <xuduochoua@163.com>"

LABEL maintainer="NGINX Docker Maintainers <docker-maint@nginx.com>"
LABEL "com.example.vendor"="acme incorpor ated"
LABEL "com.example.label-with-value"="foo"
LABEL version="1.0"
LABEL description=" this text illustrates \
thatlabe-values惨审判multiplelines"

env: 为docker容器设置环境变量

设置的环境变量查看: docker inspect
修改环境变量: docker run —env <key>=<value>
具体用法
ENV JAVA_HOME /usr/local/jdk
ENV JRE_HHOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib;$JRE_HOME/lib/
ENV PATH $PATH;$JAVA_HOME/bin/

user: 切换运行属主身份的. docker默认是使用root

workdir:切换工作目录

docker默认的工作目录是 /, 只有run能执行cd命令切换目录, 而且还是作用在当下的run, 也就是说每个run都是独立运行的.
如果想让其他指令在指定的目录下执行, 就用workdir. rowrkdir动作的目录改变是持久的.

workdir /usr/local/tomcat

volume: 创建哪一个可以从本地主机或其他容器挂载的挂载点,一般用来存放需要保持的数据等

卷: 只能定义docker管理的卷
volume/data/mysql 运行的时候回随机在宿主机的目录下生成一个卷目录

copy: 把宿主机中的文件复制到镜像中去

文件要在dockerfile工作目录
src: 源文件,
支持通配符
通常项目路径
dest: 目标路径
通常绝对路径

add: 类似copy命令

add 将文件从路径 <src> 复制添加到容器内部路径<dest>
<src> 必须是相对于源文件夹的一个文件或目录, 也可以是一个远程url
<dest>是目标容器中的绝对路径. 所有的新文件和文件夹都会创建UID和GID.
事实上如果<src>是一个远程文件ur, 那么目标文件的权限将会是600;

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

使用格式:
EXPOSE 80/tcp 23/udp
不加协议默认为tcp
不加协议默认为tcp
使用-P选项可以暴露这里指定的端口
但是宿主的关联至这个端口的端口是随机的

run:用来执行命令行命令的

由于命令行的强大能力, run指令在定制镜像时是最常用的指令之一.
其格式有两种:
shell格式: run <命令> 就像直接在命令行输入命令一样
exec格式: run [“可执行文件”,”参数1”,”参数2”] , 这更像是函数调用中的格式
使用格式
run <command>
run [“<executable>“, “param1”, “param2”]

dockerfile案例一: 创建一个基于tomcat的镜像, 里面有一个index.html, 且内容为xxxx

# 1 创建dockerfile  /usr/local/docker/demo1
vim Dockerfile
# 2 写入内容
FROM tomcat //指定tomcat最新版本镜像
LABEL MAINTAINER "lcxm <xuduochoua@163.com>"
RUN echo 'hello world' > /usr/local/tomcat/webapps/ROOT/index.html
# 3 构建镜像 -t   镜像名称 demo1:1.0
docker build -t demo1 . 
# 4 运行镜像
docker run -d --rm --name demo1-8081 -p 8081:8080 demo1

22 dockefile构建镜像2-workdir命令切换工作目录

删除ROOT下的其他所有文件

Dockerfile

from tomcat
LABEL MAINTAINER "lcxm <xuudochoua@163.com>"
WORKDIR /usr/local/tomcat/webapps/ROOT/
RUN rm -rf *
WORKDIR /usr/local/tomcat
RUN echo 'hello world 002' > /usr/local/tomcat/webapps/ROOT/index.html

docker build -t demo002 .
docker run -d —rm —name demo002-8082 -p 8082:8080 demo002

23 dockefile构建镜像3-COPY命令

基于上一个镜像, 外部复制一个文件,复制到容器中并且能够访问

加一句命令

COPY 1.png /usr/local/tomcat/webapps/ROOT

FROM tomcat
LABEL MAINTAINER "lcxm <xuudochoua@163.com>"
WORKDIR /usr/local/tomcat/webapps/ROOT/
RUN rm -rf *
WORKDIR /usr/local/tomcat/webapps
COPY 1.png /usr/local/tomcat/webapps/ROOT 
RUN echo 'hello world 002' > /usr/local/tomcat/webapps/ROOT/index.html

24 dockefile构建镜像4 war包生成镜像

利用Dockerfile 将一个war包生成生成镜像的Dockerfile

FROM tomcat
LABEL MAINTAINER "lcxm <xuudochoua@163.com>"
WORKDIR /usr/local/tomcat/webapps/ROOT/
RUN rm -rf *
WORKDIR /usr/local/tomcat/webapps
#  复制到root下
COPY test.zip /usr/local/tomcat/webapps/ROOT 
# 解压  然后删除原zip
RUN unzip test.zip
RUN rm -rf text.zip
WORKDIR /usr/local/tomcat

25 docker部署springboot项目准备

准备一个springboot项目, 并打包
服务器上准备好相应的数据库

26 docker部署springboot项目

准备好打包好的jar: test-1.0.0.jar

在同目录下创建Dockerfile文件

# 基础镜像 即运行环境
FROM java:8 
LABEL MAINTAINER "lcxm <xuudochoua@163.com>"
# 创建tmp目录并持久化到docker数据文件夹,因springboot使用内嵌tomcat容器默认使用/tmp作为工作目录
VOLUME /temp
# 复制文件并重命名
ADD test-1.0.0.jar test.jar
#并非真正的发布端口,这个只是容器部署人员之间的交流,即简历image的人员告诉容器部署人员容器应该映射那个端口给外界
EXPOSE 8080
#容器启动时运行的命令,相当于命令行输入java -jar  xxx.jar, 为了缩短tomcta启动时间,添加java.security.egd的系统属性指向/dev/./urandom作为ENTRYPOINT
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar", "/test.jar"]

27-28-29-30 IDEA集成docker实现镜像打包一键部署

希望能完成以下工作:
在IDEA中开发代码
代码达成jar
部署到linux服务器上
如果用docker(编写dockerfile文件)
构建镜像
运行容器

1 docker 开启远程访问

#修改docker服务文件
vim /lib/systemd/system/docker.service 
#修改ExecStart这行
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
# 修改为
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
# 没有netstat命令 可先安装 yum install net-tools
# 查看是否生效
curl http://127.0.0.1:2375/info

2 IDEA 安装docker插件

file - setting - plugins - install ….
docker integration

3 IDEA 配置docker

配置docker服务器 tcp://xuqiudong.cn:2375
然后在控制台进行相应操作

4 docker-maven-plugin

传统过程中: 打包, 部署, 上传到linux, 编写dockerfile, 构建镜像, 创建容器运行
在持续集成过程中,
- 项目一般使用mavbe编译打包,
- 然后生成镜像, 通过镜像上线,
- 能够大大提高上线效率. 同时能够快速动态扩容, 快速回滚

docker-maven-plugin插件: 在maven工程中,通过简单的配置,自动生成镜像,并推送到仓库中

pom.xml

<properties>
    <docker.image.prefix>lcxm</docker.image.prefix>
</properties>
<build>
    <plugins>
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            <configuration>
                <!-- 镜像名称 -->
                <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                <!-- 指定标签 -->
                <imageTags>
                    <imageTag>lastest</imageTag>
                </imageTags>
                <!--基础镜像 jdk1.8 -->
                <baseImage>java</baseImage>
                <maintainer>lcxm xuduochoua@163.com</maintainer>
                <!-- 切换到ROOT目录 -->
                <workdir>/ROOT</workdir>
                <cmd>["java", "-version"]</cmd>
                <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
                <!-- 指定dockerfile路径 -->
               <!--  
                <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
                -->     
                <!--指定远程docker api地址 -->
                <dockerHost>http://xuqiudong.cn:2375</dockerHost>
                <!-- 这里是复制 jar 包到 docker 容器指定目录配置 类似add中的target -->
                <resources>
                    <resource>
                        <targetPath>/ROOT</targetPath>
                        <!-- 用于指定需要复制的根目录 ${project.build.directory} 表示target目录-->
                        <directory>${project.build.directory}</directory>
                       <!--用于指定需要复制的文件${project.build.finalName}.jar指的是打包后的jar包文件 类似add中的 目标 --> <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>
    </plugins>
</build>

如上,用docker-maven插件会自动生成如下文件Dockerfile

FROM java
LABEL MAINTAINER "lcxm <xuudochoua@163.com>"
WORKDIR /ROOT
ADD /ROOT/xxx.jar /ROOT/ 
ENTRYPOINT ["java","-jar", "xxx.jar"]
CMD ["java", "-version"]

5 执行打包命令

打包.并构建镜像到docker上去

mvn clean package docker:build

31 IDEA 继承docker扩展

在打包的时候就实现并构建镜像到docker上去

下列标签放在plugin里面

<executions>
    <!-- 当执行mvn package 时 执行mvn clean package docker:build -->
    <execution>
        <id>build-image</id>
        <phase>package</phase>
        <goals>
            <goal>build</goal>
        </goals>
    </execution>
    <!-- 当执行mvn package时 回对镜像进行标签设定 -->
    <execution>
        <id>tag-image</id>
        <phase>package</phase>
        <goals>
            <goal>tag</goal>
        </goals>
    </execution>
</executions>

32 IDEA整合docker加密认证

官方demo示例:https://docs.docker.com/engine/security/protect-access/

1 创建目录存放ca的公钥和私钥,并进入

2 生成ca私钥和公钥

3 补全ca证书信息依次输入密码国家省市组织邮箱

Now that you have a CA, you can create a server key and certificate signing request (CSR). Make sure that “Common Name” matches the hostname you use to connect to Docker:

4 生成server-key.pem

5 ca 来签公钥

6 配置白名单

echo subjectAltName = DNS:$HOST,IP:10.10.10.20,IP:127.0.0.1 >> extfile.cnf

7 将docker守护程序秘钥的扩展使用属性设置为服务器身份验证

8 生成签名证书

9 生成客户端的key.pem

10 要使秘钥适合客户端身份验证

11 现在生成签名证书

12 删除不要需要的文件, 两个证书签名请求(也可以不删)

After generating cert.pem and server-cert.pem you can safely remove the two certificate signing requests and extensions config files:

13可修改权限

To protect your keys from accidental damage, remove their write permissions. To make them only readable by you, change file modes as follows:
Certificates can be world-readable, but you might want to remove write access to prevent accidental damage:

14 归集服务器证书

复制证书到/etc/docker/下

15修改docker配置

Now you can make the Docker daemon only accept connections from clients providing a certificate trusted by your CA:
修改docker服务文件
vim /lib/systemd/system/docker.service
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
修改为:
ExecStart=/usr/bin/dockerd —tlsverify —tlscacert=/data/docker-data/dockerca/ca.pem —tlscert=/data/docker-data/dockerca/server-cert.pem —tlskey=/data/docker-data/dockerca/server-key.pem -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock

16 重新加载damnon 并重启docker

# 1 创建目录存放ca的公钥和私钥,并进入 /data/docker-data/dockerca/
# 2生成ca私钥和公钥  phrase pass: 654321
openssl genrsa -aes256 -out ca-key.pem 4096
# 3 补全ca证书信息 654321 cn  anhui  hefei pers pers pers pers xuduochoua@163.com
openssl req -new -x509 -days 365 -key ca-key.pem -sha256 -out ca.pem
#4 生成server-key.pem
openssl genrsa -out server-key.pem 4096
#5 ca 来签公钥
openssl req -subj "/CN=139.129.118.96" -sha256 -new -key server-key.pem -out server.csr
# 6 配置白名单 需要加入服务器本身的ip地址 不然报错disconnected before any data was received
echo subjectAltName =IP:139.129.118.96,IP:0.0.0.0>> extfile.cnf
#7 将docker守护程序秘钥的扩展使用属性设置为服务器身份验证
echo extendedKeyUsage = serverAuth >> extfile.cnf
# 8 生成签名证书 654321
openssl x509 -req -days 365 -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem \
  -CAcreateserial -out server-cert.pem -extfile extfile.cnf
#9 生成客户端的key.pem
openssl genrsa -out key.pem 4096
openssl req -subj '/CN=client' -new -key key.pem -out client.csr
#10要使秘钥适合客户端身份验证
echo extendedKeyUsage = clientAuth > extfile.cnf
echo extendedKeyUsage = clientAuth > extfile-client.cnf
#11 现在 生成签名证书 654321
openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem \
  -CAcreateserial -out cert.pem -extfile extfile-client.cnf
#12  删除不要需要的文件, 两个证书签名请求
rm -v client.csr server.csr extfile.cnf extfile-client.cnf
#13  可修改权限
chmod -v 0400 ca-key.pem key.pem server-key.pem
chmod -v 0444 ca.pem server-cert.pem cert.pem
#14 归集服务器证书
cp server-*pem /etc/docker/
cp ca.pem /etc/docker/
# 15 修改docker配置
vim /lib/systemd/system/docker.service 
ExecStart=/usr/bin/dockerd --tlsverify --tlscacert=/data/docker-data/dockerca/ca.pem  --tlscert=/data/docker-data/dockerca/server-cert.pem --tlskey=/data/docker-data/dockerca/server-key.pem -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
# 16 重新加载damnon 并重启docker
systemctl daemon-reload
systemctl restart docker
# 17 开发2375端口
/sbin/iptables -I INPUT -p tcp --dport 2375 -j ACCEPT
# 18 重启docker
systemctl restart docker

IDEA操作Docker

1 保存相关客户端的pem文件到本地

ca.pem ca-key.pem cert.pem key.pem

2修改idea中的docker配置

tcp://xuqiudong.cn:2375
改为:
https://139.129.118.96:2375
并且配置秘钥的文件夹
修改pom.xml中的dockerhost 对应的ip为https


            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.2.2</version>
                <executions>
                    <execution>
                        <id>build-image</id>
                        <!--将插件绑定在package这个phase上。也就是说，用户只需执行mvn package ，就会自动执行mvn docker:build -->
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!-- 镜像名称 -->
                    <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                    <!-- 指定标签 -->
                    <imageTags>
                        <imageTag>lastest</imageTag>
                    </imageTags>
                    <!--基础镜像 jdk1.8 -->
                    <baseImage>java</baseImage>
                    <maintainer>lcxm xuduochoua@163.com</maintainer>
                    <!-- 切换到ROOT目录 -->
                    <workdir>/ROOT</workdir>
                    <cmd>["java", "-version"]</cmd>
                    <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>
                    <!-- 指定dockerfile路径 -->
                    <!--
                     -->
                    <dockerDirectory>${project.basedir}</dockerDirectory>
                    <!--指定远程docker api地址 -->
                    <dockerHost>https://139.129.118.96:2375</dockerHost>
                    <dockerCertPath>D:\tools\data\docker\ca\</dockerCertPath>
                    <!--<dockerHost>http://localhost:2375/</dockerHost>-->
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 类似add中的target -->
                    <resources>
                        <resource>
                            <targetPath>/ROOT</targetPath>
                            <!-- 用于指定需要复制的根目录 ${project.build.directory} 表示target目录-->
                            <directory>${project.build.directory}</directory>
                            <!--用于指定需要复制的文件${project.build.finalName}.jar指的是打包后的jar包文件 类似add中的 目标 --> <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>


<plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.4.10</version>
                 <executions>
                    <execution>
                        <id>default</id>
                        <goals>
                            <goal>build</goal>
                            <goal>push</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <repository>139.129.118.96/${project.artifactId}</repository>
                    <tag>${project.version}</tag>
                    <buildArgs>
                        <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
                        <JAR_EXPOSE>8082</JAR_EXPOSE>
                    </buildArgs>
                </configuration>
            </plugin>

centos防火墙端口

查看已经开放的端口

firewall-cmd --list-ports

开放端口

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

重启防火墙

firewall-cmd --reload
# 停止
firewall systemctl stop firewalld.service
# 禁止开机启动
firewall systemctl disabled1 firewalld.service

Docker快速入门 部署SpringBoot，idea集成docker实现镜像等