云服务器Docker部署SpringBoot+Vue前后端(Ubuntu)

云服务器Docker部署SpringBoot+Vue前后端(Ubuntu)

本文创作环境
华为云Ubuntu22.04
需要对以下知识具备一定了解和经验

  • Linux和Docker使用基础
  • Vue基本使用
  • SpringBoot基本使用

一、起手式-环境配置

1.远程服务器免密

在远程服务器执行ssh-keygen -t rsa,得到如下三个文件

language-bash
1
2
3
4
5
root@hecs-295176:~# ls -lh .ssh/
total 12K
-rw------- 1 root root 570 Oct 21 15:14 authorized_keys
-rw------- 1 root root 2.6K Oct 21 15:09 id_rsa
-rw-r--r-- 1 root root 570 Oct 21 15:09 id_rsa.pub

id_rsa.pub内容复制到authorized_keys,然后将id_rsa下载到本地。
在VsCode使用Remote-SSH配置远程免密登录,例如

language-bash
1
2
3
4
5
Host huaweiYun
HostName xxx.xxx.xxx.xxx
User root
Port 22
IdentityFile "C:\Users\mumu\.ssh\id_rsa"

2.安装Docker

执行以下命令安装Docker并检查docker命令是否可以使用

language-bash
1
2
3
4
5
apt update
apt upgrade
apt install docker.io
docker ps -a
docker images -a

二、Vue前端部署

1.参考文件夹结构

文件先不用创建,按照下面结构先把文件夹创建出来
然后将你的Vue打包后的dist文件夹替换下面的dist文件夹(如果没有Vue的打包文件夹本人建议先在index.html随便写点东西等会看能不能访问)

language-html
1
2
3
4
5
6
7
8
9
10
11
12
13
/root
├── conf
│ └── nginx
│ ├── default.conf
│ └── nginx.conf
└── Vue
├── MyTest01
│ ├── dist
│ │ └── index.html
│ └── logs
│ ├── access.log
│ └── error.log
└── nginxDocker.sh

2.nginx

拉取nginx镜像并创建nginx容器

language-bash
1
2
docker pull nginx
docker run -itd nginx

把里面的两个配置文件复制到主机

language-bash
1
2
docker cp containerName:/etc/nginx/nginx.conf ~/conf/nginx/nginx.conf
docker cp containerName:/etc/nginx/conf.d/default.conf ~/conf/nginx/default.conf

编辑default.conf 文件,修改以下内容:

  • listen 80; 改为 listen 8080;,表示 nginx 容器监听 8080 端口。
  • root /usr/share/nginx/html; 改为 root /usr/share/nginx/dist;,表示 nginx容器的根目录为 /usr/share/nginx/dist
  • index index.html index.htm; 改为 index index.html;,表示 nginx 容器的默认首页为 index.html。

参考第一小步文件夹结构,把以下内容写入nginxDocker.sh

language-bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/bin/bash

containerName="Test01"
nginxConf="/root/conf/nginx/nginx.conf"
defaultConf="/root/conf/nginx/default.conf"
logsPath="/root/Vue/MyTest01/logs"
vuePath="/root/Vue/MyTest01/dist"

docker run -d --name "$containerName" \
-v "$nginxConf":/etc/nginx/nginx.conf \
-v "$defaultConf":/etc/nginx/conf.d/default.conf \
-v "$logsPath":/var/log/nginx \
-v "$vuePath":/usr/share/nginx/dist \
-p 8080:8080 \
nginx

命令行运行这个sh脚本并查看当前容器列表确认容器已经在运行中

language-bash
1
2
bash Vue/nginxDocker.sh
docker ps -a

3.开放8080端口

如果你使用的VsCode远程连接的服务器,那么可以先通过端口转发,在本地访问前端服务。
如果想要别人通过公网访问,需要去购买云服务器的平台,修改服务器的安全组配置,添加入站规则,开放8080端口。
之后使用IP+8080即可访问这个docker容器里的前端服务。

4.复盘

首先是更新便捷性,使用-v挂载文件到容器,我们可以直接修改主机的dist文件夹内容而不必对容器做任何操作,前端服务就可以自动update,其它-v挂载的文件都可以在主机直接修改而不必连入容器中修改,同时重启容器即可一定保证所有服务重启。
其次是多开便捷性,以上流程就是一个包裹了前端服务的docker占一个端口,如果有多个Vue前端,使用不同端口即可。
总而言之,都是选择Docker容器化的优势所在。

三、SpringBoot后端部署

1.参考文件夹结构

将maven打包好的jar包如下图放入对应位置

language-bash
1
2
3
4
SpringBoot
├── javaDocker.sh
└── MyTest01
└── demo-0.0.1-SNAPSHOT.jar

2.openjdk17

以java17举例,拉取对应docker镜像(java8对应的镜像是java:8 )

language-bash
1
docker pull openjdk:17

如下编写javaDocker.sh脚本

language-bash
1
2
3
4
5
6
7
8
9
#!/bin/bash

containerName="JavaTest01"
SpringBootPath="/root/SpringBoot/MyTest01/demo-0.0.1-SNAPSHOT.jar"

docker run -d --name "$containerName" \
-p 8081:8081 \
-v "$SpringBootPath":/app/your-app.jar \
openjdk:17 java -jar /app/your-app.jar

命令行运行这个sh脚本并查看当前容器列表确认容器已经在运行中

language-bash
1
2
bash SpringBoot/javaDocker.sh
docker ps -a

3.开放8081端口

需要去购买云服务器的平台,修改服务器的安全组配置,添加入站规则,开放8081端口。
打开浏览器,输入IP:8081然后跟上一些你在程序中写的api路径,验证是否有返回。

四、Vue->Axios->SpringBoot前后端通信简单实现

vue这里使用ts + setup +组合式 语法举例,前端代码如下
意思是向IP为xxx.xxx.xxx.xxx的云服务器的8081端口服务发送路径为/Home/Kmo的请求

language-html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<template>
<div>
Your Remote JavaDocker State : {
{ line }}
</div>
</template>

<script setup lang="ts">
import {
ref } from "vue";
import axios from "axios";
const line = ref("fail");
axios.get("http://xxx.xxx.xxx.xxx:8081/Home/Kmo").then(rp=>{

line.value = rp.data
})
</script>


<style scoped>
</style>

SpringBoot后端写一个简单Controller类,代码如下

language-java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.kmo.demo.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@CrossOrigin(originPatterns = "*", allowCredentials = "true")
@RestController
@RequestMapping("Home")
public class TestController {


@GetMapping("/Kmo")
public String test(){

return "Success!";
}

}

分别打包放到云服务指定文件夹,然后restart重启两个docker容器即可,在本地浏览器访问IP:8080看看效果吧。

(完)

云服务器部署可视化Docker私有仓库(Ubuntu)

云服务器部署可视化Docker私有仓库(Ubuntu)

这里测试的机器为ubuntu22.04

一、环境安装

docker安装就不赘述了
先升级,再从官方仓库安装docker compose

language-bash
1
2
3
apt update
apt upgrade
apt install docker-compose

二、部署私有仓库UI

Docker提供了一个叫registry的镜像,给大家搭建私有仓库,但是没有可视化界面。
https://hub.docker.com/r/joxit/docker-registry-ui
这个镜像在registry基础之上,开发了网页可视化。

1. 创建一个文件夹Docker_Registry

2. 进入其中继续创建registry-data文件夹和docker-compose.yaml文件

3. yaml文件

language-yaml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
version: '3.8'

services:
registry-ui:
image: joxit/docker-registry-ui:main
restart: always
ports:
- 8090:80 #这里8090改成可视化网页服务端口
environment:
- SINGLE_REGISTRY=true
- REGISTRY_TITLE=Xiamu Docker Registry UI #这里可以修改标题
- DELETE_IMAGES=true
- SHOW_CONTENT_DIGEST=true
- NGINX_PROXY_PASS_URL=http://registry-server:5000
- SHOW_CATALOG_NB_TAGS=true
- CATALOG_MIN_BRANCHES=1
- CATALOG_MAX_BRANCHES=1
- TAGLIST_PAGE_SIZE=100
- REGISTRY_SECURED=false
- CATALOG_ELEMENTS_LIMIT=1000
container_name: registry-ui
depends_on:
- registry-server

registry-server:
image: registry:2.8.2
restart: always
environment:
REGISTRY_HTTP_HEADERS_Access-Control-Origin: '[http://your_server_ip]' # 这里改成你的云服务ip,启用CORS
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Methods: '[HEAD,GET,OPTIONS,DELETE]'
REGISTRY_HTTP_HEADERS_Access-Control-Credentials: '[true]'
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Headers: '[Authorization,Accept,Cache-Control]'
REGISTRY_HTTP_HEADERS_Access-Control-Expose-Headers: '[Docker-Content-Digest]'
REGISTRY_STORAGE_DELETE_ENABLED: 'true'
volumes:
- ./registry-data:/var/lib/registry
container_name: registry-server

4. 部署

进入Docker_Registry目录,执行

language-bash
1
docker-compose -f ./docker-compose.yaml up

三、访问

通过http://your_server_ip:8090 访问UI

四、上传和拉取镜像

打开vi /etc/docker/daemon.json添加以下内容:

language-txt
1
"insecure-registries":["http://your_server_ip:8090"]

这样docker才会信任你的私有仓库。

假设你的服务器ip为192.168.750.101,port为8090
推送镜像到私有镜像服务必须先tag,步骤如下:

  1. 重新tag本地镜像,名称前缀为私有仓库的地址: 192.168.150.101:8090/
language-dart
1
docker tag nginx:latest 192.168.150.101:8090/nginx:1.0
  1. 推送镜像
language-dart
1
docker push 192.168.150.101:8090/nginx:1.0
  1. 拉取镜像
language-dart
1
docker pull 192.168.150.101:8090/nginx:1.0
云服务器Docker部署SpringBoot+Redis(Ubuntu)

云服务器Docker部署SpringBoot+Redis(Ubuntu)

参考文件夹结构

language-bash
1
2
3
4
5
6
7
MyTest01
├── javaDocker.sh
├── redisDocker.sh
├── Redis
│ └── data
├── SpringBoot
└── MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar

一、起手式:配置环境

1.镜像

拉取以下两个镜像

language-bash
1
2
docker pull openjdk:17
docker pull redis

二、启动Redis容器

redisDocker.sh脚本写入以下内容,然后bash运行
脚本意思是将redis数据映射到主机

language-bash
1
2
3
4
5
6
7
8
9
#!/bin/bash

containerName="RedisTest01"
RedisData="/root/MyTest01/Redis/data"

docker run -d --name "$containerName" \
-v "$RedisData":/data \
-p 6379:6379 \
redis

三、配置SpringBoot容器并简单测试

添加如下配置到application.yml

language-yaml
1
2
3
4
5
6
spring:
data:
redis:
host: redisdb
port: 6379
password:

写一个简单的测试如下

language-java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.example.myweb01springboot.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.sql.SQLException;

@RestController
@RequestMapping("/Home")
@CrossOrigin(origins = "*", allowedHeaders = "*")
public class TestController {

@Autowired
private RedisTemplate<String, String> redisTemplate;

@GetMapping("/Kmo")
public String test() throws SQLException {

// 设置一个键值对
redisTemplate.opsForValue().set("name", "张三");

// 获取一个键值对
String name = redisTemplate.opsForValue().get("name");

System.out.println(name);

return "Success!"+name;
}
}

然后maven打包成jar,参考文件夹结构,将jar放入指定位置。
将以下内容写入javaDocker.sh脚本并bash运行
脚本意思是,向名为MySQLTest01的容器建立网络链接(单向的),它的名字(IP,主机名)为db,于是此容器可以通过db:3306访问MySQLTest01容器的mysql服务。

language-bash
1
2
3
4
5
6
7
8
9
10
11
#!/bin/bash

containerName="JavaTest01"
SpringBootPath="/root/MyTest01/SpringBoot/MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar"

docker run -d --name "$containerName" \
-p 8081:8081 \
--link RedisTest01:redisdb \
-v "$SpringBootPath":/app/your-app.jar \
openjdk:17 java -jar /app/your-app.jar

开放云服务器安全组入站规则8081端口,浏览器访问云服务器IP:8081/Home/Kmo验证。

(完)

云服务器Docker部署SpringBoot+MySQL(Ubuntu)

云服务器Docker部署SpringBoot+MySQL(Ubuntu)

参考文件夹结构

language-bash
1
2
3
4
5
6
7
MyTest01
├── javaDocker.sh
├── mysqlDocker.sh
├── MySQL
│ └── data
├── SpringBoot
└── MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar

一、起手式:配置环境

1.镜像

拉取以下两个镜像

language-bash
1
2
docker pull openjdk:17
docker pull mysql:8

二、启动Mysql容器

mysqlDocker.sh脚本写入以下内容,然后bash运行
脚本意思是将mysql数据映射到主机并设置密码为xxxx,

language-bash
1
2
3
4
5
6
7
8
9
10
#!/bin/bash

containerName="MySQLTest01"
MySQLData="/root/MyTest01/MySQL/data"

docker run -d --name "$containerName" \
-p 3306:3306 \
-v "$MySQLData":/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=xxxx \
mysql:8

在云服务器安全组开放入站规则3306端口
此时可以用你喜欢的数据库连接软件来连接这个mysql容器,并创建test01数据库和一张student表,结构随意,随便插入几条数据。

三、配置SpringBoot容器并简单测试

添加如下配置到application.yml
补充你的云服务器IP和刚才设置的密码

language-yaml
1
2
3
4
5
6
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://xxx.xxx.xxx.xxx:3306/test01?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: xxxx

写一个简单的测试如下

language-java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.example.myweb01springboot.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.sql.SQLException;

@RestController
@RequestMapping("/Home")
@CrossOrigin(origins = "*", allowedHeaders = "*")
public class TestController {

@Autowired
DataSource dataSource;

@Autowired
JdbcTemplate jdbcTemplate;
@GetMapping("/Kmo")
public String test() throws SQLException {

System.out.println("默认数据源为:" + dataSource.getClass());
System.out.println("数据库连接实例:" + dataSource.getConnection());
//访问数据库user表,查询user表的数据量
Integer i = jdbcTemplate.queryForObject("SELECT count(*) from `student`", Integer.class);
System.out.println("user 表中共有" + i + "条数据。");

return "Success!"+i;
}
}

然后本地运行打开浏览器访问localhost:8081/Home/Kmo验证是否从远程数据库取得连接。
然后在application.yml中将url的服务器IP改成db

language-yaml
1
2
3
4
5
6
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://db:3306/test01?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: xxxx

然后maven打包成jar,参考文件夹结构,将jar放入指定位置。
将以下内容写入javaDocker.sh脚本并bash运行
脚本意思是,向名为MySQLTest01的容器建立网络链接(单向的),它的名字(IP,主机名)为db,于是此容器可以通过db:3306访问MySQLTest01容器的mysql服务。

language-bash
1
2
3
4
5
6
7
8
9
10
11
#!/bin/bash

containerName="JavaTest01"
SpringBootPath="/root/MyTest01/SpringBoot/MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar"

docker run -d --name "$containerName" \
-p 8081:8081 \
--link MySQLTest01:db \
-v "$SpringBootPath":/app/your-app.jar \
openjdk:17 java -jar /app/your-app.jar

开放云服务器安全组入站规则8081端口,浏览器访问云服务器IP:8081/Home/Kmo验证。

结束后记得关闭云服务器的3306入站规则

(完)