0Pricing
Cloud & IT Cert Prep · Lezione

Gruppi di replica Redis e modalità cluster di ElastiCache

Creare un gruppo di replica Redis per scalare le letture e abilitare la modalità cluster per distribuire i dati tra più gruppi di nodi

Gruppi di replica Redis e modalità cluster di ElastiCache è una lezione Cloud & IT Cert Prep gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Cloud & IT Cert Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Cloud & IT Cert Prep include 4 lezioni in totale.

Panoramica dei gruppi di replica Redis

Un gruppo di replica ElastiCache è un raggruppamento logico costituito da un nodo Redis primario e fino a 5 read replica. Il nodo primario gestisce tutte le operazioni di scrittura; le repliche ricevono la replica asincrona dal primario e gestiscono il traffico di lettura. I gruppi di replica consentono due funzionalità fondamentali: scalabilità in lettura (distribuzione delle richieste di lettura tra più repliche) e alta disponibilità con failover automatico (promozione di una replica a primario in caso di guasto del primario). Tutti i nodi di un gruppo di replica condividono lo stesso dataset.

# Create a replication group with 1 primary and 2 read replicas
aws elasticache create-replication-group \
  --replication-group-id web-cache \
  --replication-group-description 'Web application cache' \
  --num-cache-clusters 3 \
  --cache-node-type cache.r7g.large \
  --engine redis \
  --engine-version '7.0' \
  --automatic-failover-enabled \
  --multi-az-enabled \
  --cache-subnet-group-name my-multi-az-subnet-group

Endpoint primario ed endpoint reader

ElastiCache fornisce due endpoint DNS per un gruppo di replica: il primary endpoint punta sempre al nodo primario corrente (e viene aggiornato automaticamente durante il failover); lo utilizzi per tutte le operazioni di scrittura. Il reader endpoint distribuisce il carico delle richieste di lettura tra tutte le repliche disponibili; lo utilizzi per le operazioni di lettura, così da distribuire il carico. L'applicazione dovrebbe mantenere due connection pool: una per il primary endpoint, destinata alle scritture, e una per il reader endpoint, destinata alle letture. Questo è il pattern di connessione consigliato per i gruppi di replica Redis di ElastiCache.

# Get primary and reader endpoints
aws elasticache describe-replication-groups \
  --replication-group-id web-cache \
  --query 'ReplicationGroups[].{
    Primary:NodeGroups[].PrimaryEndpoint.Address,
    Reader:ReaderEndpoint.Address
  }'

# Application connection pattern:
# write_client = redis.Redis(host='primary-endpoint', port=6379)
# read_client = redis.Redis(host='reader-endpoint', port=6379)

Processo di failover automatico

Quando il nodo primario ha un guasto (rilevato da ElastiCache in pochi secondi tramite gli health check), il failover automatico seleziona una delle read replica e la promuove a primario. Il processo di promozione è il seguente: (1) la replica selezionata viene promossa a primario, (2) il record DNS del primary endpoint viene aggiornato per puntare al nuovo primario (TTL di circa 1 secondo), (3) il vecchio primario viene sostituito da una nuova replica. Il tempo totale di failover è in genere di 30-60 secondi. Le applicazioni che utilizzano il DNS del primary endpoint si riconnettono automaticamente quando la modifica DNS si propaga: non sono necessari indirizzi IP hardcoded.

# Test failover manually (triggers primary failover)
aws elasticache test-failover \
  --replication-group-id web-cache \
  --node-group-id 0001

# Monitor failover events
aws elasticache describe-events \
  --source-identifier web-cache \
  --source-type replication-group \
  --duration 60 \
  --query 'Events[].{Time:Date,Message:Message}'

Distribuzione delle repliche su più AZ

Per ottenere la massima resilienza, distribuisca le repliche su più Availability Zone. Quando abilita Multi-AZ su un gruppo di replica, ElastiCache colloca automaticamente il primario e le repliche in AZ diverse. Se un'intera AZ diventa non disponibile, il failover promuove una replica di un'AZ ancora operativa. Quando crea il gruppo di replica, può anche specificare esplicitamente le AZ preferite per ogni nodo utilizzando l'opzione --preferred-cache-cluster-a-zs.

# Create replication group with explicit AZ placement
aws elasticache create-replication-group \
  --replication-group-id ha-redis \
  --replication-group-description 'Multi-AZ Redis' \
  --num-cache-clusters 3 \
  --cache-node-type cache.r7g.xlarge \
  --engine redis \
  --automatic-failover-enabled \
  --multi-az-enabled \
  --preferred-cache-cluster-a-zs us-east-1a us-east-1b us-east-1c \
  --cache-subnet-group-name multi-az-subnets

Che cos'è la Redis Cluster Mode

Redis Cluster Mode Enabled (CME) suddivide il dataset tra più gruppi di nodi (shard), ciascuno contenente un primario e fino a 5 repliche. Questa è la soluzione di sharding orizzontale di Redis. Cluster Mode consente di superare la memoria di un singolo nodo: può avere fino a 500 gruppi di nodi da 500 GB ciascuno, permettendo a un singolo cluster Redis di contenere fino a 500 × 500 GB = 250 TB di dati. Cluster Mode moltiplica inoltre il throughput di scrittura, poiché ogni gruppo di nodi elabora in modo indipendente le scritture per il proprio intervallo di chiavi.

# Create a Redis Cluster Mode Enabled replication group
# with 3 shards, each with 1 primary and 2 replicas
aws elasticache create-replication-group \
  --replication-group-id clustered-redis \
  --replication-group-description 'Cluster mode: 3 shards x 3 nodes' \
  --num-node-groups 3 \
  --replicas-per-node-group 2 \
  --cache-node-type cache.r7g.large \
  --engine redis \
  --automatic-failover-enabled \
  --multi-az-enabled \
  --cache-subnet-group-name multi-az-subnets

Hash slot e distribuzione delle chiavi

Redis Cluster Mode suddivide lo spazio delle chiavi in 16.384 hash slot. Ogni gruppo di nodi possiede un intervallo contiguo di hash slot. Quando viene scritta una chiave, Redis calcola CRC16(key) % 16384 per determinare l'hash slot e quindi il gruppo di nodi responsabile. L'applicazione deve utilizzare un client Redis compatibile con i cluster (come redis-py-cluster o Jedis in modalità cluster) che conosca la mappa degli slot e instradi ogni comando al nodo corretto. I client standard restituiscono errori di reindirizzamento MOVED se inviano una chiave allo shard errato.

# Python cluster-aware client example
# pip install redis[hiredis]

# from redis.cluster import RedisCluster
# cluster_client = RedisCluster(
#   host='clustered-redis.abc123.clustercfg.use1.cache.amazonaws.com',
#   port=6379,
#   decode_responses=True
# )

# The client automatically resolves slot-to-node mapping
# cluster_client.set('user:1', 'Alice')   # routes to correct shard
# cluster_client.get('user:1')            # routes to correct shard

Modalità cluster e modalità non cluster

Per l'esame SAA-C03, scelga la modalità non cluster quando: i dati entrano in un singolo nodo (< ~400 GB lasciando un margine), è necessaria una configurazione semplice primario/replica oppure l'applicazione utilizza operazioni complesse su più chiavi (le transazioni che coinvolgono più chiavi richiedono che tutte le chiavi si trovino nello stesso slot). Scelga la modalità cluster quando: il dataset supera la memoria di un singolo nodo, è necessario aumentare orizzontalmente il throughput di scrittura oppure prevede una crescita futura che richiederà il resharding online. La modalità cluster supporta l'aggiunta di shard senza downtime (resharding online).

# Scale out a cluster-mode Redis by adding shards
aws elasticache modify-replication-group-shard-configuration \
  --replication-group-id clustered-redis \
  --node-group-count 5 \
  --apply-immediately \
  --resharding-configuration \
    NodeGroupId=0004,PreferredAvailabilityZones=us-east-1a,us-east-1b,us-east-1c \
    NodeGroupId=0005,PreferredAvailabilityZones=us-east-1a,us-east-1b,us-east-1c

# No downtime — slots are migrated incrementally

Global Datastore per la replica tra regioni

ElastiCache Global Datastore estende la replica di Redis tra più Regioni AWS. Si designa una Regione come cluster primario e si aggiungono cluster secondari in altre Regioni. Le scritture vengono inviate al primario; i secondari ricevono la replica asincrona, con un ritardo tipico inferiore a 1 secondo. I cluster secondari possono gestire le letture locali con una latenza molto bassa. Global Datastore consente di realizzare applicazioni globali, in cui gli utenti di continenti diversi leggono i dati dalla Regione più vicina, e scenari di DR tra regioni, in cui è possibile promuovere un cluster secondario a primario se la Regione primaria si guasta.

# Create a Global Datastore (adds a secondary region to an existing cluster)
aws elasticache create-global-replication-group \
  --global-replication-group-id-suffix my-global-cache \
  --primary-replication-group-id prod-redis

# Add a secondary cluster in another region
aws elasticache create-replication-group \
  --replication-group-id prod-redis-eu \
  --replication-group-description 'EU secondary' \
  --global-replication-group-id ldgnf-my-global-cache \
  --region eu-west-1

Redis Pub/Sub su larga scala

In un gruppo di replica Redis non in cluster, i messaggi Pub/Sub vengono distribuiti a tutte le repliche: qualsiasi sottoscrittore su qualunque nodo riceve i messaggi pubblicati su un canale. Tuttavia, in Cluster Mode, Pub/Sub è limitato alle notifiche keyspace e Pub/Sub basato sui canali funziona solo all'interno di un singolo shard, a meno di utilizzare Redis 7+ con lo sharding Pub/Sub (SSUBSCRIBE / SPUBLISH per un Pub/Sub consapevole degli shard). Si tratta di una limitazione importante da considerare quando si progetta un sistema Pub/Sub su larga scala con Cluster Mode.

# Keyspace notification (fires when a key expires)
# Enable in parameter group: notify-keyspace-events Ex

# Subscriber in Python:
# pubsub = redis_client.pubsub()
# pubsub.psubscribe('__keyevent@0__:expired')
# for message in pubsub.listen():
#     if message['type'] == 'pmessage':
#         expired_key = message['data']
#         print(f'Key expired: {expired_key}')

Monitoraggio del ritardo di replica

Monitorare la metrica CloudWatch ReplicationLag sulle repliche di lettura per verificare che rimangano sincronizzate con il primario. Un ritardo superiore a pochi secondi indica un collo di bottiglia sulla replica, ad esempio un nodo sovraccarico, problemi di rete o un numero di scritture eccessivo per la capacità di elaborazione della replica. Negli scenari con Global Datastore, monitorare GlobalDatastoreReplicationLag. Un ritardo di replica elevato indica che le repliche di lettura potrebbero restituire dati obsoleti, un aspetto importante per le applicazioni che richiedono una consistenza eventuale entro limiti ristretti.

# Monitor replication lag for all replicas
aws cloudwatch get-metric-statistics \
  --namespace AWS/ElastiCache \
  --metric-name ReplicationLag \
  --dimensions Name=ReplicationGroupId,Value=web-cache \
  --statistic Maximum \
  --period 60 \
  --start-time $(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ) \
  --end-time $(date -u +%Y-%m-%dT%H:%M:%SZ)

# Alert if ReplicationLag > 10 seconds

Scalabilità dei gruppi di replica

È possibile effettuare una scalabilità verticale (modificando il tipo di nodo) oppure una scalabilità orizzontale (aggiungendo o rimuovendo repliche). La modifica del tipo di nodo richiede una chiamata modify-replication-group e, se applicata immediatamente, causa un breve failover: il primario viene sostituito da un nuovo nodo del tipo scelto. L'aggiunta di repliche avviene online, senza downtime. Per passare dalla modalità non in cluster alla modalità cluster, è necessario creare un nuovo gruppo in modalità cluster ed eseguire la migrazione: non è possibile convertire direttamente una modalità nell'altra.

# Scale up node type with maintenance window
aws elasticache modify-replication-group \
  --replication-group-id web-cache \
  --cache-node-type cache.r7g.xlarge \
  --apply-immediately false

# Add a read replica
aws elasticache increase-replica-count \
  --replication-group-id web-cache \
  --new-replica-count 4 \
  --apply-immediately

Verifica rapida

Verifichi la Sua comprensione dei concetti di AWS Solutions Architect (SAA-C03) presentati in questa lezione.

Riepilogo della lezione

In questa lezione ha appreso che i gruppi di replica consentono di scalare le letture tramite le repliche e garantiscono un'elevata disponibilità grazie al failover automatico con endpoint primario e di lettura; Cluster Mode suddivide i dati tra un massimo di 500 gruppi di nodi utilizzando 16.384 hash slot, permettendo di superare orizzontalmente la memoria di un singolo nodo; infine, Global Datastore replica i dati tra le Regioni per garantire letture globali a bassa latenza e il DR tra regioni. Nella prossima lezione esamineremo le strategie di caching: lazy loading e write-through.

Domande Frequenti

La lezione «Gruppi di replica Redis e modalità cluster di ElastiCache» è gratuita?

Sì — il testo completo di «Gruppi di replica Redis e modalità cluster di ElastiCache» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Cloud & IT Cert Prep, passa a CoddyKit PRO. Il corso Cloud & IT Cert Prep include 4 lezioni in totale.

Cosa imparerò in «Gruppi di replica Redis e modalità cluster di ElastiCache»?

Creare un gruppo di replica Redis per scalare le letture e abilitare la modalità cluster per distribuire i dati tra più gruppi di nodi Eserciti Cloud & IT Cert Prep con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Cloud & IT Cert Prep?

Non è richiesta alcuna esperienza precedente. Cloud & IT Cert Prep su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Gruppi di replica Redis e modalità cluster di ElastiCache»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Cloud & IT Cert Prep?

Sì. Ogni lezione Cloud & IT Cert Prep include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Redis e Memcached: scegliere il motore giusto
  2. Gruppi di replica Redis e modalità cluster di ElastiCache
  3. Strategie di caching: lazy loading e write-through
  4. Archiviazione delle sessioni e pattern per le classifiche
← Torna a Cloud & IT Cert Prep