Colocar dados em cache com o Memorystore

As aplicações Web escaláveis de elevado desempenho usam frequentemente uma cache de dados distribuída na memória antes ou em vez de um armazenamento persistente robusto para algumas tarefas. Recomendamos que use o Memorystore para Redis como serviço de colocação em cache. Tenha em atenção que o Memorystore for Redis não oferece um nível gratuito. Consulte os preços do Memorystore para ver detalhes.

Antes de começar, certifique-se de que a sua app se mantém dentro das cotas do Memorystore para Redis.

Quando usar uma cache de memória

Os dados de sessões, as preferências do utilizador e outros dados devolvidos por consultas de páginas Web são bons candidatos para o armazenamento em cache. Em geral, se uma consulta executada com frequência devolver um conjunto de resultados que não precisam de aparecer imediatamente na sua app, pode colocar os resultados em cache. Os pedidos subsequentes podem verificar a cache e apenas consultar a base de dados se os resultados estiverem ausentes ou tiverem expirado.

Se armazenar um valor apenas no Memorystore sem fazer uma cópia de segurança no armazenamento persistente, certifique-se de que a sua aplicação se comporta de forma aceitável se o valor expirar e for removido da cache. Por exemplo, se a ausência repentina dos dados de sessão de um utilizador fizer com que a sessão funcione incorretamente, esses dados devem provavelmente ser armazenados na base de dados, além do Memorystore.

Compreender as autorizações do Memorystore

Todas as interações com um serviço Google Cloud têm de ser autorizadas. Por exemplo, para interagir com uma base de dados Redis alojada pelo Memorystore, a sua app tem de fornecer as credenciais de uma conta autorizada a aceder ao Memorystore.

Por predefinição, a sua app fornece as credenciais da conta de serviço predefinida do App Engine, que está autorizada a aceder a bases de dados no mesmo projeto que a sua app.

Se alguma das seguintes condições for verdadeira, tem de usar uma técnica de autenticação alternativa que forneça explicitamente credenciais:

• A sua app e a base de dados do Memorystore estão emGoogle Cloud projetos diferentes.

• Alterou as funções atribuídas à conta de serviço predefinida do App Engine.

Para informações sobre técnicas de autenticação alternativas, consulte o artigo Configurar a autenticação para aplicações de produção de servidor a servidor.

Vista geral da utilização do Memorystore

Para usar o Memorystore na sua app:

1. Configure o Memorystore for Redis, o que requer que crie uma instância do Redis no Memorystore e crie um acesso a VPC sem servidor que a sua app usa para comunicar com a instância do Redis. A ordem de criação destas duas entidades independentes não é rígida e podem ser configuradas em qualquer ordem. As instruções neste guia mostram como configurar primeiro o Acesso a VPC sem servidor.

2. Instale uma biblioteca cliente para o Redis e use comandos do Redis para colocar dados em cache.

   O Memorystore for Redis é compatível com qualquer biblioteca de cliente para Redis. Este guia descreve a utilização da biblioteca cliente Jedis para enviar comandos Redis a partir da sua app. Para ver detalhes sobre a utilização do Jedis, consulte a wiki do Jedis.

3. Teste as atualizações.

4. Implemente a sua app no App Engine.

Configurar o Memorystore for Redis

Para configurar o Memorystore for Redis:

1. Associe o App Engine a uma rede VPC. A sua app só pode comunicar com o Memorystore através de um conetor de VPC.

   Certifique-se de que adiciona as informações de ligação da VPC ao ficheiro app.yaml, conforme descrito em Configurar a sua app para usar o conetor.

2. Tome nota do endereço IP e do número da porta da instância do Redis que criar. Vai usar estas informações quando criar um cliente Redis no seu código.

3. Crie uma instância do Redis no Memorystore.

   Quando lhe for pedido que selecione uma região para a sua instância do Redis, selecione a mesma região em que a sua app do App Engine está localizada.

Instalar dependências

Para disponibilizar a biblioteca de cliente Jedis à sua app quando é executada no App Engine, adicione a biblioteca às dependências da app. Por exemplo, se usar o Maven, adicione a seguinte dependência no seu ficheiro pom.xml:

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>5.1.0</version>
</dependency>

Criar um cliente Redis

Para interagir com uma base de dados Redis, o seu código tem de criar um cliente Redis para gerir a ligação à sua base de dados Redis. As secções seguintes descrevem como criar um cliente Redis com a biblioteca cliente Jedis.

Especificar variáveis de ambiente

A biblioteca cliente Jedis usa duas variáveis de ambiente para montar o URL da sua base de dados Redis:

• Uma variável para identificar o endereço IP da base de dados Redis que criou no Memorystore.
• Uma variável para identificar o número da porta da base de dados Redis que criou no Memorystore.

Recomendamos que defina estas variáveis no ficheiro app.yaml da sua app em vez de as definir diretamente no código. Isto facilita a execução da sua app em diferentes ambientes, como um ambiente local e o App Engine.

Por exemplo, adicione as seguintes linhas ao ficheiro app.yaml:

 env_variables:
      redis.host: '10.112.12.112'
      redis.port: '6379'

Importar Jedis e criar o cliente

Quando usa a biblioteca Jedis, recomendamos que crie um JedisPool e, em seguida, use o conjunto para criar um cliente. As seguintes linhas de código usam as variáveis de ambiente redis.host e redis.port que definiu anteriormente para criar um conjunto:

package com.example.redis;

import java.io.IOException;
import java.util.Properties;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@WebListener
public class AppServletContextListener implements ServletContextListener {

  private Properties config = new Properties();

  private JedisPool createJedisPool() throws IOException {
    String host;
    Integer port;
    config.load(
        Thread.currentThread()
            .getContextClassLoader()
            .getResourceAsStream("application.properties"));
    host = config.getProperty("redis.host");
    port = Integer.valueOf(config.getProperty("redis.port", "6379"));

    JedisPoolConfig poolConfig = new JedisPoolConfig();
    // Default : 8, consider how many concurrent connections into Redis you will need under load
    poolConfig.setMaxTotal(128);

    return new JedisPool(poolConfig, host, port);
  }

  @Override
  public void contextDestroyed(ServletContextEvent event) {
    JedisPool jedisPool = (JedisPool) event.getServletContext().getAttribute("jedisPool");
    if (jedisPool != null) {
      jedisPool.destroy();
      event.getServletContext().setAttribute("jedisPool", null);
    }
  }

  // Run this before web application is started
  @Override
  public void contextInitialized(ServletContextEvent event) {
    JedisPool jedisPool = (JedisPool) event.getServletContext().getAttribute("jedisPool");
    if (jedisPool == null) {
      try {
        jedisPool = createJedisPool();
        event.getServletContext().setAttribute("jedisPool", jedisPool);
      } catch (IOException e) {
        // handle exception
      }
    }
  }
}

Para criar um cliente a partir do conjunto, use o método JedisPool.getResource(). Por exemplo:

package com.example.redis;

import java.io.IOException;
import java.net.SocketException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

@WebServlet(name = "Track visits", value = "")
public class VisitCounterServlet extends HttpServlet {

  @Override
  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    try {
      JedisPool jedisPool = (JedisPool) req.getServletContext().getAttribute("jedisPool");

      if (jedisPool == null) {
        throw new SocketException("Error connecting to Jedis pool");
      }
      Long visits;

      try (Jedis jedis = jedisPool.getResource()) {
        visits = jedis.incr("visits");
      }

      resp.setStatus(HttpServletResponse.SC_OK);
      resp.getWriter().println("Visitor counter: " + String.valueOf(visits));
    } catch (Exception e) {
      resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
    }
  }
}

Usar comandos Redis para armazenar e obter dados na cache

Embora a base de dados Redis do Memorystore suporte a maioria dos comandos Redis, só precisa de usar alguns comandos para armazenar e obter dados da cache. A tabela seguinte sugere comandos do Redis que pode usar para colocar dados em cache. Para ver como chamar estes comandos a partir da sua app, consulte a documentação da biblioteca de cliente.

Tarefa	Comando Redis
Crie uma entrada na cache de dados e defina um tempo de validade para a entrada	SETNX MSETNX
Recupere dados da cache	GET MGET
Substituir valores de cache existentes	SET MSET
Aumentar ou diminuir valores numéricos da cache	INCR INCRBY DECR DECRBY
Elimine entradas da cache	DEL UNLINK
Suportam interações simultâneas com a cache	Veja detalhes sobre as transações Redis.

Testar as atualizações

Quando testa a sua app localmente, considere executar uma instância local do Redis para evitar interagir com dados de produção (o Memorystore não fornece um emulador). Para instalar e executar o Redis localmente, siga as instruções na documentação do Redis. Tenha em atenção que, atualmente, não é possível executar o Redis localmente no Windows.

Implementar a sua app

Assim que a app estiver a ser executada no servidor de desenvolvimento local sem erros:

1. Teste a app no App Engine.

2. Se a app for executada sem erros, use a divisão de tráfego para aumentar gradualmente o tráfego para a app atualizada. Monitorize atentamente a app para detetar problemas na base de dados antes de encaminhar mais tráfego para a app atualizada.