Questa pagina fornisce esempi di codice per le istanze Memorystore for Valkey che hanno sia la modalità cluster abilitata sia quella disabilitata.
Esempi di codice per la modalità cluster abilitata
Memorystore for Valkey è compatibile con tutti gli esempi di codice client di Memorystore for Redis Cluster:
- Esempi di codice della libreria client di Memorystore for Redis Cluster
- Memorystore for Redis Cluster Esempi di codice di connessione della libreria client
Informazioni su Valkey GLIDE
Valkey General Language Independent Driver for the Enterprise (GLIDE) è una libreria client open source e supporta tutti i comandi Valkey.
Puoi utilizzare Valkey GLIDE per connettere le tue applicazioni alle istanze Memorystore for Valkey. Valkey GLIDE è progettato per affidabilità, prestazioni ottimizzate e alta disponibilità.
Per garantire la coerenza nello sviluppo e nelle operazioni delle applicazioni, Valkey GLIDE viene implementato utilizzando un framework di driver di base, scritto in Rust, con estensioni specifiche per la lingua. Questo design garantisce la coerenza delle funzionalità tra le lingue e riduce la complessità.
Valkey GLIDE supporta le versioni 7.2 e 8.0 di Valkey. È disponibile per le seguenti lingue:
Altre librerie client OSS di Valkey
Oltre a Valkey GLIDE, Memorystore for Valkey è compatibile con le seguenti librerie client Valkey OSS:
Sistemi e servizi
Puoi utilizzare Spring Boot, PostgreSQL e Memorystore for Valkey per creare i seguenti sistemi e servizi:
- Sistema di gestione delle sessioni: la gestione delle sessioni è una parte fondamentale delle moderne applicazioni web, in quanto garantisce che le interazioni degli utenti rimangano coerenti e sicure in più richieste. Utilizzando un livello di memorizzazione nella cache, la tua applicazione può gestire le sessioni utente in modo efficiente, riducendo il carico sul database e garantendo la scalabilità.
- Sistema di classifiche scalabile: le classifiche sono un modo utile per visualizzare i dati di ranking nelle applicazioni. Utilizzando un livello di memorizzazione nella cache, puoi fornire classifiche in tempo reale riducendo il carico del database.
- Servizio di memorizzazione nella cache ad alte prestazioni: le applicazioni moderne devono offrire esperienze utente rapide e reattive su larga scala. Creando questo servizio di memorizzazione nella cache, puoi ridurre sia la latenza che il carico del database.
Esempi di codice per la modalità cluster disabilitata
Memorystore for Valkey Cluster Mode Disabled è compatibile con tutte le librerie client Redis e Valkey OSS elencate in Esempi di codice per la modalità cluster abilitata.
Quando utilizzi un'istanza con modalità cluster disabilitata in Memorystore for Valkey, completa le seguenti azioni:
- Anziché l'oggetto client
RedisCluster
oValkeyCluster
fornito dalla libreria, utilizza l'oggetto client Redis o Valkey. - Crea un client di scrittura utilizzando l'indirizzo IP dell'endpoint principale.
Crea un client di lettura utilizzando l'indirizzo IP dell'endpoint di lettura.
redis-py
Ti consigliamo di utilizzare redis-py, versioni 5.1 e successive.
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
Ti consigliamo di utilizzare go-redis, versioni 9.11.0 e successive.
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
Ti consigliamo di utilizzare Jedis, versioni 4.4.0 e successive.
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
Ti consigliamo di utilizzare Node.js, versioni 24.4.1 e successive.
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)
Esempio di codice per l'autenticazione IAM e la crittografia in transito
Questa sezione fornisce un esempio di come autenticarsi e connettersi a un'istanza Memorystore for Valkey utilizzando sia l'autenticazione IAM sia la crittografia in transito con varie librerie client.
redis-py
Ti consigliamo di utilizzare redis-py, versioni 5.1 e successive.
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'))
Vai
Ti consigliamo di utilizzare Go, versioni 1.24.5 e successive.
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) }