微服务之十四如何在 Ocelot 网关中配置多实例 Swagger 访问

一、介绍

 　　　　当我们开发基于微服务的应用程序的时候，有一个环节总是跳不过去的，那就是要创建 WebApi，然后，我们的应用程序基于 WebApi 接口去访问。在没有 Swagger 以前，我们开发好了 Web API 接口，也要写大量的接口文档。不写不行吗？当然不行，如果你不写这些文档，别人如何使用你的接口呢？难道每个接口都要和写接口的人进行沟通吗？那沟通成本就太大了，也浪费了不必要的时间。只从我们有了 Swagger 后，只需要简单的配置一下，就可以生成有关接口的详细文档，并且，可以调用执行，对于使用的人和开发的人都省去了不少力气。

　　　　但是，我们现在有一个问题，在我们的解决方案中，有多个 WebApi 的实例程序，并且每个 API 的实例程序都配置了自己的 Swagger ，方便使用。但是这样也出现了另外一个问题，我们有多个 API 实例程序，每个实例程序都对应一个 Swagger 程序，我们要访问的时候，该怎么操作呢？很多人就会说，访问哪个就打开哪个的 Swagger 程序，当然，如果你不怕繁琐，当然可以这么做。既然这么繁琐，别人也肯定遇到过，那针对这个问题，肯定就有相应的解决方案。

　　　　说起解决方案，其实，我们也很容易想起来。我们创建一个公共的、基于 WebAPI 的网关项目，在这个网关项目里，我们配置 Swagger，然后，通过访问网关的 Swagger 就可以访问各个 API 实例程序的 Swagger 。

二、开始我们

　　　　废话不多说，我们就开始，我们今天的配置和演示。这个解决方案的项目数不多，有3个 WEB API 的项目，他们都是基于 Net 5.0的，可以跨平台的。在这个解决方案中，由于我们要使用到服务发现和网关的配置，需要在各个需要的项目中引入 Consul、Swashbuckle.AspNetCore、 Ocelot 和 Ocelot.Provider.Consul 等项目。具体操作如下：

　　　　1、准备工作。

　　　　　　　　我们在开始我们的项目之前，需要现在 Consul，我这里下载的 Windows 64 位版本的，因为这个是测试的，如果在生产环境，可以根据需要下载 Linux 版本。

　　　　　　　　下载地址：https://www.consul.io/downloads

　　　　　　　　

　　　　　　　　启动Consul 服务的命令也很简单，在下载目录里面，在地址栏里输入：cmd回车，打开命令窗口。然后输入命令：consul agent -dev。截图如下：

 　　　　　　　　

 

　　　　2、项目源码

　　　　　　　　1】、第一个 WABAPI 实例程序。

 　　　　　　　　　　　　（1）、项目截图

　　　　　　　　　　　　　　　　

 

　　　　　　　　　　　　 （2）、项目源码

　　　　　　　　　　　　　　　　由于该项目使用了 Consul 进行服务发现管理，在项目创建之初，必须通过 Nuget 安装 Consul 组件，同时也必须引入 Swashbuckle.AspNetCore ，它支持对 Swagger 的实现。

　　　　　　　　　　　　　　　　A、创建一个 WebAPI 的项目，项目名称是：PatrickLiu.MicroService.WeiXin.UserService。

　　　　　　　　　　　　　　　　B、通过Nuget 分别引入：Consul 和 Swashbuckle.AspNetCore 组件包。

　　　　　　　　　　　　　　　　C、扩展 Consul 服务，在根目录下，创建一个 Utilities 文件，在该文件夹下创建一个类：ConsulManager.cs　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　

using Consul;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using System;

namespace PatrickLiu.MicroService.WeiXin.UserService.Utilities
{
    /// <summary>
    /// 该类型扩展了 IApplicationBuilder 类型，用于实现 Consul 的服务注册的工作。 
    /// </summary>
    public static class ConsulManager
    {
        /// <summary>
        /// 扩展方法，实现 WebApi 服务注册 Consul 中心。
        /// </summary>
        /// <param name="app">应用程序生成器。</param>
        /// <param name="configuration">配置系统的访问类型。</param>
        /// <param name="consulClient">Consul 的客户端类型。</param>
        /// <returns></returns>
        public static void UseConsul(this IApplicationBuilder app, IConfiguration configuration, IConsulClient consulClient)
        {
            RegisterConsul(configuration,consulClient);
        }

        /// <summary>
        /// 该方法实现核心的 Consul 注册和健康检查。
        /// </summary>
        /// <param name="configuration">配置系统的访问类型。</param>
        /// <param name="consulClient">Consul 的客户端类型。</param>
        private static void RegisterConsul(IConfiguration configuration, IConsulClient consulClient)
        {
            var consulGroupName = configuration["ConsulGroup"];
            var ip = configuration["IP"];
            var port = int.Parse(configuration["Port"]);
            var serviceID = $"{consulGroupName}_{ip}_{port}";

            AgentServiceCheck checkService = new AgentServiceCheck() {
                HTTP = $"http://{ip}:{port}/HeartCheck",
                Interval=TimeSpan.FromSeconds(6),
                Timeout=TimeSpan.FromSeconds(2),
                DeregisterCriticalServiceAfter=TimeSpan.FromSeconds(2)
            };

            AgentServiceRegistration agentServiceRegistration = new AgentServiceRegistration() {
                Name = consulGroupName,
                Address = ip,
                Port = port,
                ID = serviceID,
                Check= checkService
            };

            consulClient.Agent.ServiceRegister(agentServiceRegistration);
        }
    }
}

 　　　　　　　　　　　　　　　　D、在 appsettings.json 文件中，增加 Consul 的配置："ConsulGroup": "UserService"

　　　　　　　　　　　　　　　　　　　　

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConsulGroup": "UserService" //配置点
}

　　　　　　　　　　　　　　　　 E、配置 Startup.cs。

　　　　　　　　　　　　　　　　　　　　

using Consul;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
using System;
using PatrickLiu.MicroService.WeiXin.UserService.Utilities;

namespace PatrickLiu.MicroService.WeiXin.UserService
{
    /// <summary>
    /// dotnet PatrickLiu.MicroService.WeiXin.UserService.dll --urls="http://*:9156" --ip="127.0.0.1" --port=9156
    /// 
    /// dotnet PatrickLiu.MicroService.WeiXin.UserService.dll --urls="http://*:9157" --ip="127.0.0.1" --port=9157
    /// </summary>
    public class Startup
    {
        /// <summary>
        /// 通过构造函数注入配置访问的实例。
        /// </summary>
        /// <param name="configuration">配置访问器。</param>
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        /// <summary>
        /// 获取配置访问器的实例。
        /// </summary>
        public IConfiguration Configuration { get; }

        /// <summary>
        /// 注入的容器的服务实例。
        /// </summary>
        /// <param name="services"></param>
        public void ConfigureServices(IServiceCollection services)
        { 
            services.AddSingleton<IConsulClient>(c=> new ConsulClient(config=> {
                config.Datacenter = "dc1";
                config.Address =new Uri("http://localhost:8500");
            }));
            services.AddControllers();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("user", new OpenApiInfo { Title = "UserService", Version = "v1" });
            });
        }

        /// <summary>
        /// 配置 Http 请求的处理管道。
        /// </summary>
        /// <param name="app">应用程序生成器。</param>
        /// <param name="env">WebHost 环境。</param>
        /// <param name="consul">Consul 的客户端。</param>
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env,IConsulClient consul)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseSwagger();
            app.UseSwaggerUI(option=> {
                option.SwaggerEndpoint("/swagger/user/swagger.json", "UserService v1");
            });

            app.UseRouting();

            app.UseAuthorization();
            app.UseConsul(Configuration,consul);

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

　　　　　　　　　　　　　　　　 F、配置心跳服务的检查类型。

　　　　　　　　　　　　　　　　　　　　

using Microsoft.AspNetCore.Mvc;

namespace PatrickLiu.MicroService.WeiXin.UserService.Controllers
{
    /// <summary>
    /// 心跳检查的控制器。
    /// </summary>
    [Route("[controller]")]
    [ApiController]
    public class HeartCheckController : ControllerBase
    {
        /// <summary>
        /// 心跳检测的结果 。
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Get()
        {
            return Ok();
        }
    }
}

　　　　　　　　　　　　　　　　 G、扩展类型，为了对外区别是否进行了轮训，增加了一个端口 属性。

　　　　　　　　　　　　　　　　　　　　

using System;

namespace PatrickLiu.MicroService.WeiXin.UserService
{
    public class WeatherForecast
    {
        public DateTime Date { get; set; }

        public int TemperatureC { get; set; }

        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

        public string Summary { get; set; }

        public int Port { get; set; }//增加的属性
    }
}

　　　　　　　　　　　　　　　　 H、数据提供类型的控制器。

　　　　　　　　　　　　　　　　　　　　

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;

namespace PatrickLiu.MicroService.WeiXin.UserService.Controllers
{
    /// <summary>
    /// 获取天气的控制器。
    /// </summary>
    [ApiController]
    [Route("/user/[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        #region 私有字段

        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化类型的新实例。
        /// </summary>
        /// <param name="logger">初始化日志对象。</param>
        /// <param name="configuration">初始化配置对象。</param>
        public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
        {
            _logger = logger;
            Configuration = configuration;
        }

        #endregion

        #region 实例属性

        /// <summary>
        /// 获取配置对象。
        /// </summary>
        public IConfiguration Configuration { get; }

        #endregion

        #region 核心方法

        /// <summary>
        /// 获取天气。
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        {
            var rng = new Random();
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)],
                Port = int.Parse(Configuration["Port"])//增加的代码。
            })
            .ToArray();
        }

        #endregion
    }
}

　　　　　　　　　　　　 （3）、项目说明。

　　　　　　　　　　　　　　　　在 Startup.cs 文件里，我们配置Consul和 Swagger，具体的代码很简单，就不多说了。

　　　　　　　　　　　　　　　　该项目启动两个实例。启动代码如下：

　　　　　　　　　　　　　　　　dotnet PatrickLiu.MicroService.WeiXin.UserService.dll --urls="http://*:9157" --ip="127.0.0.1" --port=9157

　　　　　　　　　　　　　　　　

 

　　　　　　　　　　　　　　　　dotnet PatrickLiu.MicroService.WeiXin.UserService.dll --urls="http://*:9156" --ip="127.0.0.1" --port=9156

 　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　Consul 管理的服务。如图：

　　　　　　　　　　　　　　　　

 

　　　　　　　　2】、第二个 WEB API 实例程序。

 　　　　　　　　　　　　其实，第一个 WebAPI 项目和第二个 WebAPI 项目 是相同的，只是有一些配置的区别，没有本质的区别。

 　　　　　　　　　　　　（1）、项目截图

 　　　　　　　　　　　　　　　　

 

　　　　　　　　　　　　 （2）、项目源码

　　　　　　　　　　　　　　　　由于该项目使用了 Consul 进行服务发现管理，在项目创建之初，必须通过 Nuget 安装 Consul 组件，同时也必须引入 Swashbuckle.AspNetCore ，它支持对 Swagger 的实现。

　　　　　　　　　　　　　　　　A、创建一个 WebAPI 的项目，项目名称是：PatrickLiu.MicroService.WeiXin.ProductService。

　　　　　　　　　　　　　　　　B、通过Nuget 分别引入：Consul 和 Swashbuckle.AspNetCore 组件包。

　　　　　　　　　　　　　　　　C、扩展 Consul 服务，在根目录下，创建一个 Utilities 文件，在该文件夹下创建一个类：ConsulManager.cs。

　　　　　　　　　　　　　　　　　　　　　　

using Consul;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using System;

namespace PatrickLiu.MicroService.WeiXin.ProductService.Utilities
{
    /// <summary>
    /// Consul 的扩展类型，便于在 Http管道中注册 Consul。
    /// </summary>
    public static class ConsulManager
    {
        /// <summary>
        /// 注册 Consul 服务实例。
        /// </summary>
        /// <param name="app">应用程序生成器。</param>
        /// <param name="configuration">配置系统的访问器。</param>
        /// <param name="consulClient">Consul 的客户端类型。</param>
        /// <returns></returns>
        public static void UseConsul(this IApplicationBuilder app, IConfiguration configuration, IConsulClient consulClient)
        {
            RegisterConsul(configuration,consulClient);
        }

        /// <summary>
        /// 实现 Consul 的真正注册。
        /// </summary>
        /// <param name="configuration">配置系统的访问器。</param>
        /// <param name="consulClient">Consul 的客户端类型。</param>
        private static void RegisterConsul(IConfiguration configuration, IConsulClient consulClient)
        {
            var consulGroupName = configuration["ConsulGroup"];
            var ip = configuration["IP"];
            var port = int.Parse(configuration["Port"]);
            var serviceID = $"{consulGroupName}_{ip}_{port}";

            AgentServiceCheck checkService = new AgentServiceCheck() {
                HTTP = $"http://{ip}:{port}/HeartCheck",
                Interval=TimeSpan.FromSeconds(6),
                Timeout=TimeSpan.FromSeconds(2),
                DeregisterCriticalServiceAfter=TimeSpan.FromSeconds(2)
            };

            AgentServiceRegistration agentServiceRegistration = new AgentServiceRegistration() {
                Name = consulGroupName,
                Address = ip,
                Port = port,
                ID = serviceID,
                Check= checkService
            };

            consulClient.Agent.ServiceRegister(agentServiceRegistration);
        }
    }
}

 　　　　　　　　　　　　　　　　D、在 appsettings.json 文件中，增加 Consul 的配置："ConsulGroup": "ProductService"。

　　　　　　　　　　　　　　　　　　　　　 

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConsulGroup": "ProductService"//注册服务名称
}

　　　　　　　　　　　　　　　　 E、配置 Startup.cs。

　　　　　　　　　　　　　　　　　　　　　 

using Consul;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using PatrickLiu.MicroService.WeiXin.ProductService.Utilities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace PatrickLiu.MicroService.WeiXin.ProductService
{
    /// <summary>
    /// dotnet PatrickLiu.MicroService.WeiXin.ProductService.dll --urls="http://*:9158" --ip="127.0.0.1" --port=9158
    /// 
    /// dotnet PatrickLiu.MicroService.WeiXin.ProductService.dll --urls="http://*:9159" --ip="127.0.0.1" --port=9159
    /// </summary>
    public class Startup
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="configuration"></param>
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        /// <summary>
        /// 
        /// </summary>
        public IConfiguration Configuration { get; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="services"></param>
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton<IConsulClient>(new ConsulClient(c=> {
                c.Datacenter = "dc1";
                c.Address = new Uri("http://localhost:8500");
            }));

            services.AddSwaggerGen(a =>
            {
                a.SwaggerDoc("product", new Microsoft.OpenApi.Models.OpenApiInfo() { Title = "ProductService", Version = "v1" });
            });
            services.AddControllers();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="app"></param>
        /// <param name="env"></param>
        /// <param name="consul"></param>
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env,IConsulClient consul)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseConsul(Configuration,consul);

            app.UseSwagger();
            app.UseSwaggerUI(options=> {
                options.SwaggerEndpoint("/swagger/product/swagger.json", "ProductService-V1");
            });
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

　　　　　　　　　　　　　　　　 F、配置心跳服务的检查类型。

　　　　　　　　　　　　　　　　　　　　　 

using Microsoft.AspNetCore.Mvc;

namespace PatrickLiu.MicroService.WeiXin.ProductService.Controllers
{
    /// <summary>
    /// 心跳检查控制器。
    /// </summary>
    [Route("[controller]")]
    [ApiController]
    public class HeartCheckController : ControllerBase
    {
        /// <summary>
        /// 心跳检测方法。
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Get()
        {
            return Ok();
        }
    }
}

　　　　　　　　　　　　　　　

　　　　　　　　　　　　 （3）、项目说明。

　　　　　　　　　　　　　　　　在 Startup.cs 文件里，我们配置Consul和 Swagger，具体的代码很简单，就不多说了。

　　　　　　　　　　　　　　　　该项目启动两个实例。启动代码如下：

　　　　　　　　　　　　　　　　dotnet PatrickLiu.MicroService.WeiXin.ProductService.dll --urls="http://*:9158" --ip="127.0.0.1" --port=9158

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　dotnet PatrickLiu.MicroService.WeiXin.ProductService.dll --urls="http://*:9159" --ip="127.0.0.1" --port=9159

　　　　　　　　　　　　　　　　

 　　　　　　　　　　　　　　　　Consul 管理的产品服务。截图如下：

　　　　　　　　　　　　　　　　

 

　　　　　　　　3】、我们的 Ocelot 网关实例程序。

 　　　　　　　　　　　　这个项目是我们的关键先生，首先，我们在该项目中还是要引入 Ocelot、Ocelot.Provider.Consul 和 Swashbuckle.AspNetCore，引入完成后就开始我们的配置。

 　　　　　　　　　　　　（1）、项目截图

 　　　　　　　　　　　　　　　　

 

　　　　　　　　　　　　 （2）、项目源码

 　　　　　　　　　　　　　　　　A、创建一个 WebAPI 的项目，项目名称是：PatrickLiu.MicroService.WeiXin.Gateway。

　　　　　　　　　　　　　　　　 B、在 Startup 文件配置：Ocelot、Ocelot.Consul和 Swagger。

　　　　　　　　　　　　　　　　　　　　　　

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
using Ocelot.DependencyInjection;
using Ocelot.Middleware;
using Ocelot.Provider.Consul;

namespace PatrickLiu.MicroService.WeiXin.Gateway
{
    /// <summary>
    /// dotnet PatrickLiu.MicroService.WeiXin.Gateway.dll --urls="http://*:5000" --ip="127.0.0.1" --port=5000
    /// </summary>
    public class Startup
    {
        /// <summary>
        /// 通过构造函数注入配置系统。
        /// </summary>
        /// <param name="configuration">配置系统。</param>
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        /// <summary>
        /// 获取配置系统。
        /// </summary>
        public IConfiguration Configuration { get; }

        /// <summary>
        /// 注册服务。
        /// </summary>
        /// <param name="services"></param>
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSwaggerGen(c=> {
                c.SwaggerDoc("v1",new OpenApiInfo() { Title="Gateway API", Version="v1" });
            });
            services.AddOcelot().AddConsul();
            services.AddControllers();
        }

        /// <summary>
        /// 配置 Http 的请求处理管道和中间件。
        /// </summary>
        /// <param name="app">应用程序的生成器。</param>
        /// <param name="env">Web 宿主的环境。</param>
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();
            app.UseAuthorization();

            app.UseSwagger();
            //1、第一步，这里不需要以 /swagger 开头
            app.UseSwaggerUI(o => {
                o.SwaggerEndpoint("/user/swagger.json", "User-Service");
                o.SwaggerEndpoint("/product/swagger.json", "Product-Service");
            });

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });

            app.UseOcelot();
        }
    }
}

　　　　　　　　　　　　　　　　C、这是我们的重中之重，在 AppSettings 里面配置。　　

　　　　　　　　　　　　　　　　　　　　　　

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "Routes": [
    {
      "DownstreamPathTemplate": "/swagger/product/swagger.json", //下游配置也要和各自服务里面的配置一致。这是第二点
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/product/swagger.json", //上游配置，这里也不需要/swagger 开头，和网关配置一致。这是第二点
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ],
      "ServiceName": "ProductService",
      "UseServiceDiscovery": true
    },
    {
      "DownstreamPathTemplate": "/swagger/user/swagger.json", //下游配置也要和各自服务里面的配置一致。这是第二点
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/user/swagger.json", //上游配置，这里也不需要/swagger 开头，和网关配置一致。这是第二点
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ],
      "ServiceName": "UserService",
      "UseServiceDiscovery": true
    },
     //swagger 上配置
    {
      "DownstreamPathTemplate": "/user/{url}", //下游和上游配置都加上相同辨识符，才会访问自己服务的文件。这是第三点。
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/user/{url}", //下游和上游配置都加上相同辨识符，才会访问自己服务的文件。这是第三点。
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ],
      "ServiceName": "UserService",
      "LoadBalanceOptions": {
        "Type": "RoundRobin"
      },
      "UseServiceDiscovery": true
    },
    {
      "DownstreamPathTemplate": "/product/{url}", //下游和上游配置都加上相同辨识符，才会访问自己服务的文件。这是第三点。
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/product/{url}", //下游和上游配置都加上相同辨识符，才会访问自己服务的文件。这是第三点。
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ],
      "ServiceName": "ProductService",
      "LoadBalanceOptions": {
        "Type": "RoundRobin"
      },
      "UseServiceDiscovery": true
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:5000",
    "ServiceDiscoveryProvider": {
      "Host": "localhost",
      "Port": 8500,
      "Type": "Consul"
    }
  }
}

　　　　　　　　　　　　 （3）、项目说明。

　　　　　　　　　　　　　　　　在 Startup.cs 文件里，我们配置Consul和 Swagger，具体的代码很简单，就不多说了。

　　　　　　　　　　　　　　　　该项目启动一个实例。启动代码如下：

　　　　　　　　　　　　　　　　dotnet PatrickLiu.MicroService.WeiXin.Gateway.dll --urls="http://*:5000" --ip="127.0.0.1" --port=5000

 　　　　　　　　　　　　　　　　

 

　　　　3、效果如图

　　　　　　　　

 

　　　　4、关键点说明。

　　　　　　　　1】、在网关项目的 Startup.cs 文件的 ConfigServices和 Configure 配置。在 Configure 里面配置不需要以 /swagger 开头。切记。

        /// <summary>
        /// 注册服务。
        /// </summary>
        /// <param name="services"></param>
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSwaggerGen(c=> {
                c.SwaggerDoc("v1",new OpenApiInfo() { Title="Gateway API", Version="v1" });
            });
            services.AddOcelot().AddConsul();
            services.AddControllers();
        }    

        /// <summary>
        /// 配置 Http 的请求处理管道和中间件。
        /// </summary>
        /// <param name="app">应用程序的生成器。</param>
        /// <param name="env">Web 宿主的环境。</param>
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();
            app.UseAuthorization();

            app.UseSwagger();
            //1、第一步，这里不需要以 /swagger 开头
            app.UseSwaggerUI(o => {
19                 o.SwaggerEndpoint("/user/swagger.json", "User-Service");
20                 o.SwaggerEndpoint("/product/swagger.json", "Product-Service");
21             });

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });

            app.UseOcelot();
        }

　　　　　　　　　　　　如果这个网关只是单纯的做网关，可以把其他代码全部注释或者删掉，只是保留 services.AddOcelot().AddConsul() 和 app.UseOcelot() ，没问题。但是如果要在这里做Swagger 配置，就不能把其他代码注释。

　　　　　　　　2】、Swagger 上游配置，这里也不需要以/swagger 开头，和网关配置一致。下游配置也要和各自服务里面的配置一致。这是第二点。

　　　　　　　　　　　　

 

　　　　　　　　3】、Ocelot 路由配置：/下游和上游配置都加上相同辨识符，才会访问自己服务的文件。

 　　　　　　　　　　　　　A、网关中用户的服务配置要和API中 Controller 上的路由配置要一致。

　　　　　　　　　　　　　

　　　　　　　　　　　　

 　　　　　　　　　　　　B、网关中产品的服务配置要和API中 Controller 上的路由配置要一致。 　　　　　　　　　　　　

　　　　　　　　　　　　　
                  　　　　　  

 

三、总结

　　　　好了，今天就写到这里了。在网关中配置 Swagger ，就不用我们跳来跳去，去查看接口文档，便于我们的使用和维护，这个功能很实用，当初配置的时候有很多坑，我现在已经填的差不多了。俗话说，笨鸟先飞，把这东西记录下来，便于自己以后查阅，也许能帮助其他需要的人，都是不错的事情。不忘初心，我们继续努力。我们每天进步一点点，老天是不会辜负努力的人。