庐山真面目之七微服务架构Consul集群、Ocelot网关集群和IdentityServer4版本实现 - 可均可可

公告

庐山真面目之七微服务架构Consul集群、Ocelot网关集群和IdentityServer4版本实现

庐山真面目之七微服务架构Consul集群、Ocelot网关集群和IdentityServer4版本实现

一、简介
     　　　　在上一篇文章《庐山真面目之六微服务架构Consul集群、Ocelot网关集群和Nginx版本实现》中，我们已经探讨了如何搭建基于Consul服务集群和Ocelot网关集群的微服务架构。乍这么一看，好像还是挺完整和完美的了，真的像我们想象的那样吗？当然没有了，只不过是解决了那篇文章需要解决的问题。毕竟我们每篇文章只会解决一个问题，之所以这样做，是因为这样做，大家才会更能理解每篇文章的技术要点。如果我们把所有的东西都放在一篇文章里，太多了，不利于学习和查看。今天我们要解决什么问题呢？我也不卖关子了，那就是认证和授权的问题。我们现在的所有集群的服务都是敞开大门、对外开放，谁想访问谁访问，谁想怎么干就怎么干，没有任何的安全措施，我们好像在互联网上裸奔一样，虽然“裸奔”很容易出名，但是我们不需要这样，开个玩笑。

　　　　　　1、说明
    　　　　　　　　看过以前文章的朋友，今天会觉得文章的顺序改了一下，主要是便于大家理解，希望开发顺序和思维顺序一致。从今天开始，我们文章的项目建设顺序重新调整一下，怕有些人不知道先后，自己做测试的时候回出错。在此特别声明：如果是高手的话，这些东西相对于您来说，肯定是微不足道，请您口下留德，再者说，这些文章是为没有相关基础的人写的，不要抬杠了，如果有高见，也希望不灵赐教。特别说明，这里的所有代码都经过测试，所以大家可以放心使用。

　　　　　　2、开发环境
   　　　　　　　　以下就是开发环境，不用多说，都很简单，一看就知道。
   　　　　　　　　（1）、开发工具：Visual Studio 2019
   　　　　　　　　（2）、开发语言：C#
   　　　　　　　　（3）、开发平台：Net Core3.1，跨平台。
   　　　　　　　　（4）、服务注册：Consul集群，服务注册、发现中心
   　　　　　　　　（5）、服务治理：Ocelot集群，负载均衡、服务治理
   　　　　　　　　（6）、网关服务：Nginx 服务组件，一个负载Consul服务，一个负载Ocelot网关。
   　　　　　　　　（7）、操作系统：Windows 10，64bit。
   　　　　　　　　（8）、鉴权授权：IdentityServer4

　　　　　　3、我们的目标
    　　　　　　　　今天我们的目标是，在Windows系统上实现基于Consul集群、Ocelot集群和IdentityServer4鉴权、授权的微服务架构，这样就可以解决服务实例裸跑在互联网上，被别人攻击就不好了，毕竟，安全第一。从实际项目来说，系统的服务并不是向所有人开放的，有些需要授权才可以访问，有些就不需要了。当然这个肯定不是最终版本，我们还会继续演化下去。
     　　　　　　　　目标框架如图：
    　　　　　　　　　　　　

二、搭建微服务测试项目。
     　　　　我们要想搭建微服务架构，第一步，我们当然要搭建我们自己的测试项目了，代码都很简单，主要是为了突出各个开源技术点。这是基础中的基础，没有这一步，其他的都是空中楼阁，没有说服力了。废话少说，我们开始吧。

    　　　　1、建立测试项目，并编写各个项目的所需代码。

          　　　　　　（1）、PatrickLiu.MicroService.Client（ASP.NET CORE MVC）,客户端项目。
               　　　　　　　　　　该项目模仿客户端程序，当然可以是你愿意的任何客户端程序，别抬杠，我这里只是一个简单的MVC项目，通过地址访问微服务。
                 　　　　　　　　　　　　　　　　　　　　　　　　　　　　
                 　　　　　　　　　　样例代码：
　　　　　　　　　　　　　　　　　　

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Net.Http;
 5 using Consul;
 6 using Microsoft.AspNetCore.Mvc;
 7 using Microsoft.Extensions.Logging;
 8 using PatrickLiu.MicroService.Interfaces;
 9 using PatrickLiu.MicroService.Models;
10 
11 namespace PatrickLiu.MicroService.Client.Controllers
12 {
13     public class HomeController : Controller
14     {
15         private readonly ILogger<HomeController> _logger;
16         private readonly IUserService _userService;
17         private static int index;
18 
19         /// <summary>
20         /// 初始化该类型的新实例。
21         /// </summary>
22         /// <param name="logger">注入日志对象。</param>
23         /// <param name="userService">注入用户服务对象。</param>
24         public HomeController(ILogger<HomeController> logger, IUserService userService)
25         {
26             _logger = logger;
27             _userService = userService;
28         }
29 
30         /// <summary>
31         /// 首页。
32         /// </summary>
33         /// <returns></returns>
34         public IActionResult Index()
35         {
36             #region 通过 Nginx 网关访问服务实例。
37 
38             string url = "http://localhost:6400/gate/users/all?Authentication=bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE3RUI3Q0I1NjBDN0ExODgzOEZEQUJCQTg0NEE0MzU2IiwidHlwIjoiYXQrand0In0.eyJuYmYiOjE2MDc2NjkxNzUsImV4cCI6MTYwNzY3Mjc3NSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo3Mjk5IiwiYXVkIjoiVXNlckFwaSIsImNsaWVudF9pZCI6IlBhdHJpY2tMaXUuTWljcm9TZXJ2aWNlLkF1dGhlbnRpY2F0aW9uRGVtbyIsImNsaWVudF9yb2xlIjoiQWRtaW4iLCJjbGllbnRfbmlja25hbWUiOiJQYXRyaWNrTGl1IiwiY2xpZW50X2VNYWlsIjoiUGF0cmlja0xpdUBzaW5hLmNvbSIsImp0aSI6IkM0NTg5QTZBOTYyMkVCQzg5MzkxQ0Q2ODQyQ0NFN0MyIiwiaWF0IjoxNjA3NjY5MTc0LCJzY29wZSI6WyJVc2VyLkdldCJdfQ.XvNWAeVs9tN5e4Jx3o12FbsY74Vk_iWmynh9Ty8Es5Q_FYs2qGy_rAYz1VW-Mec5jh9Dz_i6WLXMG4A6a98ArRQP4ZWR-4V4CZFZdNofUW7H4JjYUIbhBBn4PHRgrRlu99jqXz34b6CqP5Rv8JgA-Yu1nDtdc1gR3OBN4t_bZaTbvaKp6Y_yS2UYC9VmRNWSS_7aELAvgvifaWmpJm55q5H4i0x-zCP-8yBMW_EHBTUfV6i5k0H71jlel-0wWOw6sijjPQMXdyDZyfg6-RJ2naOcGUItsY0LzDiNBRXoF_qDO0jFqq5-pPurwxaG8HnTx0AtcVEe2tpt2GoO_OJS6g";
39 
40             #endregion
41 
42             string content = InvokeAPI(url);
43             this.ViewBag.Users = Newtonsoft.Json.JsonConvert.DeserializeObject<IEnumerable<User>>(content);
44             Console.WriteLine($"This is {url} Invoke.");
45             
46             #endregion
47 
48             return View();
49         }
50 
51         public IActionResult Privacy()
52         {
53             return View();
54         }
55 
56         /// <summary>
57         /// 封装 HttpClient 实例，提供 Http 调用。
58         /// </summary>
59         /// <param name="url">http url 的地址。</param>
60         /// <returns>返回结束数据，格式：JSON。</returns>
61         public static string InvokeAPI(string url)
62         {
63             using (HttpClient client = new HttpClient())
64             {
65                 HttpRequestMessage message = new HttpRequestMessage();
66                 message.Method = HttpMethod.Get;
67                 message.RequestUri = new Uri(url);
68                 var result = client.SendAsync(message).Result;
69                 string conent = result.Content.ReadAsStringAsync().Result;
70                 return conent;
71             }
72         }
73     }
74 }

          　　　　　　（2）、PatrickLiu.MicroService.Interfaces（NET CORE 类库），定义服务接口，面向接口编程嘛，代码很简单，因为重点不是它。
                 　　　　　　　　　　　　
                 　　　　　　　　　　样例代码：

 1 using PatrickLiu.MicroService.Models;
 2 using System.Collections.Generic;
 3 
 4 namespace PatrickLiu.MicroService.Interfaces
 5 {
 6     /// <summary>
 7     /// 用户服务的接口定义。
 8     /// </summary>
 9     public interface IUserService
10     {
11         /// <summary>
12         /// 查找指定主键的用户实例对象。
13         /// </summary>
14         /// <param name="id">用户的主键。</param>
15         /// <returns>返回查找到的用户实例对象。</returns>
16         User FindUser(int id);
17 
18         /// <summary>
19         /// 获取所有用户的实例集合。
20         /// </summary>
21         /// <returns>返回所有的用户实例。</returns>
22         IEnumerable<User> UserAll();
23     }
24 }

          　　　　　　（3）、PatrickLiu.MicroService.Models（NET CORE 类库），定义实例类型，主要用于数据传递，代码很简单，因为重点不是它。
                 　　　　　　　　　　　　
                 　　　　　　　　　　样例代码：

 1 using System;
 2 
 3 namespace PatrickLiu.MicroService.Models
 4 {
 5     /// <summary>
 6     /// 用户模型。
 7     /// </summary>
 8     public class User
 9     {
10         /// <summary>
11         /// 获取或者设置用户主键。
12         /// </summary>
13         public int ID { get; set; }
14 
15         /// <summary>
16         /// 获取或者设置用户姓名。
17         /// </summary>
18         public string Name { get; set; }
19 
20         /// <summary>
21         /// 获取或者设置用户账号名称。
22         /// </summary>
23         public string Account { get; set; }
24 
25         /// <summary>
26         /// 获取或者设置用户密码。
27         /// </summary>
28         public string Password { get; set; }
29 
30         /// <summary>
31         /// 获取或者设置用户的电子邮箱地址。
32         /// </summary>
33         public string Email { get; set; }
34 
35         /// <summary>
36         /// 获取或者设置用户角色。
37         /// </summary>
38         public string Role { get; set; }
39 
40         /// <summary>
41         /// 获取或者设置用户的登录时间。
42         /// </summary>
43         public DateTime LoginTime { get; set; }
44     }
45 }

　　　　　　（4）、PatrickLiu.MicroService.Services（NET CORE 类库），定义服务实现，我们有了接口，然后基于接口实现具体的服务，代码很简单，因为重点不是它。
　　　　　　　　　　
　　　　　　　　　　　　　　样例代码：

 1 using PatrickLiu.MicroService.Interfaces;
 2 using PatrickLiu.MicroService.Models;
 3 using System;
 4 using System.Collections.Generic;
 5 using System.Linq;
 6 
 7 namespace PatrickLiu.MicroService.Services
 8 {
 9     /// <summary>
10     /// 实现用户服务接口的实现类型。
11     /// </summary>
12     public class UserService : IUserService
13     {
14         private IList<User> dataList;
15 
16         /// <summary>
17         /// 初始化类型的实例
18         /// </summary>
19         public UserService()
20         {
21             dataList = new List<User>()
22             { new User {ID=1,Name="黄飞鸿",Account="HuangFeiHong",Password="HuangFeiHong123456",Email="huangFeiHong@sina.com", Role="Admin", LoginTime=DateTime.Now },
23             new User {ID=2,Name="洪熙官",Account="HongXiGuan",Password="HongXiGuan54667",Email="HongXiGuan@sina.com", Role="Admin", LoginTime=DateTime.Now.AddDays(-5) },
24             new User {ID=3,Name="方世玉",Account="FangShiYu",Password="FangShiYu112233",Email="fangShiYu@163.com", Role="Admin", LoginTime=DateTime.Now.AddDays(-30) },
25             new User {ID=4,Name="苗翠花",Account="MiaoCuiHua",Password="MiaoCuiHua887766",Email="miaoCuiHua@sohu.com", Role="Admin", LoginTime=DateTime.Now.AddDays(-90) },
26             new User {ID=5,Name="严咏春",Account="YanYongChun",Password="YanYongChun09392",Email="yanYongChun@263.com", Role="Admin", LoginTime=DateTime.Now.AddMinutes(-50) }};
27         }
28 
29         /// <summary>
30         /// 查找指定主键的用户实例对象。
31         /// </summary>
32         /// <param name="id">用户的主键。</param>
33         /// <returns>返回查找到的用户实例对象。</returns>
34         public User FindUser(int id)
35         {
36             return dataList.FirstOrDefault(user => user.ID == id);
37         }
38 
39         /// <summary>
40         /// 获取所有用户的实例集合。
41         /// </summary>
42         /// <returns>返回所有的用户实例。</returns>
43         public IEnumerable<User> UserAll()
44         {
45             return dataList;
46         }
47     }
48 }

          　　　　　　（5）、PatrickLiu.MicroService.ServiceInstance（ASP.NET CORE WEBAPI）,这个就是我们的服务，通过启动多个实例，实现集群，代码很简单，因为重点不是它。
　　　　　　　　　　　　　　

                　　　　　　　　　　这个项目必须引入其他三个项目：
                 　　　　　　　　　　PatrickLiu.MicroService.Interfaces
                 　　　　　　　　　　PatrickLiu.MicroService.Models
                 　　　　　　　　　　PatrickLiu.MicroService.Services
　　　　　　　　　　　　　　　　
               　　　　　　　　　　【1】、安装Consul服务组件，以支持注册到Consul服务中心。
　　　　　　　　　　　　　　　　　　命令：Install-Package Consul
                    　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　可以在项目菜单【依赖项】菜单上点击右键，选择【管理 NuGet 程序包】来安装Consul服务。

                 　　　　　　　　　【2】、HealthController.cs，主要用于Consul服务的健康检查。
                     　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
                     　　　　　　　　　　样例代码：
　　　　　　　　　　　　　　　　　　

 1 using System;
 2 using Microsoft.AspNetCore.Mvc;
 3 using Microsoft.Extensions.Configuration;
 4 
 5 namespace PatrickLiu.MicroService.ServiceInstance.Controllers
 6 {
 7     /// <summary>
 8     /// 健康检查的控制器。
 9     /// </summary>
10     [ApiController]
11     [Route("api/[controller]")]
12     public class HealthController : ControllerBase
13     {
14         private IConfiguration _configuration;
15 
16         /// <summary>
17         /// 初始化该类型的新实例。
18         /// </summary>
19         /// <param name="configuration">配置接口。</param>
20         public HealthController(IConfiguration configuration)
21         {
22             _configuration = configuration;
23         }
24 
25         /// <summary>
26         /// 要调用的接口。
27         /// </summary>
28         [HttpGet]
29         [Route("Index")]
30         public IActionResult Index()
31         {
32             Console.WriteLine($"This is HealhController {_configuration["port"]} Invoke");
33             return Ok();
34         }
35     }
36 }

               　　　　　　　　　　【3】、UsersController.cs，主要是业务类型，内容很简单。
                      　　　　　　　　　　　　

                     　　　　　　　　　　样例代码：
　　　　　　　　　　　　　　　　　　

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Threading;
  5 using Microsoft.AspNetCore.Mvc;
  6 using Microsoft.Extensions.Configuration;
  7 using Microsoft.Extensions.Logging;
  8 using PatrickLiu.MicroService.Interfaces;
  9 using PatrickLiu.MicroService.Models;
 10 
 11 namespace PatrickLiu.MicroService.ServiceInstance.Controllers
 12 {
 13     /// <summary>
 14     /// 用户的 API 类型。
 15     /// </summary>
 16     [Route("api/[controller]")]
 17     [ApiController]    
 18     public class UsersController : ControllerBase
 19     {
 20         #region 私有字段
 21 
 22         private readonly ILogger<UsersController> _logger;
 23         private readonly IUserService _userService;
 24         private IConfiguration _configuration;
 25 
 26         #endregion
 27 
 28         #region 构造函数
 29 
 30         /// <summary>
 31         /// 初始化该类型的新实例。
 32         /// </summary>
 33         /// <param name="logger">日志记录器。</param>
 34         /// <param name="userService">用户服务接口。</param>
 35         /// <param name="configuration">配置服务。</param>
 36         public UsersController(ILogger<UsersController> logger, IUserService userService, IConfiguration configuration)
 37         {
 38             _logger = logger;
 39             _userService = userService;
 40             _configuration = configuration;
 41         }
 42 
 43         #endregion
 44 
 45         #region 实例方法
 46 
 47         /// <summary>
 48         /// 获取一条记录
 49         /// </summary>
 50         /// <param name="id"></param>
 51         /// <returns></returns>
 52         [HttpGet]
 53         [Route("Get")]
 54         public User Get(int id)
 55         {
 56             return _userService.FindUser(id);
 57         }
 58 
 59         /// <summary>
 60         /// 获取所有记录。
 61         /// </summary>
 62         /// <returns></returns>
 63         [HttpGet]
 64         [Route("All")]
 65         //[Authorize]
 66         public IEnumerable<User> Get()
 67         {
 68             Console.WriteLine($"This is UsersController {this._configuration["port"]} Invoke");
 69 
 70             return this._userService.UserAll().Select((user => new User
 71             {
 72                 ID = user.ID,
 73                 Name = user.Name,
 74                 Account = user.Account,
 75                 Password = user.Password,
 76                 Email = user.Email,
 77                 Role = $"{this._configuration["ip"]}：{this._configuration["port"]}",
 78                 LoginTime = user.LoginTime
 79             })); ;
 80         }
 81 
 82         /// <summary>
 83         /// 超时处理
 84         /// </summary>
 85         /// <returns></returns>
 86         [HttpGet]
 87         [Route("Timeout")]
 88         public IEnumerable<User> Timeout()
 89         {
 90             Console.WriteLine($"This is Timeout Start");
 91             //超时设置。
 92             Thread.Sleep(3000);
 93 
 94             Console.WriteLine($"This is Timeout End");
 95 
 96             return this._userService.UserAll().Select((user => new User
 97             {
 98                 ID = user.ID,
 99                 Name = user.Name,
100                 Account = user.Account,
101                 Password = user.Password,
102                 Email = user.Email,
103                 Role = $"{this._configuration["ip"]}：{this._configuration["port"]}",
104                 LoginTime = user.LoginTime
105             })); ;
106         }
107 
108         #endregion
109     }
110 }

              　　　　　　　　　　【4】、增加扩展类型：ConsulExtension.cs
                      　　　　　　　　　　　　

 1 using Consul;
 2 using Microsoft.Extensions.Configuration;
 3 using Microsoft.Extensions.Hosting;
 4 using System;
 5 
 6 namespace PatrickLiu.MicroService.ServiceInstance.Utilities
 7 {
 8     /// <summary>
 9     /// Consul 静态扩展类。
10     /// </summary>
11     public static class ConsulExtension
12     {
13         /// <summary>
14         ///类型初始化器，初始化 Consul 网址和数据中心。
15         /// </summary>
16         static ConsulExtension()
17         {
18             Uri = new Uri("http://localhost:8500");
19             DataCenter = "dc1";
20         }
21 
22         /// <summary>
23         /// 获取或者设置 Consul 的网址。
24         /// </summary>
25         public static Uri Uri { get; set; }
26 
27         /// <summary>
28         /// 获取或者设置数据中心。
29         /// </summary>
30         public static string DataCenter { get; set; }
31 
32         /// <summary>
33         /// 向 Consul 服务中心注册服务实例。
34         /// </summary>
35         /// <param name="configuration">配置对象。</param>
36         /// <param name="consulServiceName">在 Consul 服务中心注册的服务类别名称，多个实例的 ID 可以属于一个服务类别名称。</param>
37         /// <param name="serviceID">服务实例的主键值，必须唯一。</param>
38         public static void ConsulRegist(this IConfiguration configuration,string consulServiceName, string serviceID)
39         {
40             if (string.IsNullOrEmpty(consulServiceName) || string.IsNullOrWhiteSpace(consulServiceName))
41             {
42                 throw new ArgumentNullException("consulServiceName is null");
43             }
44             if (string.IsNullOrEmpty(serviceID) || string.IsNullOrWhiteSpace(serviceID))
45             {
46                 throw new ArgumentNullException("serviceID is null.");
47             }
48 
49             using (ConsulClient client = new ConsulClient(config =>
50             {
51                 config.Address = Uri;
52                 config.Datacenter = DataCenter;
53             }))
54             {
55                 string ip = configuration["ip"];
56                 int port = int.Parse(configuration["port"]);
57                 int weight = string.IsNullOrWhiteSpace(configuration["weight"]) ? 1 : int.Parse(configuration["weight"]);
58 
59                 client.Agent.ServiceRegister(new AgentServiceRegistration()
60                 {
61                     ID = serviceID,
62                     Name = consulServiceName,
63                     Address = ip,
64                     Port = port,
65                     Tags = new string[] { weight.ToString() },
66                     Check = new AgentServiceCheck()
67                     {
68                         Interval = TimeSpan.FromSeconds(12),
69                         HTTP = $"http://{ip}:{port}/API/Health/Index",
70                         Timeout = TimeSpan.FromSeconds(5),
71                         DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(20)
72                     }
73                 }).Wait();
74                 Console.WriteLine($"注册服务：{ip}:{port}--Weight:{weight}");
75             };                       
76         }
77 
78         /// <summary>
79         /// 向 Consul 服务中心注销服务实例。
80         /// </summary>
81         /// <param name="applicationLifetime">配置对象。</param>
82         /// <param name="serviceID">服务实例的主键值，必须唯一。</param>
83         public static void ConsulDown(this IHostApplicationLifetime applicationLifetime, string serviceID)
84         {
85             if (string.IsNullOrEmpty(serviceID) || string.IsNullOrWhiteSpace(serviceID))
86             {
87                 throw new ArgumentNullException("serviceID is null");
88             }
89             applicationLifetime.ApplicationStopped.Register(() =>
90             {
91                 using (var consulClient = new ConsulClient(config => { config.Address = Uri; config.Datacenter = DataCenter; }))
92                 {
93                     Console.WriteLine("服务已经退出");
94                     consulClient.Agent.ServiceDeregister(serviceID);
95                 }
96             });
97         }
98     }
99 }

　　　　　　　　　　【5】、修改 Startup.cs 代码。
　　　　　　　　　　　　

 1 using Consul;
 2 using Microsoft.AspNetCore.Builder;
 3 using Microsoft.AspNetCore.Hosting;
 4 using Microsoft.Extensions.Configuration;
 5 using Microsoft.Extensions.DependencyInjection;
 6 using Microsoft.Extensions.Hosting;
 7 using PatrickLiu.MicroService.Interfaces;
 8 using PatrickLiu.MicroService.ServiceInstance.Utilities;
 9 using PatrickLiu.MicroService.Services;
10 using System;
11 using System.Security.Policy;
12 
13 namespace PatrickLiu.MicroService.ServiceInstance
14 {
15     /// <summary>
16     /// 应用程序启动配置
17     /// </summary>
18     public class Startup
19     {
20         /// <summary>
21         /// 构造函数注入配置对象
22         /// </summary>
23         /// <param name="configuration">配置实例</param>
24         public Startup(IConfiguration configuration)
25         {
26             Configuration = configuration;
27         }
28 
29         /// <summary>
30         /// 获取配置实例。
31         /// </summary>
32         public IConfiguration Configuration { get; }
33 
34         /// <summary>
35         /// 配置注入对象。
36         /// </summary>
37         /// <param name="services"></param>
38         public void ConfigureServices(IServiceCollection services)
39         {
40             services.AddControllers();
41             services.AddSingleton<IUserService, UserService>();
42         }
43 
44         /// <summary>
45         /// 配置 HTTP 处理管道。
46         /// </summary>
47         /// <param name="app">应用程序对象。</param>
48         /// <param name="env">环境对象。</param>
49         /// <param name="applicationLifetime">应用程序生命周期的对象。</param>
50         public void Configure(IApplicationBuilder app, IWebHostEnvironment env,IHostApplicationLifetime applicationLifetime)
51         {
52             //其他无关代码省略
53 
54             #region Consul 注册
55 
56             string serviceID = $"Service:{Configuration["ip"]}:{Configuration["port"]}---{Guid.NewGuid()}";
57             string consuleServiceName = "PatrickLiuService";
58             
59             //注册服务。
60             Configuration.ConsulRegist(consuleServiceName,serviceID);
61 
62             //注销服务
63             applicationLifetime.ConsulDown(serviceID);
64 
65             #endregion
66         }
67     }
68 }

　　　　　　　　　　【6】、修改 Program.cs 代码，红色标注代表增加的代码。
　　　　　　　　　　　　

 1 using System.IO;
 2 using Microsoft.AspNetCore.Hosting;
 3 using Microsoft.Extensions.Configuration;
 4 using Microsoft.Extensions.Hosting;
 5 
 6 namespace PatrickLiu.MicroService.ServiceInstance
 7 {
 8     public class Program
 9     {
10         public static void Main(string[] args)
11         {
12             new ConfigurationBuilder()
13                 .SetBasePath(Directory.GetCurrentDirectory())
14                 .AddCommandLine(args)//支持命令行
15                 .Build();
16                 
17             CreateHostBuilder(args).Build().Run();
18         }
19 
20         public static IHostBuilder CreateHostBuilder(string[] args) =>
21             Host.CreateDefaultBuilder(args)
22                 .ConfigureWebHostDefaults(webBuilder =>
23                 {
24                     webBuilder.UseStartup<Startup>();
25                 });
26     }
27 }

          　　　　　　（6）、PatrickLiu.MicroService.Gateway（ASP.NET CORE WEBAPI）,网关服务。
                 　　　　　　　　　

                　　　　　　　　　　【1】、安装Ocelot组件，可以实现针对服务管理工作，如：缓存等。
                      　　　　　　　　　　　　在【程序包管理器控制台】执行命令
                      　　　　　　　　　　　　命令：Install-Package Ocelot
                      　　　　　　　　　　　　
                      　　　　　　　　　　　　当然也可以在项目下的【依赖项】上点右键，点击【管理NuGet程序包】菜单，在【浏览】项先安装，输入Ocelot，在右侧安装则可以。

                　　　　　　　　　　【2】、安装Ocelot.Provider.Consul组件，以实现Ocelot和Consul的组合。
                       　　　　　　　　　　　　在【程序包管理器控制台】执行命令。
                       　　　　　　　　　　　　命令：Install-Package Ocelot.Provider.Consul
                       　　　　　　　　　　　　
                       　　　　　　　　　　　　当然也可以在项目下的【依赖项】上点右键，点击【管理NuGet程序包】菜单，在【浏览】项先安装，输入Ocelot.Provider.Consul，在右侧安装则可以。

                　　　　　　　　　　【3】、配置Startup.cs文件。
                      　　　　　　　　　　　　

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Threading.Tasks;
 5 using IdentityServer4.AccessTokenValidation;
 6 using Microsoft.AspNetCore.Builder;
 7 using Microsoft.AspNetCore.Hosting;
 8 using Microsoft.AspNetCore.HttpsPolicy;
 9 using Microsoft.AspNetCore.Mvc;
10 using Microsoft.Extensions.Configuration;
11 using Microsoft.Extensions.DependencyInjection;
12 using Microsoft.Extensions.Hosting;
13 using Microsoft.Extensions.Logging;
14 using Ocelot.Cache;
15 using Ocelot.Cache.CacheManager;
16 using Ocelot.DependencyInjection;
17 using Ocelot.Middleware;
18 using Ocelot.Provider.Consul;
19 using Ocelot.Provider.Polly;
20 
21 namespace PatrickLiu.MicroService.Gateway
22 {
23     /// <summary>
24     /// 1、Ocelot 提供网关功能
25     /// 2、Ocelot.Provider.Polly 提供服务治理
26     /// 3、Ocelot.Provider.Consul 提供服务发现
27     /// 4、Ocelot.Cache.CacheManager 提供缓存功能。
28     /// </summary>
29     public class Startup
30     {
31         /// <summary>
32         /// 构造函数注入
33         /// </summary>
34         /// <param name="configuration">配置对象那个</param>
35         public Startup(IConfiguration configuration)
36         {
37             Configuration = configuration;
38         }
39 
40         /// <summary>
41         /// 获取配置对象
42         /// </summary>
43         public IConfiguration Configuration { get; }
44 
45         /// <summary>
46         /// 配置依赖注入的对象。
47         /// </summary>
48         /// <param name="services"></param>
49         public void ConfigureServices(IServiceCollection services)
50         {
51             #region 1、在网关中增加鉴权模块
52 
53             var authenticationProviderKey = "UserGatewayKey";
54             services.AddAuthentication("Bearer")
55                 .AddIdentityServerAuthentication(authenticationProviderKey, options =>
56                 {
57                     options.Authority = "http://localhost:7299";
58                     options.ApiName = "UserApi";
59                     options.RequireHttpsMetadata = false;
60                     options.SupportedTokens = SupportedTokens.Both;
61                 });
62 
63             #endregion
64 
65             #region 2、配置网关、网关缓存和服务治理
66 
67             services.AddOcelot()//使用 Ocelot 网关服务。
68                     .AddConsul()//使用Consul 服务发现控制器。
69                     .AddCacheManager(builer => builer.WithDictionaryHandle()) //使用 Ocelot 缓存服务
70                     .AddPolly();//支持瞬态故障库----超时、熔断、限流、降级、雪崩效应等都可以做
71 
72             #endregion
73         }
74 
75 
76         /// <summary>
77         /// 
78         /// </summary>
79         /// <param name="app"></param>
80         /// <param name="env"></param>
81         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
82         {
83             app.UseOcelot();//配置使用 Ocelot 网关中间件。
84         }
85     }
86 }

　　　　　　　　　　【4】、增加JSON配置文件，文件名：configuration.json。
　　　　　　　　　　　　　　

 1 {
 2   //************************************* Ocelot 网关 + 认证中心 + Consul 服务发现 *************************************
 3   "Routes": [
 4     {
 5       "DownstreamPathTemplate": "/api/{url}",
 6       "DownstreamScheme": "http",
 7       "UpstreamPathTemplate": "/gate/{url}",
 8       "UpstreamHttpMethod": [ "Get", "Post" ],
 9       "UseServiceDiscovery": true,
10       "ServiceName": "PatrickLiuService",
11       "LoadBalancerOptions": { "Type": "RoundRobin" },
12       //IdentityServer 4 认证中心
13       "AuthenticationOptions": {
14         "AuthenticationProviderKey": "UserGatewayKey",
15         "AllowedScops": [ "User.Get", "Health.Check" ]
16       }
17     }
18   ],
19   "GlobalConfiguration": {
20     "BaseUrl": "http://localhost:6299",
21     "ServiceDiscoveryProvider": {
22       "Host": "localhost",
23       "Port": 8090,
24       "Type": "Consul",
25       "PollingInterval": 1000,//轮训 Consul，频率毫秒
26       "Token": "footoken"//需要ACL的话
27     }
28   }
29 }

　　　　　　　　　　【5】、修改 Program.cs 文件，使用上面增加的JSON配置文件。
　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　样例代码：　　　　　　　　　　　　　　　　　　　　　

 1 using Microsoft.AspNetCore.Hosting;
 2 using Microsoft.Extensions.Configuration;
 3 using Microsoft.Extensions.Hosting;
 4 
 5 namespace PatrickLiu.MicroService.Gateway
 6 {
 7     public class Program
 8     {
 9         public static void Main(string[] args)
10         {
11             CreateHostBuilder(args).Build().Run();
12         }
13 
14         public static IHostBuilder CreateHostBuilder(string[] args) =>
15             Host.CreateDefaultBuilder(args)
16                 .ConfigureAppConfiguration(config =>
17                 {
18                     config.AddJsonFile("configuration.json",optional:false,reloadOnChange:true);
19                 })
20                 .ConfigureWebHostDefaults(webBuilder =>
21                 {
22                     webBuilder.UseStartup<Startup>();
23                 });
24     }
25 }

          　　　　　　（7）、PatrickLiu.MicroService.AuthenticationCenter（ASP.NET CORE WEBAPI）,鉴权、授权中心，也可以称“认证服务器”。
                  　　　　　　　　　　

                 　　　　　　　　　　【1】、要想认证，必须安装IdentityServer4。
                        　　　　　　　　　　　　命令：Install-Package IdentityServer4
                        　　　　　　　　　　　　
                        　　　　　　　　　　　　当然也可以在项目下的【依赖项】上点右键，点击【管理NuGet程序包】菜单，在【浏览】项先安装，输入IdentityServer4，在右侧安装则可以。

                 　　　　　　　　　   【2】、修改 Startup.cs文件。
                        　　　　　　　　　　　　

                 　　　　　　　　　 【3】、增加一个类型 ClientInitConfig.cs文件。
                         　　　　　　　　　　　　　　
                                   　　　　　　　　代码样例：
                          　　　　　　　　　　　　

 1 using IdentityServer4.Models;
 2 using System.Collections.Generic;
 3 
 4 namespace PatrickLiu.MicroService.AuthenticationCenter
 5 {
 6     /// <summary>
 7     /// 自定义的配置文件。
 8     /// </summary>
 9     public class ClientInitConfig
10     {
11         /// <summary>
12         /// 获取资源的使用范围。
13         /// </summary>
14         /// <returns></returns>
15         public static IEnumerable<ApiScope> GetApiScopes()
16         {
17             return new List<ApiScope>
18             {
19                 //User API 
20                 new ApiScope(name: "User.Get",   displayName: "获取用户数据"),                
21 
22                 // Health API
23                 new ApiScope(name: "Health.Check",    displayName: "健康检查."),                
24             };
25         }
26 
27         /// <summary>
28         /// 获取能访问的资源。
29         /// </summary>
30         /// <returns></returns>
31         public static IEnumerable<ApiResource> GetApiResources()
32         {
33             return new List<ApiResource>
34             {
35                 new ApiResource("UserApi","Invoice API")
36                 {
37                     Scopes={ "User.Get", "Health.Check" }
38                 }
39             };
40         }
41 
42 
43         /// <summary>
44         /// 客户端的认证条件。
45         /// </summary>
46         /// <returns></returns>
47         public static IEnumerable<Client> GetClients()
48         {
49             return new List<Client> {
50                 new Client{
51                  ClientId="PatrickLiu.MicroService.AuthenticationDemo",
52                  ClientSecrets={new Secret("PatrickLiu123456".Sha256()) },
53                  AllowedGrantTypes=GrantTypes.ClientCredentials,
54                  AllowedScopes=new[]{ "User.Get", "Health.Check" },
55                  Claims=new List<ClientClaim>(){
56                  new ClientClaim(IdentityModel.JwtClaimTypes.Role,"Admin"),
57                  new ClientClaim(IdentityModel.JwtClaimTypes.NickName,"PatrickLiu"),
58                  new ClientClaim("eMail","PatrickLiu@sina.com")
59                  }
60                 }
61             };
62         }
63     }
64 }

    　　　　2、编译【PatrickLiu.MicroService.ServiceInstance】项目，发布4个服务实例，独立进程承载，形成服务集群。
           　　　　　　再次提醒大家，在开始启动这4个服务实例之前，必须启动Consul服务中心。
          　　　　　　（1）、dotnet PatrickLiu.MicroService.ServiceInstance.dll --urls="http://*:5726" --ip="127.0.0.1" --port=5726
　　　　　　　　　　　　　　
                                    　　　　健康检查如图：
                  　　　　　　　　　　

          　　　　　　（2）、dotnet PatrickLiu.MicroService.ServiceInstance.dll --urls="http://*:5727" --ip="127.0.0.1" --port=5727
　　　　　　　　　　　　　　
                                   　　　　健康检查如图：
                   　　　　　　　　　

          　　　　　　（3）、dotnet PatrickLiu.MicroService.ServiceInstance.dll --urls="http://*:5728" --ip="127.0.0.1" --port=5728
　　　　　　　　　　　　　
                                   　　　　健康检查如图：
                    　　　　　　　　

          　　　　　　（4）、dotnet PatrickLiu.MicroService.ServiceInstance.dll --urls="http://*:5729" --ip="127.0.0.1" --port=5729
　　　　　　　　　　　　　　
                                   　　　　健康检查如图：
                   　　　　　　　　
          　　　　　　　　以上是我们成功启动了4个服务实例，并且在Consul 服务中心注册成功，也可以执行健康检查，功能基本完善了。让我们看看4个服务实例在Consul中心的样子吧。
             　　　　　　　　　　
　　　　　　　　　　　　　　详情页
　　　　　　　　　　　　　　

    　　　　3、编译【PatrickLiu.MicroService.AuthenticationCenter】项目，发布鉴权、授权中心实例，独立进程承载，形成服务集群。
           　　　　　　（1）、启动鉴权、授权中心服务实例（如果提示“以一种访问权限不允许的方式做了一个访问套接字的尝试”错误，请先把项目清理一下，然后再重新生成，或者 --urls 参数要增加双引号，启动实例就可以）。
                   　　　　　　　　命令：dotnet PatrickLiu.MicroService.AuthenticationCenter.dll --urls="http://*: 7299" --port=7299
                   　　　　　　　　

           　　　　　　（2）、通过PostMan工具获取Token 数据，画红框的要特别注意。
                   　　　　　　　　访问地址：Http://localhost:7299/connect/token
　　　　　　　　　　　　　　


           　　　　　　（3）、基于Jwt.io网站验证Token数据。
                   　　　　　　　　访问地址：https://jwt.io/
                   　　　　　　　　　　

    　　　　4、编译【PatrickLiu.MicroService.Gateway】项目，发布3个网关服务实例，独立进程承载，形成服务集群。

          　　　　　　（1）、启动第一个网关实例（网关启动之前，确保服务实例项目【PatrickLiu.MicroService.ServiceInstance】已启动）。
                 　　　　　　　　命令：dotnet PatrickLiu.MicroService.Gateway.dll --urls=http://*:6297 --port=6297
                       　　　　　　

          　　　　　　（2）、启动第二个网关实例（网关启动之前，确保服务实例项目【PatrickLiu.MicroService.ServiceInstance】已启动）。
                 　　　　　　　　命令：dotnet PatrickLiu.MicroService.Gateway.dll --urls=http://*:6298 --port=6298
                       　　　　　　　　

          　　　　　　（3）、启动第三个网关实例（网关启动之前，确保服务实例项目【PatrickLiu.MicroService.ServiceInstance】已启动）。
                 　　　　　　　　命令：dotnet PatrickLiu.MicroService.Gateway.dll --urls=http://*:6299 --port=6299
                       　　　　      　　

          　　　　　　（4）、验证网关实例是否启动成功（切记，网关已经增加认证功能，提交参数要增加认证参数“Authentication”，否则就会返回401，提示未授权。特别说明：测试使用PostMan，主要是方便，没有使用客户端的代码）。

　　　　　　　　　　　　　
                  　　　　　　　　第一网关地址：http://localhost:6297/gate/users/all，能获取到数据表示一切成功。

                      　　　　　　　　　　截图如下：
                              　　　　　　　　　　
                             　　　　　　　　刷新地址
                             　　　　　　　　　　

                   　　　　　　　　第二网关地址：http://localhost:6298/gate/users/all，能获取到数据表示一切成功。

                      　　　　　　　　　　截图如下：
                              　　　　　　　　　　
                             　　　　　　　　刷新地址
                             　　　　　　　　　　

                   　　　　　　　　第三网关地址：http://localhost:6299/gate/users/all，能获取到数据表示一切成功。

                      　　　　　　　　　　截图如下：
                              　　　　　　　　　　　
                            　　　　　　　　 刷新地址
                              　　　　　　　　　　　　

          　　　　　　（5）、配置Ocelot网关集群的Nginx服务。
                       　　　　　　具体的下载方法，参考上面或者上文
                       　　　　　　目录地址：D:\Programs\MicroServices\CulsterOcelotNginx
                       　　　　　　配置信息：
                              　　　　　　

           　　　　　　（6）、验证Ocelot网关集群的Nginx服务地址。
                   　　　　　　　　Nginx地址：http://localhost:6400/gate/users/all，能获取到数据表示一切成功。

                       　　　　　　　　截图如下：
                               　　　　　　　　
                             　　　　　　刷新地址后
                              　　　　　　　　

            　　　　　　　　完美完成负载均衡和认证、授权，心里有些小激动。说明：客户端程序要访问的地址就是这个地址：http://localhost:6400/gate/users/all

三、搭建Consul服务的集群。

    　　　　　　
     　　　　在互联网的环境下，任何服务组件都很难通过单打独头，独立撑起一片天。随着分布式技术的发展和日益成熟，互联网的项目也开始进行分布式部署，或者是微服务架构部署。基于我们上一篇文章所介绍的，基于单点Consul搭建的微服务架构是有很大问题的。这种情况只是测试环境，不是真正的产品环境，如果我们想更接近产品环境，或者说，我们更接近真实环境，我们必须保证每个节点的高可用。
      　　　　Consul 用 Golang 实现，因此具有天然可移植性（支持 Linux、windows 和 Mac OS X )，它的安装包仅包含一个可执行文件，方便部署，与 Docker 等轻量级容器可无缝配合。
      　　　　在这里我们仅仅对Consul集群做简单的介绍，具体的详情可以自己去网上学习。Consul服务在Cluster集群上的每一个节点都运行一个Agent代理，这个Agent代理可以使用Server服务器或者Client客户端模式。Client客户端负责到Server服务器端的高效通信，相对为无状态的。 Server服务器端负责：包括选举领导节点，维护Cluster集群的状态，对所有的查询做出响应，跨数据中心的通信等等。
      　　　　Agent代理可以运行在Server服务器模式或者Client客户模式，每个数据中心至少有一个Agent代理运行在server服务器模式，一般建议是3或者5个Server。部署单个Server是非常不好的，因为在失败场景中出现数据丢失是不可避免的。我们今天要3个服务器端和1个客户端来完成我们今天的架构任务。

      　　　　名词解释：
     　　　　　　 A、Client ：Consul 的 Client模式，就是客户端模式。是 Consul 节点的一种模式，这种模式下，所有注册到当前节点的服务会被转发到 Server，本身不具有持久化数据的功能。
      　　　　　　B、Server ：Consul 的 Server 模式，表明这个 Consul 是个 Server ，这种模式下，功能和 Client 都一样，唯一不同的是，它会把所有的数据持久化的本地，这样遇到故障，信息是可以被保留的。
      　　　　　　C、Server-Leader：是所有服务器们的老大，它和其它 Server 不一样的一点是，它需要负责同步注册的信息给其它的 Server ，同时也要负责各个节点的健康监测。
      　　　　　　D、Raft：Server 节点之间的数据一致性保证协议使用的是 raft，而 Zookeeper 用的 PAXOS，ETCD采用的也是Raft服务发现协议，Consul 采用 http 和 DNS 协议，ETCD 只支持 http 。
      　　　　　　E、服务注册：Consul 支持两种方式实现服务注册，一种是通过 Consul 的服务注册API（Http协议），由服务自己调用 API 实现注册；另一种方式是通过 JSON 格式的配置文件实现注册，将需要注册的服务以 JSON 格式的配置文件给出。Consul 官方建议使用第二种方式。

　　　　　　Consul文档：https://www.consul.io/docs
　　　　　　Consul官网：https://www.consul.io

    　　　　我们开始在此搭建我们的Consul服务集群，以便改善单节点Consul的情况。
     　　　　1、我们开始现在Consul服务组件，存放在没有包含中文的目录里。
        　　　　　　下载地址：https://www.consul.io/downloads
          　　　　　　

     　　　　2、解压文件，并存放在你指定的工作目录。
          　　　　　　工作目录：D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows
          　　　　　　在这个目录下边，只有一个文件，consul.exe
          　　　　　　

    　　　　 3、开始启动服务实例，3个服务器端，一个客户端。
        　　　　　　Consul其实不需要安装，这里所说的安装，指的是配置Consul地址到环境变量中，这样就可以在cmd命令框中直接执行命令了，避免切换目录。如果自己不嫌麻烦，就不用配置环境变量，我就没有配置（主要执行次数少），每次执行就直接进入目录执行Consul文件，执行命令：consul.exe，也就是Consul的文件名。
        　　　　　　
        　　　　参数解释：
                　　　　consul agent：命令头，必须要有。
                　　　　-server：表示要启动服务器代理（agent）模式。Consul Agent节点的运行模式有两种，Server模式和Client模式。其区别就是Server模式数据可以持久化到本地，而Client模式不可以。
                　　　　-ui：consul运行后，会提供一个http://127.0.0.1:8500/ui/的网站，里面存储了Consul Agent各个节点以及注册的服务等相关信息，即数据中心的网页形式体现。这个参数代表是否创建这个网站，这个参数与这个数据中心网站有关。
                　　　　-bind：本机的IP地址，集群内其他代理服务器可以通过这个IP来访问这台电脑的consul代理服务器。
                　　　　-bootstrap-expect：是集群启动条件，指当服务器端模式（Server模式）的代理达到这个数目后，才开始运行。
                　　　　-data-dir：是存放数据中心数据的目录，该目录必须是稳定的，系统重启后也继续存在的。
                　　　　-config-dir：是存放数据中心日志的目录，该目录必须是稳定的，系统重启后也继续存在的。
                　　　　-datacenter：当前Consul的中心数据的名称，默认是dc1。
               　　　　-node：节点在集群中的名称，在一个集群中必须是唯一的，默认是该节点的主机名（代表一个机器）。
                　　　　-client：本地IP地址，这里使用 0.0.0.0 ，就表示这个服务器所有IP都可以，即当这台电脑有俩IP，192.168.1.100和192.168.1.111，那么通过这俩IP都可以访问到这台机器的consul代理服务器。
                　　　　-join：表示当前的服务器节点或者是客户端节点要加入集群的服务器，后面跟要加入的服务器的具体IP地址。

        　　　　　　安装完成后，Agent就可以启动了，我们开始搭建我们Consul集群了。
         　　　　　　（1）、创建Server-Leader，Consul集群中的领导者。
               　　　　　　　　命令：consul agent –server -ui -bootstrap-expect=3 -data-dir D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData -node=consul-Server1 –client=0.0.0.0 -bind=127.0.0.1 –datacenter=dc1 -config-dir D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData\config
               　　　　　　　　配置：
                     　　　　　　　　当前路径：D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData\config
                     　　　　　　　　JSON配置：
                             　　　　　　
               　　　　　　　　效果：
                     　　　　　　　　

         　　　　　　（2）、创建Server- Follower，Consul集群中的第一个追随者
               　　　　　　　　命令：consul agent –server -ui -bootstrap-expect=3 -data-dir D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData2 -node=consul-Server2 –client=0.0.0.0 -bind=127.0.0.1 -config-dir D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData2\config –datacenter=dc1 –join 127.0.0.1:8301
               　　　　　　　　配置：
                     　　　　　　　　当前路径：D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData2\config
                     　　　　　　　　JSON配置：
                             　　　　　　　　　　
              　　　　　　　　效果：
                     　　　　　　　　
                     　　　　　　成功加入第一个Consul服务所创建的集群
                     　　　　　　　　

         　　　　　　（3）、创建Server- Follower，Consul集群中的第二个追随者
               　　　　　　　　命令：consul agent –server -ui -bootstrap-expect=3 -data-dir D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData3 -node=consul-Server3 –client=0.0.0.0 -bind=127.0.0.1 -config-dir D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData3\config –datacenter=dc1 –join 127.0.0.1:8301
               　　　　　　　　配置：
                     　　　　　　　　当前路径：D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulData3\config
                     　　　　　　　　JSON配置：
                             　　　　　　　　　　
               　　　　　　　　效果：
                      　　　　　　　　

         　　　　　　（4）、创建Consul-Client ，Consul集群中的客户端。
               　　　　　　　　命令：consul agent -ui –client=0.0.0.0 –bind=127.0.0.1 -data-dir=D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulClient -node=consul-Client -config-dir=D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulClient\config –datacenter=dc1 -join 127.0.0.1:8301
              　　　　　　　　配置：
                     　　　　　　　　当前路径：D:\Programs\MicroServices\ConsulCluster\consul_1.8.4_windows\ConsulClient\config
                     　　　　　　　　JSON配置：
                             　　　　　　　　　　
               　　　　　　　　效果：
                     　　　　　　　　

    　　　　 4、验证3个服务器端和一个客户端是否安装成功。
         　　　　　　执行这些命令，都要切换到Consul所在的目录。切记。
         　　　　　　　（1）、consul members查看Consul成员列表。                        　　3个server,1个client,状态是：alive,说明集群创建成功。         　　（2）、我们在看看服务器角色的分配是否合适？               执行命令：consul operator raft list-peers

                　　　　　　　　　　

         　　　　　　（3）、我们也可以通过浏览器访问以下地址，验证Consul服务是否安装成功。
             　　　　　　　　　　第一主服务器： http://localhost:8500
              　　　　　　　　　　第二从服务器： http://localhost:9500
              　　　　　　　　　　第三从服务器： http://localhost:10500
              　　　　　　　　　　Consul客户端： http://localhost:11500
              　　　　　　　　　　能看到如下截图，也可以说明成功。我只截一个图了，其他都类似。
              　　　　　　　　　　

四、配置Nginx服务组件

      　　　　　　

      　　　　在这里我并不想对Nginx做更多的介绍，网上的资料太多了，我在这里只是简单说明一下，如果大家想去学习有关Nginx的知识，请去网上自行恶补了。还要说明一下，在进行这项工作之前，请确保上一步的工作配置完成，就是Consul集群的配置工作，因为在这一步里我们要配置Nginx，使用的地址信息就是Consul集群地址列表。
      　　　　Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器，同时也提供了IMAP/POP3/SMTP服务。Nginx是由伊戈尔·赛索耶夫为俄罗斯访问量第二的Rambler.ru站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源的消耗而闻名。2011年6月1日，Nginx 1.0.4发布。
     　　　　其特点是占有内存少，并发能力强，事实上Nginx的并发能力在同类型的网页服务器中表现较好，中国大陆使用Nginx网站用户有：百度、京东、新浪、网易、腾讯、淘宝等。

     　　　　1、下载Nginx服务组件。
          　　　　　　网关下载：http://nginx.org/en/download.html
          　　　　　　
         　　　　　　我下载的版本号是：1.18.0，随着时间推移，你们下的版本可能不一样，但是只要是稳定版本就可以了。

     　　　　2、解压到没有包含中文字符的目录里。
         　　　　　　Nginx 根目录：D:\Programs\MicroServices\ConsulNginx
         　　　　　　Nginx.Conf文件目录：D:\Programs\MicroServices\ConsulNginx\conf

     　　　　3、开始配置nginx.conf 文件，配置很简单，不多说了。
         　　　　　　
      　　　　　　　　
     　　　　4、启动Nginx 服务。
         　　　　　　执行命令：start nginx
         　　　　　　如果修改文件后可以执行：nginx –s reload
         　　　　　　如果想停止获或退出，可以执行：nginx –s stop|quit

　　　　　　　　　

     　　　　5、检查Nginx服务是否启动成功。
         　　　　　　我们可以通过访问以下地址，来验证Nginx配置是否正确。
          　　　　　　http://localhost:8090，打开地址，我们看到了Consul服务界面，说明配置和启动成功。
          　　　　　　

五、Ocelot服务治理组件简介

　　　　　　　　
　　　　今天要给大家介绍的Ocelot是一个基于 .net core的开源WebAPI服务网关项目，它的功能非常强大，包括了路由、请求聚合、服务发现、认证鉴权、限流、负载均衡等功能。而这些功能都可以直接通过修改json配置文件即可使用，非常方便。Ocelot是系统中对外暴露的一个请求入口，所有外部接口都必须通过这个网关才能向下游API发出请求，就如地铁中的安检系统，所有人都必须经过安检才能乘坐地铁。
当然了，我今天肯定也不会对Ocelot服务组件进行详细的讨论，它有官网和详细的文档，如果想看它的源码也是没有问题的，因为它是开源的。如果大家想去学习的话，可以直接点击我贴出的连接。

　　官网：https://threemammals.com/ocelot

　　　　文档：https://ocelot.readthedocs.io/en/latest

　　　　 GIT：https://github.com/ThreeMammals/Ocelot

六、我们可以看看客户端展示的效果了

          　　1、客户端我们自己实现的轮训策略，每次刷新，端口号都变，效果如图：

             　　　　5726端口的数据：
                   　　　　

              　　　　5727端口的数据：
                   　　　　

              　　　　5728端口的数据：
                   　　　　

              　　　　5729端口的数据：
                   　　　　

    　　　　2、我们的结论。

          　　　　　　虽然我们现在增加了Consul集群，也增加了Ocelot网关集群，每个集群也都有自己的Nginx服务实现负载均衡，系统从整体上来说，稳定性和高可用性得到了的保障，并且，我们的服务也已经有了安全认证，安全性大大加强，这样看似挺圆满的，这样就完成了吗？当然不是，还要Token过期的问题，和客户端集成的问题，当然IdentityServer的认证方式有很多种，在产品环境中，我们还有很多要改进的地方。但是这些问题，可能，我要放一放，我要把这些东西全部搬到Linux服务器上，全部实现虚拟化部署，当然也会涉及到Docker的使用。这也是我们下一篇文章要解决的问题，有挑战啊。

七、结束语
　　　　好了，今天就写到这里了。俗话说，兵来将挡水来土掩，只要我们勇往直前，道路一定是光明的，再者说，老天不会饿死努力的小鸟的。努力吧，每天进步一点点。

posted on 2020-12-11 15:55 可均可可阅读(2264) 评论(3) 编辑收藏举报

刷新页面返回顶部