Almacena datos en caché de una app de Spring Boot con Memorystore

1. Descripción general

Memorystore para Redis es un servicio de Redis completamente administrado para Google Cloud. Las apps que se ejecutan en Google Cloud pueden lograr un rendimiento extremo aprovechando el servicio de Redis altamente escalable, disponible y seguro sin la carga de administrar implementaciones complejas de Redis. Se puede usar como backend para el almacenamiento en caché de datos y, así, mejorar el rendimiento de las apps de Spring Boot. En el codelab, se explica cómo configurarlo.

Qué aprenderás

• Cómo usar Memorystore como backend de caché para una app de Spring Boot

Requisitos

• Un proyecto de Google Cloud
• Un navegador, como Google Chrome
• Conocimientos de editores de texto estándares de Linux, como Vim, Emacs y GNU Nano

¿Cómo usarás el codelab?

Solo leer Leer y completar los ejercicios

¿Cómo calificarías tu experiencia con los servicios de Google Cloud?

Principiante Intermedio Avanzado

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

1. Accede a la consola de Cloud y crea un proyecto nuevo o reutiliza uno existente. (Si todavía no tienes una cuenta de Gmail o de G Suite, debes crear una).

Nota: Para acceder a la consola de Cloud con facilidad, memoriza su URL, que es console.cloud.google.com.

Recuerde el ID de proyecto, un nombre único en todos los proyectos de Google Cloud (el nombre anterior ya se encuentra en uso y no lo podrá usar). Se mencionará más adelante en este codelab como PROJECT_ID.

Nota: Si usas una cuenta de Gmail, puedes configurar la ubicación predeterminada como Sin organización. Si usas una cuenta de G Suite, elige una ubicación que sea adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar los recursos de Google Cloud recursos.

Ejecutar este codelab no debería costar mucho, tal vez nada. Asegúrate de seguir las instrucciones de la sección “Realiza una limpieza”, en la que se aconseja cómo cerrar recursos para que no se te facture más allá de este instructivo. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.

Activar Cloud Shell

1. En la consola de Cloud, haz clic en Activar Cloud Shell.

Si nunca ha iniciado Cloud Shell, aparecerá una pantalla intermedia (debajo de la mitad inferior de la página) que describe qué es. Si ese es el caso, haz clic en Continuar (y no volverás a verlo). Así es como se ve la pantalla única:

El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer simplemente con un navegador o tu Chromebook.

Una vez conectado a Cloud Shell, debería ver que ya se autenticó y que el proyecto ya se configuró con tu ID del proyecto.

2. En Cloud Shell, ejecuta el siguiente comando para confirmar que está autenticado:

gcloud auth list

Resultado del comando

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Nota: gcloud es la herramienta de línea de comandos potente y unificada de Google Cloud. Ya está preinstalada en Cloud Shell. Notarás que admite el autocompletado con la tecla Tab. Para obtener más información, consulta la descripción general de la herramienta de línea de comandos de gcloud.

gcloud config list project

Resultado del comando

[core]
project = <PROJECT_ID>

De lo contrario, puedes configurarlo con el siguiente comando:

gcloud config set project <PROJECT_ID>

Resultado del comando

Updated property [core/project].

3. Configura una instancia de Memorystore para Redis

Inicie Cloud Shell.

Después de que se inicie Cloud Shell, usa la línea de comandos para habilitar la API de Memorystore y crear una nueva instancia de Memorystore.

$ gcloud services enable redis.googleapis.com
$ gcloud redis instances create myinstance --size=1 --region=us-central1

Una vez que se complete la operación, tu instancia estará lista para usar.

Ejecuta el siguiente comando para obtener la dirección IP del host de Redis de la instancia. La volverás a usar más adelante cuando configures tu app de Spring Boot.

$ gcloud redis instances describe myinstance --region=us-central1 \
  | grep host
host: 10.0.0.4

En la consola de Google Cloud, navega a Bases de datos > Memorystore > Redis. Tu instancia debería estar en el estado "lista":

4. Configura una instancia de Compute Engine

Crea una instancia de Compute Engine en la misma región.

$ gcloud compute instances create instance-1 --zone us-central1-c

Una vez que se complete la operación, tu instancia estará lista para usar.

Conéctate a tu instancia a través de SSH con el siguiente comando:

$ gcloud compute ssh instance-1 --zone us-central1-c

Como alternativa, navega a Compute > Compute Engine > Instancias de VM y haz clic en SSH en la columna Conectar:

En la shell de la instancia de máquina virtual (VM) (no en Cloud Shell), instala OpenJDK, Maven y las herramientas de Redis:

$ sudo apt-get install openjdk-17-jdk-headless maven redis-tools

Espera a que se complete la instalación y, luego, continúa con el siguiente paso.

5. Configura una app de Spring Boot

Crea un proyecto nuevo de Spring Boot con las dependencias web, redis y 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

Edita el archivo application.properties para configurar la app de modo que use la dirección IP del host de la instancia de Memorystore para Redis.

$ nano src/main/resources/application.properties

Agrega la siguiente línea con tu dirección IP de Memorystore para Redis (de hace unos pasos):

spring.data.redis.host=<memorystore-host-ip-address> 

Agrega una línea nueva después de eso y crea una clase Java de controlador de REST:

$ nano src/main/java/com/example/demo/HelloWorldController.java

Ingresa el siguiente contenido en el archivo:

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

La anotación @RequestMapping expone el método como un extremo HTTP y asigna parte de la ruta a un parámetro del método (como lo indica la anotación @PathVariable).

La anotación @Cacheable("hello") indica que la ejecución del método debe almacenarse en caché y que el nombre de la caché es "hello". Se usa en combinación con el valor del parámetro como clave de caché. Verás un ejemplo más adelante en el codelab.

A continuación, habilitaremos el almacenamiento en caché en la clase de la app de Spring Boot. Edita DemoApplication.java:

$ nano src/main/java/com/example/demo/DemoApplication.java

Importa org.springframework.cache.annotation.EnableCaching y anota la clase con esta anotación. El resultado debería verse como el siguiente:

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. Ejecuta la app y accede al extremo

Asegúrate de que JAVA_HOME esté configurado en la versión correcta:

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/

Ahora puedes ejecutar la app.

$ mvn spring-boot:run

Abre otra conexión SSH a tu instancia de la misma manera que lo hiciste antes. En la nueva ventana de SSH, accede al extremo /hello/ varias veces y pasa "bob" como nombre.

$ 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

Observa que la primera vez la solicitud tardó cinco segundos, pero la siguiente fue mucho más rápida a pesar de que tienes la invocación Thread.sleep(5000) en el método. Esto se debe a que el método real se ejecutó solo una vez y el resultado se colocó en la caché. Cada llamada posterior devuelve el resultado directamente desde la caché.

7. Revisa los objetos almacenados en caché

De hecho, puedes ver exactamente lo que la app almacenó en caché. Desde la misma terminal que usaste en el paso anterior, conéctate al host de Memorystore para Redis con redis-cli:

$ redis-cli -h <memorystore-host-ip-address>

Para ver la lista de claves de caché, usa el siguiente comando:

:6379> KEYS *
1) "hello::bob"

Como puedes ver, el nombre de la caché se usa como prefijo de la clave y el valor del parámetro se usa como la segunda parte.

Para recuperar el valor, usa el comando GET:

:6379> GET hello::bob
   Hello bob!

Usa el comando exit para salir.

8. Limpia

Para limpiar, borra las instancias de Compute Engine y Memorystore de Cloud Shell.

Borra la instancia de procesamiento:

$ gcloud compute instances delete instance-1 --zone us-central1-c

Borra la instancia de Memorystore para Redis:

$ gcloud redis instances delete myinstance --region=us-central1

9. ¡Felicitaciones!

Creaste Memorystore para Redis y una instancia de Compute Engine. Además, configuraste una app de Spring Boot para usar Memorystore con el almacenamiento en caché de Spring Boot.

Más información

• Almacenamiento en caché de Spring Boot
• Memorystore
• Repositorio de GitHub de Spring en Google Cloud
• Java en Google Cloud

Licencia

Este trabajo cuenta con una licencia Atribución 2.0 Genérica de Creative Commons.