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.

Prácticas recomendadas para utilizar 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 (coherencia final), lo que significa que se acepta que distintos usuarios vean momentáneamente versiones ligeramente diferentes de los mismos datos. Por ejemplo:

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

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

Mejora de la escalabilidad de lectura

Rendimiento optimizado del nodo principal

Uso de Read from Replica en Serverless ElastiCache

ElastiCache serverless proporciona dos puntos finales diferentes para diferentes requisitos de coherencia. Los dos puntos de conexión 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 de conexión del principal (puerto 6379)

Punto de conexión con latencia optimizada (puerto 6380)

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

En el siguiente fragmento de código, se muestra cómo configurar la lectura desde una réplica para ElastiCache Serverless en la biblioteca Valkey glide. No necesita especificar el puerto para la lectura desde réplicas, pero sí configurar el parámetro 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());
                }
            }
        }
    }
}