本文将带您了解关于【云原生】springboot项目打包部署docker镜像的新内容，同时我们还将为您解释springboot项目打包成docker镜像的相关知识，另外，我们还将为您提供关于docke
本文将带您了解关于【云原生】springboot 项目打包部署 docker 镜像的新内容，同时我们还将为您解释springboot项目打包成docker镜像的相关知识，另外，我们还将为您提供关于docker 打包 springboot 项目快速入门、docker 打包springboot镜像并启动、docker 部署 springboot 项目、Docker 部署Springboot 项目的实用信息。
本文目录一览：- 【云原生】springboot 项目打包部署 docker 镜像（springboot项目打包成docker镜像）
- docker 打包 springboot 项目快速入门
- docker 打包springboot镜像并启动
- docker 部署 springboot 项目
- Docker 部署Springboot 项目
【云原生】springboot 项目打包部署 docker 镜像（springboot项目打包成docker镜像）
目录
序
一 打包 maven 项目
二 上传 jar 和 dockerfile 文件到服务器
三 打包发布镜像
四 访问项目
序
前面我们使用了框架 jenkins 进行部署发布：【云原生】jenkins 部署 docker 镜像到远程服务器
还使用腾讯 coding 进行自动化部署发布：【云原生】coding 持续集成部署 docker 镜像到远程服务器
现在再来试试不依赖第三方框架，手动发布 docker 镜像
一 打包 maven 项目
打开 idea，找到右侧 maven 项，依次点击命令
打包完成后，项目中会生成一个 target 文件夹，打开找到生成的 jar 包
二 上传 jar 和 dockerfile 文件到服务器
进入远程服务器，创建一个文件夹 java_docker 用于存放上传的文件
如果进入服务器是 / 结尾，则需要切换到 root 用户模式～
进入 root 模式
cd root
创建文件夹
mkdir java_docker
ls 
进入文件夹
cd java_docker使用 工具上传 jar 和 dockerfile 到 java_docker 文件夹中
查看是否上传成功
三 打包发布镜像
在 java_docker 中执行命令进行镜像构建（前提：服务器已安装 docker 环境）
docker build -t=boot_base .
查看镜像
docker images
构建容器
注：端口映射根据自己的项目设置进行修改
docker run -d -p 8088:8088 --name boot boot_base:latest
查看容器
docker ps
查看日志
docker logs 容器id四 访问项目
服务器公网 ip + 外表映射端口
生活就算再糟糕，也要坚强的走下去
sha 不 si 我的，只会让我更强大...
本文同步分享在 博客 “君燕尾”（CSDN）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与 “OSC 源创计划”，欢迎正在阅读的你也加入，一起分享。
docker 打包 springboot 项目快速入门
> 收藏不点赞，表示很遗憾
docker 打包 springboot 项目快速入门
文末源码 @[toc]
1.构建Sringboot工程
新建项目
创建接口
package com.wangshiyu.javapub.demo.springbootdocker.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* @Author: JavaPub
* @License: https://github.com/Rodert/ https://gitee.com/rodert/
* @Contact: https://javapub.blog.csdn.net/
* @Date: 2022/2/26 12:24
* @Version: 1.0
* @Description:
*/
@RestController
public class HelloController {
@RequestMapping("/hello")
String hello(@RequestParam(required = false, defaultValue = "") String name) {
return "hello, welcome wangshiyu JavaPub " + name;
}
}
maven 打包 springboot 项目
mvn clean package -DskipTests
2.编写Dockerfile
Dockerfile讲解
#基础镜像通过java8来的
FROM java:8
#将当前文件中所有*.jar 拷贝到项目的app.jar中（这个app.jar是自己生成的）
COPY *.jar /app.jar
#映射地址
CMD ["--server.prot=8080"]
#暴露端口
EXPOSE 8080
#执行命令java -jar
ENTRYPOINT ["java","-jar","/app.jar"]
3.docker环境搭建和构建docker镜像运行
文件准备
拷贝 *.jar 包和 Dockerfile 到linux服务器文件夹下
linux下docker安装
本次在root权限下安装
- 更新yum到最新版本
> yum update
- 卸载旧版本（如果没安装，忽略）
> yum remove docker
docker-client
docker-client-latest
docker-common
docker-latest
docker-latest-logrotate
docker-logrotate
docker-selinux
docker-engine-selinux
docker-engine
> yum list installed | grep docker
> yum remove docker-ce
> rm -rf /var/lib/docker
curl -sSL https://get.daocloud.io/docker | sh
- 安装一些工具
> yum install -y yum-utils device-mapper-persistent-data lvm2
> yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
- 安装docker稳定版
> yum install docker-ce
- 成功
> docker version
- 切换国内加速镜像
> vim /etc/docker/daemon.json
{
"registry-mirrors": [
"https://dockerhub.azk8s.cn",
"https://docker.mirrors.ustc.edu.cn",
"https://registry.docker-cn.com"
]
}
> systemctl daemon-reload
> systemctl restart docker
异常
如果中途出现什么旧版本没卸载干净，把卸载命令全部重新执行一遍。
打包构建docker镜像
- 将 jar包 打包成 docker 镜像（基于Dockerfile打包一个名为 idea_docker_image_test 的镜像，版本为1.0）
> docker build -t idea_docker_image_test:1.0 -f Dockerfile .
- 查看镜像是否打包成功
> docker images
运行
> docker run -d --name idea_docker_image_test -p 8080:8080 idea_docker_image_test:1.0
查看日志
- 查看控制台日志
> docker logs -f --tail=100 容器id
- 查看slf4j日志
> 通过 docker exec -it 容器id /bin/bash 进入容器 再通过项目里指定的路径及可找到日志文件
仓库地址
公众号: JavaPub 回复： 仓库地址
docker 打包springboot镜像并启动
1.使用maven将项目打成一个包含所有的jar包
2.pom.xml中包含即可通过mvn clean package 就可以打成可执行jar包
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
<mainClass>com.org.Application</mainClass>
<layout>ZIP</layout>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
<!-- 分离出代码包
<configuration>
<classifier>exec</classifier>
</configuration>
-->
</execution>
</executions>
</plugin>
</plugins>
</build>
3.将打成的jar包和一个DockerFile文件放入安装了docker的环境
DockerFile内容为：
#指定依赖的镜像
FROM java:8-alpine
#springboot tomcat挂载的目录
VOLUME /tmp
#容器使用端口
EXPOSE 9002
#添加jar包入容器
ADD start-apply-service-1.0-SNAPSHOT.jar app.jar
#改名
RUN sh -c ''touch /app.jar''
#容器启动java
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
------------------------------简化版DockerFile配置-----------------------------------------
FROM java:8-alpine
EXPOSE 9002
ADD start-apply-service-1.0-SNAPSHOT.jar /app.jar
ENTRYPOINT ["java","-jar","/app.jar"]
-------------------------------end---------------------------------------------
4.执行 docker build -t springboot:2.0 . #最后的"."指的是DockerFile文件的当前路径，springboot 为镜像名，2.0为tag，build 就是构建的意思。
5.执行上述命名 即可通过docker images 看到 我们生成的镜像
6. docker run -d -p 9002:9002 springboot:2.0 #启动自定义容器
7.docker logs --tail=200 2915c40fdcdf #查看容器启动日志
8.本地尝试访问
docker 部署 springboot 项目
# 安装docker
[菜鸟教程](http://www.runoob.com/docker/macos-docker-install.html)
# springboot项目
maven依赖
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>boottest</groupId>
<artifactId>com.ityang.boot</artifactId>
<version>1.0-SNAPSHOT</version>
<name>boottest</name>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<java.version>1.8</java.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
```
启动和rest服务类
```java
@SpringBootApplication
@RestController
public class StartApp {
public static void main(String[] args) {
SpringApplication.run(StartApp.class, args);
}
@RequestMapping("/")
public String index() {
return "hello spring boot";
}
}
```
启动项目，浏览器访问 localhost:8080
# 编写Dockerfile
在项目 `/src/main`目录下新建目录docker，在`/src/main/docker`下新建文件 Dockerfile，内容为：
```
# 基础镜像 这里使用国内网易镜像
FROM hub.c.163.com/dwyane/openjdk:8
#挂载宿主/tmp目录到容器的/tmp目录
VOLUME /tmp
# 拷贝文件(maven打包后的jar文件)，并重命名为 app.jar
ADD com.ityang.boot-1.0-SNAPSHOT.jar app.jar
# 启动容器后执行一些命令
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
```
# 项目添加docker-maven-plugin插件
```xml
<!-- Docker maven plugin start -->
<plugin>
<groupId>com.spotify</groupId>
<artifactId>docker-maven-plugin</artifactId>
<version>0.4.13</version>
<configuration>
<!--[a-z 0-9] 不然docker:build会报错-->
<imageName>dockerspringboot</imageName>
<dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
<resources>
<resource>
<targetPath>/</targetPath>
<directory>${project.build.directory}</directory>
<include>${project.build.finalName}.jar</include>
</resource>
</resources>
</configuration>
</plugin>
<!-- Docker maven plugin end -->
```
需要注意的是，镜像名称必须为 a-z（小写）和0-9 的值，否则docker:build 报错
# 构建镜像文件
执行命令：
```
$ mvn clean package docker:build
```
或者分开执行：
```
$ mvn clean package
$ mvn docker:build
```
部分控制台信息：
```
[INFO] --- docker-maven-plugin:0.4.13:build (default-cli) @ com.ityang.boot ---
[INFO] Copying /Users/yangzhenlong/projs/my/boot-test/target/com.ityang.boot-1.0-SNAPSHOT.jar -> /Users/yangzhenlong/projs/my/boot-test/target/docker/com.ityang.boot-1.0-SNAPSHOT.jar
[INFO] Copying /Users/yangzhenlong/projs/my/boot-test/src/main/docker/Dockerfile -> /Users/yangzhenlong/projs/my/boot-test/target/docker/Dockerfile
[INFO] Building image dockerspringboot
Step 1/4 : FROM hub.c.163.com/dwyane/openjdk:8
---> 96cddf5ae9f1
Step 2/4 : VOLUME /tmp
---> Running in 0dab3c046923
Removing intermediate container 0dab3c046923
---> 2e62fad6a16a
Step 3/4 : ADD com.ityang.boot-1.0-SNAPSHOT.jar app.jar
---> a966ed4c8748
Step 4/4 : ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
---> Running in 4ec1c4990022
Removing intermediate container 4ec1c4990022
---> 02b677ad12e1
ProgressMessage{id=null, status=null, stream=null, error=null, progress=null, progressDetail=null}
Successfully built 02b677ad12e1
Successfully tagged dockerspringboot:latest
[INFO] Built dockerspringboot
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 7.475 s
[INFO] Finished at: 2018-11-17T01:24:57+08:00
[INFO] ------------------------------------------------------------------------
```
# 通过docker镜像启动容器
查看镜像
```
$ docker images
```
|REPOSITORY | TAG | IMAGE ID | CREATED | SIZE|
|---|---|---|---|---|
|dockerspringboot | latest | 02b677ad12e1 | 8 seconds ago | 657MB|
启动容器
```
$ docker run -p 8080:8080 -d dockerspringboot
cbc89f9e0cd584f1405d7177098423f5b576d668f7aee6ff7dfb5b4e34154862
```
解释：
```
-p 8080:8080 #容器端口映射到宿主端口，格式为：主机(宿主)端口:容器端口
-d #后台运行容器，并返回容器ID
```
查看运行的容器
```
$ docker ps
```
CONTAINER ID | IMAGE | COMMAND | CREATED | STATUS | PORTS | NAMES
---|---|---|---|---|---|---
cbc89f9e0cd5 | dockerspringboot | "java -Djava.securit…" | 58 seconds ago | Up 58 seconds | 0.0.0.0:8001->8001/tcp | frosty_lichterman
浏览器访问 loalhost:8080
Docker 部署Springboot 项目
Docker 环境部署参照：https://www.cnblogs.com/oneMr/p/14200760.html
简单 Springboot 项目
新建一个 Springboot 项目,写一个简单的Controller
@RestController
public class HelloController {
@RequestMapping("/")
public String hello() {
return "Hello Docker";
}
}
在 pom 文件中添加 Docker 镜像名称
<properties>
<java.version>1.8</java.version>
<docker.image.prefix>docker</docker.image.prefix>
</properties>
plugins 中添加 Docker 构建插件：
<build>
<plugins>
<!--Docker 插件-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- Docker maven plugin -->
<plugin>
<groupId>com.spotify</groupId>
<artifactId>docker-maven-plugin</artifactId>
<version>1.0.0</version>
<configuration>
<imageName>${docker.image.prefix}/${project.artifactId}</imageName>
<dockerDirectory>src/main/docker</dockerDirectory>
<resources>
<resource>
<targetPath>/</targetPath>
<directory>${project.build.directory}</directory>
<include>${project.build.finalName}.jar</include>
</resource>
</resources>
</configuration>
</plugin>
<!-- Docker maven plugin -->
</plugins>
</build>
在 src/main/docker 下创建 Dockerfile 文件（无后缀名），地址即为插件中的 <dockerDirectory>
Dockerfile 文件内容（ADD 后对应自己的 jar 包名称）：
# 添加 Java 8 镜像来源 FROM java:8 VOLUME /tmp # 添加 Spring Boot 包 ADD docker-1.0.jar /app.jar # 执行启动命令 ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
完成后打包项目
使用 Docker 部署 Spring Boot 项目
将 jar 包和 Dockerfile 上传到服务器的同一个文件夹下
输入命令构建镜像（helloworld 为镜像名，注意后面有个点表示当前目录）
docker build -t helloworld .
查看镜像：
docker images
运行镜像：
docker run -d -p 8081:8080 --name helloworld helloworld
查看正在运行的镜像：
docker ps
访问地址 ip:8081/
今天关于【云原生】springboot 项目打包部署 docker 镜像和springboot项目打包成docker镜像的讲解已经结束，谢谢您的阅读，如果想了解更多关于docker 打包 springboot 项目快速入门、docker 打包springboot镜像并启动、docker 部署 springboot 项目、Docker 部署Springboot 项目的相关知识，请在本站搜索。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
