使用YARP來實現負載均衡

黄明基發表於2024-11-25
負載

YARP (“Yet Another Reverse Proxy”) 是一個庫，可幫助建立高效能、生產就緒且高度可自定義的反向代理伺服器。

YARP 是使用 ASP.NET 和 .NET（.NET 6 及更高版本）的基礎結構在 .NET 上構建的，旨在透過 .NET 程式碼輕鬆自定義和調整，以滿足每個部署方案的特定需求。所以，它支援配置檔案，也可以基於自己的後端配置管理系統以程式設計方式管理配置。

許多現有代理都是為了支援 HTTP/1.1 而構建的，但隨著工作負載更改為包括 gRPC 流量，它們需要 HTTP/2 支援，這需要更復雜的實現。透過使用 YARP，專案可以自定義路由和處理行為，而不必實現 http 協議。

同類應用

YARP 的主要用途是負載均衡，它將請求路由到後端伺服器，並根據負載均衡策略（如輪詢、隨機、權重等）將請求分發到後端伺服器。目前流行的同類應用有 Nginx、HAProxy 等。

https://stargazer.tech/2024/11/25/use-YARP-for-load-balancing/load-balancing.png

YARP 是在 .NET Core 基礎結構之上實現的，可在 Windows、Linux 或 MacOS 上使用。 可以使用 SDK 和您最喜歡的編輯器 Microsoft Visual Studio 或 Visual Studio Code 進行開發。

建立新專案

使用以下步驟生成的專案的完整版本可在基本 YARP 示例中找到。
首先，使用命令列建立一個 “Empty” ASP.NET Core 應用程式：

dotnet new web -n MyProxy -f net8.0

新增專案引用

dotnet add package Yarp.ReverseProxy

新增 YARP 中介軟體

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));
var app = builder.Build();
app.MapReverseProxy();
app.Run();

配置

YARP 的配置在 appsettings.json 檔案中定義。有關詳細資訊，請參閱配置檔案。
還可以透過程式設計方式提供配置。有關詳細資訊，請參閱 配置提供程式。
您可以透過檢視 RouteConfig 和 ClusterConfig 來了解有關可用配置選項的更多資訊。

{
 "Logging": {
   "LogLevel": {
     "Default": "Information",
     "Microsoft": "Warning",
     "Microsoft.Hosting.Lifetime": "Information"
   }
 },
 "AllowedHosts": "*",
 "ReverseProxy": {
   "Routes": {
     "route1" : {
       "ClusterId": "cluster1",
       "Match": {
         "Path": "{**catch-all}"
       }
     }
   },
   "Clusters": {
     "cluster1": {
       "Destinations": {
         "destination1": {
           "Address": "https://example.com/"
         }
       }
     }
   }
 }
}

執行專案

dotnet run --project <path to .csproj file>

其他配置

我們建立了一個完整的YARP專案，可在Github上找到：Gateways

負載均衡

建立了兩個路由，baidu-route 和 example-route，分別對應百度和example.com。當使用localhost和127.0.0.1訪問時，將請求轉發到對應的後端伺服器。有關詳細資訊，請參閱負載均衡。

{
  "ReverseProxy": {
    "Routes": {
      "baidu-route" : {
        "ClusterId": "baidu-cluster",
        "Match": {
          "Path": "{**catch-all}",
          "Hosts": [ "localhost:5000" ]
        }
      },
      "example-route" : {
        "ClusterId": "example-cluster",
        "Match": {
          "Path": "{**catch-all}",
          "Hosts": [ "127.0.0.1:5000" ]
        },
      }
    },
    "Clusters": {
      "baidu-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://www.baidu.com/"
          }
        }
      },
      "example-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://example.com/"
          }
        }
      }
    }
  }
}

快取

反向代理可用於快取代理響應，並在請求代理到目標伺服器之前提供請求。這可以減少目標伺服器上的負載，增加一層保護，並確保在應用程式中實施一致的策略。此功能僅在使用 .NET 7.0 或更高版本時可用。有關詳細資訊，請參閱輸出快取。
輸出快取策略可以在 Program.cs 中配置，如下所示：

#region cache

string defaultCachePolicyName = "DefaultCache";
builder.Services.AddOutputCache(options =>
{
    string expire = configuration["App:CacheExpire"] ?? "20";
    int expireSeconds = int.Parse(expire);
    options.AddPolicy("NoCache", build => build.NoCache());
    options.AddPolicy(defaultCachePolicyName, build => build.Expire(TimeSpan.FromSeconds(20)));
    options.AddPolicy("CustomCache", build => build.Expire(TimeSpan.FromSeconds(expireSeconds)));
});

#endregion

app.UseOutputCache();

增加OutputCachePolicy配置到路由中，如：

"baidu-route" : {
  "ClusterId": "baidu-cluster",
  "Match": {
    "Path": "{**catch-all}",
    "Hosts": [ "localhost:5000" ]
  },
  "OutputCachePolicy": "DefaultCache",
},

OutputCachePolicy值為：DefaultCache時，則使用預設快取策略，快取20秒。如：CustomCache，則使用自定義快取策略， 自定義快取時間， 讀取配置檔案App:CacheExpire。如果沒有配置，或者配置NoCache，則不使用快取功能。

限流

反向代理可用於在將請求代理到目標伺服器之前對請求進行速率限制。這可以減少目標伺服器上的負載，增加一層保護，並確保在應用程式中實施一致的策略。此功能僅在使用 .NET 7.0 或更高版本時可用。有關詳細資訊，請參閱RateLimiter。
RateLimiter 策略可以在 Program.cs 中配置，如下所示：


#region rate limiter

string defaultRateLimiterPolicyName = "DefaultRateLimiter";
builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter(defaultRateLimiterPolicyName, opt =>
    {
        opt.PermitLimit = 4;
        opt.Window = TimeSpan.FromSeconds(12);
        opt.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        opt.QueueLimit = 2;
    });
    options.AddFixedWindowLimiter("CustomRateLimiter", opt =>
    {
        opt.PermitLimit = rateLimitOptions.PermitLimit;
        opt.Window = TimeSpan.FromSeconds(rateLimitOptions.Window);
        opt.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        opt.QueueLimit = rateLimitOptions.QueueLimit;
    });
});

#endregion

app.UseRateLimiter();

增加RateLimiterPolicy配置到路由中，如：


"CustomRateLimit": {
  "PermitLimit": 100,
  "Window": 10,
  "QueueLimit": 2
},


"baidu-route" : {
  "ClusterId": "baidu-cluster",
  "Match": {
    "Path": "{**catch-all}",
    "Hosts": [ "localhost:5000" ]
  },
  "RateLimiterPolicy": "DefaultRateLimiter"
},

RateLimiterPolicy值為：DefaultRateLimiter時，則使用預設限流策略，每12秒，最多允許4個請求。如：CustomRateLimiter，則使用自定義限流策略，自定義限流策略， 讀取配置檔案CustomRateLimit。如果沒有配置，則不使用限流功能。

請求超時

超時和超時策略可以透過 RouteConfig 為每個路由指定，並且可以從配置檔案的各個部分進行繫結。與其他路由屬性一樣，可以在不重新啟動代理的情況下修改和重新載入此屬性。有關詳細資訊，請參閱請求超時。
超時策略可以在 Program.cs 中配置，如下所示：

#region timeouts
builder.Services.AddRequestTimeouts(options => { options.AddPolicy("CustomPolicy", TimeSpan.FromSeconds(30)); });
#endregion

app.UseRequestTimeouts();

30秒為自定義超時時間。
增加TimeoutPolicy配置到路由中，亦可以直接配置Timeout，如：

"baidu-route" : {
  "ClusterId": "baidu-cluster",
  "Match": {
    "Path": "{**catch-all}",
    "Hosts": [ "localhost:5000" ]
  },
  "Timeout": "00:00:30"
},
"example-route" : {
  "ClusterId": "example-cluster",
  "Match": {
    "Path": "{**catch-all}",
    "Hosts": [ "127.0.0.1:5000" ]
  },
  "TimeoutPolicy": "CustomPolicy"
}

TimeoutPolicy和Timeout不可同時配置到同一個路由上面。

跨域

反向代理可以在跨域請求被代理到目標伺服器之前處理這些請求。這可以減少目標伺服器上的負載，並確保在應用程式中實施一致的策略。有關詳細資訊，請參閱跨域請求（CORS）。
跨域策略可以在 Program.cs 中配置，如下所示：

#region CORS

string defaultCorsPolicyName = "DefaultCors";
builder.Services.AddCors(options =>
{
    options.AddPolicy(defaultCorsPolicyName, policy =>
    {
        string corsOrigins = configuration["App:CorsOrigins"] ?? "";
        if (!string.IsNullOrWhiteSpace(corsOrigins))
        {
            string[] origins = corsOrigins.Split(",", StringSplitOptions.RemoveEmptyEntries)
                .Select(x => x.Trim())
                .Select(x =>
                {
                    return x.EndsWith("/", StringComparison.Ordinal) ? x.Substring(0, x.Length - 1) : x;
                }).ToArray();

            policy = policy.WithOrigins(origins);
        }
        else
        {
            policy = policy.AllowAnyOrigin();
        }

        policy.SetIsOriginAllowedToAllowWildcardSubdomains()
            .AllowAnyHeader()
            .AllowAnyMethod()
            .AllowCredentials();
    });
});

#endregion

app.UseCors();

增加CorsPolicy配置到路由中，如：

"baidu-route" : {
  "ClusterId": "baidu-cluster",
  "Match": {
    "Path": "{**catch-all}",
    "Hosts": [ "localhost:5000" ]
  },
"CorsPolicy": "DefaultCors"
},

CorsPolicy值為：DefaultCors時，則使用預設跨域策略。讀取配置檔案App:CorsOrigins。如果沒有配置，則不使用跨域策略。

HTTPS

HTTPS（HTTP over TLS 加密連線）是出於安全性、完整性和隱私原因在 Internet 上發出 HTTP 請求的標準方式。使用反向代理（如 YARP）時，需要考慮幾個 HTTPS/TLS 注意事項。
YARP 是 7 級 HTTP 代理，這意味著傳入的 HTTPS/TLS 連線由代理完全解密，因此它可以處理和轉發 HTTP 請求。這通常稱為 TLS 終止。到目標的傳出連線可能加密，也可能不加密，具體取決於提供的配置。
有關詳細資訊，請參閱HTTPS。

builder.WebHost.ConfigureKestrel(kestrel =>
{
    kestrel.ListenAnyIP(80);
    kestrel.ListenAnyIP(443);
});

app.UseHsts();
app.UseHttpsRedirection();

自動生成HTTPS證書

YARP 可以透過使用另一個 ASP.NET Core 專案 LettuceEncrypt 的 API 來支援證書頒發機構 Lets Encrypt。它允許您以最少的配置在客戶端和 YARP 之間設定 TLS。有關詳細資訊，請參閱LettuceEncrypt。

builder.Services.AddLettuceEncrypt()
            .PersistDataToDirectory(new DirectoryInfo(Path.Combine(env.ContentRootPath, "certs")), "");
builder.WebHost.ConfigureKestrel(kestrel =>
{
    kestrel.ListenAnyIP(80);
    kestrel.ListenAnyIP(443,
        portOptions => { portOptions.UseHttps(h => { h.UseLettuceEncrypt(kestrel.ApplicationServices); }); });
});

"LettuceEncrypt": {
  "AcceptTermsOfService": true,
  "DomainNames": [
    "example.com"
  ],
  "EmailAddress": "it-admin@example.com"
}

DomainNames為域名，EmailAddress為郵箱地址。

使用中介軟體實現waf

ASP.NET Core 使用中介軟體管道將請求處理劃分為離散的步驟。應用程式開發人員可以根據需要新增和訂購中介軟體。ASP.NET Core 中介軟體還用於實現和自定義反向代理功能。
反向代理IEndpointRouteBuilderExtensions 提供了一個過載，允許您構建一箇中介軟體管道，該管道將僅針對與代理配置的路由匹配的請求執行。有關詳細資訊，請參閱Middleware。

app.MapReverseProxy(proxyPipeline =>
{
    proxyPipeline.Use((context, next) =>
    {
        // Custom inline middleware

        return next();
    });
    proxyPipeline.UseSessionAffinity();
    proxyPipeline.UseLoadBalancing();
    proxyPipeline.UsePassiveHealthChecks();
});

如果我們的應用對安全性驗證要求比較高的話，我們可以使用中介軟體來實現waf。透過中介軟體對請求進行驗證，比如新建一個WafMiddleware類：

namespace StargazerGateway;

public static class WafMiddleware
{
    public static void UseWaf(this IReverseProxyApplicationBuilder proxyPipeline)
    {
        proxyPipeline.Use((context, next) =>
        {
            if (!CheckServerDefense(context))
            {
                context.Response.StatusCode = 444;
                return context.Response.WriteAsync("I catch you!");
            }
            return next();
        });
    }

    private static bool CheckServerDefense(HttpContext context)
    {
        if(!CheckHeader(context)) return false;
        if(!CheckQueryString(context)) return false;
        if(!CheckBody(context)) return false;
        return true;
    }

    private static bool CheckHeader(HttpContext context)
    {
        // TODO: 檢查請求頭是否包含敏感詞
        return true;
    }

    private static bool CheckQueryString(HttpContext context)
    {
        if(context.Request.Query.ContainsKey("base64_encode")
           || context.Request.Query.ContainsKey("base64_decode")
           || context.Request.Query.ContainsKey("WEB-INF")
           || context.Request.Query.ContainsKey("META-INF")
           || context.Request.Query.ContainsKey("%3Cscript%3E")
           || context.Request.Query.ContainsKey("%3Ciframe")
           || context.Request.Query.ContainsKey("%3Cimg")
           || context.Request.Query.ContainsKey("proc/self/environ")
           || context.Request.Query.ContainsKey("mosConfig_"))
        {
            return false;
        }
        // TODO: 檢查請求引數是否包含敏感詞
        return true;
    }

    private static bool CheckBody(HttpContext context)
    {
        if (context.Request.Method == "POST"
            || context.Request.Method == "PUT"
            || context.Request.Method == "PATCH")
        {
            // TODO: 讀取請求體, 判斷是否包含敏感詞
            // 重置請求體
            context.Request.Body.Seek(0, SeekOrigin.Begin);
            return true;
        }

        return  true;
    }
}

然後在反向代理中新增中介軟體：

app.MapReverseProxy(proxyPipeline =>
{
    proxyPipeline.UseWaf();
    proxyPipeline.UseSessionAffinity();
    proxyPipeline.UseLoadBalancing();
    proxyPipeline.UsePassiveHealthChecks();
});

中介軟體在呼叫時，會先檢查請求頭、請求引數、請求體，如果包含敏感詞，則返回444狀態碼，表示請求被攔截。當然這些都會產生額外的開銷，影響效能。因此需要根據實際情況進行最佳化。

首發網站：https://stargazer.tech/2024/11/25/use-YARP-for-load-balancing/
相關連結

  1. Microsoft Visual Studio: https://visualstudio.microsoft.com/vs/
  2. Visual Studio Code: https://code.visualstudio.com/
  3. YARP 示例 https://github.com/microsoft/reverse-proxy/tree/release/latest/samples/BasicYarpSample
  4. YARP 文件 https://microsoft.github.io/reverse-proxy/
  5. YARP 配置 https://microsoft.github.io/reverse-proxy/articles/config-files.html
  6. RouteConfig https://microsoft.github.io/reverse-proxy/api/Yarp.ReverseProxy.Configuration.RouteConfig.html
  7. ClusterConfig https://microsoft.github.io/reverse-proxy/api/Yarp.ReverseProxy.Configuration.ClusterConfig.html
  8. Gateways https://github.com/huangmingji/Stargazer.Abp.Template/tree/main/models/Gateways
  9. 負載均衡 https://microsoft.github.io/reverse-proxy/articles/load-balancing.html
  10. 輸出快取 https://microsoft.github.io/reverse-proxy/articles/output-caching.html
  11. RateLimiter https://microsoft.github.io/reverse-proxy/articles/rate-limiting.html
  12. 請求超時 https://microsoft.github.io/reverse-proxy/articles/timeouts.html
  13. 跨域請求（CORS）https://microsoft.github.io/reverse-proxy/articles/cors.html
  14. HTTPS https://microsoft.github.io/reverse-proxy/articles/https-tls.html
  15. LettuceEncrypt https://microsoft.github.io/reverse-proxy/articles/lets-encrypt.html
  16. Middleware https://microsoft.github.io/reverse-proxy/articles/middleware.html

相關文章