Consultas em cache no Couchbase para alto desempenho

A partir da versão 2.0, o servidor Couchbase oferece uma maneira eficiente de criar índices para documentos JSON por meio do conceito de exibições.

Usando exibições, é possível definir índices primários, índices compostos e agregações que permitem:

. consultar documentos em diferentes propriedades JSON

. criar estatísticas e agregados

As visualizações geram índices materializados, o que proporciona uma maneira rápida e eficiente de executar consultas predefinidas.

No entanto, no Couchbase 2.x, os índices são armazenados no disco e lidos do disco para cada consulta, o que tem algumas implicações de desempenho.

No futuro, o Couchbase permitirá o armazenamento em cache de índices no cache gerenciado de forma semelhante ao que é feito para documentos JSON para acelerar as consultas.

Enquanto isso, este blog fornece um exemplo simples de como os resultados da consulta podem ser armazenados em cache no Couchbase para serem recuperados do cache em vez de serem servidos a partir do índice no disco.

Isso é útil para cenários em que uma consulta a um índice não precisa ser atualizada imediatamente (minutos ou mais são suficientes), mas é lida com frequência (várias vezes por segundo). Nesse caso, os resultados da consulta serão calculados apenas de vez em quando com base nas necessidades do aplicativo e lidos do cache gerenciado no restante do tempo.

Um bom exemplo de caso de uso para isso é uma tabela de classificação de jogos. Uma exibição pode ser usada para criar um índice para as pontuações mais altas de um determinado jogo e essa exibição pode ser consultada a cada poucos minutos (digamos, 5 minutos) e armazenada em cache no Couchbase Server. Todas as solicitações para a exibição serão direcionadas ao valor armazenado em cache e, portanto, levarão apenas alguns ms e não precisarão de nenhuma consulta de índice no servidor.

Observe que o método acima é independente da atualização automática dos índices. Por padrão, cada índice no Couchbase é atualizado a cada 5 segundos ou 5000 atualizações, ambos ajustáveis por meio da API REST. Saiba mais sobre isso em: https://www.couchbase.com/docs/couchbase-manual-2.1.0/couchbase-views-operation-autoupdate.html

Isso significa que, embora o índice possa ser mantido atualizado, as consultas específicas, que não precisam ser atualizadas, podem ser armazenadas em cache para aumentar a taxa de transferência e diminuir a latência. A única ressalva é que o tamanho máximo dos valores no Couchbase é de 20 MB, portanto, as consultas em cache não devem ser usadas para conjuntos de resultados muito grandes, embora seja sempre possível dividir os resultados em vários valores em cache para conjuntos maiores.

Isso é bastante simples de implementar. Vamos dar uma olhada em como podemos fazer isso em Java.

Usarei o banco de dados bee-sample, que vem com o servidor Couchbase. Se você ainda não o instalou, vá para Settings (Configurações) e selecione beer-sample (amostra de cerveja) e clique em Create (Criar):

Ele vem com uma visualização brewery_beer, que usarei para criar o exemplo de armazenamento em cache:

Agora vamos dar uma olhada em um aplicativo Java simples que pode ser usado para executar e armazenar em cache uma consulta e comparar com a execução da consulta todas as vezes.

O código Java abaixo, primeiro se conecta ao banco de dados de amostras de abelhas e:

. executa a consulta 1 vez e a lê do cache n vezes ou

. executa a consulta n vezes

Em ambos os casos, um cronômetro é iniciado antes e depois para medir o tempo de execução.

O código é muito simples, não usa parâmetros para a consulta, mas usa includeDocs para recuperar todos os documentos JSON associados aos resultados da consulta em vez de apenas os IDs dos documentos.

Para saber mais sobre exibições e consultas no Couchbase, leia: https://www.couchbase.com/docs/couchbase-devguide-2.1.0/indexing-querying-data.html

O código-fonte completo é:

// @author Alexis Roos

pacote com.couchbase.dev.examples;

import com.couchbase.client.CouchbaseClient;

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

importar java.net.URI;

importar java.util.LinkedList;

importar java.util.List;

classe pública CachedQuery {

   public static void main(String args[]) {

       List uris = new LinkedList();

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

       CouchbaseClient client = null;

       tente {

           cliente = novo CouchbaseClient(uris, "beer-sample", "");

           int requestCount = 100;

           double t1 = System.currentTimeMillis();

           View view = client.getView("beer", "brewery_beers");

           Consulta = new Query();

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

           query.setStale(Stale.FALSE);

           // Fazendo a consulta uma única vez e armazenando-a em cache

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

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

           // Uso do cache para solicitações subsequentes

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

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

           }

           double t2 = System.currentTimeMillis();

           System.out.println("Teste com cache concluído em " + (t2 - t1) / 1000 + " segundos");

           t1 = System.currentTimeMillis();

           // Consultando todas as vezes

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

               result = client.query(view, query);

           }

           t2 = System.currentTimeMillis();

           System.out.println("O teste sem cache foi concluído em " + (t2 - t1) / 1000 + " segundos");

           cliente.shutdown();

       } catch (Exception e) {

           System.err.println("Erro ao conectar-se ao Couchbase: " + e.getMessage());

           System.exit(0);

       }

   }

}

A execução do código produz os dois resultados do teste, que para 100 consultas em série produz:

Teste com cache concluído em 3,755 segundos

O teste sem cache foi concluído em 19,835 segundos

Não só o teste com cache é muito mais rápido, mas também requer menos recursos no servidor Couchbase.

O gráfico a seguir mostra a métrica de operações por segundo para o bucket de amostra de cerveja e o primeiro pequeno aumento corresponde ao teste com cache (essencialmente mapeando o número de documentos para cervejarias e cervejas, pois a consulta é executada apenas uma vez), enquanto o restante da curva maior mostra que a consulta foi executada muitas vezes e, portanto, resultou em muito mais operações por segundo.

É fácil usar o armazenamento em cache para consultar exibições, e é simples configurar um programa que consultará periodicamente a exibição e armazenará o resultado no servidor Couchbase, onde será armazenado em cache. Por sua vez, os aplicativos podem usar esse valor em cache para obter eficiência.

Isso deve ser usado conforme apropriado, com base nos casos de uso do aplicativo.