配置三个Spring Boot应用并通过Nginx进行反向代理讨论中

潇锐killer

已于 2024-07-30 15:29:36 修改

阅读量1.1k

点赞数 6

CC 4.0 BY-SA版权

文章标签： docker nginx

于 2024-07-23 15:22:56 首次发布

本文链接：https://blog.youkuaiyun.com/wangqiaowq/article/details/140637322

要配置三个Spring Boot应用并通过Nginx进行反向代理，你可以按照以下步骤操作：

步骤 1: 准备Spring Boot应用

确保每个Spring Boot应用都有不同的端口号。例如，你可以设置第一个应用监听8080端口，第二个监听8081端口，第三个监听8082端口。在每个应用的application.properties或application.yml中配置：

Properties

深色版本

1# 对于第一个应用
2server.port=8080
3
4# 对于第二个应用
5server.port=8081
6
7# 对于第三个应用
8server.port=8082

然后分别为每个应用构建Docker镜像，使用不同的Dockerfile或者在同一个Dockerfile中通过ARGs参数来区分不同应用的构建。

步骤 2: 准备Nginx配置

编辑Nginx配置文件，使每个Spring Boot应用都有自己的location块。例如：

Nginx

深色版本

1server {
2    listen       80;
3    server_name  localhost;
4    return       301 https://$host$request_uri;
5}
6
7server {
8    listen 443 ssl;
9    server_name example.com;
10
11    ssl_certificate /etc/nginx/ssl/server.crt;
12    ssl_certificate_key /etc/nginx/ssl/server.key;
13
14    location /app1/ {
15        proxy_pass http://app1:8080;
16        proxy_set_header Host $host;
17        proxy_set_header X-Real-IP $remote_addr;
18        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
19        proxy_set_header X-Forwarded-Proto $scheme;
20    }
21
22    location /app2/ {
23        proxy_pass http://app2:8081;
24        proxy_set_header Host $host;
25        proxy_set_header X-Real-IP $remote_addr;
26        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
27        proxy_set_header X-Forwarded-Proto $scheme;
28    }
29
30    location /app3/ {
31        proxy_pass http://app3:8082;
32        proxy_set_header Host $host;
33        proxy_set_header X-Real-IP $remote_addr;
34        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
35        proxy_set_header X-Forwarded-Proto $scheme;
36    }
37}

在这个配置中，/app1/, /app2/, 和 /app3/ 是访问各个应用的路径前缀。

步骤 3: 创建Docker Compose文件

在docker-compose.yml中定义所有服务：

Yaml

深色版本

1version: '3'
2
3services:
4  nginx:
5    image: nginx
6    container_name: nginx
7    ports:
8      - "80:80"
9      - "443:443"
10    volumes:
11      - ./nginx.conf:/etc/nginx/nginx.conf
12      - ./ssl:/etc/nginx/ssl
13    depends_on:
14      - app1
15      - app2
16      - app3
17
18  app1:
19    image: my-spring-boot-app1
20    container_name: app1
21    environment:
22      - SPRING_PROFILES_ACTIVE=docker
23    expose:
24      - "8080"
25
26  app2:
27    image: my-spring-boot-app2
28    container_name: app2
29    environment:
30      - SPRING_PROFILES_ACTIVE=docker
31    expose:
32      - "8081"
33
34  app3:
35    image: my-spring-boot-app3
36    container_name: app3
37    environment:
38      - SPRING_PROFILES_ACTIVE=docker
39    expose:
40      - "8082"

步骤 4: 部署

运行Docker Compose来启动服务：

Bash

深色版本

1docker-compose up -d

这样，你就有了三个通过Nginx反向代理的Spring Boot应用，每个应用都运行在不同的容器中，并且可以通过各自的路径前缀访问。记得确保SSL证书和私钥文件正确配置在ssl目录下。

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

我将为你展示如何使用Docker Compose结合一个简单的负载均衡器（如Nginx）来部署这三个Spring Boot服务节点在三台不同的机器上，并且使用一个单独的Nginx服务器来作为反向代理。

1. 准备工作

三台服务器：每台服务器上安装Docker。
一台Nginx服务器：这台服务器需要安装Docker和Nginx，并配置Docker Compose。

假设我们有四台服务器：server1、server2、server3 和 nginx-server。

2. 在每台服务器上创建 Docker Compose 文件

在每台服务器上创建一个docker-compose.yml文件。

示例 `docker-compose.yml` for `server1`, `server2`, and `server3`

Yaml

深色版本

1version: '3.8'
2
3services:
4  service:
5    build: .
6    image: springboot-service
7    container_name: service
8    ports:
9      - "8080:8080"

3. 配置 Nginx 反向代理

在nginx-server上创建一个docker-compose.yml文件来运行Nginx实例，并配置Nginx来反向代理到这三个Spring Boot服务节点。

示例 `docker-compose.yml` for `nginx-server`

Yaml

深色版本

1version: '3.8'
2
3services:
4  nginx:
5    image: nginx:latest
6    container_name: nginx
7    ports:
8      - "80:80"
9    volumes:
10      - ./nginx.conf:/etc/nginx/nginx.conf

4. 配置 Nginx 反向代理

创建一个nginx.conf文件在nginx-server上。

示例 `nginx.conf`

Nginx

深色版本

1user  nginx;
2worker_processes  1;
3
4error_log  /var/log/nginx/error.log warn;
5pid        /var/run/nginx.pid;
6
7events {
8    worker_connections  1024;
9}
10
11http {
12    include       /etc/nginx/mime.types;
13    default_type  application/octet-stream;
14
15    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
16                      '$status $body_bytes_sent "$http_referer" '
17                      '"$http_user_agent" "$http_x_forwarded_for"';
18
19    access_log  /var/log/nginx/access.log  main;
20
21    sendfile        on;
22    #tcp_nopush     on;
23
24    keepalive_timeout  65;
25
26    #gzip  on;
27
28    upstream backend {
29        server server1.example.com:8080;
30        server server2.example.com:8080;
31        server server3.example.com:8080;
32    }
33
34    server {
35        listen       80;
36        server_name  localhost;
37
38        location / {
39            proxy_pass http://backend;
40            proxy_set_header Host $host;
41            proxy_set_header X-Real-IP $remote_addr;
42            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
43            proxy_set_header X-Forwarded-Proto $scheme;
44        }
45
46        error_page   500 502 503 504  /50x.html;
47        location = /50x.html {
48            root   /usr/share/nginx/html;
49        }
50    }
51}

5. 部署服务

在每台服务器上执行以下命令来部署服务：

深色版本

1docker-compose up -d

6. 部署 Nginx

在nginx-server上执行以下命令来部署Nginx：

深色版本

1docker-compose up -d

注意事项：

确保你的Spring Boot服务能够通过网络互相通信，例如，你可能需要开放防火墙端口。
确保域名或者IP地址能够解析到正确的服务器上。
如果你的Spring Boot应用需要数据库或其他服务，也需要相应地部署在相应的服务器上，并确保服务之间的连接是安全的。
对于生产环境，考虑使用更强大的负载均衡解决方案，如HAProxy或更高级的Nginx配置。
如果需要进一步的高可用性和容错能力，考虑使用Kubernetes等编排工具来管理这些服务。

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

方式三：

使用Kubernetes来部署和管理Spring Boot应用和服务节点是非常常见的做法。下面我会指导你如何使用Kubernetes来部署三个Spring Boot服务节点和一个Nginx反向代理节点。

1. 准备工作

确保你有一个可用的Kubernetes集群。
安装kubectl并配置好集群环境。
准备好你的Spring Boot应用的Dockerfile。

2. 构建 Docker 镜像

构建Spring Boot应用的Docker镜像并推送到Docker Hub或私有仓库中。

示例 `Dockerfile`

Dockerfile

深色版本

1# 使用官方的Java运行时作为父镜像
2FROM openjdk:11-jdk-slim
3
4# 定义环境变量
5ARG JAR_FILE=target/my-app.jar
6
7# 将本地文件复制到容器中
8COPY ${JAR_FILE} app.jar
9
10# 声明运行时容器提供服务端口
11EXPOSE 8080
12
13# 指定容器启动程序及参数
14ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

3. 创建 Kubernetes Deployment 和 Service

对于每个Spring Boot服务，你需要创建一个Deployment和一个Service资源。

示例 `deployment.yaml` (为单个Spring Boot服务)

Yaml

深色版本

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

4. 创建 Nginx 反向代理

创建一个Nginx Deployment和Service来作为反向代理。

示例 `nginx-deployment.yaml`

Yaml

深色版本

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: nginx-proxy
5spec:
6  replicas: 1
7  selector:
8    matchLabels:
9      app: nginx-proxy
10  template:
11    metadata:
12      labels:
13        app: nginx-proxy
14    spec:
15      containers:
16      - name: nginx-proxy
17        image: nginx:latest
18        ports:
19        - containerPort: 80
20        volumeMounts:
21        - name: nginx-config
22          mountPath: /etc/nginx
23      volumes:
24      - name: nginx-config
25        configMap:
26          name: nginx-config
27---
28apiVersion: v1
29kind: Service
30metadata:
31  name: nginx-proxy
32spec:
33  selector:
34    app: nginx-proxy
35  ports:
36    - protocol: TCP
37      port: 80
38      targetPort: 80
39  type: LoadBalancer

示例 `nginx-configmap.yaml`

Yaml

深色版本

1apiVersion: v1
2kind: ConfigMap
3metadata:
4  name: nginx-config
5data:
6  nginx.conf: |-
7    user  nginx;
8    worker_processes  1;
9
10    error_log  /var/log/nginx/error.log warn;
11    pid        /var/run/nginx.pid;
12
13    events {
14        worker_connections  1024;
15    }
16
17    http {
18        include       /etc/nginx/mime.types;
19        default_type  application/octet-stream;
20
21        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
22                          '$status $body_bytes_sent "$http_referer" '
23                          '"$http_user_agent" "$http_x_forwarded_for"';
24
25        access_log  /var/log/nginx/access.log  main;
26
27        sendfile        on;
28        #tcp_nopush     on;
29
30        keepalive_timeout  65;
31
32        #gzip  on;
33
34        upstream backend {
35            server spring-boot-service-1:8080;
36            server spring-boot-service-2:8080;
37            server spring-boot-service-3:8080;
38        }
39
40        server {
41            listen       80;
42            server_name  localhost;
43
44            location / {
45                proxy_pass http://backend;
46                proxy_set_header Host $host;
47                proxy_set_header X-Real-IP $remote_addr;
48                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
49                proxy_set_header X-Forwarded-Proto $scheme;
50            }
51
52            error_page   500 502 503 504  /50x.html;
53            location = /50x.html {
54                root   /usr/share/nginx/html;
55            }
56        }
57    }

5. 部署

部署Spring Boot服务和Nginx反向代理。

深色版本

1kubectl apply -f deployment.yaml
2kubectl apply -f nginx-deployment.yaml
3kubectl apply -f nginx-configmap.yaml

6. 检查状态

检查Deployment和服务的状态。

深色版本

1kubectl get deployments
2kubectl get services

注意事项：

如果你希望在不同的节点上运行不同的Spring Boot服务，可以在Deployment中指定节点选择器(nodeSelector)或使用节点亲和性(nodeAffinity)。
对于生产环境，考虑使用Ingress资源来暴露服务，并利用Ingress Controller来处理HTTP(S)路由和TLS终止。
你可能还需要考虑Spring Boot应用之间的通信，比如服务发现和健康检查。
确保所有服务都有足够的资源限制和请求。

以上步骤应该可以帮助你将Spring Boot服务部署到Kubernetes集群中，并使用Nginx作为反向代理。