Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Gestione dei cluster in ElastiCache
Un *cluster* è una raccolta di uno o più nodi di cache, che eseguono tutti un'istanza del software del motore Valkey, Memcached e Redis OSS. Quando si crea un cluster, occorre specificare il motore e la versione che verrà utilizzata da tutti i nodi.
**Cluster Valkey e Redis OSS**
Il diagramma seguente illustra un tipico cluster Valkey o Redis OSS. Questi cluster possono contenere un singolo nodo o fino a sei nodi all'interno di uno shard (API/CLI: gruppo di nodi), un cluster Valkey o Redis OSS a nodo singolo (modalità cluster disabilitata) non ha shard e un cluster Valkey o Redis OSS a più nodi (modalità cluster disabilitata) ha un singolo shard. I cluster Valkey o Redis OSS (modalità cluster abilitata) possono avere fino a 500 shard, con i dati partizionati tra gli shard. Il limite di nodi o shard può essere aumentato fino a un massimo di 500 per cluster se la versione del motore è Valkey 7.2 e superiore o Redis OSS 5.0.6 e successiva. Ad esempio, è possibile scegliere di configurare un cluster a 500 nodi che varia tra 83 partizioni (un primario e 5 repliche per partizione) e 500 partizioni (un singolo primario e nessuna replica). Assicurati che esistano abbastanza indirizzi IP disponibili per soddisfare l'aumento. Le problematiche comuni sono che le le sottoreti nel gruppo di sottoreti hanno un intervallo CIDR troppo piccolo o che le sottoreti sono condivise e utilizzate pesantemente da altri cluster. Per ulteriori informazioni, consulta [Creazione di un gruppo di sottoreti](SubnetGroups.Creating.md). Per le versioni inferiori alla 5.0.6, il limite è 250 per cluster.
Per richiedere un aumento dei limiti, consulta [Limiti dei servizi AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) e seleziona il tipo di limite **Nodi per cluster per tipo di istanza**.
Quando sono presenti più nodi in uno shard Valkey o Redis OSS, uno dei nodi è un nodo primario. read/write Tutti gli altri nodi nella partizione sono repliche di sola lettura.
I cluster Valkey o Redis OSS tipici hanno il seguente aspetto.
![\[Immagine: cluster OSS Valkey e Redis tipici\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Redis.png)
**Cluster Memcached**
I cluster Memcached tipici hanno il seguente aspetto. I cluster Memcached contengono da 1 a 60 nodi, sui quali è possibile partizionare orizzontalmente i dati.
![\[Immmagine: tipico cluster Memcached\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
**Operazioni Elasticache per Valkey, Memcached e Redis OSS**
La maggior parte delle ElastiCache operazioni viene eseguita a livello di cluster. Un cluster può essere configurato con un numero specifico di nodi e con un gruppo di parametri che controlla le proprietà di ciascun nodo. Tutti i nodi all'interno di un cluster sono progettati in modo da essere dello stesso tipo e da avere le stesse impostazioni del gruppo di parametri e del gruppo di sicurezza.
Ogni cluster deve avere un proprio identificatore. L'identificatore del cluster è un nome fornito dal cliente. Questo identificatore specifica un particolare cluster quando interagisce con l' ElastiCache API e i comandi. AWS CLI L'identificatore del cluster deve essere univoco per quel cliente in una regione. AWS
ElastiCache supporta più versioni del motore. A meno che non ci siano motivi specifici, consigliamo di utilizzare l'ultima versione.
ElastiCache i cluster sono progettati per essere accessibili tramite un' EC2 istanza Amazon. Se il cluster viene avviato in un virtual private cloud (VPC) basato sul servizio Amazon VPC, vi si può accedere dall'esterno di AWS. Per ulteriori informazioni, consulta [Accesso alle ElastiCache risorse dall'esterno AWS](accessing-elasticache.md#access-from-outside-aws).
Per un elenco delle versioni supportate, consulta [Motori e versioni supportati](VersionManagement.md#supported-engine-versions)[Versioni del motore Redis OSS supportate](engine-versions.md#supported-engine-versions.redis), e[Supportato ElastiCache per le versioni Memcached](engine-versions.md#supported-engine-versions-mc).
# Scelta del tipo di rete in ElastiCache
ElastiCache supporta le versioni 4 e 6 (IPv4 e IPv6) del protocollo Internet, che consente di configurare il cluster in modo che accetti:
+ solo IPv4 connessioni,
+ solo IPv6 connessioni,
+ entrambi IPv4 e IPv6 connessioni (dual-stack)
IPv6 [è supportato per carichi di lavoro che utilizzano Valkey 7.2 e versioni successive, o Redis OSS 6.2 e versioni successive, su tutte le istanze basate sul sistema Nitro.](https://aws.amazon.com/ec2/nitro/) Non sono previsti costi aggiuntivi per l'accesso tramite. ElastiCache IPv6
**Nota**
La migrazione di cluster creati prima della disponibilità di IPV6 /dual-stack non è supportata. Anche il passaggio da un tipo di rete all'altro nei nuovi cluster creati non è supportato.
IPv6 [è supportato per i carichi di lavoro che utilizzano Memcached 1.6.6 e versioni successive su tutte le istanze basate sul sistema Nitro.](https://aws.amazon.com/ec2/nitro/) Non sono previsti costi aggiuntivi per l'accesso tramite. ElastiCache IPv6
## Configurazione di sottoreti per tipo di rete
Se crei un cluster in un Amazon VPC, devi specificare un gruppo di sottoreti. ElastiCache utilizza quel gruppo di sottorete per scegliere una sottorete e gli indirizzi IP all'interno di quella sottorete da associare ai nodi. ElastiCache i cluster richiedono una sottorete dual-stack con entrambi IPv6 gli indirizzi assegnati per funzionare in modalità dual-stack IPv4 e una sottorete -only per funzionare solo come -only. IPv6 IPv6
## Utilizzo di dual-stack
Quando si utilizza ElastiCache Redis OSS in modalità cluster abilitata, dal punto di vista di un'applicazione, la connessione a tutti i nodi del cluster tramite l'endpoint di configurazione non è diversa dalla connessione diretta a un singolo nodo di cache. Per ottenere questo risultato, un client basato su cluster deve essere coinvolto in un processo di individuazione del cluster e richiedere le informazioni di configurazione per tutti i nodi. Il protocollo di individuazione di Redis supporta un solo IP per nodo.
Quando si crea un cluster con ElastiCache for Memcache e si sceglie dual-stack come tipo di rete, è necessario designare un tipo di rilevamento IP, ovvero oppure. IPv4 IPv6 ElastiCache imposterà come impostazione predefinita il tipo di rete e il rilevamento IP, ma ciò può essere modificato. IPv6 Se si utilizza Individuazione automatica, solo gli indirizzi IP del tipo IP scelto vengono restituiti al client Memcached. Per ulteriori informazioni, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md).
Per mantenere la retrocompatibilità con tutti i client esistenti, viene introdotto il rilevamento IP, che consente di selezionare il tipo di IP (ovvero IPv4 o IPv6) da pubblicizzare nel protocollo di rilevamento. Sebbene ciò limiti il rilevamento automatico a un solo tipo di IP, il dual-stack è comunque vantaggioso per i carichi di lavoro abilitati alla modalità cluster, in quanto consente le migrazioni (o il rollback) da un tipo IP Discovery IPv4 a un tipo di IP IPv6 Discovery senza tempi di inattività.
## Cluster dual stack abilitati per TLS ElastiCache
Quando TLS è abilitato per ElastiCache i cluster, le funzioni di rilevamento dei cluster (ad esempio `cluster slots``cluster shards`, e `cluster nodes` con Valkey o Redis OSS e `config get cluster` con Memcached) restituiscono i nomi di host anziché. IPs I nomi host vengono quindi utilizzati anziché per connettersi al cluster ed eseguire un IPs handshake TLS. ElastiCache Ciò significa che i client non saranno interessati dal parametro Individuazione IP. *Per i cluster abilitati per TLS, il parametro Individuazione IP non ha alcun effetto sul protocollo IP preferito.* Invece, il protocollo IP utilizzato verrà determinato in base a quello preferito dal client durante la risoluzione dei nomi host DNS.
Per esempi su come configurare una preferenza protocollo IP durante la risoluzione dei nomi host DNS, consulta [Cluster dual ElastiCache stack abilitati per TLS](BestPractices.md#network-type-configuring-tls-enabled-dual-stack).
## Utilizzo di Console di gestione AWS(Valkey e Redis OSS)
Quando crei un cluster utilizzando Console di gestione AWS, in **Connettività**, scegli un tipo di rete **IPv4**, **IPv6**o **Dual stack**. Se stai creando un cluster Valkey o Redis OSS (modalità cluster abilitata) e scegli il dual stack, devi selezionare un **tipo di IP Discovery**, oppure. IPv6 IPv4
Per ulteriori informazioni, consulta [Creazione di un cluster Valkey o Redis OSS (modalità cluster abilitata) (Console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) o [Creazione di un Valkey o Redis OSS (modalità cluster disabilitata) (Console)](Clusters.Create.md#Clusters.Create.CON.Redis).
**Quando crei un gruppo di replica utilizzando Console di gestione AWS, scegli un tipo di rete o **IPv4**Dual stack. **IPv6**** Se si sceglie il dual stack, è necessario selezionare un **tipo di Discovery IP, oppure**. IPv6 IPv4
Per ulteriori informazioni, consulta [Creazione da zero di un gruppo di replica Valkey o Redis OSS (Cluster Mode Disabled)](Replication.CreatingReplGroup.NoExistingCluster.Classic.md) o [Creazione da zero di un gruppo di replica in Valkey o Redis OSS (modalità cluster abilitata)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md).
## Utilizzo di Console di gestione AWS(Memcached)
Quando crei un cluster utilizzando Console di gestione AWS, in **Connettività**, scegli un tipo di rete **IPv4**, **IPv6**o **Dual stack**. Se si sceglie il dual stack, è necessario selezionare un **tipo di Discovery IP**, oppure IPv6 . IPv4
Per ulteriori informazioni, consulta [Creazione di un cluster Memcached (console)](Clusters.Create-mc.md#Clusters.Create.CON.Memcached).
## Utilizzo della CLI con Valkey, Memcached o Redis OSS.
**Redis OSS**
Quando si crea un cluster con Valkey o Redis OSS utilizzando la CLI, si utilizza il [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)comando e si specificano i parametri and: `NetworkType` `IPDiscovery`
Per Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine redis \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Per Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine redis ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Quando si crea un gruppo di replica con la modalità cluster disabilitata utilizzando la CLI, si utilizza [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)il comando e si specificano `NetworkType` i `IPDiscovery` parametri and:
Per Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01 \
--network-type dual_stack \
--ip-discovery ipv4
```
Per Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Quando si crea un gruppo di replica con la modalità cluster abilitata e utilizzato IPv4 per il rilevamento IP tramite la CLI, si utilizza [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)il comando e si specificano `NetworkType` i `IPDiscovery` parametri and:
Per Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv4 \
--region us-east-1
```
Per Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv4 ^
--region us-east-1
```
Quando si crea un gruppo di replica con la modalità cluster abilitata e utilizzato IPv6 per il rilevamento IP tramite la CLI, si utilizza [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)il comando e si specificano `NetworkType` i `IPDiscovery` parametri and:
Per Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv6 \
--region us-east-1
```
Per Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv6 ^
--region us-east-1
```
**Memcached**
Quando si crea un cluster con Memcached utilizzando la CLI, si utilizza il [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)comando e si specificano i parametri and: `NetworkType` `IPDiscovery`
Per Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine memcached \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Per Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine memcached ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
# Identifica automaticamente i nodi del cluster (Memcached)
Per i cluster che utilizzano il motore Memcached, ElastiCache supporta *Auto Discovery*, la capacità dei programmi client di identificare automaticamente tutti i nodi di un cluster e di avviare e mantenere le connessioni a tutti questi nodi.
**Nota**
L'individuazione automatica viene aggiunta per i cluster in esecuzione su Amazon ElastiCache Memcached. Auto Discovery non è disponibile per i motori Valkey o Redis OSS.
Con Individuazione automatica, non occorre collegare manualmente l'applicazione ai singoli nodi di cache; invece, l'applicazione si collega a un nodo Memcached e recupera l'elenco di nodi. Da tale elenco l'applicazione è in grado di conoscere il resto dei nodi nel cluster e può connettersi a uno qualsiasi di essi. Non è necessario codificare gli endpoint dei singoli nodi di cache nell'applicazione.
Se si utilizza un tipo di rete dual stack sul cluster, Auto Discovery restituirà solo IPv6 gli indirizzi IPv4 o, a seconda di quello selezionato. Per ulteriori informazioni, consulta [Scelta del tipo di rete in ElastiCache](network-type.md).
Tutti i nodi di cache nel cluster mantengono un elenco di metadati relativi a tutti gli altri nodi. Questi metadati vengono aggiornati ogni volta che si aggiungono o rimuovono nodi dal cluster.
**Topics**
+ [Vantaggi dell'individuazione automatica con Memcached](AutoDiscovery.Benefits.md)
+ [Funzionamento di Individuazione automatica](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [Uso di Individuazione automatica](AutoDiscovery.Using.md)
+ [Connessione manuale ai nodi Memcached Cache](AutoDiscovery.Manual.md)
+ [Aggiungere Auto Discovery alla libreria client Memcached](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache clienti con rilevamento automatico](Clients.md)
# Vantaggi dell'individuazione automatica con Memcached
Quando si utilizza Memcached, Auto Discovery offre i seguenti vantaggi:
+ Quando si aumenta il numero di nodi in un cluster, i nuovi nodi si registrano con l'endpoint di configurazione e con tutti gli altri nodi. Quando si rimuovono nodi dal cluster di cache, i nodi che vengono a mancare annullano automaticamente la loro registrazione. In entrambi i casi, tutti gli altri nodi nel cluster vengono aggiornati con i metadati di nodi di cache più recenti.
+ Guasti nei nodi di cache vengono rilevati automaticamente; nodi non riusciti vengono sostituiti automaticamente.
**Nota**
Finché la sostituzione del nodo non viene completata, il nodo continuerà a restituire un errore.
+ Un programma client deve solo connettersi all'endpoint di configurazione. Successivamente, la libreria di Individuazione automatica si collega a tutti gli altri nodi nel cluster.
+ I programmi client eseguono il polling del cluster una volta il minuto (questo intervallo può essere modificato se necessario). In caso di modifiche alla configurazione del cluster, ad esempio nodi nuovi o eliminati, il client riceve un elenco aggiornato di metadati. Quindi il client si collega a, o si scollega da, questi nodi in base alle esigenze.
Auto Discovery è abilitato su tutti i cluster ElastiCache Memcached. Per utilizzare questa caratteristica non è necessario riavviare i nodi di cache.
# Funzionamento di Individuazione automatica
**Topics**
+ [Connessione ai nodi di cache](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [Operazioni cluster normali](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [Altre operazioni](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
Questa sezione descrive come le applicazioni client utilizzano il ElastiCache Cluster Client per gestire le connessioni dei nodi di cache e interagire con gli elementi di dati nella cache.
## Connessione ai nodi di cache
Dal punto di vista dell'applicazione, la connessione all'endpoint di configurazione del cluster non è diverso dalla connessione diretta a un singolo nodo di cache. Il diagramma di sequenza seguente mostra il processo di connessione ai nodi di cache.
![\[Connessione ai nodi di cache\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**Processo di connessione ai nodi di cache**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/1.png) | L'applicazione risolve il nome DNS dell'endpoint di configurazione. Poiché l'endpoint di configurazione mantiene le voci CNAME per tutti i nodi di cache, il nome DNS viene risolto in uno dei nodi; il client può quindi connettersi a tale nodo. |
| ![\[2\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/2.png) | Il client richiede le informazioni di configurazione per tutti gli altri nodi. Poiché ogni nodo mantiene informazioni di configurazione per tutti i nodi nel cluster, qualsiasi nodo può passare informazioni di configurazione al client su richiesta. |
| ![\[3\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/3.png) | Il client riceve l'elenco corrente di nomi host e indirizzi IP dei nodi di cache. Può quindi connettersi a tutti gli altri nodi nel cluster. |
**Nota**
Il programma client aggiorna il suo elenco di nomi host e indirizzi IP dei nodi di cache una volta il minuto. Questo intervallo di polling può essere modificato se necessario.
## Operazioni cluster normali
Quando l'applicazione è connessa a tutti i nodi di cache, ElastiCache Cluster Client determina quali nodi devono archiviare i singoli elementi di dati e quali nodi devono essere interrogati per tali elementi di dati in un secondo momento. Il diagramma di sequenza seguente mostra il processo di operazioni cluster normali.
![\[Operazioni cluster normali\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**Processo di operazioni cluster normali**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/1.png) | L'applicazione emette una richiesta get per un particolare item di dati, identificato dalla sua chiave. |
| ![\[2\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/2.png) | Il client utilizza un algoritmo di hashing rispetto alla chiave per determinare quale nodo di cache contiene l'item di dati. |
| ![\[3\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/3.png) | L'item di dati viene richiesto dal nodo appropriato. |
| ![\[4\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/4.png) | L'item di dati viene restituito all'applicazione. |
## Altre operazioni
In alcune situazioni, è possibile effettuare una modifica ai nodi di un cluster. Ad esempio, è possibile aggiungere un nodo aggiuntivo per soddisfare una domanda aggiuntiva oppure eliminare un nodo per risparmiare denaro durante i periodi di domanda ridotta. Oppure potresti sostituire un nodo a causa di un errore di un nodo di un tipo o di un altro.
In presenza di una modifica nel cluster che richiede un aggiornamento dei metadati negli endpoint del cluster, tale modifica viene apportata a tutti i nodi contemporaneamente. Pertanto, i metadati in qualsiasi nodo specificato sono coerenti con i metadati in tutti gli altri nodi nel cluster.
In ciascuno di questi casi, i metadati sono coerenti tra tutti i nodi in qualsiasi momento poiché i metadati vengono aggiornati contemporaneamente per tutti i nodi nel cluster. Si consiglia di utilizzare sempre l'endpoint di configurazione per ottenere gli endpoint dei diversi nodi nel cluster. L'uso dell'endpoint di configurazione evita che vengano ricevuti dati dell'endpoint da un nodo che "scompare".
### Aggiunta di un nodo
Durante il periodo di attivazione del nodo, il suo endpoint non è incluso nei metadati. Non appena il nodo diventa disponibile, viene aggiunto ai metadati di ciascuno dei nodi del cluster. In questo scenario, i metadati sono coerenti tra tutti i nodi e sarai in grado di interagire con il nuovo nodo solo dopo che questo diventa disponibile. Il nodo non è noto prima che diventi disponibile e l'interazione con i nodi nel cluster avviene come se il nuovo nodo non esistesse.
### Eliminazione di un nodo
Quando un nodo viene rimosso, il relativo endpoint viene rimosso innanzitutto dai metadati e quindi il nodo viene rimosso dal cluster. In questo scenario, i metadati in tutti i nodi sono coerenti e in nessun momento conterranno l'endpoint per il nodo che deve essere rimosso mentre il nodo non è disponibile. Durante la rimozione del nodo il tempo non è segnalato nei metadati e pertanto l'applicazione interagisce solo con gli n-1 nodi rimanenti, come se il nodo non esistesse.
### Sostituzione di un nodo
Se un nodo ElastiCache si guasta, lo rimuove e ne avvia uno sostitutivo. Il processo di sostituzione richiede alcuni minuti. Durante questo periodo di tempo i metadati in tutti i nodi mostrano ancora l'endpoint per il nodo non riuscito, ma qualsiasi tentativo di interagire con il nodo restituisce un errore. Pertanto, la logica deve sempre includere la logica di ripetizione.
# Uso di Individuazione automatica
Per iniziare a utilizzare Auto Discovery with ElastiCache for Memcached, segui questi passaggi:
+ [Ottenete l'endpoint di configurazione](#AutoDiscovery.Using.ConfigEndpoint)
+ [Scarica il ElastiCache Cluster Client](#AutoDiscovery.Using.ClusterClient)
+ [Modifica il tuo programma applicativo](#AutoDiscovery.Using.ModifyApp)
## Ottenete l'endpoint di configurazione
Per connettersi a un cluster, i programmi client devono conoscere l'endpoint di configurazione del cluster. Consulta l'argomento [Individuazione degli endpoint di un cluster (console) (Memcached)](Endpoints.md#Endpoints.Find.Memcached)
Puoi anche utilizzare il comando `aws elasticache describe-cache-clusters` con il parametro `--show-cache-node-info`:
Qualunque sia il metodo utilizzato per trovare gli endpoint del cluster, l'indirizzo dell'endpoint di configurazione conterrà sempre **.cfg**.
**Example Ricerca degli endpoint utilizzando il comando for AWS CLI ElastiCache**
Per Linux, macOS o Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Per Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
Questa operazione genera un output simile al seguente (formato JSON):
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0001.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1e"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0002.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1a"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "Multiple",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-10-12T21:39:28.001Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "sat:06:00-sat:07:00",
"CacheNodeType": "cache.r3.large"
}
]
}
```
## Scarica il ElastiCache Cluster Client
Per sfruttare Individuazione automatica, i programmi client devono utilizzare il *Client del cluster ElastiCache*. Il ElastiCache Cluster Client è disponibile per Java, PHP e.NET e contiene tutta la logica necessaria per scoprire e connettersi a tutti i nodi della cache.
**Per scaricare il ElastiCache Cluster Client**
1. Accedi alla console di AWS gestione e apri la ElastiCache console all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dalla ElastiCache console, scegli **ElastiCache Cluster Client**, quindi scegli **Scarica**.
Il codice sorgente per ElastiCache Cluster Client for Java è disponibile all'indirizzo [https://github.com/amazonwebservices/aws-elasticache-cluster-client- memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Questa libreria è basata sul client Spymemcached di uso comune. Il ElastiCache Cluster Client è rilasciato con la licenza Amazon Software [https://aws.amazon.com/asl](https://aws.amazon.com/asl). Sei libero di modificare il codice fonte come meglio credi. Puoi persino incorporare il codice in altre librerie Memcached open source o nel tuo codice client.
**Nota**
Per utilizzare ElastiCache Cluster Client for PHP, devi prima installarlo sulla tua EC2 istanza Amazon. Per ulteriori informazioni, consulta [Installazione del client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoverySetup.md).
Per un client con supporto TLS, scarica il file binario con PHP versione 7.4 o superiore.
Per utilizzare il ElastiCache Cluster Client for .NET, devi prima installarlo sulla tua EC2 istanza Amazon. Per ulteriori informazioni, consulta [Installazione del client ElastiCache cluster per.NET](Appendix.DotNETAutoDiscoverySetup.md).
## Modifica il tuo programma applicativo
Modifica il programma dell'applicazione in modo che utilizzi Individuazione automatica. Le seguenti sezioni mostrano come utilizzare il ElastiCache Cluster Client per Java, PHP e.NET.
**Importante**
Durante la specifica dell'endpoint di configurazione del cluster, assicurati che l'indirizzo dell'endpoint contenga ".cfg" come mostrato qui. Non utilizzare un CNAME o un endpoint che non contiene ".cfg" al suo interno.
```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
La mancata specifica esplicita dell'endpoint di configurazione del cluster determina la configurazione di un nodo specifico.
# Utilizzo del ElastiCache Cluster Client per Java
Il programma seguente mostra come utilizzare il ElastiCache Cluster Client per connettersi a un endpoint di configurazione del cluster e aggiungere un elemento di dati alla cache. Utilizzando Individuazione automatica, il programma si connette a tutti i nodi nel cluster senza ulteriori interventi.
```
package com.amazon.elasticache;
import java.io.IOException;
import java.net.InetSocketAddress;
// Import the &AWS;-provided library with Auto Discovery support
import net.spy.memcached.MemcachedClient;
public class AutoDiscoveryDemo {
public static void main(String[] args) throws IOException {
String configEndpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
Integer clusterPort = 11211;
MemcachedClient client = new MemcachedClient(
new InetSocketAddress(configEndpoint,
clusterPort));
// The client will connect to the other cache nodes automatically.
// Store a data item for an hour.
// The client will decide which cache host will store this item.
client.set("theKey", 3600, "This is the data value");
}
}
```
# Utilizzo del ElastiCache Cluster Client per PHP
Il programma seguente mostra come utilizzare il ElastiCache Cluster Client per connettersi a un endpoint di configurazione del cluster e aggiungere un elemento di dati alla cache. Utilizzando Individuazione automatica, il programma si connette a tutti i nodi in un cluster senza ulteriori interventi.
Per utilizzare ElastiCache Cluster Client for PHP, devi prima installarlo sulla tua EC2 istanza Amazon. Per ulteriori informazioni, consulta [Installazione del client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoverySetup.md)
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
$dynamic_client->addServer($server_endpoint, $server_port);
/**
* Store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
$dynamic_client->set('key', 'value', 60);
/**
* Configuring the client with Static client mode disables the usage of Auto Discovery
* and the client operates as it did before the introduction of Auto Discovery.
* The user can then add a list of server endpoints.
*/
$static_client = new Memcached('persistent-id');
$static_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::STATIC_CLIENT_MODE);
$static_client->addServer($server_endpoint, $server_port);
/**
* Store the data without expiration.
* The client will decide which cache host will store this item.
*/
$static_client->set('key', 'value');
?>
```
Per un esempio su come utilizzare il ElastiCache Cluster Client con TLS abilitato, consulta [Utilizzo della crittografia in transito con PHP](in-transit-encryption.md#in-transit-encryption-connect-php-mc) e Memcached.
# Utilizzo del ElastiCache Cluster Client per.NET
**Nota**
Il client del cluster ElastiCache .NET è obsoleto a maggio 2022.
Il client.NET per ElastiCache è open source all'indirizzo. [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net)
Le applicazioni .NET in genere recuperano le loro configurazioni dal file config. Di seguito viene riportato un file config dell'applicazione di esempio.
```
```
Il programma C\$1 riportato di seguito mostra come utilizzare il ElastiCache Cluster Client per connettersi a un endpoint di configurazione del cluster e aggiungere un elemento di dati alla cache. Utilizzando Individuazione automatica, il programma si connette a tutti i nodi in un cluster senza ulteriori interventi.
```
// *****************
// Sample C# code to show how to integrate with the Amazon ElastiCcache Auto Discovery feature.
using System;
using Amazon.ElastiCacheCluster;
using Enyim.Caching;
using Enyim.Caching.Memcached;
public class DotNetAutoDiscoveryDemo {
public static void Main(String[] args) {
// instantiate a new client.
ElastiCacheClusterConfig config = new ElastiCacheClusterConfig();
MemcachedClient memClient = new MemcachedClient(config);
// Store the data for 3600 seconds (1hour) in the cluster.
// The client will decide which cache host will store this item.
memClient.Store(StoreMode.Set, 3600, "This is the data value.");
} // end Main
} // end class DotNetAutoDiscoverDemo
```
# Connessione manuale ai nodi Memcached Cache
Se il programma client non utilizza Auto Discovery, può connettersi manualmente a ciascuno dei nodi di cache Memcached. Questo è il comportamento di default per i client Memcached.
Puoi ottenere un elenco di nomi host e numeri porta dei nodi di cache dalla [AWS Console di gestione](https://aws.amazon.com/console/). È inoltre possibile utilizzare il AWS CLI`aws elasticache describe-cache-clusters` comando con il `--show-cache-node-info` parametro.
**Example**
Il seguente frammento di codice Java mostra come connettersi a tutti i nodi di un cluster a quattro nodi:
```
...
ArrayList cacheNodes = new ArrayList(
Arrays.asList(
"mycachecluster.fnjyzo.0001.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0002.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0003.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0004.use1.cache.amazonaws.com:11211"));
MemcachedClient cache = new MemcachedClient(AddrUtil.getAddresses(cacheNodes));
...
```
**Importante**
Se si aumenta o si riduce il cluster aggiungendo o rimuovendo nodi, sarà necessario aggiornare l'elenco dei nodi nel codice client.
# Aggiungere Auto Discovery alla libreria client Memcached
Le informazioni di configurazione per Auto Discovery sono archiviate in modo ridondante in ogni nodo del cluster Memcached. Le applicazioni client possono eseguire la query di qualsiasi nodo di cache e ottenere le informazioni di configurazione per tutti i nodi nel cluster.
Il modo utilizzato dall'applicazione dipende dalla versione del motore della cache:
+ Se la versione del motore della cache è **1.4.14 o successive**, utilizza il comando `config`.
+ Se la versione del motore della cache è **precedente alla 1.4.14**, utilizza il comando `get AmazonElastiCache:cluster`.
I risultati di questi due comandi sono identici e vengono descritti nella sezione [Formato di output](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) sottostante.
## Motore di cache versione 1.4.14 o successiva
Per versioni del motore della cache 1.4.14 o successive, utilizza il comando `config`. Questo comando è stato aggiunto ai protocolli Memcached ASCII e binari da ElastiCache, ed è implementato nel Cluster Client. ElastiCache Se desideri utilizzare Individuazione automatica con un'altra libreria client, allora sarà necessario espandere tale libreria per supportare il comando `config`.
**Nota**
La documentazione seguente è relativa al protocollo ASCII; tuttavia, il comando `config` supporta ASCII e binario. Se desideri aggiungere il supporto Auto Discovery utilizzando il protocollo binario, fai riferimento al [codice sorgente del Cluster Client](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary). ElastiCache
**Sintassi**
`config [sub-command] [key]`
### Opzioni
| Nome | Description | Richiesto |
| --- | --- | --- |
| sub-command | Il sottocomando utilizzando per interagire con un nodo di cache. Per Individuazione automatica, questo sottocomando è `get`. | Sì |
| key | La chiave sotto cui viene archiviata la configurazione cluster. Per Individuazione automatica, questa chiave è denominata `cluster`. | Sì |
Per ottenere le informazioni di configurazione del cluster, utilizza il seguente comando:
```
config get cluster
```
## Motore di cache versione 1.4.14 o precedente
Per ottenere le informazioni di configurazione del cluster, utilizza il seguente comando:
```
get AmazonElastiCache:cluster
```
**Nota**
Non manomettere la chiave «:clusterAmazonElastiCache», poiché è qui che risiedono le informazioni di configurazione del cluster. Se si sovrascrive questa chiave, è possibile che il client venga configurato in modo errato per un breve periodo di tempo (non più di 15 secondi) prima di aggiornare ElastiCache automaticamente e correttamente le informazioni di configurazione.
## Formato di output
A prescindere che utilizzi `config get cluster` o `get AmazonElastiCache:cluster`, la risposta è costituita sempre da due righe:
+ Il numero di versione delle informazioni di configurazione. Ogni volta che un nodo viene aggiunto o rimosso dal cluster, il numero di versione aumenta di uno.
+ Un elenco di nodi di cache. Ogni nodo nell'elenco è rappresentato da un gruppo *hostname\$1ip-address\$1port* e ogni nodo è delimitato da uno spazio.
Alla fine di ciascuna riga vengono visualizzati un carattere di ritorno a capo e un carattere di avanzamento riga (CR \$1 LF). La riga di dati contiene un carattere di avanzamento riga (LF) alla fine, cui viene aggiunto CR \$1 LF. La riga di versione config è terminata da LF senza CR.
Un cluster contenente tre nodi sarebbe rappresentato come segue:
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
Ogni nodo viene mostrato con il CNAME e l'indirizzo IP privato. Il CNAME è sempre presente; se l'indirizzo IP privato non è disponibile, non verrà visualizzato; tuttavia, i caratteri pipe "`|`" verranno ancora stampati.
**Example**
Di seguito è riportato un esempio del payload restituito quando si esegue la query delle informazioni di configurazione:
```
CONFIG cluster 0 136\r\n
12\n
myCluster.pc4ldq.0001.use1.cache.amazonaws.com|10.82.235.120|11211 myCluster.pc4ldq.0002.use1.cache.amazonaws.com|10.80.249.27|11211\n\r\n
END\r\n
```
**Nota**
La seconda riga indica che le informazioni di configurazione sono state modificate dodici volte finora.
Nella terza riga, l'elenco dei nodi è in ordine alfabetico per nome host. Questo ordinamento deve essere in una sequenza diversa da quella attualmente in uso nell'applicazione client.
# ElastiCache clienti con rilevamento automatico
I programmi client del cluster possono identificare e connettersi automaticamente a tutti i nodi del cluster che eseguono il motore Memcached.
Questa sezione descrive l'installazione e la configurazione dei client ElastiCache PHP e.NET da utilizzare con l'individuazione automatica.
**Topics**
+ [Installazione e compilazione di client del cluster](Appendix.InstallingClients.md)
+ [Configurazione dei client ElastiCache](ClientConfig.md)
# Installazione e compilazione di client del cluster
Questa sezione tratta l'installazione, la configurazione e la compilazione dei client PHP e.NET Amazon ElastiCache auto discovery cluster.
**Topics**
+ [Installazione del client ElastiCache cluster per.NET](Appendix.DotNETAutoDiscoverySetup.md)
+ [Installazione del client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoverySetup.md)
+ [Compilazione del codice sorgente per il client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoveryCompile.md)
# Installazione del client ElastiCache cluster per.NET
È possibile trovare il codice open source di ElastiCache .NET Cluster Client all'indirizzo [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Questa sezione descrive come installare, aggiornare e rimuovere i componenti.NET per il ElastiCache Cluster Client sulle EC2 istanze Amazon. Per ulteriori informazioni sull'individuazione automatica, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md). Per il codice .NET di esempio per utilizzare il client, consulta [Utilizzo del ElastiCache Cluster Client per.NET](AutoDiscovery.Using.ModifyApp.DotNET.md).
**Topics**
+ [Installazione di .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [Scarica il client cluster ElastiCache .NET per ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [Installa AWS gli assiemi con NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing)
## Installazione di .NET
È necessario che sia installato .NET 3.5 o versione successiva per utilizzare AWS .NET SDK per. ElastiCache In caso contrario, puoi scaricare e installare la versione più recente da [http://www.microsoft.com/net](http://www.microsoft.com/net).
## Scarica il client cluster ElastiCache .NET per ElastiCache
**Per scaricare il client del cluster ElastiCache .NET**
1. Accedere a Console di gestione AWS e aprire la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione, fai clic su **ElastiCache Cluster Client**.
1. **Nell'elenco **Scarica ElastiCache Memcached Cluster Client**, **seleziona.NET**, quindi fai clic su Scarica.**
## Installa AWS gli assiemi con NuGet
NuGet è un sistema di gestione dei pacchetti per la piattaforma .NET. NuGet è consapevole delle dipendenze dell'assieme e installa automaticamente tutti i file richiesti. NuGet gli assembly installati vengono archiviati con la soluzione, anziché in una posizione centrale, ad esempio`Program Files`, in modo da poter installare versioni specifiche di un'applicazione senza creare problemi di compatibilità.
### Installazione NuGet
NuGet può essere installato dalla Galleria di installazione su MSDN; vedere [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c). Se si utilizza Visual Studio NuGet 2010 o versione successiva, viene installato automaticamente.
È possibile utilizzare NuGet da **Solution Explorer** o dalla **console di Package Manager**.
### Utilizzo NuGet da Solution Explorer
**NuGet Da utilizzare da Solution Explorer in Visual Studio 2010**
1. Dal menu **Strumenti**, scegli **Gestione pacchetti libreria**.
1. Fai clic su **Console di Gestione pacchetti**.
**NuGet Da utilizzare da Solution Explorer in Visual Studio 2012 o Visual Studio 2013**
1. Dal menu **Strumenti**, selezionare **NuGet Package Manager**.
1. Fai clic su **Console di Gestione pacchetti**.
Dalla riga di comando, è possibile installare gli assembly utilizzando `Install-Package`, come mostrato di seguito.
```
Install-Package Amazon.ElastiCacheCluster
```
[Per visualizzare una pagina per ogni pacchetto disponibile tramite NuGet, ad esempio gli assembly AWS SDK AWS e.Extensions, visitate il sito Web all' NuGet indirizzo http://www.nuget.org.](http://www.nuget.org) La pagina di ogni pacchetto include una riga di comando di esempio per l'installazione del pacchetto tramite la console e un elenco delle versioni precedenti del pacchetto disponibili tramite. NuGet
Per ulteriori informazioni sui comandi di **Package Manager Console (Console di Gestione pacchetti)**, consulta [http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29](http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29).
# Installazione del client ElastiCache cluster per PHP
Questa sezione descrive come installare, aggiornare e rimuovere i componenti PHP per il ElastiCache Cluster Client sulle EC2 istanze Amazon. Per ulteriori informazioni sull'individuazione automatica, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md). Per il codice PHP di esempio per utilizzare il client, consulta [Utilizzo del ElastiCache Cluster Client per PHP](AutoDiscovery.Using.ModifyApp.PHP.md).
**Topics**
+ [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [Per utenti con già installata l'estensione *php-memcached*](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [Fasi di installazione per nuovi utenti](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [Rimozione del client del cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md)
# Download del pacchetto di installazione
Per assicurarti di utilizzare la versione corretta di ElastiCache Cluster Client for PHP, devi sapere quale versione di PHP è installata sulla tua istanza Amazon EC2 . Dovrai anche sapere se la tua EC2 istanza Amazon esegue una versione di Linux a 64 o 32 bit.
**Per determinare la versione di PHP installata sulla tua istanza Amazon EC2**
+ Dal prompt dei comandi, eseguire il seguente comando:
```
php -v
```
La versione PHP verrà visualizzata nell'output, come nel seguente esempio:
```
PHP 5.4.10 (cli) (built: Jan 11 2013 14:48:57)
Copyright (c) 1997-2012 The PHP Group
Zend Engine v2.4.0, Copyright (c) 1998-2012 Zend Technologies
```
**Nota**
Se le versioni PHP e Memcached non sono compatibili, verrà restituito un messaggio di errore simile al seguente:
```
PHP Warning: PHP Startup: memcached: Unable to initialize module
Module compiled with module API=20100525
PHP compiled with module API=20131226
These options need to match
in Unknown on line 0
```
In tal caso, occorre compilare il modulo dal codice fonte. Per ulteriori informazioni, consulta [Compilazione del codice sorgente per il client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoveryCompile.md).
**Per determinare la tua architettura Amazon EC2 AMI (64 bit o 32 bit)**
1. Accedi a Console di gestione AWS e apri la EC2 console Amazon all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nell'elenco **Istanze**, fai clic sulla tua EC2 istanza Amazon.
1. Nella scheda **Description (Descrizione)**, cercare il campo **AMI:**. Un'istanza a 64 bit deve includere `x86_64` come parte della descrizione; per un'istanza a 32 bit, cercare `i386` o `i686` in questo campo.
Ora sei pronto per scaricare il ElastiCache Cluster Client.
**Per scaricare il client ElastiCache cluster per PHP**
1. Accedi a Console di gestione AWS e apri la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dalla ElastiCache console, scegli **ElastiCache Cluster Client**.
1. **Dall'elenco **Scarica ElastiCache Memcached Cluster Client**, scegli il ElastiCache Cluster Client che corrisponde alla tua versione PHP e all'architettura AMI, quindi scegli il pulsante Download.**
## Per utenti con già installata l'estensione *php-memcached*
**Per aggiornare l'installazione `php-memcached`**
1. Rimuovere l'installazione precedente dell'estensione Memcached per PHP come descritto dall'argomento [Rimozione del client del cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md).
1. Installa la nuova ElastiCache `php-memcached` estensione come descritto in precedenza in. [Fasi di installazione per nuovi utenti](Appendix.PHPAutoDiscoverySetup.Installing.md)
# Fasi di installazione per nuovi utenti
**Topics**
+ [Installazione di PHP 7.x per nuovi utenti](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [Installazione di PHP 5.x per nuovi utenti](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## Installazione di PHP 7.x per nuovi utenti
**Topics**
+ [Per installare PHP 7 su un server Ubuntu 14.04 AMI LTS (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [Per installare PHP 7 su un'AMI Amazon Linux 201609](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [Per installare PHP 7 su un'AMI SUSE Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### Per installare PHP 7 su un server Ubuntu 14.04 AMI LTS (64 bit e 32 bit)
1. Avviare una nuova istanza dall'AMI.
1. Esegui i comandi seguenti:
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. Installare PHP 7.
```
sudo yum install php70
```
1. Scarica Amazon ElastiCache Cluster Client.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Estrarre `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Con autorizzazioni root, copiare il file dell'artefatto estratto `amazon-elasticache-cluster-client.so` in `/usr/lib/php/20151012`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. Inserire la riga `extension=amazon-elasticache-cluster-client.so` nel file `/etc/php/7.0/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php/7.0/cli/php.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
### Per installare PHP 7 su un'AMI Amazon Linux 201609
1. Avviare una nuova istanza dall'AMI.
1. Esegui il comando seguente:
```
sudo yum install gcc-c++
```
1. Installare PHP 7.
```
sudo yum install php70
```
1. Scarica Amazon ElastiCache Cluster Client.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Estrarre `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Con autorizzazione root, copiare il file dell'artefatto estratto `amazon-elasticache-cluster-client.so` in `/usr/lib64/php/7.0/modules/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. Crea il file `50-memcached.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
### Per installare PHP 7 su un'AMI SUSE Linux
1. Avviare una nuova istanza dall'AMI.
1. Esegui il comando seguente:
```
sudo zypper install gcc
```
1. Installare PHP 7.
```
sudo yum install php70
```
1. Scarica Amazon ElastiCache Cluster Client.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Estrarre `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Con autorizzazione root, copiare il file dell'artefatto estratto `amazon-elasticache-cluster-client.so` in `/usr/lib64/php7/extensions/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. Inserire la riga `extension=amazon-elasticache-cluster-client.so` nel file `/etc/php7/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
## Installazione di PHP 5.x per nuovi utenti
**Topics**
+ [Per installare PHP 5 su un'AMI Amazon Linux 2014.03 (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [Per installare PHP 5 su un'AMI Red Hat Enterprise Linux 7.0 (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [Per installare PHP 5 su un'AMI Ubuntu Server 14.04 LTS (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [Per installare PHP 5 per l'AMI SUSE Linux Enterprise Server 11 (64 bit o 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [Altre distribuzioni Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### Per installare PHP 5 su un'AMI Amazon Linux 2014.03 (64 bit e 32 bit)
1. Avviare un'istanza Amazon Linux (a 64 bit o 32 bit) ed eseguire l'accesso.
1. Installare le dipendenze PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione:
```
sudo pecl install
```
Di seguito è riportato un comando di installazione di esempio per PHP 5.4, Linux a 64 bit. In questo esempio, sostituisci *X.Y.Z* con il numero di versione effettivo:
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**Nota**
Assicurati di utilizzare la versione più recente dell'artefatto di installazione.
1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php.d` directory e inserisci «extension= amazon-elasticache-cluster-client .so» nel file:
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
### Per installare PHP 5 su un'AMI Red Hat Enterprise Linux 7.0 (64 bit e 32 bit)
1. Avviare un'istanza Red Hat Enterprise Linux (64 bit o 32 bit) ed eseguire l'accesso.
1. Installare le dipendenze PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione:
```
sudo pecl install
```
1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php.d` directory e inseriscilo `extension=amazon-elasticache-cluster-client.so` nel file.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
### Per installare PHP 5 su un'AMI Ubuntu Server 14.04 LTS (64 bit e 32 bit)
1. Avviare un'istanza Ubuntu Linux (a 64 bit o 32 bit) ed eseguire l'accesso.
1. Installare le dipendenze PHP:
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione.
```
sudo pecl install
```
**Nota**
Questa fase di installazione consente di installare l'artefatto di compilazione `amazon-elasticache-cluster-client.so` nella directory `/usr/lib/php5/20121212*`. Verifica il percorso assoluto dell'artefatto di compilazione perché è richiesto nella fase successiva.
Se il comando precedente non funziona, occorre estrarre manualmente l'artefatto client PHP `amazon-elasticache-cluster-client.so` dal file `*.tgz` scaricato e copiarlo nella directory `/usr/lib/php5/20121212*`.
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php5/cli/conf.d` directory e inserisci «extension=» nel file.
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
### Per installare PHP 5 per l'AMI SUSE Linux Enterprise Server 11 (64 bit o 32 bit)
1. Avviare un'istanza SUSE Linux (64 bit o 32 bit) ed eseguire l'accesso.
1. Installare le dipendenze PHP:
```
sudo zypper install gcc php53-devel
```
1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione.
```
sudo pecl install
```
1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php5/conf.d` directory e inseriscilo **extension=`amazon-elasticache-cluster-client.so`** nel file.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
**Nota**
Se la Fase 5 non funziona per una delle piattaforme precedenti, verifica il percorso di installazione di `amazon-elasticache-cluster-client.so`. Specifica inoltre il percorso completo del file binario nell'estensione. Inoltre, verifica che la versione del PHP in uso sia supportata. Sono supportate le versioni da 5.3 a 5.5.
### Altre distribuzioni Linux
Su alcuni sistemi, in particolare Cent OS7 e Red Hat Enterprise Linux (RHEL) 7.1, `libsasl2.so.3` è stata sostituita. `libsasl2.so.2` Su questi sistemi, quando si carica il client del ElastiCache cluster, questo tenta e fallisce di trovare e caricare. `libsasl2.so.2` Per risolvere questo problema, crea un collegamento simbolico a `libsasl2.so.3` in modo che quando il client tenta di caricare libsasl2.so.2, viene reindirizzato a `libsasl2.so.3`. Il codice seguente crea questo collegamento simbolico:
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# Rimozione del client del cluster PHP
**Topics**
+ [Rimozione di una versione precedente di PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [Rimozione di una versione precedente di PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## Rimozione di una versione precedente di PHP 7
**Per rimuovere una versione precedente di PHP 7**
1. Rimuovi il file `amazon-elasticache-cluster-client.so` dalla directory lib PHP appropriata, come indicato in precedenza nelle istruzioni di installazione. Per informazioni sull'installazione consulta la sezione in [Per utenti con già installata l'estensione *php-memcached*](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting).
1. Rimuovi la riga `extension=amazon-elasticache-cluster-client.so` dal file `php.ini`.
1. Avviare o riavviare il server Apache.
```
sudo /etc/init.d/httpd start
```
## Rimozione di una versione precedente di PHP 5
**Per rimuovere una versione precedente di PHP 5**
1. Rimuovi l'estensione `php-memcached`:
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. Rimuovi il file `memcached.ini` aggiunto nella directory appropriata come indicato nelle fasi di installazione precedenti.
# Compilazione del codice sorgente per il client ElastiCache cluster per PHP
Questa sezione spiega come ottenere e compilare il codice sorgente per il ElastiCache Cluster Client for PHP.
[Ci sono due pacchetti da cui estrarre GitHub e compilare; [aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) e -. aws-elasticache-cluster-client memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php)
**Topics**
+ [Compilazione della libreria libmemcached](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [Compilazione del client di auto discovery ElastiCache Memcached per PHP](#Appendix.PHPAutoDiscoveryCompile.Client)
## Compilazione della libreria libmemcached
**Per compilare la libreria -libmemcached aws-elasticache-cluster-client**
1. Avvia un' EC2 istanza Amazon.
1. Installare le dipendenze di libreria.
+ In Amazon Linux 201509 AMI
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ In Ubuntu 14.04 AMI
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. Estrarre il repository e compilare il codice.
```
Download and install [ https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz]( https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz)
```
## Compilazione del client di auto discovery ElastiCache Memcached per PHP
Le seguenti sezioni descrivono come compilare il Memcached Auto Discovery Client ElastiCache
**Topics**
+ [Compilazione del client ElastiCache Memcached per PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [Compilazione del client Memcached per ElastiCache PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5)
### Compilazione del client ElastiCache Memcached per PHP 7
Esegui il set di comandi seguente nella directory del codice.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
git checkout php7
sudo yum install php70-devel
phpize
./configure --with-libmemcached-dir= --disable-memcached-sasl
make
make install
```
**Nota**
Puoi collegare staticamente la libreria libmemcached nel file binario PHP per consentirne la portabilità tra diverse piattaforme Linux. A questo scopo, esegui il comando seguente prima di `make`:
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### Compilazione del client Memcached per ElastiCache PHP 5
Compila `aws-elasticache-cluster-client-memcached-for-php` eseguendo i comandi seguenti nella cartella `aws-elasticache-cluster-client-memcached-for-php/`.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
sudo yum install zlib-devel
phpize
./configure --with-libmemcached-dir=
make
make install
```
# Configurazione dei client ElastiCache
Un ElastiCache cluster è conforme al protocollo con Valkey, Memcached e Redis OSS. Il codice, le applicazioni e gli strumenti più diffusi che utilizzate oggi con l'ambiente esistente funzioneranno perfettamente con il servizio.
In questa sezione vengono trattate considerazioni specifiche per la connessione ai nodi di cache in ElastiCache.
**Topics**
+ [Comandi limitati](ClientConfig.RestrictedCommands.md)
+ [Individuazione di endpoint e numeri di porta dei nodi](ClientConfig.FindingEndpointsAndPorts.md)
+ [Connessione per l'utilizzo di Individuazione automatica](ClientConfig.AutoDiscovery.md)
+ [Connessione ai nodi in un cluster Valkey o Redis OSS](ClientConfig.ReplicationGroup.md)
+ [Nomi DNS e IP sottostante](ClientConfig.DNS.md)
# Comandi limitati
Per offrire un'esperienza di servizio gestito, ElastiCache limita l'accesso a determinati comandi specifici del motore di cache che richiedono privilegi avanzati. Per i cluster che eseguono Redis OSS, i seguenti comandi non sono disponibili:
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# Individuazione di endpoint e numeri di porta dei nodi
Per effettuare la connessione a un nodo di cache, l'applicazione deve conoscere l'endpoint e il numero di porta per tale nodo.
## Individuazione di endpoint e numeri di porta dei nodi (console)
**Per determinare gli endpoint e i numeri di porta dei nodi**
1. Accedi alla [console di ElastiCache gestione Amazon](https://aws.amazon.com/elasticache) e scegli il motore in esecuzione sul tuo cluster.
Viene visualizzato un elenco di tutti i cluster che eseguono il motore scelto.
1. Proseguire di seguito per il motore e la configurazione in esecuzione.
1. Scegliere il nome del cluster di interesse.
1. Individuare le colonne **Port (Porta)** ed **Endpoint** per il nodo desiderato.
## Individuazione di endpoint e numeri di porta dei nodi di cache (AWS CLI)
Per determinare gli endpoint e i numeri di porta dei nodi di cache, utilizza il comando `describe-cache-clusters` con il parametro `--show-cache-node-info`.
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
I nomi DNS completi e i numeri di porta si trovano nella sezione Endpoint dell'output.
## Ricerca degli endpoint e dei numeri di porta (ElastiCache API) dei nodi di cache
Per determinare gli endpoint e i numeri di porta dei nodi di cache, utilizza l'operazione `DescribeCacheClusters` con il parametro `ShowCacheNodeInfo=true`.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ShowCacheNodeInfo=true
4. &SignatureVersion=4
5. &SignatureMethod=HmacSHA256
6. &Timestamp=20140421T220302Z
7. &Version=2014-09-30
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Credential=
10. &X-Amz-Date=20140421T220302Z
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Signature=
13. &X-Amz-SignedHeaders=Host
```
# Connessione per l'utilizzo di Individuazione automatica
Se le applicazioni utilizzano Individuazione automatica, è sufficiente conoscere l'endpoint di configurazione per il cluster, anziché i singoli endpoint per ogni nodo di cache. Per ulteriori informazioni, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md).
**Nota**
Al momento, Auto Discovery è disponibile solo per i cluster che eseguono Memcached.
# Connessione ai nodi in un cluster Valkey o Redis OSS
**Nota**
Al momento, i cluster (API/CLI: gruppi di replica) che supportano la replica e le repliche di lettura sono supportati solo per i cluster che eseguono Valkey o Redis OSS.
Per i cluster, ElastiCache fornisce interfacce console, CLI e API per ottenere informazioni di connessione per i singoli nodi.
Per attività di sola lettura, le applicazioni possono connettersi a qualsiasi nodo nel cluster. Tuttavia, per le attività di scrittura, consigliamo che le applicazioni si connettano all'endpoint principale (Valkey o Redis OSS (modalità cluster disabilitata)) o all'endpoint di configurazione (Valkey o Redis OSS (modalità cluster abilitata)) del cluster anziché connettersi direttamente a un nodo. In questo modo, l'applicazione può sempre trovare il nodo corretto, anche se si sceglie di riconfigurare il cluster promuovendo una replica di lettura al ruolo primario.
## Connessione a cluster in un gruppo di replica (Console)
**Per determinare gli endpoint e i numeri di porta**
+ Consulta l'argomento [Ricerca degli endpoint (console) del cluster Valkey o Redis OSS (modalità cluster disabilitata)](Endpoints.md#Endpoints.Find.Redis)
## Connessione a cluster in un gruppo di replica (AWS CLI)
**Per determinare gli endpoint e i numeri di porta dei nodi di cache**
Utilizzare il comando `describe-replication-groups` con il nome del gruppo di replica:
```
aws elasticache describe-replication-groups redis2x2
```
Questo comando dovrebbe generare un output simile al seguente:
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "redis2x2.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "redis2x2",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"redis2x2-0001-001",
"redis2x2-0001-002",
"redis2x2-0002-001",
"redis2x2-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"PendingModifiedValues": {}
}
]
}
```
## Connessione ai cluster in un gruppo di replica (API) ElastiCache
**Per determinare gli endpoint e i numeri di porta dei nodi di cache**
Chiama `DescribeReplicationGroups` con il seguente parametro:
`ReplicationGroupId` = il nome del gruppo di replica.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ReplicationGroupId=repgroup01
4. &Version=2014-09-30
5. &SignatureVersion=4
6. &SignatureMethod=HmacSHA256
7. &Timestamp=20140421T220302Z
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Date=20140421T220302Z
10. &X-Amz-SignedHeaders=Host
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Credential=
13. &X-Amz-Signature=
```
# Nomi DNS e IP sottostante
I client mantengono un elenco di server contenente gli indirizzi e i numeri di porta dei server che detengono i dati di cache. Quando viene utilizzata ElastiCache, l' DescribeCacheClusters API (o l'utilità della riga di describe-cache-clusters comando) restituisce una voce DNS completa e un numero di porta che possono essere utilizzati per l'elenco dei server.
**Importante**
È importante che le applicazioni client siano configurate per risolvere frequentemente nomi DNS di nodi di cache quando tentano di connettersi a un endpoint del nodo di cache.
ElastiCache assicura che il nome DNS dei nodi di cache rimanga lo stesso quando i nodi di cache vengono ripristinati in caso di errore.
La maggior parte delle librerie client supportano connessioni ai nodi di cache persistenti per impostazione predefinita. Ti consigliamo di utilizzare connessioni a nodi di cache persistenti durante l'utilizzo di ElastiCache. Il caching DNS lato client si può verificare in più punti, inclusi librerie client, il runtime del linguaggio di programmazione o il sistema operativo del client. È opportuno rivedere la configurazione dell'applicazione a ogni livello per essere certi di risolvere frequentemente indirizzi IP per i nodi di cache.
# Suddivisione dei dati su più livelli in ElastiCache
ElastiCache per i cluster Valkey o Redis OSS che comprendono un gruppo di replica e utilizzano un tipo di nodo della famiglia r6gd, i dati vengono suddivisi su più livelli tra la memoria e lo storage SSD locale (unità a stato solido). Il data tiering offre una nuova opzione in termini di rapporto prezzo/prestazioni per i carichi di lavoro Valkey o Redis OSS utilizzando unità a stato solido () a basso costo in ogni nodo del cluster oltre all'archiviazione dei dati in memoria. SSDs È ideale per carichi di lavoro che accedono regolarmente fino al 20% del set di dati complessivo e per applicazioni che possono tollerare una latenza aggiuntiva quando si accede ai dati su SSD.
Nei ElastiCache cluster con suddivisione dei dati su più livelli, monitora l'ultimo orario di accesso di ogni elemento archiviato. ElastiCache Quando la memoria disponibile (DRAM) è completamente consumata, ElastiCache utilizza un algoritmo utilizzato più recentemente (LRU) per spostare automaticamente gli elementi a cui si accede meno frequentemente dalla memoria all'SSD. Quando successivamente si accede ai dati sull'SSD, li riporta ElastiCache automaticamente e in modo asincrono in memoria prima di elaborare la richiesta. Se si dispone di un carico di lavoro che accede regolarmente a un sottoinsieme di dati, il tiering di dati è un modo ottimale per dimensionare la capacità a costi contenuti.
Tieni presente che quando utilizzi il tiering dei dati, le chiavi rimangono sempre in memoria, mentre posizionamento dei valori sulla memoria viene gestito da LRU e non dal disco. In generale, è preferibile che le dimensioni delle chiavi siano inferiori a quelle dei valori quando utilizzi il tiering dei dati.
Il tiering dei dati è progettato per avere un impatto minimo sulle prestazioni dei carichi di lavoro delle applicazioni. Ad esempio, supponendo valori String di 500 byte, è possibile prevedere in media ulteriori 300 microsecondi di latenza per le richieste ai dati archiviati su SSD rispetto alle richieste ai dati in memoria.
Con le dimensioni più grandi dei nodi di tiering di dati (cache.r6gd.16xlarge), è possibile archiviare fino a 1 petabyte in un singolo cluster a 500 nodi (500 TB quando si utilizza 1 replica di lettura). Il tiering dei dati è compatibile con tutti i comandi e le strutture dati Valkey o Redis OSS supportati in. ElastiCache Non è necessaria alcuna modifica lato client per utilizzare questa caratteristica.
**Topics**
+ [Best practice](#data-tiering-best-practices)
+ [Limitazioni](#data-tiering-prerequisites)
+ [Prezzi](#data-tiering-pricing)
+ [Monitoraggio](#data-tiering-monitoring)
+ [Utilizzo del tiering di dati](#data-tiering-enabling)
+ [Ripristino di dati da backup su cluster con tiering di dati abilitato](#data-tiering-enabling-snapshots)
## Best practice
È preferibile seguire le best practice seguenti:
+ Il tiering dei dati è ideale per carichi di lavoro che accedono regolarmente fino al 20% del set di dati complessivo e per applicazioni che possono tollerare una latenza supplementare durante l’accesso ai dati su SSD.
+ Quando utilizzi la capacità SSD disponibile su nodi con tiering di dati, è ti consigliamo una dimensione del valore superiore a quella della chiave. Quando gli elementi vengono spostati tra DRAM e SSD, le chiavi rimarranno sempre in memoria e solo i valori verranno spostati al livello SSD.
## Limitazioni
Il livello di dati presenta le seguenti limitazioni:
+ È possibile utilizzare il tiering di dati solo su cluster che fanno parte di un gruppo di replica.
+ Il tipo di nodo utilizzato deve appartenere alla famiglia r6gd, disponibile nelle regioni seguenti: `us-east-2`, `us-east-1`, `us-west-2`, `us-west-1`, `eu-west-1`, `eu-central-1`, `eu-north-1`, `eu-west-3`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` e `sa-east-1`.
+ È necessario utilizzare un motore Valkey 7.2 o successivo oppure Redis OSS 6.2 o successivo.
+ Non è possibile ripristinare un backup di un cluster r6gd in un altro cluster a meno che non utilizzi anche r6gd.
+ Non è possibile esportare un backup su Amazon S3 per cluster con tiering di dati.
+ La migrazione online non è supportata per i cluster in esecuzione sul tipo di nodo r6gd.
+ Il dimensionamento non è supportato da dati un cluster di tiering di dati (ad esempio, un cluster che utilizza un tipo di nodo r6gd) a un cluster che non utilizza il tiering di dati (ad esempio, un cluster che utilizza un tipo di nodo r6g). Per ulteriori informazioni, consulta [Ridimensionamento ElastiCache](Scaling.md).
+ La scalabilità automatica è supportata sui cluster che utilizzano la suddivisione in più livelli dei dati per Valkey versione 7.2 e successive e Redis OSS versione 7.0.7 e successive. Per ulteriori informazioni, consulta [Auto Scaling dei cluster Valkey e Redis OSS](AutoScaling.md)
+ Il tiering di dati supporta solo policy maxmemory `volatile-lru`, `allkeys-lru`, `volatile-lfu`, `allkeys-lfu` e `noeviction`.
+ Il salvataggio senza forkless è supportato per Valkey versione 7.2 e successive e Redis OSS versione 7.0.7 e successive. Per ulteriori informazioni, consulta [Modalità di implementazione di sincronizzazione e backup](Replication.Redis.Versions.md).
+ Gli elementi più grandi di 128 MiB non vengono spostati su SSD.
+ A partire da Valley 8.1 e versioni successive, un elemento la cui dimensione key\$1 value è inferiore a 40 byte non verrà spostato sull'SSD.
## Prezzi
I nodi R6gd hanno una capacità totale 4,8 volte superiore (memoria \$1 SSD) e possono contribuire a un risparmio di oltre il 60% quando si esegue al massimo utilizzo rispetto ai nodi R6g (solo memoria). Per ulteriori informazioni, consulta [Prezzi di ElastiCache ](https://aws.amazon.com/elasticache/pricing/).
## Monitoraggio
ElastiCache offre metriche progettate specificamente per monitorare i cluster di prestazioni che utilizzano il tiering dei dati. [Per monitorare il rapporto tra gli elementi in DRAM e quelli SSD, puoi utilizzare la `CurrItems` metrica di Metrics for Valkey e Redis OSS.](CacheMetrics.Redis.md) Puoi calcolare la percentuale come: *(CurrItems con Dimension: Tier = Memory \$1 100)/(CurrItems senza filtro dimensionale)*.
Se la politica di sfratto configurata lo consente, ElastiCache inizierà a sfrattare gli articoli quando la percentuale di elementi in memoria scende al di sotto del 5%. Sui nodi configurati con nessuna politica di espulsione, le operazioni di scrittura riceveranno un errore di esaurimento della memoria.
Si consiglia comunque di prendere in considerazione la scalabilità orizzontale per i cluster abilitati alla modalità cluster o la scalabilità verticale per i cluster disabilitati in modalità cluster quando la percentuale di elementi in memoria scende al di sotto del 5%. Per ulteriori informazioni sulla scalabilità, vedere. [Scalabilità dei cluster Valkey o Redis OSS (Cluster Mode Enabled)](scaling-redis-cluster-mode-enabled.md) Per ulteriori informazioni sulle metriche per i cluster Valkey o Redis OSS che utilizzano il tiering dei dati, consulta. [Metriche per Valkey e Redis OSS](CacheMetrics.Redis.md)
## Utilizzo del tiering di dati
### Utilizzo della suddivisione in più livelli dei dati utilizzando il Console di gestione AWS
Quando si crea un cluster come parte di un gruppo di replica, il tiering di dati viene utilizzato selezionando un tipo di nodo dalla famiglia r6gd, ad esempio *cache.r6gd.xlarge*. La selezione di quel tipo di nodo abilita automaticamente il tiering di dati.
Per ulteriori informazioni sulla creazione di cluster, consulta [Creazione di un cluster per Valkey o Redis OSS](Clusters.Create.md).
### Abilitazione della suddivisione dei dati su più livelli utilizzando il AWS CLI
*Quando si crea un gruppo di replica utilizzando il AWS CLI, si utilizza il tiering dei dati selezionando un tipo di nodo dalla famiglia r6gd, ad esempio cache.r6gd.xlarge e impostando il parametro.* `--data-tiering-enabled`
Non è possibile disattivare il tiering di dati quando si seleziona un tipo di nodo dalla famiglia r6gd. Se si imposta il parametro `--no-data-tiering-enabled`, l'operazione avrà esito negativo.
Per Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled
```
Per Windows:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled
```
Dopo aver eseguito questa operazione, verrà visualizzata una risposta simile alla seguente:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
## Ripristino di dati da backup su cluster con tiering di dati abilitato
È possibile ripristinare un backup in un nuovo cluster con il tiering dei dati abilitato utilizzando (Console), () o (API).AWS CLI ElastiCache Quando si crea un cluster utilizzando tipi di nodo nella famiglia r6gd, il tiering di dati è abilitato.
### Ripristino di dati da backup su cluster con tiering di dati abilitato (console)
**Per ripristinare un backup su un nuovo cluster con tiering di dati abilitato (console)**
1. Accedi a Console di gestione AWS e apri la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione, scegliere **Backups (Backup)**.
1. Nell'elenco dei backup, scegli la casella a sinistra del nome di backup da cui desideri eseguire il ripristino.
1. Scegli **Restore** (Ripristina).
1. Completare la finestra di dialogo **Restore Cluster (Ripristina cluster)**. Assicurarsi di completare tutti i campi **Obbligatori** e gli eventuali altri che si desidera modificare rispetto alle impostazioni predefinite.
1. **Cluster ID (ID cluster)** : Obbligatorio. Il nome del nuovo cluster.
1. **Modalità cluster abilitata (scalabilità orizzontale)**: scegli questa opzione per un cluster Valkey o Redis OSS (modalità cluster abilitata).
1. **Tipo di nodo** – Specificare **cache.r6gd.xlarge** o qualsiasi altro tipo di nodo della famiglia r6gd.
1. **Number of Shards (Numero di partizioni)** - Scegliere il numero di partizioni desiderato nel nuovo cluster (API/CLI: gruppi di nodi).
1. **Replicas per Shard (Repliche per partizioni)** - Scegliere il numero di nodi di replica di lettura desiderato in ognle partizioni.
1. **Slots and keyspaces (Slot e keyspaces)** - Scegliere la modalità di distribuzione delle chiavi tra le partizioni. Se si sceglie di specificare le distribuzioni chiave, completare la tabella specificando gli intervalli chiave per ognle partizioni.
1. **Availability zone(s) (Zone di disponibilità)** - Specificare la modalità di selezione delle zone di disponibilità del cluster.
1. **Porta**: modifica solo se il nuovo cluster deve utilizzare una porta diversa.
1. **Choose a VPC (scegliere un VPC)** : Scegliere il VPC in cui creare questo cluster.
1. **Gruppo di parametri**: scegli un gruppo di parametri che riservi memoria sufficiente per l'overhead di Valkey o Redis OSS per il tipo di nodo selezionato.
1. Dopo aver selezionato tutte le impostazioni desiderate, scegli **Crea**.
Per ulteriori informazioni sulla creazione di cluster, consulta [Creazione di un cluster per Valkey o Redis OSS](Clusters.Create.md).
### Ripristino di dati da backup su cluster con tiering di dati abilitato (AWS CLI)
*Quando si crea un gruppo di replica utilizzando AWS CLI, per impostazione predefinita viene utilizzato il tiering dei dati su più livelli selezionando un tipo di nodo dalla famiglia r6gd, ad esempio cache.r6gd.xlarge e impostando il parametro.* `--data-tiering-enabled`
Non è possibile disattivare il tiering di dati quando si seleziona un tipo di nodo dalla famiglia r6gd. Se si imposta il parametro `--no-data-tiering-enabled`, l'operazione avrà esito negativo.
Per Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled \
--snapshot-name my-snapshot
```
Per Linux, macOS o Unix:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled ^
--snapshot-name my-snapshot
```
Dopo aver eseguito questa operazione, verrà visualizzata una risposta simile alla seguente:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
# Preparazione di un cluster in ElastiCache
Di seguito, puoi trovare le istruzioni sulla creazione di un cluster utilizzando la ElastiCache console AWS CLI, l'o l' ElastiCache API.
Puoi anche creare un ElastiCache cluster utilizzando [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html). Per ulteriori informazioni, consulta [AWS::ElastiCache:: CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html) nella *Guida per l'utente di AWS Cloud Formation*, che include indicazioni su come implementare questo approccio.
È consigliabile eseguire delle operazioni preliminari a ogni creazione di un cluster o di un gruppo di replica , in modo da non dover effettuare aggiornamenti o modifiche sin dai primi momenti.
**Topics**
+ [Determinazione dei requisiti ElastiCache del cluster](cluster-create-determine-requirements.md)
+ [Scelta delle dimensioni dei nodi](CacheNodes.SelectSize.md)
# Determinazione dei requisiti ElastiCache del cluster
**Preparazione**
Conoscere le risposte alle seguenti domande aiuta a semplificare la creazione ElastiCache del cluster:
+ Che tipo di istanza dei nodi ti occorre?
Per assistenza nella scelta di un tipo di nodo dell'istanza, consulta [Scelta delle dimensioni dei nodi](CacheNodes.SelectSize.md).
+ Intendi avviare il cluster in un cloud privato virtuale (VPC) basato su Amazon VPC?
**Importante**
Se intendi avviare il cluster in un VPC, prima di iniziarne la creazione devi creare un gruppo di sottoreti nello stesso VPC. Per ulteriori informazioni, consulta [Sottoreti e gruppi di sottoreti](SubnetGroups.md).
ElastiCache è progettato per essere accessibile dall'interno AWS tramite Amazon EC2. Tuttavia, se il cluster viene avviato in un VPC basato su Amazon VPC e si trova in un VPC, è possibile fornire l'accesso dall'esterno di AWS. Per ulteriori informazioni, consulta [Accesso alle ElastiCache risorse dall'esterno AWS](accessing-elasticache.md#access-from-outside-aws).
+ Devi personalizzare qualche valore di parametro?
In tal caso, crea un gruppo di parametri personalizzato. Per ulteriori informazioni, consulta [Creazione di un gruppo di ElastiCache parametri](ParameterGroups.Creating.md).
Se utilizzi Valkey o Redis OSS, prendi in considerazione l'impostazione `reserved-memory` o. `reserved-memory-percent` Per ulteriori informazioni, consulta [Gestione della memoria riservata per Valkey e Redis OSS](redis-memory-management.md).
+ Devi creare un tuo *gruppo di sicurezza VPC*?
Per ulteriori informazioni, consulta [Security in Your VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ Come intendi implementare la tolleranza ai guasti?
Per ulteriori informazioni, consulta [Limitazione dell'impatto degli errori](disaster-recovery-resiliency.md#FaultTolerance).
**Topics**
+ [ElastiCache requisiti di memoria e processore](#cluster-create-determine-requirements-memory)
+ [Configurazione del cluster Memcached](#memcached-cluster-configuration)
+ [Configurazione dei cluster Valkey e Redis OSS](#redis-cluster-configuration)
+ [ElastiCache requisiti di scalabilità](#cluster-create-determine-requirements-scaling)
+ [ElastiCache requisiti di accesso](#cluster-create-determine-requirements-access)
+ [Requisiti per regione, zona di disponibilità e zona locale per ElastiCache](#cluster-create-determine-requirements-region)
## ElastiCache requisiti di memoria e processore
L'elemento costitutivo di base di Amazon ElastiCache è il nodo. Per formare i cluster, i nodi vengono configurati singolarmente o a gruppi. Quando determini il tipo di nodo da utilizzare per il cluster, prendi in considerazione la configurazione dei nodi del cluster e la quantità di dati da archiviare.
Memcached è un motore multi-thread, quindi il numero di core di un nodo influisce sulla potenza di elaborazione disponibile per il cluster.
## Configurazione del cluster Memcached
ElastiCache per i cluster Memcached sono composti da 1 a 60 nodi. I dati presenti in un cluster Memcached vengono partizionati nei nodi del cluster. La tua applicazione si connette a un cluster Memcached tramite un indirizzo di rete chiamato endpoint. Ogni nodo di un cluster Memcached ha un proprio endpoint, che viene utilizzato dall'applicazione per le operazioni di lettura o scrittura sul nodo specifico. Oltre agli endpoint sul nodo primario, lo stesso cluster Memcached ha un endpoint denominato *endpoint di configurazione*. L'applicazione può utilizzare questo endpoint per leggere dal o scrivere sul cluster, lasciando la determinazione del nodo da cui leggere o scrivere all'individuazione automatica.
![\[Immagine che mostra come un cluster Memcached è partizionato tra i nodi del cluster.\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
Per ulteriori informazioni, consulta [Gestione dei cluster in ElastiCache](Clusters.md).
## Configurazione dei cluster Valkey e Redis OSS
ElastiCache per i cluster Valkey e Redis OSS sono composti da 0 a 500 shard (chiamati anche gruppi di nodi). I dati in un cluster Valkey o Redis OSS sono partizionati tra gli shard del cluster. L'applicazione si connette a un cluster Valkey o Redis OSS utilizzando un indirizzo di rete chiamato Endpoint. I nodi di uno shard Valkey o Redis OSS soddisfano uno dei due ruoli: uno read/write primario e tutti gli altri nodi secondari di sola lettura (chiamati anche repliche di lettura). *Oltre agli endpoint del nodo, lo stesso cluster Valkey o Redis OSS dispone di un endpoint chiamato endpoint di configurazione.* L'applicazione può utilizzare questo endpoint per leggere o scrivere nel cluster, lasciando a Redis OSS la determinazione del nodo da cui leggere o scrivere. ElastiCache
![\[Immagine che confronta un cluster Valkey o Redis OSS in modalità disabilitata rispetto alla modalità abilitata.\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-Redis-ClustersRGs.png)
Per ulteriori informazioni, consulta [Gestione dei cluster in ElastiCache](Clusters.md).
## ElastiCache requisiti di scalabilità
Tutti i cluster sono dimensionabili tramite la creazione di un nuovo cluster con un nuovo e più grande tipo di nodo. Quando si esegue la scalabilità di un cluster Memcached, il nuovo cluster inizia vuoto. Quando si esegue la scalabilità di un cluster Valkey o Redis OSS, è possibile eseguire il seeding da un backup ed evitare che il nuovo cluster sia inizialmente vuoto.
I cluster Amazon ElastiCache for Memcached possono essere scalati orizzontalmente o internamente. Per dimensionare un cluster Memcached basta aggiungere o rimuovere i nodi dal cluster. Se hai abilitato l'individuazione automatica e la tua applicazione si connette all'endpoint di configurazione del cluster, non devi apportare alcuna modifica all'applicazione quando aggiungi o rimuovi i nodi.
Per ulteriori informazioni sul tagging, consulta [Ridimensionamento ElastiCache](Scaling.md)in questa guida.
## ElastiCache requisiti di accesso
In base alla progettazione, è possibile accedere ElastiCache ai cluster Amazon dalle EC2 istanze Amazon. L'accesso di rete a un ElastiCache cluster è limitato all'account che ha creato il cluster. Pertanto, prima di poter accedere a un cluster da un' EC2 istanza Amazon, devi autorizzare l' EC2 istanza Amazon ad accedere al cluster. I passaggi per eseguire questa operazione variano a seconda che sia stato avviato in EC2 -VPC o EC2 -Classic.
Se hai avviato il cluster in EC2 -VPC, devi concedere l'ingresso di rete al cluster. Se hai avviato il cluster in EC2 -Classic, devi concedere al gruppo di sicurezza Amazon Elastic Compute Cloud associato all'istanza l'accesso al tuo gruppo di ElastiCache sicurezza. Per istruzioni dettagliate, consultare [Fase 3. Autorizza l'accesso al cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) in questa guida.
## Requisiti per regione, zona di disponibilità e zona locale per ElastiCache
Amazon ElastiCache supporta tutte le AWS regioni. Localizzando ElastiCache i cluster in una AWS regione vicina all'applicazione, puoi ridurre la latenza. Se il cluster dispone di più nodi, posizionarli in Zone di disponibilità o in Local Zones diverse può ridurre l'effetto degli errori sul cluster.
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Scelta delle regioni e delle zone di disponibilità per ElastiCache](RegionsAndAZs.md)
+ [Utilizzo delle zone locali con ElastiCache](Local_zones.md)
+ [Limitazione dell'impatto degli errori](disaster-recovery-resiliency.md#FaultTolerance)
# Scelta delle dimensioni dei nodi
La dimensione del nodo selezionata per il ElastiCache cluster influisce sui costi, sulle prestazioni e sulla tolleranza agli errori.
## Dimensione del nodo (Valkey e Redis OSS)
Per informazioni sui vantaggi dei processori Graviton, vedere [Processore AWS Graviton](https://aws.amazon.com/pm/ec2-graviton/).
Rispondere alle seguenti domande può aiutarvi a determinare il tipo di nodo minimo necessario per l'implementazione di Valkey o Redis OSS:
+ Si prevedono carichi di lavoro legati al velocità di trasmissione effettiva con più connessioni client?
Se questo è il caso e stai utilizzando Redis OSS versione 5.0.6 o successiva, puoi ottenere velocità e latenza migliori con le nostre I/O funzionalità avanzate, ove disponibili, CPUs utilizzate per scaricare le connessioni client, per conto del motore Redis OSS. Se utilizzi Redis OSS versione 7.0.4 o successiva, oltre ai I/O, you will get additional acceleration with enhanced I/O multiplexing, where each dedicated network IO thread pipelines commands from multiple clients into the Redis OSS engine, taking advantage of Redis OSS' ability to efficiently process commands in batches. In ElastiCache for Redis OSS v7.1 and above, we extended the enhanced I/O threads functionality to also handle the presentation layer logic. By presentation layer, what we mean is that Enhanced I/O thread avanzati ora non solo leggono l'input del client, ma analizzano anche l'input nel formato di comando binario Redis OSS, che viene quindi inoltrato al thread principale per l'esecuzione, garantendo un aumento delle prestazioni. Per ulteriori dettagli, consulta il [post del blog](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/) e la pagina delle [versioni supportate](VersionManagement.md#supported-engine-versions).
+ Si dispone di carichi di lavoro che accedono regolarmente a una piccola percentuale dei dati?
Se questo è il caso e utilizzi la versione 6.2 o successiva del motore Redis OSS, puoi sfruttare il tiering dei dati scegliendo il tipo di nodo r6gd. Con il tiering di dati, i dati utilizzati meno di recente vengono archiviati su SSD. Quando vengono recuperati, è previsto un piccolo costo di latenza, bilanciato dai risparmi sui costi. Per ulteriori informazioni, consulta [Suddivisione dei dati su più livelli in ElastiCache](data-tiering.md).
Per ulteriori informazioni, consulta [Tipi di nodi supportati](CacheNodes.SupportedTypes.md).
+ Di quanta memoria in totale necessiti per i tuoi dati?
Per ottenere una stima generale, prendere la dimensione degli elementi che si desidera memorizzare nella cache. Moltiplicare questa dimensione per il numero degli elementi da conservare nella cache contemporaneamente. Per ottenere una stima veritiera delle dimensioni degli elementi, serializza gli elementi della cache e contane i caratteri. Poi dividi questo numero per il numero delle partizioni nel cluster.
Per ulteriori informazioni, consulta [Tipi di nodi supportati](CacheNodes.SupportedTypes.md).
+ Quale versione di Redis OSS stai utilizzando?
Le versioni di Redis OSS precedenti alla 2.8.22 richiedono di riservare più memoria per il failover, le istantanee, la sincronizzazione e la promozione di una replica alle operazioni principali. Occorre infatti disporre di una quantità di memoria sufficiente per tutte le operazioni di scrittura necessarie, affinché il processo vada a buon fine.
Redis OSS versione 2.8.22 e successive utilizzano un processo di salvataggio senza forkless che richiede meno memoria disponibile rispetto al processo precedente.
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Modalità di implementazione di sincronizzazione e backup](Replication.Redis.Versions.md)
+ [Garantire la disponibilità di memoria sufficiente per creare un'istantanea Valkey o Redis OSS](BestPractices.BGSAVE.md)
+ Quant'è consistente il carico di lavoro in scrittura della tua applicazione?
Le applicazioni caratterizzate da elevata attività di scrittura possono richiedere molta più memoria disponibile, non occupata dai dati, per acquisire snapshot o per il failover. Ogni volta che viene svolto il processo `BGSAVE`, è necessario disporre di memoria sufficiente che non viene utilizzata dai dati per contenere tutte le scritture che avvengono durante il processo `BGSAVE` Esempi sono quando si esegue uno snapshot, quando si sincronizza un cluster primario con una replica in un cluster e quando si abilita la caratteristica AOF (Append-only File). Un altro è la promozione di una replica al ruolo di nodo primario (se la funzione Multi-AZ è abilitata). Il caso peggiore è quando tutti i tuoi dati vengono riscritti durante il processo. In questo caso, è necessaria una dimensione di istanza di nodo con il doppio della memoria necessaria per i soli dati.
Per informazioni più dettagliate, consulta [Garantire la disponibilità di memoria sufficiente per creare un'istantanea Valkey o Redis OSS](BestPractices.BGSAVE.md).
+ L'implementazione sarà un cluster Valkey o Redis OSS autonomo (modalità cluster disabilitata) oppure un cluster Valkey o Redis OSS (modalità cluster abilitata) con più shard?
**Cluster Valkey o Redis OSS (modalità cluster disabilitata)**
Se stai implementando un cluster Valkey o Redis OSS (modalità cluster disabilitata), il tipo di nodo deve essere in grado di ospitare tutti i tuoi dati più l'overhead necessario, come descritto nel bullet precedente.
Si supponga, ad esempio, di stimare che la dimensione totale di tutti gli articoli sia di 12 GB. In questo caso, puoi usare un `cache.m3.xlarge` nodo con 13,3 GB di memoria o un `cache.r3.large` con 13,5 GB di memoria. Tuttavia, potrebbe occorrere più memoria per le operazioni di `BGSAVE`. Se l'applicazione è pesante da scrivere, raddoppiare i requisiti di memoria fino ad almeno 24 GB. Quindi, usa un `cache.m3.2xlarge` con 27,9 GB di memoria o`cache.r3.xlarge` con 30,5 GB di memoria.
**Valkey o Redis OSS (modalità cluster abilitata) con più shard**
Se stai implementando un cluster Valkey o Redis OSS (modalità cluster abilitata) con più shard, il tipo di nodo deve essere in grado di contenere byte di dati. `bytes-for-data-and-overhead / number-of-shards`
Se, ad esempio, stimi in 12 GB la dimensione totale di tutti gli elementi e disponi di due partizioni. In questo caso, puoi usare un nodo `cache.m3.large` con 6,05 GB di memoria (12 GB/2). Tuttavia, potrebbe occorrere più memoria per le operazioni di `BGSAVE`. Se l'applicazione è pesante da scrivere, raddoppiare i requisiti di memoria fino ad almeno 12 GB per partizioni. Quindi, usa un `cache.m3.xlarge` con 13,3 GB di memoria o `cache.r3.large` con 13,5 GB di memoria.
+ Stai usando Local Zones?
[Le Local Zones](Local_zones.md) ti consentono di collocare risorse come un ElastiCache cluster in più posizioni vicine ai tuoi utenti. Tuttavia, quando si sceglie la dimensione del nodo, tenere presente che le dimensioni dei nodi disponibili sono limitate alle seguenti al momento, indipendentemente dai requisiti di capacità:
+ Generazione attuale:
**Tipi di nodi M5:** `cache.m5.large`, `cache.m5.xlarge`, `cache.m5.2xlarge`, `cache.m5.4xlarge`, `cache.m5.12xlarge`, `cache.m5.24xlarge`
**Tipi di nodi R5:** `cache.r5.large`, `cache.r5.xlarge`, `cache.r5.2xlarge`, `cache.r5.4xlarge`, `cache.r5.12xlarge`, `cache.r5.24xlarge`
**Tipi di nodo T3:** `cache.t3.micro`, `cache.t3.small`, `cache.t3.medium`
Mentre il cluster è in esecuzione, è possibile monitorare l'utilizzo della memoria, l'utilizzo del processore, gli accessi alla cache e le metriche relative agli errori di cache pubblicati su. CloudWatch È possibile notare che il cluster non ha la frequenza di accessi desiderata o che le chiavi vengono espulse troppo spesso. In questi casi, puoi scegliere una dimensione di nodi diversa con specifiche di memoria e CPU maggiori.
Quando monitorate l'utilizzo della CPU, ricordate che Valkey e Redis OSS sono a thread singolo. Pertanto, moltiplica l'utilizzo della CPU segnalato per il numero di core CPU per ottenere l'effettivo utilizzo. Ad esempio, una CPU a quattro core che riporta un tasso di utilizzo del 20% è in realtà l'OSS Redis a un core in esecuzione con un utilizzo dell'80%.
## Dimensione del nodo (Memcached)
I cluster Memcached possono contenere uno o più nodi, tra i quali ripartire i propri dati. Per questo motivo, le esigenze di memoria del cluster e la memoria di un nodo sono correlate, ma non corrispondenti. La necessaria capacità di memoria del cluster può contare su pochi nodi grandi o molti nodi piccoli. Inoltre, in base alle mutevoli esigenze, è possibile aggiungere nodi al cluster o rimuoverli in qualunque momento, pagando solo ciò che occorre.
La capacità di memoria totale del cluster viene calcolata moltiplicando il numero di nodi nel cluster per la capacità di RAM di ciascun nodo, al netto del carico operativo del sistema. La capacità di un nodo dipende dalla sua tipologia.
```
cluster_capacity = number_of_nodes * (node_capacity - system_overhead)
```
Il numero dei suoi nodi è un fattore determinante per la disponibilità di un cluster che esegue Memcached. Il fallimento di un solo nodo può influire sulla disponibilità dell'applicazione e sul carico sul database back-end. In tal caso, ElastiCache predispone un nodo sostitutivo per un nodo guasto e questo viene ripopolato. Per ridurre questo potenziale impatto sulla disponibilità, basta distribuire la memoria e la capacità di calcolo su più nodi a capacità ridotta, anziché su meno nodi ad ampia capacità.
Se, ad esempio, occorrono 35 GB di memoria cache, è possibile impostare una qualsiasi delle seguenti configurazioni:
+ 11 nodi `cache.t2.medium`, ciascuno con 3,22 GB di memoria e 2 thread = 35,42 GB e 22 thread.
+ 6 nodi `cache.m4.large`, ciascuno con 6,42 GB di memoria e 2 thread = 38,52 GB e 12 thread.
+ 3 nodi `cache.r4.large`, ciascuno con 12,3 GB di memoria e 2 thread = 36,90 GB e 6 thread.
+ 3 nodi `cache.m4.xlarge`, ciascuno con 14,28 GB di memoria e 4 thread = 42,84 GB e 12 thread.
**Opzioni disponibili per i nodi a confronto**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/CacheNodes.SelectSize.html)
Ognuna di queste opzioni offre una disponibilità di memoria simile, ma capacità e costi di elaborazione diversi. Per confrontare i costi delle tue opzioni specifiche, consulta la pagina [ ElastiCache dei prezzi di Amazon](https://aws.amazon.com/elasticache/pricing/).
Nel caso dei cluster che eseguono Memcached, parte della memoria disponibile su ciascun nodo viene utilizzata per la gestione della connessione. Per ulteriori informazioni, consulta [Sovraccarico delle connessioni Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead)
L'utilizzo di più nodi richiede la distribuzione delle chiavi tra gli stessi. Ogni nodo dispone del proprio endpoint. Per una gestione semplificata degli endpoint, puoi utilizzare ElastiCache la funzionalità Auto Discovery, che consente ai programmi client di identificare automaticamente tutti i nodi di un cluster. Per ulteriori informazioni, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md).
In alcuni casi, è possibile non essere sicuri di quanta capacità è necessaria. In caso affermativo, per i test consigliamo di iniziare con un `cache.m5.large` nodo. Quindi monitora l'utilizzo della memoria, l'utilizzo della CPU e la frequenza di accesso alla cache con le ElastiCache metriche pubblicate su Amazon. CloudWatch Per ulteriori informazioni sulle CloudWatch metriche per ElastiCache, consulta. [Monitoraggio dell'utilizzo con CloudWatch Metrics](CacheMetrics.md) Per carichi di lavoro di produzione particolarmente consistenti, i nodi R5 garantiscono le prestazioni e il valore di costo della RAM migliori.
Se il cluster non garantisce l'hit rate desiderato, basta aggiungere più nodi, aumentando così la memoria totale in esso disponibile.
Se il cluster risulta vincolato dalla CPU ma, comunque, con un hit rate sufficiente, prova a configurare un nuovo cluster con un tipo di nodo che garantisca maggiore potenza di calcolo.
# Creazione di un cluster per Valkey o Redis OSS
Gli esempi seguenti mostrano come creare un cluster Valkey o Redis OSS utilizzando l'Console di gestione AWS API e.AWS CLI ElastiCache
## Creazione di un Valkey o Redis OSS (modalità cluster disabilitata) (Console)
ElastiCache supporta la replica quando si utilizza il motore Valkey o Redis OSS. Per monitorare la latenza tra il momento in cui i dati vengono scritti su un cluster read/write primario Valkey o Redis OSS e il momento in cui vengono propagati in un cluster secondario di sola lettura, aggiunge al cluster una chiave speciale, ElastiCache . `ElastiCacheMasterReplicationTimestamp` Questa chiave è l'ora UTC (Universal Time Coordinated) corrente. Poiché un cluster Valkey o Redis OSS potrebbe essere aggiunto a un gruppo di replica in un secondo momento, questa chiave è inclusa in tutti i cluster Valkey o Redis OSS, anche se inizialmente non sono membri di un gruppo di replica. Per ulteriori informazioni sui gruppi di replica, consulta [Alta disponibilità utilizzando gruppi di replica](Replication.md).
Per creare un cluster Valkey o Redis OSS (modalità cluster disabilitata), procedi nel seguente modo. [Creazione di un cluster Valkey (modalità cluster disabilitata) (console)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
Non appena lo stato del cluster è *disponibile*, puoi concedere ad Amazon EC2 l'accesso, connetterti e iniziare a utilizzarlo. Per ulteriori informazioni, consultare [Fase 3. Autorizza l'accesso al cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) e [Passaggio 4. Connect al nodo del cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene effettivamente utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
## Creazione di un cluster Valkey o Redis OSS (modalità cluster abilitata) (Console)
Se utilizzi Redis OSS 3.2.4 o versione successiva, puoi creare un cluster Valkey o Redis OSS (modalità cluster abilitata). I cluster Valkey o Redis OSS (modalità cluster abilitata) supportano il partizionamento dei dati su 1-500 shard (API/CLI: gruppi di nodi) ma con alcune limitazioni. Per un confronto tra Valkey o Redis OSS (modalità cluster disabilitata) e Valkey o Redis OSS (modalità cluster abilitata), vedi. [Motori e versioni supportati](VersionManagement.md#supported-engine-versions)
**Per creare un cluster Valkey o Redis OSS (modalità cluster abilitata) utilizzando la console ElastiCache**
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dall'elenco nell'angolo in alto a destra, scegli la AWS regione in cui desideri avviare questo cluster.
1. Scegli **Nozioni di base** dal riquadro di navigazione.
1. Scegli **Crea VPC** e segui la procedura descritta in [Creazione di un cloud privato virtuale (VPC)](VPCs.CreatingVPC.md).
1. Nella pagina del ElastiCache dashboard, scegli **Crea cluster, quindi scegli Crea cluster** **Valkey o **Crea** cluster Redis** OSS.
1. In **Cluster settings** (Impostazioni cluster), procedi come indicato di seguito:
1. Scegli **Configurazione e creazione di un nuovo cluster**.
1. Per **Modalità cluster**, scegli **Abilitata**.
1. Per **Informazioni sul cluster**, inserisci un valore per **Nome**.
1. (Facoltativo) Inserisci un valore per **Descrizione**.
1. In **Location** (Ubicazione):
------
#### [ AWS Cloud ]
1. Per **Cloud AWS**, è preferibile accettare le impostazioni predefinite per **Multi-AZ** e **Failover automatico**. Per ulteriori informazioni, consulta [Ridurre al minimo i tempi di inattività in Redis OSS con ElastiCache Multi-AZ](AutoFailover.md).
1. In **Cluster settings** (Impostazioni cluster)
1. Per **Engine version** (Versione motore), scegli una versione disponibile.
1. Per **Porta** utilizza la porta predefinita, 6379. Se esiste un motivo per utilizzare una porta diversa, immettere il numero di porta.
1. Per **Parameter group (Gruppo di parametri)**, scegliere un gruppo di parametri o crearne uno nuovo. I gruppi di parametri controllano i parametri di runtime del cluster. Per ulteriori informazioni sui gruppi di parametri, consulta [Parametri Valkey e Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) e [Creazione di un gruppo di ElastiCache parametri](ParameterGroups.Creating.md).
**Nota**
Quando si seleziona un gruppo di parametri per impostare i valori di configurazione del motore, tale gruppo di parametri viene applicato a tutti i cluster nel Global Datastore. Nella pagina **Parameter Groups (Gruppi di parametri)** con/senza l'attributo **Global (Globale)** indica se un gruppo di parametri fa parte di un Global Datastore.
1. In **Node type (Tipo di nodo)**, scegliere la freccia in giù (![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)). Nella finestra di dialogo **Change node type (Cambia tipo di nodo)** scegliere un valore per **Instance family (Famiglia di istanze)** per il tipo di nodo desiderato. Scegliere quindi il tipo di nodo che si desidera utilizzare per il cluster, quindi scegliere **Save (Salva)**.
Per ulteriori informazioni, consulta [Scelta delle dimensioni dei nodi](CacheNodes.SelectSize.md).
Se scegli un tipo di nodo r6gd, il tiering dei dati viene abilitato automaticamente. Per ulteriori informazioni, consulta [Suddivisione dei dati su più livelli in ElastiCache](data-tiering.md).
1. Per **Numero di shard**, scegli il numero di shard (partizioni/gruppi di nodi) che desideri per questo cluster Valkey o Redis OSS (modalità cluster abilitata).
Per alcune versioni di Valkey o Redis OSS (modalità cluster abilitata), puoi modificare il numero di shard nel cluster in modo dinamico:
+ **Redis OSS 3.2.10 e versioni successive**: se sul cluster è in esecuzione Redis OSS 3.2.10 o versioni successive, è possibile modificare il numero di shard nel cluster in modo dinamico. Per ulteriori informazioni, consulta [Scalabilità dei cluster Valkey o Redis OSS (Cluster Mode Enabled)](scaling-redis-cluster-mode-enabled.md).
+ **Altre versioni di Redis OSS**: se sul cluster è in esecuzione una versione di Redis OSS precedente alla versione 3.2.10, esiste un altro approccio. Per modificare il numero dle partizioni nel cluster in questo caso, creare un nuovo cluster con il nuovo numero dle partizioni. Per ulteriori informazioni, consulta [Ripristino da un backup in una nuova cache](backups-restoring.md).
1. In **Replicas per shard (Repliche per partizione)**: scegliere il numero di nodi di replica di lettura per ognle partizioni.
Esistono le seguenti restrizioni per Valkey o Redis OSS (modalità cluster abilitata).
+ Se hai abilitato la funzione Multi-AZ, assicurati di avere almeno una replica per ognle partizioni.
+ Quando utilizzi la console per creare il cluster, il numero delle repliche è lo stesso per ognle partizioni.
+ Il numero delle repliche di lettura per ognle partizioni è fisso e non modificabile. Se scopri che ti servono più o meno repliche per partizione (API/CLI: gruppo di nodi), devi creare un nuovo cluster con il nuovo numero di repliche. Per ulteriori informazioni, consulta [Tutorial: Seminare un nuovo cluster basato su nodi con un backup creato esternamente](backups-seeding-redis.md).
1. In **Connectivity** (Connettività)
1. Per **Network type** (Tipo di rete), scegli le versioni IP supportate da questo cluster.
1. Per i **gruppi di sottoreti**, scegli la sottorete che desideri applicare a questo cluster. ElastiCache utilizza quel gruppo di sottorete per scegliere una sottorete e gli indirizzi IP all'interno di quella sottorete da associare ai nodi. ElastiCache i cluster richiedono una sottorete dual-stack con entrambi IPv6 gli indirizzi assegnati per funzionare in modalità dual-stack IPv4 e una sottorete -only per funzionare solo come -only. IPv6 IPv6
Durante la creazione di un nuovo gruppo di sottoreti, immettere l'**VPC ID** (ID VPC) a cui appartiene.
Seleziona un **Discovery IP type** (Tipo di rilevamento IP). Vengono restituiti solo gli indirizzi IP del protocollo scelto.
Per ulteriori informazioni, consulta:
+ [Scelta del tipo di rete in ElastiCache](network-type.md).
+ Creazione di una sottorete nel VPC.
Se si esegue per [Utilizzo delle zone locali con ElastiCache](Local_zones.md), è necessario creare o scegliere una sottorete che si trova nella zona locale.
Per ulteriori informazioni, consulta [Sottoreti e gruppi di sottoreti](SubnetGroups.md).
1. Per **Posizionamento zone disponibilità**, le opzioni sono due:
+ ** ElastiCache Nessuna** preferenza: sceglie la zona di disponibilità.
+ **Specify Availability Zones (Specifica zone di disponibilità)** – L'utente specifica la zona di disponibilità per ogni cluster.
Se hai scelto di specificare le zone di disponibilità, per ogni cluster in ognle partizioni, seleziona la zona di disponibilità dall'elenco.
Per ulteriori informazioni, consulta [Scelta delle regioni e delle zone di disponibilità per ElastiCache](RegionsAndAZs.md).
1. Seleziona **Successivo**.
1. Nelle impostazioni **Advanced Valkey o nelle impostazioni** **Advanced Redis OSS** oppure
1. Per **Sicurezza**:
1. Per crittografare i dati, le opzioni disponibili sono le seguenti:
+ **Crittografia dei dati inattivi** : Consente la crittografia dei dati memorizzati su disco. Per ulteriori informazioni, consultare [Crittografia dei dati inattivi](at-rest-encryption.md).
**Nota**
Hai la possibilità di fornire una chiave di crittografia diversa scegliendo la chiave **AWS KMS gestita dal cliente e scegliendo la chiave**. Per ulteriori informazioni, vedere [Utilizzo di chiavi gestite dal cliente da AWS KMS](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ **Crittografia dei dati in transito** – Consente la crittografia dei dati in trasferimento. Per maggiori informazioni, consultare [Crittografia dei dati in transito](in-transit-encryption.md). **Per Valkey 7.2 e versioni successive o Redis OSS 6.0 e versioni successive, se abiliti Encryption in-transit ti verrà richiesto di specificare una delle seguenti opzioni di controllo degli accessi:**
+ **Nessun controllo degli accessi** - Questa è l'impostazione di default. Questo non indica alcuna restrizione sull'accesso dell’utente al cluster.
+ **Lista di controllo accessi** – scegliere un gruppo di utenti con un set definito di utenti che possono accedere al cluster. Per ulteriori informazioni, consulta [Gestione dei gruppi di utenti con Console e CLI](Clusters.RBAC.md#User-Groups).
+ **AUTH Default User**: meccanismo di autenticazione per un server Valkey o Redis OSS. [Per ulteriori informazioni, consulta AUTH.](auth.md)
+ **AUTH**: meccanismo di autenticazione per il server Valkey o Redis OSS. [Per ulteriori informazioni, consulta AUTH.](auth.md)
**Nota**
Per le versioni Redis OSS comprese tra 3.2.6 e successive, esclusa la versione 3.2.10, AUTH è l'unica opzione.
1. In **Security groups (Gruppi di sicurezza)**, scegliere i gruppi di sicurezza per il cluster. Un *gruppo di sicurezza* si comporta come un firewall, controllando l'accesso di rete al cluster. È possibile utilizzare il gruppo di sicurezza di default per il VPC o crearne uno nuovo.
Per ulteriori informazioni sui gruppi di sicurezza, consulta [Gruppi di sicurezza per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) nella *Guida per l'utente di Amazon VPC*.
1. Se si desiderano backup regolari pianificati regolarmente, scegliere **Enable automatic backups (Abilita backup automatici)**, quindi digitare il numero di giorni in cui conservare ciascun backup automatico prima che venga automaticamente eliminato. Se non si desiderano backup automatici pianificati regolarmente, deselezionare la casella di controllo **Enable automatic backups (Abilita backup automatici)**. In ogni caso, hai sempre la possibilità di creare backup manuali.
Per ulteriori informazioni sul backup e il ripristino, vedere. [Snapshot e ripristino](backups.md)
1. (Facoltativo) Specifica una finestra di manutenzione. La *Maintenance window (Finestra di manutenzione)* è l'intervallo di tempo, generalmente un'ora a settimana, in cui ElastiCache pianifica la manutenzione di sistema per il cluster. Si può consentire a ElastiCache di scegliere l'ora e il giorno della finestra di manutenzione (*No preference (Nessuna preferenza)*) o sceglierne autonomamente il giorno, l'ora e la durata (*Specify maintenance window (Specifica finestra di manutenzione)*). Se dagli elenchi si sceglie *Specify maintenance window (Specifica finestra di manutenzione)*, selezionare *Start day (Giorno di inizio)*, *Start time (Ora di inizio)* e *Duration (Durata)* (in ore) per la finestra di manutenzione. Tutti gli orari sono UCT.
Per ulteriori informazioni, consulta [Gestione della manutenzione dei ElastiCache cluster](maintenance-window.md).
1. (Facoltativo) Per**Registro**:
+ In **Formato del registro**, scegliere **Text** o **JSON**.
+ In **Tipo di destinazione**, scegli **CloudWatch Logs** o **Kinesis Firehose**.
+ In **Destinazione log**, scegliete **Crea nuovo** e inserite il nome del gruppo di log CloudWatch Logs o il nome dello stream Firehose, oppure **scegliete Seleziona esistente e quindi scegliete** il nome del gruppo di log Logs o CloudWatch il nome dello stream Firehose,
1. Per quanto riguarda i **tag**, per aiutarti a gestire i tuoi cluster e altre ElastiCache risorse, puoi assegnare i tuoi metadati a ciascuna risorsa sotto forma di tag. Per ulteriori informazioni, consulta [Taggare le tue risorse ElastiCache](Tagging-Resources.md).
1. Scegli **Next (Successivo)**.
1. Riesaminare le voci e le selezioni, quindi apportare le eventuali correzioni. Al termine, scegli **Crea**.
------
#### [ On premises ]
1. Per **On-premise**, è preferibile lasciare abilitato il **Failover automatico**. Per ulteriori informazioni, consulta [Ridurre al minimo i tempi di inattività in ElastiCache ](AutoFailover.md) Redis OSS con Multi-AZ
1. Segui la procedura descritta in [Utilizzo di outpost](ElastiCache-Outposts.md).
------
Per creare l'equivalente utilizzando l' ElastiCache API o al AWS CLI posto della ElastiCache console, consulta quanto segue:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Non appena lo stato del cluster è *disponibile*, puoi concedere EC2 l'accesso al cluster, connetterti e iniziare a usarlo. Per ulteriori informazioni, consultare [Fase 3. Autorizza l'accesso al cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) e [Passaggio 4. Connect al nodo del cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene effettivamente utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
## Creazione di un cluster (AWS CLI)
Per creare un cluster utilizzando il AWS CLI, usa il `create-cache-cluster` comando.
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene effettivamente utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
### Creazione di un cluster (CLI) Valkey o Redis OSS (modalità cluster disabilitata)
**Example — Un cluster Valkey o Redis OSS (modalità cluster disabilitata) senza repliche di lettura**
Il seguente codice CLI crea un cluster Valkey o Redis OSS (modalità cluster disabilitata) senza repliche.
Quando si crea un cluster utilizzando un tipo di nodo della famiglia r6gd, è necessario passare il parametro `data-tiering-enabled`.
Per Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--cache-parameter-group default.redis6.x \
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
Per Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--cache-parameter-group default.redis6.x ^
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
### Creazione di un cluster Valkey o Redis OSS (modalità cluster abilitata) ()AWS CLI
I cluster Valkey o Redis OSS (modalità cluster enabled) (API/CLI: gruppi di replica) non possono essere creati utilizzando l'operazione. `create-cache-cluster` Per creare un cluster Valkey o Redis OSS (modalità cluster abilitata) (API/CLI: gruppo di replica), vedere. [Creazione da zero di un gruppo di replica Valkey o Redis OSS (Cluster Mode Enabled) ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
Per ulteriori informazioni, consulta l'argomento di riferimento.AWS CLI ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
## Creazione di un cluster per Valkey o Redis OSS (API) ElastiCache
Per creare un cluster utilizzando l' ElastiCache API, utilizza l'azione`CreateCacheCluster`.
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
**Topics**
+ [Creazione di un cluster (API) Valkey o Redis OSS (modalità cluster disabilitata) ElastiCache](#Clusters.Create.API.Redis)
+ [Creazione di un cluster in Valkey o Redis OSS (modalità cluster abilitata) (API) ElastiCache](#Clusters.Create.API.RedisCluster)
### Creazione di un cluster (API) Valkey o Redis OSS (modalità cluster disabilitata) ElastiCache
Il codice seguente crea un cluster (API) Valkey o Redis OSS (modalità cluster disabilitata). ElastiCache
Le interruzioni di riga vengono aggiunte per facilitare la lettura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&CacheParameterGroup=default.redis3.2
&Engine=redis
&EngineVersion=3.2.4
&NumCacheNodes=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SnapshotArns.member.1=arn%3Aaws%3As3%3A%3A%3AmyS3Bucket%2Fdump.rdb
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
### Creazione di un cluster in Valkey o Redis OSS (modalità cluster abilitata) (API) ElastiCache
I cluster Valkey o Redis OSS (modalità cluster enabled) (API/CLI: gruppi di replica) non possono essere creati utilizzando l'operazione. `CreateCacheCluster` Per creare un cluster Valkey o Redis OSS (modalità cluster abilitata) (API/CLI: gruppo di replica), vedere. [Creazione da zero di un gruppo di replica in Valkey o Redis OSS (Cluster Mode Enabled) (API) ElastiCache](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API)
Per ulteriori informazioni, consulta l'argomento di riferimento sulle API. ElastiCache [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
# Creazione di un cluster per Memcached
Gli esempi seguenti mostrano come creare un cluster utilizzando l'API Console di gestione AWSAWS CLI e ElastiCache .
## Creazione di un cluster Memcached (console)
Quando utilizzi il motore Memcached, Amazon ElastiCache supporta il partizionamento orizzontale dei dati su più nodi. Memcached permette l'individuazione automatica per non dover tenere traccia degli endpoint di ciascun nodo. Memcached monitora l'endpoint di ciascun nodo, aggiornando l'elenco degli endpoint man mano che i nodi vengono aggiunti e rimossi. Per interagire con il cluster, all'applicazione è sufficiente l'endpoint di configurazione.
Per creare un cluster Memcached tramite la console, segui i passaggi riportati in [Creazione di un cluster Valkey (modalità cluster disabilitata) (](Clusters.Create.md#Clusters.Create.CON.RedisCluster)console). Quando raggiungi la fase cinque, seleziona **Crea** cache Memcached.
Non appena lo stato del cluster è *disponibile*, puoi concedere ad Amazon EC2 l'accesso, connetterti e iniziare a utilizzarlo. Per ulteriori informazioni, consulta i passaggi simili [Fase 3. Autorizza l'accesso al cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) e[Passaggio 4. Connect al nodo del cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene effettivamente utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
## Creazione di un cluster (AWS CLI)
Per creare un cluster utilizzando il AWS CLI, utilizzare il `create-cache-cluster` comando.
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene effettivamente utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
### Creazione di un cluster di cache Memcached (AWS CLI)
Il seguente codice CLI crea un cluster Memcached con 3 nodi.
Per Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine memcached \
--engine-version 1.4.24 \
--cache-parameter-group default.memcached1.4 \
--num-cache-nodes 3
```
Per Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine memcached ^
--engine-version 1.4.24 ^
--cache-parameter-group default.memcached1.4 ^
--num-cache-nodes 3
```
## Creazione di un cluster per Memcached (API) ElastiCache
Per creare un cluster utilizzando l' ElastiCache API, usa l'azione`CreateCacheCluster`.
**Importante**
Non appena il cluster diventa disponibile, viene addebitata ogni ora o frazione di ora in cui il cluster è attivo, anche se non viene utilizzato. Per evitare di sostenere i costi del cluster, è necessario eliminarlo. Per informazioni, consulta [Eliminazione di un cluster in ElastiCache](Clusters.Delete.md).
**Topics**
+ [Creazione di un cluster Memcached (API) ElastiCache](#Clusters.Create.API.Memcached)
### Creazione di un cluster Memcached (API) ElastiCache
Il codice seguente crea un cluster Memcached con 3 nodi (API). ElastiCache
Le interruzioni di riga vengono aggiunte per facilitare la lettura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&Engine=memcached
&NumCacheNodes=3
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
# Visualizzazione dei dettagli di un ElastiCache cluster
È possibile visualizzare informazioni dettagliate su uno o più cluster utilizzando la ElastiCache console o AWS CLI l' ElastiCache API.
## Visualizzazione dei dettagli di un cluster Memcached (console)
È possibile visualizzare i dettagli di un cluster Memcached utilizzando la ElastiCache console, il AWS CLI for o l'API ElastiCache. ElastiCache
La procedura seguente descrive come visualizzare i dettagli di un cluster Memcached utilizzando la console. ElastiCache
**Per visualizzare i dettagli di un cluster Memcached**
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dall'elenco nell'angolo in alto a destra, scegli la AWS regione che ti interessa.
1. **Nella dashboard del ElastiCache motore, scegli Memcached.** In questo modo viene visualizzato un elenco di tutti i cluster in esecuzione sul motore Memcached.
1. Per visualizzare i dettagli di un cluster, scegliere la casella a sinistra del nome del cluster.
1. Per visualizzare informazioni sui nodi, scegli la scheda **Nodes** (Nodi), contenente le informazioni sullo stato dei nodi e sull'endpoint.
1. Per visualizzare le metriche, scegli la scheda **Metrics** (Metriche), contenente le metriche pertinenti per tutti i nodi del cluster. Per ulteriori informazioni, consulta [Monitoraggio dell'utilizzo con CloudWatch Metrics](CacheMetrics.md)
1. Scegli la scheda **Network and security** (Rete e sicurezza) per visualizzare i dettagli sulla connettività di rete del cluster e sulla configurazione del gruppo di sottoreti e sul gruppo di sicurezza VPC. Per ulteriori informazioni, consulta [Sottoreti e gruppi di sottoreti](SubnetGroups.md).
1. Scegli la scheda **Maintenance** (Manutenzione) per visualizzare i dettagli sulle impostazioni di manutenzione del cluster. Per ulteriori informazioni, consulta [Gestione della manutenzione dei ElastiCache cluster](maintenance-window.md).
1. Scegli la scheda **Tags** (Tag) per visualizzare i dettagli su tutti i tag applicati alle risorse del cluster. Per ulteriori informazioni, consulta [Taggare le tue risorse ElastiCache](Tagging-Resources.md).
## Visualizzazione dei dettagli di Valkey o Redis OSS (modalità cluster disabilitata) (console)
È possibile visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster disabilitata) utilizzando la ElastiCache console, il modulo o AWS CLI l'API ElastiCache. ElastiCache
La procedura seguente descrive come visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster disabilitata) utilizzando la console. ElastiCache
**Per visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster disabilitata)**
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nella dashboard del ElastiCache motore, scegli **Valkey** o **Redis OSS** per visualizzare un elenco di tutti i cluster in esecuzione su quel motore.
1. Per visualizzare i dettagli di un cluster, seleziona la casella di controllo a sinistra del nome del cluster. Assicurati di selezionare un cluster che esegue il motore Valkey o Redis OSS, non Clustered Valkey o Clustered Redis OSS. In questo modo vengono visualizzati i dettagli relativi al cluster, incluso l'endpoint primario del cluster.
1. Per visualizzare le informazioni del nodo:
1. Seleziona il nome del cluster.
1. Seleziona la scheda **Partizioni e nodi**. In questo modo vengono visualizzati i dettagli relativi a ciascun nodo, incluso l'endpoint del nodo che dovrai utilizzare per effettuare la lettura dal cluster.
1. Per visualizzare le metriche, scegli la scheda **Metrics** (Metriche), contenente le metriche pertinenti per tutti i nodi del cluster. Per ulteriori informazioni, consulta [Monitoraggio dell'utilizzo con CloudWatch Metrics](CacheMetrics.md)
1. Per visualizzare i log, scegli la scheda **Logs** (Log), che indica se il cluster utilizza i log lenti o i log del motore e fornisce i dettagli pertinenti. Per ulteriori informazioni, consulta [Consegna dei registri](Log_Delivery.md).
1. Scegli la scheda **Network and security** (Rete e sicurezza) per visualizzare i dettagli sulla connettività di rete del cluster e sulla configurazione del gruppo di sottoreti. Per ulteriori informazioni, consulta [Sottoreti e gruppi di sottoreti](SubnetGroups.md).
1. Scegli la scheda **Maintenance** (Manutenzione) per visualizzare i dettagli sulle impostazioni di manutenzione del cluster. Per ulteriori informazioni, consulta [Gestione della manutenzione dei ElastiCache cluster](maintenance-window.md).
1. Scegli la scheda **Service updates** (Aggiornamenti del servizio) per visualizzare i dettagli sugli eventuali aggiornamenti del servizio disponibili insieme all'applicazione per data consigliata. Per ulteriori informazioni, consulta [Aggiornamenti del servizio in ElastiCache](Self-Service-Updates.md).
1. Scegli la scheda **Tags** (Tag) per visualizzare i dettagli su tutti i tag applicati alle risorse del cluster. Per ulteriori informazioni, consulta [Taggare le tue risorse ElastiCache](Tagging-Resources.md).
## Visualizzazione dei dettagli per un cluster Valkey o Redis OSS (Cluster Mode Enabled) (Console)
È possibile visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster abilitata) utilizzando la ElastiCache console, il modulo o AWS CLI l'API ElastiCache. ElastiCache
La procedura seguente descrive come visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster abilitata) utilizzando la console. ElastiCache
**Per visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster abilitata)**
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dall'elenco nell'angolo in alto a destra, scegli la AWS regione che ti interessa.
1. Nella dashboard del ElastiCache motore, scegli **Valkey** o **Redis OSS** per visualizzare un elenco di tutti i cluster in esecuzione su quel motore.
1. Per visualizzare i dettagli di un cluster Valkey o Redis OSS (modalità cluster abilitata), scegli la casella a sinistra del nome del cluster. Assicurati di scegliere un cluster che esegue il motore OSS Valkey o Clustered Redis.
La schermata si espande al di sotto del cluster e ne mostra i dettagli, incluso l'endpoint di configurazione.
1. Per visualizzare un elenco delle partizioni del cluster e del numero dei nodi in ogni partizione, scegli la scheda **Shards and nodes** (Partizioni e nodi).
1. Per visualizzare informazioni specifiche su un nodo:
1. Scegliere l'ID della partizione.
In questo modo vengono visualizzate le informazioni relative a ciascun nodo, incluso l'endpoint, da utilizzare per effettuare la lettura dei dati dal cluster.
1. Per visualizzare le metriche, scegli la scheda **Metrics**(Parametri), contenente le metriche pertinenti per tutti i nodi del cluster. Per ulteriori informazioni, consulta [Monitoraggio dell'utilizzo con CloudWatch Metrics](CacheMetrics.md)
1. Per visualizzare i log, scegli la scheda **Logs** (Log), che indica se il cluster utilizza i log lenti o i log del motore e fornisce i dettagli pertinenti. Per ulteriori informazioni, consulta [Consegna dei registri](Log_Delivery.md).
1. Scegli la scheda **Network and security** (Rete e sicurezza) per visualizzare i dettagli sulla connettività di rete del cluster e sulla configurazione del gruppo di sottoreti e su quale metodo di crittografia è abilitato sul cluster. Per ulteriori informazioni, consultare [Sottoreti e gruppi di sottoreti](SubnetGroups.md) e [Sicurezza dei dati in Amazon ElastiCache](encryption.md).
1. Scegli la scheda **Maintenance** (Manutenzione) per visualizzare i dettagli sulle impostazioni di manutenzione del cluster. Per ulteriori informazioni, consulta [Gestione della manutenzione dei ElastiCache cluster](maintenance-window.md).
1. Scegli la scheda **Service updates** (Aggiornamenti del servizio) per visualizzare i dettagli sugli eventuali aggiornamenti del servizio disponibili insieme all'applicazione per data consigliata. Per ulteriori informazioni, consulta [Aggiornamenti del servizio in ElastiCache](Self-Service-Updates.md).
1. Scegli la scheda **Tags** (Tag) per visualizzare i dettagli su tutti i tag applicati alle risorse del cluster. Per ulteriori informazioni, consulta [Taggare le tue risorse ElastiCache](Tagging-Resources.md).
## Visualizzazione dei dettagli di un ElastiCache cluster ()AWS CLI
Il codice seguente elenca i dettagli per*my-cluster*:
```
aws elasticache describe-cache-clusters --cache-cluster-id my-cluster
```
Sostituiscilo *my-cluster* con il nome del cluster nel caso in cui il cluster venga creato con 1 nodo di cache e 0 shard utilizzando il `create-cache-cluster` comando.
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"Engine": "redis",
"PreferredMaintenanceWindow": "wed:12:00-wed:13:00",
"CacheSubnetGroupName": "default",
"SnapshotWindow": "08:30-09:30",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"CacheClusterId": "my-cluster1",
"CacheClusterCreateTime": "2018-02-26T21:06:43.420Z",
"PreferredAvailabilityZone": "us-west-2c",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"AutoMinorVersionUpgrade": true,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
]
}
```
Nel caso in cui il cluster venga creato utilizzando Console di gestione AWS (nodo del cluster abilitato o disabilitato con 1 o più shard), utilizza il comando seguente per descrivere i dettagli del cluster (sostituiscilo *my-cluster* con il nome del gruppo di replica (nome del cluster):
```
aws elasticache describe-replication-groups --replication-group-id my-cluster
```
Per ulteriori informazioni, consulta l'argomento AWS CLI per ElastiCache . [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html)
## Visualizzazione dei dettagli di un ElastiCache cluster (ElastiCache API)
È possibile visualizzare i dettagli di un cluster utilizzando l'`DescribeCacheClusters`azione ElastiCache API. Se il parametro `CacheClusterId` è incluso, vengono restituiti solo i dettagli relativi al cluster specificato. Se si omette il parametro `CacheClusterId`, vengono restituiti i dettagli relativi a più cluster, fino a un massimo di `MaxRecords` (valore di default 100). Il valore dei `MaxRecords` non può essere minore di 20 o maggiore di 100.
Il codice seguente consente di elencare i dettagli per `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Il codice seguente consente di elencare i dettagli per un massimo di 25 cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Per ulteriori informazioni, consulta l'argomento di riferimento sull' ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html).
# Modifica di un cluster ElastiCache
Oltre ad aggiungere o rimuovere nodi da un ElastiCache cluster, a volte è necessario apportare altre modifiche, ad esempio aggiungere un gruppo di sicurezza, modificare la finestra di manutenzione o un gruppo di parametri.
Consigliamo di impostare la finestra di manutenzione nel momento di utilizzo più basso. Potrebbe essere quindi necessario apportare modifiche di tanto in tanto.
Quando modifichi i parametri di un cluster, la modifica viene applicata al cluster immediatamente o dopo il riavvio del cluster. Ciò è valido se modifichi il gruppo dei parametri del cluster o un valore di parametro nel gruppo dei parametri del cluster. Per determinare quando viene applicata una particolare modifica ai parametri, **consultate la sezione Le modifiche hanno effetto** nella colonna **Dettagli** nelle tabelle relative a [Parametri Memcached specifici](ParameterGroups.Engine.md#ParameterGroups.Memcached)e [Parametri Valkey e Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis). Per ulteriori informazioni sul riavvio dei nodi del cluster, consulta [Riavvio dei nodi](nodes.rebooting.md).
## Usando il ElastiCache Console di gestione AWS
**Per modificare un cluster**
1. Accedi a Console di gestione AWS e apri la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dall'elenco nell'angolo in alto a destra, scegli la AWS regione in cui si trova il cluster che desideri modificare.
1. Nel riquadro di navigazione, scegliere il motore in esecuzione sul cluster da modificare.
Comparirà un elenco dei cluster che eseguono il motore selezionato.
1. Nell'elenco dei cluster, per il cluster che si desidera modificare, scegli il nome.
1. Scegliere **Actions (Operazioni)**, quindi **Modify (Modifica)**.
Comparirà la finestra **Modifica cluster**.
1. Nella finestra **Modify Cluster (Modifica cluster)**, apportare le modifiche desiderate. Le opzioni includono:
+ Descrizione
+ Modalità cluster: per modificare la modalità cluster da **Disabilitata** ad **Abilitata**, è necessario innanzitutto impostare la modalità cluster su **Compatibile**.
La modalità compatibile consente ai client Valkey o Redis OSS di connettersi utilizzando sia la modalità cluster abilitata che la modalità cluster disabilitata. **Dopo aver migrato tutti i client Valkey o Redis OSS per utilizzare la modalità cluster abilitata, è possibile completare la configurazione della modalità cluster e impostare la modalità cluster su Enabled.**
+ Compatibilità versione del motore
**Importante**
Puoi eseguire l'upgrade alle versioni più recenti del motore. Se si aggiornano le versioni principali del motore, ad esempio da 5.0.6 a 6.0, è necessario scegliere una famiglia di gruppi di parametri compatibile con la nuova versione del motore. Per ulteriori informazioni in merito, consulta [Gestione delle versioni per ElastiCache](VersionManagement.md). Tuttavia, non puoi eseguire il downgrade alle versioni precedenti del motore se non eliminando il cluster esistente e creandolo di nuovo.
+ Gruppi di sicurezza VPC
+ Gruppo di parametri
+ Tipo di nodo
**Nota**
Se il cluster utilizza un tipo di nodo della famiglia r6gd, è possibile scegliere solo una dimensione del nodo diversa da quella famiglia. Se si sceglie un tipo di nodo dalla famiglia r6gd, il tiering di dati verrà attivato automaticamente. Per ulteriori informazioni, consulta [Tiering di dati](data-tiering.md).
+ Multi-AZ
+ Failover automatico (solo modalità cluster disabilitata)
+ Abilitazione backup automatici.
+ Id nodo di backup
+ Periodo di retention dei backup
+ Finestra di backup
+ Argomento per la notifica SNS
+ Compatibilità della versione di Memcached Engine
+ Tipo di rete
**Nota**
Se si passa da IPv4 a IPv6, è necessario selezionare o creare gruppi di sottoreti compatibili con. IPv6 Per ulteriori informazioni, consulta [Scelta del tipo di rete in ElastiCache](network-type.md).
+ Gruppi di sicurezza VPC
+ Gruppo di parametri
+ Finestra di manutenzione
+ Argomento per la notifica SNS
La casella **Applica immediatamente** si applica solo alle modifiche alla versione del motore e al tipo di nodo. Per applicare immediatamente le modifiche, scegliere la casella di controllo **Apply Immediately (Applica immediatamente)**. Se non si seleziona questa casella, le modifiche apportate alle versioni del motore vengono applicate nella finestra di manutenzione successiva. Le altre modifiche, come quelle della finestra di manutenzione, vengono applicate immediatamente.
**Per enable/disable registrare la consegna per Redis**
1. Nell'elenco di cluster, scegliere quello da dimensionare. Seleziona **Cluster name (Nome del cluster)** e non la casella di controllo accanto ad essa.
1. Nella pagina dei **dettagli del cluster**, scegli la scheda **Registri.**
1. **Per abilitare o disabilitare gli slow log, scegli **Abilita o Disabilita.****
Se scegli l’abilitazione:
1. Sotto **Formato registro**, scegli **JSON** o **Testo**.
1. In **Tipo di destinazione del registro**, scegli **CloudWatch Logs o Kinesis** **Firehose**.
1. In **Destinazione del registro**, puoi scegliere **Crea nuovo** e inserire il nome del gruppo di CloudWatchLogs log o il nome dello stream Kinesis Data Firehose. Puoi anche scegliere **Seleziona esistente** e quindi scegliere il nome del gruppo di CloudWatchLogs log o il nome dello stream Kinesis Data Firehose.
1. Scegli **Abilita **.
**Per modificare la configurazione per Redis:**
1. Scegli **Modifica**.
1. Sotto **Formato registro**, scegli **JSON** o **Testo**.
1. In **Tipo di destinazione**, scegli **CloudWatch Logs** o **Kinesis Firehose**.
1. In **Destinazione del registro**, scegli **Crea nuovo** e inserisci il nome del gruppo di CloudWatchLogs log o il nome dello stream Kinesis Data Firehose. Oppure scegli **Seleziona esistente**, quindi scegli il nome del gruppo di CloudWatchLogs log o il nome dello stream Kinesis Data Firehose.
## Usare il con AWS CLI ElastiCache
È possibile modificare un cluster esistente utilizzando l' AWS CLI `modify-cache-cluster`operazione. Per modificare il valore di configurazione del cluster, specificare l'ID del cluster, il parametro da modificare e il nuovo valore del parametro. L'esempio seguente modifica la finestra di manutenzione di un cluster denominato `my-cluster` e applica immediatamente la modifica.
**Importante**
È possibile eseguire l'aggiornamento alle versioni più recenti del motore Memcached. Per ulteriori informazioni in merito, consulta [Gestione delle versioni per ElastiCache](VersionManagement.md). Tuttavia, non puoi eseguire il downgrade alle versioni precedenti del motore se non eliminando il cluster esistente e creandolo di nuovo.
**Importante**
È possibile eseguire l'aggiornamento alle versioni più recenti del motore Valkey o Redis OSS. Se si aggiornano le versioni principali del motore, ad esempio da Redis OSS 5.0.6 a Redis OSS 6.0, è necessario selezionare una famiglia di gruppi di parametri compatibile con la nuova versione del motore. Per ulteriori informazioni in merito, consulta [Gestione delle versioni per ElastiCache](VersionManagement.md). Tuttavia, non puoi eseguire il downgrade alle versioni precedenti del motore se non eliminando il cluster esistente e creandolo di nuovo.
Per Linux, macOS o Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Per Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Il parametro `--apply-immediately` si applica solo alle modifiche del tipo di nodi, della versione del motore e del numero dei nodi di un cluster. Se si desidera applicare immediatamente una di queste modifiche, utilizzare il parametro `--apply-immediately`. Se si preferisce posticipare queste modifiche alla prossima finestra di manutenzione, utilizzare il parametro `--no-apply-immediately`. Le altre modifiche, come quelle della finestra di manutenzione, vengono applicate immediatamente.
Per ulteriori informazioni, consultate l'argomento relativo al modulo. AWS CLI ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html)
## Utilizzo dell' ElastiCache API
È possibile modificare un cluster esistente utilizzando l'`ModifyCacheCluster`operazione ElastiCache API. Per modificare il valore di configurazione del cluster, specificare l'ID del cluster, il parametro da modificare e il nuovo valore del parametro. L'esempio seguente modifica la finestra di manutenzione di un cluster denominato `my-cluster` e applica immediatamente la modifica.
**Importante**
È possibile eseguire l'aggiornamento alle versioni più recenti del motore Memcached. Per ulteriori informazioni in merito, consulta [Gestione delle versioni per ElastiCache](VersionManagement.md). Tuttavia, non puoi eseguire il downgrade alle versioni precedenti del motore se non eliminando il cluster esistente e creandolo di nuovo.
**Importante**
È possibile eseguire l'aggiornamento alle versioni più recenti del motore Valkey o Redis OSS. Se si aggiornano le versioni principali del motore, ad esempio da Redis OSS 5.0.6 a Redis OSS 6.0, è necessario selezionare una famiglia di gruppi di parametri compatibile con la nuova versione del motore. Per ulteriori informazioni in merito, consulta [Gestione delle versioni per ElastiCache](VersionManagement.md). Tuttavia, non puoi eseguire il downgrade alle versioni precedenti del motore se non eliminando il cluster esistente e creandolo di nuovo.
Le interruzioni di riga vengono aggiunte per facilitare la lettura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150901T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150901T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Il parametro `ApplyImmediately` si applica solo alle modifiche del tipo di nodi, della versione del motore e del numero dei nodi di un cluster. Se si desidera applicare immediatamente una di queste modifiche, impostare il parametro `ApplyImmediately` su `true`. Se si preferisce posticipare queste modifiche alla prossima finestra di manutenzione, impostare il parametro `ApplyImmediately` su `false`. Le altre modifiche, come quelle della finestra di manutenzione, vengono applicate immediatamente.
Per ulteriori informazioni, consultate l'argomento di riferimento sulle API ElastiCache . [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)
# Aggiungere nodi a un ElastiCache cluster
L'aggiunta di nodi a un cluster Memcached aumenta il numero di partizioni del cluster. Quando si modifica il numero delle partizioni in un cluster, alcuni dei keyspace devono essere rimappati per essere mappati al nodo corretto. La rimappatura dei keyspace aumenta temporaneamente il numero di mancati riscontri nella cache sul cluster. Per ulteriori informazioni, consulta [Configurazione ElastiCache del client per un bilanciamento efficiente del carico (Memcached)](BestPractices.LoadBalancing.md).
Per riconfigurare il cluster Valkey o Redis OSS (modalità cluster abilitata), vedi [Scalabilità dei cluster Valkey o Redis OSS (Cluster Mode Enabled)](scaling-redis-cluster-mode-enabled.md)
È possibile utilizzare la console di ElastiCache gestione, l' ElastiCache API AWS CLI o l'API per aggiungere nodi al cluster.
## Utilizzando il ElastiCache Console di gestione AWS
Se desideri aggiungere un nodo a un cluster Valkey o Redis OSS (modalità cluster disabilitata) a nodo singolo (uno senza la replica abilitata), è necessario un processo in due fasi: prima aggiungi la replica e poi aggiungi un nodo di replica.
**Argomenti**
+ [Per aggiungere la replica a un cluster Valkey o Redis OSS senza shard](#AddReplication.CON)
+ [Per aggiungere nodi a un ElastiCache cluster (console)](#AddNode.CON)
La procedura seguente aggiunge la replica a un Valkey o Redis OSS a nodo singolo in cui la replica non è abilitata. Quando aggiungi la funzione di replica, il nodo esistente diventa quello primario nel cluster con replica abilitata. Dopo l'aggiunta della funzione di replica, puoi aggiungere al cluster fino a 5 nodi di replica.
**Per aggiungere la replica a un cluster Valkey o Redis OSS senza shard**
1. Accedi a Console di gestione AWS e apri la console all'indirizzo. ElastiCache [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. Dal pannello di navigazione, scegli i cluster **Valkey o i cluster** **Redis OSS**.
Viene visualizzato un elenco di cluster che eseguono quel motore.
1. Scegliere il nome di un cluster, non la casella alla sinistra del nome, a cui aggiungere i nodi.
Quanto segue è vero per un cluster Redis OSS che non ha la replica abilitata:
+ Esegue Redis OSS, non Clustered Redis OSS.
+ Non presenta partizioni.
Se nel cluster è presente qualche partizione, la funzione di replica è già abilitata e si può proseguire all'indirizzo [Per aggiungere nodi a un ElastiCache cluster (console)](#AddNode.CON).
1. Scegliere **Add replication (Aggiungi funzione di replica)**.
1. In **Add Replication (Aggiungi funzione di replica)**, digitare una descrizione del cluster con funzione di replica abilitata.
1. Scegliere **Aggiungi**.
Non appena lo stato del cluster ritorna *disponibile*, puoi passare alla procedura successiva e aggiungere repliche al cluster.
**Per aggiungere nodi a un ElastiCache cluster (console)**
La procedura seguente può essere utilizzata per aggiungere nodi a un cluster:
1. Accedi a Console di gestione AWS e apri la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione, scegliere il motore in esecuzione sul cluster a cui aggiungere nodi.
Viene visualizzato un elenco dei cluster che eseguono il motore scelto.
1. Dall'elenco dei cluster, per il cluster a cui si desidera aggiungere un nodo, sceglierne il nome.
Se il tuo cluster è un cluster Valkey o Redis OSS (modalità cluster abilitata), vedi. [Scalabilità dei cluster Valkey o Redis OSS (Cluster Mode Enabled)](scaling-redis-cluster-mode-enabled.md)
Se il tuo cluster è un cluster Valkey o Redis OSS (modalità cluster disabilitata) con zero shard, completa innanzitutto i passaggi seguenti. [Per aggiungere la replica a un cluster Valkey o Redis OSS senza shard](#AddReplication.CON)
1. Scegliere **Add node (Aggiungi nodo)**.
1. Compilare le informazioni richieste nella finestra di dialogo **Add Node (Aggiungi nodo)**.
1. Scegliere il pulsante **Apply Immediately - Yes (Applica immediatamente - Sì)** per aggiungere subito il nodo o **No** per aggiungere il nodo nella prossima finestra di manutenzione del cluster.
**Impatto delle nuove richieste di aggiunta e rimozione sulle richieste in sospeso**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/Clusters.AddNode.html)
Per determinare quali operazioni sono in sospeso, scegliere l'opzione**Description (Descrizione) ** e verificare quante creazioni o eliminazioni in sospeso vengono visualizzate. Non è possibile avere sia creazioni in sospeso che eliminazioni in sospeso.
1. Scegliere il pulsante **Add (Aggiungi)**.
Dopo qualche momento, nell'elenco dovrebbero comparire i nuovi nodi, con lo stato **creating (in fase di creazione)**. Se non compaiono, aggiornare la pagina del browser. Quando lo stato del nodo diventa *disponibile*, il nuovo nodo è pronto per l'uso.
## Usare il con AWS CLI ElastiCache
Per aggiungere nodi a un cluster utilizzando il AWS CLI, utilizzare l'AWS CLI operazione `modify-cache-cluster` con i seguenti parametri:
+ `--cache-cluster-id` L'ID del cluster a cui aggiungere nodi.
+ `--num-cache-nodes` Il parametro `--num-cache-nodes` specifica il numero di nodi nel cluster dopo l'applicazione della modifica. Per aggiungere nodi al cluster, `--num-cache-nodes` deve essere maggiore del numero attuale di nodi nel cluster. Se questo valore è inferiore al numero corrente di nodi, ElastiCache prevede la rimozione del parametro `cache-node-ids-to-remove` e di un elenco di nodi dal cluster. Per ulteriori informazioni, consulta [Usare il con AWS CLI ElastiCache](Clusters.DeleteNode.md#Clusters.DeleteNode.CLI).
+ `--apply-immediately` o `--no-apply-immediately`, che specificano se aggiungere i nodi subito o alla prossima finestra di manutenzione.
Per Linux, macOS o Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--num-cache-nodes 5 \
--apply-immediately
```
Per Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--num-cache-nodes 5 ^
--apply-immediately
```
Questa operazione genera un output simile al seguente (formato JSON):
```
{
"CacheCluster": {
"Engine": "memcached",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "my-cluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "rlh-mem000.7alc7bf-example.cfg.usw2.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-21T16:28:28.973Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {
"NumCacheNodes": 5
},
"PreferredMaintenanceWindow": "sat:09:00-sat:10:00",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
}
}
```
Per ulteriori informazioni, consulta l'AWS CLI argomento [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Usare il AWS CLI con ElastiCache
Se desideri aggiungere nodi a un cluster Valkey o Redis OSS (modalità cluster disabilitata) esistente che non ha la replica abilitata, devi prima creare il gruppo di replica specificando il cluster esistente come primario. Per ulteriori informazioni, consulta [Creazione di un gruppo di replica utilizzando un cluster Valkey o Redis OSS disponibile ()AWS CLI](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.CLI). Una volta che il gruppo di replica è *disponibile*, si può proseguire con il processo seguente.
Per aggiungere nodi a un cluster utilizzando il AWS CLI, utilizzate l'AWS CLI operazione `increase-replica-count` con i seguenti parametri:
+ `--replication-group-id`L'ID del gruppo di replica a cui aggiungere nodi.
+ `--new-replica-count` specifica il numero di nodi desiderati nel gruppo di replica dopo l'applicazione della modifica. Per aggiungere nodi al cluster, `--new-replica-count` deve essere maggiore del numero attuale di nodi nel cluster.
+ `--apply-immediately` o `--no-apply-immediately`, che specificano se aggiungere i nodi subito o alla prossima finestra di manutenzione.
Per Linux, macOS o Unix:
```
aws elasticache increase-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 4 \
--apply-immediately
```
Per Windows:
```
aws elasticache increase-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 4 ^
--apply-immediately
```
Questa operazione genera un output simile al seguente (formato JSON):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test",
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Per ulteriori informazioni, consulta l'AWS CLI argomento [https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html).
## Utilizzo dell' ElastiCache API
Se desideri aggiungere nodi a un cluster Valkey o Redis OSS (modalità cluster disabilitata) esistente che non ha la replica abilitata, devi prima creare il gruppo di replica specificando il cluster esistente come primario. Per ulteriori informazioni, consulta [Aggiungere repliche a un cluster (API) Valkey o Redis OSS (Cluster Mode Disabled) autonomo ElastiCache](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.API). Una volta che il gruppo di replica è *disponibile*, si può proseguire con il processo seguente.
**Per aggiungere nodi a un cluster (API) ElastiCache**
+ Chiamare l'operazione API `IncreaseReplicaCount` con i parametri seguenti:
+ `ReplicationGroupId` L'ID del cluster a cui aggiungere nodi.
+ `NewReplicaCount` Il parametro `NewReplicaCount` specifica il numero di nodi nel cluster dopo l'applicazione della modifica. Per aggiungere nodi al cluster, `NewReplicaCount` deve essere maggiore del numero attuale di nodi nel cluster. Se il valore è inferiore al numero attuale di nodi, utilizzare l’API `DecreaseReplicaCount` con un elenco di nodi da rimuovere dal cluster
+ `ApplyImmediately` Specifica se aggiungere i nodi subito o alla prossima finestra di manutenzione.
+ `Region`Specifica la AWS regione del cluster a cui si desidera aggiungere nodi.
L'esempio seguente mostra una chiamata per aggiungere nodi a un cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=true
&NumCacheNodes=4
&ReplicationGroupId=my-replication-group
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Per ulteriori informazioni, consulta ElastiCache l'argomento [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html)API.
## Utilizzo dell' ElastiCache API
**Per aggiungere nodi a un cluster (ElastiCache API)**
+ Chiamare l'operazione API `ModifyCacheCluster` con i parametri seguenti:
+ `CacheClusterId` L'ID del cluster a cui aggiungere nodi.
+ `NumCacheNodes` Il parametro `NumCachNodes` specifica il numero di nodi nel cluster dopo l'applicazione della modifica. Per aggiungere nodi al cluster, `NumCacheNodes` deve essere maggiore del numero attuale di nodi nel cluster. Se questo valore è inferiore al numero corrente di nodi, ElastiCache prevede che il parametro `CacheNodeIdsToRemove` con un elenco di nodi venga rimosso dal cluster (vedi[Utilizzo dell' ElastiCache API con Memcached](Clusters.DeleteNode.md#Clusters.DeleteNode.API)).
+ `ApplyImmediately` Specifica se aggiungere i nodi subito o alla prossima finestra di manutenzione.
+ `Region`Speciifica la AWS regione del cluster a cui si desidera aggiungere nodi.
L'esempio seguente mostra una chiamata per aggiungere nodi a un cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&NumCacheNodes=5
&CacheClusterId=my-cluster
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Per ulteriori informazioni, consulta ElastiCache l'argomento [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)API.
# Rimozione di nodi da un ElastiCache cluster
È possibile eliminare un nodo da un cluster Valkey, Memcached o Redis OSS utilizzando l'Console di gestione AWS, l'o l'API AWS CLI. ElastiCache
**Nota**
Ogni volta che si cambia il numero di nodi in un cluster Memcached, è necessario rimappare almeno una parte del keyspace in modo da mapparlo sul nodo corretto. Per informazioni più dettagliate sul bilanciamento del carico di un cluster Memcached, consulta [Configurazione ElastiCache del client per un bilanciamento efficiente del carico (Memcached)](BestPractices.LoadBalancing.md):
## Usando il ElastiCache Console di gestione AWS
**Per rimuovere nodi da un cluster (console)**
1. Accedi a Console di gestione AWS e apri la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Dall'elenco nell'angolo in alto a destra, scegli la AWS regione del cluster da cui desideri rimuovere i nodi.
1. Nel pannello di navigazione, scegliere il motore in esecuzione sul cluster da cui rimuovere un nodo.
Viene visualizzato un elenco dei cluster che eseguono il motore scelto.
1. Dall'elenco dei cluster, scegliere il nome del cluster da cui rimuovere un nodo.
Viene visualizzato un elenco dei nodi del cluster.
1. Scegliere la casella a sinistra dell'ID del nodo da rimuovere. Utilizzando la console ElastiCache si può eliminare solo un nodo alla volta, quindi se si selezionano più nodi il pulsante **Delete node (Elimina nodo)** non può essere utilizzato.
Viene visualizzata la pagina *Delete node (Elimina nodo)* .
1. Per eliminare il nodo, completare la pagina **Delete Node (Elimina nodo)** e scegliere **Delete Node (Elimina nodo)**. Per mantenere il nodo, scegliere **Cancel (Annulla)**.
**Importante**
**Con Valkey o Redis OSS, se stai eliminando i risultati del nodo nel cluster che non sono più conformi a Multi-AZ, assicurati di deselezionare prima la casella di controllo Multi-AZ e poi di eliminare il nodo.** Se si deseleziona la casella di controllo **Multi-AZ** è possibile scegliere di attivare la funzione **Auto failover (Failover automatico)**.
**Impatto delle nuove richieste di aggiunta e rimozione sulle richieste in sospeso**
| Scenari | Operazioni in sospeso | Nuova richiesta | Risultati |
| --- | --- | --- | --- |
| Scenario 1 | Elimina | Elimina | La nuova richiesta di eliminazione, in sospeso o immediata, sostituisce la richiesta di eliminazione in sospeso. Ad esempio, se i nodi 0001, 0003 e 0007 sono in attesa di eliminazione e viene emessa una nuova richiesta di eliminazione dei nodi 0002 e 0004, verranno eliminati solo i nodi 0002 e 0004. I nodi 0001, 0003 e 0007 non verranno eliminati. |
| Scenario 2 | Elimina | Crea | La nuova richiesta di creazione, in sospeso o immediata, sostituisce la richiesta di eliminazione in sospeso. Ad esempio, se i nodi 0001, 0003 e 0007 sono in attesa di eliminazione e viene emessa una nuova richiesta di creazione di un nodo, verrà creato un nuovo nodo e i nodi 0001, 0003 e 0007 non verranno eliminati. |
| Scenario 3 | Crea | Elimina | La nuova richiesta di eliminazione, in sospeso o immediata, sostituisce la richiesta di creazione in sospeso. Ad esempio, se è presente una richiesta in sospeso per creare due nodi e viene emessa una nuova richiesta per eliminare il nodo 0003, non verranno creati nuovi nodi e il nodo 0003 verrà eliminato. |
| Scenario 4 | Crea | Crea | La nuova richiesta di creazione viene aggiunta alla richiesta di creazione in sospeso. Ad esempio, se è presente una richiesta in sospeso per creare due nodi e viene emessa una nuova richiesta per creare tre nodi, le nuove richieste vengono aggiunte alla richiesta in sospeso e verranno creati cinque nodi. Se la nuova richiesta di creazione è impostata su**Applica immediatamente - Sì**, tutte le richieste di creazione vengono eseguite immediatamente. Se la nuova richiesta di creazione è impostata su**Applica immediatamente - No**, tutte le richieste di creazione sono in sospeso. |
Per determinare quali operazioni sono in sospeso, scegliere l'opzione**Description (Descrizione) ** e verificare quante creazioni o eliminazioni in sospeso vengono visualizzate. Non è possibile avere sia creazioni in sospeso che eliminazioni in sospeso.
## Usare il con AWS CLI ElastiCache
1. IDs Identifica i nodi che desideri rimuovere. Per ulteriori informazioni, consulta [Visualizzazione dei dettagli di un ElastiCache cluster](Clusters.ViewDetails.md).
1. Utilizzare l'operazione CLI `decrease-replica-count` con un elenco dei nodi da rimuovere, come nell'esempio seguente.
Per rimuovere nodi da un cluster tramite l'interfaccia a riga di comando, utilizzare il comando `decrease-replica-count` con i seguenti parametri:
+ `--replication-group-id` L'ID del gruppo di replica da cui rimuovere i nodi.
+ `--new-replica-count` Il parametro `--new-replica-count` specifica il numero di nodi nel cluster dopo l'applicazione della modifica.
+ `--replicas-to-remove`Un elenco di nodi IDs che desideri rimuovere da questo cluster.
+ `--apply-immediately` o `--no-apply-immediately` Specificano se rimuovere i nodi subito o alla prossima finestra di manutenzione.
+ `--region`Speciifica la AWS regione del cluster da cui si desidera rimuovere i nodi.
**Nota**
È possibile passare solo uno dei parametri `--replicas-to-remove` o `--new-replica-count` quando si chiama questa operazione.
Per Linux, macOS o Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 2 \
--region us-east-2 \
--apply-immediately
```
Per Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 3 ^
--region us-east-2 ^
--apply-immediately
```
Questa operazione genera un output simile al seguente (formato JSON):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test"
},
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005",
"node-test-006"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test-ro.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-004",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-004.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-005",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-005.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-006",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-006.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
In alternativa, puoi chiamare `decrease-replica-count` e invece di passare nel parametro `--new-replica-count`, è possibile passare il parametro `--replicas-to-remove`, come illustrato di seguito:
Per Linux, macOS o Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--replicas-to-remove node-test-003 \
--region us-east-2 \
--apply-immediately
```
Per Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--replicas-to-remove node-test-003 ^
--region us-east-2 ^
--apply-immediately
```
Per ulteriori informazioni, consulta gli AWS CLI argomenti [https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html).
## Utilizzo dell' ElastiCache API con Valkey o Redis OSS
Per rimuovere i nodi utilizzando l' ElastiCache API, richiamate l'operazione `DecreaseReplicaCount` API con l'ID del gruppo di replica e un elenco di nodi da rimuovere, come mostrato:
+ `ReplicationGroupId` L'ID del gruppo di replica da cui rimuovere i nodi.
+ `ReplicasToRemove` Il parametro `ReplicasToRemove` specifica il numero di nodi nel cluster dopo l'applicazione della modifica.
+ `ApplyImmediately` Specifica se rimuovere i nodi subito o alla prossima finestra di manutenzione.
+ `Region`Specificate la AWS regione del cluster da cui si desidera rimuovere un nodo.
L'esempio seguente rimuove immediatamente i nodi 0004 e 0005 dal cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ReplicationGroupId=my-replication-group
&ApplyImmediately=true
&ReplicasToRemove=node-test-003
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Per ulteriori informazioni, consulta ElastiCache l'argomento [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html)API.
## Utilizzo dell' ElastiCache API con Memcached
Per rimuovere i nodi utilizzando l' ElastiCache API, richiamate l'operazione `ModifyCacheCluster` API con l'ID del cluster di cache e un elenco di nodi da rimuovere, come mostrato:
+ `CacheClusterId`L'ID del cluster da cui desideri rimuovere i nodi.
+ `NumCacheNodes` Il parametro `NumCacheNodes` specifica il numero di nodi nel cluster dopo l'applicazione della modifica.
+ `CacheNodeIdsToRemove.member.n`L'elenco dei nodi IDs da rimuovere dal cluster.
+ `CacheNodeIdsToRemove.member.1=0004`
+ `CacheNodeIdsToRemove.member.1=0005`
+ `ApplyImmediately` Specifica se rimuovere i nodi subito o alla prossima finestra di manutenzione.
+ `Region`Specifica la AWS regione del cluster da cui si desidera rimuovere un nodo.
L'esempio seguente rimuove immediatamente i nodi 0004 e 0005 dal cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&ApplyImmediately=true
&CacheNodeIdsToRemove.member.1=0004
&CacheNodeIdsToRemove.member.2=0005
&NumCacheNodes=3
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Per ulteriori informazioni, consulta ElastiCache l'argomento [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)API.
# Annullamento delle operazioni di aggiunta o eliminazione dei nodi in sospeso in ElastiCache
Se si è scelto di non applicare immediatamente una modifica al ElastiCache cluster, l'operazione rimarrà **in sospeso** fino a quando non verrà eseguita nella finestra di manutenzione successiva. È possibile annullare qualsiasi operazione di aggiunta o eliminazione in sospeso.
Per annullare un'operazione di aggiunta o eliminazione di un nodo in sospeso con AWS CLI, utilizzare il `modify-cache-cluster` comando. Imposta un `num-cache-nodes` valore uguale al numero corrente di nodi di cache nel cluster, quindi aggiungi il `--apply-immediately` flag. Ciò sostituirà la modifica in sospeso.
Per annullare l'aggiunta o l'eliminazione di un nodo in sospeso:
```
aws elasticache modify-cache-cluster
--cache-cluster-id
--num-cache-nodes
--apply-immediately
```
Se non è chiaro se le aggiunte o le eliminazioni di nodi siano in sospeso, puoi confermarne lo stato con il comando: `describe-cache-clusters`
```
aws elasticache describe-cache-clusters
--cache-cluster-id
```
Tutti i nodi in sospeso dovrebbero apparire nell'output. `PendingModifiedValues` Per esempio:
```
"PendingModifiedValues": {
"NumCacheNodes": 3
},
```
# Eliminazione di un cluster in ElastiCache
Finché un ElastiCache cluster è *disponibile*, ti verrà addebitato un costo, indipendentemente dal fatto che tu lo stia utilizzando attivamente o meno. Per interrompere l'addebito, elimina il cluster.
**avvertimento**
Quando si elimina un ElastiCache cluster, le istantanee manuali vengono conservate. È inoltre possibile creare uno snapshot finale prima che il cluster venga eliminato. Gli snapshot di cache automatici non vengono conservati.
## Utilizzando il Console di gestione AWS
La procedura seguente elimina un solo cluster dalla distribuzione. Per eliminare più cluster, ripetere la procedura per ogni cluster da eliminare. Non occorre attendere la fine dell'eliminazione di un cluster prima di avviare la procedura per eliminarne un altro.
**Come eliminare un cluster**
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nella dashboard ElastiCache del motore, scegli il motore in esecuzione nel cluster che desideri eliminare.
Viene visualizzato un elenco di tutti i cluster che eseguono quel motore.
1. Per scegliere il cluster da eliminare, seleziona il nome del cluster nell'elenco di cluster.
**Importante**
Puoi eliminare solo un cluster alla volta dalla ElastiCache console. La selezione di più cluster disabilita l'operazione di eliminazione.
1. In **Actions (Azioni)**, scegliere **Delete (Elimina)**.
1. Nella schermata di conferma **Delete Cluster (Elimina cluster)**, scegliere **Delete (Elimina)** per eliminare il cluster o scegliere **Cancel (Annulla)** per mantenerlo.
Se si sceglie **Delete (Elimina)**, lo stato del cluster diventa *in fase di eliminazione*.
Non appena il cluster viene rimosso dall'elenco di cluster, non ti verranno più addebitati costi.
## Utilizzo di AWS CLI per eliminare un ElastiCache cluster
Il codice seguente elimina il ElastiCache cluster`my-cluster`.
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
L'azione `delete-cache-cluster` CLI elimina solo un cluster. Per eliminare più cluster, richiama ogni cluster `delete-cache-cluster` di cache che desideri eliminare. Non è necessario attendere il completamento dell'eliminazione di un cluster prima di eliminarne un altro.
Per Linux, macOS o Unix:
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
Per Windows:
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
Per ulteriori informazioni, vedere l'argomento AWS CLI per ElastiCache . [https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html)
## Utilizzo dell' ElastiCache API
Il seguente codice elimina il cluster `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheCluster
&CacheClusterId=my-cluster
&Region us-east-2
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150202T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
L'operazione `DeleteCacheCluster` API elimina solo un cluster. Per eliminare più cluster, richiama `DeleteCacheCluster` ogni cluster che desideri eliminare. Non è necessario attendere il completamento dell'eliminazione di un cluster prima di eliminarne un altro.
Per ulteriori informazioni, consulta l'argomento di riferimento sulle ElastiCache API. [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html)
# Accesso al ElastiCache cluster o al gruppo di replica
Le tue ElastiCache istanze Amazon sono progettate per essere accessibili tramite un' EC2 istanza Amazon.
Se hai avviato l' ElastiCache istanza in un Amazon Virtual Private Cloud (Amazon VPC), puoi accedere all' ElastiCacheistanza da un' EC2 istanza Amazon nello stesso Amazon VPC. Oppure, utilizzando il peering VPC, puoi accedere alla tua ElastiCache istanza da un Amazon EC2 in un altro Amazon VPC.
Se hai avviato l' ElastiCache istanza nella EC2 versione Classic, consenti all' EC2 istanza di accedere al tuo cluster concedendo al gruppo di EC2 sicurezza Amazon associato all'istanza l'accesso al tuo gruppo di sicurezza della cache. Per impostazione predefinita, l'accesso a un cluster è riservato all'account che lo ha avviato.
**Topics**
+ [Concedi l'accesso al cluster o gruppo di replica](#grant-access)
## Concedi l'accesso al cluster o gruppo di replica
### Hai lanciato il tuo cluster in EC2 -VPC
Se hai avviato il cluster in un Amazon Virtual Private Cloud (Amazon VPC), puoi connetterti al ElastiCache cluster solo da EC2 un'istanza Amazon in esecuzione nello stesso Amazon VPC. In questo caso sarà necessario concedere al cluster l'ingresso di rete.
**Nota**
Se si utilizza *Local Zones*, assicurarsi di averla abilitata. Per ulteriori informazioni, consulta [Abilitazione delle zone locali](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/using-regions-availability-zones.html#opt-in-local-zone). In questo modo, il VPC viene esteso a tale zona locale e il VPC tratterà la sottorete come qualsiasi sottorete in qualsiasi altra Zona di Disponibilità e gateway rilevanti, tabelle di instradamento e altre considerazioni sui gruppi di sicurezza.
**Per concedere l'ingresso di rete a un cluster da un gruppo di sicurezza Amazon VPC**
1. Accedi a Console di gestione AWS e apri la EC2 console Amazon all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, in **Rete e sicurezza**, scegli **Gruppi di sicurezza**.
1. Dall'elenco dei gruppi di sicurezza, scegli il gruppo di sicurezza per il VPC Amazon. A meno che tu non abbia creato un gruppo di sicurezza da ElastiCache utilizzare, questo gruppo di sicurezza verrà denominato *predefinito*.
1. Scegli la scheda **In entrata**, quindi procedi come segue:
1. Scegli **Modifica**.
1. Scegli **Aggiungi regola**.
1. Nella colonna **Tipo**, scegli **Regola TCP personalizzata**.
1. Nella casella **Intervallo porta**, digita il numero di porta per il nodo del cluster. Questo numero deve essere lo stesso specificato durante l'avvio del cluster. La porta predefinita per Memcached è **11211** La porta predefinita per Valkey e Redis OSS è. **6379**
1. Nella casella **Source**, scegli **Anywhere** con l'intervallo di porte (0.0.0.0/0) in modo che qualsiasi EC2 istanza Amazon che avvii all'interno del tuo Amazon VPC possa connettersi ai tuoi nodi. ElastiCache
**Importante**
L'apertura del ElastiCache cluster a 0.0.0.0/0 non espone il cluster a Internet perché non dispone di un indirizzo IP pubblico e pertanto non è accessibile dall'esterno del VPC. Tuttavia, il gruppo di sicurezza predefinito può essere applicato ad altre EC2 istanze Amazon nell'account del cliente e tali istanze possono avere un indirizzo IP pubblico. Se eseguono qualche attività sulla porta predefinita, il servizio può essere esposto involontariamente. Consigliamo quindi di creare un gruppo di sicurezza VPC che verrà utilizzato esclusivamente da ElastiCache. Per ulteriori informazioni, consulta [Gruppi di sicurezza personalizzati](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Scegli **Save** (Salva).
Quando avvii un' EC2 istanza Amazon nel tuo Amazon VPC, quell'istanza sarà in grado di connettersi al tuo ElastiCache cluster.
### Accesso alle ElastiCache risorse dall'esterno AWS
Amazon ElastiCache è un AWS servizio che fornisce un archivio chiave-valore in memoria basato sul cloud. Il servizio è progettato per essere accessibile esclusivamente dall'interno.AWS Tuttavia, se il ElastiCache cluster è ospitato all'interno di un VPC, puoi utilizzare un'istanza NAT (Network Address Translation) per fornire l'accesso esterno.
#### Requisiti
Per poter accedere alle ElastiCache risorse dall'esterno, è necessario soddisfare i seguenti requisiti:AWS
+ Il cluster deve risiedere all'interno di un VPC e deve essere possibile accedervi tramite un'istanza NAT (Network Address Translation). Non ci sono eccezioni a questo requisito.
+ L'istanza NAT deve essere avviata nello stesso VPC del cluster.
+ L'istanza NAT deve essere avviata nella sottorete pubblica separata dal cluster.
+ Un indirizzo IP elastico (EIP) deve essere associato all'istanza NAT. La funzionalità di inoltro della porta iptables viene utilizzata per inoltrare una porta nell'istanza NAT verso la porta del nodo di cache all'interno del VPC.
#### Considerazioni
Quando si accede alle risorse ElastiCache dall'esterno di ElastiCache, è necessario tenere presenti le seguenti considerazioni:
+ I client si connettono all'EIP e alla porta della cache dell'istanza NAT. Il port forwarding sull'istanza NAT inoltra il traffico al nodo del cluster appropriato.
+ Se un nodo cluster viene aggiunto o sostituito, le regole iptables devono essere aggiornate per riflettere questo cambiamento.
#### Limitazioni
Questo approccio deve essere utilizzato esclusivamente a scopo di sviluppo e test. Non è consigliato per essere utilizzato per la produzione a causa dei limiti seguenti:
+ L'istanza NAT agisce come proxy tra i client e più cluster. L'aggiunta di un proxy influisce sulle prestazioni del cluster. L'impatto aumenta con il numero di cluster a cui si accede tramite l'istanza NAT.
+ Il traffico dai client verso l'istanza NAT non è crittografato. Devi pertanto evitare l'invio di dati sensibili tramite l'istanza NAT.
+ L'istanza NAT aggiunge il sovraccarico della gestione di un'altra istanza.
+ L'istanza NAT viene utilizzata come singolo punto di errore. Per informazioni su come configurare l'elevata disponibilità per NAT su VPC, consulta [Elevata disponibilità per istanze NAT Amazon VPC: un esempio](https://aws.amazon.com/articles/2781451301784570).
#### Come accedere alle ElastiCache risorse dall'esterno AWS
La procedura seguente mostra come connettersi alle ElastiCache risorse utilizzando un'istanza NAT.
Questi passaggi presuppongono quanto segue:
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379`
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379`
Quindi, è necessario NAT nella direzione opposta:
`iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 10.0.0.55`
È inoltre necessario abilitare l'inoltro IP, che è disabilitato per impostazione predefinita:
`sudo sed -i 's/net.ipv4.ip_forward=0/net.ipv4.ip_forward=1/g' /etc/sysctl.conf sudo sysctl --system`
+ Stai accedendo a un cluster Memcached con:
+ Indirizzo IP: *10.0.1.230*
+ Porta Memcached predefinita: *11211*
+ Gruppo di sicurezza: *\$110\$1.0\$1.0\$1.55\$1*
+ Si accede a un cluster Valkey o Redis OSS con:
+ Indirizzo IP: *10.0.1.230*
+ *Porta predefinita: 6379*
+ Gruppo di sicurezza: *sg-bd56b7da*
+ AWS*indirizzo IP dell'istanza — 198.99.100.27*
+ L'indirizzo IP del client affidabile è *198.51.100.27*.
+ L'indirizzo IP elastico (EIP) dell'istanza NAT è *203.0.113.73*.
+ Il gruppo di sicurezza dell'istanza NAT è *sg-ce56b7a9*.
**Per connetterti alle tue ElastiCache risorse utilizzando un'istanza NAT**
1. Crea un'istanza NAT nello stesso VPC del cluster ma in una sottorete pubblica.
Per impostazione predefinita, la creazione guidata di VPC avvia un tipo di nodo *cache.m1.small*. È necessario selezionare una dimensione di nodo in base alle proprie esigenze: È necessario utilizzare EC2 NAT AMI per poter accedere ElastiCache dall'esterno AWS.
Per informazioni sulla creazione di un'istanza NAT, consulta [Istanze NAT nella Guida](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html) per l'utente VPC AWS.
1. Crea regole di gruppo di sicurezza per il cluster e l'istanza NAT.
Il gruppo di sicurezza per le istanze NAT e l'istanza del cluster devono essere associati alle seguenti regole:
+ Due regole in entrata
+ Con Memcached, la prima regola è consentire le connessioni TCP da client affidabili a ciascuna porta cache inoltrata dall'istanza NAT (11211 - 11213).
+ Con Valkey e Redis OSS, la prima regola è consentire le connessioni TCP da client affidabili a ciascuna porta cache inoltrata dall'istanza NAT (6379 - 6381).
+ Una seconda regola per consentire l'accesso SSH a client affidabili.
**Gruppo di sicurezza di istanze NAT: regole in entrata con Memcached**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/accessing-elasticache.html)
**Gruppo di sicurezza dell'istanza NAT: regole in entrata con Valkey o Redis OSS**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Memcached, una regola in uscita per consentire le connessioni TCP alla porta cache (11211).
**Gruppo di sicurezza per le istanze NAT - Regola in uscita**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Valkey o Redis OSS, una regola in uscita per consentire le connessioni TCP alla porta cache (6379).
**Gruppo di sicurezza per le istanze NAT - Regola in uscita**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Memcached, una regola in entrata per il gruppo di sicurezza del cluster che consente le connessioni TCP dall'istanza NAT alla porta cache (11211).
**Gruppo di sicurezza per le istanze del cluster - Regola in entrata**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Valkey o Redis OSS, una regola in entrata per il gruppo di sicurezza del cluster che consente le connessioni TCP dall'istanza NAT alla porta cache (6379).
**Gruppo di sicurezza per le istanze del cluster - Regola in entrata**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/accessing-elasticache.html)
1. Convalidare le regole.
+ Confermare che il client affidabile possa effettuare la connessione SSH all'istanza NAT.
+ Confermare che il client affidabile possa effettuare la connessione al cluster dall'istanza NAT.
1. **Memcached**
Aggiungere una regola iptables all'istanza NAT.
È necessario aggiungere una regola iptables alla tabella NAT per ogni nodo nel cluster per inoltrare la porta della cache dall'istanza NAT al nodo del cluster. Di seguito è riportato un possibile esempio:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
```
Il numero di porta deve essere univoco per ciascun nodo nel cluster. Ad esempio, se si utilizza un cluster Memcached a tre nodi tramite le porte 11211 - 11213, le regole avrebbero un aspetto simile al seguente:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11212 -j DNAT --to 10.0.1.231:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11213 -j DNAT --to 10.0.1.232:11211
```
Confermare che il client affidabile possa effettuare la connessione al cluster.
Il client affidabile deve connettersi all'EIP associato all'istanza NAT e alla porta del cluster corrispondente al nodo del cluster appropriato. Ad esempio, la stringa di connessione per PHP potrebbe apparire come segue:
```
$memcached->connect( '203.0.113.73', 11211 );
$memcached->connect( '203.0.113.73', 11212 );
$memcached->connect( '203.0.113.73', 11213 );
```
È anche possibile utilizzare un client telnet per verificare la connessione. Esempio:
```
telnet 203.0.113.73 11211
telnet 203.0.113.73 11212
telnet 203.0.113.73 11213
```
**Sistema operativo Valkey o Redis**
Aggiungere una regola iptables all'istanza NAT.
È necessario aggiungere una regola iptables alla tabella NAT per ogni nodo nel cluster per inoltrare la porta della cache dall'istanza NAT al nodo del cluster. Di seguito è riportato un possibile esempio:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
```
Il numero di porta deve essere univoco per ciascun nodo nel cluster. Ad esempio, se si lavora con un cluster Redis OSS a tre nodi utilizzando le porte 6379 - 6381, le regole sarebbero le seguenti:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379
```
Confermare che il client affidabile possa effettuare la connessione al cluster.
Il client affidabile deve connettersi all'EIP associato all'istanza NAT e alla porta del cluster corrispondente al nodo del cluster appropriato. Ad esempio, la stringa di connessione per PHP potrebbe apparire come segue:
```
redis->connect( '203.0.113.73', 6379 );
redis->connect( '203.0.113.73', 6380 );
redis->connect( '203.0.113.73', 6381 );
```
È anche possibile utilizzare un client telnet per verificare la connessione. Esempio:
```
telnet 203.0.113.73 6379
telnet 203.0.113.73 6380
telnet 203.0.113.73 6381
```
1. Salvare la configurazione iptables.
Salvare le regole dopo averle sottoposte a test e a verifica. Se si sta utilizzando una distribuzione Linux basata su Redhat (ad esempio Amazon Linux), eseguire questo comando:
```
service iptables save
```
#### Argomenti correlati
Negli argomenti seguenti vengono fornite informazioni aggiuntive.
+ [Modelli di accesso per l'accesso a una ElastiCache cache in un Amazon VPC](elasticache-vpc-accessing.md)
+ [Accesso a una ElastiCache cache da un'applicazione in esecuzione nel data center di un cliente](elasticache-vpc-accessing.md#elasticache-vpc-accessing-data-center)
+ [Istanze NAT](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+ [Configurazione dei client ElastiCache ](ClientConfig.md)
+ [Elevata disponibilità per istanze NAT Amazon VPC: un esempio](https://aws.amazon.com/articles/2781451301784570)
# Ricerca degli endpoint di connessione in ElastiCache
L'applicazione si connette al ElastiCache cluster utilizzando gli endpoint. Un endpoint corrisponde all'indirizzo univoco di un nodo o di un cluster.
Puoi anche stabilire una connessione privata tra gli endpoint VPC e ElastiCache API creando un'interfaccia VPC endpoint tramite. AWS PrivateLink Per ulteriori informazioni, consulta [ElastiCache Endpoint VPC di interfaccia e API ()AWS PrivateLink](elasticache-privatelink.md).
**Quali endpoint utilizzare con Valkey o Redis OSS.**
+ Per un **nodo autonomo**, usa l'endpoint del nodo per le operazioni di lettura e scrittura.
+ Per i cluster **Valkey o Valkey o Redis OSS (modalità cluster disabilitata)**, utilizza l'endpoint *primario* per tutte le operazioni di scrittura. Usa l'*endpoint di lettura* per dividere equamente le connessioni in arrivo verso l'endpoint tra tutte le repliche di lettura. I vari *endpoint di nodo* (definiti in ambiente API/CLI endpoint di lettura) vengono invece impiegati per le operazioni di lettura.
+ Per i cluster **Valkey o Redis OSS (modalità cluster abilitata), utilizza l'*endpoint di configurazione* del cluster per tutte le operazioni che supportano i** comandi abilitati in modalità cluster. È necessario utilizzare un client che supporti Valkey Cluster o Redis OSS Cluster su Redis OSS 3.2 e versioni successive. È comunque possibile leggere dagli endpoint dei singoli nodi (in API/CLI questi casi si parla di Read Endpoints).
Nelle sezioni seguenti è illustrato, fase per fase, il processo di individuazione degli endpoint necessari per il motore in esecuzione.
**Quali endpoint usare con Memcached.**
Per una **cache ElastiCache serverless per Memcached**, è sufficiente acquisire il DNS e la porta dell'endpoint del cluster dalla console.
Da AWS CLI, usa il `describe-serverless-caches` comando per acquisire le informazioni sull'endpoint.
Linux
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Windows
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
L'output dell'operazione precedente è simile al seguente (in formato JSON):
```
{
"ServerlessCaches": [
{
"ServerlessCacheName": "serverless-memcached",
"Description": "test",
"CreateTime": 1697659642.136,
"Status": "available",
"Engine": "memcached",
"MajorEngineVersion": "1.6",
"FullEngineVersion": "21",
"SecurityGroupIds": [
"sg-083eda453e1e51310"
],
"Endpoint": {
"Address": "serverless-memcached-01.amazonaws.com",
"Port":11211
},
"ARN": "",
"SubnetIds": [
"subnet-0cf759df15bd4dc65",
"subnet-09e1307e8f1560d17"
],
"SnapshotRetentionLimit": 0,
"DailySnapshotTime": "03:00"
}
]
}
```
Per un **cluster Memcached basato su istanze**, se si utilizza Automatic Discovery, è possibile utilizzare l'*endpoint di configurazione* del cluster per configurare il client Memcached. È necessario quindi utilizzare un client che supporti la funzione di individuazione automatica Auto Discovery.
In caso contrario, occorre configurare il client in modo che si avvalga degli endpoint di nodo individuali per le operazioni di lettura e scrittura. È necessario, inoltre, tenere traccia dei nodi eventualmente aggiunti o rimossi.
## Ricerca degli endpoint (console) del cluster Valkey o Redis OSS (modalità cluster disabilitata)
Se un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) ha un solo nodo, l'endpoint del nodo viene utilizzato sia per le letture che per le scritture. **Se un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) ha più nodi, esistono tre tipi di endpoint: l'endpoint *primario*, l'endpoint reader e gli endpoint del nodo.**
L'endpoint primario è un nome DNS che viene sempre risolto nel nodo primario nel cluster. L'endpoint primario è immune a modifiche al cluster, ad esempio la promozione di una replica di lettura al ruolo primario. Per attività di scrittura, è preferibile collegare le applicazioni all'endpoint primario.
Un endpoint di lettura suddividerà in modo uniforme le connessioni in entrata all'endpoint tra tutte le repliche di lettura in un cluster per Redis OSS. ElastiCache Ulteriori fattori come, ad esempio, quando l'applicazione crea le connessioni o il modo in cui l'applicazione riutilizza le connessioni determineranno la distribuzione del traffico. Gli endpoint di lettura mantengono le modifiche ai cluster in tempo reale mano a mano che le repliche vengono aggiunte o rimosse. È possibile posizionare le repliche di lettura multiple del cluster ElastiCache for Redis OSS in diverse zone di disponibilità (AZ) per garantire l'elevata AWS disponibilità degli endpoint di lettura.
**Nota**
Un endpoint di lettura non è un servizio di load balancer. Si tratta di un record DNS che si risolverà in un indirizzo IP di uno dei nodi di replica in modo round robin.
Per attività di lettura, le applicazioni possono inoltre connettersi a qualsiasi nodo nel cluster. A differenza dell'endpoint primario, gli endpoint dei nodi vengono risolti in endpoint specifici. Se apporti una modifica al cluster, ad esempio aggiungendo o eliminando una replica, devi aggiornare gli endpoint dei nodi nell'applicazione.
**Per trovare gli endpoint di un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)**
1. Accedi a Console di gestione AWS e apri la console all'indirizzo. ElastiCache [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. Dal pannello di navigazione, scegli i cluster **Valkey o i cluster** **Redis OSS**.
Apparirà la schermata dei cluster con un elenco di cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) e Valkey o Redis OSS (modalità cluster abilitata).
1. Per trovare gli endpoint Primary and/or Reader del cluster, scegli il nome del cluster (non il pulsante alla sua sinistra).
![\[Immagine: endpoint primario per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Endpoint primari e Reader per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)*
Se il cluster annovera un solo nodo, non c'è alcun endpoint primario e si può passare alla fase successiva.
1. **Se il cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) dispone di nodi di replica, puoi trovare gli endpoint del nodo di replica del cluster scegliendo il nome del cluster e quindi scegliendo la scheda Nodi.**
Così facendo, viene visualizzata una schermata con l'elenco di tutti i nodi del cluster, primario e di replica, e i relativi endpoint.
![\[Immagine: endpoint Node per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Endpoint di nodi per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)*
1. Per copiare un endpoint negli appunti:
1. Individua, uno alla volta, gli endpoint da copiare.
1. Scegli l'icona di copia direttamente davanti all'endpoint.
L'endpoint è stato correttamente copiato negli appunti. Per informazioni sull'utilizzo dell'endpoint per la connessione a un nodo, consulta [Connessione ai nodi Memcached](nodes-connecting.md#nodes-connecting.mem).
Un endpoint primario Valkey o Valkey o Redis OSS (modalità cluster disabilitata) ha un aspetto simile al seguente. Differisce in base all'avvenuta o mancata abilitazione della crittografia dati in transito.
**Crittografia dati in transito non abilitata**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**Crittografia dati in transito abilitata**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
## Ricerca degli endpoint per un cluster (console) Valkey o Redis OSS (modalità cluster abilitata)
Un cluster Valkey o Redis OSS (modalità cluster abilitata) ha un unico endpoint di configurazione. Connettendosi all'endpoint di configurazione, la tua applicazione è in grado di scoprire gli endpoint primari e di lettura per ognle partizioni del cluster.
**Per trovare l'endpoint di un cluster Valkey o Redis OSS (modalità cluster abilitata)**
1. Accedi a Console di gestione AWS e apri la console all' ElastiCache indirizzo. [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. Dal pannello di navigazione, scegli i cluster **Valkey o i cluster** **Redis OSS**.
Apparirà la schermata dei cluster con un elenco di cluster. Scegli il cluster a cui desideri connetterti.
1. Per trovare l'endpoint di configurazione del cluster, scegli il nome del cluster (non il pulsante di opzione).
1. L’**endpoint di configurazione** è visualizzato sotto **i dettagli del cluster**. Per copiarlo scegli l'icona *copia* a sinistra dell'endpoint.
## Individuazione degli endpoint di un cluster (console) (Memcached)
Tutti gli endpoint Memcached sono endpoint. read/write Per connettersi ai nodi in un cluster Memcached, l'applicazione può utilizzare gli endpoint di ciascun nodo o l'endpoint di configurazione del cluster, insieme all'individuazione automatica. Per avvalersi dell'individuazione automatica è necessario utilizzare un client che la supporti.
Con l'individuazione automatica, l'applicazione client si connette al cluster Memcached tramite l'endpoint di configurazione. Nel momento in cui si ridimensiona il cluster aggiungendo o rimuovendo nodi, l'applicazione viene automaticamente e immediatamente a "conoscenza" di tutti i nodi del cluster ed è in grado di connettersi a essi. Senza l'individuazione automatica, l'applicazione deve fare da sé o spetta all'utente aggiornare manualmente gli endpoint nell'applicazione, per ogni aggiunta o rimozione di un nodo.
Per copiare un endpoint, scegli l'icona di copia direttamente davanti all'indirizzo dell'endpoint. Per informazioni sull'utilizzo dell'endpoint per la connessione a un nodo, consulta [Connessione ai nodi Memcached](nodes-connecting.md#nodes-connecting.mem).
Gli endpoint di configurazione e dei nodi sono molto simili. Le differenze sono riportate di seguito in **grassetto**.
```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port # node endpoint for node 0001
```
**Importante**
Chi sceglie di impostare un CNAME come endpoint di configurazione Memcached, affinché il client dell'individuazione automatica lo riconosca come tale, deve includere `.cfg.` nel CNAME stesso.
## Individuazione degli endpoint (AWS CLI)
Per Memcached, puoi usare for AWS CLI Amazon ElastiCache per scoprire gli endpoint per nodi e cluster.
Per Redis OSS, puoi usare AWS CLI for Amazon ElastiCache per scoprire gli endpoint per nodi, cluster e anche gruppi di replica.
**Topics**
+ [Individuazione degli endpoint per nodi e cluster (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Individuazione degli endpoint per i gruppi di replica Valkey o Redis OSS ()AWS CLI](#Endpoints.Find.CLI.ReplGroups)
### Individuazione degli endpoint per nodi e cluster (AWS CLI)
Puoi usare il AWS CLI per scoprire gli endpoint di un cluster e dei suoi nodi con il comando. `describe-cache-clusters` Per i cluster Valkey o Redis OSS, il comando restituisce l'endpoint del cluster. Per i cluster Memcached, il comando restituisce l'endpoint di configurazione. Se si include il parametro facoltativo `--show-cache-node-info`, il comando restituisce, inoltre, gli endpoint dei vari nodi nel cluster.
**Example**
Il seguente comando recupera l'endpoint di configurazione (`ConfigurationEndpoint`) e gli endpoint dei singoli nodi (`Endpoint`) del cluster Memcached *mycluster*.
Per Linux, macOS o Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Per Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
L'output dell'operazione sopra indicata dovrebbe essere simile a questo (in formato JSON).
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0003",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-22T21:30:29.967Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 3,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "mon:09:00-mon:10:00",
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled"
}
]
}
```
Chi sceglie di impostare un CNAME come endpoint di configurazione Memcached, affinché il client dell'individuazione automatica lo riconosca come tale, deve includere `.cfg.` nel CNAME stesso. Ad esempio, `mycluster.cfg.local` nel file php.ini per il parametro `session.save_path`.
**Example**
*Per Valkey e Redis OSS, il comando seguente recupera le informazioni sul cluster per il cluster a nodo singolo mycluster.*
Il parametro `--cache-cluster-id` può essere utilizzato con ID cluster Valkey o Redis OSS (modalità cluster disabilitata) a nodo singolo o ID di nodo specifici nei gruppi di replica. Il valore `--cache-cluster-id` di un gruppo di replica è un valore a 4 cifre come. `0001` Se `--cache-cluster-id` è l'id di un cluster (nodo) in un gruppo di replica, `replication-group-id` viene incluso nell'output.
Per Linux, macOS o Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id redis-cluster \
--show-cache-node-info
```
Per Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id redis-cluster ^
--show-cache-node-info
```
L'output dell'operazione sopra indicata dovrebbe essere simile a questo (in formato JSON).
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"SecurityGroupId": "sg-77186e0d",
"Status": "active"
}
],
"CacheNodes": [
{
"CustomerAvailabilityZone": "us-east-1b",
"CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
"CacheNodeStatus": "available",
"CacheNodeId": "0001",
"Endpoint": {
"Address": "redis-cluster.amazonaws.com",
"Port": 6379
},
"ParameterGroupStatus": "in-sync"
}
],
"AtRestEncryptionEnabled": false,
"CacheClusterId": "redis-cluster",
"TransitEncryptionEnabled": false,
"CacheParameterGroup": {
"ParameterApplyStatus": "in-sync",
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis3.2"
},
"NumCacheNodes": 1,
"PreferredAvailabilityZone": "us-east-1b",
"AutoMinorVersionUpgrade": true,
"Engine": "redis",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
"CacheSecurityGroups": [],
"CacheSubnetGroupName": "default",
"CacheNodeType": "cache.t2.small",
"DataTiering": "disabled"
"EngineVersion": "3.2.10",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
}
]
}
```
Per ulteriori informazioni, consulta l'argomento [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
### Individuazione degli endpoint per i gruppi di replica Valkey o Redis OSS ()AWS CLI
È possibile utilizzare il AWS CLI per scoprire gli endpoint di un gruppo di replica e dei relativi cluster con il comando. `describe-replication-groups` Il comando restituisce l'endpoint primario del gruppo di replica e l'elenco di tutti i cluster (nodi) nel gruppo di replica con i loro endpoint insieme all'endpoint di lettura.
L'operazione seguente recupera l'endpoint primario e l'endpoint di lettura per il gruppo di replica `myreplgroup`. Utilizza l'endpoint primario per tutte le operazioni di scrittura.
```
aws elasticache describe-replication-groups \
--replication-group-id myreplgroup
```
Per Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id myreplgroup
```
L'aspetto dell'output di questa operazione è simile al seguente (in formato JSON).
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-001.amazonaws.com"
},
"CacheClusterId": "myreplgroup-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-002.amazonaws.com"
},
"CacheClusterId": "myreplgroup-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-003.amazonaws.com"
},
"CacheClusterId": "myreplgroup-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "myreplgroup.amazonaws.com"
},
"ReaderEndpoint": {
"Port": 6379,
"Address": "myreplgroup-ro.amazonaws.com"
}
}
],
"ReplicationGroupId": "myreplgroup",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "myreplgroup-002",
"MemberClusters": [
"myreplgroup-001",
"myreplgroup-002",
"myreplgroup-003"
],
"PendingModifiedValues": {}
}
]
}
```
Per ulteriori informazioni, consulta la sezione [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) nella *Documentazione di riferimento della AWS CLI *.
## Ricerca degli endpoint (API) ElastiCache
Per Memcached, puoi utilizzare l' ElastiCache API Amazon per scoprire gli endpoint per nodi e cluster.
Per Redis OSS, puoi utilizzare l' ElastiCache API Amazon per scoprire gli endpoint per nodi, cluster e anche gruppi di replica.
**Topics**
+ [Ricerca di endpoint per nodi e cluster (API) ElastiCache](#Endpoints.Find.API.Nodes)
+ [Ricerca di endpoint per Valkey o Redis OSS Replication Groups (API) ElastiCache](#Endpoints.Find.API.ReplGroups)
### Ricerca di endpoint per nodi e cluster (API) ElastiCache
Puoi utilizzare l' ElastiCache API per scoprire gli endpoint di un cluster e dei relativi nodi con l'azione. `DescribeCacheClusters` Per i cluster Valkey o Redis OSS, il comando restituisce l'endpoint del cluster. Per i cluster Memcached, il comando restituisce l'endpoint di configurazione. Se si include il parametro facoltativo `ShowCacheNodeInfo`, l'operazione restituisce, inoltre, gli endpoint dei vari nodi nel cluster.
**Example**
*Per Memcached, il comando seguente recupera l'endpoint di configurazione (`ConfigurationEndpoint`) e gli endpoint dei singoli nodi () per il cluster Memcached mycluster. `Endpoint`*
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=mycluster
&ShowCacheNodeInfo=true
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Chi sceglie di impostare un CNAME come endpoint di configurazione Memcached, affinché il client dell'individuazione automatica lo riconosca come tale, deve includere `.cfg.` nel CNAME stesso. Ad esempio, `mycluster.cfg.local` nel file php.ini per il parametro `session.save_path`.
### Ricerca di endpoint per Valkey o Redis OSS Replication Groups (API) ElastiCache
È possibile utilizzare l' ElastiCache API per scoprire gli endpoint di un gruppo di replica e dei relativi cluster con l'azione. `DescribeReplicationGroups` Il comando restituisce l'endpoint primario del gruppo di replica e l'elenco di tutti i cluster nel gruppo di replica con i loro endpoint insieme all'endpoint di lettura.
La seguente operazione recupera l'endpoint primario (PrimaryEndpoint), l'endpoint del lettore () e gli endpoint dei singoli nodi (ReaderEndpoint) per il gruppo di replica. ReadEndpoint `myreplgroup` Utilizza l'endpoint primario per tutte le operazioni di scrittura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myreplgroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Per ulteriori informazioni, consulta [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html).
# Lavorare con i frammenti in ElastiCache
Uno shard (API/CLI: node group) è una raccolta da uno a sei ElastiCache per i nodi Valkey o Redis OSS. Un cluster Valkey o Redis OSS (modalità cluster disabilitata) non avrà mai più di uno shard. Con gli shard, puoi separare i database di grandi dimensioni in parti più piccole, più veloci e più facili da gestire, chiamate frammenti di dati. Ciò può aumentare l'efficienza del database distribuendo le operazioni su più sezioni separate. L'utilizzo degli shard può offrire molti vantaggi, tra cui miglioramento delle prestazioni, della scalabilità e dell'efficienza dei costi.
Puoi creare un cluster con un numero più alto dle partizioni e un numero più basso di repliche per un totale di 90 nodi per cluster. Questa configurazione del cluster può andare da 90 partizioni e 0 repliche a 15 partizioni e 5 repliche che è il numero massimo consentito di repliche. I dati del cluster vengono partizionati tra gli shard del cluster. Se in uno shard è presente più di un nodo, lo shard implementa la replica con un nodo come nodo read/write principale e gli altri nodi come nodi di replica di sola lettura.
Il limite di nodi o shard può essere aumentato fino a un massimo di 500 per cluster se la versione del motore è Valkey 7.2 o superiore o Redis OSS da 5.0.6 a 7.1. Ad esempio, è possibile scegliere di configurare un cluster a 500 nodi che varia tra 83 partizioni (un primario e 5 repliche per partizione) e 500 partizioni (un singolo primario e nessuna replica). Assicurati che esistano abbastanza indirizzi IP disponibili per soddisfare l'aumento. Le problematiche comuni sono che le le sottoreti nel gruppo di sottoreti hanno un intervallo CIDR troppo piccolo o che le sottoreti sono condivise e utilizzate pesantemente da altri cluster. Per ulteriori informazioni, consulta [Creazione di un gruppo di sottoreti](SubnetGroups.Creating.md).
Per le versioni inferiori alla 5.0.6, il limite è 250 per cluster.
Per richiedere un aumento dei limiti, consulta [AWS Limiti dei servizi AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) e seleziona il tipo di limite **Nodi per cluster per tipo di istanza**.
Quando si crea un cluster Valkey o Redis OSS (modalità cluster abilitata) utilizzando la ElastiCache console, si specifica il numero di shard nel cluster e il numero di nodi negli shard. Per ulteriori informazioni, consulta [Creazione di un cluster Valkey o Redis OSS (modalità cluster abilitata) (Console)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Se utilizzi l' ElastiCache API o AWS CLI per creare un cluster (chiamato gruppo di *replica nel gruppo* di nodiAPI/CLI), you can configure the number of nodes in a shard (API/CLI:) in modo indipendente. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Ogni nodo in uno shard presenta le stesse specifiche di calcolo, storage e memoria. L' ElastiCache API consente di controllare gli attributi a livello di shard, come il numero di nodi, le impostazioni di sicurezza e le finestre di manutenzione del sistema.
![\[Immagine: configurazioni di shard OSS Valkey o Redis.\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisShards.png)
*Configurazioni degli shard OSS Valkey o Redis*
Per ulteriori informazioni, consultare [Resharding offline per Valkey o Redis OSS (modalità cluster abilitata)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-offline) e [Resharding online per Valkey o Redis OSS (modalità cluster abilitata)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online).
## Ricerca dell'ID di uno shard
Puoi trovare l'ID di uno shard utilizzando Console di gestione AWS, the o l'API. AWS CLI ElastiCache
### Usando il Console di gestione AWS
**Topics**
+ [Per Valkey o Redis OSS (modalità cluster disabilitata)](#shard-find-id-con-classic)
+ [Per Valkey o Redis OSS (modalità cluster abilitata)](#shard-find-id-con-cluster)
#### Per Valkey o Redis OSS (modalità cluster disabilitata)
Gli shard del gruppo di replica Valkey o Redis OSS (modalità cluster disabilitata) sono sempre disponibili. IDs `0001`
#### Per Valkey o Redis OSS (modalità cluster abilitata)
La procedura seguente utilizza il Console di gestione AWS per trovare l'ID shard del gruppo di replica di Valkey o Redis OSS (modalità cluster abilitata).
**Per trovare l'ID dello shard in un gruppo di replica Valkey o Redis OSS (modalità cluster abilitata)**
1. Accedi a Console di gestione AWS e apri la console all'indirizzo. ElastiCache [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. Nel pannello di navigazione, scegli **Valkey** o **Redis OSS**, quindi scegli il nome del gruppo di replica Valkey o Redis OSS (modalità cluster abilitata) per cui desideri trovare lo shard. IDs
1. Nella colonna **Shard Name (Nome shard)**, l'ID shard sono le ultime quattro cifre del nome dello shard.
### Usando il AWS CLI
Per trovare gli ID degli shard (gruppo di nodi) per i gruppi di replica Valkey o Redis OSS (modalità cluster disabilitata) o Valkey o Redis OSS (modalità cluster abilitata), utilizzate l' AWS CLI operazione `describe-replication-groups` con il seguente parametro opzionale.
+ **`--replication-group-id`**- Parametro facoltativo che, se utilizzato, limita l'output ai dettagli del gruppo di replica specificato. Se si omette il parametro, vengono restituiti i dettagli di un massimo di 100 gruppi di replica.
**Example**
Questo comando restituisce i dettagli per `sample-repl-group`.
Per Linux, macOS o Unix:
```
aws elasticache describe-replication-groups \
--replication-group-id sample-repl-group
```
Per Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id sample-repl-group
```
L'aspetto dell'output di questo comando è simile al seguente. Gli ID shard (gruppo di nodi) sono *highlighted* qui per facilitarne la ricerca.
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "sample-repl-group.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
]
}
```
### Utilizzo dell'API ElastiCache
Per trovare gli ID degli shard (gruppo di nodi) per i gruppi di replica Valkey o Redis OSS (modalità cluster disabilitata) o Valkey o Redis OSS (modalità cluster abilitata), utilizzate l' AWS CLI operazione `describe-replication-groups` con il seguente parametro opzionale.
+ **`ReplicationGroupId`**- Parametro facoltativo che, se utilizzato, limita l'output ai dettagli del gruppo di replica specificato. Se questo parametro viene omesso, vengono restituiti i dettagli di un massimo di gruppi di replica. *xxx*
**Example**
Questo comando restituisce i dettagli per `sample-repl-group`.
Per Linux, macOS o Unix:
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroup
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```