Redis est-il plus rapide que MongoDB ?

Question

Il est largement mentionné que Redis est "Blazing Fast" et que MongoDB est également rapide. Mais j'ai du mal à trouver des chiffres réels comparant les résultats des deux. Avec des configurations, des fonctionnalités et des opérations similaires (et peut-être en montrant comment le facteur change avec différentes configurations et opérations), etc. Redis est-il 10x plus rapide ? 2x plus rapide ? 5x plus rapide ?

Je parle UNIQUEMENT de performance. Je comprends que MongoDB est un outil différent et qu'il dispose d'un ensemble de fonctionnalités plus riche. Il ne s'agit pas de la question "Est-ce que mongoDB meilleur que Redis". Je pose la question suivante : de combien Redis est-il plus performant que MongoDB ?

À ce stade, même des repères bon marché sont préférables à l'absence de repères.

Answer 1

Les résultats bruts de l'analyse comparative suivante : 2x écriture, 3x lecture .

Voici un simple benchmark en python que vous pouvez adapter à vos besoins. J'ai cherché à savoir si chacun d'entre eux pouvait simplement définir/récupérer des valeurs :

#!/usr/bin/env python2.7
import sys, time
from pymongo import Connection
import redis

# connect to redis & mongodb
redis = redis.Redis()
mongo = Connection().test
collection = mongo['test']
collection.ensure_index('key', unique=True)

def mongo_set(data):
    for k, v in data.iteritems():
        collection.insert({'key': k, 'value': v})

def mongo_get(data):
    for k in data.iterkeys():
        val = collection.find_one({'key': k}, fields=('value',)).get('value')

def redis_set(data):
    for k, v in data.iteritems():
        redis.set(k, v)

def redis_get(data):
    for k in data.iterkeys():
        val = redis.get(k)

def do_tests(num, tests):
    # setup dict with key/values to retrieve
    data = {'key' + str(i): 'val' + str(i)*100 for i in range(num)}
    # run tests
    for test in tests:
        start = time.time()
        test(data)
        elapsed = time.time() - start
        print "Completed %s: %d ops in %.2f seconds : %.1f ops/sec" % (test.__name__, num, elapsed, num / elapsed)

if __name__ == '__main__':
    num = 1000 if len(sys.argv) == 1 else int(sys.argv[1])
    tests = [mongo_set, mongo_get, redis_set, redis_get] # order of tests is significant here!
    do_tests(num, tests)

Résultats avec mongodb 1.8.1 et redis 2.2.5 et la dernière version de pymongo/redis-py :

$ ./cache_benchmark.py 10000
Completed mongo_set: 10000 ops in 1.40 seconds : 7167.6 ops/sec
Completed mongo_get: 10000 ops in 2.38 seconds : 4206.2 ops/sec
Completed redis_set: 10000 ops in 0.78 seconds : 12752.6 ops/sec
Completed redis_get: 10000 ops in 0.89 seconds : 11277.0 ops/sec

Prenez les résultats avec un grain de sel, bien sûr ! Si vous programmez dans un autre langage, si vous utilisez d'autres clients/des implémentations différentes, etc. vos résultats varieront considérablement. Sans oublier que votre utilisation sera complètement différente ! Votre meilleure chance est de les comparer vous-même, précisément de la manière dont vous avez l'intention de les utiliser. En corollaire, vous découvrirez sans doute que les meilleur la manière d'utiliser chacun d'entre eux. Faites toujours des comparaisons pour vous-même !

Answer 2

Veuillez cocher ce poste sur l'analyse des performances d'insertion de Redis et MongoDB :

Jusqu'à 5000 entrées, $push de mongodb est plus rapide que RPUSH de Redis, puis il devient incroyablement lent, probablement parce que le type de tableau de mongodb a un temps d'insertion linéaire et devient donc de plus en plus lent. mongodb pourrait gagner un peu en performances en exposant un type de liste à insertion à temps constant, mais même avec le type de tableau à temps linéaire (qui peut garantir une consultation à temps constant), il a ses applications pour les petits ensembles de données.

Answer 3

Bon et simple repère

J'ai essayé de recalculer les résultats en utilisant les versions actuelles de redis(2.6.16) et mongo(2.4.8) et voici le résultat

Completed mongo_set: 100000 ops in 5.23 seconds : 19134.6 ops/sec
Completed mongo_get: 100000 ops in 36.98 seconds : 2703.9 ops/sec
Completed redis_set: 100000 ops in 6.50 seconds : 15389.4 ops/sec
Completed redis_get: 100000 ops in 5.59 seconds : 17896.3 ops/sec

De même, cette article de blog compare les deux mais en utilisant node.js. Il montre l'effet de l'augmentation du nombre d'entrées dans la base de données en fonction du temps.

Answer 4

Les chiffres seront difficiles à trouver car les deux ne sont pas tout à fait dans le même espace. La réponse générale est que Redis est 10 à 30 % plus rapide lorsque l'ensemble des données tient dans la mémoire de travail d'une seule machine. Une fois cette quantité de données dépassée, Redis échoue. Mongo ralentit en fonction du type de charge. Pour une charge de type insertion uniquement, un utilisateur a récemment signalé un ralentissement de 6 à 7 ordres de grandeur (10 000 à 100 000 fois), mais ce rapport admettait également qu'il y avait des problèmes de configuration et qu'il s'agissait d'une charge de travail très atypique. La lecture normale de charges lourdes ralentit d'environ 10 fois lorsqu'une partie des données doit être lue à partir d'un disque.

Conclusion : Redis sera plus rapide, mais pas de beaucoup.

Answer 5

Voici un excellent article sur performance de la session dans le cadre de Tornado datant d'environ 1 an. Il propose une comparaison entre plusieurs implémentations différentes, dont Redis et MongoDB. Le graphique de l'article indique que Redis est derrière MongoDB d'environ 10 % dans ce cas d'utilisation spécifique.

Redis dispose d'un benchmark intégré qui analyse les performances de la machine sur laquelle vous vous trouvez. Il y a une tonne de données brutes à ce sujet à l'adresse Benchmark wiki pour Redis. Mais vous devrez peut-être chercher un peu plus loin pour Mongo. Comme aquí , aquí et de quelques numéros de polonais (mais il vous donne un point de départ pour réaliser vous-même des tests de performance de MongoDB).

Je pense que la meilleure solution à ce problème est d'effectuer les tests vous-même dans les types de situations auxquelles vous vous attendez.