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à.
# Dimensionamento
Raramente la quantità dei dati che un'applicazione deve elaborare è statica. Aumenta e diminuisce secondo le fluttuazioni della domanda del tuo business. Se gestisci autonomamente le tue applicazioni, devi fornire hardware sufficiente per i picchi di domanda, il che può essere costoso. Utilizzando MemoryDB è possibile scalare per soddisfare la domanda attuale, pagando solo per ciò che si utilizza.
I contenuti seguenti ti danno la possibilità di trovare l'argomento adatto alle operazioni di scalabilità di tuo interesse.
**Ridimensionamento di MemoryDB**
| Azione | MemoryDB |
| --- | --- |
| Dimensionamento orizzontale | [Resharding online per MemoryDB](cluster-resharding-online.md) |
| Modifica dei tipi di nodo | [Ridimensionamento verticale online tramite la modifica del tipo di nodo](cluster-vertical-scaling.md) |
| Modifica del numero di frammenti | [Scalabilità dei cluster MemoryDB](scaling-cluster.md) |
# Scalabilità dei cluster MemoryDB
Man mano che la domanda dei cluster cambia, potresti decidere di migliorare le prestazioni o ridurre i costi modificando il numero di shard nel cluster MemoryDB. Per questa operazione si consiglia di utilizzare il dimensionamento orizzontale online, poiché consente ai cluster di continuare a servire le richieste durante il processo di dimensionamento.
È possibile decidere di ridimensionare il cluster in presenza delle seguenti condizioni:
+ **Utilizzo elevato di memoria:**
Se i nodi nel cluster sono sottoposti a utilizzo elevato di memoria, è possibile decidere di aumentare le dimensioni per disporre delle risorse necessarie per migliorare l'archiviazione dei dati e servire le richieste.
*Puoi determinare se i tuoi nodi sono sotto pressione in termini di memoria monitorando le seguenti metriche: *FreeableMemory*, e DB. *SwapUsage*BytesUsedForMemory*
+ **Collo di bottiglia della CPU o della rete:**
Se i latency/throughput problemi affliggono il cluster, potrebbe essere necessario eseguire una scalabilità orizzontale per risolverli.
Puoi monitorare i livelli di latenza e velocità effettiva monitorando le seguenti metriche: *CPUUtilization*,,, *NetworkBytesIn*e. *NetworkBytesOut*CurrConnections*NewConnections***
+ **Il cluster è sovradimensionato:**
La domanda corrente sul cluster è tale che la riduzione delle dimensioni non compromette le prestazioni e riduce i costi.
È possibile monitorare l'utilizzo del cluster per determinare se è possibile scalare in sicurezza o meno utilizzando le seguenti metriche: *FreeableMemory*,, *BytesUsedForMemoryDB *SwapUsage**,, *CPUUtilization*NetworkBytesIn**, *NetworkBytesOut*e. *CurrConnections*NewConnections**
**Impatto del dimensionamento sulle prestazioni**
Quando si effettua il dimensionamento utilizzando il processo offline, il cluster è offline per una porzione significativa del processo, pertanto non è disponibile per servire le richieste. Quando si effettua il dimensionamento utilizzando il metodo online, poiché il dimensionamento è un'operazione di calcolo intensiva, si registra un peggioramento delle prestazioni ma, nonostante tutto, il cluster continua a servire richieste mediante l'operazione di scalabilità. Il livello di peggioramento riscontrato dipende dall'utilizzo normale della CPU e dai dati.
Esistono due modi per scalare il cluster MemoryDB: scalabilità orizzontale e verticale.
+ Il ridimensionamento orizzontale consente di modificare il numero di shard nel cluster aggiungendo o rimuovendo shard. Il processo di resharding online consente la scalabilità in/out mentre il cluster continua a soddisfare le richieste in arrivo.
+ Ridimensionamento verticale: ridimensiona il cluster tramite la modifica del tipo di nodo. La scalabilità verticale online consente la scalabilità up/down mentre il cluster continua a soddisfare le richieste in arrivo.
Se state riducendo le dimensioni e la capacità di memoria del cluster, mediante una scalabilità verso l'alto o verso il basso, assicuratevi che la nuova configurazione disponga di memoria sufficiente per i dati e il sovraccarico del motore.
# Risharding offline per MemoryDB
Il vantaggio principale che si ottiene dalla riconfigurazione offline degli shard è che è possibile fare molto di più che aggiungere o rimuovere shard dal cluster. Quando esegui una nuova shard offline, oltre a modificare il numero di shard nel cluster, puoi fare quanto segue:
+ Cambia il tipo di nodo del cluster.
+ Effettuare l'upgrade a una versione del motore più recente.
**Nota**
Il resharding offline non è supportato nei cluster con la suddivisione dei dati su più livelli abilitata. Per ulteriori informazioni, consulta [Tiering di dati](data-tiering.md)..
Lo svantaggio principale della riconfigurazione shard offline è che il cluster è offline a partire dalla fase di ripristino del processo e continua a essere offline fino agli aggiornamenti degli endpoint nell'applicazione. Il periodo di tempo in cui il cluster rimane offline dipende dalla quantità di dati nel cluster.
**Per riconfigurare offline il cluster Shards MemoryDB**
1. Crea un'istantanea manuale del tuo cluster MemoryDB esistente. Per ulteriori informazioni, consulta [Creazione di istantanee manuali](snapshots-manual.md).
1. Crea un nuovo cluster eseguendo il ripristino dalla snapshot. Per ulteriori informazioni, consulta [Ripristino da uno snapshot](snapshots-restoring.md).
1. Aggiornare gli endpoint nell'applicazione agli endpoint del nuovo cluster. Per ulteriori informazioni, consulta [Individuazione degli endpoint di connessione](endpoints.md).
# Resharding online per MemoryDB
Utilizzando il resharding online e con MemoryDB, puoi scalare MemoryDB in modo dinamico senza tempi di inattività. Questo approccio indica che il cluster può continuare a servire le richieste anche durante il dimensionamento o il ribilanciamento.
È possibile effettuare le seguenti operazioni:
+ **Scalabilità** orizzontale: aumenta la capacità di lettura e scrittura aggiungendo shard al cluster MemoryDB.
Se aggiungi uno o più shard al cluster, il numero di nodi in ogni nuovo shard è uguale al numero di nodi nel più piccolo degli shard esistenti.
+ **Scalabilità**: riduci la capacità di lettura e scrittura, e quindi i costi, rimuovendo gli shard dal cluster MemoryDB.
Attualmente, le seguenti limitazioni si applicano al resharding online di MemoryDB:
+ Gli slot, gli spazi chiave e gli elementi grandi prevedono delle limitazioni:
Se una delle chiavi di uno shard contiene un elemento di grandi dimensioni, tale chiave non viene migrata su un nuovo shard durante la scalabilità orizzontale. Questa caratteristicapuò produrre partizioni non bilanciati.
Se alcune chiavi in una partizione contengono un elemento grande (di dimensioni superiori a 256 MB dopo la serializzazione), quella partizione non viene eliminato se le dimensioni diminuiscono. Con questa caratteristicaalcunle partizioni potrebbero non essere eliminati.
+ Durante la scalabilità orizzontale, il numero di nodi in ogni nuovo shard è uguale al numero di nodi negli shard esistenti.
Per ulteriori informazioni, consulta [Best practice. Dimensionamento di cluster online](best-practices-online-resharding.md).
È possibile ridimensionare orizzontalmente i cluster di MemoryDB utilizzando, the e l'API MemoryDB. Console di gestione AWS AWS CLI
## Aggiunta dele partizioni con il resharding online
È possibile aggiungere shard al cluster MemoryDB utilizzando l'API, o MemoryDB. Console di gestione AWS AWS CLI
### Aggiunta dle partizioni (Console)
È possibile utilizzare il Console di gestione AWS per aggiungere uno o più shard al cluster MemoryDB. Questo processo viene descritto di seguito.
****
1. Accedi Console di gestione AWS e apri la console MemoryDB all'indirizzo. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dall'elenco dei cluster, scegli il nome del cluster da cui desideri aggiungere uno shard.
1. **Nella scheda **Shards and nodes, scegli Aggiungi/Elimina shard****
1. In **Nuovo numero di frammenti**, inserisci il numero di frammenti che desideri.
1. Scegliete **Conferma** per mantenere le modifiche o **Annulla per ignorarle**.
### Aggiunta dle partizioni (AWS CLI)
Il processo seguente descrive come riconfigurare gli shard nel cluster MemoryDB aggiungendo shard utilizzando. AWS CLI
Utilizzare i seguenti parametri con `update-cluster`.
**Parameters**
+ `--cluster-name`: obbligatorio Speciifica su quale cluster (cluster) deve essere eseguita l'operazione di riconfigurazione degli shard.
+ `--shard-configuration`: obbligatorio Consente di impostare il numero di shard.
+ `ShardCount`— Impostate questa proprietà per specificare il numero di frammenti desiderati.
**Example**
L'esempio seguente modifica il numero di shard nel cluster `my-cluster` portandolo a 2.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--shard-configuration \
ShardCount=2
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--shard-configuration ^
ShardCount=2
```
Restituisce la seguente risposta JSON:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "updating",
"NumberOfShards": 2,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
}
```
Per visualizzare i dettagli del cluster aggiornato una volta che il suo stato passa da *aggiornamento* a *disponibile*, utilizza il comando seguente:
Per Linux, macOS o Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Per Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Restituirà la seguente risposta JSON:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 2,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-8191",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
},
{
"Name": "0002",
"Status": "available",
"Slots": "8192-16383",
"Nodes": [
{
"Name": "my-cluster-0002-001",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-22T14:26:18.693000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0002-002",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-22T14:26:18.765000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
Per ulteriori informazioni, vedere [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) nel Command Reference. AWS CLI
### Aggiungere frammenti (API MemoryDB)
È possibile utilizzare l'API MemoryDB per riconfigurare gli shard nel cluster MemoryDB online utilizzando l'operazione. `UpdateCluster`
Utilizzare i seguenti parametri con `UpdateCluster`.
**Parameters**
+ `ClusterName`: obbligatorio Speciifica su quale cluster deve essere eseguita l'operazione di riconfigurazione degli shard.
+ `ShardConfiguration`: obbligatorio Consente di impostare il numero di shard.
+ `ShardCount`— Impostate questa proprietà per specificare il numero di frammenti desiderati.
Per ulteriori informazioni, consulta [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
## Rimozione dele partizioni con il resharding online
È possibile rimuovere gli shard dal cluster MemoryDB utilizzando l'API Console di gestione AWS AWS CLI, o MemoryDB.
### Rimozione dle partizioni (Console)
Il processo seguente descrive come riconfigurare gli shard nel cluster MemoryDB rimuovendo gli shard utilizzando. Console di gestione AWS
**Importante**
Prima di rimuovere gli shard dal cluster, MemoryDB si assicura che tutti i dati entrino negli shard rimanenti. Se i dati sono adatti, gli shard vengono eliminati dal cluster come richiesto. Se i dati non rientrano negli shard rimanenti, il processo viene terminato e al cluster viene lasciata la stessa configurazione degli shard di prima della richiesta.
È possibile utilizzare il Console di gestione AWS per rimuovere uno o più shard dal cluster MemoryDB. Non è possibile rimuovere tutti gli shard in un cluster. È invece necessario eliminare il cluster. Per ulteriori informazioni, consulta [Passaggio 5: Eliminazione di un cluster](getting-started.md#clusters.delete). La procedura seguente descrive il processo di rimozione di uno o più shard.
****
1. Accedi Console di gestione AWS e apri la console MemoryDB all'indirizzo. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Dall'elenco dei cluster, scegli il nome del cluster da cui desideri rimuovere uno shard.
1. **Nella scheda **Shards and nodes, scegli Aggiungi/Elimina shard****
1. In **Nuovo numero di frammenti**, inserisci il numero di frammenti che desideri (con un minimo di 1).
1. Scegliete **Conferma** per mantenere le modifiche o **Annulla per ignorarle**.
### Rimozione dele partizioni (AWS CLI)
Il processo seguente descrive come riconfigurare gli shard nel cluster MemoryDB rimuovendo gli shard utilizzando. AWS CLI
**Importante**
Prima di rimuovere gli shard dal cluster, MemoryDB si assicura che tutti i dati entrino negli shard rimanenti. Se i dati sono adatti, gli shard vengono eliminati dal cluster come richiesto e i relativi keyspace mappati negli shard rimanenti. Se i dati non rientrano negli shard rimanenti, il processo viene terminato e al cluster viene lasciata la stessa configurazione degli shard di prima della richiesta.
È possibile utilizzare il AWS CLI per rimuovere uno o più shard dal cluster MemoryDB. Non è possibile rimuovere tutti gli shard in un cluster. È invece necessario eliminare il cluster. Per ulteriori informazioni, consulta [Passaggio 5: Eliminazione di un cluster](getting-started.md#clusters.delete).
Utilizzare i seguenti parametri con `update-cluster`.
**Parameters**
+ `--cluster-name`: obbligatorio Speciifica su quale cluster (cluster) deve essere eseguita l'operazione di riconfigurazione dello shard.
+ `--shard-configuration`: obbligatorio Consente di impostare il numero di shard utilizzando la proprietà: `ShardCount`
`ShardCount`— Imposta questa proprietà per specificare il numero di frammenti che desideri.
**Example**
L'esempio seguente modifica il numero di shard nel cluster `my-cluster` portandolo a 2.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--shard-configuration \
ShardCount=2
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--shard-configuration ^
ShardCount=2
```
Restituisce la seguente risposta JSON:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "updating",
"NumberOfShards": 2,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
}
```
Per visualizzare i dettagli del cluster aggiornato una volta che il suo stato passa da *aggiornamento* a *disponibile*, utilizza il comando seguente:
Per Linux, macOS o Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Per Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Restituirà la seguente risposta JSON:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 2,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-8191",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
},
{
"Name": "0002",
"Status": "available",
"Slots": "8192-16383",
"Nodes": [
{
"Name": "my-cluster-0002-001",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-22T14:26:18.693000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0002-002",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-22T14:26:18.765000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
Per ulteriori informazioni, vedere [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) nel Command Reference. AWS CLI
### Rimozione degli shard (API MemoryDB)
È possibile utilizzare l'API MemoryDB per riconfigurare gli shard nel cluster MemoryDB online utilizzando l'operazione. `UpdateCluster`
Il processo seguente descrive come riconfigurare gli shard nel cluster MemoryDB rimuovendo gli shard utilizzando l'API MemoryDB.
**Importante**
Prima di rimuovere gli shard dal cluster, MemoryDB si assicura che tutti i dati rientrino negli shard rimanenti. Se i dati sono adatti, gli shard vengono eliminati dal cluster come richiesto e i relativi keyspace mappati negli shard rimanenti. Se i dati non rientrano negli shard rimanenti, il processo viene terminato e al cluster viene lasciata la stessa configurazione degli shard di prima della richiesta.
È possibile utilizzare l'API MemoryDB per rimuovere uno o più shard dal cluster MemoryDB. Non è possibile rimuovere tutti gli shard in un cluster. È invece necessario eliminare il cluster. Per ulteriori informazioni, consulta [Passaggio 5: Eliminazione di un cluster](getting-started.md#clusters.delete).
Utilizzare i seguenti parametri con `UpdateCluster`.
**Parameters**
+ `ClusterName`: obbligatorio Speciifica su quale cluster (cluster) deve essere eseguita l'operazione di riconfigurazione dello shard.
+ `ShardConfiguration`: obbligatorio Consente di impostare il numero di shard utilizzando la proprietà: `ShardCount`
`ShardCount`— Imposta questa proprietà per specificare il numero di frammenti che desideri.
# Ridimensionamento verticale online tramite la modifica del tipo di nodo
Utilizzando la scalabilità verticale online con MemoryDB, è possibile scalare il cluster in modo dinamico con tempi di inattività minimi. Ciò consente al cluster di soddisfare le richieste anche durante la scalabilità.
**Nota**
Il dimensionamento non è supportato tra un cluster di tiering di dati (ad esempio, un cluster che utilizza un tipo di nodo r6gd) e un cluster che non utilizza il tiering di dati (ad esempio, un cluster che utilizza un tipo di nodo r6g). Per ulteriori informazioni, consulta [Tiering di dati](data-tiering.md).
È possibile effettuare le seguenti operazioni:
+ **Scalabilità: aumenta** la capacità di lettura e scrittura modificando il tipo di nodo del cluster MemoryDB per utilizzare un tipo di nodo più grande.
MemoryDB ridimensiona dinamicamente il cluster rimanendo online e soddisfacendo le richieste.
+ **Riduzione verticale** - Riduce la capacità di lettura e scrittura modificando il tipo di nodo affinché utilizzi un nodo più piccolo. Ancora una volta, MemoryDB ridimensiona dinamicamente il cluster rimanendo online e soddisfacendo le richieste. In questo caso, il ridimensionamento del nodo permette di ridurre i costi.
**Nota**
I processi di dimensionamento verso l'alto e il basso si basano sulla creazione di cluster con i nuovi tipi di nodo selezionati e sulla sincronizzazione dei nuovi nodi con quelli precedenti. Per garantire un up/down flusso su larga scala, procedi come segue:
Anche se il processo di ridimensionamento verticale è progettato affinché il cluster rimanga completamente online, esso si basa sulla sincronizzazione dei dati tra il vecchio nodo e il nuovo nodo. Si consiglia di avviare il processo di dimensionamento verso l'alto/il basso durante le ore in cui si prevede che il traffico dati sia al minimo.
Se possibile, testa il comportamento della tua applicazione durante il ridimensionamento in un ambiente di prova.
# Dimensionamento verso l'alto online
**Topics**
+ [Scalabilità dei cluster MemoryDB (Console)](#cluster-vertical-scaling-console)
+ [Scalabilità dei cluster MemoryDB (CLI)AWS](#scaling.scaleUp.cli)
+ [Scalabilità dei cluster MemoryDB (API MemoryDB)](#verticalscaling.scaleup.api)
## Scalabilità dei cluster MemoryDB (Console)
La procedura seguente descrive come scalare un cluster MemoryDB utilizzando. Console di gestione AWS Durante questo processo, il cluster MemoryDB continuerà a soddisfare le richieste con tempi di inattività minimi.
**Per scalare un cluster (console)**
1. Accedi Console di gestione AWS e apri la console MemoryDB all'indirizzo. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Nell'elenco dei cluster, scegliere quello da ridimensionare.
1. Scegliere **Actions (Operazioni)**, quindi **Modify (Modifica)**.
1. Nella finestra di dialogo **Modifica cluster**:
1. Scegliere il tipo di nodo a cui dimensionare dall'elenco **Node type (Tipo di nodo)**. Per aumentare, scegliere un tipo di nodo più grande del nodo esistente.
1. Scegli **Save changes** (Salva modifiche).
Lo stato del cluster cambia in *modifica.* Quando lo stato cambia in *disponibile*, la modifica è completa ed è possibile iniziare a utilizzare il nuovo cluster.
## Scalabilità dei cluster MemoryDB (CLI)AWS
La procedura seguente descrive come scalare un cluster MemoryDB utilizzando. AWS CLI Durante questo processo, il cluster MemoryDB continuerà a soddisfare le richieste con tempi di inattività minimi.
**Per scalare un cluster MemoryDB (CLI AWS )**
1. Determina i tipi di nodi fino a cui puoi scalare eseguendo il AWS CLI `list-allowed-node-type-updates` comando con il seguente parametro.
Per Linux, macOS o Unix:
```
aws memorydb list-allowed-node-type-updates \
--cluster-name my-cluster-name
```
Per Windows:
```
aws memorydb list-allowed-node-type-updates ^
--cluster-name my-cluster-name
```
L'output del comando in alto è simile al seguente (in formato JSON).
```
{
"ScaleUpNodeTypes": [
"db.r6g.2xlarge",
"db.r6g.large"
],
"ScaleDownNodeTypes": [
"db.r6g.large"
],
}
```
Per ulteriori informazioni, vedere [list-allowed-node-type-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/list-allowed-node-type-updates.html) nel *AWS CLI Reference.*
1. Modifica il cluster per adattarlo al nuovo tipo di nodo più grande, utilizzando il AWS CLI `update-cluster` comando e i seguenti parametri.
+ `--cluster-name`— Il nome del cluster verso cui stai eseguendo la scalabilità.
+ `--node-type`— Il nuovo tipo di nodo su cui scalare il cluster. Questo valore deve essere uno dei tipi di nodi restituiti dal comando `list-allowed-node-type-updates` nella fase 1.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--node-type db.r6g.2xlarge
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--node-type db.r6g.2xlarge ^
```
Per ulteriori informazioni, vedere [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Scalabilità dei cluster MemoryDB (API MemoryDB)
Il seguente processo ridimensiona il cluster dal tipo di nodo corrente a un nuovo tipo di nodo più grande utilizzando l'API MemoryDB. Durante questo processo, MemoryDB aggiorna le voci DNS in modo che puntino ai nuovi nodi. Puoi scalare i cluster abilitati al failover automatico mentre il cluster continua a rimanere online e a soddisfare le richieste in arrivo.
Il tempo necessario per la scalabilità fino a un tipo di nodo più grande varia a seconda del tipo di nodo e della quantità di dati nel cluster corrente.
**Per scalare un cluster MemoryDB (API MemoryDB)**
1. Determina a quali tipi di nodi puoi scalare utilizzando l'azione dell'API `ListAllowedNodeTypeUpdates` MemoryDB con il seguente parametro.
+ `ClusterName`— il nome del cluster. Utilizzate questo parametro per descrivere un cluster specifico anziché tutti i cluster.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=ListAllowedNodeTypeUpdates
&ClusterName=MyCluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Per ulteriori informazioni, vedere [ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html)nel riferimento all'API di *MemoryDB.*
1. Scala il cluster corrente fino al nuovo tipo di nodo utilizzando l'azione dell'API `UpdateCluster` MemoryDB e con i seguenti parametri.
+ `ClusterName`— il nome del cluster.
+ `NodeType`— il nuovo tipo di nodo più grande dei cluster di questo cluster. Questo valore deve essere uno dei tipi di istanza restituiti dall'operazione `ListAllowedNodeTypeUpdates` nella fase 1.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&NodeType=db.r6g.2xlarge
&ClusterName=myCluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210801T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Per ulteriori informazioni, consulta [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Dimensionamento verso il basso online
**Topics**
+ [Ridimensionamento dei cluster MemoryDB (Console)](#cluster-vertical-scaling-down-console)
+ [Ridimensionamento dei cluster MemoryDB (CLI)AWS](#scaling.scaledown.cli)
+ [Ridimensionamento dei cluster MemoryDB (API MemoryDB)](#scaling.vertical.scaledown.api)
## Ridimensionamento dei cluster MemoryDB (Console)
La procedura seguente descrive come ridimensionare un cluster MemoryDB utilizzando. Console di gestione AWS Durante questo processo, il cluster MemoryDB continuerà a soddisfare le richieste con tempi di inattività minimi.
**Per ridimensionare un cluster MemoryDB (console)**
1. Accedi Console di gestione AWS e apri la console MemoryDB all'indirizzo. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Nell'elenco dei cluster, scegliere quello da ridimensionare.
1. Scegliere **Actions (Operazioni)**, quindi **Modify (Modifica)**.
1. Nella finestra di dialogo **Modifica cluster**:
1. Scegliere il tipo di nodo a cui dimensionare dall'elenco **Node type (Tipo di nodo)**. Per la riduzione verticale, scegliere un tipo di nodo più piccolo del nodo esistente. Si noti che non tutti i tipi di nodo sono disponibili per il dimensionamento.
1. Scegli **Save changes** (Salva modifiche).
Lo stato del cluster cambia in *modifica.* Quando lo stato cambia in *disponibile*, la modifica è completa ed è possibile iniziare a utilizzare il nuovo cluster.
## Ridimensionamento dei cluster MemoryDB (CLI)AWS
La procedura seguente descrive come ridimensionare un cluster MemoryDB utilizzando. AWS CLI Durante questo processo, il cluster MemoryDB continuerà a soddisfare le richieste con tempi di inattività minimi.
**Per ridimensionare un cluster MemoryDB (CLI AWS )**
1. Determina i tipi di nodi a cui puoi ridimensionare eseguendo il AWS CLI `list-allowed-node-type-updates` comando con il seguente parametro.
Per Linux, macOS o Unix:
```
aws memorydb list-allowed-node-type-updates \
--cluster-name my-cluster-name
```
Per Windows:
```
aws memorydb list-allowed-node-type-updates ^
--cluster-name my-cluster-name
```
L'output del comando in alto è simile al seguente (in formato JSON).
```
{
"ScaleUpNodeTypes": [
"db.r6g.2xlarge",
"db.r6g.large"
],
"ScaleDownNodeTypes": [
"db.r6g.large"
],
}
```
Per ulteriori informazioni, vedere [list-allowed-node-type-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/list-allowed-node-type-updates.html).
1. Modifica il cluster per ridurlo al nuovo tipo di nodo più piccolo, utilizzando il `update-cluster` comando e i seguenti parametri.
+ `--cluster-name`— Il nome del cluster a cui si sta effettuando la scalabilità.
+ `--node-type`— Il nuovo tipo di nodo su cui scalare il cluster. Questo valore deve essere uno dei tipi di nodi restituiti dal comando `list-allowed-node-type-updates` nella fase 1.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--node-type db.r6g.large
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--node-type db.r6g.large
```
Per ulteriori informazioni, vedere [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Ridimensionamento dei cluster MemoryDB (API MemoryDB)
Il seguente processo ridimensiona il cluster dal tipo di nodo corrente a un nuovo tipo di nodo più piccolo utilizzando l'API MemoryDB. Durante questo processo, il cluster MemoryDB continuerà a soddisfare le richieste con tempi di inattività minimi.
Il tempo necessario per la scalabilità a un tipo di nodo più piccolo varia a seconda del tipo di nodo e della quantità di dati nel cluster corrente.
**Ridimensionamento (API MemoryDB)**
1. Determina a quali tipi di nodi puoi ridimensionare utilizzando l'[ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html)API con il seguente parametro:
+ `ClusterName`— il nome del cluster. Utilizzate questo parametro per descrivere un cluster specifico anziché tutti i cluster.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=ListAllowedNodeTypeUpdates
&ClusterName=MyCluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
1. Ridimensiona il cluster corrente fino al nuovo tipo di nodo utilizzando l'[UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html)API con i seguenti parametri.
+ `ClusterName`— il nome del cluster.
+ `NodeType`— il nuovo tipo di nodo più piccolo dei cluster di questo cluster. Questo valore deve essere uno dei tipi di istanza restituiti dall'operazione `ListAllowedNodeTypeUpdates` nella fase 1.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&NodeType=db.r6g.2xlarge
&ClusterName=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210801T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```