Using Redis as a cache storage for for multiple application on the same server

Question

I want to use Redis as a cache storage for multiple applications on the same physical machine.

I know at least two ways of doing it:

1. by running several Redis instances on different ports;
2. by using different Redis databases for different applications.

But I don't know which one is better for me.

What are advantages and disadvantages of these methods?

Is there any better way of doing it?

Answer 1

Generally, you should prefer the 1st approach, i.e. dedicated Redis servers. Shared databases are managed by the same Redis process and can therefore block each other. Additionally, shared databases share the same configuration (although in your case this may not be an issue since all databases are intended for caching). Lastly, shared databases are not supported by Redis Cluster.

For more information refer to this blog post: https://redislabs.com/blog/benchmark-shared-vs-dedicated-redis-instances

Answer 2

You can use different cache manager for each application will also work same way I am using. like :

@Bean(name = "myCacheManager")
    public CacheManager cacheManager(RedisTemplate<String, Object> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager;
    }

    @Bean(name ="customKeyGenerator")
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                // This will generate a unique key of the class name, the method name,
                // and all method parameters appended.
                StringBuilder sb = new StringBuilder();
                sb.append(o.getClass().getName());
                sb.append(method.getName());
                for (Object obj : objects) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

Answer 3

We solved this problem by namespacing the keys. Initially we tried using databases where each database ID would be used for a specific application. However, that idea was not scalable since there is a limited number of databases, plus in Premium offerings (like Azure Cache for Redis Premium instances with Sharding enabled), the concept of database is not used.

The solution we used is attaching a unique prefix for all keys. Each application would be annotated with a unique moniker which would be prefixed in front of each key.

To reduce churn, we have built a framework (URP). If you are using StackExchange.Redis then you will be able to use the URP SDK directly. If it helps, I have added some of the references.

1. Source Code and Documentation - https://github.com/microsoft/UnifiedRedisPlatform.Core/wiki/Management-Console
2. Blog Post (idea) - https://www.devcompost.com/post/__urp