azure - Azure 上的 StackExchange.Redis 抛出执行获取超时且无连接可用异常

Question

我最近将一个提供数据源和动态生成图像(6k rpm 吞吐量)的 MVC 应用程序从 v3.9.67 ServiceStack.Redis 客户端切换到最新的 StackExchange.Redis 客户端 (v1.0.450)，我发现速度有些慢性能和一些新的异常。

我们的 Redis 实例是 S4 级别 (13GB)，CPU 显示相当稳定的 45% 左右，网络带宽显得相当低。我不完全确定如何解释我们的 Azure 门户中的获取/设置图表，但它向我们显示了大约 1M 获取和 100k 集(看起来这可能以 5 分钟为增量)。

客户端库切换很简单，我们仍在使用 v3.9 ServiceStack JSON 序列化器，因此客户端库是唯一发生变化的部分。

我们使用 New Relic 进行的外部监控清楚地表明，ServiceStack 和 StackExchange 库之间的平均响应时间从约 200 毫秒增加到约 280 毫秒(StackExchange 较慢)，而没有其他变化。

我们记录了许多异常情况，其消息大致如下:

Timeout performing GET feed-channels:ag177kxj_egeo-_nek0cew, inst: 12, mgr: Inactive, queue: 30, qu=0, qs=30, qc=0, wr=0/0, in=0/0

我理解这意味着队列中有许多命令已发送，但 Redis 没有可用的响应，这可能是由于长时间运行的命令超过超时而导致的。这些错误是在备份我们的一个数据服务背后的 SQL 数据库时出现的，所以也许这就是原因？在扩展该数据库以减少负载后，我们没有看到更多的此错误，但数据库查询应该发生在 .Net 中，我不知道这将如何阻止 redis 命令或连接。

今天早上，我们还在短时间内(几分钟)记录了大量错误，其中包含以下消息:

No connection is available to service this operation: SETEX feed-channels:vleggqikrugmxeprwhwc2a:last-retry

我们习惯了 ServiceStack 库的短暂连接错误，这些异常消息通常是这样的:

Unable to Connect: sPort: 63980

我的印象是 SE.Redis 应该在后台为我重试连接和命令。我是否仍然需要将我们的调用通过 SE.Redis 封装在我自己的重试策略中？也许不同的超时值会更合适(尽管我不确定使用什么值)？

我们的 Redis 连接字符串设置这些参数:abortConnect=false,syncTimeout=2000,ssl=true。我们使用 ConnectionMultiplexer 的单例实例和 IDatabase 的 transient 实例。

我们绝大多数的 Redis 使用都是通过 Cache 类进行的，下面是实现的重要部分，以防我们做一些愚蠢的事情而导致问题。

我们的 key 一般是10-30个左右的字符串。值主要是标量或相当小的序列化对象集(通常为数百字节到几 kB)，尽管我们也在缓存中存储 jpg 图像，因此大部分数据从几百 kB 到几 MB。

也许我应该对小值和大值使用不同的多路复用器，对于较大的值可能需要更长的超时？或者几个/几个多路复用器以防万一出现故障？

public class Cache : ICache
{
    private readonly IDatabase _redis;

    public Cache(IDatabase redis)
    {
        _redis = redis;
    }

    // storing this placeholder value allows us to distinguish between a stored null and a non-existent key
    // while only making a single call to redis. see Exists method.
    static readonly string NULL_PLACEHOLDER = "$NULL_VALUE$";

    // this is a dictionary of https://github.com/StephenCleary/AsyncEx/wiki/AsyncLock
    private static readonly ILockCache _locks = new LockCache();

    public T GetOrSet<T>(string key, TimeSpan cacheDuration, Func<T> refresh) {
        T val;
        if (!Exists(key, out val)) {
            using (_locks[key].Lock()) {
                if (!Exists(key, out val)) {
                    val = refresh();
                    Set(key, val, cacheDuration);
                }
            }
        }
        return val;
    }

    private bool Exists<T>(string key, out T value) {
        value = default(T);
        var redisValue = _redis.StringGet(key);

        if (redisValue.IsNull)
            return false;

        if (redisValue == NULL_PLACEHOLDER)
            return true;

        value = typeof(T) == typeof(byte[])
            ? (T)(object)(byte[])redisValue
            : JsonSerializer.DeserializeFromString<T>(redisValue);

        return true;
    }

    public void Set<T>(string key, T value, TimeSpan cacheDuration)
    {
        if (value.IsDefaultForType())
            _redis.StringSet(key, NULL_PLACEHOLDER, cacheDuration);
        else if (typeof (T) == typeof (byte[]))
            _redis.StringSet(key, (byte[])(object)value, cacheDuration);
        else
            _redis.StringSet(key, JsonSerializer.SerializeToString(value), cacheDuration);
    }


    public async Task<T> GetOrSetAsync<T>(string key, Func<T, TimeSpan> getSoftExpire, TimeSpan additionalHardExpire, TimeSpan retryInterval, Func<Task<T>> refreshAsync) {
        var softExpireKey = key + ":soft-expire";
        var lastRetryKey = key + ":last-retry";

        T val;
        if (ShouldReturnNow(key, softExpireKey, lastRetryKey, retryInterval, out val)) 
            return val;

        using (await _locks[key].LockAsync()) {
            if (ShouldReturnNow(key, softExpireKey, lastRetryKey, retryInterval, out val))
                return val;

            Set(lastRetryKey, DateTime.UtcNow, additionalHardExpire);

            try {
                var newVal = await refreshAsync();
                var softExpire = getSoftExpire(newVal);
                var hardExpire = softExpire + additionalHardExpire;

                if (softExpire > TimeSpan.Zero) {
                    Set(key, newVal, hardExpire);
                    Set(softExpireKey, DateTime.UtcNow + softExpire, hardExpire);
                }
                val = newVal;
            }
            catch (Exception ex) {
                if (val == null)
                    throw;
            }
        }

        return val;
    }

    private bool ShouldReturnNow<T>(string valKey, string softExpireKey, string lastRetryKey, TimeSpan retryInterval, out T val) {
        if (!Exists(valKey, out val))
            return false;

        var softExpireDate = Get<DateTime?>(softExpireKey);
        if (softExpireDate == null)
            return true;

        // value is in the cache and not yet soft-expired
        if (softExpireDate.Value >= DateTime.UtcNow)
            return true;

        var lastRetryDate = Get<DateTime?>(lastRetryKey);

        // value is in the cache, it has soft-expired, but it's too soon to try again
        if (lastRetryDate != null && DateTime.UtcNow - lastRetryDate.Value < retryInterval) {
            return true;
        }

        return false;
    }
}

Answer 1

一些建议。- 您可以针对不同类型的键/值使用具有不同超时值的不同多路复用器 http://azure.microsoft.com/en-us/documentation/articles/cache-faq/- 确保您的客户端和服务器未受网络限制。如果您在服务器上，则转移到具有更多带宽的更高 SKU请阅读这篇文章了解更多详情 http://azure.microsoft.com/blog/2015/02/10/investigating-timeout-exceptions-in-stackexchange-redis-for-azure-redis-cache/