GVKun编程网logo

docker 的学习笔记 (二)- 部署一个 springboot 项目（docker如何部署springboot项目）

18

本篇文章给大家谈谈docker的学习笔记(二)-部署一个springboot项目，以及docker如何部署springboot项目的知识点，同时本文还将给你拓展20分钟学会Docker部署Spring

本篇文章给大家谈谈docker 的学习笔记 (二)- 部署一个 springboot 项目，以及docker如何部署springboot项目的知识点，同时本文还将给你拓展20 分钟学会 Docker 部署 SpringBoot 项目、docker - 部署一个复杂的springboot服务、Docker 部署 SpringBoot 项目、Docker 部署Springboot 项目等相关知识，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

docker 的学习笔记 (二)- 部署一个 springboot 项目（docker如何部署springboot项目）

docker 的学习笔记 (二)- 部署一个 springboot 项目（docker如何部署springboot项目）

部署一个 springboot 项目

1. 在 dockerHub 上面拉取镜像

docker pull jetty

2. 运行容器

docker run --name dems -v /opt/data:/tmp -p 8080:8080 -v /etc/localtime:/etc/localtime -d java java -jar -Duser.timezone=Asia/Shanghai /tmp/demo.jar

注释:--name 容器名称

-v /opt/data 项目 jar 放的位置

-p 端口映射 8080 映射到服务器的 8080 端口 -p 80:8080 表示将容器的 8080 端口映射到主机的 80 端口

3. 查看日志

docker logs -f --tail=100 容器名

4. 若果报错，可以删除之前的容器，重新开始

docker rm 容器名称

5. 可以查找一些镜像

docker search 镜像名称

6. 访问项目

20 分钟学会 Docker 部署 SpringBoot 项目

20 分钟学会 Docker 部署 SpringBoot 项目

我们的开源博客项目 eblog 已经更新完毕了。今天，我们使用 docker 的安装方式，来安装一下我们的项目，实验环境是 centos 7 系统上，本实验适用部署大部分 Springboot 项目。

eblog 项目地址：

https://github.com/MarkerHub/eblog

安装 docker

#安装
yum install docker

#检验安装是否成功
[root@localhost opt]# docker --version
Docker version 1.13.1, build 7f2769b/1.13.1

#启动
systemctl start docker

#换镜像源
sudo vim /etc/docker/daemon.json
内容如下：
{
 "registry-mirrors": ["https://m9r2r2uj.mirror.aliyuncs.com"]
}
保存退出，重启docker

#重启
systemctl restart docker

安装 redis

首先上 dockerHub 搜索 redis，点击进入详情页之后，拉到下面就可以看到 how to use，如果需要选择特定的版本，有 Supported tags 给我们选择，然后如果拉取最新的版本的话，拉倒下面就教程。

  • https://hub.docker.com/_/redis
#拉取redis的镜像
docker pull redis
#查看本地redis镜像
docker images
#运行redis
docker run --name myredis -p 6379:6379 -d redis redis-server --appendonly yes
  • docker run 表示运行的意思
  • --name myredis 表示起个名字叫 myredis
  • -p 6379:6379 表示把服务器的 6379 映射到 docker 的 6379 端口，这样就可以通过服务器的端口访问 docker 的端口
  • -d 表示以后台服务形式运行 redis
  • redis redis-server --appendonly yes 表示开启持久化缓存模式，可以存到硬盘

安装 mysql

  • https://hub.docker.com/_/mysql

MYSQL_ROOT_PASSWORD=admin 表示 root 的初始密码

mysql:5.7.27 表示操作的是 mysql 的 5.7.27 版本，没有后面的版本号的话，默认是拉取最新版本的 mysql。

docker pull mysql:5.7.27
docker run --name mymysql -e MYSQL_ROOT_PASSWORD=admin -d -p 3306:3306  mysql:5.7.27

连上 mysql，创建数据库 eblog，然后把数据库脚本导入进去。 脚本位置：https://github.com/MarkerHub/eblog/blob/master/eblog.sql

安装 RabbitMq

一行命令搞定，注意 RABBITMQ_DEFAULT_PASS=password 是设置密码的意思哈。

docker run -d --hostname my-rabbit --name myrabbit -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 rabbitmq:management

安装 ElasticSearch

docker 安装 Elasticsearch6.4.3 版本 及中文插件安装。

系统配置

不配置的话，可能会启动失败

具体报错：max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]。

解决：

  • sudo sysctl -w vm.max_map_count=262144

启动 ES

  • docker run -p 9200:9200 -p 9300:9300 -d --name es_643 elasticsearch:6.4.3

进入镜像

  • docker exec -it es_643 /bin/bash

es 配置文件位置： /usr/share/elasticsearch/config/elasticsearch.yml

安装中文分词插件

./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.4.3/elasticsearch-analysis-ik-6.4.3.zip

退出并重启镜像

  • exit
  • docker restart es_643

构建 eblog 的 docker 镜像

接下来，我们需要先去 clone eblog 博客项目，对项目进行打包成 jar 包。

clone https://github.com/MarkerHub/eblog.git
cd eblog
# 打包
mvn clean package -Dmaven.test.skip=true

然后把项目 eblog-0.0.1-SNAPSHOT.jar 包上传到服务器中 同 eblog-0.0.1-SNAPSHOT.jar 的目录，创建一个名称为 Dockerfile 文件。

内容如下：

  • Dockerfile
FROM java:8
EXPOSE 8080

VOLUME /tmp

ENV TZ=Asia/Shanghai
RUN ln -sf /usr/share/zoneinfo/{TZ} /etc/localtime && echo "{TZ}" > /etc/timezone

ADD eblog-0.0.1-SNAPSHOT.jar  /app.jar
RUN bash -c ''touch /app.jar''
ENTRYPOINT ["java","-jar","/app.jar"]
  • FROM java:8 表示基于 jdk8 环境
  • EXPOSE 8080 表示对外暴露的端口是 8080
    • VOLUME /tmp 表示挂载到 /tmp 目录
  • ADD eblog-0.0.1-SNAPSHOT.jar/app.jar 表示把 jar 包复制到镜像服务里面的根目录，并改名称 app.jar
  • RUN bash -c ''touch /app.jar'' 表示执行创建 app.jar
  • ENTRYPOINT ["java","-jar","/app.jar"] 表示执行启动命令 java -jar

接下来，我们安装 Dockrfile 的命令，把 eblog-0.0.1-SNAPSHOT.jar 构建成 docker 的镜像。

#构建镜像，注意后面有个点哈。
docker build -t eblog .
#查看镜像
docker images

这步骤完成之后，我们就可以在准备工作就已经完成啦，接下来，我们就直接启动我们的项目哈。

启动 eblog 项目

启动命令如下：

docker run -p 8080:8080 -p 9326:9326 --name eblog --link es_643:ees --link myrabbit:erabbit --link mymysql:emysql --link myredis:eredis -d eblog

-p 8080:8080 -p 9326:9326 ：9326 是因为即时聊天需要用到的 ws 端口 --link es:ees 表示关联容器，把容器 es 起别名为 ees

查看 eblog 打印日志

docker logs -f eblog

这时候我们查看就可以通过 8080 端口访问我们的项目了！！！

到此项目运行成功！！

 

 yum -y install lrzsz

systemctl status firewalld.service

 

 

docker 迁移后，还需要启动的 

docker run -p 8080:8080 -d myblog

docker - 部署一个复杂的springboot服务

docker - 部署一个复杂的springboot服务

    在文章 docker容器网络 - 同一个host下的容器间通信 中，我们已经了解怎么在同一个host中容器间互相通信，本文将会利用学会的知识，部署一个“复杂”的springboot应用。该应用实现一个计数服务，springboot应用暴露服务接口，通过redis实现计数功能。该应用在docker里的部署图如下图所示：

我们先看下应用的代码，初步了解下应用提供什么服务。

在配置文件中配置了一个redis。redis地址将会在容器启动的时候通过设置环境变量修改

spring.application.name=springboot-redis
server.port=8080
logging.file=app.log

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=

应用通过rest的方式提供了计数的服务

    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping("/count")
    public Long count() {
        ValueOperations<String, Long> valueOperations = redisTemplate.opsForValue();
        Long next = valueOperations.increment("counter", 1);
        System.out.println("get next counter, value=" + next);
        return next;
    }

要成功部署该服务，共需要三步：1、创建网络；2、部署redis；3、部署app。

创建网络

为了能够通过容器名访问其它容器，这里需要创建一个bridge网络，名字为my_bridge

[root@localhost data]# docker network create --driver bridge my_bridge
6067b2b842be2daf748bd8300eff2d63cbb9cb15746a4fd540621010e684daf6

部署redis

redis的官方镜像可以在 链接 中查看，里面有详细的配置信息和启动说明。本文将会采用redis 4.0.11版本。

(1) 拉取redis镜像

docker pull redis:4.0.11

（2）运行redis容器

[root@localhost data]# docker run --name redis --network my_bridge -v /data/redis:/data -d redis:4.0.11 redis-server --appendonly yes
68334422af05dba03d87ec1dafbc1dc0bb85302389b0e7f04722405f80074d95
  • --name：容器名为redis
  • --network：redis容器连接到my_bridge网络
  • -v：redis的持久化数据默认存放在容器的/data目录，这里把/data目录映射到宿主主机的/data/redis数据卷中
  • -d：后台运行
  • --appendonly yes：redis数据持久化

（3）验证redis是否运行正常

因为redis容器在启动的时候没有暴露端口到宿主主机，所以我们需要进入到redis容器中，并通过redis-cli操作redis验证是否正常工作。

交互方式进入容器：

[root@localhost data]# docker exec -it redis bash
root@68334422af05:/data#

运行redis-cli客户端，与redis交互

root@68334422af05:/# redis-cli

127.0.0.1:6379> set 123 123
OK
127.0.0.1:6379> get 123
"123"

OK，redis运行正常。

部署应用

springboot-redis的dockerfile如下，如果对dockerfile不熟悉，可以通过 构建一个简单的docker镜像  、 Dockerfile常用指令、 dockerfile构建一个简单的springboot应用镜像 熟悉。

FROM openjdk:8u181-jdk-alpine
ARG workdir=/app
VOLUME ${workdir}
WORKDIR ${workdir}
ADD springboot-redis-1.0.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]

创建springboot-redis:1.0镜像

[root@localhost springboot-redis]# docker build -t springboot-redis:1.0 .

Sending build context to Docker daemon  25.47MB
Step 1/7 : FROM openjdk:8u181-jdk-alpine
 ---> 97bc1352afde
Step 2/7 : ARG workdir=/app
 ---> Running in 65e48ea3ccf6
Removing intermediate container 65e48ea3ccf6
 ---> 15ef3bac3e17
Step 3/7 : VOLUME ${workdir}
 ---> Running in 0b5421f1827d
Removing intermediate container 0b5421f1827d
 ---> ce5e62a86355
Step 4/7 : WORKDIR ${workdir}
Removing intermediate container 9009b9ac08e6
 ---> 2e50c02c2f88
Step 5/7 : ADD springboot-redis-1.0.jar app.jar
 ---> 20e46c2d3b76
Step 6/7 : EXPOSE 8080
 ---> Running in c58cf2d973ee
Removing intermediate container c58cf2d973ee
 ---> bc5cb5e87d27
Step 7/7 : ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]
 ---> Running in b66b3e2ecf6e
Removing intermediate container b66b3e2ecf6e
 ---> 05de26e57ed3
Successfully built 05de26e57ed3
Successfully tagged springboot-redis:1.0

运行springboot-redis容器。

[root@localhost ~]# docker run -p 8080:8080  -d --name springboot-redis --network my_bridge --env spring.redis.host=redis springboot-redis:1.0

因为设置了容器的网络是前面定义的my_bridge，所以在springboot-redis容器中，可以通过redis容器名访问到容器。所以，可以通过--env参数设置redis的地址是 redis 。

通过下面的命令可以实时查看日志输出

[root@localhost ~]# docker logs -f springboot-redis

在浏览器上验证一下服务是否正常。192.168.88.30是我的宿主机IP。

总结

有时，一个应用需要很多个服务同时部署，如果都按照上面的方式进行部署，将是一个很吃力的事情。那么，有什么样的方式可以简化我们的部署呢？docker-compose是docker官方提供的服务编排工具，通过docker-compose脚本可以批量启动我们的服务。

 

文章收录于：

容器技术系列汇总

Docker 部署 SpringBoot 项目

Docker 部署 SpringBoot 项目

Spring Boot 项目代码

首先构建一个简单的 Spring Boot 项目，然后给项目添加 Docker 支持，最后对项目进行部署。

  • 在 pom.xml 中添加 SpringBoot 依赖，并添加 Web 支持。

    	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.2.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

  • 创建 启动类 并添加 Controller ，这里为了方便写在一起，其中有一个 Hello 方法，访问时返回 Hello Docker。

    /**
 * @author Arley
 * data:2020/1/30
 * desc:Docker中部署springboot项目
 */
@RestController
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, "--server.port=8888");
    }

    @GetMapping("/hello")
    public String Hello() {
        return "Hello Docker";
    }
}

添加完成之后，启动项目，访问 http://127.0.0.1:8888/hello ，页面返回 Hello Docker，说明项目配置正常。

在 SpringBoot 中添加 Docker 支持

  • 在 pom.xml 中添加 Docker 镜像支持：

        <!--  Docker 镜像前缀名 -->
    <properties>
        <docker.image.prefix>springboot</docker.image.prefix>
    </properties>

  • plugins 中添加 Docker 构建插件：

    <build>
        <plugins>
            <!-- 添加这个是因为我启动项目时遇到个问题(jar中没有主清单属性)
 				 添加下面这个插件即可-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.arley.Application</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </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>			
                    <!-- Dockerfile 文件存放目录 -->
                    <dockerDirectory>src/main/resources/docker</dockerDirectory>
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <!-- jar包所在目录,缺省为target -->
                            <directory>${project.build.directory}</directory>
                            <!-- jar包名,缺省为 ${project.artifactId}-${project.version} -->
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
            <!-- Docker maven plugin -->
        </plugins>
    </build>

创建 Dockerfile 文件

在目录 src/main/resources/docker 下创建 Dockerfile 文件，Dockerfile 文件来说明如何构建镜像

  • Dockerfile 文件内容：

    FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD boot-docker-1.0-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

    参数说明：

    FROM openjdk:8-jdk-alpine : 使用 JDK8 环境作为基础镜像

    VOLUME /tmp : 在宿主机的 /var/lib/docker 目录下创建一个临时文件并把它链接到 tomcat 容器的工作目 录 /tmp 目录

    ADD boot-docker-1.0-SNAPSHOT.jar app.jar : 复制文件并且重命名。boot-docker-1.0-SNAPSHOT.jar 为你的 SpringBoot 项目达成的 jar 包名。

    ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] :

    为了缩短 Tomcat 的启动时间，添加 java.security.egd 的系统属性指向 /dev/urandom 作为 ENTRYPOINT。

环境搭建

  • 首先安装 Docker ，可以看我之前的教程

    <a href="https://www.cnblogs.com/leizzige/p/12183038.html" target="_blank">https://www.cnblogs.com/leizzige/p/12183038.html</a>

  • 安装 Jdk

    yum -y install java-1.8.0-openjdk*;

    配置环境变量：

    打开 vim /etc/profile，添加以下内容 ：

    export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export PATH=$PATH:$JAVA_HOME/bin

    修改完成之后，使其生效：source /etc/profile，输入 java -version 返回版本信息则安装正常。

  • 安装 Maven

    maven 下载地址

    解压：tar -zxvf apache-maven-3.5.2-bin.tar.gz 移动：mv apache-maven-3.5.2 /usr/local/maven

    修改环境变量， 在 /etc/profile 中添加以下几行：

    MAVEN_HOME=/usr/local/maven
export MAVEN_HOME
export PATH=${PATH}:${MAVEN_HOME}/bin

    记得执行 source /etc/profile 使环境变量生效。输入 mvn -version 返回版本信息则安装正常。 这样整个构建环境就配置完成了。

使用 Docker 部署 Spring Boot 项目

将我们写好的 SpringBoot 项目复制到服务器中，进入项目的 pom 文件所在目录下进行打包测试。

  • 打包：mvn clean compile package ，启动 : java -jar target/xxx-jar

  • 看到 Spring Boot 的启动日志后表明环境配置没有问题。 使用 DockerFile 构建镜像 : mvn package docker:build

  • 第一次构建，看到以下内容表示构建成功了：

  • 使用 docker images 命令查看构建好的镜像：

​ springboot/boot-docker 就是我们构建好的镜像，下一步运行该镜像：

docker run -itd -p 8888:8888 --name spring-boot-docker e879d41f3a71

​ 启动完成之后 docker ps 查看正在运行的容器，可以看到我们构建的 spring-boot-docker 容器正在运行，

​ 访问浏览器 http:http://47.98.161.xxx:8888/hello ，返回 Hello Docker。

使用 Docker 部署 SpringBoot 项目成功！！！！

项目地址 ：<a href="https://github.com/CrazyArley/springboot" target="_blank">https://github.com/CrazyArley/springboot</a>

Docker 部署Springboot 项目

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/

 

 

关于docker 的学习笔记 (二)- 部署一个 springboot 项目和docker如何部署springboot项目的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于20 分钟学会 Docker 部署 SpringBoot 项目、docker - 部署一个复杂的springboot服务、Docker 部署 SpringBoot 项目、Docker 部署Springboot 项目等相关内容，可以在本站寻找。

本文标签：

上一篇org.apache.commons.lang3.time之DateUtil

下一篇Spring Boot 2.6 新特性（spring boot2.4新特性）

相关文章