Easy-DotNET
  • NET微服务
  • 网关
一个大西瓜
2023-04-25
目录

Ocelot

开源地址

Github：https://github.com/ThreeMammals/Ocelot (opens new window)

Ocelot 是一个开源的 .NET Core 中间件，它可以帮助开发人员管理 API Gateway 的路由、请求过滤、请求转发等功能。它是基于 ASP.NET Core 2.2 开发的，因此它与 .NET Core 的整合非常紧密。 Ocelot 帮助开发人员实现分布式系统的 API 管理，并简化了其使用和管理。

# 为什么需要 API Gateway?

在分布式系统中，每个服务都会暴露出一组 API 接口，它们之间会互相调用。服务与服务之间的调用过程中，可能会存在以下问题：

  1. 每个服务都需要有一个独立的 IP 和端口，这会增加管理的复杂度。
  2. 随着服务数量的增加，每个服务之间的相互调用也变得越来越复杂。
  3. 如果某个服务的 API 发生了变更，其他服务的 API 也需要进行相应的调整。

API Gateway 就是为了解决这些问题而出现的。它将所有的请求都经过一个中心化的入口点，所有的服务请求都可以通过这个入口点进行访问。API Gateway 可以根据请求的 URL、HTTP 方法等信息，将请求路由到相应的服务上，并且可以进行请求过滤、请求转发等操作。通过 API Gateway，我们可以将服务间的复杂性进行抽象，从而降低了服务管理的复杂度。

# Ocelot 功能介绍

# 路由

Ocelot 可以通过路由配置，将请求路由到指定的服务上。路由的配置可以通过 JSON 或者 XML 配置文件进行配置。以下是一个基本的路由配置示例：


{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5000
        }
      ],
      "UpstreamPathTemplate": "/users/{everything}",
      "UpstreamHttpMethod": [ "GET" ]
    }
  ]
}

上述配置定义了一个路由规则，将 GET 请求的 /users/* 转发到 http://localhost:5000/api/*。

# 负载均衡

在微服务架构中，同一个服务可能会部署在多个实例上。为了保证高可用性和可扩展性，我们需要将请求均衡地分配到多个实例上。Ocelot 提供了负载均衡的支持，可以将请求发送到多个服务实例上。

Ocelot 支持以下几种负载均衡策略：

  1. 轮询（Round Robin）：将请求轮流分配到各个实例上。
  2. 随机（Random）：将请求随机分配到各个实例上。
  3. 最少连接（Least Connection）：将请求发送到当前连接数最少的实例上。
  4. 加权轮询（Weighted Round Robin）：根据实例的权重进行分配。
  5. 加权随机（Weighted Random）：根据实例的权重进行随机分配。

以下是一个基本的负载均衡配置示例：


{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/{everything}",
      "DownstreamScheme": "http",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      },
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5000
        },
        {
          "Host": "localhost",
          "Port": 5001
        }
      ],
      "UpstreamPathTemplate": "/users/{everything}",
      "UpstreamHttpMethod": [ "GET" ]
    }
  ]
}

上述配置定义了一个路由规则，将 GET 请求的 /users/* 转发到 http://localhost:5000/api/* 或者 http://localhost:5001/api/* 上。负载均衡策略为轮询。

# 请求转发

除了简单的路由之外，Ocelot 还提供了请求转发的功能。通过请求转发，我们可以在发送请求之前对请求进行处理，如修改请求头、修改请求体等。以下是一个请求转发的示例：


{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5000
        }
      ],
      "UpstreamPathTemplate": "/users/{everything}",
      "UpstreamHttpMethod": [ "POST" ],
      "AddHeadersToRequest": {
        "MyHeader": "MyValue"
      },
      "AddQueriesToRequest": {
        "MyQuery": "MyValue"
      },
      "Content": "{ \"name\": \"Test\" }"
    }
  ]
}

上述配置定义了一个路由规则，将 POST 请求的 /users/* 转发到 http://localhost:5000/api/* 上，并且在请求头中添加了 MyHeader: MyValue，在请求参数中添加了 MyQuery=MyValue，请求体为 { "name": "Test" }。

# 鉴权

在微服务架构中，鉴权是非常重要的一个环节。Ocelot 可以帮助我们对请求进行鉴权，以保证安全性。Ocelot 支持以下几种鉴权方式：

  1. 基于 JWT 的鉴权
  2. 基于 OAuth2 的鉴权
  3. 自定义鉴权

以下是一个基于 JWT 的鉴权示例：


{
    "Routes": [
    {
        "DownstreamPathTemplate": "/api/{everything}",
        "DownstreamScheme": "http",
        "DownstreamHostAndPorts": [
                {
                    "Host": "localhost",
                    "Port": 5000
                }
            ],
        "UpstreamPathTemplate": "/users/{everything}",
        "UpstreamHttpMethod": [ "GET" ],
        "AuthenticationOptions": {
            "AuthenticationProviderKey": "Jwt",
            "AllowedScopes": [ "api1.read" ]
        }
    }],

    "IdentityServer": {
        "Clients": {
            "MyClient": {
                "AccessTokenType": 0,
                "AccessTokenLifetime": 3600,
                "AllowedGrantTypes": [ "client_credentials" ],
                "ClientSecrets": [
                    {
                    "Value": "MySecret"
                    }
                ],
                "AllowedScopes": [ "api1.read", "api1.write" ]
            }
        },
        "ApiResources": [
            {
                "Name": "api1",
                "Scopes": [
                    { "Name": "api1.read", "DisplayName": "API 1 Read" },
                    { "Name": "api1.write", "DisplayName": "API 1 Write" }
                ]
            }
        ]
    },

    "JWTOptions": {
        "Issuer": "MyIssuer",
        "Audience": "MyAudience",
        "Key": "MyKey",
        "Type": "Bearer",
        "ValidationMode": "IssuerSigningKey",
        "ClockSkew": 300
    }
}

上述配置定义了一个路由规则，将 GET 请求的 /users/* 转发到 http://localhost:5000/api/* 上，并且需要进行 JWT 鉴权，鉴权方式为 Jwt。JWT 的配置信息在 JWTOptions 中，IdentityServer 的配置信息在 IdentityServer 中。

# 使用 Ocelot

接下来，我们来看一下如何使用 Ocelot。

# 安装 Ocelot

首先，我们需要安装 Ocelot 的 NuGet 包。在 Visual Studio 中，可以使用 NuGet 包管理器，或者使用命令行工具 dotnet add package Ocelot。

# 配置文件

接下来，我们需要配置 Ocelot。Ocelot 的配置文件可以使用 JSON 或者 XML 格式，以下是一个基本的 JSON 配置文件示例：

{
  "ReRoutes": [
    {
      "DownstreamPathTemplate": "/api/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPort": "localhost:5000",
      "UpstreamPathTemplate": "/users/{everything}",
      "UpstreamHttpMethod": [ "GET" ]
    }
  ]
}

上述配置定义了一个路由规则，将 GET 请求的 /users/* 转发到 http://localhost:5000/api/* 上。

# 启动 Ocelot

最后，我们需要在程序中启动 Ocelot。以下是一个基本的启动示例：


public class Program
{
    public static void Main(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .AddJsonFile("ocelot.json")
            .Build();

        var builder = new WebHostBuilder()
            .UseConfiguration(configuration)
            .ConfigureServices(s => s.AddOcelot())
            .Configure(app =>
            {
                app.UseOcelot().Wait();
            })
            .Build();

        builder.Run();
    }
}

以上代码读取了配置文件 ocelot.json，并在 WebHostBuilder中启用了 Ocelot 中间件。在ConfigureServices方法中，我们需要添加 Ocelot 的服务。在Configure 方法中，我们需要使用 Ocelot 中间件。

# 高级用法

除了基本的路由、负载均衡、请求转发和鉴权等功能之外，Ocelot 还提供了一些高级用法，如以下几种：

  1. 自定义中间件
  2. 自定义配置
  3. 扩展 Ocelot

在 Ocelot 中，可以通过自定义中间件的方式，对请求进行处理。例如，可以在请求转发之前进行日志记录、异常处理等操作。以下是一个自定义中间件的示例：


public class MyMiddleware : OcelotMiddleware
{
    public MyMiddleware(OcelotRequestDelegate next) : base(next)
    {
    }

    public async Task Invoke(DownstreamContext context)
    {
        // do something
        await Next.Invoke(context);
    }
}

在自定义中间件中，我们需要实现 Invoke 方法。在 Invoke 方法中，我们可以对请求进行处理，例如记录日志、进行异常处理等操作。

Ocelot 还支持自定义配置。在自定义配置中，我们可以添加自定义的 JSON 配置，或者添加额外的路由规则等。以下是一个自定义配置的示例：


public class MyConfiguration : IConfigurationProvider
{
    public async Task<IdentityServerConfiguration> GetIdentityServerConfiguration()
    {
        return new IdentityServerConfiguration();
    }

    public async Task<OcelotConfiguration> GetConfiguration()
    {
        return new OcelotConfiguration
        {
            Routes = new List<RouteConfiguration>
            {
                new RouteConfiguration
                {
                    DownstreamPathTemplate = "/api/{everything}",
                    DownstreamScheme = "http",
                    DownstreamHostAndPorts = new List<DownstreamHostAndPort>
                    {
                        new DownstreamHostAndPort
                        {
                            Host = "localhost",
                            Port = 5000
                        }
                    },
                    UpstreamPathTemplate = "/users/{everything}",
                    UpstreamHttpMethod = new List<string> { "GET" }
                }
            }
        };
    }

    public void Dispose()
    {
    }
}

在自定义配置中，我们需要实现 IConfigurationProvider 接口。在 GetConfiguration 方法中，我们可以返回自定义的路由规则等配置信息。

最后，Ocelot 还支持扩展。我们可以自定义路由规则、请求转发、负载均衡等功能。以下是一个自定义路由规则的示例：


public class MyRouteFinder : IRouteFinder
{
    public Task<List<DownstreamRoute>> FindDownstreamRoutes(HttpContext httpContext)
    {
        // do something
    }
}

在自定义路由规则中，我们需要实现 IRouteFinder 接口。在 FindDownstreamRoutes 方法中，我们可以根据请求信息，返回相应的路由规则。

# 总结

通过 Ocelot，我们可以简化分布式系统中的 API 管理。Ocelot 提供了路由、负载均衡、请求转发、鉴权等一系列功能，可以帮助我们快速地实现 API Gateway。同时，Ocelot 还支持自定义中间件、自定义配置和扩展等高级用法，可以满足不同场景的需求。

在使用 Ocelot 时，我们需要了解其基本配置和使用方法，可以通过 JSON 或者 XML 文件进行配置。同时，我们还可以通过自定义中间件、自定义配置和扩展等高级用法，来满足不同的需求。

虽然 Ocelot 目前还处于开发中，但是它已经具有了很多成熟的功能，并且在 .NET 社区中得到了广泛的应用。因此，我们可以放心地使用 Ocelot，来简化分布式系统的 API 管理。

上次更新: 2023/04/26, 22:10:06
Apollo
Kong

← Kong→

Theme by Vdoing | Copyright © 2019-2024 一个大西瓜 | MIT License | 苏ICP备2023013501号