Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Mejores prácticas para usar réplicas de lectura

Muchas aplicaciones, como los almacenes de sesiones, las tablas de clasificación y los motores de recomendaciones, requieren una alta disponibilidad y gestionan muchas más operaciones de lectura que de escritura. A menudo, estas aplicaciones toleran datos ligeramente obsoletos (con la consiguiente coherencia), lo que significa que es aceptable que distintos usuarios vean momentáneamente versiones ligeramente diferentes de los mismos datos. Por ejemplo:

La coherencia final significa que todos los nodos de réplica finalmente devolverán los mismos datos una vez que se complete el proceso de replicación, normalmente en milisegundos. En estos casos de uso, implementar réplicas de lectura es una estrategia eficaz para reducir la latencia al leer desde la ElastiCache instancia.

El uso de réplicas de lectura en Amazon ElastiCache puede proporcionar importantes beneficios de rendimiento mediante:

Escalabilidad de lectura mejorada

Rendimiento optimizado del nodo principal

Uso de Read from Replica en ElastiCache Serverless

ElastiCache serverless proporciona dos puntos finales diferentes para diferentes requisitos de coherencia. Los dos puntos finales utilizan el mismo nombre de DNS pero puertos diferentes. Para utilizar el read-from-replica puerto, debe autorizar el acceso a ambos puertos desde la aplicación cliente mediante la configuración de los grupos de seguridad y las listas de control de acceso a la red de su VPC.

Punto final principal (puerto 6379)

Punto final con latencia optimizada (puerto 6380)

Conexión para leer réplicas en Serverless: Valkey y Glide ElastiCache

El siguiente fragmento de código muestra cómo configurar la lectura desde una réplica para ElastiCache Serverless en la biblioteca Valkey glide. No es necesario especificar el puerto para la lectura de las réplicas, pero sí configurar la configuración de enrutamiento. 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());
                }
            }
        }
    }
}