.net core ocelot+consul+jwt 身份验证，服务治理与发现，网关配置(二)增加consul

上一篇 搞了那么多还没有加上consul 这一篇加上consul

consul 的功能 服务治理与发现 ， 如果 服务越来越多那么 配置也越来越多 能不能把服务地址统一，然后统一从这个地址访问就行了 这就是consul的作用

上一篇 忘说了ocelot 有负载均衡的配置忘说了 

LeastConnection - 最少连接，跟踪哪些服务正在处理请求，并把新请求发送到现有请求最少的服务上。该算法状态不在整个Ocelot集群中分布。

RoundRobin - 轮询可用的服务并发送请求。 该算法状态不在整个Ocelot集群中分布。

NoLoadBalancer - 不负载均衡，从配置或服务发现提供程序中取第一个可用的下游服务。

这次补上 路由配置

LeastConnection 最小连接数

 "LoadBalancerOptions": {
        "Type": "LeastConnection"
    },

下面进入正题

consul 官网上下一个

Install | Consul | HashiCorp Developer

 

 windows下 consul 有开发模式 不能持久化 有server模式可以持久化 这里快速搞 就开发模式吧

consul agent -dev

 新增项目

 

运行和停止 Agent
Consul agent 是 Consul 的核心:它运行 agent，执行维护成员信息、运行 check、通知 service、处理 queries 等的重要任务。Agent 必须在作为 Consul 集群一部分运行于每个节点上。

Agent 有两种模式:client 或 server。

Server 要参与 consensus quorum，当遇到故障情况时，这些节点通过 Raft 提供强一致性和强有效性，在 Server 节点上的较高负载意味着它们应该运行在专属的实例 —— 它们比 client 节点更为资源密集型。在整个集群中，绝大部分都为 Client 节点。

client 把所有的 RPCs 请求转发到 server 端，是相对无状态的。唯一在后台运行的时 client 端执行了 LAN gossip pool，只消耗极少的资源和网络带宽。

Running an Agent
Agent 通过执行 consul agent 启动。这个命令是阻塞的，除非主动终止。Agent 命令需要很多配置参数，但大多数都有默认值。
————————————————
版权声明：本文为CSDN博主「阳光倾洒」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/quanzhan_King/article/details/131469063

 

ConsulAgent是Consul的核心进程，Agent的工作是维护成员关系信息、注册服务、健康检查、响应查询等等。Consul集群的每一个节点都必须运行agent进程。

Agent有两种模式：client或server。

Server要参与consensus quorum，当遇到故障情况时，这些节点通过Raft提供强一致性和强有效性，在Server节点上的较高负载意味着它们应该运行在专属的实例——它们比客户端节点更为资源密集型。在整个集群中，绝大部分都为Client节点。

client把所有的RPCs转发到server端，是相对无状态的。唯一在后台运行的时client端执行了LAN gossip pool，只消耗极少的资源和网络带宽。
————————————————
版权声明：本文为CSDN博主「YoungerChina」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/younger_china/article/details/52255005

 

Agent——agent是一直运行在Consul集群中每个成员上的守护进程。通过运行 consul agent 来启动。agent可以运行在client或者server模式。指定节点作为client或者server是非常简单的，除非有其他agent实例。所有的agent都能运行DNS或者HTTP接口，并负责运行时检查和保持服务同步。
Client——一个Client是一个转发所有RPC到server的代理。这个client是相对无状态的。client唯一执行的后台活动是加入LAN gossip池。这有一个最低的资源开销并且仅消耗少量的网络带宽。
Server——一个server是一个有一组扩展功能的代理，这些功能包括参与Raft选举，维护集群状态，响应RPC查询，与其他数据中心交互WAN gossip和转发查询给leader或者远程数据中心。
DataCenter——虽然数据中心的定义是显而易见的，但是有一些细微的细节必须考虑。例如，在EC2中，多个可用区域被认为组成一个数据中心？我们定义数据中心为一个私有的，低延迟和高带宽的一个网络环境。这不包括访问公共网络，但是对于我们而言，同一个EC2中的多个可用区域可以被认为是一个数据中心的一部分。
Consensus——在我们的文档中，我们使用Consensus来表明就leader选举和事务的顺序达成一致。由于这些事务都被应用到有限状态机上，Consensus暗示复制状态机的一致性。
Gossip——Consul建立在Serf的基础之上，它提供了一个用于多播目的的完整的gossip协议。Serf提供成员关系，故障检测和事件广播。更多的信息在gossip文档中描述。这足以知道gossip使用基于UDP的随机的点到点通信。
LAN Gossip——它包含所有位于同一个局域网或者数据中心的所有节点。
WAN Gossip——它只包含Server。这些server主要分布在不同的数据中心并且通常通过因特网或者广域网通信。
RPC——远程过程调用。这是一个允许client请求server的请求/响应机制。
-----------------------------------
©著作权归作者所有：来自51CTO博客作者wx62ccd9cc616d1的原创作品，请联系作者获取转载授权，否则将追究法律责任
服务发现之consul的介绍、部署和使用
https://blog.51cto.com/u_15715098/5920980

 

 

需要理解 ConsulClient  和 agent 
consulClient 需要配置 consul ui 的配置项 比如说 数据中心config.Datacenter = "dc1";，
ip地址端口号 8500 而 agent 是consul 核心 扶着 注册服务，健康检查，响应查询等 所以

 

using Consul;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace Common.core.consul
{
    public static class ConsulExtend
    {
        public static async Task<IApplicationBuilder> UseCustomConsulAsync(this IApplicationBuilder app, IConfiguration config)
        {
            ConsulOptions consulOptions = new ConsulOptions();
            config.Bind(consulOptions);
            config.GetSection("ConsulOptions").Bind(consulOptions);
            return await ConsulExtend.UseDefaultConsulAsync(app, consulOptions);
        }

        public static async Task<IApplicationBuilder> UseDefaultConsulAsync(this IApplicationBuilder app,
            ConsulOptions options)
        {
            using ConsulClient client = new ConsulClient(config =>
            {
                config.Address = new Uri(options.ConsulMain.Address);
                config.Datacenter = options.ConsulMain.Datacenter;
                //config.Address = new Uri("http://localhost:8500");
                //config.Datacenter = "dc1";
            });
            await client.Agent.ServiceRegister(new AgentServiceRegistration
            {
                ID = Guid.NewGuid().ToString(),
                Name = options.ConsulRegister.Name,
                Address = options.ConsulRegister.Address,
                Port = options.ConsulRegister.Port,
                //Address = "localhost",
                //Port = 5032,
                Tags = new string[] { options.ConsulRegister.Tag },
                Check = new AgentServiceCheck()
                {
                    DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(options.ConsulRegister.DeregisterCriticalServiceAfter),//服务启动多久后注册
                    Interval = TimeSpan.FromSeconds(options.ConsulRegister.Interval),//健康检查时间间隔
                    HTTP = options.ConsulRegister.HealthCheckUrl,///健康检查地址
                    Timeout = TimeSpan.FromSeconds(options.ConsulRegister.Timeout)
                }
            });
            return app;
        }
    }
}

 

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Common.core.consul
{
    public class ConsulOptions
    {
        public ConsulMain ConsulMain { get; set; }
        public ConsulRegister ConsulRegister { get; set; }
    }
    /// <summary>
    /// consul ui 
    /// </summary>
    public class ConsulMain
    {
        public string Address { get; set; }
        public string Datacenter { get; set; }
    }

    /// <summary>
    /// consul 下节点 注册
    /// </summary>
    public class ConsulRegister
    {
        public string Name { get; set; }
        public string Address { get; set; }
        public int Port { get; set; }
        public string Tag { get; set; }

        public string HealthCheckUrl { get; set; }
        public int Interval { get; set; }
        public int Timeout { get; set; }
        public int DeregisterCriticalServiceAfter { get; set; }
    }

}

 

 

 

以下项目引用

 

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Audience": {
    "Secret": "sdfsdfsrty45634kkhllghtdgdfss345t678fs", //密钥
    "Issuer": "SwiftCode.BBS", //发行人
    "Audience": "wr" //订阅人
  },
  "ConsulOptions": {
    "ConsulMain": {
      "Address": "http://localhost:8500",
      "Datacenter": "dc1"
    },
    "ConsulRegister": {
      "Name": "MainWeb",
      "Address": "localhost",
      "Port": 5032,
      "Tag": "1",
      "HealthCheckUrl": "http://localhost:5032/HealthCheck",
      "Interval": 10,
      "Timeout": 5,
      "DeregisterCriticalServiceAfter": 20
    }
  },
  //redis分布式缓存
  "RedisConfig": {
    //是否打开缓存1是0否
    "IsOpenCache": "0",
    "ReadWriteHosts": "192.168.1.2:6379,192.168.1.3:6379,password=123456",
    "ReadOnlyHosts": "192.168.1.2:6379,password=123456"
  }
}

 

 

using Common.core.consul;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi.Models;
using Swashbuckle.AspNetCore.Filters;
using System.Text;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(options =>
{

    //开启小锁
    options.OperationFilter<AddResponseHeadersFilter>();
    options.OperationFilter<AppendAuthorizeToSummaryOperationFilter>();
    //在header 中添加token 传给后台
    options.OperationFilter<SecurityRequirementsOperationFilter>();
    //添加安全定义
    options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Description = "jwt授权直接在下框输入token,格式 bearer+空格+token",
        Name = "Authorization",//默认参数名称
        In = ParameterLocation.Header,
        Type = SecuritySchemeType.ApiKey,
        BearerFormat = "JWT",
        Scheme = "Bearer"
    });
    //添加安全要求
    options.AddSecurityRequirement(new OpenApiSecurityRequirement {
        {
            new OpenApiSecurityScheme{
                Reference =new OpenApiReference{
                    Type = ReferenceType.SecurityScheme,
                    Id ="Bearer"
                }
            },new string[]{ }
        }
    });
    string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "JwtMainWebApI.xml");
    options.IncludeXmlComments(path, true);
    options.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
    {
        Title = "主页登录",
        Description = "主页登录"
    });
});

//注入consul 配置
builder.Services.Configure<ConsulOptions>(builder.Configuration.GetSection("ConsulOptions"));

//jwt
builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
    //读取配置文件
    var audienceConfig = builder.Configuration.GetSection("Audience");
    var symmetricKeyAsBase64 = audienceConfig["Secret"];
    var keyByteArray = Encoding.ASCII.GetBytes(symmetricKeyAsBase64);
    var signingKey = new SymmetricSecurityKey(keyByteArray);
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuerSigningKey = true,
        IssuerSigningKey = signingKey,
        ValidateIssuer = true,
        ValidIssuer = audienceConfig["Issuer"],//发行人
        ValidateAudience = true,
        ValidAudience = audienceConfig["Audience"],//订阅人
        ValidateLifetime = true,
        ClockSkew = TimeSpan.Zero,//这个是缓冲过期时间，也就是说，即使我们配置了过期时间，这里也要考虑进去，过期时间+缓冲，默认好像是7分钟，你可以直接设置为0
        RequireExpirationTime = true,
    };
});

//builder.Services.AddCors(options =>
//{
//    options.AddPolicy("cors", policy =>
//    {
//        policy.AllowAnyOrigin();
//        policy.AllowAnyHeader();
//        policy.AllowAnyMethod();
//    });
//});

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "v1");
        options.RoutePrefix = "";
    });
}
//app.UseCors("cors");
//注册consul
app.UseCustomConsulAsync(app.Configuration).Wait();
// consul 健康检查
app.Map("/HealthCheck", config =>
{
    config.Run(async context =>
    {
        context.Response.StatusCode = 200;
        app.Logger.LogError( $"{context.Request.Host}consul健康检查成功");
        await Task.CompletedTask;
    });
});

app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

 

using Common.core.consul;
using Consul;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;

namespace JwtMainWebApI.Controllers
{

    /// <summary>
    /// 测试 consul
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class ConsulController : ControllerBase
    {
        private readonly ConsulOptions _consulOptions;
        public ConsulController(IOptionsMonitor<ConsulOptions> optionsMonitor)
        {
            _consulOptions = optionsMonitor.CurrentValue;
        }
        /// <summary>
        /// 请求consul节点
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> Get()
        {
            using ConsulClient consulClient = new ConsulClient(config =>
              {
                  config.Address = new Uri(_consulOptions.ConsulMain.Address);
              });
            var services = consulClient.Catalog.Service("MainWeb").Result.Response;
            if (services != null && services.Any())
            {
                HttpClient httpClient = new HttpClient();
                HttpResponseMessage responseMessage = await httpClient.GetAsync($"http://{_consulOptions.ConsulRegister.Address}:{_consulOptions.ConsulRegister.Port}/WeatherForecast");
                string result = await responseMessage.Content.ReadAsStringAsync();
                return Ok(result);
            }
            return BadRequest();
        }
    }
}

 

测试结果

 

 

ocelot  配置  之前没有 配置consul 下游用的是http 配置consul 根节点要新增consul 路由http那里要注释同时要新增开启consul配置

路由http注释

 新增 开启 consul servicename 对应的是consul 节点服务的名称

 

根节点的配置

 

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/",
      "UpstreamPathTemplate": "/",
      "UpstreamHttpMethod": [
        "Get"
      ],
      "DownstreamHttpMethod": "",
      "DownstreamHttpVersion": "",
      "AddHeadersToRequest": {},
      "AddClaimsToRequest": {},
      "RouteClaimsRequirement": {},
      "AddQueriesToRequest": {},
      "RequestIdKey": "",
      "FileCacheOptions": {
        "TtlSeconds": 0,
        "Region": ""
      },
      "RouteIsCaseSensitive": false,
      "ServiceName": "",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 51876
        }
      ],
      "QoSOptions": {
        "ExceptionsAllowedBeforeBreaking": 0,
        "DurationOfBreak": 0,
        "TimeoutValue": 0
      },
      "LoadBalancer": "",
      "RateLimitOptions": {
        "ClientWhitelist": [],
        "EnableRateLimiting": false,
        "Period": "",
        "PeriodTimespan": 0,
        "Limit": 0
      },
      "AuthenticationOptions": {
        "AuthenticationProviderKey": "",
        "AllowedScopes": []
      },
      "HttpHandlerOptions": {
        "AllowAutoRedirect": true,
        "UseCookieContainer": true,
        "UseTracing": true,
        "MaxConnectionsPerServer": 100
      },
      "DangerousAcceptAnyServerCertificateValidator": false
    },


    {
      "UpstreamPathTemplate": "/api/Auth/{everything}",
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "PATCH", "Delete", "Options" ],
      "DownstreamPathTemplate": "/api/Auth/{everything}",
      //"DownstreamScheme": "http",
      //"DownstreamHostAndPorts": [
      //  {
      //    "Host": "localhost",
      //    "Port": 5246
      //  }
      //],
      //跨域
      "DownstreamHeaderTransform": {
        "Access-Control-Allow-Origin": "http://localhost:5253", //不存在就添加  
        "Access-Control-Allow-Methods": "*",
        "Access-Control-Allow-Headers": "*"
      },

      /*熔断/超时 
      超时就是网关请求服务时可容忍的最长响应时间。
      熔断的意思就是当请求某个服务的异常次数达到一定量时，
      那么网关在一定时间内就不再对这个服务发起请求了，直接熔断*/
      "QoSOptions": {
        "ExceptionsAllowedBeforeBreaking": 3, //发生错误的次数
        "DurationOfBreak": 10000, //熔断时间
        "TimeoutValue": 5000 //请求超过 5 秒，它将自动超时。
      },
      /*缓存*/
      "FileCacheOptions": {
        "TtlSeconds": 5, //过期时间
        "Region": "productcache"
      },
      /*限流*/
      "RateLimitOptions": {
        "ClientWhitelist": [ "SuperClient" ], //白名单中的客户端可以不受限流的影响
        "EnableRateLimiting": true, //是否限流
        "Period": "5s", //限流的单位时间
        "PeriodTimespan": 2, //请求上限多少秒后可以重试
        "Limit": 1 //定义的时间内可以发出的最大请求数
      },
      "UseServiceDiscovery": true, //开启consul发现
      "ServiceName": "Auth",
      "LoadBalancerOptions": {
        "Type": "RoundRobin" //轮询      LeastConnection-最少连接数的服务器   NoLoadBalance不负载均衡
      }
    },

    {
      "UpstreamPathTemplate": "/api/Login",
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "PATCH", "Delete", "Options" ],
      "DownstreamPathTemplate": "/api/Login",
      //"DownstreamScheme": "http",
      //"DownstreamHostAndPorts": [
      //  {
      //    "Host": "localhost",
      //    "Port": 5032
      //  }
      //],
      //跨域
      "DownstreamHeaderTransform": {
        "Access-Control-Allow-Origin": "http://localhost:5253", //不存在就添加  
        "Access-Control-Allow-Methods": "*",
        "Access-Control-Allow-Headers": "*"
      },
      /*熔断/超时 
      超时就是网关请求服务时可容忍的最长响应时间。
      熔断的意思就是当请求某个服务的异常次数达到一定量时，
      那么网关在一定时间内就不再对这个服务发起请求了，直接熔断*/
      "QoSOptions": {
        "ExceptionsAllowedBeforeBreaking": 3, //发生错误的次数
        "DurationOfBreak": 10000, //熔断时间
        "TimeoutValue": 5000 //请求超过 5 秒，它将自动超时。
      },
      /*缓存*/
      "FileCacheOptions": {
        "TtlSeconds": 5, //过期时间
        "Region": "productcache"
      },
      /*限流*/
      "RateLimitOptions": {
        "ClientWhitelist": [ "3" ], //白名单中的客户端可以不受限流的影响
        "EnableRateLimiting": true, //是否限流
        "Period": "5s", //限流的单位时间
        "PeriodTimespan": 2, //请求上限多少秒后可以重试
        "Limit": 1 //定义的时间内可以发出的最大请求数
      },
      //鉴权授权
      "AuthenticationOptions": {
        "AuthenticationProviderKey": "TestKey",
        "AllowedScopes": [ "testscope" ]
      },
      "UseServiceDiscovery": true, //开启consul发现
      "ServiceName": "MainWeb" ,
      "LoadBalancerOptions": {
        "Type": "RoundRobin" //轮询      LeastConnection-最少连接数的服务器   NoLoadBalance不负载均衡
      }
    },

    //身份验证swagger
    {
      "UpstreamPathTemplate": "/auth/swagger/v1/swagger.json",
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "PATCH", "Delete", "Options" ],
      "DownstreamPathTemplate": "/swagger/v1/swagger.json",
      //"DownstreamScheme": "http",
      //"DownstreamHostAndPorts": [
      //  {
      //    "Host": "localhost",
      //    "Port": 5246
      //  }
      //],
      "DownstreamHeaderTransform": {
        "Access-Control-Allow-Origin": "http://localhost:5253", //不存在就添加  
        "Access-Control-Allow-Methods": "*",
        "Access-Control-Allow-Headers": "*"
      },
      /*熔断/超时 
      超时就是网关请求服务时可容忍的最长响应时间。
      熔断的意思就是当请求某个服务的异常次数达到一定量时，
      那么网关在一定时间内就不再对这个服务发起请求了，直接熔断*/
      "QoSOptions": {
        "ExceptionsAllowedBeforeBreaking": 3, //发生错误的次数
        "DurationOfBreak": 10000, //熔断时间
        "TimeoutValue": 5000 //请求超过 5 秒，它将自动超时。
      },
      /*缓存*/
      "FileCacheOptions": {
        "TtlSeconds": 5, //过期时间
        "Region": "productcache"
      },
      /*限流*/
      "RateLimitOptions": {
        "ClientWhitelist": [ "SuperClient" ], //白名单中的客户端可以不受限流的影响
        "EnableRateLimiting": true, //是否限流
        "Period": "5s", //限流的单位时间
        "PeriodTimespan": 2, //请求上限多少秒后可以重试
        "Limit": 1 //定义的时间内可以发出的最大请求数
      },
      "UseServiceDiscovery": true, //开启consul发现
      "ServiceName": "Auth",
      "LoadBalancerOptions": {
        "Type": "RoundRobin" //轮询      LeastConnection-最少连接数的服务器   NoLoadBalance不负载均衡
      }
    },

    //主页面swagger
    {
      "UpstreamPathTemplate": "/jwtmain/swagger/v1/swagger.json",
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "PATCH", "Delete", "Options" ],
      "DownstreamPathTemplate": "/swagger/v1/swagger.json",
      //"DownstreamScheme": "http",
      //"DownstreamHostAndPorts": [
      //  {
      //    "Host": "localhost",
      //    "Port": 5032
      //  }
      //],
      "DownstreamHeaderTransform": {
        "Access-Control-Allow-Origin": "http://localhost:5253", //不存在就添加  
        "Access-Control-Allow-Methods": "*",
        "Access-Control-Allow-Headers": "*"
      },
      /*熔断/超时 
      超时就是网关请求服务时可容忍的最长响应时间。
      熔断的意思就是当请求某个服务的异常次数达到一定量时，
      那么网关在一定时间内就不再对这个服务发起请求了，直接熔断*/
      "QoSOptions": {
        "ExceptionsAllowedBeforeBreaking": 3, //发生错误的次数
        "DurationOfBreak": 10000, //熔断时间
        "TimeoutValue": 5000 //请求超过 5 秒，它将自动超时。
      },
      /*缓存*/
      "FileCacheOptions": {
        "TtlSeconds": 5, //过期时间
        "Region": "productcache"
      },
      /*限流*/
      "RateLimitOptions": {
        "ClientWhitelist": [ "SuperClient" ], //白名单中的客户端可以不受限流的影响
        "EnableRateLimiting": true, //是否限流
        "Period": "5s", //限流的单位时间
        "PeriodTimespan": 2, //请求上限多少秒后可以重试
        "Limit": 1 //定义的时间内可以发出的最大请求数
      },
      "UseServiceDiscovery": true, //开启consul发现
      "ServiceName": "MainWeb" ,
      "LoadBalancerOptions": {
        "Type": "RoundRobin" //轮询      LeastConnection-最少连接数的服务器   NoLoadBalance不负载均衡
      }
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:5253",
    "ServiceDiscoveryProvider": {
      "Scheme": "http",
      "Host": "localhost",
      "Port": 8500,
      "Type": "Consul"
    },
    "RateLimitOptions": {
      "DisableRateLimitHeaders": false, //是否禁用X-Rate-Limit和Retry-After标头
      "QuotaExceededMessage": "{\"res_code\":\"999\",\"res_msg\":\"请求中\"}", //请求达到上限时返回
      "HttpStatusCode": 999, //HTTP状态代码
      "ClientIdHeader": "Test"
    }
  }
}

出现个坑 在consul 注册节点那里