Almacenamiento en caché de consultas en Couchbase para un alto rendimiento

A partir de la versión 2.0, el servidor Couchbase ofrece una potente forma de crear índices para documentos JSON a través del concepto de vistas.

Mediante las vistas, es posible definir índices primarios, índices compuestos y agregaciones que permitan:

. consultar documentos en función de distintas propiedades JSON

. crear estadísticas y agregados

Las vistas generan índices materializados, por lo que proporcionan una forma rápida y eficaz de ejecutar consultas predefinidas.

Sin embargo, en Couchbase 2.x, los índices se almacenan en el disco y se leen desde el disco para cada consulta, lo que tiene algunas implicaciones de rendimiento.

En el futuro, Couchbase permitirá almacenar índices en la caché gestionada de forma similar a lo que se hace con los documentos JSON para acelerar las consultas.

Mientras tanto, este blog proporciona un ejemplo sencillo de cómo los resultados de las consultas pueden ser almacenados en caché en Couchbase para ser recuperados de la caché en lugar de ser servidos desde el índice en el disco.

Esto es útil para escenarios en los que una consulta para un índice no necesita estar actualizada inmediatamente (minutos o más están bien) pero se lee a menudo (varias veces por segundo). En este caso, los resultados de la consulta se calcularán sólo cada cierto tiempo en función de las necesidades de la aplicación y se leerán de la caché gestionada el resto del tiempo.

Un buen ejemplo de uso para esto, es la clasificación de un juego. Se puede utilizar una vista para crear un índice de las mejores puntuaciones de un juego en particular y esa vista puede ser consultada cada pocos minutos (digamos 5 minutos) y almacenada en caché en Couchbase Server. Todas las peticiones para la vista irán contra el valor almacenado en caché y, como tal, sólo tomará ms y no necesita ningún índice de consulta en el servidor.

Ten en cuenta que, el método anterior es independiente de la actualización automática de los índices. Por defecto, cada índice en Couchbase se actualiza cada 5 segundos o 5000 actualizaciones, ambos sintonizables a través de la API REST. Más información en: http://www.couchbase.com/docs/couchbase-manual-2.1.0/couchbase-views-operation-autoupdate.html

Esto significa que mientras que el índice se puede mantener actualizado, las consultas específicas, que no necesitan estar actualizadas, se pueden almacenar en caché para un mayor rendimiento y menor latencia. La única advertencia es que la longitud máxima de los valores en Couchbase es de 20 MB, por lo que las consultas almacenadas en caché no deben utilizarse para conjuntos de resultados muy grandes, aunque siempre es posible dividir los resultados en varios valores almacenados en caché para conjuntos más grandes.

Esto es bastante simple de implementar, echemos un vistazo a cómo podemos hacer esto en Java.

Usaré la base de datos bee-sample, que viene con el servidor Couchbase. Si aún no la has instalado, ve a Configuración y selecciona beer-sample y luego haz clic en Crear:

Esto viene con una vista brewery_beer, que voy a utilizar para construir el ejemplo de almacenamiento en caché:

Veamos ahora una sencilla aplicación Java que puede utilizarse para ejecutar y almacenar en caché una consulta y compararla con la ejecución de la consulta cada vez.

El código Java a continuación, primero se conecta a la base de datos de abeja-muestra y:

. ejecuta la consulta 1 vez y la lee de la caché n veces o

. ejecuta la consulta n veces

En ambos casos, se pone en marcha un temporizador antes y después para medir el tiempo de ejecución.

El código es muy sencillo, no utiliza parámetros para la consulta pero utiliza includeDocs para recuperar todos los documentos JSON asociados a los resultados de la consulta frente a sólo los IDs de los documentos.

Para saber más sobre vistas y consultas en Couchbase, lee: http://www.couchbase.com/docs/couchbase-devguide-2.1.0/indexing-querying-data.html

El código fuente completo es:

// @autor Alexis Roos

paquete com.couchbase.dev.examples;

import com.couchbase.client.CouchbaseClient;

import com.couchbase.client.protocol.views.*;

import java.net.URI;

import java.util.LinkedList;

import java.util.List;

public class CachedQuery {

   public static void main(String args[]) {

       Lista uris = nueva LinkedList();

       uris.add(URI.create("http://127.0.0.1:8091/pools"));

       CouchbaseClient cliente = null;

       intentar {

           client = new CouchbaseClient(uris, "cerveza-muestra", "");

           int solicitudCuento = 100;

           double t1 = System.currentTimeMillis();

           Vista vista = client.getView("cerveza", "cerveceria_cervezas");

           Consulta consulta = nueva consulta();

           query.setIncludeDocs(true).setLimit(10000);

           query.setStale(Stale.FALSE);

           // Hacer la consulta una sola vez y almacenarla en caché

           ViewResponse result = client.query(view, query);

           client.set("cachedBrewery_beersQuery", 0, result.toString());

           // Uso de la caché para peticiones posteriores

           for (int i = 0; i < requestCount - 1; i++) {

               String cachedIndex = (String) client.get("cachedBrewery_beersQuery");

           }

           double t2 = System.currentTimeMillis();

           System.out.println("Prueba con caché finalizada en " + (t2 - t1) / 1000 + " segundos");

           t1 = System.currentTimeMillis();

           // Consulta cada vez

           for (int i = 0; i < requestCount; i++) {

               result = client.query(view, query);

           }

           t2 = System.currentTimeMillis();

           System.out.println("La prueba sin caché finalizó en " + (t2 - t1) / 1000 + " segundos");

           client.shutdown();

       } catch (Exception e) {

           System.err.println("Error al conectar con Couchbase: " + e.getMessage());

           System.exit(0);

       }

   }

}

Al ejecutar el código se obtienen los dos resultados de la prueba, que para 100 consultas en serie arroja:

Prueba con caché finalizada en 3,755 segundos

La prueba sin caché terminó en 19,835 segundos

No sólo la prueba con caché es mucho más rápida, sino que también requiere menos recursos en el servidor Couchbase.

El siguiente gráfico muestra la métrica de operaciones por segundo para el cubo de muestras de cerveza y la primera pequeña protuberancia corresponde a la prueba con caché (que corresponde esencialmente al número de documentos de cervecerías y cervezas, ya que la consulta se ejecuta una sola vez), mientras que el resto de la curva más grande muestra que la consulta se ha ejecutado muchas veces y, como tal, ha dado lugar a muchas más operaciones por segundo.

Usar la caché para consultar vistas es fácil y es sencillo configurar un programa, que periódicamente consultará la vista y almacenará el resultado en el servidor Couchbase donde se almacenará en caché. A su vez, las aplicaciones pueden utilizar este valor almacenado en caché para mayor eficiencia.

Debe utilizarse según proceda en función de los casos de uso de la aplicación.