1. Visão geral
O Memorystore para Redis é um serviço totalmente gerenciado do Redis para Google Cloud. Os aplicativos em execução no Google Cloud podem atingir o desempenho máximo aproveitando o serviço Redis altamente escalonável, disponível e seguro sem o fardo de gerenciar implantações complexas do Redis. Ele pode ser usado como back-end de armazenamento em cache de dados para melhorar o desempenho dos apps Spring Boot. O codelab explica como fazer a configuração desse recurso.
O que você vai aprender
- Como usar o Memorystore como back-end de cache para um app 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?
2. Configuração e requisitos
Configuração de ambiente autoguiada
- Faça login no Console do Cloud e crie um novo projeto ou reutilize um existente. Crie uma se você ainda não tiver uma conta do Gmail ou do G Suite.
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, será necessário ativar o faturamento no Console do Cloud para usar os recursos do Google Cloud.
A execução deste codelab não será muito cara, se for o caso. Siga todas as instruções na seção "Limpeza", que orienta você sobre como encerrar recursos para não incorrer em cobranças além deste tutorial. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.
Ativar o Cloud Shell
- No Console do Cloud, clique em Ativar o Cloud Shell
.
Se você nunca tiver iniciado o Cloud Shell, verá uma tela intermediária (abaixo da dobra) com a descrição do que ele é. Se esse for o caso, clique em Continuar e você não o verá novamente. Esta é uma tela única:
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
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 codelab pode ser feito em um navegador ou no seu Chromebook.
Depois de se conectar ao Cloud Shell, você já estará autenticado e o projeto já estará configurado com seu ID do projeto.
- Execute o seguinte comando no Cloud Shell para confirmar que você está autenticado:
gcloud auth list
Resposta ao 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
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].
3. Configurar uma instância do Memorystore para Redis
Inicie o Cloud Shell.
Após o lançamento do Cloud Shell, use a linha de comando para ativar a API Memorystore e criar uma nova instância do Memorystore.
$ gcloud services enable redis.googleapis.com $ gcloud redis instances create myinstance --size=1 --region=us-central1
Após a conclusão da operação, a instância estará pronta para uso.
Encontre o redis host ip-address da instância executando o comando a seguir. Você o usará novamente mais tarde ao configurar o aplicativo Spring Boot.
$ gcloud redis instances describe myinstance --region=us-central1 \ | grep host host: 10.0.0.4
No console do Google Cloud, acesse Bancos de dados > Memorystore > Redis Sua instância deve estar no estado "pronta" estado :
4. Configurar uma instância do Compute Engine
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 da operação, a instância estará pronta para uso.
Conecte-se à sua instância via SSH com o seguinte comando:
$ gcloud compute ssh instance-1 --zone us-central1-c
Como alternativa, navegue até Computação > 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 as ferramentas OpenJDK, Maven e Redis:
$ sudo apt-get install openjdk-17-jdk-headless maven redis-tools
Aguarde a conclusão da instalação e prossiga para a próxima etapa.
5. Configurar um app Spring Boot
Crie um novo projeto do 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 \ -d type=maven-project \ | tar -xzvf - && cd cache-app
Edite o arquivo application.properties para configurar o aplicativo para usar o endereço IP da instância do Memorystore para host do Redis.
$ nano src/main/resources/application.properties
Adicione a seguinte linha ao endereço IP do Memorystore para Redis (de algumas etapas anteriores):
spring.data.redis.host=<memorystore-host-ip-address>
Adicione uma nova linha depois disso e crie uma classe Java do controlador REST:
$ nano src/main/java/com/example/demo/HelloWorldController.java
Insira 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". Ele é usado em combinação com o valor do parâmetro como uma chave de cache. Vamos ver um exemplo mais adiante no codelab.
Em seguida, ativaremos 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 uma anotação à classe com essa anotação. 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);
}
}
6. Executar o app e acessar o endpoint
Verifique se JAVA_HOME está definido com a versão correta:
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/
Agora você já pode executar o app.
$ mvn spring-boot:run
Abra outra conexão SSH para a instância da mesma forma que você fez antes. Na nova janela 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 haver a invocação Thread.sleep(5000) no método. Isso ocorre 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.
7. Analisar objetos armazenados em 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 redis-cli:
$ redis-cli -h <memorystore-host-ip-address>
Para ver a lista de chaves de cache, use o seguinte comando:
:6379> KEYS * 1) "hello::bob"
Como você pode notar, o nome do cache é usado como prefixo para a chave e o valor do parâmetro é usado como a segunda parte.
Para recuperar o valor, use o comando GET:
:6379> GET hello::bob Hello bob!
Use o comando exit para sair.
8. Limpar
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
9. Parabéns!
Você criou o Memorystore para Redis e uma instância do Compute Engine. Além disso, você configurou um aplicativo Spring Boot para usar o Memorystore com armazenamento em cache do Spring Boot.
Saiba mais
- Armazenamento em cache do Spring Boot
- Memorystore
- Repositório do GitHub do Spring no Google Cloud
- Java no Google Cloud
Licença
Este conteúdo está sob a licença Atribuição 2.0 Genérica da Creative Commons.