En esta página, se proporcionan muestras de código para las instancias de Memorystore para Valkey que tienen los modos Cluster Mode Enabled y Cluster Mode Disabled.
Muestras de código para el modo de clúster habilitado
Memorystore para Valkey es compatible con todas las muestras de código de cliente de Memorystore para Redis Cluster:
- Ejemplos de código de la biblioteca cliente de Memorystore for Redis Cluster
- Ejemplos de código de conexión de la biblioteca cliente de Memorystore for Redis Cluster
Acerca de Valkey GLIDE
Valkey General Language Independent Driver for the Enterprise (GLIDE) es una biblioteca cliente de código abierto que admite todos los comandos de Valkey.
Puedes usar Valkey GLIDE para conectar tus aplicaciones a instancias de Memorystore for Valkey. Valkey GLIDE está diseñado para brindar confiabilidad, rendimiento optimizado y alta disponibilidad.
Para ayudar a garantizar la coherencia en el desarrollo y las operaciones de las aplicaciones, Valkey GLIDE se implementa con un framework de controladores principal, escrito en Rust, con extensiones específicas del lenguaje. Este diseño garantiza la coherencia en las funciones en todos los idiomas y reduce la complejidad.
Valkey GLIDE admite las versiones 7.2 y 8.0 de Valkey. Está disponible en los siguientes idiomas:
Otras bibliotecas cliente de OSS de Valkey
Además de Valkey GLIDE, Memorystore para Valkey es compatible con las siguientes bibliotecas cliente de código abierto de Valkey:
Sistemas y servicios
Puedes usar Spring Boot, PostgreSQL y Memorystore para Valkey para crear los siguientes sistemas y servicios:
- Sistema de administración de sesiones: La administración de sesiones es una parte fundamental de las aplicaciones web modernas, ya que garantiza que las interacciones del usuario sigan siendo coherentes y seguras en varias solicitudes. Con una capa de almacenamiento en caché, tu aplicación puede administrar las sesiones de los usuarios de manera eficiente y, al mismo tiempo, reducir la carga en tu base de datos y garantizar la escalabilidad.
- Sistema de clasificación escalable: Las clasificaciones son una forma útil de mostrar datos de clasificación en las aplicaciones. Si usas una capa de almacenamiento en caché, puedes entregar clasificaciones de tablas de clasificación en tiempo real y, al mismo tiempo, reducir la carga de la base de datos.
- Servicio de almacenamiento en caché de alto rendimiento: Las aplicaciones modernas deben ofrecer experiencias del usuario rápidas y responsivas a gran escala. Si compilas este servicio de almacenamiento en caché, puedes reducir la latencia y la carga de la base de datos.
Muestras de código para el modo de clúster inhabilitado
Memorystore para Valkey con el modo de clúster inhabilitado es compatible con todas las bibliotecas cliente de OSS de Redis y Valkey que se indican en Muestras de código para el modo de clúster habilitado.
Cuando usas una instancia con el modo de clúster inhabilitado en Memorystore para Valkey, completa las siguientes acciones:
- En lugar del objeto cliente
RedisCluster
oValkeyCluster
que proporciona la biblioteca, usa el objeto cliente de Redis o Valkey. - Crea un cliente de escritura con la dirección IP del extremo principal.
Crea un cliente de lectura con la dirección IP del extremo de lectura.
redis-py
Recomendamos usar redis-py, versiones 5.1 y posteriores.
import redis primaryEndpoint = PRIMARY_ENDPOINT_IP readerEndpoint = READER_ENDPOINT_IP primary_client = redis.Redis(host=primaryEndpoint, port=6379, db=0, decode_responses=True) reader_client = redis.Redis(host=readerEndpoint, port=6379, db=0, decode_responses=True) primary_client.set("key","value") print(reader_client.get("key"))
go-redis
Te recomendamos que uses go-redis, versiones 9.11.0 y posteriores.
package main import ( "context" "fmt" "github.com/redis/go-redis/v9" ) func main() { primary_endpoint := PRIMARY_ENDPOINT_IP reader_endpoint := READER_ENDPOINT_IP primary_client := redis.NewClient(&redis.Options{ Addr: primary_endpoint, Password: "", // no password set DB: 0, // use default DB }) reader_client := redis.NewClient(&redis.Options{ Addr: reader_endpoint, Password: "", // no password set DB: 0, // use default DB }) ctx := context.Background() err := primary_client.Set(ctx, "foo", "bar", 0).Err() if err != nil { panic(err) } val, err := reader_client.Get(ctx, "foo").Result() if err != nil { panic(err) } fmt.Println("foo", val) }
Jedis
Te recomendamos usar Jedis, versiones 4.4.0 y posteriores.
package org.example; import java.io.*; import java.time.LocalDateTime; import java.lang.Thread; import java.util.HashMap; import java.util.Map; import redis.clients.jedis.HostAndPort; import redis.clients.jedis.JedisPoolConfig; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; public class Main { public static void main( String[] args ) { primaryEndpoint = PRIMARY_ENDPOINT_IP JedisPool pool = new JedisPool(primaryEndpoint, 6379); try (Jedis jedis = pool.getResource()) { jedis.set("foo", "bar"); System.out.println(jedis.get("foo")); // prints bar Maphash = new HashMap<>();; hash.put("name", "John"); hash.put("surname", "Smith"); hash.put("company", "Redis"); hash.put("age", "29"); jedis.hset("user-session:123", hash); System.out.println(jedis.hgetAll("user-session:123")); // Prints: {name=John, surname=Smith, company=Redis, age=29} } catch (Exception e) { System.out.println("Error setting or getting key: " + e.getMessage()); } } }
Node.js
Te recomendamos usar Node.js, versiones 24.4.1 y posteriores.
import { createClient } from 'redis'; import * as fs from 'fs'; const primaryEndpoint = PRIMARY_ENDPOINT_IP const primary_endpoint_url ='redis://primaryEndpoint:6379' const client = createClient({ url: primary_endpoint_url }); await client.connect(); await client.set(key, value); const retval = await client.get(key); console.log(retval)
Muestra de código para la autenticación de IAM y la encriptación en tránsito
En esta sección, se proporciona un ejemplo de cómo autenticarse y conectarse a una instancia de Memorystore para Valkey usando la autenticación de IAM y la encriptación en tránsito con varias bibliotecas cliente.
redis-py
Recomendamos usar redis-py, versiones 5.1 y posteriores.
from google.cloud import iam_credentials_v1 from redis.backoff import ConstantBackoff from redis.retry import Retry from redis.exceptions import ( ConnectionError, AuthenticationWrongNumberOfArgsError, AuthenticationError ) from redis.utils import (str_if_bytes) import redis service_account="projects/-/serviceAccounts/<TO-DO-1: your service account that used to authenticate to Valkey>"" host=<TO-DO-2: your Redis Cluster discovery endpoint ip> ssl_ca_certs=<TO-DO-3, your trusted server ca file name> def generate_access_token(): # Create a client client = iam_credentials_v1.IAMCredentialsClient() # Initialize request argument(s) request = iam_credentials_v1.GenerateAccessTokenRequest( name=service_account, scope=['https://www.googleapis.com/auth/cloud-platform'], ) # Make the request response = client.generate_access_token(request=request) print(str(response.access_token)) # Handle the response return str(response.access_token) class ValkeyTokenProvider(redis.CredentialProvider): # Generated IAM tokens are valid for 15 minutes def get_credentials(self): token= generate_access_token() return "default",token creds_provider = ValkeyTokenProvider() client = redis.Redis(host=host, port=6379, credential_provider=creds_provider, ssl=True, ssl_ca_certs=caFilePath) client.set('foo',"bar") print(client.get('foo'))
Go
Te recomendamos que uses Go, versiones 1.24.5 y posteriores.
package main import ( "context" "crypto/tls" "crypto/x509" "flag" "fmt" "io/ioutil" "log" "sync" "time" credentials "google.golang.org/genproto/googleapis/iam/credentials/v1" "github.com/golang/protobuf/ptypes" "github.com/redis/go-redis/v9" "google.golang.org/api/option" gtransport "google.golang.org/api/transport/grpc" ) var ( svcAccount = flag.String("a", "projects/-/serviceAccounts/example-service-account@example-project.iam.gserviceaccount.com", "service account email") lifetime = flag.Duration("d", time.Hour, "lifetime of token") refreshDuration = flag.Duration("r", 5*time.Minute, "token refresh duration") checkTokenExpiryInterval = flag.Duration("e", 10*time.Second, "check token expiry interval") lastRefreshInstant = time.Time{} errLastSeen = error(nil) token = "" mu = sync.RWMutex{} err = error(nil) ) func retrieveToken() (string, error) { ctx := context.Background() conn, err := gtransport.Dial(ctx, option.WithEndpoint("iamcredentials.googleapis.com:443"), option.WithScopes("https://www.googleapis.com/auth/cloud-platform")) if err != nil { log.Printf("Failed to dial API, error: %v", err) return token, err } client := credentials.NewIAMCredentialsClient(conn) req := credentials.GenerateAccessTokenRequest{ Name: *svcAccount, Scope: []string{"https://www.googleapis.com/auth/cloud-platform"}, Lifetime: ptypes.DurationProto(*lifetime), } rsp, err := client.GenerateAccessToken(ctx, &req) if err != nil { log.Printf("Failed to call GenerateAccessToken with request: %v, error: %v", req, err) return token, err } return rsp.AccessToken, nil } func refreshTokenLoop() { if *refreshDuration > *lifetime { log.Fatal("Refresh should not happen after token is already expired.") } for { mu.RLock() lastRefreshTime := lastRefreshInstant mu.RUnlock() if time.Now().After(lastRefreshTime.Add(*refreshDuration)) { var err error retrievedToken, err := retrieveToken() mu.Lock() token = retrievedToken if err != nil { errLastSeen = err } else { lastRefreshInstant = time.Now() } mu.Unlock() } time.Sleep(*checkTokenExpiryInterval) } } func retrieveTokenFunc() (string, string) { mu.RLock() defer mu.RUnlock() if time.Now().After(lastRefreshInstant.Add(*refreshDuration)) { log.Printf("Token is expired. last refresh instant: %v, refresh duration: %v, error that was last seen: %v", lastRefreshInstant, *refreshDuration, errLastSeen) return "", "" } username := "default" password := token return username, password } func main() { caFilePath := CA_FILE_PATH clusterDicEpAddr := PRIMARY_ENDPOINT_IP_ADDRESS_AND_PORT caCert, err := ioutil.ReadFile(caFilePath) if err != nil { log.Fatal(err) } caCertPool := x509.NewCertPool() caCertPool.AppendCertsFromPEM(caCert) token, err = retrieveToken() if err != nil { log.Fatal("Cannot retrieve IAM token to authenticate to the cluster, error: %v", err) } token, err = retrieveToken() fmt.Printf("token : %v", token) if err != nil { log.Fatal("Cannot retrieve IAM token to authenticate to the cluster, error: %v", err) } lastRefreshInstant = time.Now() go refreshTokenLoop() client := redis.NewClient(&redis.Options{ Addr: clusterDicEpAddr, CredentialsProvider: retrieveTokenFunc, TLSConfig: &tls.Config{ RootCAs: caCertPool, }, }) ctx := context.Background() err = client.Set(ctx, "foo", "bar", 0).Err() if err != nil { log.Fatal(err) } val, err := client.Get(ctx, "foo").Result() if err != nil { log.Fatal(err) } fmt.Printf("\nGot the value for key: key, which is %s \n", val) }