【.NET Core項目實戰-統一認證平臺】第十五章網關篇-使用二級緩存提高性能

時間 2019-11-05

標籤 core 項目實戰統一認證平臺第十五網關使用二級緩存提高性能欄目系統性能简体版

原文原文鏈接

【.NET Core項目實戰-統一認證平臺】開篇及目錄索引

1、背景

首先說聲抱歉，多是由於假期綜合症（其實就是由於懶哈）的緣由，已經很長時間沒更新博客了，如今也調整的差很少了，準備仍是以每週1-2篇的進度來更新博客，並完成本項目全部功能。html

言歸正傳，本重構項目是在我根據實際需求重構，因爲還未徹底寫完，因此也沒進行壓測，在2月份時，張善友老師給我留言說通過壓測發現我重構的Ocelot網關功能性能較差，其中根本緣由就是緩存模塊，因爲重構項目的緩存強依賴Redis緩存，形成性能瓶頸，發現問題後，我也第一時間進行測試，性能影響很大，通過跟張老師請教，可使用二級緩存來解決性能問題，首先感謝張老師關注並指點迷津，因而就有了這篇文章，如何把現有緩存改爲二級緩存並使用。node

2、改造思路

爲了解決redis的強依賴性，首先須要把緩存數據存儲到本地，全部請求都優先從本地提取，若是提取不到再從redis提取，若是redis無數據，在從數據庫中提取。提取流程以下：git

MemoryCache > Redis > dbgithub

此種方式減小提取緩存的網絡開銷，也合理利用了分佈式緩存，並最終減小數據庫的訪問開銷。可是使用此種方案也面臨了一個問題是如何保證集羣環境時每一個機器本地緩存數據的一致性，這時咱們會想到redis的發佈、訂閱特性，在數據發生變更時更新redis數據併發布緩存更新通知，由每一個集羣機器訂閱變動事件，而後處理本地緩存記錄，最終達到集羣緩存的緩存一致性。redis

可是此方式對於緩存變動很是頻繁的業務不適用，好比限流策略（準備仍是使用分佈式redis緩存實現），可是能夠擴展配置單機限流時使用本地緩存實現，若是誰有更好的實現方式，也麻煩告知下集羣環境下限流的實現，不勝感激。數據庫

3、改造代碼

首先須要分析下目前改造後的Ocelot網關在哪些業務中使用的緩存，而後把使用本地緩存的的業務重構，增長提取數據流程，最後提供網關外部緩存初始化接口，便於與業務系統進行集成。c#

1.重寫緩存方法api

找到問題的緣由後，就能夠重寫緩存方法，增長二級緩存支持，默認使用本地的緩存，新建CzarMemoryCache類，來實現IOcelotCache<T>方法，實現代碼以下。緩存

using Czar.Gateway.Configuration;
using Czar.Gateway.RateLimit;
using Microsoft.Extensions.Caching.Memory;
using Ocelot.Cache;
using System;

namespace Czar.Gateway.Cache
{
    /// <summary>
    /// 金焰的世界
    /// 2019-03-03
    /// 使用二級緩存解決集羣環境問題
    /// </summary>
    public class CzarMemoryCache<T> : IOcelotCache<T>
    {
        private readonly CzarOcelotConfiguration _options;
        private readonly IMemoryCache _cache;
        public CzarMemoryCache(CzarOcelotConfiguration options,IMemoryCache cache)
        {
            _options = options;
            _cache = cache;
        }
        public void Add(string key, T value, TimeSpan ttl, string region)
        {
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix,region, key);
            if (_options.ClusterEnvironment)
            {
                var msg = value.ToJson();
                if (typeof(T) == typeof(CachedResponse))
                {//帶過時時間的緩存
                    _cache.Set(key, value, ttl); //添加本地緩存
                    RedisHelper.Set(key, msg); //加入redis緩存
                    RedisHelper.Publish(key, msg); //發佈
                }
                else if (typeof(T) == typeof(CzarClientRateLimitCounter?))
                {//限流緩存，直接使用redis
                    RedisHelper.Set(key, value, (int)ttl.TotalSeconds);
                }
                else
                {//正常緩存,發佈
                    _cache.Set(key, value, ttl); //添加本地緩存
                    RedisHelper.Set(key, msg); //加入redis緩存
                    RedisHelper.Publish(key, msg); //發佈
                }
            }
            else
            {
                _cache.Set(key, value, ttl); //添加本地緩存
            }
        }

        public void AddAndDelete(string key, T value, TimeSpan ttl, string region)
        {
            Add(key, value, ttl, region);
        }

        public void ClearRegion(string region)
        {
            if (_options.ClusterEnvironment)
            {
                var keys = RedisHelper.Keys(region + "*");
                RedisHelper.Del(keys);
                foreach (var key in keys)
                {
                    RedisHelper.Publish(key, ""); //發佈key值爲空，處理時刪除便可。
                }
            }
            else
            {
                _cache.Remove(region);
            }
        }

        public T Get(string key, string region)
        {
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            if(region== CzarCacheRegion.CzarClientRateLimitCounterRegion&& _options.ClusterEnvironment)
            {//限流且開啓了集羣支持，默認從redis取
                return RedisHelper.Get<T>(key);
            }
            var result = _cache.Get<T>(key);
            if (result == null&& _options.ClusterEnvironment)
            {
                result= RedisHelper.Get<T>(key);
                if (result != null)
                {
                    if (typeof(T) == typeof(CachedResponse))
                    {//查看redis過時時間
                        var second = RedisHelper.Ttl(key);
                        if (second > 0)
                        {
                            _cache.Set(key, result, TimeSpan.FromSeconds(second));
                        }
                    }
                    else
                    {
                        _cache.Set(key, result, TimeSpan.FromSeconds(_options.CzarCacheTime));
                    }
                }
            }
            return result;
        }
    }
}

上面就段代碼實現了本地緩存和Redis緩存的支持，優先從本地提取，若是在集羣環境使用，增長redis緩存支持，可是此種方式不適用緩存變動很是頻繁場景，好比客戶端限流的實現，因此在代碼中把客戶端限流的緩存直接使用redis緩存實現。服務器

2.注入實現和訂閱

有了實現代碼後，發現還缺乏添加緩存注入和配置信息修改。首先須要修改配置文件來知足是否開啓集羣判斷，而後須要實現redis的不一樣部署方式可以經過配置文件配置進行管理，避免硬編碼致使的不可用問題。

配置文件CzarOcelotConfiguration.cs修改代碼以下：

namespace Czar.Gateway.Configuration
{
    /// <summary>
    /// 金焰的世界
    /// 2018-11-11
    /// 自定義配置信息
    /// </summary>
    public class CzarOcelotConfiguration
    {
        /// <summary>
        /// 數據庫鏈接字符串，使用不一樣數據庫時自行修改,默認實現了SQLSERVER
        /// </summary>
        public string DbConnectionStrings { get; set; }

        /// <summary>
        /// 金焰的世界
        /// 2018-11-12
        /// 是否啓用定時器，默認不啓動
        /// </summary>
        public bool EnableTimer { get; set; } = false;

        /// <summary>
        /// 金焰的世界
        /// 2018-11.12
        /// 定時器週期，單位（毫秒），默認30分總自動更新一次
        /// </summary>
        public int TimerDelay { get; set; } = 30 * 60 * 1000;

        /// <summary>
        /// 金焰的世界
        /// 2018-11-14
        /// Redis鏈接字符串
        /// </summary>
        public string RedisConnectionString { get; set; }

        /// <summary>
        /// 金焰的世界
        /// 2019-03-03
        /// 配置哨兵或分區時使用
        /// </summary>
        public string[] RedisSentinelOrPartitionConStr { get; set; }

        /// <summary>
        /// 金焰的世界
        /// 2019-03-03
        /// Redis部署方式，默認使用普通方式
        /// </summary>
        public RedisStoreMode RedisStoreMode { get; set; } = RedisStoreMode.Normal;

        /// <summary>
        /// 金焰的計界
        /// 2019-03-03
        /// 作集羣緩存同步時使用，會訂閱全部正則匹配的事件
        /// </summary>
        public string RedisOcelotKeyPrefix { get; set; } = "CzarOcelot";

        /// <summary>
        /// 金焰的世界
        /// 2019-03-03
        /// 是否啓用集羣環境，若是非集羣環境直接本地緩存+數據庫便可
        /// </summary>
        public bool ClusterEnvironment { get; set; } = false;

        /// <summary>
        /// 金焰的世界
        /// 2018-11-15
        /// 是否啓用客戶端受權,默認不開啓
        /// </summary>
        public bool ClientAuthorization { get; set; } = false;

        /// <summary>
        /// 金焰的世界
        /// 2018-11-15
        /// 服務器緩存時間，默認30分鐘
        /// </summary>
        public int CzarCacheTime { get; set; } = 1800;
        /// <summary>
        /// 金焰的世界
        /// 2018-11-15
        /// 客戶端標識，默認 client_id
        /// </summary>
        public string ClientKey { get; set; } = "client_id";

        /// <summary>
        /// 金焰的世界
        /// 2018-11-18
        /// 是否開啓自定義限流，默認不開啓
        /// </summary>
        public bool ClientRateLimit { get; set; } = false;
    }
}

在配置文件中修改了redis相關配置，支持使用redis的普通模式、集羣模式、哨兵模式、分區模式，配置方式可參考csrediscore開源項目。

而後修改ServiceCollectionExtensions.cs代碼，注入相關實現和redis客戶端。

builder.Services.AddMemoryCache(); //添加本地緩存
            #region 啓動Redis緩存，並支持普通模式 官方集羣模式  哨兵模式 分區模式
            if (options.ClusterEnvironment)
            {
                //默認使用普通模式
                var csredis = new CSRedis.CSRedisClient(options.RedisConnectionString);
                switch (options.RedisStoreMode)
                {
                    case RedisStoreMode.Partition:
                        var NodesIndex = options.RedisSentinelOrPartitionConStr;
                        Func<string, string> nodeRule = null;
                        csredis = new CSRedis.CSRedisClient(nodeRule, options.RedisSentinelOrPartitionConStr);
                        break;
                    case RedisStoreMode.Sentinel:
                        csredis = new CSRedis.CSRedisClient(options.RedisConnectionString, options.RedisSentinelOrPartitionConStr);
                        break;
                }
                //初始化 RedisHelper
                RedisHelper.Initialization(csredis);
            }
            #endregion
            builder.Services.AddSingleton<IOcelotCache<FileConfiguration>, CzarMemoryCache<FileConfiguration>>();
            builder.Services.AddSingleton<IOcelotCache<InternalConfiguration>, CzarMemoryCache<InternalConfiguration>>();
            builder.Services.AddSingleton<IOcelotCache<CachedResponse>, CzarMemoryCache<CachedResponse>>();
            builder.Services.AddSingleton<IInternalConfigurationRepository, RedisInternalConfigurationRepository>();
            builder.Services.AddSingleton<IOcelotCache<ClientRoleModel>, CzarMemoryCache<ClientRoleModel>>();
            builder.Services.AddSingleton<IOcelotCache<RateLimitRuleModel>, CzarMemoryCache<RateLimitRuleModel>>();
            builder.Services.AddSingleton<IOcelotCache<RemoteInvokeMessage>, CzarMemoryCache<RemoteInvokeMessage>>();
            builder.Services.AddSingleton<IOcelotCache<CzarClientRateLimitCounter?>, CzarMemoryCache<CzarClientRateLimitCounter?>>();

如今須要實現redis訂閱來更新本地的緩存信息，在項目啓動時判斷是否開啓集羣模式，若是開啓就啓動訂閱，實現代碼以下：

public static async Task<IApplicationBuilder> UseCzarOcelot(this IApplicationBuilder builder, OcelotPipelineConfiguration pipelineConfiguration)
{
    //重寫建立配置方法
    var configuration = await CreateConfiguration(builder);
    ConfigureDiagnosticListener(builder);
    CacheChangeListener(builder);
    return CreateOcelotPipeline(builder, pipelineConfiguration);
}
/// <summary>
/// 金焰的世界
/// 2019-03-03
/// 添加緩存數據變動訂閱
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
private static void CacheChangeListener(IApplicationBuilder builder)
{
    var config= builder.ApplicationServices.GetService<CzarOcelotConfiguration>();
    var _cache= builder.ApplicationServices.GetService<IMemoryCache>();
    if (config.ClusterEnvironment)
    {
        //訂閱知足條件的全部事件
        RedisHelper.PSubscribe(new[] { config.RedisOcelotKeyPrefix + "*" }, message =>
              {
                  var key = message.Channel;
                  _cache.Remove(key); //直接移除，若是有請求從redis裏取
                  //或者直接判斷本地緩存是否存在，若是存在更新，可自行實現。
              });
    }
}

使用的是從配置文件提取的正則匹配的全部KEY都進行訂閱，因爲本地緩存增長了定時過時策略，因此爲了實現方便，當發現redis數據發生變化，全部訂閱端直接移除本地緩存便可，若是有新的請求直接從redis取，而後再次緩存，防止集羣客戶端緩存信息不一致。

爲了區分不一樣的緩存實體，便於在原始數據發送變動時進行更新，定義CzarCacheRegion類。

namespace Czar.Gateway.Configuration
{
    /// <summary>
    /// 緩存所屬區域
    /// </summary>
    public class CzarCacheRegion
    {
        /// <summary>
        /// 受權
        /// </summary>
        public const string AuthenticationRegion = "CacheClientAuthentication";

        /// <summary>
        /// 路由配置
        /// </summary>
        public const string FileConfigurationRegion = "CacheFileConfiguration";

        /// <summary>
        /// 內部配置
        /// </summary>
        public const string InternalConfigurationRegion = "CacheInternalConfiguration";

        /// <summary>
        /// 客戶端權限
        /// </summary>
        public const string ClientRoleModelRegion = "CacheClientRoleModel";

        /// <summary>
        /// 限流規則
        /// </summary>
        public const string RateLimitRuleModelRegion = "CacheRateLimitRuleModel";

        /// <summary>
        /// Rpc遠程調用
        /// </summary>
        public const string RemoteInvokeMessageRegion = "CacheRemoteInvokeMessage";

        /// <summary>
        /// 客戶端限流
        /// </summary>
        public const string CzarClientRateLimitCounterRegion = "CacheCzarClientRateLimitCounter";
    }
}

如今只須要修改緩存的region爲定義的值便可，惟一須要改動的代碼就是把以前寫死的代碼改爲以下代碼便可。

var enablePrefix = CzarCacheRegion.AuthenticationRegion;

3.開發緩存變動接口

如今整個二級緩存基本完成，可是還遇到一個問題就是外部如何根據數據庫變動數據時來修改緩存數據，這時就須要提供外部修改api來實現。

添加CzarCacheController.cs對外部提供緩存更新相關接口,詳細代碼以下：

using Czar.Gateway.Authentication;
using Czar.Gateway.Configuration;
using Czar.Gateway.RateLimit;
using Czar.Gateway.Rpc;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using Ocelot.Configuration;
using Ocelot.Configuration.Creator;
using Ocelot.Configuration.Repository;
using System;
using System.Threading.Tasks;

namespace Czar.Gateway.Cache
{
    /// <summary>
    /// 提供外部緩存處理接口
    /// </summary>
    [Authorize]
    [Route("CzarCache")]
    public class CzarCacheController : Controller
    {
        private readonly CzarOcelotConfiguration _options;
        private readonly IClientAuthenticationRepository _clientAuthenticationRepository;
        private IFileConfigurationRepository _fileConfigurationRepository;
        private IInternalConfigurationCreator _internalConfigurationCreator;
        private readonly IClientRateLimitRepository _clientRateLimitRepository;
        private readonly IRpcRepository _rpcRepository;
        private readonly IMemoryCache _cache;
        public CzarCacheController(IClientAuthenticationRepository clientAuthenticationRepository, CzarOcelotConfiguration options,
          IFileConfigurationRepository fileConfigurationRepository,
          IInternalConfigurationCreator internalConfigurationCreator,
          IClientRateLimitRepository clientRateLimitRepository,
          IRpcRepository rpcRepository,
          IMemoryCache cache)
        {
            _clientAuthenticationRepository = clientAuthenticationRepository;
            _options = options;
            _fileConfigurationRepository = fileConfigurationRepository;
            _internalConfigurationCreator = internalConfigurationCreator;
            _clientRateLimitRepository = clientRateLimitRepository;
            _rpcRepository = rpcRepository;
            _cache = cache;
        }

        /// <summary>
        /// 更新客戶端地址訪問受權接口
        /// </summary>
        /// <param name="clientid">客戶端ID</param>
        /// <param name="path">請求模板</param>
        /// <returns></returns>
        [HttpPost]
        [Route("ClientRule")]
        public async Task UpdateClientRuleCache(string clientid, string path)
        {
            var region = CzarCacheRegion.AuthenticationRegion;
            var key = CzarOcelotHelper.ComputeCounterKey(region, clientid, "", path);
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            var result = await _clientAuthenticationRepository.ClientAuthenticationAsync(clientid, path);
            var data = new ClientRoleModel() { CacheTime = DateTime.Now, Role = result };
            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, data); //加入redis緩存
                RedisHelper.Publish(key, data.ToJson()); //發佈事件
            }
            else
            {
                _cache.Remove(key);
            }
        }

        /// <summary>
        /// 更新網關配置路由信息
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("InternalConfiguration")]
        public async Task UpdateInternalConfigurationCache()
        {
            var key = CzarCacheRegion.InternalConfigurationRegion;
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, "", key);
            var fileconfig = await _fileConfigurationRepository.Get();
            var internalConfig = await _internalConfigurationCreator.Create(fileconfig.Data);
            var config = (InternalConfiguration)internalConfig.Data;
            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, config); //加入redis緩存
                RedisHelper.Publish(key, config.ToJson()); //發佈事件
            }
            else
            {
                _cache.Remove(key);
            }
        }

        /// <summary>
        /// 刪除路由配合的緩存信息
        /// </summary>
        /// <param name="region">區域</param>
        /// <param name="downurl">下端路由</param>
        /// <returns></returns>
        [HttpPost]
        [Route("Response")]
        public async Task DeleteResponseCache(string region,string downurl)
        {
            var key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, downurl);
            if (_options.ClusterEnvironment)
            {
                await RedisHelper.DelAsync(key);
                RedisHelper.Publish(key, "");//發佈時間
            }
            else
            {
                _cache.Remove(key);
            }
        }

        /// <summary>
        /// 更新客戶端限流規則緩存
        /// </summary>
        /// <param name="clientid">客戶端ID</param>
        /// <param name="path">路由模板</param>
        /// <returns></returns>
        [HttpPost]
        [Route("RateLimitRule")]
        public async Task UpdateRateLimitRuleCache(string clientid, string path)
        {
            var region = CzarCacheRegion.RateLimitRuleModelRegion;
            var key = clientid + path;
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            var result = await _clientRateLimitRepository.CheckClientRateLimitAsync(clientid, path);
            var data = new RateLimitRuleModel() { RateLimit = result.RateLimit, rateLimitOptions = result.rateLimitOptions };
            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, data); //加入redis緩存
                RedisHelper.Publish(key, data.ToJson()); //發佈事件
            }
            else
            {
                _cache.Remove(key);
            }
        }

        /// <summary>
        /// 更新客戶端是否開啓限流緩存
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ClientRole")]
        public async Task UpdateClientRoleCache(string path)
        {
            var region = CzarCacheRegion.ClientRoleModelRegion;
            var key = path;
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            var result = await _clientRateLimitRepository.CheckReRouteRuleAsync(path);
            var data = new ClientRoleModel() { CacheTime = DateTime.Now, Role = result };
            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, data); //加入redis緩存
                RedisHelper.Publish(key, data.ToJson()); //發佈事件
            }
            else
            {
                _cache.Remove(key);
            }
        }

        /// <summary>
        /// 更新呢客戶端路由白名單緩存
        /// </summary>
        /// <param name="clientid"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ClientReRouteWhiteList")]
        public async Task UpdateClientReRouteWhiteListCache(string clientid, string path)
        {
            var region = CzarCacheRegion.ClientReRouteWhiteListRegion;
            var key = clientid + path;
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            var result = await _clientRateLimitRepository.CheckClientReRouteWhiteListAsync(clientid, path);
            var data = new ClientRoleModel() { CacheTime = DateTime.Now, Role = result };
            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, data); //加入redis緩存
                RedisHelper.Publish(key, data.ToJson()); //發佈事件
            }
            else
            {
                _cache.Remove(key);
            }
        }

        [HttpPost]
        [Route("Rpc")]
        public async Task UpdateRpcCache(string UpUrl)
        {
            var region = CzarCacheRegion.RemoteInvokeMessageRegion;
            var key = UpUrl;
            key = CzarOcelotHelper.GetKey(_options.RedisOcelotKeyPrefix, region, key);
            var result = await _rpcRepository.GetRemoteMethodAsync(UpUrl);
            if (_options.ClusterEnvironment)
            {
                RedisHelper.Set(key, result); //加入redis緩存
                RedisHelper.Publish(key, result.ToJson()); //發佈事件
            }
            else
            {
                _cache.Remove(key);
            }
        }
    }
}

如今基本實現整個緩存的更新策略，只要配合後臺管理界面，在相關緩存原始數據發送變動時，調用對應接口便可完成redis緩存的更新，並自動通知集羣的全部本機清理緩存等待從新獲取。

接口的調用方式參考以前我寫的配置信息接口變動那篇便可。

4、性能測試

完成了改造後，咱們拿改造前網關、改造後網關、原始Ocelot、直接調用API四個環境分別測試性能指標，因爲測試環境有效，我直接使用本機環境，而後是Apache ab測試工具測試下相關性能（本測試不必定準確，只做爲參考指標），測試的方式是使用100個併發請求10000次，測試結果分別以下。

一、改造前網關性能

二、改造後網關性能

三、Ocelot默認網關性能

四、直接調用API性能

本測試僅供參考，由於因爲網關和服務端都在本機環境部署，因此使用網關和不使用網關性能差異很是小，若是分開部署可能性別差異會明顯寫，這不是本篇討論的重點。

從測試中能夠看到，重構的網關改造前和改造後性能有2倍多的提高，且與原生的Ocelot性能很是接近。

5、總結

本篇主要講解了如何使用redis的發佈訂閱來實現二級緩存功能，並提供了緩存的更新相關接口供外部程序調用，避免出現集羣環境下沒法更新緩存數據致使提取數據不一致狀況，可是針對每一個客戶端獨立限流這塊集羣環境目前仍是採用的redis的方式未使用本地緩存，若是有寫的不對或有更好方式的，也但願多提寶貴意見。

本篇相關源碼地址：https://github.com/jinyancao/czar.gateway