As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Práticas recomendadas para usar réplicas de leitura
<a name="ReadReplicas"></a>

Muitos aplicativos, como armazenamentos de sessões, tabelas de classificação e mecanismos de recomendação, exigem alta disponibilidade e processam uma quantidade significativamente maior de operações de leitura do que de operações de gravação. Em geral, esses aplicativos podem tolerar dados um pouco obsoletos (consistência eventual). Isso significa que é aceitável que usuários diferentes vejam, por alguns instantes, versões ligeiramente diferentes dos mesmos dados. Por exemplo:
+ Os resultados das consultas em cache geralmente podem tolerar dados um pouco obsoletos, especialmente para padrões de armazenamento em cache, nos quais a fonte da verdade é externa.
+ Em uma tabela de classificação de jogos, alguns segundos de atraso nas pontuações atualizadas geralmente não afetam significativamente a experiência do usuário.
+ Para armazenamentos de sessões, alguns pequenos atrasos na propagação dos dados da sessão entre réplicas raramente afetam a funcionalidade do aplicativo.
+ Os mecanismos de recomendação costumam usar análise de dados históricos, portanto, a consistência em tempo real é menos crítica.

A consistência eventual significa que todos os nós de réplica eventualmente retornarão os mesmos dados quando o processo de replicação for concluído, normalmente em milissegundos. Para esses casos de uso, implementar réplicas de leitura é uma estratégia eficaz para reduzir a latência ao ler da sua ElastiCache instância.

O uso de réplicas de leitura na Amazon ElastiCache pode oferecer benefícios significativos de desempenho por meio de:

**Escalabilidade de leitura aprimorada**
+ Distribui as operações de leitura em vários nós de réplica
+ Descarrega o tráfego de leitura do nó primário
+ Reduz a latência de leitura ao atender solicitações de réplicas geograficamente mais próximas

**Desempenho otimizado do nó primário**
+ Dedica recursos do nó primário às operações de gravação
+ Reduz a sobrecarga de conexão no nó primário
+ Melhora o desempenho de gravação e mantém melhores tempos de resposta durante os períodos de pico de tráfego

## Usando a leitura da réplica sem servidor ElastiCache
<a name="ReadReplicas.serverless"></a>

ElastiCache O serverless fornece dois endpoints diferentes, para diferentes requisitos de consistência. Os dois endpoints usam o mesmo nome de DNS, mas portas diferentes. Para usar a read-from-replica porta, você deve autorizar o acesso às duas portas do seu aplicativo cliente [configurando os grupos de segurança e as listas de controle de acesso à rede da sua VPC](set-up.md#elasticache-install-grant-access-VPN).

**Endpoint primário (porta 6379)**
+ Use para operações que exigem consistência imediata
+ Garante a leitura da maioria dos up-to-date dados
+ Ideal para transações críticas e operações de gravação
+ Necessário para operações de gravação
+ Exemplo: `test-12345.serverless.use1.cache.amazonaws.com:6379`

**Endpoint otimizado para latência (porta 6380)**
+ Otimizado para operações de leitura que podem tolerar uma eventual consistência
+ Quando possível, o ElastiCache serverless encaminha automaticamente as solicitações de leitura para o nó de réplica na zona de disponibilidade local do cliente. Essa otimização fornece menor latência ao evitar a latência adicional de rede resultante da recuperação de dados de um nó em uma zona de disponibilidade diferente.
+ ElastiCache serverless seleciona automaticamente os nós disponíveis em outras zonas se um nó local não estiver disponível
+ Exemplo: `test-12345.serverless.use1.cache.amazonaws.com:6380`
+ Clientes como Glide e Lettuce detectarão e rotearão automaticamente as leituras para o endpoint com latência otimizada se você fornecer a leitura da configuração da réplica. Se seu cliente não é compatível com a configuração de roteamento (por exemplo, valkey-java e versões mais antigas do jedis), será necessário definir a porta e a configuração do cliente corretas para ler as réplicas.

## Conectando-se a réplicas de leitura em ElastiCache Serverless - Valkey and Glide
<a name="ReadReplicas.connecting-primary"></a>

O trecho de código a seguir mostra como você pode configurar a leitura da réplica para ElastiCache Serverless na biblioteca Valkey glide. Não é preciso especificar a porta para leitura das réplicas, mas sim configurar a configuração de roteamento `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());
                }
            }
        }
    }
}
```