1. Présentation
Memorystore pour Redis est un service Redis entièrement géré pour Google Cloud. Les applications exécutées sur Google Cloud peuvent atteindre des performances extrêmes en exploitant le service Redis hautement évolutif, disponible et sécurisé, sans qu'il soit nécessaire de gérer des déploiements Redis complexes. Il peut être utilisé comme backend pour la mise en cache des données afin d'améliorer les performances des applications Spring Boot. L'atelier de programmation vous explique comment le configurer.
Points abordés
- Utiliser Memorystore en tant que backend de cache pour une application Spring Boot.
Prérequis
- Un projet Google Cloud
- Un navigateur tel que Google Chrome
- Bonne connaissance des éditeurs de texte Linux standards tels que Vim, Emacs et GNU Nano
Comment allez-vous utiliser l'atelier de programmation ?
<ph type="x-smartling-placeholder">Comment évalueriez-vous votre expérience des services Google Cloud ?
<ph type="x-smartling-placeholder">2. Préparation
Configuration de l'environnement d'auto-formation
- Connectez-vous à Cloud Console, puis créez un projet ou réutilisez un projet existant. (Si vous n'avez pas encore de compte Gmail ou G Suite, vous devez en créer un.)
Mémorisez l'ID du projet. Il s'agit d'un nom unique permettant de différencier chaque projet Google Cloud (le nom ci-dessus est déjà pris ; vous devez en trouver un autre). Il sera désigné par le nom PROJECT_ID tout au long de cet atelier de programmation.
- Vous devez ensuite activer la facturation dans Cloud Console pour pouvoir utiliser les ressources Google Cloud.
L'exécution de cet atelier de programmation est très peu coûteuse, voire gratuite. Veillez à suivre les instructions de la section "Nettoyer" qui indique comment désactiver les ressources afin d'éviter les frais une fois ce tutoriel terminé. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.
Activer Cloud Shell
- Dans Cloud Console, cliquez sur Activer Cloud Shell
.
Si vous n'avez encore jamais démarré Cloud Shell, un écran intermédiaire s'affiche en dessous de la ligne de séparation pour décrire de quoi il s'agit. Si tel est le cas, cliquez sur Continuer (cet écran ne s'affiche qu'une seule fois). Voici à quoi il ressemble :
Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.
Cette machine virtuelle contient tous les outils de développement nécessaires. Elle intègre un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier dans un simple navigateur ou sur votre Chromebook.
Une fois connecté à Cloud Shell, vous êtes en principe authentifié et le projet est défini avec votre ID de projet.
- Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :
gcloud auth list
Résultat de la commande
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si vous obtenez un résultat différent, exécutez cette commande :
gcloud config set project <PROJECT_ID>
Résultat de la commande
Updated property [core/project].
3. Configurer une instance Memorystore pour Redis
Démarrez Cloud Shell.
Une fois Cloud Shell lancé, utilisez la ligne de commande pour activer l'API Memorystore et créer une instance Memorystore.
$ gcloud services enable redis.googleapis.com $ gcloud redis instances create myinstance --size=1 --region=us-central1
Une fois l'opération terminée, votre instance sera prête à l'emploi.
Obtenez l'adresse IP de l'hôte redis de l'instance en exécutant la commande suivante. Vous l'utiliserez à nouveau plus tard lors de la configuration de votre application Spring Boot.
$ gcloud redis instances describe myinstance --region=us-central1 \ | grep host host: 10.0.0.4
Dans la console Google Cloud, accédez à Bases de données > Memorystore > Redis : Votre instance devrait se trouver à l'état "prêt" état :
4. Configurer une instance Compute Engine
Créez une instance Compute Engine dans la même région.
$ gcloud compute instances create instance-1 --zone us-central1-c
Une fois l'opération terminée, votre instance sera prête à l'emploi.
Connectez-vous à votre instance via SSH à l'aide de la commande suivante:
$ gcloud compute ssh instance-1 --zone us-central1-c
Vous pouvez également accéder à Calcul > Compute Engine > Instances de VM, puis cliquez sur SSH dans la colonne Connecter:
Dans le shell de l'instance de machine virtuelle (VM), et non dans Cloud Shell, installez les outils OpenJDK, Maven et Redis:
$ sudo apt-get install openjdk-17-jdk-headless maven redis-tools
Attendez la fin de l'installation, puis passez à l'étape suivante.
5. Configurer une application Spring Boot
Créez un projet Spring Boot avec les dépendances web, redis et 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
Modifiez le fichier application.properties afin de configurer l'application de sorte qu'elle utilise l'adresse IP de l'instance Memorystore pour l'hôte Redis.
$ nano src/main/resources/application.properties
Ajoutez la ligne suivante à votre adresse IP Memorystore pour Redis (indiquée précédemment):
spring.data.redis.host=<memorystore-host-ip-address>
Ajoutez une ligne après cela et créez une classe Java de contrôleur REST:
$ nano src/main/java/com/example/demo/HelloWorldController.java
Insérez le contenu suivant dans le fichier:
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'annotation @RequestMapping expose la méthode en tant que point de terminaison HTTP et mappe une partie du chemin d'accès à un paramètre de méthode (comme indiqué par l'annotation @PathVariable).
L'annotation @Cacheable("hello") indique que l'exécution de la méthode doit être mise en cache et que le nom du cache est "hello". Elle est utilisée avec la valeur du paramètre en tant que clé de cache. Vous en verrez un exemple plus tard dans l'atelier de programmation.
Nous allons ensuite activer la mise en cache dans la classe de l'application Spring Boot. Modifier DemoApplication.java:
$ nano src/main/java/com/example/demo/DemoApplication.java
Importez org.springframework.cache.annotation.EnableCaching et annotez la classe avec cette annotation. Voici le résultat attendu :
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. Exécuter l'application et accéder au point de terminaison
Assurez-vous que JAVA_HOME est défini sur la bonne version:
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/
Vous êtes maintenant prêt à exécuter l'application.
$ mvn spring-boot:run
Ouvrez une autre connexion SSH à votre instance de la même manière que précédemment. Dans la nouvelle fenêtre SSH, accédez plusieurs fois au point de terminaison /hello/ en transmettant "bob". comme nom.
$ 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
Notez que la première fois que la requête a pris cinq secondes, mais que la suivante était beaucoup plus rapide, malgré l'appel de Thread.sleep(5000) dans la méthode. En effet, la méthode n'a été exécutée qu'une seule fois et le résultat a été placé dans le cache. Chaque appel suivant renvoie le résultat directement à partir du cache.
7. Examiner les objets mis en cache
Vous pouvez voir exactement ce que l'application a mis en cache. Depuis le terminal utilisé à l'étape précédente, connectez-vous à l'hôte Memorystore pour Redis à l'aide de redis-cli:
$ redis-cli -h <memorystore-host-ip-address>
Pour afficher la liste des clés de cache, exécutez la commande suivante:
:6379> KEYS * 1) "hello::bob"
Comme vous pouvez le voir, le nom de cache est utilisé comme préfixe pour la clé et la valeur de paramètre dans la seconde partie.
Pour récupérer la valeur, utilisez la commande GET:
:6379> GET hello::bob Hello bob!
Utilisez la commande exit pour quitter.
8. Effectuer un nettoyage
Pour effectuer un nettoyage, supprimez les instances Compute Engine et Memorystore de Cloud Shell.
Supprimez l'instance de calcul:
$ gcloud compute instances delete instance-1 --zone us-central1-c
Supprimez l'instance Memorystore pour Redis:
$ gcloud redis instances delete myinstance --region=us-central1
9. Félicitations !
Vous avez créé Memorystore pour Redis et une instance Compute Engine. Vous avez également configuré une application Spring Boot pour utiliser Memorystore avec la mise en cache Spring Boot.
En savoir plus
Licence
Ce document est publié sous une licence Creative Commons Attribution 2.0 Generic.