Memorizzazione nella cache dei dati con Memorystore

Le applicazioni web scalabili ad alte prestazioni spesso utilizzano una cache di dati in memoria distribuita davanti o al posto di un'archiviazione permanente robusta per alcune attività. Ti consigliamo di utilizzare Memorystore for Redis come servizio di memorizzazione nella cache. Tieni presente che Memorystore for Redis non fornisce un livello senza costi. Per i dettagli, consulta Prezzi di Memorystore.

Prima di iniziare, assicurati che la tua app rimanga entro le quote di Memorystore for Redis.

Quando utilizzare una memoria cache

I dati delle sessioni, le preferenze utente e altri dati restituiti dalle query per le pagine web sono buoni candidati per la memorizzazione nella cache. In generale, se una query eseguita di frequente restituisce un insieme di risultati che non devono essere visualizzati immediatamente nella tua app, puoi memorizzare i risultati nella cache. Le richieste successive possono controllare la cache ed eseguire query sul database solo se i risultati non sono presenti o sono scaduti.

Se memorizzi un valore solo in Memorystore senza eseguirne il backup nell'archiviazione permanente, assicurati che la tua applicazione si comporti in modo accettabile se il valore scade e viene rimosso dalla cache. Ad esempio, se l'improvvisa assenza dei dati di sessione di un utente causasse un malfunzionamento della sessione, questi dati dovrebbero probabilmente essere archiviati nel database oltre che in Memorystore.

Informazioni sulle autorizzazioni di Memorystore

Ogni interazione con un Google Cloud servizio deve essere autorizzata. Ad esempio, per interagire con un database Redis ospitato da Memorystore, la tua app deve fornire le credenziali di un account autorizzato ad accedere a Memorystore.

Per impostazione predefinita, la tua app fornisce le credenziali dell'account di servizio predefinito di App Engine , che è autorizzato ad accedere ai database nello stesso progetto della tua app.

Se una delle seguenti condizioni è vera, devi utilizzare una tecnica di autenticazione alternativa che fornisca esplicitamente le credenziali:

• La tua app e il database Memorystore si trovano in progetti diversi Google Cloud

• Hai modificato i ruoli assegnati all'account di servizio predefinito di App Engine.

Per informazioni sulle tecniche di autenticazione alternative, consulta Configurare l'autenticazione per le applicazioni di produzione da server a server.

Panoramica dell'utilizzo di Memorystore

Per utilizzare Memorystore nella tua app:

1. Configura Memorystore for Redis, che richiede la creazione di un'istanza Redis su Memorystore e di un accesso VPC serverless che la tua app utilizza per comunicare con l' istanza Redis.

2. Installa una libreria client per Redis e utilizza i comandi Redis per memorizzare i dati nella cache.

   Memorystore for Redis è compatibile con qualsiasi libreria client per Redis.

   Vai

   Questa guida descrive l'utilizzo della redigo libreria client per inviare comandi Redis dalla tua app.

   Java

   Questa guida descrive l'utilizzo della libreria client Jedis per inviare comandi Redis dalla tua app. Per i dettagli sull' utilizzo di Jedis, consulta il wiki di Jedis.

   Node.js

   Questa guida descrive l'utilizzo della node_redis libreria client per inviare comandi Redis dalla tua app.

   PHP

   Questa guida descrive l'utilizzo della PHPRedis libreria client per inviare comandi Redis dalla tua app.

   Python

   Questa guida descrive l'utilizzo della libreria client redis-py 3.0 per inviare comandi Redis dalla tua app.

   Ruby

   Questa guida descrive l'utilizzo della redis-rb libreria client per inviare comandi Redis dalla tua app.

3. Testa gli aggiornamenti.

4. Esegui il deployment dell'app in App Engine.

Configurare Memorystore for Redis

Per configurare Memorystore for Redis:

1. Crea un'istanza Redis in Memorystore.

   Quando ti viene chiesto di selezionare una regione per l'istanza Redis, seleziona la stessa regione in cui si trova l'app App Engine.

2. Prendi nota dell'indirizzo IP e del numero di porta dell'istanza Redis che hai creato. Utilizzerai queste informazioni quando crei un client Redis nel codice.

3. Collega App Engine a una rete VPC. La tua app può comunicare con Memorystore solo tramite un connettore VPC.

   Assicurati di aggiungere le informazioni sulla connessione VPC al file app.yaml come descritto in Configurare l'app per utilizzare il connettore.

Installazione delle dipendenze

Vai

Per rendere disponibile la libreria client redigo alla tua app quando viene eseguita in App Engine, aggiungi la libreria alle dipendenze dell'app. Ad esempio, se utilizzi un file go.mod per dichiarare le dipendenze, aggiungi la seguente riga al file go.mod:

module github.com/GoogleCloudPlatform/golang-samples/tree/master/memorystore/redis

Scopri di più sulla specifica delle dipendenze per la tua app Go.

Java

Per rendere disponibile la libreria client Jedis alla tua app quando viene eseguita in App Engine, aggiungi la libreria alle dipendenze dell'app. Ad esempio, se utilizzi Maven, aggiungi la seguente dipendenza al file pom.xml:

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

Node.js

Per rendere disponibile la libreria client node_redis alla tua app quando viene eseguita in App Engine, aggiungi la libreria al file package.json dell'app.

Ad esempio:

{
  "name": "memorystore-redis",
  "description": "An example of using Memorystore(Redis) with Node.js",
  "version": "0.0.1",
  "private": true,
  "license": "Apache Version 2.0",
  "author": "Google Inc.",
  "engines": {
    "node": ">=16.0.0"
  },
  "dependencies": {
    "redis": "^4.0.0"
  }
}

Scopri di più sulla specifica delle dipendenze per la tua app Node.js.

PHP

Per rendere disponibile la libreria client PHPRedis alla tua app quando viene eseguita in App Engine, aggiungi l'estensione redis.so al file php.ini dell'app. Ad esempio:

; Enable the Redis extension on App Engine
extension=redis.so

Per ulteriori informazioni sull'attivazione delle estensioni PHP in App Engine, consulta Estensioni caricabili dinamicamente .

Python

Per rendere disponibile la libreria client redis-py alla tua app quando viene eseguita in App Engine, aggiungi la seguente riga al file requirements.txt dell'app:

  redis

Il runtime Python 3 di App Engine caricherà automaticamente tutte le librerie del file requirements.txt dell'app quando esegui il deployment dell'app.

Per lo sviluppo locale, ti consigliamo di installare le dipendenze in un ambiente virtuale come venv.

Ruby

Per rendere disponibile la libreria client redis-rb alla tua app quando viene eseguita in App Engine, aggiungi la libreria al file Gemfile dell'app.

  source "https://cloud.google.com/memorystore"

  gem "redis-rb"

Creazione di un client Redis

Per interagire con un database Redis, il codice deve creare un client Redis per gestire la connessione al database Redis. Le sezioni seguenti descrivono la creazione di un client Redis utilizzando la libreria client Redis.

Specifica delle variabili di ambiente

La libreria client Redis utilizza due variabili di ambiente per assemblare l'URL del database Redis:

• Una variabile per identificare l'indirizzo IP del database Redis che hai creato in Memorystore.
• Una variabile per identificare il numero di porta del database Redis creato in Memorystore.

Ti consigliamo di definire queste variabili nel file app.yaml dell'app anziché definirle direttamente nel codice. In questo modo è più facile eseguire l'app in ambienti diversi, ad esempio un ambiente locale e App Engine. Scopri di più sulle variabili di ambiente nella app.yaml pagina di riferimento.

Vai

Ad esempio, aggiungi le seguenti righe al file app.yaml:

  env_variables:
       REDISHOST: '10.112.12.112'
       REDISPORT: '6379'

Java

Ad esempio, aggiungi le seguenti righe al file app.yaml:

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

Node.js

Ad esempio, aggiungi le seguenti righe al file app.yaml:

  env_variables:
       REDISHOST: '10.112.12.112'
       REDISPORT: '6379'

PHP

Ad esempio, aggiungi le seguenti righe al file app.yaml:

  env_variables:
       REDIS_HOST: '10.112.12.112'
       REDIS_PORT: '6379'

Python

Ad esempio, aggiungi le seguenti righe al file app.yaml:

  env_variables:
       REDISHOST: '10.112.12.112'
       REDISPORT: '6379'

Ruby

Ad esempio, aggiungi le seguenti righe al file app.yaml:

  env_variables:
       REDISHOST: '10.112.12.112'
       REDISPORT: '6379'

Importazione di Redis e creazione del client

Vai

Dopo aver definito le variabili di ambiente REDISHOST e REDISPORT, utilizza le seguenti righe per importare la libreria redigo, creare un pool di connessioni, e recuperare un client Redis dal pool:

// Package main is a basic app that connects to a managed Redis instance.
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/gomodule/redigo/redis"
)

var redisPool *redis.Pool

func incrementHandler(w http.ResponseWriter, r *http.Request) {
	conn := redisPool.Get()
	defer conn.Close()

	counter, err := redis.Int(conn.Do("INCR", "visits"))
	if err != nil {
		http.Error(w, "Error incrementing visitor counter", http.StatusInternalServerError)
		return
	}
	fmt.Fprintf(w, "Visitor number: %d", counter)
}

func main() {
	redisHost := os.Getenv("REDISHOST")
	redisPort := os.Getenv("REDISPORT")
	redisAddr := fmt.Sprintf("%s:%s", redisHost, redisPort)

	const maxConnections = 10
	redisPool = &redis.Pool{
		MaxIdle: maxConnections,
		Dial:    func() (redis.Conn, error) { return redis.Dial("tcp", redisAddr) },
	}

	http.HandleFunc("/", incrementHandler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

Java

Quando utilizzi la libreria Jedis, ti consigliamo di creare un JedisPool e poi di utilizzare il pool per creare un client. Le seguenti righe di codice utilizzano le variabili di ambiente redis.host e redis.port definite in precedenza per creare un pool:

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
      }
    }
  }
}

Per creare un client dal pool, utilizza il metodo JedisPool.getResource(). Ad esempio:

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());
    }
  }
}

Node.js

Dopo aver definito le variabili di ambiente REDISHOST e REDISPORT, puoi utilizzare le seguenti righe per importare la libreria node_redis e creare un client Redis:

'use strict';
const http = require('http');
const redis = require('redis');

const REDISHOST = process.env.REDISHOST || 'localhost';
const REDISPORT = process.env.REDISPORT || 6379;

const client = redis.createClient({
  url: `redis://${REDISHOST}:${REDISPORT}`,
});

client.on('error', err => console.error('ERR:REDIS:', err));

client
  .connect()
  .then(() => {
    console.log('Connected to Redis');
    http
      .createServer(async (req, res) => {
        try {
          const reply = await client.incr('visits');
          res.writeHead(200, {'Content-Type': 'text/plain'});
          res.end(`Visitor number: ${reply}\n`);
        } catch (err) {
          console.error(err);
          res.statusCode = 500;
          res.end(err.message);
        }
      })
      .listen(8080, () => {
        console.log('Server listening on port 8080');
      });
  })
  .catch(err => {
    console.error('Failed to connect to Redis:', err);
    throw err;
  });

PHP

Dopo aver definito le variabili di ambiente REDIS_HOST e REDIS_PORT, puoi utilizzare le seguenti righe per creare un client Redis:

<?php
/**
 * Copyright 2019 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Only serve traffic from "/"
switch (@parse_url($_SERVER['REQUEST_URI'])['path']) {
    case '/':
        break;
    default:
        http_response_code(404);
        exit('Not Found');
}

// Connect to Memorystore from App Engine.
if (!$host = getenv('REDIS_HOST')) {
    throw new Exception('The REDIS_HOST environment variable is required');
}

# Memorystore Redis port defaults to 6379
$port = getenv('REDIS_PORT') ?: '6379';

try {
    $redis = new Redis();
    $redis->connect($host, $port);
} catch (Exception $e) {
    return print('Error: ' . $e->getMessage());
}

$value = $redis->incr('counter');

printf('Visitor number: %s', $value);

Python

Dopo aver definito le variabili di ambiente REDISHOST e REDISPORT, utilizza le seguenti righe per importare la libreria redis-py e creare un client:

  import redis

  redis_host = os.environ.get('REDISHOST', 'localhost')
  redis_port = int(os.environ.get('REDISPORT', 6379))
  redis_client = redis.Redis(host=redis_host, port=redis_port)

Se hai utilizzato una versione precedente di redis-py per altre app, potresti aver utilizzato la classe StrictClient anziché Client. Tuttavia, ora redis-py consiglia Client anziché StrictClient.

Ruby

Non sono disponibili informazioni aggiuntive per questo runtime.

Utilizzare i comandi Redis per archiviare e recuperare i dati nella cache

Sebbene il database Redis di Memorystore supporti la maggior parte dei comandi Redis, devi utilizzare solo alcuni comandi per archiviare e recuperare i dati dalla cache. La seguente tabella suggerisce i comandi Redis che puoi utilizzare per memorizzare i dati nella cache. Per scoprire come chiamare questi comandi dalla tua app, consulta la documentazione della libreria client.

Attività	Comando Redis
Crea una voce nella cache di dati e imposta un tempo di scadenza per la voce	SETNX MSETNX
Recupera i dati dalla cache	GET MGET
Sostituisci i valori della cache esistenti	SET MSET
Incrementa o decrementa i valori numerici della cache	INCR INCRBY DECR DECRBY
Elimina le voci dalla cache	DEL UNLINK
Supporta le interazioni simultanee con la cache	Consulta i dettagli sulle transazioni Redis. Per Python, la libreria client redis-py richiede che tutte le transazioni avvengano in una pipeline.

Testare gli aggiornamenti

Quando testi l'app localmente, valuta la possibilità di eseguire un'istanza locale di Redis per evitare di interagire con i dati di produzione (Memorystore non fornisce un emulatore). Per installare ed eseguire Redis localmente, segui le istruzioni nella documentazione di Redis. Tieni presente che al momento non è possibile eseguire Redis localmente su Windows.

Per ulteriori informazioni sul test delle app, consulta Test e deployment dell'applicazione.

Eseguire il deployment dell'app

Una volta che l'app è in esecuzione nel server di sviluppo locale senza errori:

1. Testa l'app su App Engine.

2. Se l'app viene eseguita senza errori, utilizza la suddivisione del traffico per aumentare gradualmente il traffico per l'app aggiornata. Monitora attentamente l'app per verificare la presenza di problemi con il database prima di indirizzare altro traffico all'app aggiornata.