Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Bonnes pratiques d'utilisation des répliques de lecture

De nombreuses applications, telles que les magasins de sessions, les classements et les moteurs de recommandation, nécessitent une haute disponibilité et gèrent beaucoup plus d'opérations de lecture que d'opérations d'écriture. Ces applications peuvent souvent tolérer des données légèrement périmées (cohérence éventuelle), ce qui signifie qu'il est acceptable que différents utilisateurs voient momentanément des versions légèrement différentes des mêmes données. Par exemple :

La cohérence éventuelle signifie que tous les nœuds de réplication renverront les mêmes données une fois le processus de réplication terminé, généralement en quelques millisecondes. Dans de tels cas d'utilisation, la mise en œuvre de répliques de lecture constitue une stratégie efficace pour réduire le temps de latence lors de la lecture depuis votre ElastiCache instance.

L'utilisation de répliques de lecture dans Amazon ElastiCache peut apporter des avantages significatifs en termes de performances grâce à :

Évolutivité de lecture améliorée

Performances optimisées du nœud principal

Utilisation de Read from Replica en mode ElastiCache Serverless

ElastiCache serverless fournit deux points de terminaison différents, pour des exigences de cohérence différentes. Les deux points de terminaison utilisent le même nom DNS mais des ports différents. Pour utiliser le read-from-replica port, vous devez autoriser l'accès aux deux ports depuis votre application cliente en configurant les groupes de sécurité et les listes de contrôle d'accès réseau de votre VPC.

Point de terminaison principal (port 6379)

Point de terminaison optimisé pour la latence (port 6380)

Connexion pour lire des répliques en mode ElastiCache Serverless - Valkey and Glide

L'extrait de code suivant montre comment configurer la lecture depuis une réplique pour ElastiCache Serverless dans la bibliothèque Valkey Glide. Il n'est pas nécessaire de spécifier le port pour la lecture à partir des répliques, mais vous devez configurer la configuration ReadFrom.PREFER_REPLICA du routage.

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());
                }
            }
        }
    }
}