Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Procedure consigliate per l'utilizzo delle repliche di lettura

Molte applicazioni, come gli archivi di sessioni, le classifici e i motori di raccomandazione, richiedono un'elevata disponibilità e gestiscono un numero significativamente maggiore di operazioni di lettura rispetto alle operazioni di scrittura. Queste applicazioni possono spesso tollerare dati leggermente obsoleti (eventuale coerenza), il che significa che è accettabile che utenti diversi visualizzino momentaneamente versioni leggermente diverse degli stessi dati. Per esempio:

La coerenza finale significa che tutti i nodi di replica restituiranno gli stessi dati una volta completato il processo di replica, in genere entro pochi millisecondi. In questi casi d'uso, l'implementazione di repliche di lettura è una strategia efficace per ridurre la latenza durante la lettura dall'istanza. ElastiCache

L'utilizzo di repliche di lettura in Amazon ElastiCache può offrire vantaggi significativi in termini di prestazioni attraverso:

Scalabilità di lettura migliorata

Prestazioni ottimizzate del nodo primario

Utilizzo di Read from Replica in modalità Serverless ElastiCache

ElastiCache serverless fornisce due endpoint diversi, per requisiti di coerenza diversi. I due endpoint utilizzano lo stesso nome DNS ma porte diverse. Per utilizzare la read-from-replica porta, devi autorizzare l'accesso a entrambe le porte dall'applicazione client configurando i gruppi di sicurezza e gli elenchi di controllo degli accessi alla rete del tuo VPC.

Endpoint primario (porta 6379)

Endpoint ottimizzato per la latenza (porta 6380)

Connessione per leggere le repliche in Serverless - Valkey e Glide ElastiCache

Il seguente frammento di codice mostra come configurare la lettura dalla replica per ElastiCache Serverless nella libreria Valkey glide. Non è necessario specificare la porta per la lettura dalle repliche, ma è necessario configurare la configurazione del routing. ReadFrom.PREFER_REPLICA

package glide.examples;

import glide.api.GlideClusterClient;
import glide.api.logging.Logger;
import glide.api.models.configuration.GlideClusterClientConfiguration;
import glide.api.models.configuration.NodeAddress;
import glide.api.models.exceptions.ClosingException;
import glide.api.models.exceptions.ConnectionException;
import glide.api.models.exceptions.TimeoutException;
import glide.api.models.configuration.ReadFrom;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class ClusterExample {

    public static void main(String[] args) {
        // Set logger configuration
        Logger.setLoggerConfig(Logger.Level.INFO);

        GlideClusterClient client = null;

        try {
            System.out.println("Connecting to Valkey Glide...");

            // Configure the Glide Client
            GlideClusterClientConfiguration config = GlideClusterClientConfiguration.builder()
                .address(NodeAddress.builder()
                    .host("your-endpoint")
                    .port(6379)
                    .build())
                .useTLS(true)
                .readFrom(ReadFrom.PREFER_REPLICA)
                .build();

            // Create the GlideClusterClient
            client = GlideClusterClient.createClient(config).get();
            System.out.println("Connected successfully.");

            // Perform SET operation
            CompletableFuture<String> setResponse = client.set("key", "value");
            System.out.println("Set key 'key' to 'value': " + setResponse.get());

            // Perform GET operation
            CompletableFuture<String> getResponse = client.get("key");
            System.out.println("Get response for 'key': " + getResponse.get());

            // Perform PING operation
            CompletableFuture<String> pingResponse = client.ping();
            System.out.println("PING response: " + pingResponse.get());

        } catch (ClosingException | ConnectionException | TimeoutException | ExecutionException e) {
            System.err.println("An exception occurred: ");
            e.printStackTrace();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // Close the client connection
            if (client != null) {
                try {
                    client.close();
                    System.out.println("Client connection closed.");
                } catch (ClosingException | ExecutionException e) {
                    System.err.println("Error closing client: " + e.getMessage());
                }
            }
        }
    }
}