1. Panoramica
Memorystore for Redis è un servizio Redis completamente gestito per Google Cloud. Le app in esecuzione su Google Cloud possono raggiungere prestazioni elevate utilizzando il servizio Redis altamente scalabile, disponibile e sicuro, senza il carico di dover gestire complessi deployment Redis. Può essere utilizzato come backend per la memorizzazione nella cache dei dati al fine di migliorare le prestazioni delle app Spring Boot. Il codelab spiega come configurarlo.
Cosa imparerai a fare
- Come utilizzare Memorystore come backend della cache per un'app di avvio a molla.
Che cosa ti serve
- Un progetto Google Cloud
- Un browser, ad esempio Google Chrome.
- Familiarità con gli editor di testo standard di Linux, ad esempio Vim, Emacs e GNU Nano.
Come utilizzerai il codelab?
Come giudichi la tua esperienza con i servizi Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo autonomo
- Accedi alla console Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o G Suite, devi crearne uno.
Ricorda l'ID progetto, un nome univoco in tutti i progetti Google Cloud (il nome precedente è già stato utilizzato e non funzionerà correttamente). Verrà indicato più avanti in questo codelab come PROJECT_ID.
- Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse Google Cloud.
Eseguire questo codelab non dovrebbe costare molto. Assicurati di seguire le istruzioni nella sezione "Pulizia" in cui viene spiegato come arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.
Attiva Cloud Shell
- Dalla console Cloud, fai clic su Attiva Cloud Shell
.
Se non hai mai avviato Cloud Shell, ti verrà mostrata una schermata intermedia (below the fold) in cui viene illustrato di cosa si tratta. In tal caso, fai clic su Continua (e non la vedrai più). Ecco come appare quella singola schermata:
Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.
Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto semplicemente con un browser o Chromebook.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo ID progetto.
- Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
3. Configura un'istanza Memorystore for Redis
Avvia Cloud Shell.
Dopo l'avvio di Cloud Shell, utilizza la riga di comando per abilitare l'API Memorystore e creare una nuova istanza Memorystore.
$ gcloud services enable redis.googleapis.com $ gcloud redis instances create myinstance --size=1 --region=us-central1
Al termine dell'operazione, l'istanza sarà pronta per l'uso.
Esegui questo comando per ottenere l'indirizzo IP dell'host Redis dell'istanza. Lo utilizzerai di nuovo in seguito durante la configurazione dell'app Spring Boot.
$ gcloud redis instances describe myinstance --region=us-central1 \ | grep host host: 10.0.0.4
Nella console Google Cloud, vai a Database > Memorystore > Redis. L'istanza dovrebbe trovarsi nello stato "pronta" stato :
4. Configura un'istanza Compute Engine
Crea un'istanza Compute Engine nella stessa regione.
$ gcloud compute instances create instance-1 --zone us-central1-c
Al termine dell'operazione, l'istanza sarà pronta per l'uso.
Connettiti all'istanza tramite SSH con il seguente comando:
$ gcloud compute ssh instance-1 --zone us-central1-c
In alternativa, vai a Compute > Compute Engine > Istanze VM e fai clic su SSH nella colonna Connetti:
Nella shell dell'istanza della macchina virtuale (VM) (non Cloud Shell), installa gli strumenti OpenJDK, Maven e Redis:
$ sudo apt-get install openjdk-17-jdk-headless maven redis-tools
Attendi il completamento dell'installazione e poi vai al passaggio successivo.
5. Configurare un'app Spring Boot
Crea un nuovo progetto Spring Boot con dipendenze web, redis e cache:
$ curl https://start.spring.io/starter.tgz \ -d dependencies=web,redis,cache -d language=java -d baseDir=cache-app \ -d type=maven-project \ | tar -xzvf - && cd cache-app
Modifica il file application.properties per configurare l'app in modo che utilizzi l'indirizzo IP dell'istanza Memorystore for Redis.
$ nano src/main/resources/application.properties
Aggiungi la seguente riga con il tuo indirizzo IP di Memorystore for Redis (di un paio di passaggi fa):
spring.data.redis.host=<memorystore-host-ip-address>
Aggiungi poi una nuova riga e crea una classe Java del controller REST:
$ nano src/main/java/com/example/demo/HelloWorldController.java
Inserisci i seguenti contenuti nel file:
package com.example.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloWorldController {
@Autowired
private StringRedisTemplate template;
@RequestMapping("/hello/{name}")
@Cacheable("hello")
public String hello(@PathVariable String name) throws InterruptedException {
Thread.sleep(5000);
return "Hello " + name;
}
}
L'annotazione @RequestMapping mostra il metodo come endpoint HTTP e mappa parte del percorso a un parametro del metodo (come indicato dall'annotazione @PathVariable).
L'annotazione @Cacheable("hello") indica che l'esecuzione del metodo deve essere memorizzata nella cache e il nome della cache è "hello". Viene utilizzata in combinazione con il valore parametro come chiave cache. Vedrai un esempio più avanti nel lab del codice.
A seguire, abiliteremo la memorizzazione nella cache nella classe dell'app Spring Boot. Modifica DemoApplication.java:
$ nano src/main/java/com/example/demo/DemoApplication.java
Importa org.springframework.cache.annotation.EnableCaching e annota la classe con questa annotazione. Il risultato dovrebbe essere simile al seguente:
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
6. Esegui l'app e accedi all'endpoint
Assicurati che JAVA_HOME sia impostata sulla versione corretta:
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/
Ora puoi eseguire l'app.
$ mvn spring-boot:run
Apri un'altra connessione SSH all'istanza come hai fatto in precedenza. Nella nuova finestra SSH, accedi più volte all'endpoint /hello/, passando "bob" come nome.
$ time curl http://localhost:8080/hello/bob Hello bob! real 0m5.408s user 0m0.036s sys 0m0.009s $ time curl http://localhost:8080/hello/bob Hello bob! real 0m0.092s user 0m0.021s sys 0m0.027s
Nota che la prima volta che la richiesta ha richiesto cinque secondi, ma quella successiva è stata molto più veloce, nonostante tu abbia Thread.sleep(5000)la chiamata nel metodo. Il motivo è che il metodo effettivo è stato eseguito una sola volta e il risultato è stato inserito nella cache. Ogni chiamata successiva restituisce il risultato direttamente dalla cache.
7. Esamina gli oggetti memorizzati nella cache
Puoi vedere esattamente ciò che l'app ha memorizzato nella cache. Dallo stesso terminale che hai utilizzato nel passaggio precedente, connettiti all'host Memorystore for Redis utilizzando l'interfaccia a riga di comando di Redis:
$ redis-cli -h <memorystore-host-ip-address>
Per visualizzare l'elenco delle chiavi cache, utilizza il seguente comando:
:6379> KEYS * 1) "hello::bob"
Come puoi vedere, il nome della cache viene utilizzato come prefisso della chiave e il valore del parametro come seconda parte.
Per recuperare il valore, utilizza il comando GET:
:6379> GET hello::bob Hello bob!
Usa il comando exit per uscire.
8. Esegui la pulizia
Per eseguire la pulizia, elimina le istanze Compute Engine e Memorystore da Cloud Shell.
Elimina l'istanza Compute:
$ gcloud compute instances delete instance-1 --zone us-central1-c
Elimina l'istanza Memorystore for Redis:
$ gcloud redis instances delete myinstance --region=us-central1
9. Complimenti!
Hai creato Memorystore for Redis e un'istanza Compute Engine. Inoltre, hai configurato un'app Spring Boot per utilizzare Memorystore con la memorizzazione nella cache Spring Boot.
Scopri di più
- Memorizzazione nella cache dell'avvio primaverile
- Memorystore
- Spring nel repository GitHub di Google Cloud
- Java su Google Cloud
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.