O Memorystore para Redis é um serviço totalmente gerenciado do Redis para o Google Cloud. Os apps em execução no Google Cloud podem alcançar desempenho máximo aproveitando o serviço Redis altamente escalonável, disponível e seguro sem o trabalho de gerenciar implantações complexas do Redis. Ele pode ser usado como um back-end para o armazenamento em cache de dados e melhorar o desempenho dos apps Spring Boot. O codelab explica como configurar.
O que você vai aprender
- Como usar o Memorystore como um back-end de cache para um app do Spring Boot.
O que é necessário
- um projeto do Google Cloud;
- Um navegador, como o Google Chrome
- Conhecer os editores de texto padrão do Linux, como Vim, Emacs e GNU Nano
Como você vai usar o codelab?
Como você classificaria sua experiência com os serviços do Google Cloud?
Configuração de ambiente autoguiada
Se você ainda não tem uma Conta do Google (Gmail ou Google Apps), crie uma. Faça login no Console do Google Cloud Platform (console.cloud.google.com) e crie um projeto:
Lembre-se do código do projeto, um nome exclusivo em todos os projetos do Google Cloud. O nome acima já foi escolhido e não servirá para você. Faremos referência a ele mais adiante neste codelab como PROJECT_ID.
Em seguida, ative o faturamento no console do Cloud para usar os recursos do Google Cloud.
A execução por meio deste codelab terá um custo baixo, mas poderá ser mais se você decidir usar mais recursos ou se deixá-los em execução. Consulte a seção "limpeza" no final deste documento.
Novos usuários do Google Cloud Platform têm direito a uma avaliação sem custo financeiro de US$300.
Ativar o Google Cloud Shell
No Console do GCP, clique no ícone do Cloud Shell na barra de ferramentas localizada no canto superior direito:
Em seguida, clique em "Start Cloud Shell":
O provisionamento e a conexão ao ambiente levarão apenas alguns instantes para serem concluídos:
Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Praticamente todo o seu trabalho neste laboratório pode ser feito em um navegador ou no seu Google Chromebook.
Depois de se conectar ao Cloud Shell, sua conta já estará autenticada e o projeto estará configurado com seu PROJECT_ID.
Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:
gcloud auth list
Resposta ao comando
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
Inicie o Cloud Shell.
Depois que o Cloud Shell for iniciado, use a linha de comando para criar uma instância do Memorystore.
$ gcloud redis instances create myinstance --size=1 --region=us-central1
Se a API Memorystore não estiver ativada, você vai receber uma pergunta sobre se quer ativá-la. Responda y.
API [redis.googleapis.com] not enabled on project [204466653457]. Would you like to enable and retry (this will take a few minutes)? (y/N)? y Enabling service redis.googleapis.com on project 204166153457... Waiting for async operation operations/tmo-acf.c8909997-1b4e-1a62-b6f5-7da75cce1416 to complete... Operation finished successfully. The following command can describe the Operation details: gcloud services operations describe operations/tmo-acf.c8909997-1b4e-1a62-b6f5-7da75cce1416 Create request issued for: [myinstance] Waiting for operation [operation-1538645026454-57763b937ad39-2564ab37-3fea7701] to complete...done. Created instance [myinstance].
Após a conclusão dessa operação, sua instância estará pronta para uso.
Execute o comando a seguir para receber o endereço IP do host do Redis da instância. Você vai usá-lo novamente mais tarde ao configurar o app Spring Boot.
$ gcloud redis instances describe myinstance --region=us-central1 \ | grep host host: 10.0.0.4
Se você acessar Armazenamento > Memorystore no console do Google Cloud, poderá ver sua instância no estado "pronta":
Crie uma instância do Compute Engine na mesma região.
$ gcloud compute instances create instance-1 --zone us-central1-c
Após a conclusão dessa operação, sua instância estará pronta para uso.
Para se conectar à instância via SSH, acesse Compute > Compute Engine > Instâncias de VM e clique em SSH na coluna Conectar:
No shell da instância de máquina virtual (VM), não no Cloud Shell, instale o OpenJDK, o Maven e o telnet:
$ sudo apt-get install openjdk-8-jdk-headless maven telnet
Aguarde a conclusão da instalação e siga para a próxima etapa.
Crie um projeto Spring Boot com as dependências web, redis e cache:
$ curl https://start.spring.io/starter.tgz \ -d dependencies=web,redis,cache -d language=java -d baseDir=cache-app \ | tar -xzvf - && cd cache-app
Edite o arquivo application.properties para configurar o app de modo que ele use o endereço IP da instância do Memorystore para host do Redis.
$ nano src/main/resources/application.properties
Adicione a seguinte linha com seu endereço IP do Memorystore para Redis (de algumas etapas atrás):
spring.redis.host=<memorystore-host-ip-address>
Adicione uma nova linha depois disso e crie uma classe Java de controlador REST:
$ nano src/main/java/com/example/demo/HelloWorldController.java
Coloque o seguinte conteúdo no arquivo:
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;
}
}A anotação @RequestMapping expõe o método como um endpoint HTTP e mapeia parte do caminho para um parâmetro de método (conforme indicado pela anotação @PathVariable).
A anotação @Cacheable("hello") indica que a execução do método precisa ser armazenada em cache, e o nome do cache é "hello". Ela é usada em combinação com o valor do parâmetro como uma chave de cache. Você vai ver um exemplo mais adiante neste codelab.
Além disso, é necessário ativar o armazenamento em cache na classe do app Spring Boot.
Editar DemoApplication.java:
$ nano src/main/java/com/example/demo/DemoApplication.java
Importe org.springframework.cache.annotation.EnableCaching e adicione essa anotação à classe. O resultado ficará assim:
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);
}
}Agora você já pode executar o app.
$ mvn spring-boot:run
Abra outra conexão SSH com a instância da mesma forma que fez antes. Na nova janela do SSH, acesse o endpoint /hello/ várias vezes, transmitindo "bob" como 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
A primeira vez que a solicitação levou cinco segundos, mas a próxima foi significativamente mais rápida, apesar de você ter Thread.sleep(5000)invocation no método. Isso acontece porque o método real foi executado apenas uma vez e o resultado foi colocado no cache. Cada chamada subsequente retorna o resultado diretamente do cache.
Você pode ver exatamente o que o app armazenou em cache. No mesmo terminal usado na etapa anterior, conecte-se ao host do Memorystore para Redis usando o Telnet:
$ telnet <memorystore-host-ip-address> 6379
Para conferir a lista de chaves de cache, use o seguinte comando:
KEYS * hello::bob
Como você pode ver, o nome do cache é usado como prefixo da chave, e o valor do parâmetro é usado como a segunda parte.
Para recuperar o valor, use o comando GET:
$ GET hello::bob Hello bob!
Use o comando QUIT para sair.
Para limpar, exclua as instâncias do Compute Engine e do Memorystore do Cloud Shell.
Exclua a instância de computação:
$ gcloud compute instances delete instance-1 --zone us-central1-c
Exclua a instância do Memorystore para Redis:
$ gcloud redis instances delete myinstance --region=us-central1
Você criou o Memorystore para Redis e uma instância do Compute Engine. Além disso, você configurou um app Spring Boot para usar o Memorystore com caching do Spring Boot.
Saiba mais
- Armazenamento em cache do Spring Boot
- Memorystore
- Projeto Spring no Google Cloud
- Repositório do Spring no Google Cloud no GitHub
- Java no Google Cloud
Licença
Este conteúdo está sob a licença Atribuição 2.0 Genérica da Creative Commons.