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
La maggior parte delle operazioni di MemoryDB 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'API e i comandi di MemoryDB. AWS CLI L'identificatore del cluster deve essere univoco per quel cliente in una regione. AWS
I cluster MemoryDB sono progettati per essere accessibili utilizzando un'istanza Amazon EC2. Puoi avviare il tuo cluster MemoryDB solo in un cloud privato virtuale (VPC) basato sul servizio Amazon VPC, ma puoi accedervi dall'esterno. AWS Per ulteriori informazioni, consulta [Accesso alle risorse di MemoryDB dall'esterno AWS](accessing-memorydb.md#access-from-outside-aws).
# Tiering di dati
I cluster che utilizzano un tipo di nodo della famiglia r6gd hanno i dati 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 e Redis OSS utilizzando unità a stato solido () a basso costo in ogni nodo del cluster oltre all'archiviazione dei dati in memoria. SSDs Analogamente ad altri tipi di nodi, i dati scritti sui nodi r6gd vengono archiviati in modo duraturo in un registro delle transazioni Multi-AZ. 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.
Nei cluster con tiering dei dati, MemoryDB monitora l'ultimo orario di accesso di ogni elemento archiviato. Quando la memoria disponibile (DRAM) è completamente consumata, MemoryDB utilizza un algoritmo LRU (Least-Recently Used) per spostare automaticamente gli elementi a cui si accede meno frequentemente dalla memoria all'SSD. Quando successivamente si accede ai dati sull'SSD, MemoryDB li riporta 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 da 500 byte, in genere è possibile aspettarsi una latenza aggiuntiva di 450 microsecondi per le richieste di lettura dei dati archiviati su SSD rispetto alle richieste di lettura dei dati in memoria.
Con la dimensione massima del nodo di tiering dei dati (db.r6gd.8xlarge), è possibile archiviare fino a \$1 500 in un singolo cluster da 500 nodi (250 TB quando si utilizza 1 replica di lettura). TBs Per il data tiering, MemoryDB riserva il 19% della memoria (DRAM) per nodo per uso diverso dai dati. Il tiering dei dati è compatibile con tutti i comandi e le strutture dati OSS Valkey e Redis supportati in MemoryDB. Non è necessaria alcuna modifica lato client per utilizzare questa caratteristica.
**Topics**
+ [Best practice](data-tiering-best-practices.md)
+ [Limitazioni del tiering dei dati](data-tiering-prerequisites.md)
+ [Prezzi del tiering di dati](data-tiering-pricing.md)
+ [Monitoraggio dei dati su più livelli](data-tiering-monitoring.md)
+ [Utilizzo del tiering di dati](data-tiering-enabling.md)
+ [Ripristino dei dati da un'istantanea nei cluster](data-tiering-enabling-snapshots.md)
# 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. La dimensione del valore non può essere superiore a 128 MB, altrimenti non verrà spostato su disco. 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 del tiering dei dati
Il livello di dati presenta le seguenti limitazioni:
+ 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-west-3`, `eu-central-1`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` e `sa-east-1`.
+ Non è possibile ripristinare un'istantanea di un cluster r6gd in un altro cluster a meno che non utilizzi anche r6gd.
+ Non è possibile esportare uno snapshot in Amazon S3 per cluster di dati su più livelli.
+ Il salvataggio senza fork non è supportato.
+ 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).
+ Il tiering di dati supporta solo policy maxmemory `volatile-lru`, `allkeys-lru` e `noeviction`.
+ Gli elementi più grandi di 128 MiB non vengono spostati su SSD.
# Prezzi del tiering di dati
I nodi R6gd hanno una capacità totale (memoria\$1SSD) 5 volte superiore e possono aiutare a ottenere risparmi sui costi di storage di oltre il 60% quando vengono eseguiti al massimo utilizzo rispetto ai nodi R6g (solo memoria). [Per ulteriori informazioni, consulta i prezzi di MemoryDB.](https://aws.amazon.com/memorydb/pricing/)
# Monitoraggio dei dati su più livelli
MemoryDB 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 metrica all'indirizzo. `CurrItems` [Metriche per MemoryDB](metrics.memorydb.md) Puoi calcolare la percentuale come:. `(CurrItems with Dimension: Tier = Memory * 100) / (CurrItems with no dimension filter)`
Se la politica di sfratto configurata lo consente, allora MemoryDB inizierà a sfrattare gli elementi quando la percentuale di elementi in memoria scende al di sotto del 5 percento. Sui nodi configurati con nessuna politica di espulsione, le operazioni di scrittura riceveranno un errore di memoria esaurita.
Si consiglia comunque di considerare [Scalabilità dei cluster MemoryDB](scaling-cluster.md) quando la percentuale di elementi in memoria scende al di sotto del 5%. Per ulteriori informazioni, consulta *Metriche per i cluster MemoryDB che utilizzano* il tiering dei dati su. [Metriche per MemoryDB](metrics.memorydb.md)
# Utilizzo del tiering di dati
## Utilizzo della suddivisione dei dati su più livelli utilizzando il Console di gestione AWS
*Quando si crea un cluster, si utilizza il tiering dei dati selezionando un tipo di nodo della famiglia r6gd, ad esempio db.r6gd.xlarge.* La selezione di quel tipo di nodo abilita automaticamente il tiering di dati.
Per ulteriori informazioni sulla creazione di cluster, consulta [Fase 2: creazione di un cluster](getting-started.md#getting-started.createcluster).
## Abilitazione del tiering dei dati su più livelli utilizzando il AWS CLI
Quando si crea un cluster utilizzando il AWS CLI, si utilizza il tiering dei dati selezionando un tipo di nodo dalla famiglia r6gd, ad esempio *db.r6gd.xlarge e impostando il parametro.* `--data-tiering`
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`, l'operazione avrà esito negativo.
Per Linux, macOS o Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey \
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering
```
Per Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg
--data-tiering
```
Dopo aver eseguito questa operazione, verrà visualizzata una risposta simile alla seguente:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering":"true",
"AutoMinorVersionUpgrade": true
}
}
```
# Ripristino dei dati da un'istantanea nei cluster
È possibile ripristinare un'istantanea in un nuovo cluster con il tiering dei dati abilitato utilizzando (Console), (AWS CLI) o (API MemoryDB). Quando si crea un cluster utilizzando tipi di nodo nella famiglia r6gd, il tiering di dati è abilitato.
## Ripristino dei dati da un'istantanea in cluster con la suddivisione dei dati su più livelli abilitata (console)
Per ripristinare un'istantanea in un nuovo cluster con il tiering dei dati abilitato (console), segui i passaggi riportati in [Ripristino da un'istantanea (console)](snapshots-restoring.md#snapshots-restoring-CON)
Tieni presente che per abilitare il tiering dei dati, devi selezionare un tipo di nodo della famiglia r6gd.
## Ripristino dei dati da un'istantanea in cluster con data tiering abilitato (CLI)AWS
Quando si crea un cluster utilizzando AWS CLI, per impostazione predefinita viene utilizzato il tiering dei dati su più livelli selezionando un tipo di nodo della famiglia r6gd, ad esempio *db.r6gd.xlarge* e impostando il parametro. `--data-tiering`
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`, l'operazione avrà esito negativo.
Per Linux, macOS o Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering \
--snapshot-name my-snapshot
```
Per Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg ^
--data-tiering ^
--snapshot-name my-snapshot
```
Dopo aver eseguito questa operazione, verrà visualizzata una risposta simile alla seguente:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "true"
}
```
# Preparazione di un cluster
Di seguito, puoi trovare le istruzioni per creare un cluster utilizzando la console MemoryDB, o l'API MemoryDB. AWS CLI
Ogni volta che si crea un cluster, è consigliabile eseguire alcuni lavori preparatori in modo da non dover aggiornare o apportare modifiche immediatamente.
**Topics**
+ [Determina i tuoi requisiti](cluster-create-determine-requirements.md)
# Determina i tuoi requisiti
**Preparazione**
Conoscere le risposte alle seguenti domande aiuta a velocizzare la creazione del cluster:
+ Assicurati di creare un gruppo di sottoreti nello stesso VPC prima di iniziare a creare un cluster. In alternativa, è possibile utilizzare il gruppo di sottoreti predefinito fornito. Per ulteriori informazioni, consulta [Sottoreti e gruppi di sottoreti](subnetgroups.md).
MemoryDB è progettato per essere accessibile dall'interno AWS tramite Amazon EC2. Tuttavia, se si avvia in un VPC basato su Amazon VPC, è possibile fornire l'accesso dall'esterno. AWS Per ulteriori informazioni, consulta [Accesso alle risorse di MemoryDB dall'esterno AWS](accessing-memorydb.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 parametri](parametergroups.creating.md).
+ Devi creare un 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](faulttolerance.md).
**Topics**
+ [Requisiti di memoria e del processore](#cluster-create-determine-requirements-memory)
+ [Configurazione del cluster MemoryDB](#cluster-configuration)
+ [Multiplexing migliorato I/O](#cluster-create-determine-requirements-multiplexing)
+ [Requisiti di dimensionamento](#cluster-create-determine-requirements-scaling)
+ [Requisiti di accesso](#cluster-create-determine-requirements-access)
+ [Regione e zone di disponibilità](#cluster-create-determine-requirements-region)
## Requisiti di memoria e del processore
L'elemento costitutivo di base di MemoryDB è il nodo. I nodi sono configurati in shard per formare cluster. 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.
## Configurazione del cluster MemoryDB
I cluster MemoryDB sono composti da 1 a 500 shard. I dati in un cluster MemoryDB sono partizionati tra gli shard del cluster. L'applicazione si connette a un cluster MemoryDB utilizzando un indirizzo di rete chiamato Endpoint. *Oltre agli endpoint del nodo, lo stesso cluster MemoryDB dispone di un endpoint chiamato endpoint del cluster.* L'applicazione può utilizzare questo endpoint per leggere o scrivere nel cluster, lasciando a MemoryDB la determinazione del nodo da cui leggere o scrivere.
## Multiplexing migliorato I/O
Se utilizzi Valkey o Redis OSS versione 7.0 o successiva, otterrai un'ulteriore accelerazione grazie al I/O multiplexing avanzato, in cui ogni thread IO di rete dedicato trasferisce i comandi da più client al motore, sfruttando la capacità di elaborare in modo efficiente i comandi in batch. [Per ulteriori informazioni, consulta Prestazioni ultraveloci e.](https://aws.amazon.com/memorydb/features/#Ultra-fast_performance) [Tipi di nodi supportati](nodes.supportedtypes.md)
## Requisiti di dimensionamento
Tutti i cluster possono essere scalati verso un tipo di nodo più grande. Quando si esegue il ridimensionamento di un cluster MemoryDB, è possibile farlo online in modo che il cluster rimanga disponibile oppure è possibile eseguire il seeding di un nuovo cluster da un'istantanea ed evitare che il nuovo cluster sia inizialmente vuoto.
Per ulteriori informazioni sul tagging, consulta [Dimensionamento](scaling.md)in questa guida.
## Requisiti di accesso
In base alla progettazione, è possibile accedere ai cluster MemoryDB dalle istanze Amazon EC2. L'accesso di rete a un cluster MemoryDB è limitato all'account che ha creato il cluster. Pertanto, prima di poter accedere a un cluster da un'istanza Amazon EC2, è necessario autorizzare l'accesso al cluster. Per istruzioni dettagliate, consultare [Fase 3: autorizzazione dell'accesso al cluster](getting-started.md#getting-started.authorizeaccess) in questa guida.
## Regione e zone di disponibilità
Posizionando i cluster di MemoryDB in una AWS regione vicina all'applicazione, è possibile ridurre la latenza. Se il cluster dispone di più nodi, posizionarli in zone di disponibilità diverse può ridurre l'effetto degli errori sul cluster.
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Scelta di regioni e zone di disponibilità](regionsandazs.md)
+ [Limitazione dell'impatto degli errori](faulttolerance.md)
# Creazione di un cluster
MemoryDB offre tre modi per creare un cluster. Per ulteriori informazioni, consulta [Fase 2: creazione di un cluster](getting-started.md#getting-started.createcluster).
# Visualizzazione dei dettagli di un cluster
È possibile visualizzare informazioni dettagliate su uno o più cluster utilizzando la console MemoryDB o l'API MemoryDB. AWS CLI
## Visualizzazione dei dettagli per un cluster MemoryDB (Console)
La procedura seguente descrive come visualizzare i dettagli di un cluster MemoryDB utilizzando la console MemoryDB.
****
1. Accedere Console di gestione AWS e aprire la console MemoryDB all'indirizzo. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Per visualizzare i dettagli di un cluster, scegli il pulsante di opzione a sinistra del nome del cluster, quindi scegli **Visualizza** dettagli. Puoi anche fare clic direttamente sul cluster per visualizzare la pagina dei dettagli del cluster.
La pagina dei **dettagli del cluster** mostra i dettagli sul cluster, incluso l'endpoint del cluster. È possibile visualizzare ulteriori dettagli utilizzando le diverse schede disponibili nella pagina dei **dettagli del cluster**.
1. Scegli la scheda **Frammenti e nodi** per visualizzare un elenco degli shard del cluster e il numero di nodi in ogni shard.
1. Per visualizzare informazioni specifiche su un nodo, espandi lo shard nella tabella seguente. In alternativa, puoi anche cercare lo shard utilizzando la casella di ricerca.
In questo modo vengono visualizzate informazioni su ciascun nodo, inclusa la zona di disponibilità slots/keyspaces e lo stato.
1. Scegli la scheda **Metriche** per monitorare i rispettivi processi, come l'**utilizzo della CPU e l'utilizzo della** **CPU del motore**. Per ulteriori informazioni, consulta [Metriche per MemoryDB](metrics.memorydb.md).
1. Scegli la scheda **Rete e sicurezza** per visualizzare i dettagli del gruppo di sottoreti e dei gruppi di sicurezza.
1. Nel **gruppo di sottoreti**, puoi visualizzare il nome del gruppo di sottoreti, un collegamento al VPC a cui appartiene la sottorete e l'Amazon Resource Name (ARN) del gruppo di sottoreti.
1. Nei **gruppi di sicurezza**, puoi visualizzare l'ID, il nome e la descrizione del gruppo di sicurezza.
1. Scegli la scheda **Manutenzione e istantanea** per visualizzare i dettagli delle impostazioni delle istantanee.
1. In **Snapshot**, puoi vedere se le istantanee automatizzate sono abilitate, il periodo di conservazione delle istantanee e la finestra delle istantanee.
1. In **Snapshots**, verrà visualizzato un elenco di tutte le istantanee di questo cluster, inclusi il nome, la dimensione, il numero di shard e lo stato delle istantanee.
Per ulteriori informazioni, consulta [Snapshot e ripristino](snapshots.md).
1. Scegli la scheda **Manutenzione e istantanea** per visualizzare i dettagli della finestra di manutenzione, insieme a eventuali aggiornamenti ACL, Resharding o Service in sospeso. Per ulteriori informazioni, consulta [Gestione della manutenzione](maintenance-window.md).
1. Scegli la scheda **Service Updates** per visualizzare i dettagli degli eventuali aggiornamenti del servizio applicabili a questo cluster. Per ulteriori informazioni, consulta [Aggiornamenti del servizio in MemoryDB](service-updates.md).
1. Scegli la scheda **Tag** per visualizzare i dettagli di eventuali tag di allocazione delle risorse o dei costi associati a questo cluster. Per ulteriori informazioni, consulta [Taggare le istantanee](snapshots-tagging.md).
## Visualizzazione dei dettagli di un cluster (AWS CLI)
È possibile visualizzare i dettagli di un cluster utilizzando il AWS CLI `describe-clusters` comando. Se si omette il parametro `--cluster-name`, vengono restituiti i dettagli relativi a più cluster, fino a un massimo di `--max-results`. Se il parametro `--cluster-name` è incluso, vengono restituiti solo i dettagli relativi al cluster specificato. Puoi limitare il numero di record restituiti con il parametro `--max-results`.
Il codice seguente consente di elencare i dettagli per `my-cluster`.
```
aws memorydb describe-clusters --cluster-name my-cluster
```
Il codice seguente consente di elencare i dettagli per un massimo di 25 cluster.
```
aws memorydb describe-clusters --max-results 25
```
**Example**
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
```
Il seguente output JSON mostra la risposta:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Description": "my cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": 1629230643.961,
"Endpoint": {
"Address": "my-cluster-0001-001.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"CreateTime": 1629230644.025,
"Endpoint": {
"Address": "my-cluster-0001-002.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.abcdef.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": "default",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:000000000:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "sat:06:30-sat:07:30",
"SnapshotWindow": "04:00-05:00",
"ACLName": "open-access",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true,
}
```
Per ulteriori informazioni, consultate l' AWS CLI argomento dedicato a MemoryDB. [https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html)
## Visualizzazione dei dettagli di un cluster (API MemoryDB)
È possibile visualizzare i dettagli di un cluster utilizzando l'azione API MemoryDB. `DescribeClusters` Se il parametro `ClusterName` è incluso, vengono restituiti solo i dettagli relativi al cluster specificato. Se si omette il parametro `ClusterName`, vengono restituiti i dettagli relativi a più cluster, fino a un massimo di `MaxResults` (valore di default 100). Il valore dei `MaxResults` non può essere minore di 20 o maggiore di 100.
Il codice seguente consente di elencare i dettagli per `my-cluster`.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=my-cluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Il codice seguente consente di elencare i dettagli per un massimo di 25 cluster.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&MaxResults=25
&Version=2021-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Per ulteriori informazioni, consultate l'argomento di riferimento sull'API MemoryDB. [https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html)
# Modifica di un cluster MemoryDB
Oltre ad aggiungere o rimuovere nodi da un cluster, a volte è necessario apportare altre modifiche a un cluster esistente, 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 si modificano i parametri di un cluster, la modifica viene applicata immediatamente al cluster. Ciò è vero indipendentemente dal fatto che si modifichi il gruppo di parametri del cluster stesso o un valore di parametro all'interno del gruppo di parametri del cluster.
Puoi anche aggiornare la versione del motore dei tuoi cluster. Ad esempio, puoi selezionare una nuova versione secondaria del motore e MemoryDB inizierà immediatamente ad aggiornare il cluster.
## Utilizzando il Console di gestione AWS
**Per modificare un cluster**
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 nell'angolo in alto a destra, scegli la AWS regione in cui si trova il cluster che desideri modificare.
1. **Dalla barra di navigazione a sinistra, vai a Clusters.** **Da **Dettagli sui cluster**, seleziona il cluster utilizzando il pulsante di opzione e vai su **Azioni**, quindi su Modifica.**
1. Viene visualizzata **la pagina Modifica**.
1. Nella finestra **Modifica**, apportate le modifiche desiderate. Le opzioni includono:
+ Description
+ Gruppi di sottoreti
+ Gruppi di sicurezza VPC
+ 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).
+ Compatibilità delle versioni di Valkey o Redis OSS
+ Abilita le istantanee automatiche
+ Periodo di conservazione delle istantanee
+ Finestra Snapshot
+ Finestra di manutenzione
+ Argomento relativo alla notifica SNS
1. Scegli **Save changes** (Salva modifiche).
Puoi anche andare alla pagina dei **dettagli del cluster** e fare clic su **modifica** per apportare modifiche al cluster. Se desideri modificare sezioni specifiche del cluster, puoi andare alla rispettiva scheda nella pagina dei **dettagli del cluster** e fare clic su **Modifica**.
## Usando il AWS CLI
È possibile modificare un cluster esistente utilizzando l' AWS CLI `update-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.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Per ulteriori informazioni, vedere [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) nel AWS CLI Command Reference.
## Utilizzo dell'API MemoryDB
È possibile modificare un cluster esistente utilizzando l'operazione API MemoryDB. [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html) 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.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&ClusterName=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210802T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
## Come attivare un aggiornamento cross-engine da Redis OSS a Valkey
È possibile aggiornare un cluster Redis OSS esistente al motore Valkey utilizzando Console, API o CLI.
Se disponi di un cluster Redis OSS esistente che utilizza il gruppo di parametri predefinito, puoi eseguire l'aggiornamento a Valkey specificando il nuovo motore e la nuova versione del motore con l'API update-cluster.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2
```
Se hai un gruppo di parametri personalizzato applicato al cluster Redis OSS esistente che desideri aggiornare, dovrai anche passare un gruppo di parametri Valkey personalizzato nella richiesta. Il gruppo di parametri personalizzati Valkey di input deve avere gli stessi valori dei parametri statici Redis OSS del gruppo di parametri personalizzati Redis OSS esistente.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2 \
--parameter-group-name myParamGroup
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2 ^
--parameter-group-name myParamGroup
```
# Aggiunta/rimozione di nodi da un cluster
È possibile aggiungere o rimuovere nodi da un cluster utilizzando l' Console di gestione AWS API MemoryDB o AWS CLI l'API MemoryDB.
## Utilizzando il Console di gestione AWS
****
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 o rimuovere un nodo.
1. **Nella scheda **Shards and nodes**, scegli Aggiungi/Elimina nodi**
1. In **Nuovo numero di nodi**, inserisci il numero di nodi che desideri.
1. Scegli **Conferma**.
**Importante**
Se imposti il numero di nodi su 1, non sarai più abilitato a Multi-AZ. Puoi anche scegliere di abilitare il **failover automatico**.
## Utilizzando il AWS CLI
1. Identifica i nomi dei nodi che desideri rimuovere. Per ulteriori informazioni, consulta [Visualizzazione dei dettagli di un cluster](clusters.viewdetails.md).
1. Utilizzare l'operazione CLI `update-cluster` 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 `update-cluster` con i seguenti parametri:
+ `--cluster-name`L'ID del cluster da cui desideri rimuovere i nodi.
+ `--replica-configuration`— Consente di impostare il numero di repliche:
+ `ReplicaCount`— Imposta questa proprietà per specificare il numero di nodi di replica che desideri.
+ `--region`Specifica la AWS regione del cluster da cui si desidera rimuovere i nodi.
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--replica-configuration \
ReplicaCount=1 \
--region us-east-1
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--replica-configuration ^
ReplicaCount=1 ^
--region us-east-1
```
Per ulteriori informazioni, consulta gli AWS CLI argomenti [https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Utilizzo dell'API MemoryDB
Per rimuovere i nodi utilizzando l'API MemoryDB, chiamate l'operazione `UpdateCluster` API con il nome del cluster e un elenco di nodi da rimuovere, come mostrato:
+ `ClusterName`L'ID del cluster da cui desideri rimuovere i nodi.
+ `ReplicaConfiguration`— Consente di impostare il numero di repliche:
+ `ReplicaCount`— Imposta questa proprietà per specificare il numero di nodi di replica che desideri.
+ `Region`Specifica la AWS regione del cluster da cui si desidera rimuovere un nodo.
Per ulteriori informazioni, consulta [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Accesso al cluster
Le tue istanze MemoryDB sono progettate per essere accessibili tramite un'istanza Amazon. EC2
Puoi accedere al tuo nodo MemoryDB da EC2 un'istanza Amazon nello stesso Amazon VPC. Oppure, utilizzando il peering VPC, puoi accedere al tuo nodo MemoryDB da un Amazon in un EC2 altro Amazon VPC.
**Topics**
+ [Concedi l'accesso al tuo cluster](#grant-access)
+ [Accesso alle risorse di MemoryDB dall'esterno AWS](#access-from-outside-aws)
## Concedi l'accesso al tuo cluster
Puoi connetterti al tuo cluster MemoryDB solo da EC2 un'istanza Amazon in esecuzione nello stesso Amazon VPC. In questo caso sarà necessario concedere al cluster l'ingresso di rete.
**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 a sinistra, 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 per l'uso di MemoryDB, 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 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 MemoryDB.
**Importante**
L'apertura del cluster MemoryDB a 0.0.0.0/0 non espone il cluster a Internet perché non ha un indirizzo IP pubblico e quindi 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. Pertanto, consigliamo di creare un gruppo di sicurezza VPC che verrà utilizzato esclusivamente da MemoryDB. 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 cluster MemoryDB.
## Accesso alle risorse di MemoryDB dall'esterno AWS
MemoryDB è un servizio progettato per essere utilizzato internamente al tuo VPC. L'accesso esterno è sconsigliato a causa della latenza del traffico Internet e dei problemi di sicurezza. Tuttavia, se l'accesso esterno a MemoryDB è necessario per scopi di test o sviluppo, è possibile farlo tramite una VPN.
Utilizzando AWS Client VPN, consenti l'accesso esterno ai tuoi nodi MemoryDB con i seguenti vantaggi:
+ Accesso limitato agli utenti approvati o alle chiavi di autenticazione;
+ Traffico crittografato tra il client VPN e l'endpoint AWS VPN;
+ Accesso limitato a sottoreti o nodi specifici;
+ Facile revoca dell'accesso agli utenti o alle chiavi di autenticazione;
+ Audit delle connessioni.
Le seguenti procedure dimostrano come:
**Topics**
+ [Creare un'autorità di certificazione](#create-cert)
+ [Configurazione dei componenti VPN del client AWS](#configure-vpn-components)
+ [Configurazione del client VPN](#configure-vpn-client)
### Creare un'autorità di certificazione
È possibile creare un'autorità di certificazione (CA) utilizzando tecniche o strumenti diversi. Suggeriamo l'utilità easy-rsa, fornita dal progetto [OpenVPN](https://openvpn.net/community-resources/openvpn-project/). Indipendentemente dall'opzione scelta, assicurati di conservare le chiavi al sicuro. La procedura seguente scarica gli script easy-rsa, crea l'autorità di certificazione e le chiavi per autenticare il primo client VPN:
+ Per creare i certificati iniziali, apri un terminale e procedi come segue:
+ `git clone`[https://github.com/OpenVPN/easy-rsa](https://github.com/OpenVPN/easy-rsa)
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa init-pki`
+ `./easyrsa3/easyrsa build-ca nopass`
+ `./easyrsa3/easyrsa build-server-full server nopass`
+ `./easyrsa3/easyrsa build-client-full client1.domain.tld nopass`
Una sottodirectory **pki** contenente i certificati verrà creata sotto **easy-rsa**.
+ Invia il certificato del server al gestore dei AWS certificati (ACM):
+ Nella console ACM scegli **Gestione certificati**.
+ Scegli **Importa certificato**.
+ Immetti il certificato della chiave pubblica disponibile nel file `easy-rsa/pki/issued/server.crt` nel campo **Corpo certificato**.
+ Incolla la chiave privata disponibile in `easy-rsa/pki/private/server.key` nel campo **Chiave privata certificato**. Assicurarsi di scegliere tutte le righe tra `BEGIN AND END PRIVATE KEY` (comprese le righe `BEGIN` ed `END`).
+ Incolla la chiave pubblica CA disponibile nel file `easy-rsa/pki/ca.crt` nel campo **Catena di certificati**.
+ Scegli **Verifica e importa**.
+ Scegli **Importa**.
Per inviare i certificati del server ad ACM utilizzando la AWS CLI, esegui il seguente comando: `aws acm import-certificate --certificate fileb://easy-rsa/pki/issued/server.crt --private-key file://easy-rsa/pki/private/server.key --certificate-chain file://easy-rsa/pki/ca.crt --region region`
Annota il certificato ARN per uso futuro.
### Configurazione dei componenti VPN del client AWS
**Utilizzo della console AWS **
Sulla AWS console, seleziona **Servizi** e poi **VPC**.
In **Rete privata virtuale**, seleziona **Endpoint VPN client** ed esegui le operazioni seguenti:
**Configurazione dei componenti AWS Client VPN**
+ Seleziona **Crea endpoint VPN client**.
+ Puoi specificare le seguenti opzioni:
+ **Client IPv4 CIDR**: utilizza una rete privata con una netmask di almeno un intervallo /22. Assicurati che la sottorete selezionata non sia in conflitto con gli indirizzi delle reti VPC. Esempio: 10.0.0.0/22.
+ In **Server certificate ARN (ARN certificato server)**, seleziona l'ARN del certificato precedentemente importato.
+ Seleziona **Use mutual authentication (Utilizza autenticazione reciproca)**.
+ In **Client certificate ARN (ARN certificato client)**, seleziona l'ARN del certificato precedentemente importato.
+ Seleziona **Crea endpoint VPN client**.
**Usando il AWS CLI**
Esegui il comando seguente:
`aws ec2 create-client-vpn-endpoint --client-cidr-block "10.0.0.0/22" --server-certificate-arn arn:aws:acm:us-east-1:012345678912:certificate/0123abcd-ab12-01a0-123a-123456abcdef --authentication-options Type=certificate-authentication,,MutualAuthentication={ClientRootCertificateChainArn=arn:aws:acm:us-east-1:012345678912:certificate/123abcd-ab12-01a0-123a-123456abcdef} --connection-log-options Enabled=false `
Output di esempio:
`"ClientVpnEndpointId": "cvpn-endpoint-0123456789abcdefg", "Status": { "Code": "pending-associate" }, "DnsName": "cvpn-endpoint-0123456789abcdefg.prod.clientvpn.us-east-1.amazonaws.com" } `
**Associazione delle reti di destinazione all'endpoint VPN**
+ Seleziona il nuovo endpoint VPN, quindi scegli la scheda **Associazioni**.
+ Seleziona **Associa** e specifica le seguenti opzioni.
+ **VPC: seleziona il VPC** del cluster MemoryDB.
+ Seleziona una delle reti del cluster MemoryDB. In caso di dubbio, esamina le reti nei **gruppi di sottorete** sulla dashboard di MemoryDB.
+ Seleziona **Associa**. Se necessario, ripeti le fasi per le reti rimanenti.
**Usando il AWS CLI**
Esegui il comando seguente:
`aws ec2 associate-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --subnet-id subnet-0123456789abdcdef`
Output di esempio:
`"Status": { "Code": "associating" }, "AssociationId": "cvpn-assoc-0123456789abdcdef" } `
**Verifica del gruppo di sicurezza VPN**
L'endpoint VPN adotta automaticamente il gruppo di sicurezza di default del VPC. Controlla le regole in entrata e in uscita e conferma se il gruppo di sicurezza consente il traffico dalla rete VPN (definita nelle impostazioni dell'endpoint VPN) alle reti MemoryDB sulle porte di servizio (per impostazione predefinita, 6379 per Redis).
Se è necessario modificare il gruppo di sicurezza assegnato all'endpoint VPN, procedi come segue:
+ Seleziona il gruppo di sicurezza corrente.
+ Seleziona **Apply Security Group (Applica gruppo di sicurezza)**.
+ Scegli il nuovo gruppo di sicurezza.
**Usando il AWS CLI**
Esegui il comando seguente:
`aws ec2 apply-security-groups-to-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefga --vpc-id vpc-0123456789abdcdef --security-group-ids sg-0123456789abdcdef`
Output di esempio:
`"SecurityGroupIds": [ "sg-0123456789abdcdef" ] } `
**Nota**
Il gruppo di sicurezza MemoryDB deve inoltre consentire il traffico proveniente dai client VPN. Gli indirizzi dei client saranno mascherati con l'indirizzo dell'endpoint VPN, in base alla rete VPC. Pertanto, considera la rete VPC (non la rete dei client VPN) quando crei la regola in entrata sul gruppo di sicurezza MemoryDB.
**Autorizzazione dell'accesso VPN alle reti di destinazione**
Nella scheda **Authorization (Autorizzazione)** seleziona **Authorize Ingress (Autorizza ingresso)** e specifica quanto segue:
+ Rete di destinazione per consentire l'accesso: usa 0.0.0.0/0 per consentire l'accesso a qualsiasi rete (inclusa Internet) o limita le reti/gli host di MemoryDB.
+ In **Grant access to: (Concedi accesso a:)**, seleziona **Allow access to all users (Consenti accesso a tutti gli utenti)**.
+ Seleziona **Add Authorization Rules (Aggiungi regole di autorizzazione)**.
**Usando il AWS CLI**
Esegui il comando seguente:
`aws ec2 authorize-client-vpn-ingress --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --target-network-cidr 0.0.0.0/0 --authorize-all-groups`
Output di esempio:
`{ "Status": { "Code": "authorizing" } }`
**Autorizzazione dell'accesso a Internet dai client VPN**
Se è necessario navigare in Internet tramite la VPN, dovrai creare una route aggiuntiva. Seleziona la scheda **Route Table (Tabella di routing)** e quindi seleziona **Create Route (Crea route)**:
+ Destinazione route: 0.0.0.0/0
+ **Target VPC Subnet ID (ID sottorete VPC di destinazione)**: seleziona una delle sottoreti associate con accesso a Internet.
+ Seleziona **Create Route (Crea route)**.
**Usando il AWS CLI**
Esegui il comando seguente:
`aws ec2 create-client-vpn-route --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --destination-cidr-block 0.0.0.0/0 --target-vpc-subnet-id subnet-0123456789abdcdef`
Output di esempio:
`{ "Status": { "Code": "creating" } } `
### Configurazione del client VPN
Nella dashboard AWS Client VPN, seleziona l'endpoint VPN creato di recente e seleziona **Scarica la configurazione del client**. Copia il file di configurazione e i file `easy-rsa/pki/issued/client1.domain.tld.crt` e `easy-rsa/pki/private/client1.domain.tld.key`. Modifica il file di configurazione e modifica o aggiungi i seguenti parametri:
+ cert: aggiungi una nuova riga con il parametro cert che punta al file `client1.domain.tld.crt`. Usa il percorso completo del file. Esempio: `cert /home/user/.cert/client1.domain.tld.crt`
+ cert: key: aggiungi una nuova riga con la chiave del parametro che punta al file `client1.domain.tld.key`. Usa il percorso completo del file. Esempio: `key /home/user/.cert/client1.domain.tld.key`
Stabilisci la connessione VPN con il comando: `sudo openvpn --config downloaded-client-config.ovpn`
**Revoca dell'accesso**
Se è necessario invalidare l'accesso a una particolare chiave client, la chiave deve essere revocata nella CA. Quindi invia l'elenco delle revoche a AWS Client VPN.
Revoca la chiave con easy-rsa:
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa revoke client1.domain.tld`
+ Inserisci "sì" per continuare o qualsiasi altro input per interrompere.
`Continue with revocation: `yes` ... * `./easyrsa3/easyrsa gen-crl`
+ È stato creato un file CRL aggiornato. File CRL: `/home/user/easy-rsa/pki/crl.pem`
Importazione dell'elenco delle revoche nella AWS Client VPN:
+ Sul Console di gestione AWS, seleziona **Servizi** e poi **VPC**.
+ Seleziona **Client VPN Endpoints (Endpoint client VPN)**.
+ Seleziona l'endpoint VPN client e quindi seleziona **Actions (Operazioni)** -> **Import Client Certificate CRL (Importa CRL certificato client)**.
+ Incolla il contenuto del file `crl.pem`:
**Usando il AWS CLI**
Esegui il comando seguente:
`aws ec2 import-client-vpn-client-certificate-revocation-list --certificate-revocation-list file://./easy-rsa/pki/crl.pem --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg `
Output di esempio:
`Example output: { "Return": true } `
# Individuazione degli endpoint di connessione
L'applicazione si connette al cluster utilizzando l'endpoint. Un endpoint è l'indirizzo univoco di un cluster. Utilizza il Cluster *Endpoint del cluster* per tutte le operazioni.
Le seguenti sezioni ti guidano nella scoperta dell'endpoint di cui avrai bisogno.
## Trovare l'endpoint per un cluster MemoryDB ()Console di gestione AWS
**Per trovare l'endpoint di un cluster MemoryDB**
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. Nel riquadro di navigazione scegliere **Clusters (Cluster)**.
Apparirà la schermata dei cluster con un elenco di cluster. Scegli il cluster a cui desideri connetterti.
1. Per trovare l'endpoint del cluster, scegli il nome del cluster (non il pulsante di opzione).
1. L'**endpoint del cluster** viene visualizzato in Dettagli del **cluster**. Per copiarlo scegli l'icona *copia* a sinistra dell'endpoint.
## Individuazione dell'endpoint per un cluster MemoryDB (CLI)AWS
È possibile utilizzare il `describe-clusters` comando per scoprire l'endpoint per un cluster. Il comando restituisce l'endpoint del cluster.
La seguente operazione recupera l'endpoint, che in questo esempio è rappresentato come a*sample*, per il cluster. `mycluster`
Restituisce la seguente risposta JSON:
```
aws memorydb describe-clusters \
--cluster-name mycluster
```
Per Windows:
```
aws memorydb describe-clusters ^
--cluster-name mycluster
```
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.4",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:zzzexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"AutoMinorVersionUpgrade": true
}
]
}
```
Per ulteriori informazioni, consulta [describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html).
## Ricerca dell'endpoint per un cluster MemoryDB (API MemoryDB)
È possibile utilizzare l'API MemoryDB per scoprire l'endpoint di un cluster.
### Ricerca dell'endpoint per un cluster MemoryDB (API MemoryDB)
È possibile utilizzare l'API MemoryDB per scoprire l'endpoint di un cluster con l'azione. `DescribeClusters` L'azione restituisce l'endpoint del cluster.
La seguente operazione recupera l'endpoint del cluster per il cluster. `mycluster`
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=mycluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&Version=2021-01-01
&X-Amz-Credential=
```
Per ulteriori informazioni, consulta [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html).
# Utilizzo degli shard.
Uno shard è una raccolta da uno a 6 nodi. È possibile creare un cluster con un numero maggiore di shard e un numero inferiore di repliche, per un totale di fino a 500 nodi per cluster. Questa configurazione del cluster può variare da 500 shard e 0 repliche a 100 shard e 4 repliche, ovvero il numero massimo di repliche consentite. 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.
Quando si crea un cluster MemoryDB utilizzando Console di gestione AWS, si specifica il numero di shard nel cluster e il numero di nodi negli shard. Per ulteriori informazioni, consulta [Creazione di un cluster MemoryDB](getting-started.md#clusters.create).
Ogni nodo in uno shard presenta le stesse specifiche di calcolo, storage e memoria. L'API MemoryDB consente di controllare gli attributi a livello di cluster, come il numero di nodi, le impostazioni di sicurezza e le finestre di manutenzione del sistema.
Per ulteriori informazioni, consultare [Risharding offline per MemoryDB](cluster-resharding-offline.md) e [Resharding online per MemoryDB](cluster-resharding-online.md).
## Trovare il nome di uno shard
È possibile trovare il nome di uno shard utilizzando l'API MemoryDB AWS CLI o Console di gestione AWS l'API MemoryDB.
### Usando il Console di gestione AWS
La procedura seguente utilizza Console di gestione AWS per trovare i nomi degli shard del cluster di MemoryDB.
****
1. Accedi a Console di gestione AWS e apri la console MemoryDB all'indirizzo. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. **Nel riquadro di navigazione a sinistra, scegli Clusters.**
1. Scegli il cluster in **Nome** di cui vuoi trovare i nomi degli shard.
1. **Nella scheda **Shards and nodes**, visualizza l'elenco degli shard sotto Nome.** Puoi anche espandere ognuno di essi per visualizzare i dettagli dei relativi nodi.
### Usando il AWS CLI
Per trovare i nomi degli shard (shard) per i cluster MemoryDB, utilizzate l' AWS CLI operazione `describe-clusters` con il seguente parametro opzionale.
+ **`--cluster-name`**—Un parametro opzionale che, se utilizzato, limita l'output ai dettagli del cluster specificato. Se questo parametro viene omesso, vengono restituiti i dettagli di un massimo di 100 cluster.
+ **`--show-shard-details`**—Restituisce i dettagli degli shard, inclusi i loro nomi.
Questo comando restituisce i dettagli per `my-cluster`.
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
```
Restituisce la seguente risposta JSON:
Le interruzioni di riga vengono aggiunte per facilitare la lettura.
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"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.xxxxx.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.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxx.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:xxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
### Utilizzo dell'API MemoryDB
Per trovare gli shard id per i cluster MemoryDB, utilizzate l'operazione `DescribeClusters` API con il seguente parametro opzionale.
+ **`ClusterName`**—Un parametro opzionale che, se utilizzato, limita l'output ai dettagli del cluster specificato. Se questo parametro viene omesso, vengono restituiti i dettagli di un massimo di 100 cluster.
+ **`ShowShardDetails`**—Restituisce i dettagli degli shard, inclusi i loro nomi.
**Example**
Questo comando restituisce i dettagli per `my-cluster`.
Per Linux, macOS o Unix:
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=sample-cluster
&ShowShardDetails=true
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```