实现一个行为类似于 nginx 的 Undertow 反向代理

Posted 2023-02-27

【中文标题】实现一个行为类似于 nginx 的 Undertow 反向代理

【英文标题】：Implement an Undertow reverse proxy that behaves like nginx

【发布时间】：2016-09-13 16:48:18

【问题描述】：

出于开发目的，并不是每个人都可以在他们的机器上安装 nginx（就像我们在 Windows 环境中的开发人员一样），但我们希望能够做一个行为类似于 nginx 的反向代理。

这是我们非常具体的案例：

我们在http://0.0.0.0:8081 上运行了一个 Spring Boot REST 服务 我们在http://0.0.0.0:8082 上运行了 Spring Boot Web 应用程序

我们希望通过http://0.0.0.0:8080 提供这两种服务

所以我们想这样映射它：

对http://0.0.0.0:8080/ 的请求被代理到http://0.0.0.0:8082 对http://0.0.0.0:8080/api 的请求被代理到http://0.0.0.0:8081

这样它就像 nginx 一样工作，带有 url 重写反向代理。

我查看了 Undertow 源代码和示例，甚至是这个特定示例：Reverse Proxy Example，但这是一个负载均衡器示例，我还没有找到任何满足我需要的示例。

另外，我知道 Undertow 能够做到这一点，因为我们知道我们可以通过 Undertow 组件配置配置 WildFly 以涵盖这种特定情况而不会出现问题，但我们希望自己实现它作为本地开发的轻量级解决方案。

有人知道这样做的例子吗？或任何有足够信息来实现这一点的文档？因为我还阅读了 Undertow 关于反向代理的文档，它根本没有帮助。

谢谢

【问题讨论】：

为什么不简单地使用 Zuul 代理来做到这一点。 Windows 用户也完全可以使用running nginx。多次使用它（用于测试目的）并且像魅力一样工作。

听起来不错，但我们想以此作为学习经验，而且，如果我们将此反向代理作为模块添加到 Gradle 项目中，则开发人员无需进行任何配置在他们的机器上，因为代理将包含在那里。

他们仍然需要启动它，并且您始终可以创建一个 gradle taks 来下载、解压缩、配置 nginx 代理。或者使用虚拟机和/或 docker。但是由于您已经在使用 Spring Boot，因此添加 Zuul 代理应该很容易。

是的，我实际上正在研究 Zuul Spring Boot 组件而不是 Undertow，因此感谢您的建议，这样我们可以通过 this tutorial 在 Spring Boot 中添加 Zuul，而不是试图弄清楚是否Undertow 是有能力的，Zuul 也是专门为代理而设计的，因此对于这种特定情况，它是比我们用于其他服务的 Undertow 更强大的解决方案。添加此评论作为解决方案，以便我可以接受它作为答案，我的好人 +1 :)

【参考方案1】：

根据 M. Deinum 的评论建议，我将使用 Zuul Spring Boot 组件而不是尝试使用 Undertow 执行此操作，因为它更适合此任务。

这里有一个教程链接：

https://spring.io/guides/gs/routing-and-filtering/

希望这对其他人有帮助，因为这是很常见的情况，而且我不知道 Spring Boot 上的 Zuul。

【参考方案2】：

这应该可以完成工作。

它是 Java8，因此某些部分可能不适用于您的设置。

您可以使用与您在问题中提到的the example 类似的方式启动它。

package com.company

import com.google.common.collect.ImmutableMap;
import io.undertow.client.ClientCallback;
import io.undertow.client.ClientConnection;
import io.undertow.client.UndertowClient;
import io.undertow.server.HttpServerExchange;
import io.undertow.server.ServerConnection;
import io.undertow.server.handlers.proxy.ProxyCallback;
import io.undertow.server.handlers.proxy.ProxyClient;
import io.undertow.server.handlers.proxy.ProxyConnection;
import org.xnio.IoUtils;
import org.xnio.OptionMap;

import java.io.IOException;
import java.net.URI;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Start the ReverseProxy with an ImmutableMap of matching endpoints and a default
 * 
 * Example:
 * mapping: ImmutableMap("api" -> "http://some-domain.com")
 * default: "http://default-domain.com"
 * 
 * Request 1: localhost:8080/foo -> http://default-domain.com/foo
 * Request 2: localhost:8080/api/bar -> http://some-domain.com/bar
 */

public class ReverseProxyClient implements ProxyClient 
    private static final ProxyTarget TARGET = new ProxyTarget() ;

    private final UndertowClient client;
    private final ImmutableMap<String, URI> mapping;
    private final URI defaultTarget;

    public ReverseProxyClient(ImmutableMap<String, URI> mapping, URI defaultTarget) 
        this.client = UndertowClient.getInstance();
        this.mapping = mapping;
        this.defaultTarget = defaultTarget;
    

    @Override
    public ProxyTarget findTarget(HttpServerExchange exchange) 
        return TARGET;
    

    @Override
    public void getConnection(ProxyTarget target, HttpServerExchange exchange, ProxyCallback<ProxyConnection> callback, long timeout, TimeUnit timeUnit) 
        URI targetUri = defaultTarget;

        Matcher matcher = Pattern.compile("^/(\\w+)(/.*)").matcher(exchange.getRequestURI());
        if (matcher.find()) 
            String firstUriSegment = matcher.group(1);
            String remaininguri = matcher.group(2);
            if (mapping.containsKey(firstUriSegment)) 
                // If the first uri segment is in the mapping, update the targetUri
                targetUri = mapping.get(firstUriSegment);
                // Strip the request uri from the part that is used to map upon.
                exchange.setRequestURI(remaininguri);
            
        

        client.connect(
            new ConnectNotifier(callback, exchange),
            targetUri,
            exchange.getIoThread(),
            exchange.getConnection().getByteBufferPool(),
            OptionMap.EMPTY);
    

    private final class ConnectNotifier implements ClientCallback<ClientConnection> 
        private final ProxyCallback<ProxyConnection> callback;
        private final HttpServerExchange exchange;

        private ConnectNotifier(ProxyCallback<ProxyConnection> callback, HttpServerExchange exchange) 
            this.callback = callback;
            this.exchange = exchange;
        

        @Override
        public void completed(final ClientConnection connection) 
            final ServerConnection serverConnection = exchange.getConnection();
            serverConnection.addCloseListener(serverConnection1 -> IoUtils.safeClose(connection));
            callback.completed(exchange, new ProxyConnection(connection, "/"));
        

        @Override
        public void failed(IOException e) 
            callback.failed(exchange);