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à.
# Protezione dei dati in MemoryDB
Il modello di [responsabilità AWS condivisa modello](https://aws.amazon.com/compliance/shared-responsibility-model/) di di si applica alla protezione dei dati in. Come descritto in questo modello, AWS è responsabile della protezione dell'infrastruttura globale che gestisce tutti i Cloud AWS. L’utente è responsabile del controllo dei contenuti ospitati su questa infrastruttura. L’utente è inoltre responsabile della configurazione della protezione e delle attività di gestione per i Servizi AWS utilizzati. Per maggiori informazioni sulla privacy dei dati, consulta le [Domande frequenti sulla privacy dei dati](https://aws.amazon.com/compliance/data-privacy-faq/). Per informazioni sulla protezione dei dati in Europa, consulta il post del blog relativo al [AWS Modello di responsabilità condivisa e GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) nel *AWS Blog sulla sicurezza*.
Ai fini della protezione dei dati, consigliamo di proteggere Account AWS le credenziali e configurare i singoli utenti con AWS IAM Identity Center or AWS Identity and Access Management (IAM). In tal modo, a ogni utente verranno assegnate solo le autorizzazioni necessarie per svolgere i suoi compiti. Suggeriamo, inoltre, di proteggere i dati nei seguenti modi:
+ Utilizza l’autenticazione a più fattori (MFA) con ogni account.
+ SSL/TLS Da utilizzare per comunicare con AWS le risorse. È richiesto TLS 1.2 ed è consigliato TLS 1.3.
+ Configura l'API e la registrazione delle attività degli utenti con AWS CloudTrail. Per informazioni sull'utilizzo dei CloudTrail percorsi per acquisire AWS le attività, consulta [Lavorare con i CloudTrail percorsi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) nella *Guida per l'AWS CloudTrail utente*.
+ Utilizza soluzioni di AWS crittografia, insieme a tutti i controlli di sicurezza predefiniti all'interno Servizi AWS.
+ Utilizza i servizi di sicurezza gestiti avanzati, come Amazon Macie, che aiutano a individuare e proteggere i dati sensibili archiviati in Amazon S3.
+ Se hai bisogno di moduli crittografici convalidati FIPS 140-3 per accedere AWS tramite un'interfaccia a riga di comando o un'API, usa un endpoint FIPS. Per ulteriori informazioni sugli endpoint FIPS disponibili, consulta il [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Ti consigliamo di non inserire mai informazioni riservate o sensibili, ad esempio gli indirizzi e-mail dei clienti, nei tag o nei campi di testo in formato libero, ad esempio nel campo **Nome**. Ciò include quando lavori o Servizi AWS utilizzi la console, l'API o. AWS CLI AWS SDKs I dati inseriti nei tag o nei campi di testo in formato libero utilizzati per i nomi possono essere utilizzati per i la fatturazione o i log di diagnostica. Quando si fornisce un URL a un server esterno, suggeriamo vivamente di non includere informazioni sulle credenziali nell’URL per convalidare la richiesta al server.
# Sicurezza dei dati in MemoryDB
Per proteggere i dati, MemoryDB e Amazon EC2 forniscono meccanismi di protezione contro l'accesso non autorizzato ai dati sul server.
MemoryDB fornisce anche funzionalità di crittografia per i dati sui cluster:
+ La crittografia dei dati in transito esegue la crittografia dei dati quando si spostano da una posizione a un'altra, ad esempio tra i nodi nel cluster o tra il cluster e l'applicazione.
+ La crittografia At-Rest crittografa il registro delle transazioni e i dati su disco durante le operazioni di snapshot.
Puoi anche utilizzarla [Autenticazione degli utenti con gli elenchi di controllo degli accessi () ACLs](clusters.acls.md) per controllare l'accesso degli utenti ai tuoi cluster.
**Topics**
+ [Sicurezza dei dati in MemoryDB](encryption.md)
+ [Crittografia At-Rest in MemoryDB](at-rest-encryption.md)
+ [Crittografia in transito (TLS) in MemoryDB](in-transit-encryption.md)
+ [Autenticazione degli utenti con gli elenchi di controllo degli accessi () ACLs](clusters.acls.md)
+ [Autenticazione con IAM](auth-iam.md)
# Crittografia At-Rest in MemoryDB
Per proteggere i dati, MemoryDB e Amazon S3 offrono diversi modi per limitare l'accesso ai dati nei cluster. Per ulteriori informazioni, consultare [MemoryDB e Amazon VPC](vpcs.md) e [Gestione delle identità e degli accessi in MemoryDB](iam.md).
La crittografia a riposo di MemoryDB è sempre abilitata per aumentare la sicurezza dei dati crittografando i dati persistenti. Crittografa i seguenti aspetti:
+ Dati nel registro delle transazioni
+ Disco durante le operazioni di sincronizzazione, istantanea e scambio
+ Istantanee archiviate in Amazon S3
MemoryDB offre la crittografia predefinita (gestita dal servizio) a riposo, oltre alla possibilità di utilizzare le proprie chiavi root simmetriche gestite dal cliente in [AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) Management Service (KMS).
I dati archiviati su SSDs (unità a stato solido) in cluster abilitati alla suddivisione dei dati sono sempre crittografati per impostazione predefinita.
Per informazioni sulla crittografia dei dati in transito, consulta [Crittografia in transito (TLS) in MemoryDB](in-transit-encryption.md)
**Topics**
+ [Utilizzo delle chiavi gestite dai clienti di KMS AWS](#using-customer-managed-keys-for-memorydb-security)
+ [Vedi anche](#at-rest-encryption-see-also)
## Utilizzo delle chiavi gestite dai clienti di KMS AWS
MemoryDB supporta chiavi root simmetriche gestite dal cliente (chiave KMS) per la crittografia a riposo. Le chiavi KMS gestite dal cliente sono chiavi di crittografia che puoi creare, possedere e gestire nel tuo account. AWS Per ulteriori informazioni, consulta [Customer Root Keys nella AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys) *Management Service* Developer Guide. Le chiavi devono essere create in AWS KMS prima di poter essere utilizzate con MemoryDB.
Per informazioni su come creare le chiavi principali di AWS KMS, consulta [Creating Keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) nella *AWS Key Management* Service Developer Guide.
MemoryDB consente l'integrazione con KMS. AWS Per ulteriori informazioni, consulta [Utilizzo di concessioni](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) nella *AWS Guida per gli sviluppatori Key Management Service*. Non è necessaria alcuna azione da parte del cliente per abilitare l'integrazione di MemoryDB con KMS. AWS
La chiave `kms:ViaService` condition limita l'uso di una chiave AWS KMS alle richieste provenienti da servizi specifici. AWS Da utilizzare `kms:ViaService` con MemoryDB, includi entrambi i ViaService nomi nel valore della chiave di condizione:. `memorydb.amazon_region.amazonaws.com` Per ulteriori informazioni, vedere [kms:](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service). ViaService
Puoi usarlo [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)per tenere traccia delle richieste a cui MemoryDB invia per tuo AWS Key Management Service conto. Tutte le chiamate API AWS Key Management Service relative alle chiavi gestite dal cliente hanno i log corrispondenti CloudTrail . Puoi anche vedere le concessioni create da MemoryDB chiamando la chiamata all'[ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)API KMS.
Una volta crittografato un cluster utilizzando una chiave gestita dal cliente, tutte le istantanee del cluster vengono crittografate come segue:
+ Le istantanee giornaliere automatiche vengono crittografate utilizzando la chiave gestita dal cliente associata al cluster.
+ L'istantanea finale creata quando il cluster viene eliminato viene inoltre crittografata utilizzando la chiave gestita dal cliente associata al cluster.
+ Le istantanee create manualmente sono crittografate per impostazione predefinita per utilizzare la chiave KMS associata al cluster. Puoi sostituirla scegliendo un'altra chiave gestita dal cliente.
+ Per impostazione predefinita, la copia di un'istantanea prevede l'utilizzo della chiave gestita dal cliente associata allo snapshot di origine. Puoi sostituirla scegliendo un'altra chiave gestita dal cliente.
**Nota**
Le chiavi gestite dal cliente non possono essere utilizzate per l'esportazione di istantanee nel bucket Amazon S3 selezionato. Tuttavia, tutte le istantanee esportate in Amazon S3 vengono crittografate [utilizzando](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) la crittografia lato server. Puoi scegliere di copiare il file di istantanea su un nuovo oggetto S3 e cifrarlo utilizzando una chiave KMS gestita dal cliente, copiare il file in un altro bucket S3 configurato con crittografia predefinita utilizzando una chiave KMS o modificare un'opzione di crittografia nel file stesso.
Puoi anche utilizzare chiavi gestite dal cliente per crittografare istantanee create manualmente che non utilizzano chiavi gestite dal cliente per la crittografia. Con questa opzione, il file di snapshot archiviato in Amazon S3 viene crittografato utilizzando una chiave KMS, anche se i dati non sono crittografati nel cluster originale.
Il ripristino da un'istantanea consente di scegliere tra le opzioni di crittografia disponibili, simili alle scelte di crittografia disponibili durante la creazione di un nuovo cluster.
+ Se si elimina la chiave o si [disabilita](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) la chiave e si [revocano le concessioni](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html) per la chiave utilizzata per crittografare un cluster, il cluster diventa irrecuperabile. In altre parole, non può essere modificato o ripristinato dopo un guasto hardware. AWS KMS elimina le chiavi principali solo dopo un periodo di attesa di almeno sette giorni. Dopo l'eliminazione della chiave, puoi utilizzare una chiave gestita dal cliente diversa per creare un'istantanea a scopo di archiviazione.
+ La rotazione automatica delle chiavi preserva le proprietà delle chiavi principali del AWS KMS, quindi la rotazione non ha alcun effetto sulla capacità di accedere ai dati di MemoryDB. I cluster MemoryDB crittografati non supportano la rotazione manuale delle chiavi, che comporta la creazione di una nuova chiave principale e l'aggiornamento di qualsiasi riferimento alla vecchia chiave. Per ulteriori informazioni, consulta [Rotating Customer Root Keys nella AWS Key](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) *Management* Service Developer Guide.
+ La crittografia di un cluster MemoryDB utilizzando la chiave KMS richiede una concessione per cluster. Questa concessione viene utilizzata per tutta la durata del cluster. Inoltre, durante la creazione di istantanee viene utilizzata una concessione per istantanea. Questa concessione viene ritirata una volta creata l'istantanea.
+ Per ulteriori informazioni su concessioni e limiti AWS KMS, consulta [Quotas](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html) nella *AWS Key* Management Service Developer Guide.
## Vedi anche
+ [Crittografia in transito (TLS) in MemoryDB](in-transit-encryption.md)
+ [MemoryDB e Amazon VPC](vpcs.md)
+ [Gestione delle identità e degli accessi in MemoryDB](iam.md)
# Crittografia in transito (TLS) in MemoryDB
Per aiutarti a proteggere i tuoi dati, MemoryDB e Amazon EC2 forniscono meccanismi di protezione contro l'accesso non autorizzato ai tuoi dati sul server. Fornendo funzionalità di crittografia in transito, MemoryDB ti offre uno strumento che puoi usare per proteggere i tuoi dati quando vengono spostati da una posizione all'altra. Ad esempio, è possibile spostare i dati da un nodo primario a un nodo di replica di lettura all'interno di un cluster o tra il cluster e l'applicazione.
**Topics**
+ [Panoramica della crittografia dei dati in transito](#in-transit-encryption-overview)
+ [Consulta anche](#in-transit-encryption-see-also)
## Panoramica della crittografia dei dati in transito
La crittografia in transito di MemoryDB è una funzionalità che aumenta la sicurezza dei dati nei punti più vulnerabili, quando sono in transito da una posizione all'altra.
La crittografia in transito di MemoryDB implementa le seguenti funzionalità:
+ **Connessioni crittografate: sia le connessioni** server che quelle client sono crittografate con Transport Layer Security (TLS).
+ **Replica crittografata.**i dati che si spostano tra un nodo primario e nodi di replica vengono crittografati.
+ **Autenticazione del server**: i client possono autenticare che si stanno connettendo al server giusto.
A partire dal 20/07/2023, TLS 1.2 è la versione minima supportata per i cluster nuovi ed esistenti. Utilizza questo [link](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/) per ulteriori informazioni su TLS 1.2 all'indirizzo. AWS
Per ulteriori informazioni sulla connessione ai cluster MemoryDB, vedere. [Connessione ai nodi MemoryDB utilizzando redis-cli](getting-started.md#connect-tls)
## Consulta anche
+ [Crittografia At-Rest in MemoryDB](at-rest-encryption.md)
+ [Autenticazione degli utenti con elenchi di controllo degli accessi () ACLs](https://docs.aws.amazon.com/memorydb/latest/devguide/clusters.acls.html)
+ [MemoryDB e Amazon VPC](vpcs.md)
+ [Gestione delle identità e degli accessi in MemoryDB](iam.md)
# Autenticazione degli utenti con gli elenchi di controllo degli accessi () ACLs
È possibile autenticare gli utenti con gli elenchi di controllo degli accessi (). ACLs
ACLs consentono di controllare l'accesso al cluster raggruppando gli utenti. Queste liste di controllo degli accessi sono progettate per organizzare l'accesso ai cluster.
Con ACLs, si creano utenti e si assegnano loro autorizzazioni specifiche utilizzando una stringa di accesso, come descritto nella sezione successiva. Gli utenti vengono assegnati agli elenchi di controllo degli accessi allineati a un ruolo specifico (amministratori, risorse umane) che vengono quindi distribuiti in uno o più cluster di MemoryDB. In questo modo, è possibile stabilire limiti di sicurezza tra i client che utilizzano lo stesso cluster o gli stessi cluster di MemoryDB e impedire ai client di accedere ai dati degli altri.
ACLs sono progettati per supportare l'introduzione di [ACL](https://valkey.io/docs/topics/acl/) in Redis OSS 6. Quando si utilizza ACLs con il cluster MemoryDB, esistono alcune limitazioni:
+ Non è possibile specificare password in una stringa di accesso. Le password vengono impostate con [CreateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateUser.html)o chiamate. [UpdateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateUser.html)
+ Per i diritti utente, si passa`on`e`off`come parte della stringa di accesso. Se nessuno dei due è specificato nella stringa di accesso, l'utente viene assegnato `off` e non dispone dei diritti di accesso al cluster.
+ Non è possibile utilizzare comandi proibiti. Se specifichi un comando proibito, verrà generata un'eccezione. Per un elenco di questi comandi, vedi[Comandi limitati](restrictedcommands.md).
+ Non è possibile utilizzare la`reset`come parte di una stringa di accesso. Si specificano le password con parametri API e MemoryDB gestisce le password. Pertanto, non è possibile utilizzare`reset`perché rimuoverebbe tutte le password per un utente.
+ [Redis OSS 6 introduce il comando ACL LIST.](https://valkey.io/commands/acl-list) Questo comando restituisce un elenco di utenti insieme alle regole ACL applicate a ciascun utente. MemoryDB supporta il `ACL LIST` comando, ma non include il supporto per gli hash delle password come fa Redis OSS. Con MemoryDB, è possibile utilizzare l'[DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)operazione per ottenere informazioni simili, incluse le regole contenute nella stringa di accesso. Tuttavia, [DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)non recupera una password utente.
[https://valkey.io/commands/acl-users](https://valkey.io/commands/acl-users) MemoryDB non supporta nessun altro comando ACL basato sulla scrittura.
L'utilizzo ACLs con MemoryDB è descritto più dettagliatamente di seguito.
**Topics**
+ [Specifica delle autorizzazioni mediante una stringa di accesso](#access-string)
+ [Funzionalità di ricerca vettoriale](#access-vss)
+ [Applicazione ACLs a un cluster per MemoryDB](#rbac-using)
## Specifica delle autorizzazioni mediante una stringa di accesso
Per specificare le autorizzazioni per un cluster MemoryDB, si crea una stringa di accesso e la si assegna a un utente, utilizzando o. AWS CLI Console di gestione AWS
Le stringhe di accesso sono definite come un elenco di regole delimitate da spazi che vengono applicate all'utente. Essi definiscono quali comandi un utente può eseguire e quali chiavi un utente può operare. Per eseguire un comando, un utente deve avere accesso al comando in esecuzione e tutte le chiavi sono accessibili dal comando. Le regole vengono applicate da sinistra a destra in modo cumulativo ed è possibile utilizzare una stringa più semplice al posto di quella fornita in caso di ridondanze nella stringa fornita.
Per ulteriori informazioni sulla sintassi delle regole ACL, consulta [ACL](https://valkey.io/topics/acl).
Nell'esempio seguente, la stringa di accesso rappresenta un utente attivo con accesso a tutti i tasti e i comandi disponibili.
`on ~* &* +@all`
La sintassi della stringa di accesso è suddivisa come segue:
+ `on`— L'utente è un utente attivo.
+ `~*`— L'accesso è dato a tutte le chiavi disponibili.
+ `&*`— L'accesso è dato a tutti i canali pubsub.
+ `+@all`— Accesso a tutti i comandi disponibili.
Le impostazioni precedenti sono le meno restrittive. È possibile modificare queste impostazioni per renderle più sicure.
Nell'esempio seguente, la stringa di accesso rappresenta un utente con accesso limitato all'accesso in lettura sulle chiavi che iniziano con lo spazio delle chiavi «app::»
`on ~app::* -@all +@read`
È possibile perfezionare ulteriormente queste autorizzazioni elencando i comandi a cui l'utente ha accesso:
`+command1`— L'accesso dell'utente ai comandi è limitato a*`command1`*.
`+@category`— L'accesso dell'utente è limitato a una categoria di comandi.
Per informazioni sull'assegnazione di una stringa di accesso a un utente, vedere[Creazione di utenti ed elenchi di controllo degli accessi con la console e la CLI](#users-management).
Se stai migrando un carico di lavoro esistente su MemoryDB, puoi recuperare la stringa di accesso chiamando`ACL LIST`, escludendo l'utente e qualsiasi hash della password.
## Funzionalità di ricerca vettoriale
Infatti[Ricerca vettoriale](vector-search.md), tutti i comandi di ricerca appartengono alla `@search` categoria e alle categorie `@read` esistenti `@fast` e `@slow` vengono aggiornati per includere i comandi di ricerca. `@write` Se un utente non ha accesso a una categoria, non ha accesso a nessun comando all'interno della categoria. Ad esempio, se l'utente non ha accesso a`@search`, non può eseguire alcun comando relativo alla ricerca.
La tabella seguente indica la mappatura dei comandi di ricerca alle categorie appropriate.
| Comandi VSS | @read | @write | @fast | @slow |
| --- | --- | --- | --- | --- |
| FT.CREATE | | Y | Y | |
| FT.DROPINDEX | | Y | Y | |
| FT.LIST | Y | | | Y |
| FT.INFO | Y | | Y | |
| FT.SEARCH | Y | | | Y |
| FT.AGGREGATE | Y | | | Y |
| FT.PROFILE | Y | | | Y |
| FT.ALIASADD | | Y | Y | |
| FT.ALIASDEL | | Y | Y | |
| FT.ALIASUPDATE | | Y | Y | |
| FT.\$1ALIASLIST | Y | | | Y |
| FT.EXPLAIN | Y | | Y | |
| FT.EXPLAINCLI | Y | | Y | |
| FT.CONFIG | Y | | Y | |
## Applicazione ACLs a un cluster per MemoryDB
Per utilizzare MemoryDB ACLs, procedi nel seguente modo:
1. Crea uno o più utenti.
1. Crea un ACL e aggiungi utenti all'elenco.
1. Assegna l'ACL a un cluster.
La tabella seguente descrive i seguenti passaggi nel dettaglio.
**Topics**
+ [Creazione di utenti ed elenchi di controllo degli accessi con la console e la CLI](#users-management)
+ [Gestione degli elenchi di controllo degli accessi con la console e la CLI](#user-groups)
+ [Assegnazione delle liste di controllo degli accessi ai cluster](#users-groups-to-clusterss)
### Creazione di utenti ed elenchi di controllo degli accessi con la console e la CLI
Le informazioni utente per ACLs gli utenti sono un nome utente e, facoltativamente, una password e una stringa di accesso. La stringa di accesso fornisce il livello di autorizzazione per i tasti e i comandi. Il nome è univoco per l'utente ed è quello che viene passato al motore.
Assicurati che le autorizzazioni utente fornite corrispondano allo scopo previsto dell'ACL. Ad esempio, se crei un ACL chiamato`Administrators`, qualsiasi utente aggiunto a quel gruppo dovrebbe avere la stringa di accesso impostata per l'accesso completo a tasti e comandi. Per gli utenti di un `e-commerce` ACL, è possibile impostare le stringhe di accesso in sola lettura.
MemoryDB configura automaticamente un utente predefinito per account con un nome utente. `"default"` Non sarà associato a nessun cluster a meno che non venga aggiunto esplicitamente a un ACL. Non è possibile eliminare o modificare questo utente. Questo utente è progettato per garantire la compatibilità con il comportamento predefinito delle versioni precedenti di Redis OSS e dispone di una stringa di accesso che gli consente di chiamare tutti i comandi e accedere a tutte le chiavi.
Verrà creato un ACL immutabile «ad accesso aperto» per ogni account che contiene l'utente predefinito. Questa è l'unica ACL di cui l'utente predefinito può essere membro. Quando si crea un cluster, è necessario selezionare un ACL da associare al cluster. Sebbene sia possibile applicare l'ACL «ad accesso aperto» all'utente predefinito, consigliamo vivamente di creare un ACL con utenti con autorizzazioni limitate alle esigenze aziendali.
I cluster che non hanno TLS abilitato devono utilizzare l'ACL «ad accesso aperto» per fornire un'autenticazione aperta.
ACLs possono essere creati senza utenti. Un ACL vuoto non avrebbe accesso a un cluster e può essere associato solo a cluster abilitati per TLS.
Quando si crea un utente, è possibile impostare fino a due password. Quando si modifica una password, vengono mantenute tutte le connessioni esistenti ai cluster.
In particolare, tenete presente questi vincoli relativi alla password utente quando utilizzate ACLs for MemoryDB:
+ Le password devono essere da 16 a 128 caratteri stampabili.
+ I seguenti caratteri non alfanumerici non sono consentiti:`,` `""` `/` `@`.
#### Gestione degli utenti con la console e la CLI
##### Creazione di un utente (Console)
**Per creare utenti sulla 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. **Nel riquadro di navigazione a sinistra, scegli Utenti.**
1. Scegli **Crea utente**.
1. Nella pagina **Crea utente**, inserisci un **nome**.
I vincoli di denominazione dei cluster sono i seguenti:
+ Devono contenere da 1 a 40 caratteri alfanumerici o trattini.
+ Devono iniziare con una lettera.
+ Non possono contenere due trattini consecutivi.
+ Non possono terminare con un trattino.
1. In **Password**, puoi inserire fino a due password.
1. In Stringa di **accesso, inserisci una stringa** di accesso. La stringa di accesso imposta il livello di autorizzazione per le chiavi e i comandi consentiti all'utente.
1. Per i **tag**, puoi facoltativamente applicare tag per cercare e filtrare gli utenti o tenere traccia AWS dei costi.
1. Scegli **Create** (Crea).
##### Creazione di un utente utilizzando il AWS CLI
**Per creare un utente utilizzando la CLI**
+ Utilizzate il comando [create-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-user.html) per creare un utente.
Per Linux, macOS o Unix:
```
aws memorydb create-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode \
Passwords="abc",Type=password
```
Per Windows:
```
aws memorydb create-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode \
Passwords="abc",Type=password
```
##### Modifica di un utente (Console)
**Per modificare gli utenti sulla 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. **Nel riquadro di navigazione a sinistra, scegli Utenti.**
1. Scegli il pulsante di opzione accanto all'utente che desideri modificare, quindi scegli **Azioni** -> **Modifica**
1. Se desideri modificare una password, scegli il pulsante di opzione **Modifica password**. Nota che se hai due password, devi inserirle entrambe quando ne modifichi una.
1. Se stai aggiornando la stringa di accesso, inserisci quella nuova.
1. Scegli **Modifica**.
##### Modificare un utente utilizzando AWS CLI
**Per modificare un utente utilizzando la CLI;**
1. Usa il comando [update-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-user.html) per modificare un utente.
1. Quando un utente viene modificato, gli elenchi di controllo degli accessi associati all'utente vengono aggiornati, insieme a tutti i cluster associati all'ACL. Tutte le connessioni esistenti vengono mantenute. Di seguito vengono mostrati gli esempi.
Per Linux, macOS o Unix:
```
aws memorydb update-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*"
```
Per Windows:
```
aws memorydb update-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*"
```
##### Visualizzazione dei dettagli dell'utente (Console)
**Per visualizzare i dettagli dell'utente sulla 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. **Nel riquadro di navigazione a sinistra, scegli Utenti.**
1. Scegli l'utente in **Nome utente** o utilizza la casella di ricerca per trovare l'utente.
1. In **Impostazioni utente** puoi controllare la stringa di accesso, il numero di password, lo stato e l'Amazon Resource Name (ARN) dell'utente.
1. In **Access control lists (ACL)** puoi controllare l'ACL a cui appartiene l'utente.
1. In **Tag** puoi rivedere tutti i tag associati all'utente.
##### Visualizzazione dei dettagli dell'utente utilizzando il AWS CLI
Utilizzare il comando [describe-users](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-users.html) per visualizzare i dettagli di un utente.
```
aws memorydb describe-users \
--user-name my-user-name
```
##### Eliminazione di un utente (Console)
**Per eliminare utenti dalla 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. **Nel riquadro di navigazione a sinistra, scegli Utenti.**
1. Scegli il pulsante di opzione accanto all'utente che desideri modificare, quindi scegli **Azioni** -> **Elimina**
1. Per confermare, inserisci `delete` nella casella di testo di conferma, quindi scegli **Elimina**.
1. Per annullare, scegliere **Cancel (Annulla)**.
##### Eliminazione di un utente utilizzando il AWS CLI
**Per eliminare un utente utilizzando la CLI;**
+ Utilizzare il comando [delete-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-user.html) per eliminare un utente.
L'account viene eliminato e rimosso da tutti gli elenchi di controllo degli accessi a cui appartiene. Di seguito è riportato un esempio di :
Per Linux, macOS o Unix:
```
aws memorydb delete-user \
--user-name user-name-2
```
Per Windows:
```
aws memorydb delete-user ^
--user-name user-name-2
```
### Gestione degli elenchi di controllo degli accessi con la console e la CLI
È possibile creare elenchi di controllo degli accessi per organizzare e controllare l'accesso degli utenti a uno o più cluster, come illustrato di seguito.
Utilizzare la procedura seguente per gestire gli elenchi di controllo degli accessi utilizzando la console.
#### Creazione di una lista di controllo degli accessi (ACL) (console)
**Per creare un elenco di controllo degli accessi utilizzando la 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. Nel riquadro di navigazione a sinistra, scegli **Access control lists (ACL)**.
1. Scegli **Crea ACL**.
1. Nella pagina **Crea lista di controllo di accesso (ACL)**, inserisci un nome ACL.
I vincoli di denominazione dei cluster sono i seguenti:
+ Devono contenere da 1 a 40 caratteri alfanumerici o trattini.
+ Devono iniziare con una lettera.
+ Non possono contenere due trattini consecutivi.
+ Non possono terminare con un trattino.
1. In **Utenti selezionati**, esegui una delle seguenti operazioni:
1. Crea un nuovo utente selezionando **Crea utente**
1. Aggiungi utenti scegliendo **Gestisci**, quindi selezionando gli utenti dalla finestra di dialogo **Gestisci utenti** e quindi selezionando **Scegli**.
1. Per i **tag**, puoi opzionalmente applicare tag per cercare e filtrare ACLs o tenere traccia AWS dei costi.
1. Scegli **Create** (Crea).
#### Creazione di una lista di controllo degli accessi (ACL) utilizzando AWS CLI
Utilizzare le seguenti procedure per creare un elenco di controllo degli accessi utilizzando la CLI.
**Per creare un nuovo ACL e aggiungere un utente utilizzando la CLI**
+ Utilizzate il comando [create-acl per creare un ACL](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-acl.html).
Per Linux, macOS o Unix:
```
aws memorydb create-acl \
--acl-name "new-acl-1" \
--user-names "user-name-1" "user-name-2"
```
Per Windows:
```
aws memorydb create-acl ^
--acl-name "new-acl-1" ^
--user-names "user-name-1" "user-name-2"
```
#### Modifica di una lista di controllo degli accessi (ACL) (console)
**Per modificare un elenco di controllo degli accessi utilizzando la 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. Nel riquadro di navigazione a sinistra, scegli **Access control lists (ACL)**.
1. **Scegli l'ACL che desideri modificare, quindi scegli Modifica**
1. Nella pagina **Modifica**, in **Utenti selezionati**, esegui una delle seguenti operazioni:
1. Crea un nuovo utente scegliendo **Crea utente** da aggiungere all'ACL.
1. **Aggiungi o rimuovi utenti scegliendo **Gestisci**, quindi selezionando o deselezionando gli utenti dalla finestra di dialogo **Gestisci utenti** e quindi selezionando Scegli.**
1. Nella pagina **Crea lista di controllo degli accessi (ACL)**, inserisci un nome ACL.
I vincoli di denominazione dei cluster sono i seguenti:
+ Devono contenere da 1 a 40 caratteri alfanumerici o trattini.
+ Devono iniziare con una lettera.
+ Non possono contenere due trattini consecutivi.
+ Non possono terminare con un trattino.
1. In **Utenti selezionati**, esegui una delle seguenti operazioni:
1. Crea un nuovo utente selezionando **Crea utente**
1. Aggiungi utenti scegliendo **Gestisci**, quindi selezionando gli utenti dalla finestra di dialogo **Gestisci utenti** e quindi selezionando **Scegli**.
1. Scegli **Modifica** per salvare le modifiche o **Annulla** per eliminarle.
#### Modifica di una lista di controllo degli accessi (ACL) utilizzando il AWS CLI
**Per modificare un ACL aggiungendo nuovi utenti o rimuovendo i membri correnti utilizzando la CLI**
+ Utilizzate il comando [update-acl per modificare un ACL](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-acl.html).
Per Linux, macOS o Unix:
```
aws memorydb update-acl --acl-name new-acl-1 \
--user-names-to-add user-name-3 \
--user-names-to-remove user-name-2
```
Per Windows:
```
aws memorydb update-acl --acl-name new-acl-1 ^
--user-names-to-add user-name-3 ^
--user-names-to-remove user-name-2
```
**Nota**
Tutte le connessioni aperte appartenenti a un utente rimosso da un ACL vengono terminate con questo comando.
#### Visualizzazione dei dettagli dell'Access Control List (ACL) (Console)
**Per visualizzare i dettagli ACL sulla 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. Nel riquadro di navigazione a sinistra, scegli **Access control lists (ACL)**.
1. Scegli l'ACL sotto il **nome ACL** o usa la casella di ricerca per trovare l'ACL.
1. In **Utenti** puoi visualizzare l'elenco degli utenti associati all'ACL.
1. In **Cluster associati** è possibile esaminare il cluster a cui appartiene l'ACL.
1. In **Tag** è possibile esaminare tutti i tag associati all'ACL.
#### Visualizzazione degli elenchi di controllo degli accessi (ACL) utilizzando il AWS CLI
Utilizzate il comando [describe-acls](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-acls.html) per visualizzare i dettagli di un ACL.
```
aws memorydb describe-acls \
--acl-name test-group
```
#### Eliminazione di un Access Control List (ACL) (console)
**Per eliminare gli elenchi di controllo degli accessi utilizzando la 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. Nel riquadro di navigazione a sinistra, scegli **Access control lists (ACL)**.
1. **Scegli l'ACL che desideri modificare, quindi scegli Elimina**
1. Nella pagina **Elimina**, inserisci `delete` la casella di conferma e scegli **Elimina** o **Annulla** per evitare di eliminare l'ACL.
L'ACL stesso, non gli utenti appartenenti al gruppo, viene eliminato.
#### Eliminazione di una lista di controllo degli accessi (ACL) utilizzando AWS CLI
**Per eliminare un ACL utilizzando la CLI**
+ Utilizzate il comando [delete-acl per eliminare un ACL](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-acl.html).
Per Linux, macOS o Unix:
```
aws memorydb delete-acl /
--acl-name
```
Per Windows:
```
aws memorydb delete-acl ^
--acl-name
```
Gli esempi precedenti restituiscono la risposta seguente.
```
aws memorydb delete-acl --acl-name "new-acl-1"
{
"ACLName": "new-acl-1",
"Status": "deleting",
"EngineVersion": "6.2",
"UserNames": [
"user-name-1",
"user-name-3"
],
"clusters": [],
"ARN":"arn:aws:memorydb:us-east-1:493071037918:acl/new-acl-1"
}
```
### Assegnazione delle liste di controllo degli accessi ai cluster
Dopo aver creato un ACL e aggiunto gli utenti, il passaggio finale dell'implementazione ACLs consiste nell'assegnare l'ACL a un cluster.
#### Assegnazione degli elenchi di controllo degli accessi ai cluster tramite la console
Per aggiungere un ACL a un cluster utilizzando il Console di gestione AWS, vedere. [Creazione di un cluster MemoryDB](getting-started.md#clusters.create)
#### Assegnazione delle liste di controllo degli accessi ai cluster Utilizzando il AWS CLI
La seguente AWS CLI operazione crea un cluster con la crittografia in transito (TLS) abilitata e il **acl-name** parametro con il valore. `my-acl-name` Sostituisci il gruppo di sottoreti `subnet-group` con uno esistente.
**Parametri chiave**
+ **--engine-version**— Deve essere 6.2.
+ **--tls-enabled**— Utilizzato per l'autenticazione e per associare un ACL.
+ **--acl-name**— Questo valore fornisce elenchi di controllo degli accessi composti da utenti con autorizzazioni di accesso specifiche per il cluster.
Per Linux, macOS o Unix:
```
aws memorydb create-cluster \
--cluster-name "new-cluster" \
--description "new-cluster" \
--engine-version "6.2" \
--node-type db.r6g.large \
--tls-enabled \
--acl-name "new-acl-1" \
--subnet-group-name "subnet-group"
```
Per Windows:
```
aws memorydb create-cluster ^
--cluster-name "new-cluster" ^
--cluster-description "new-cluster" ^
--engine-version "6.2" ^
--node-type db.r6g.large ^
--tls-enabled ^
--acl-name "new-acl-1" ^
--subnet-group-name "subnet-group"
```
La seguente AWS CLI operazione modifica un cluster con la crittografia in transito (TLS) abilitata e il **acl-name** parametro con il valore. `new-acl-2`
Per Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name cluster-1 \
--acl-name "new-acl-2"
```
Per Windows:
```
aws memorydb update-cluster ^
--cluster-name cluster-1 ^
--acl-name "new-acl-2"
```
# Autenticazione con IAM
**Topics**
+ [Panoramica di](#auth-iam-overview)
+ [Limitazioni](#auth-iam-limits)
+ [Configurazione](#auth-iam-setup)
+ [Connessione](#auth-iam-Connecting)
## Panoramica di
Con IAM Authentication puoi autenticare una connessione a MemoryDB utilizzando identità AWS IAM, quando il cluster è configurato per utilizzare Valkey o Redis OSS versione 7 o successiva. Ciò consente di consolidare il modello di sicurezza e semplificare molte attività di sicurezza amministrative. Con IAM Authentication puoi configurare un controllo granulare degli accessi per ogni singolo cluster di MemoryDB e utente di MemoryDB e seguire i principi delle autorizzazioni con privilegi minimi. L'autenticazione IAM per MemoryDB funziona fornendo un token di autenticazione IAM di breve durata anziché una password utente MemoryDB di lunga durata nel comando or. `AUTH` `HELLO` Per ulteriori informazioni sul token di autenticazione IAM, consulta il [processo di firma Signature Version 4](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html) nella AWS General Reference Guide e l'esempio di codice riportato di seguito.
Puoi utilizzare le identità IAM e le relative politiche associate per limitare ulteriormente l'accesso a Valkey o Redis OSS. Puoi anche concedere l'accesso agli utenti dei loro provider di identità federati direttamente ai cluster MemoryDB.
Per utilizzare AWS IAM con MemoryDB, devi prima creare un utente MemoryDB con la modalità di autenticazione impostata su IAM, quindi puoi creare o riutilizzare un'identità IAM. L'identità IAM necessita di una policy associata per concedere l'`memorydb:Connect`azione al cluster MemoryDB e all'utente MemoryDB. Una volta configurato, puoi creare un token di autenticazione IAM utilizzando AWS le credenziali dell'utente o del ruolo IAM. Infine, è necessario fornire il token di autenticazione IAM di breve durata come password nel client Valkey o Redis OSS quando ci si connette al nodo del cluster MemoryDB. Un client con supporto per il provider di credenziali può generare automaticamente le credenziali temporanee per ogni nuova connessione. MemoryDB eseguirà l'autenticazione IAM per le richieste di connessione degli utenti di MemoryDB abilitati a IAM e convaliderà le richieste di connessione con IAM.
## Limitazioni
Durante l'utilizzo dell'autenticazione IAM, valgono le seguenti limitazioni:
+ L'autenticazione IAM è disponibile quando si utilizza la versione 7.0 o successiva del motore Valkey o Redis OSS.
+ Il token di autenticazione IAM è valido per 15 minuti. Per connessioni di lunga durata, consigliamo di utilizzare un client Redis OSS che supporti un'interfaccia con un provider di credenziali.
+ Una connessione autenticata IAM a MemoryDB verrà automaticamente disconnessa dopo 12 ore. La connessione può essere prolungata per 12 ore inviando un comando `AUTH` o `HELLO` con un nuovo token di autenticazione IAM.
+ L'autenticazione IAM non è supportata nei comandi `MULTI EXEC`.
+ Attualmente, l'autenticazione IAM non supporta nessuna delle chiavi di contesto delle condizioni globali. Per ulteriori informazioni sulle chiavi di contesto delle condizioni globali, consultare [Chiavi di contesto delle condizioni globali AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella Guida per l'utente di IAM.
## Configurazione
Per impostare l'autenticazione IAM:
1. Creazione di un cluster
```
aws memorydb create-cluster \
--cluster-name cluster-01 \
--description "MemoryDB IAM auth application"
--node-type db.r6g.large \
--engine-version 7.0 \
--acl-name open-access
```
1. Crea un documento della policy di attendibilità IAM per il ruolo, come mostrato di seguito, che consenta all'account di assumere il nuovo ruolo. Salva la policy in un file denominato *trust-policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:root" },
"Action": "sts:AssumeRole"
}
}
```
------
1. Crea un documento della policy IAM, come mostrato di seguito. Salva la policy in un file denominato *policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect" : "Allow",
"Action" : [
"memorydb:connect"
],
"Resource" : [
"arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01",
"arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01"
]
}
]
}
```
------
1. Crea un ruolo IAM.
```
aws iam create-role \
--role-name "memorydb-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Creare la policy IAM.
```
aws iam create-policy \
--policy-name "memorydb-allow-all" \
--policy-document file://policy.json
```
1. Allega la policy IAM al ruolo.
```
aws iam attach-role-policy \
--role-name "memorydb-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/memorydb-allow-all"
```
1. Crea un nuovo utente attivato da IAM.
```
aws memorydb create-user \
--user-name iam-user-01 \
--authentication-mode Type=iam \
--access-string "on ~* +@all"
```
1. Crea un ACL e collega l'utente.
```
aws memorydb create-acl \
--acl-name iam-acl-01 \
--user-names iam-user-01
aws memorydb update-cluster \
--cluster-name cluster-01 \
--acl-name iam-acl-01
```
## Connessione
**Connetti con token come password**
È innanzitutto necessario generare il token di autenticazione IAM di breve durata utilizzando una [richiesta prefirmata AWS SigV4](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html). Dopodiché, fornisci il token di autenticazione IAM come password quando ti connetti a un cluster MemoryDB, come mostrato nell'esempio seguente.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
String region = "insert region"
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request and signed it using the AWS credentials.
// The pre-signed request URL is used as an IAM authentication token for MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userName, iamAuthToken)
.build();
// Create a new Lettuce client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
Di seguito è riportata la definizione per `IAMAuthTokenRequest`.
```
public class IAMAuthTokenRequest {
private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET;
private static final String REQUEST_PROTOCOL = "http://";
private static final String PARAM_ACTION = "Action";
private static final String PARAM_USER = "User";
private static final String ACTION_NAME = "connect";
private static final String SERVICE_NAME = "memorydb";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userName;
private final String clusterName;
private final String region;
public IAMAuthTokenRequest(String userName, String clusterName, String region) {
this.userName = userName;
this.clusterName = clusterName;
this.region = region;
}
public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException {
Request request = getSignableRequest();
sign(request, credentials);
return new URIBuilder(request.getEndpoint())
.addParameters(toNamedValuePair(request.getParameters()))
.build()
.toString()
.replace(REQUEST_PROTOCOL, "");
}
private Request getSignableRequest() {
Request request = new DefaultRequest<>(SERVICE_NAME);
request.setHttpMethod(REQUEST_METHOD);
request.setEndpoint(getRequestUri());
request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME));
request.addParameters(PARAM_USER, Collections.singletonList(userName));
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, clusterName));
}
private void sign(SignableRequest request, AWSCredentials credentials) {
AWS4Signer signer = new AWS4Signer();
signer.setRegionName(region);
signer.setServiceName(SERVICE_NAME);
DateTime dateTime = DateTime.now();
dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS));
signer.presignRequest(request, credentials, dateTime.toDate());
}
private static List toNamedValuePair(Map> in) {
return in.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
.collect(Collectors.toList());
}
}
```
**Connetti con provider di credenziali**
Il codice seguente mostra come autenticarsi con MemoryDB utilizzando il provider di credenziali di autenticazione IAM.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
String region = "insert region"
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request. Once this request is signed it can be used as an
// IAM authentication token for MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
// Create a credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userName, iamAuthTokenRequest, awsCredentialsProvider);
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
Di seguito è riportato un esempio di client cluster Lettuce che lo inserisce IAMAuth TokenRequest in un provider di credenziali per generare automaticamente credenziali temporanee quando necessario.
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userName;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userName,
IAMAuthTokenRequest iamAuthTokenRequest,
AWSCredentialsProvider awsCredentialsProvider) {
this.userName = userName;
this.awsCredentialsProvider = awsCredentialsProvider;
this.iamAuthTokenRequest = iamAuthTokenRequest;
this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS);
}
@Override
public Mono resolveCredentials() {
return Mono.just(RedisCredentials.just(userName, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
```