Java Kubernetes本地部署RuoYi框架jar包

在本地 Kubernetes 集群中部署 RuoYi 框架的 JAR 包是一个很好的实践，可以帮助你更好地理解和掌握 Kubernetes 的应用部署流程。以下是详细的步骤，指导你在本地 Kubernetes 集群中部署 RuoYi 框架的 JAR 包。

1. 准备环境

1.1 安装 Minikube 或 kind

首先，确保你已经安装了 Minikube 或 kind 来本地运行 Kubernetes 集群。这里以 Minikube 为例进行说明。

安装 kubectl：

1curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
2chmod +x kubectl
3sudo mv kubectl /usr/local/bin/
4

安装 Minikube：

1curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
2chmod +x minikube
3sudo mv minikube /usr/local/bin/
4

启动 Minikube：

1minikube start --driver=docker
2

2. 准备 RuoYi 框架的 JAR 包

2.1 构建 RuoYi 框架的 JAR 包

假设你已经有一个 RuoYi 框架的项目，需要构建 JAR 包。

构建 JAR 包：

1cd /path/to/ruoyi-project
2mvn clean package -DskipTests
3

找到生成的 JAR 包：构建完成后，JAR 包通常位于 target 目录下，例如 ruoyi.jar。

3. 创建 Docker 镜像

3.1 编写 Dockerfile

在 RuoYi 项目的根目录下创建一个 Dockerfile 文件，内容如下：

1# 使用官方的 OpenJDK 镜像作为基础镜像
2FROM openjdk:8-jdk-alpine
3
4# 设置工作目录
5WORKDIR /app
6
7# 将 JAR 包复制到容器中
8COPY target/ruoyi.jar /app/
9
10# 暴露应用的端口
11EXPOSE 8080
12
13# 启动应用
14ENTRYPOINT ["java", "-jar", "ruoyi.jar"]
15

3.2 构建 Docker 镜像

在项目根目录下运行以下命令来构建 Docker 镜像：

1docker build -t ruoyi:latest .
2

4. 部署到 Kubernetes

4.1 创建 Kubernetes 配置文件

4.1.1 创建 Deployment 配置文件

创建一个 ruoyi-deployment.yaml 文件，内容如下：

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: ruoyi
5spec:
6  replicas: 1
7  selector:
8    matchLabels:
9      app: ruoyi
10  template:
11    metadata:
12      labels:
13        app: ruoyi
14    spec:
15      containers:
16      - name: ruoyi
17        image: ruoyi:latest
18        ports:
19        - containerPort: 8080
20        env:
21        - name: SPRING_DATASOURCE_URL
22          value: "jdbc:mysql://<mysql-service-name>:3306/ruoyi?useUnicode=true&characterEncoding=utf8&useSSL=false"
23        - name: SPRING_DATASOURCE_USERNAME
24          value: "root"
25        - name: SPRING_DATASOURCE_PASSWORD
26          value: "password"
27        - name: SPRING_REDIS_HOST
28          value: "<redis-service-name>"
29        - name: SPRING_REDIS_PORT
30          value: "6379"
31        - name: SPRING_REDIS_PASSWORD
32          value: "password"
33

4.1.2 创建 Service 配置文件

创建一个 ruoyi-service.yaml 文件，内容如下：

1apiVersion: v1
2kind: Service
3metadata:
4  name: ruoyi
5spec:
6  selector:
7    app: ruoyi
8  ports:
9  - protocol: TCP
10    port: 8080
11    targetPort: 8080
12  type: NodePort
13

4.2 部署应用

应用 Deployment 和 Service：

1kubectl apply -f ruoyi-deployment.yaml
2kubectl apply -f ruoyi-service.yaml
3

验证部署：

1kubectl get pods
2kubectl get services
3

5. 访问应用

5.1 获取 NodePort

1kubectl get service ruoyi
2

输出类似于：

1NAME     TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
2ruoyi    NodePort   10.109.155.99   <none>        8080:30001/TCP   2m
3

5.2 访问应用

使用 minikube ip 获取 Minikube 的 IP 地址，然后通过 http://<minikube-ip>:30001 访问应用。

6. 配置数据库和 Redis

6.1 部署 MySQL

创建一个 mysql-deployment.yaml 文件，内容如下：

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: mysql
5spec:
6  replicas: 1
7  selector:
8    matchLabels:
9      app: mysql
10  template:
11    metadata:
12      labels:
13        app: mysql
14    spec:
15      containers:
16      - name: mysql
17        image: mysql:5.7
18        env:
19        - name: MYSQL_ROOT_PASSWORD
20          value: "password"
21        - name: MYSQL_DATABASE
22          value: "ruoyi"
23        ports:
24        - containerPort: 3306
25        volumeMounts:
26        - name: mysql-persistent-storage
27          mountPath: /var/lib/mysql
28      volumes:
29      - name: mysql-persistent-storage
30        emptyDir: {}
31---
32apiVersion: v1
33kind: Service
34metadata:
35  name: mysql
36spec:
37  selector:
38    app: mysql
39  ports:
40  - protocol: TCP
41    port: 3306
42    targetPort: 3306
43

应用配置：

1kubectl apply -f mysql-deployment.yaml
2

6.2 部署 Redis

创建一个 redis-deployment.yaml 文件，内容如下：

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: redis
5spec:
6  replicas: 1
7  selector:
8    matchLabels:
9      app: redis
10  template:
11    metadata:
12      labels:
13        app: redis
14    spec:
15      containers:
16      - name: redis
17        image: redis:5.0
18        ports:
19        - containerPort: 6379
20---
21apiVersion: v1
22kind: Service
23metadata:
24  name: redis
25spec:
26  selector:
27    app: redis
28  ports:
29  - protocol: TCP
30    port: 6379
31    targetPort: 6379
32

应用配置：

1kubectl apply -f redis-deployment.yaml
2

7. 更新 RuoYi 配置

确保 RuoYi 的配置文件中使用的数据库和 Redis 服务名称与 Kubernetes 中的服务名称一致。例如：

1spring:
2  datasource:
3    url: jdbc:mysql://mysql:3306/ruoyi?useUnicode=true&characterEncoding=utf8&useSSL=false
4    username: root
5    password: password
6  redis:
7    host: redis
8    port: 6379
9    password: password
10

8. 重新部署 RuoYi

重新构建 RuoYi 的 Docker 镜像并重新部署：

1docker build -t ruoyi:latest .
2kubectl delete deployment ruoyi
3kubectl apply -f ruoyi-deployment.yaml
4kubectl apply -f ruoyi-service.yaml
5

总结

通过以上步骤，你可以在本地 Kubernetes 集群中成功部署 RuoYi 框架的 JAR 包。这个过程不仅帮助你理解 Kubernetes 的基本概念和操作，还为你在生产环境中部署复杂应用打下了坚实的基础。

《Java Kubernetes本地部署RuoYi框架jar包》是转载文章，点击查看原文。