CentOS7中使用Docker简单部署SpringBoot项目

蔚落 2022-02-05 02:41 328阅读 0赞

# 前言 #

Docker 类似于一个小型的集装箱，里面可以配置项目运行的环境，而且解决了 '我的环境可以运行的，你的环境

运行不起来' 的问题。现在我们部署一个简单的 SpringBoot 项目来初步感受一下 Docker。

# 本篇博客的操作有： #

① 在本地创建一个 SpringBoot 项目；配置 Dockerfile；访问输出 'Hello Docker ！！！'

② 把 SpringBoot 项目传输到服务器；打包成 Docker 镜像；运行镜像；访问输出 'Hello Docker ！！！'

③ 把服务器中打包的 SpringBoot 项目镜像传输到 Docker Hub

# 源码 #

GitHub 地址：[https://github.com/intomylife/Docker][https_github.com_intomylife_Docker]

Docker Hub 地址：[https://hub.docker.com/r/intomylife/docker-springboot][https_hub.docker.com_r_intomylife_docker-springboot]

# 本地创建 SpringBoot 项目 #

## POM 文件 ##

<?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>
    
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.3.RELEASE</version>
        </parent>
    
        
        <groupId>com.zwc</groupId>
        <artifactId>docker-springboot</artifactId>
        <version>1.0</version>
    
        
        <name>docker-springboot</name>
        <description>使用 Docker 部署 SpringBoot 项目</description>
    
        
        <packaging>jar</packaging>
    
        
        <properties>
            
            <java.version>1.8</java.version>
    
            
            <docker.image.prefix>intomylife</docker.image.prefix>
        </properties>
    
        <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>
    
        
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
    
                
                <plugin>
                    
                    <groupId>com.spotify</groupId>
                    <artifactId>docker-maven-plugin</artifactId>
                    <version>1.1.1</version>
                    
                    <configuration>
                        
                        <imageName>${docker.image.prefix}/${project.artifactId}:${project.version}</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>
            </plugins>
        </build>
    
    </project>

*  <docker.image.prefix> Docker 镜像前缀 ：一般会被镜像名称节点引用在前面。为仓库的用户名
 *  <imageName> 镜像名称：仓库用户名**/**镜像名称**:**镜像版本号
 *  如果想接下来把打包好的镜像传输到仓库中，那么这里 <imageName> 镜像名称要按照格式来

## Dockerfile 文件 ##

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

*  注意此文件的路径为 ：src/main/docker/
 *  此文件是构建 Docker 的核心文件
 *  FROM openjdk:8-jdk-alpine：基础镜像环境 JDK1.8
 *  VOLUME /tmp：指定了挂载目录
 *  ADD docker-springboot-1.0.jar app.jar：把生成的 jar 包拷贝到 Docker 容器中并命名为 app.jar

**docker-springboot-1.0.jar 是我项目打包后的名称（项目名称  + 版本号），你的对应要修改成你的项目**

**       打包后的名称，否则在后面构建 Docker 镜像时会失败**

*  最后一行是修改 Tomcat 随机数生成方式，加快 Tomcat 启动

## Controller 前端控制器 ##

package com.zwc.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @ClassName HelloDockerController
     * @Desc TODO   say hello - 前端控制器
     * @Date 2019/5/3 17:18
     * @Version 1.0
     */
    @RestController
    public class HelloDockerController {
    
        /*
         * @ClassName HelloDockerController
         * @Desc TODO   say hello
         * @Date 2019/5/3 17:21
         * @Version 1.0
         */
        @RequestMapping("/")
        public String say(){
            return "Hello Docker ！！！";
        }
    
    }

--------------------

# 服务器上部署环境 #

## CentOS7中安装Maven3.6.0 ##

[CentOS7中安装Maven3.6.0][CentOS7_Maven3.6.0]

## CentOS7中安装Docker ##

[CentOS7中安装Docker][CentOS7_Docker]

## 传输 ##

1. 打开下载好的 MobaXterm，使用 SSH 连接方式

2. 连接成功后默认到 root 目录

3. MobaXterm 左边是目录，在左边目录的最底部，有个选择框（Follow terminal folder）把它勾选上。

勾选上它后，目录就会跟着你的命令动态发生变化

4. 输入命令 **cd /usr/local/** -> 进入目录

5. 输入命令 **mkdir JavaWork **\-> 新建文件夹

6. 输入命令 **cd JavaWork** -> 进入目录

7. 把本地的 SpringBoot 项目文件夹拖拽到 MobaXterm 左边目录中

8. 传输需要一点点时间，也可以在 MobaXterm 左边目录底部看到传输进度

## 打包 Docker 镜像 ##

1. 输入命令 **cd /usr/local/JavaWork/docker-springboot/** \-> 进入目录

注意： **docker-springboot** 是从本地传输到服务器上的 SpringBoot 项目

2. 输入命令 **mvn package docker:build** \-> 使用 Maven 打包 Docker 镜像

3. 第一次打包需要一点时间，最后看到 'BUILD SUCCESS' 等字样就证明打包成功了

## 运行 Docker 镜像 ##

1. 输入命令 **docker images** \-> 查看构建的镜像

2. 镜像有两种启动方式：

① 使用镜像名称（REPOSITORY）启动：

输入命令 **docker run -p 8080:8080 intomylife/docker-springboot:1.0** \-> 运行镜像

注：**intomylife/docker-springboot:1.0** 是在 POM 文件中设置的 imageName

② 使用镜像 ID（IMAGE ID）启动

输入命令 **docker run -p 8080:8080 a1b2c3d4** -> 运行镜像

注：**a1b2c3d4** 是镜像 ID

**注：这两种启动方式选择其一即可；-p： 端口映射（格式为：宿主机端口:容器端口）**

3. 看到依旧熟悉的 Tomcat 日志，并在最后显示了端口和启动时间就证明 Docker 镜像运行成功了

4. 使用 ip + 8080 访问，看到 'Hello Docker ！！！' 就证明整个部署过程就成功了（注意安全组和端口）

--------------------

## 安全组 ##

** 注：如果服务器是在阿里云租用的需要设置安全组**

1. 登录到阿里云

2. 进入到 '云服务器 ECS' 控制台

3. 左侧栏中选择 '实例'

4. 进入实例详情，点击左侧栏中 '本实例安全组'

5. 点击安全组中的 '配置规则'

6. 点击 '添加安全组规则' 按钮

7. 配置 8080 端口

## 防火墙 ##

**注：如果服务器是在阿里云租用的需要开启防火墙。服务器是默认不开启防火墙的，感觉不安全**

1. 输入命令 **systemctl status firewalld** -> 查看防火墙状态

2. 输入命令 **systemctl start firewalld** -> 开启防火墙

3. 如果你不想开防火墙的话，那就输入命令** systemctl stop firewalld **\-> 关闭防火墙

4. 输入命令 **systemctl restart firewalld.service** -> 重启防火墙

## 端口 ##

**  注：端口操作需要在开启防火墙的情况下才能执行成功。****如下两条命令只需要执行一个即可**

** ** 1. 输入命令** firewall-cmd --permanent --zone=public --add-port=8080****/tcp** \-> 永久开放 8080 端口

2. 输入命令** firewall-cmd --zone=public --add-port=8080/tcp** \-> 临时开放 8080 端口

--------------------

# **把打包好的镜像传输到仓库中** #

**  注：这里选择 [Docker Hub][] 官方仓库**

1. 如果没有账号的话先注册一个，填写用户名邮箱及密码等信息提交，到邮箱中确认即可

2. 确保 Docker 服务已经启动：**systemctl  start docker.service **\-> 启动 Docker 服务

3. 输入命令 **docker login** \-> 登录 Docker Hub

4. 出现 'Login Succeeded' 等字样就证明登录成功了

5. 输入命令 **docker push intomylife/docker-springboot:1.0** \-> 把镜像传输到仓库中

**intomylife 为 Docker Hub 仓库用户名**

**      docker-springboot 为 镜像名称**

**1.0 为镜像版本**

6. 在自己的仓库中就可以看到此镜像了，注意此时镜像为公开的

7. 因为我此次打包的 SpringBoot 项目是样例，里面没有很隐私的信息，所以公开的也没关系

如果你不想被别人下载你的镜像，你也可以设置为私有的（貌似有费用），当然也可以搭建私库

# 把仓库中的公有镜像拉取到服务器中 #

1. 输入命令** docker pull** **intomylife****/****docker-springboot****:****1.0** -> 把镜像拉取到服务器中

**intomylife 为 Docker Hub 仓库用户名**

**      docker-springboot 为 镜像名称**

**1.0 为镜像版本**

--------------------

# 扩展 #

[CentOS7中常用命令行][CentOS7]

# #

希望能够帮助到你

over

[https_github.com_intomylife_Docker]: https://github.com/intomylife/Docker
[https_hub.docker.com_r_intomylife_docker-springboot]: https://hub.docker.com/r/intomylife/docker-springboot
[CentOS7_Maven3.6.0]: https://blog.csdn.net/qq_41402200/article/details/89789864
[CentOS7_Docker]: https://blog.csdn.net/qq_41402200/article/details/89790700
[Docker Hub]: https://hub.docker.com/
[CentOS7]: https://blog.csdn.net/qq_41402200/article/details/89549311