español - ¿Cuánto más rápido es Redis que mongoDB?

redis vs mongodb español

Question

Se menciona ampliamente que Redis es "Blazing Fast" y que mongoDB también es rápido. Pero, estoy teniendo problemas para encontrar números reales comparando los resultados de los dos. Dadas configuraciones, características y operaciones similares (y tal vez mostrando cómo cambia el factor con diferentes configuraciones y operaciones), etc., ¿es Redis 10 veces más rápido ?, ¿2 veces más rápido ?, ¿5 veces más rápido?

SOLO estoy hablando de performance. Entiendo que mongoDB es una herramienta diferente y tiene un conjunto de características más rico. Este no es el debate "Is mongoDB es mejor que Redis". Estoy preguntando, ¿por qué margen Redis supera a mongoDB?

En este punto, incluso los puntos de referencia baratos son mejores que los puntos de referencia no.

Answer 1

Aquí hay un excelente artículo sobre el rendimiento de la sesión en el marco de Tornado de aproximadamente 1 año de edad. Tiene una comparación entre algunas implementaciones diferentes, de las cuales se incluyen Redis y MongoDB. El gráfico en el artículo indica que Redis está detrás de MongoDB en aproximadamente un 10% en este caso de uso específico.

Redis viene con un punto de referencia incorporado que analizará el rendimiento de la máquina en la que se encuentra. Hay una tonelada de datos sin procesar en la wiki de Benchmark para Redis. Pero es posible que tengas que mirar un poco por Mongo. Como here , here , y algunos números de pulido al azar (pero te da un punto de partida para ejecutar algunos puntos de referencia de MongoDB).

Creo que la mejor solución para este problema es realizar las pruebas usted mismo en los tipos de situaciones que espera.

Answer 2

Buen y sencillo punto de referencia.

Intenté recalcular los resultados nuevamente usando las versiones actuales de redis (2.6.16) y mongo (2.4.8) y aquí está el resultado

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

También esta publicación del blog compara ambos pero usando node.js. Muestra el efecto de aumentar el número de entradas en la base de datos junto con el tiempo.

Answer 3

Creo que los 2-3X en el punto de referencia mostrado son engañosos, ya que si también depende del hardware con el que lo ejecute, según mi experiencia, cuanto más ''fuerte'' sea la máquina, mayor será la brecha (a favor de Redis). será, probablemente por el hecho de que el punto de referencia alcanza el límite de límites de memoria bastante rápido.

En cuanto a la capacidad de la memoria, esto es parcialmente cierto, ya que también hay formas de ir sobre eso, hay productos (comerciales) que registran los datos de Redis en el disco, y también soluciones de cluster (de múltiples fragmentos) que superan el tamaño de la memoria. limitación.

Answer 4

En mi caso, lo que ha sido un factor determinante en la comparación de rendimiento, es el MongoDb WriteConcern que se utiliza. La mayoría de los controladores de mongo en la actualidad establecerán la WriteConcern predeterminada en RECONOCIDA, que significa "escrito en la RAM" ( Mongo2.6.3-WriteConcern ), en ese sentido, era muy comparable a redis para la mayoría de las operaciones de escritura.

Pero la realidad depende de las necesidades de la aplicación y la configuración del entorno de producción, es posible que desee cambiar esta inquietud a WriteConcern.JOURNALED (escrito en oplog) o WriteConcern.FSYNCED (escrito en el disco) o incluso escrito en conjuntos de réplicas (copias de seguridad) Si es necesario.

Entonces puedes comenzar a ver una disminución en el rendimiento. Otros factores importantes también incluyen, qué tan optimizados están sus patrones de acceso a los datos, el índice de pérdida de índice (vea mongostat ) y los índices en general.

Answer 5

Los números serán difíciles de encontrar ya que los dos no están exactamente en el mismo espacio. La respuesta general es que Redis es 10 a 30% más rápido cuando el conjunto de datos se ajusta a la memoria de trabajo de una sola máquina. Una vez que se excede esa cantidad de datos, Redis falla. Mongo se ralentizará en una cantidad que depende del tipo de carga. Para un tipo de carga solo de inserción, un usuario informó recientemente una desaceleración de 6 a 7 órdenes de magnitud (10,000 a 100,000 veces) pero ese informe también admitió que había problemas de configuración y que esto era una carga de trabajo muy atípica. Las cargas pesadas de lectura normal son anecdóticamente lentas en aproximadamente 10X cuando algunos de los datos deben leerse desde el disco.

Conclusión: Redis será más rápido pero no mucho.

Answer 6

Por favor, consulte esta publicación sobre el análisis de rendimiento de inserción de Redis y MongoDB:

Hasta 5000 entradas mongodb $ push es más rápido incluso en comparación con Redis RPUSH, luego se vuelve increíblemente lento, probablemente el tipo de matriz mongodb tiene un tiempo de inserción lineal y, por lo tanto, se vuelve más lento y más lento. mongodb puede obtener un poco de rendimiento al exponer un tipo de lista de inserción de tiempo constante, pero incluso con el tipo de matriz de tiempo lineal (que puede garantizar la búsqueda de tiempo constante) tiene sus aplicaciones para pequeños conjuntos de datos.

Answer 7

Resultados aproximados del siguiente punto de referencia: escritura 2x, lectura 3x .

Aquí hay un punto de referencia simple en Python que puede adaptar a sus propósitos. Estaba viendo qué tan bien se desempeñaría cada uno simplemente estableciendo / recuperando valores:

#!/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)

Resultados para con mongodb 1.8.1 y redis 2.2.5 y el último 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

¡Tome los resultados con un grano de sal por supuesto! Si está programando en otro lenguaje, utilizando otros clientes / implementaciones diferentes, etc., sus resultados variarán considerablemente. ¡Sin mencionar que su uso será completamente diferente! Lo mejor que puedes hacer es compararlos tú mismo, precisamente de la manera que pretendes usarlos. Como corolario, probablemente descubrirás la mejor manera de hacer uso de cada uno. Siempre referencia para ti mismo!