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à.
# Guida introduttiva ad Amazon ElastiCache
Usa il tutorial pratico in questa sezione per iniziare e saperne di più sull'utilizzo. ElastiCache
**Topics**
+ [Configurazione ElastiCache](set-up.md)
+ [Crea una cache senza server Valkey](GettingStarted.serverless-valkey.step1.md)
+ [Crea una cache serverless Redis OSS](GettingStarted.serverless-redis.step1.md)
+ [Crea una cache serverless Memcached](create-serverless-cache-mem.md)
+ [Tutorial: Guida introduttiva a Python e ElastiCache](ElastiCache-Getting-Started-Tutorials.md)
+ [Tutorial: Configurazione di Lambda per ElastiCache l'accesso in un VPC](LambdaRedis.md)
# Configurazione ElastiCache
Per utilizzare il servizio ElastiCache web, segui questi passaggi.
**Topics**
+ [Registrati per un Account AWS](#sign-up-for-aws)
+ [Crea un utente con accesso amministrativo](#create-an-admin)
+ [Concessione dell'accesso programmatico](#elasticache-set-up-access-key)
+ [Impostazione delle autorizzazioni](#elasticache-set-up-permissions)
+ [Configurare EC2](#elasticache-install-configure-ec2)
+ [Assegnazione dell'accesso di rete](#elasticache-install-grant-access-VPN)
+ [Configura l'accesso alla riga di comando](#Download-and-install-cli)
## Registrati per un Account AWS
Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.
**Per iscriverti a un Account AWS**
1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)
1. Segui le istruzioni online.
Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.
Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.
## Crea un utente con accesso amministrativo
Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWSAWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.
**Proteggi i tuoi Utente root dell'account AWS**
1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.
Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) della *Guida per l’utente di Accedi ad AWS*.
1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.
Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.
**Crea un utente con accesso amministrativo**
1. Abilita il Centro identità IAM.
Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center*.
1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.
Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.
**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.
Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.
**Assegnazione dell’accesso ad altri utenti**
1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.
Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center*.
1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).
Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center*.
## Concessione dell'accesso programmatico
Gli utenti hanno bisogno di un accesso programmatico se vogliono interagire con l'AWSConsole di gestione AWS esterno di. Il modo per concedere l'accesso programmatico dipende dal tipo di utente che accede.AWS
Per fornire agli utenti l’accesso programmatico, scegli una delle seguenti opzioni.
****
| Quale utente necessita dell’accesso programmatico? | Per | Come |
| --- | --- | --- |
| IAM | (Consigliato) Utilizza le credenziali della console come credenziali temporanee per firmare le richieste programmatiche a,, o.AWS CLIAWS SDKs AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/set-up.html) |
| Identità della forza lavoro (Utenti gestiti nel centro identità IAM) | Utilizza credenziali temporanee per firmare le richieste programmatiche a AWS CLI,AWS SDKs, o.AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | Utilizza credenziali temporanee per firmare le richieste programmatiche a AWS CLI,AWS SDKs, o.AWS APIs | Seguendo le istruzioni riportate in [Utilizzo delle credenziali temporanee con le AWS risorse nella Guida per](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) l'utente IAM. |
| IAM | (Non consigliato)Utilizza credenziali a lungo termine per firmare richieste programmatiche a AWS CLI,,AWS SDKs o.AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/set-up.html) |
**Argomenti correlati:**
+ [Cos'è IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) nella *Guida per l'utente di IAM*.
+ [AWS Informazioni generali sulle credenziali di sicurezza](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)*.AWS*
## Configura le tue autorizzazioni (solo nuovi ElastiCache utenti)
Per fornire l’accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:
+ Utenti e gruppi in AWS IAM Identity Center:
Crea un set di autorizzazioni. Segui le istruzioni riportate nella pagina [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) (Creazione di un set di autorizzazioni) nella *Guida per l’utente di AWS IAM Identity Center*.
+ Utenti gestiti in IAM tramite un provider di identità:
Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate nella pagina [Create a role for a third-party identity provider (federation)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) della *Guida per l’utente IAM*.
+ Utenti IAM:
+ Crea un ruolo che l’utente possa assumere. Segui le istruzioni riportate nella pagina [Create a role for an IAM user](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) della *Guida per l’utente IAM*.
+ (Non consigliato) Collega una policy direttamente a un utente o aggiungi un utente a un gruppo di utenti. Segui le istruzioni riportate nella pagina [Aggiunta di autorizzazioni a un utente (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) nella *Guida per l’utente IAM*.
Amazon ElastiCache crea e utilizza ruoli collegati ai servizi per fornire risorse e accedere ad altre AWS risorse e servizi per tuo conto. Per creare ElastiCache per te un ruolo collegato ai servizi, utilizza la policy -managed denominata AWS. `AmazonElastiCacheFullAccess` Per questo ruolo viene effettuato il provisioning preventivo con l'autorizzazione necessaria al servizio per creare un ruolo collegato ai servizi per tuo conto.
Potresti decidere di non utilizzare la policy predefinita e di utilizzare piuttosto una policy gestita in modo personalizzato. In questo caso, verificare di avere le autorizzazioni per chiamare `iam:createServiceLinkedRole` o per creare il ruolo collegato ai servizi ElastiCache.
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Creare una nuova policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM)
+ [AWS politiche gestite per Amazon ElastiCache](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Utilizzo di ruoli collegati ai servizi per Amazon ElastiCache](using-service-linked-roles.md)
## Configurare EC2
Dovrai configurare un' EC2 istanza da cui connetterti alla cache.
+ Se non disponi già di un' EC2 istanza, scopri come configurarla qui: [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html). EC2
+ L' EC2 istanza deve trovarsi nello stesso VPC e avere le stesse impostazioni del gruppo di sicurezza della cache. Per impostazione predefinita, Amazon ElastiCache crea una cache nel tuo VPC predefinito e utilizza il gruppo di sicurezza predefinito. Per seguire questo tutorial, assicurati che la tua EC2 istanza si trovi nel VPC predefinito e abbia il gruppo di sicurezza predefinito.
## Assegnazione dell'accesso di rete di un gruppo di sicurezza Amazon VPC alla cache
ElastiCache i cluster basati su nodi utilizzano la porta 6379 per i comandi Valkey e Redis OSS e ElastiCache serverless utilizza sia la porta 6379 che la porta 6380. Per connettere ed eseguire correttamente i comandi Valkey o Redis OSS dall' EC2 istanza, il gruppo di sicurezza deve consentire l'accesso a queste porte secondo necessità.
ElastiCache for Memcached utilizza le porte 11211 e 11212 per accettare i comandi Memcached. Per connettere ed eseguire correttamente i comandi Memcached dall' EC2 istanza, il gruppo di sicurezza deve consentire l'accesso a queste porte.
1. Accedi AWS Command Line Interface e apri la [ EC2 console Amazon](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, in **Rete e sicurezza**, scegli **Gruppi di sicurezza**.
1. Dall'elenco dei gruppi di sicurezza, scegli il gruppo di sicurezza per il VPC Amazon. A meno che tu non abbia creato un gruppo di sicurezza da ElastiCache utilizzare, questo gruppo di sicurezza verrà denominato *predefinito*.
1. Seleziona la scheda In entrata, quindi:
1. Scegli **Modifica**.
1. Scegli **Aggiungi regola**.
1. Nella colonna Tipo, scegli **Regola TCP personalizzata**.
1. Se usi Valkey o Redis OSS, nella casella **Intervallo di porte**, digita. `6379`
Se si utilizza Memcached, nella casella **Intervallo di porte**, digitare. `11211`
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 alla cache.
1. **Se utilizzi ElastiCache serverless, aggiungi un'altra regola scegliendo Aggiungi regola.**
1. Nella colonna **Tipo**, scegli **Regola TCP personalizzata**.
1. Se lo utilizzi ElastiCache per Redis OSS, nella casella **Intervallo di porte**, digita. `6380`
Se si utilizza ElastiCache per Memcached, nella casella **Intervallo di porte**, digitare. `11212`
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 alla cache.
1. Seleziona **Salva**
## Scarica e configura l'accesso alla riga di comando
***Scarica e installa l'utilità valkey-cli.***
Se usi ElastiCache Valkey, potresti trovare utile l'utilità valkey-cli. Se utilizzi Redis OSS con ElastiCache redis-cli, valuta la possibilità di passare a valkey-cli poiché funziona anche per Redis OSS.
1. Connettiti alla tua EC2 istanza Amazon utilizzando l'utilità di connessione che preferisci. Per istruzioni su come connettersi a un' EC2 istanza Amazon, consulta la [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
1. Scarica e installa l'utilità valkey-cli eseguendo il comando appropriato per la tua configurazione.
**Amazon Linux 2**
```
sudo amazon-linux-extras install epel -y
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel -y
wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz
tar xvzf valkey-8.0.0.tar.gz
cd valkey-8.0.0
make BUILD_TLS=yes
```
**Nota**
Quando installi il pacchetto redis6, viene installato redis6-cli con il supporto di crittografia predefinito.
È importante disporre del supporto di build per TLS durante l'installazione di valkey-cli o redis-cli. ElastiCache Serverless è accessibile solo quando TLS è abilitato.
Se ci si connette a un cluster non crittografato, non è necessaria l'opzione `Build_TLS=yes`.
# Crea una cache serverless Valkey
In questo passaggio, crei una nuova cache in Amazon ElastiCache.
**Console di gestione AWS**
Per creare una nuova cache utilizzando la ElastiCache console:
1. Accedi a Console di gestione AWS e apri il [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Valkey caches**.
1. Sul lato destro della console, scegli **Crea** cache Valkey
1. In **Impostazioni cache** inserisci un **nome**. Facoltativamente, è possibile inserire una **descrizione** per la cache.
1. Lascia le impostazioni predefinite selezionate.
1. Fai clic su **Crea** per creare la cache.
1. Una volta che lo stato della cache è "ATTIVO", puoi iniziare a scrivere e leggere i dati nella cache.
**AWS CLI**
L' AWS CLI esempio seguente crea una nuova cache utilizzando create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine valkey
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine valkey
```
Il valore del campo Stato è impostato su `CREATING`.
Per verificare di aver ElastiCache terminato la creazione della cache, utilizzare il `describe-serverless-caches` comando.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Dopo aver creato la nuova cache, procedi alla [Leggi e scrivi dati nella cache](GettingStarted.serverless-valkey.step2.md).
# Leggi e scrivi dati nella cache
Questa sezione presuppone che tu abbia creato un' EC2 istanza Amazon e che tu possa connetterti ad essa. Per istruzioni su come eseguire questa operazione, consulta la [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
Questa sezione presuppone inoltre che tu abbia configurato l'accesso al VPC e le impostazioni del gruppo di sicurezza per EC2 l'istanza da cui ti connetti alla cache e che tu abbia configurato valkey-cli sull'istanza. EC2 Per ulteriori informazioni su questa fase, consulta [Configurazione ElastiCache](set-up.md).
Oltre ai passaggi seguenti, se disponi di un'applicazione di grandi dimensioni o globale, puoi aumentare notevolmente le prestazioni di lettura creando e leggendo da repliche. Per ulteriori informazioni su questo passaggio più avanzato, vedere[Procedure consigliate per l'utilizzo delle repliche di lettura](ReadReplicas.md).
**Ricerca dell'endpoint della cache**
**Console di gestione AWS**
Per trovare l'endpoint della cache utilizzando la ElastiCache console:
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Valkey caches**.
1. Sul lato destro della console fai clic sul nome della cache che hai appena creato.
1. In **Dettagli della cache** individua e copia l'endpoint della cache.
**AWS CLI**
L'AWS CLI esempio seguente mostra come trovare l'endpoint per la nuova cache utilizzando il comando. describe-serverless-caches Dopo aver eseguito il comando, cerca il campo "Endpoint".
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connect a Valkey Cache (Linux)
Ora che hai l'endpoint di cui hai bisogno, puoi accedere alla tua EC2 istanza e connetterti alla cache. Nell'esempio seguente, si utilizza l'utilità *valkey-cli* per connettersi a un cluster. Il comando seguente esegue la connessione a una cache (nota: sostituisci cache-endpoint con l'endpoint recuperato nella fase precedente).
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Connect a Valkey Cache (Windows)
Ora che hai l'endpoint di cui hai bisogno, puoi accedere alla tua EC2 istanza e connetterti alla cache. Nell'esempio seguente, si utilizza l'utilità *valkey-cli* per connettersi a un cluster. Il seguente comando esegue la connessione a una cache. Apri il prompt dei comandi, passa alla directory Valkey o Redis OSS ed esegui il comando (nota: sostituisci Cache\$1Endpoint con l'endpoint recuperato nel passaggio precedente).
```
c:\Valkey>valkey-cli -h Valkey_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Ora puoi procedere alla [(Facoltativo) Pulizia](GettingStarted.serverless-valkey.step3.md).
# (Facoltativo) Pulizia
Se non ti serve più la ElastiCache cache Amazon che hai creato, puoi eliminarla. In questo modo hai la certezza che non ti vengano addebitati costi per risorse che non stai utilizzando. Puoi utilizzare la ElastiCache console AWS CLI, l'o l' ElastiCache API per eliminare la cache.
**Console di gestione AWS**
Per eliminare la cache tramite la console:
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Valkey Caches**.
1. Scegli il pulsante di opzione accanto alla cache che vuoi eliminare.
1. Seleziona **Operazioni** in alto a destra e scegli **Elimina**.
1. Facoltativamente, puoi scegliere di acquisire uno snapshot finale prima di eliminare la cache.
1. Nella schermata di conferma **Elimina** reinserisci il nome della cache e scegli **Elimina** per eliminare la cache o **Annulla** per mantenerla.
Non appena la cache passa allo stato **ELIMINAZIONE IN CORSO**, non vengono più addebitati i costi.
**AWS CLI**
L' AWS CLI esempio seguente elimina una cache utilizzando il comando. delete-serverless-cache
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Il valore del campo **Stato** è impostato su **ELIMINAZIONE IN CORSO**.
Ora puoi procedere alla [Fasi successive](GettingStarted.serverless-valkey.next-steps.md).
# Fasi successive
Per maggiori informazioni su questo argomento, ElastiCache consulta le seguenti pagine:
+ [Lavorare con ElastiCache](WorkingWithElastiCache.md)
+ [Ridimensionamento ElastiCache](Scaling.md)
+ [Registrazione e monitoraggio in Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache migliori pratiche e strategie di caching](BestPractices.md)
+ [Snapshot e ripristino](backups.md)
+ [Monitoraggio degli eventi con Amazon SNS ElastiCache](ECEvents.md)
# Crea una cache serverless Redis OSS
In questo passaggio, crei una nuova cache in Amazon ElastiCache.
**Console di gestione AWS**
Per creare una nuova cache utilizzando la ElastiCache console:
1. Accedi Console di gestione AWS e apri la ElastiCache console all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Cache Redis OSS**.
1. Sul lato destro della console, scegli **Crea cache Redis OSS**
1. In **Impostazioni cache** inserisci un **nome**. Facoltativamente, è possibile inserire una **descrizione** per la cache.
1. Lascia le impostazioni predefinite selezionate.
1. Fai clic su **Crea** per creare la cache.
1. Una volta che lo stato della cache è "ATTIVO", puoi iniziare a scrivere e leggere i dati nella cache.
**AWS CLI**
L' AWS CLI esempio seguente crea una nuova cache utilizzando create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis
```
Il valore del campo Stato è impostato su `CREATING`.
Per verificare di aver ElastiCache terminato la creazione della cache, utilizzare il `describe-serverless-caches` comando.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Dopo aver creato la nuova cache, procedi alla [Leggi e scrivi dati nella cache](GettingStarted.serverless-redis.step2.md).
# Leggi e scrivi dati nella cache
Questa sezione presuppone che tu abbia creato un' EC2 istanza Amazon e che tu possa connetterti ad essa. Per istruzioni su come eseguire questa operazione, consulta la [Amazon EC2 Getting Started Guide](https://aws.amazon.com/ec2/getting-started/).
Questa sezione presuppone inoltre che tu abbia configurato l'accesso al VPC e le impostazioni del gruppo di sicurezza per EC2 l'istanza da cui ti connetti alla cache e che tu abbia configurato valkey-cli sull'istanza. EC2 Per ulteriori informazioni su questa fase, consulta [Configurazione ElastiCache](set-up.md).
**Ricerca dell'endpoint della cache**
**Console di gestione AWS**
Per trovare l'endpoint della cache utilizzando la console: ElastiCache
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Valkey caches** **Redis** OSS.
1. Sul lato destro della console fai clic sul nome della cache che hai appena creato.
1. In **Dettagli della cache** individua e copia l'endpoint della cache.
**AWS CLI**
L'AWS CLI esempio seguente mostra come trovare l'endpoint per la nuova cache utilizzando il comando. describe-serverless-caches Dopo aver eseguito il comando, cerca il campo "Endpoint".
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connect a Valkey o Redis OSS Cache (Linux)
Ora che hai l'endpoint di cui hai bisogno, puoi accedere alla tua EC2 istanza e connetterti alla cache. Nell'esempio seguente, si utilizza l'utilità *valkey-cli* per connettersi a un cluster. Il comando seguente esegue la connessione a una cache (nota: sostituisci cache-endpoint con l'endpoint recuperato nella fase precedente).
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Connect alla tua Valkey o Redis OSS Cache (Windows)
Ora che hai l'endpoint di cui hai bisogno, puoi accedere all' EC2 istanza e connetterti alla cache. Nell'esempio seguente, si utilizza l'utilità *valkey-cli* per connettersi a un cluster. Il seguente comando esegue la connessione a una cache. Aprite il prompt dei comandi, passate alla directory Valkey ed eseguite il comando (nota: sostituite Cache\$1Endpoint con l'endpoint recuperato nel passaggio precedente).
```
c:\Redis>valkey-cli -h Redis_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Ora puoi procedere alla [(Facoltativo) Pulizia](GettingStarted.serverless-redis.step3.md).
# (Facoltativo) Pulizia
Se non ti serve più la ElastiCache cache Amazon che hai creato, puoi eliminarla. In questo modo hai la certezza che non ti vengano addebitati costi per risorse che non stai utilizzando. Puoi utilizzare la ElastiCache console AWS CLI, l'o l' ElastiCache API per eliminare la cache.
**Console di gestione AWS**
Per eliminare la cache tramite la console:
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Valkey o Redis OSS** Caches.
1. Scegli il pulsante di opzione accanto alla cache che vuoi eliminare.
1. Seleziona **Operazioni** in alto a destra e scegli **Elimina**.
1. Facoltativamente, puoi scegliere di acquisire uno snapshot finale prima di eliminare la cache.
1. Nella schermata di conferma **Elimina** reinserisci il nome della cache e scegli **Elimina** per eliminare la cache o **Annulla** per mantenerla.
Non appena la cache passa allo stato **ELIMINAZIONE IN CORSO**, non vengono più addebitati i costi.
**AWS CLI**
L' AWS CLI esempio seguente elimina una cache utilizzando il comando. delete-serverless-cache
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Il valore del campo **Stato** è impostato su **ELIMINAZIONE IN CORSO**.
Ora puoi procedere alla [Fasi successive](GettingStarted.serverless-redis.next-steps.md).
# Fasi successive
Per maggiori informazioni su questo argomento, ElastiCache consulta le seguenti pagine:
+ [Lavorare con ElastiCache](WorkingWithElastiCache.md)
+ [Ridimensionamento ElastiCache](Scaling.md)
+ [Registrazione e monitoraggio in Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache migliori pratiche e strategie di caching](BestPractices.md)
+ [Snapshot e ripristino](backups.md)
+ [Monitoraggio degli eventi con Amazon SNS ElastiCache](ECEvents.md)
# Crea una cache serverless Memcached
**Console di gestione AWS**
Per creare una nuova cache serverless Memcached utilizzando la console: ElastiCache
1. Accedi Console di gestione AWS e apri la console all'indirizzo. ElastiCache [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. Nel riquadro di navigazione sul lato sinistro della console scegli **Cache Memcached**.
1. Sul lato destro della console scegli **Crea cache Memcached**.
1. In **Impostazioni cache** inserisci un **nome**. Facoltativamente, è possibile inserire una **descrizione** per la cache.
1. Lascia le impostazioni predefinite selezionate.
1. Fai clic su **Crea** per creare la cache.
1. Una volta che lo stato della cache è "ATTIVO", puoi iniziare a scrivere e leggere i dati nella cache.
Per creare una nuova cache utilizzando il AWS CLI
L' AWS CLI esempio seguente crea una nuova cache utilizzando create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine memcached
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine memcached
```
Il valore del campo Stato è impostato su `CREATING`.
Per verificare di aver ElastiCache terminato la creazione della cache, utilizzare il `describe-serverless-caches` comando.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Dopo aver creato la nuova cache, procedi alla [Leggi e scrivi dati nella cache](read-write-cache-mem.md).
# Leggi e scrivi dati nella cache
Questa sezione presuppone che tu abbia creato un' EC2 istanza Amazon e che tu possa connetterti ad essa. Per istruzioni su come eseguire questa operazione, consulta la [Amazon EC2 Getting Started Guide](https://aws.amazon.com/ec2/getting-started/).
Per impostazione predefinita, ElastiCache crea una cache nel tuo VPC predefinito. Assicurati che l' EC2 istanza sia creata anche nel VPC predefinito, in modo che sia in grado di connettersi alla cache.
**Ricerca dell'endpoint della cache**
**Console di gestione AWS**
Per trovare l'endpoint della cache utilizzando la ElastiCache console:
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nel riquadro di navigazione sul lato sinistro della console scegli **Cache Memcached**.
1. Sul lato destro della console fai clic sul nome della cache che hai appena creato.
1. In **Dettagli della cache** individua e copia l'endpoint della cache.
**AWS CLI**
L'AWS CLI esempio seguente mostra come trovare l'endpoint per la nuova cache utilizzando il describe-serverless-caches comando. Dopo aver eseguito il comando, cerca il campo "Endpoint".
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connessione tramite OpenSSL
Per informazioni su come eseguire la connessione tramite OpenSSL, consulta [ElastiCache crittografia in transito (TLS)](in-transit-encryption.md).
## Connessione tramite il client Memcached Java
```
import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.FailureMode;
import net.spy.memcached.MemcachedClient;
public class TLSDemo {
public static void main(String[] args) throws Exception {
ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
// Build SSLContext
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init((KeyStore) null);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);
// Create the client in TLS mode
connectionFactoryBuilder.setSSLContext(sslContext);
// Set Failure Mode to Retry
connectionFactoryBuilder.setFailureMode(FailureMode.Retry);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster-fnjyzo.serverless.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## Connessione tramite il client Memcached PHP
```
addServer($cluster_endpoint, $server_port);
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.serverless.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
$tls_client->createAndSetTLSContext((array)$tls_config);
/* store the data for 60 seconds in the cluster */
$tls_client->set('key', 'value', 60);
?>
```
## Connessione tramite il client Memcached Python (Pymemcache)
Vedi [https://pymemcache.readthedocs. io/en/latest/getting\$1started.html](https://pymemcache.readthedocs.io/en/latest/getting_started.html)
```
import ssl
from pymemcache.client.base import Client
context = ssl.create_default_context()
cluster_endpoint =
target_port = 11211
memcached_client = Client(("{cluster_endpoint}", target_port), tls_context=context)
memcached_client.set("key", "value", expire=500, noreply=False)
assert self.memcached_client.get("key").decode() == "value"
```
## Connect utilizzando il NodeJS/TS client Memcached (Electrode-IO memcache)
[Vedi https://github.com/electrode-io/ memcache e [https://www.npmjs.com/package/memcache-client](https://www.npmjs.com/package/memcache-client)](https://github.com/electrode-io/memcache)
Installa usando `npm i memcache-client`.
Nell'applicazione, crea un client TLS Memcached come segue:
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Connessione tramite il client Memcached Rust (rust-memcache)
[Vedi https://crates. io/crates/memcache](https://crates.io/crates/memcache)e [https://github.com/aisk/rust-memcache](https://github.com/aisk/rust-memcache).
```
// create connection with to memcached server node:
let client = memcache::connect("memcache+tls://:11211?verify_mode=none").unwrap();
// set a string value
client.set("foo", "bar", 0).unwrap();
```
## Connessione tramite il client Memcached Go (Gomemcache)
[https://github.com/bradfitz/Vedi gomemcache](https://github.com/bradfitz/gomemcache)
```
c := New(net.JoinHostPort("{cluster_endpoint}", strconv.Itoa(port)))
c.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
var td tls.Dialer
td.Config = &tls.Config{}
return td.DialContext(ctx, network, addr)
}
foo := &Item{Key: "foo", Value: []byte("fooval"), Flags: 123}
err := c.Set(foo)
```
## Connessione tramite il client Memcached Ruby (Dalli)
[Vedi dalli https://github.com/petergoldstein/](https://github.com/petergoldstein/dalli)
```
require 'dalli'
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.ssl_version = :SSLv23
ssl_context.verify_hostname = true
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
client = Dalli::Client.new(":11211", :ssl_context => ssl_context);
client.get("abc")
```
## Connect utilizzando il client Memcached .NET () EnyimMemcachedCore
Per informazioni, consultare [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore).
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
Ora puoi procedere alla [(Facoltativo) Pulizia](read-write-cleanup-mem.md).
# (Facoltativo) Pulizia
**Utilizzando il Console di gestione AWS**
La procedura seguente elimina una sola cache dall'implementazione. Per eliminare più cache, ripeti la procedura per ogni cache da eliminare. Non occorre attendere la fine dell'eliminazione di una cache prima di avviare la procedura per eliminarne un'altra.
**Per eliminare una cache**
1. Accedi a Console di gestione AWS e apri la ElastiCache console Amazon all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Nella dashboard della ElastiCache console, scegli il motore in esecuzione sulla cache che desideri eliminare. Viene visualizzato un elenco di tutte le cache che eseguono quel motore.
1. Per scegliere la cache da eliminare, seleziona il nome della cache nell'elenco.
**Importante**
Puoi eliminare solo una cache alla volta dalla ElastiCache console. La selezione di più cache disabilita l'operazione di eliminazione.
1. In **Actions (Azioni)**, scegliere **Delete (Elimina)**.
1. Nella schermata di conferma **Elimina cache** scegli **Elimina** per eliminare la cache o scegli **Annulla** per mantenerla.
1. Se si sceglie **Elimina**, lo stato della cache diventa *Eliminazione in corso*.
Non appena la cache passa allo stato **ELIMINAZIONE IN CORSO**, non vengono più addebitati i costi.
**Utilizzando il AWS CLI**
Il seguente codice elimina la cache my-cache.
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
L'azione delete-serverless-cache CLI elimina solo una cache serverless. Per eliminare più cache, richiama delete-serverless-cache ogni cache serverless che desideri eliminare. Non occorre attendere la fine dell'eliminazione di una cache serverless prima di eliminarne un'altra.
**Per Linux, macOS o Unix:**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Per Windows:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
Per ulteriori informazioni, consulta l'argomento AWS CLI per ElastiCache . delete-serverless-cache
Ora puoi procedere alla [Fasi successive](next-steps-mem.md).
# Fasi successive
Per ulteriori informazioni su ElastiCache vedi:
+ [Lavorare con ElastiCache](WorkingWithElastiCache.md)
+ [Ridimensionamento ElastiCache](Scaling.md)
+ [Quote per ElastiCache](quota-limits.md)
+ [ElastiCache migliori pratiche e strategie di caching](BestPractices.md)
+ [Visualizzazione ElastiCache degli eventi](ECEvents.Viewing.md)
# Tutorial: Guida introduttiva a Python e ElastiCache
Questa sezione contiene tutorial pratici per aiutarti a conoscere Valkey e Redis OSS. ElastiCache Ti raccomandiamo di lavorare con dei tutorial specifici della lingua.
**Nota**
AWS SDKs sono disponibili per un'ampia varietà di lingue. Per un elenco completo consulta la pagina relativa agli [Strumenti per Amazon Web Services](https://aws.amazon.com/tools/).
**Topics**
+ [Python e ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python e ElastiCache
In questo tutorial, usi l'AWS SDK for Python (Boto3) per scrivere programmi semplici per eseguire le seguenti operazioni: ElastiCache
+ Crea ElastiCache cluster Redis OSS (modalità cluster abilitata e modalità cluster disabilitata)
+ Controlla se esistono utenti o gruppi di utenti, altrimenti creali. (Questa funzionalità è disponibile con Valkey 7.2 e versioni successive e con Redis OSS da 6.0 a 7.1.)
+ Connect a ElastiCache
+ Esegui operazioni come impostare e ricevere stringhe, leggere e scrivere su Steam e pubblicare e iscriverti dal canale. Pub/Sub
Mentre segui questo tutorial, puoi fare riferimento alla documentazione di AWS SDK for Python (Boto). [La sezione seguente è specifica per ElastiCache: client di basso livello ElastiCache ](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html)
## Prerequisiti dei tutorial
+ Imposta una chiave di AWS accesso per utilizzare.AWS SDKs Per ulteriori informazioni, consulta [Configurazione ElastiCache](set-up.md).
+ Installare Python 3.0 o versione successiva. Per maggiori informazioni, consulta [https://www.python.org/downloads](https://www.python.org/downloads). Per istruzioni, consulta [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) nella documentazione di Boto 3.
**Topics**
+ [Prerequisiti dei tutorial](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [Tutorial: creazione di cluster e utenti ElastiCache](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [Tutorial: Connessione a ElastiCache](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [Esempi di utilizzo](#ElastiCache-Getting-Started-Tutorials-Usage)
## Tutorial: creazione di cluster e utenti ElastiCache
Gli esempi seguenti utilizzano l'SDK boto3 ElastiCache per le operazioni di gestione Redis OSS (creazione di cluster o utenti) e redis-py/ per la gestione dei dati. redis-py-cluster
**Topics**
+ [Creare un cluster in modalità cluster disabilitata](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [Creare un cluster in modalità cluster disabilitata con TLS e RBAC](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [Creare un cluster in modalità cluster abilitata](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [Creare un cluster in modalità cluster abilitata con TLS e RBAC](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [Controlla se users/usergroup esiste, altrimenti creali](#ElastiCache-Getting-Started-Tutorials-Users)
### Creare un cluster in modalità cluster disabilitata
*Copia il seguente programma e incollalo in un file denominato .py. CreateClusterModeDisabledCluster*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode disabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
NumCacheClusters=NumCacheClusters,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
SnapshotRetentionLimit=30,
)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas
elasticacheResponse = create_cluster_mode_disabled(
#CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104053'
)
logging.info(elasticacheResponse)
```
Per eseguire il programma, immetti il comando seguente:
`python CreateClusterModeDisabledCluster.py`
Per ulteriori informazioni, consulta [Gestione dei cluster in ElastiCache](Clusters.md).
### Creare un cluster in modalità cluster disabilitata con TLS e RBAC
Per garantire la sicurezza, è possibile utilizzare Transport Layer Security (TLS) e Controllo di accesso basato sul ruolo (RBAC) quando si crea un cluster disabilitato in modalità cluster. A differenza di Valkey o Redis OSS AUTH, in cui tutti i client autenticati hanno accesso completo al gruppo di replica se il token è autenticato, RBAC consente di controllare l'accesso al cluster tramite gruppi di utenti. Questi gruppi di utenti sono progettati come un modo per organizzare l'accesso ai gruppi di replica. Per ulteriori informazioni, consulta [Controllo accessi basato sui ruoli (RBAC)](Clusters.RBAC.md).
*Copia il seguente programma e incollalo in un file denominato RBAC.py. ClusterModeDisabledWith*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled_rbac(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None, UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None):
"""Creates an ElastiCache Cluster with cluster mode disabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Mandatory name for the cluster.
:param UserGroupIds: The ID of the user group to be assigned to the cluster.
:param SecurityGroupIds: List of security groups to be assigned. If not defined, default will be used
:param CacheSubnetGroupName: subnet group where the cluster will be placed. If not defined, default will be used.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return {'Error': 'ReplicationGroupId parameter is required'}
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'NumCacheClusters': NumCacheClusters,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas.
# Assigns the existent user group "mygroup" for RBAC authentication
response=create_cluster_mode_disabled_rbac(
CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104',
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Per eseguire il programma, immetti il comando seguente:
`python ClusterModeDisabledWithRBAC.py`
Per ulteriori informazioni, consulta [Gestione dei cluster in ElastiCache](Clusters.md).
### Creare un cluster in modalità cluster abilitata
Copiare il seguente programma e incollarlo in un file denominato *ClusterModeEnabled.py.*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode enabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary node (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=NumNodeGroups,
ReplicasPerNodeGroup=ReplicasPerNodeGroup,
CacheParameterGroupName='default.valkey7.2.cluster.on'
)
return response
# Creates a cluster mode enabled
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='6.0',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey20210',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
)
logging.info(response)
```
Per eseguire il programma, immetti il comando seguente:
`python ClusterModeEnabled.py`
Per ulteriori informazioni, consulta [Gestione dei cluster in ElastiCache](Clusters.md).
### Creare un cluster in modalità cluster abilitata con TLS e RBAC
Per garantire la sicurezza, è possibile utilizzare Transport Layer Security (TLS) e Controllo di accesso basato sul ruolo (RBAC) durante la creazione di un cluster in modalità cluster abilitata. A differenza di Valkey o Redis OSS AUTH, in cui tutti i client autenticati hanno accesso completo al gruppo di replica se il token è autenticato, RBAC consente di controllare l'accesso al cluster tramite gruppi di utenti. Questi gruppi di utenti sono progettati come un modo per organizzare l'accesso ai gruppi di replica. Per ulteriori informazioni, consulta [Controllo accessi basato sui ruoli (RBAC)](Clusters.RBAC.md).
*Copia il seguente programma e incollalo in un file denominato RBAC.py. ClusterModeEnabledWith*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None,UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None,CacheParameterGroupName='default.valkey7.2.cluster.on'):
"""Creates an ElastiCache Cluster with cluster mode enabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster.
:param CacheParameterGroupName: Parameter group to be used. Must be compatible with the engine version and cluster mode enabled.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds,
'NumNodeGroups': NumNodeGroups,
'ReplicasPerNodeGroup': ReplicasPerNodeGroup,
'CacheParameterGroupName': CacheParameterGroupName
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates a cluster mode enabled cluster
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='7.2',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey2021',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Per eseguire il programma, immetti il comando seguente:
`python ClusterModeEnabledWithRBAC.py`
Per ulteriori informazioni, consulta [Gestione dei cluster in ElastiCache](Clusters.md).
### Controlla se users/usergroup esiste, altrimenti creali
Con RBAC, è possibile creare utenti e assegnare loro autorizzazioni specifiche utilizzando una stringa di accesso. Gli utenti vengono assegnati a gruppi di utenti allineati con un ruolo specifico (amministratori, risorse umane) che vengono quindi distribuiti a uno o più ElastiCache gruppi di replica Redis OSS. In questo modo, è possibile stabilire limiti di sicurezza tra i client che utilizzano lo stesso gruppo o gruppi di replica Valkey o Redis OSS e impedire ai client di accedere ai dati degli altri. Per ulteriori informazioni, consulta [Controllo accessi basato sui ruoli (RBAC)](Clusters.RBAC.md).
*Copia il seguente programma e incollalo in un file denominato .py. UserAndUserGroups* Aggiorna il meccanismo per fornire le credenziali. Le credenziali in questo esempio vengono mostrate come sostituibili e assegnate a un elemento non dichiarato. Evita le credenziali a codifica fissa.
Questo esempio utilizza una stringa di accesso con le autorizzazioni per l'utente. Per ulteriori informazioni sulle stringhe di accesso, vedere. [Specifica delle autorizzazioni mediante una stringa di accesso](Clusters.RBAC.md#Access-string)
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def check_user_exists(UserId):
"""Checks if UserId exists
Returns True if UserId exists, otherwise False
:param UserId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_users(
UserId=UserId,
)
if response['Users'][0]['UserId'].lower() == UserId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def check_group_exists(UserGroupId):
"""Checks if UserGroupID exists
Returns True if Group ID exists, otherwise False
:param UserGroupId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_user_groups(
UserGroupId=UserGroupId
)
if response['UserGroups'][0]['UserGroupId'].lower() == UserGroupId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserGroupNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def create_user(UserId=None,UserName=None,Password=None,AccessString=None):
"""Creates a new user
Returns the ARN for the newly created user or the error message
:param UserId: ElastiCache user ID. User IDs must be unique
:param UserName: ElastiCache user name. ElastiCache allows multiple users with the same name as long as the associated user ID is unique.
:param Password: Password for user. Must have at least 16 chars.
:param AccessString: Access string with the permissions for the user.
:return: user ARN
"""
try:
response = client.create_user(
UserId=UserId,
UserName=UserName,
Engine='Redis',
Passwords=[Password],
AccessString=AccessString,
NoPasswordRequired=False
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
return e.response['Error']
def create_group(UserGroupId=None, UserIds=None):
"""Creates a new group.
A default user is required (mandatory) and should be specified in the UserIds list
Return: Group ARN
:param UserIds: List with user IDs to be associated with the new group. A default user is required
:param UserGroupId: The ID (name) for the group
:return: Group ARN
"""
try:
response = client.create_user_group(
UserGroupId=UserGroupId,
Engine='Redis',
UserIds=UserIds
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
if __name__ == '__main__':
groupName='mygroup2'
userName = 'myuser2'
userId=groupName+'-'+userName
# Creates a new user if the user ID does not exist.
for tmpUserId,tmpUserName in [ (userId,userName), (groupName+'-default','default')]:
if not check_user_exists(tmpUserId):
response=create_user(UserId=tmpUserId, UserName=EXAMPLE,Password=EXAMPLE,AccessString='on ~* +@all')
logging.info(response)
# assigns the new user ID to the user group
if not check_group_exists(groupName):
UserIds = [ userId , groupName+'-default']
response=create_group(UserGroupId=groupName,UserIds=UserIds)
logging.info(response)
```
Per eseguire il programma, immetti il comando seguente:
`python UserAndUserGroups.py`
## Tutorial: Connessione a ElastiCache
I seguenti esempi utilizzano il client Valkey o Redis OSS a cui connettersi. ElastiCache
**Topics**
+ [Connessione a un cluster non crittografato in modalità cluster disabilitata](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [Connessione a un cluster abilitato in modalità cluster](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### Connessione a un cluster non crittografato in modalità cluster disabilitata
Copia il seguente programma e incollalo in un file denominato *ConnectClusterModeDisabled.py.* Aggiorna il meccanismo per fornire le credenziali. Le credenziali in questo esempio vengono mostrate come sostituibili e assegnate a un elemento non dichiarato. Evita le credenziali a codifica fissa.
```
from redis import Redis
import logging
logging.basicConfig(level=logging.INFO)
redis = Redis(host='primary.xxx.yyyyyy.zzz1.cache.amazonaws.com', port=6379, decode_responses=True, ssl=True, username=example, password=EXAMPLE)
if redis.ping():
logging.info("Connected to Redis")
```
Per eseguire il programma, immetti il comando seguente:
`python ConnectClusterModeDisabled.py`
### Connessione a un cluster abilitato in modalità cluster
Copiare il seguente programma e incollarlo in un file denominato *ConnectClusterModeEnabled.py.*
```
from rediscluster import RedisCluster
import logging
logging.basicConfig(level=logging.INFO)
redis = RedisCluster(startup_nodes=[{"host": "xxx.yyy.clustercfg.zzz1.cache.amazonaws.com","port": "6379"}], decode_responses=True,skip_full_coverage_check=True)
if redis.ping():
logging.info("Connected to Redis")
```
Per eseguire il programma, immetti il comando seguente:
`python ConnectClusterModeEnabled.py`
## Esempi di utilizzo
I seguenti esempi utilizzano l'SDK boto3 per ElastiCache lavorare con ElastiCache Redis OSS.
**Topics**
+ [Imposta e ottieni stringhe](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [Imposta e ottieni un hash con più elementi](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Pubblica (scrivi) e iscriviti (leggi) da un canale Pub/Sub](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [Scrivere e leggere da un flusso](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### Imposta e ottieni stringhe
*Copia il seguente programma e incollalo in un file denominato .py. SetAndGetStrings*
```
import time
import logging
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
currTime=time.ctime(time.time())
# Set the key 'mykey' with the current date and time as value.
# The Key will expire and removed from cache in 60 seconds.
redis.set(keyName, currTime, ex=60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieve the key value and current TTL
keyValue=redis.get(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValue, keyTTL))
```
Per eseguire il programma, immetti il comando seguente:
`python SetAndGetStrings.py`
### Imposta e ottieni un hash con più elementi
Copia il seguente programma e incollalo in un file denominato *SetAndGetHash.py.*
```
import logging
import time
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
keyValues={'datetime': time.ctime(time.time()), 'epochtime': time.time()}
# Set the hash 'mykey' with the current date and time in human readable format (datetime field) and epoch number (epochtime field).
redis.hset(keyName, mapping=keyValues)
# Set the key to expire and removed from cache in 60 seconds.
redis.expire(keyName, 60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieves all the fields and current TTL
keyValues=redis.hgetall(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValues, keyTTL))
```
Per eseguire il programma, immetti il comando seguente:
`python SetAndGetHash.py`
### Pubblica (scrivi) e iscriviti (leggi) da un canale Pub/Sub
Copia il seguente programma e incollalo in un file chiamato *PubAndSub.py.*
```
import logging
import time
def handlerFunction(message):
"""Prints message got from PubSub channel to the log output
Return None
:param message: message to log
"""
logging.info(message)
logging.basicConfig(level=logging.INFO)
redis = Redis(host="redis202104053.tihewd.ng.0001.use1.cache.amazonaws.com", port=6379, decode_responses=True)
# Creates the subscriber connection on "mychannel"
subscriber = redis.pubsub()
subscriber.subscribe(**{'mychannel': handlerFunction})
# Creates a new thread to watch for messages while the main process continues with its routines
thread = subscriber.run_in_thread(sleep_time=0.01)
# Creates publisher connection on "mychannel"
redis.publish('mychannel', 'My message')
# Publishes several messages. Subscriber thread will read and print on log.
while True:
redis.publish('mychannel',time.ctime(time.time()))
time.sleep(1)
```
Per eseguire il programma, immetti il comando seguente:
`python PubAndSub.py`
### Scrivere e leggere da un flusso
Copia il seguente programma e incollalo in un file denominato *ReadWriteStream.py.*
```
from redis import Redis
import redis.exceptions as exceptions
import logging
import time
import threading
logging.basicConfig(level=logging.INFO)
def writeMessage(streamName):
"""Starts a loop writting the current time and thread name to 'streamName'
:param streamName: Stream (key) name to write messages.
"""
fieldsDict={'writerId':threading.currentThread().getName(),'myvalue':None}
while True:
fieldsDict['myvalue'] = time.ctime(time.time())
redis.xadd(streamName,fieldsDict)
time.sleep(1)
def readMessage(groupName=None,streamName=None):
"""Starts a loop reading from 'streamName'
Multiple threads will read from the same stream consumer group. Consumer group is used to coordinate data distribution.
Once a thread acknowleges the message, it won't be provided again. If message wasn't acknowledged, it can be served to another thread.
:param groupName: stream group were multiple threads will read.
:param streamName: Stream (key) name where messages will be read.
"""
readerID=threading.currentThread().getName()
while True:
try:
# Check if the stream has any message
if redis.xlen(streamName)>0:
# Check if if the messages are new (not acknowledged) or not (already processed)
streamData=redis.xreadgroup(groupName,readerID,{streamName:'>'},count=1)
if len(streamData) > 0:
msgId,message = streamData[0][1][0]
logging.info("{}: Got {} from ID {}".format(readerID,message,msgId))
#Do some processing here. If the message has been processed sucessfuly, acknowledge it and (optional) delete the message.
redis.xack(streamName,groupName,msgId)
logging.info("Stream message ID {} read and processed successfuly by {}".format(msgId,readerID))
redis.xdel(streamName,msgId)
else:
pass
except:
raise
time.sleep(0.5)
# Creates the stream 'mystream' and consumer group 'myworkergroup' where multiple threads will write/read.
try:
redis.xgroup_create('mystream','myworkergroup',mkstream=True)
except exceptions.ResponseError as e:
logging.info("Consumer group already exists. Will continue despite the error: {}".format(e))
except:
raise
# Starts 5 writer threads.
for writer_no in range(5):
writerThread = threading.Thread(target=writeMessage, name='writer-'+str(writer_no), args=('mystream',),daemon=True)
writerThread.start()
# Starts 10 reader threads
for reader_no in range(10):
readerThread = threading.Thread(target=readMessage, name='reader-'+str(reader_no), args=('myworkergroup','mystream',),daemon=True)
readerThread.daemon = True
readerThread.start()
# Keep the code running for 30 seconds
time.sleep(30)
```
Per eseguire il programma, immetti il comando seguente:
`python ReadWriteStream.py`
# Tutorial: Configurazione di Lambda per ElastiCache l'accesso in un VPC
In questo tutorial puoi imparare a creare una cache ElastiCache serverless, creare una funzione Lambda, quindi testare la funzione Lambda e, facoltativamente, ripulirla dopo.
**Topics**
+ [Passaggio 1: creazione di una cache serverless. ElastiCache](#LambdaRedis.step1)
+ [Fase 2: Creare una funzione Lambda per ElastiCache](#LambdaRedis.step2)
+ [Fase 3: testare la funzione Lambda con ElastiCache](#LambdaRedis.step3)
+ [Fase 4: Pulizia (opzionale)](#LambdaRedis.step4)
## Passaggio 1: creazione di una cache serverless. ElastiCache
Per creare una cache serverless, segui questi passaggi.
### Passaggio 1.1: Creare una cache serverless
In questo passaggio, crei una cache serverless nel VPC Amazon predefinito nella regione us-east-1 del tuo account utilizzando (CLI).AWS Command Line Interface Per informazioni sulla creazione di cache serverless utilizzando la console o l'API, consulta ElastiCache . [Crea una cache serverless Redis OSS](GettingStarted.serverless-redis.step1.md)
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
Il valore del campo Stato è impostato su `CREATING`. Il completamento della creazione della cache può richiedere un minuto. ElastiCache
### Passaggio 1.2: Copia l'endpoint della cache serverless
Verifica che ElastiCache for Redis OSS abbia terminato la creazione della cache con il comando. `describe-serverless-caches`
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
Copia l'indirizzo dell'endpoint presente nell'output. Avrai bisogno di questo indirizzo quando crei il pacchetto di implementazione per la funzione Lambda.
### Fase 1.3: Creazione del ruolo IAM
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",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
},
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
}]
}
```
------
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" : [
"elasticache:Connect"
],
"Resource" : [
"arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01",
"arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
]
}
]
}
```
------
1. Crea un ruolo IAM.
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Creare la policy IAM.
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. Allega la policy IAM al ruolo.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
### Fase 1.4: Creare un utente predefinito
1. Crea un nuovo utente predefinito.
```
aws elasticache create-user \
--user-name default \
--user-id default-user-disabled \
--engine redis \
--authentication-mode Type=no-password-required \
--access-string "off +get ~keys*"
```
1. Crea un nuovo utente attivato da IAM.
```
aws elasticache create-user \
--user-name iam-user-01 \
--user-id iam-user-01 \
--authentication-mode Type=iam \
--engine redis \
--access-string "on ~* +@all"
```
1. Crea un gruppo di utenti e collega l'utente.
```
aws elasticache create-user-group \
--user-group-id iam-user-group-01 \
--engine redis \
--user-ids default-user-disabled iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Fase 2: Creare una funzione Lambda per ElastiCache
Per creare una funzione Lambda per accedere alla ElastiCache cache, procedi nel seguente modo.
### Fase 2.1: Creare una funzione Lambda
In questo tutorial, forniamo codice di esempio in Python per la tua funzione Lambda.
**Python**
L'esempio seguente di codice Python legge e scrive un elemento nella cache. ElastiCache Copia il codice e salvalo in un file denominato `app.py`. Assicurati di sostituire il `elasticache_endpoint` valore nel codice con l'indirizzo dell'endpoint che hai copiato nel passaggio precedente.
```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse
import botocore.session
import redis
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid
class ElastiCacheIAMProvider(redis.CredentialProvider):
def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
self.user = user
self.cache_name = cache_name
self.is_serverless = is_serverless
self.region = region
session = botocore.session.get_session()
self.request_signer = RequestSigner(
ServiceId("elasticache"),
self.region,
"elasticache",
"v4",
session.get_credentials(),
session.get_component("event_emitter"),
)
# Generated IAM tokens are valid for 15 minutes
@cached(cache=TTLCache(maxsize=128, ttl=900))
def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
query_params = {"Action": "connect", "User": self.user}
if self.is_serverless:
query_params["ResourceType"] = "ServerlessCache"
url = urlunparse(
ParseResult(
scheme="https",
netloc=self.cache_name,
path="/",
query=urlencode(query_params),
params="",
fragment="",
)
)
signed_url = self.request_signer.generate_presigned_url(
{"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
operation_name="connect",
expires_in=900,
region_name=self.region,
)
# RequestSigner only seems to work if the URL has a protocol, but
# Elasticache only accepts the URL without a protocol
# So strip it off the signed URL before returning
return (self.user, signed_url.removeprefix("https://"))
def lambda_handler(event, context):
username = "iam-user-01" # replace with your user id
cache_name = "cache-01" # replace with your cache name
elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
redis_client = redis.Redis(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
key='uuid'
# create a random UUID - this will be the sample element we add to the cache
uuid_in = uuid.uuid4().hex
redis_client.set(key, uuid_in)
result = redis_client.get(key)
decoded_result = result.decode("utf-8")
# check the retrieved item matches the item added to the cache and print
# the results
if decoded_result == uuid_in:
print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
else:
raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
return "Fetched value from Valkey"
```
Questo codice utilizza la libreria Python redis-py per inserire elementi nella cache e recuperarli. Questo codice utilizza cachetools per memorizzare nella cache i token IAM Auth generati per 15 minuti. Per creare un pacchetto di distribuzione contenente redis-py e cachetools, procedi nel seguente modo.
Nella directory del progetto contenente il file di codice sorgente app.py, create un pacchetto di cartelle in cui installare le librerie redis-py e cachetools.
```
mkdir package
```
Installa redis-py, cachetools usando pip.
```
pip install --target ./package redis
pip install --target ./package cachetools
```
Crea un file.zip contenente le librerie redis-py e cachetools. Su Linux e macOS, esegui il comando seguente. In Windows, utilizzate l'utilità zip preferita per creare un file.zip con le librerie redis-py e cachetools alla radice.
```
cd package
zip -r ../my_deployment_package.zip .
```
Aggiungi il codice della funzione al file .zip. Su Linux e macOS, esegui il comando seguente. In Windows, utilizzate l'utilità zip preferita per aggiungere app.py alla radice del file .zip.
```
cd ..
zip my_deployment_package.zip app.py
```
### Fase 2.2: creazione del ruolo IAM (ruolo di esecuzione)
Allega la policy AWS gestita denominata `AWSLambdaVPCAccessExecutionRole` al ruolo.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### Fase 2.3: caricamento del pacchetto di implementazione (creazione della funzione Lambda)
In questo passaggio, crei la funzione Lambda (AccessValkey) utilizzando il comando AWS CLI create-function.
Dalla directory del progetto che contiene il file.zip del pacchetto di distribuzione, esegui il seguente comando Lambda `create-function` CLI.
Per l'opzione role, utilizzate l'ARN del ruolo di esecuzione creato nel passaggio precedente. Per vpc-config inserisci gli elenchi separati da virgole delle sottoreti del tuo VPC predefinito e dell'ID del gruppo di sicurezza del tuo VPC predefinito. Questi valori sono disponibili nella console Amazon VPC. Per trovare le sottoreti del tuo VPC predefinito, scegli **Your VPCs, quindi scegli il** VPC predefinito AWS del tuo account. Per trovare il gruppo di sicurezza per questo VPC, vai su **Sicurezza** e scegli Gruppi di **sicurezza**. Assicurati di aver selezionato la regione us-east-1.
```
aws lambda create-function \
--function-name AccessValkey \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12 \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id
```
## Fase 3: testare la funzione Lambda con ElastiCache
In questo passaggio, si richiama la funzione Lambda manualmente utilizzando il comando invoke. Quando la funzione Lambda viene eseguita, genera un UUID e lo scrive nella ElastiCache cache specificata nel codice Lambda. Successivamente la funzione Lambda recupera la voce dalla cache.
1. Invocate la funzione Lambda AccessValkey () utilizzando AWS Lambda il comando invoke.
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Eseguire le operazioni seguenti per verificare che la funzione Lambda sia stata eseguita nel modo corretto:
+ Esaminare il file output.txt.
+ Verifica i risultati in CloudWatch Logs aprendo la CloudWatch console e scegliendo il gruppo di log per la tua funzione (/). aws/lambda/AccessValkey Il flusso di log genera un output simile al seguente:
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ Esamina i risultati nella AWS Lambda console.
## Fase 4: Pulizia (opzionale)
Per eseguire la pulizia, procedi nel seguente modo.
### Fase 4.1: Eliminare la funzione Lambda
```
aws lambda delete-function \
--function-name AccessValkey
```
### Fase 4.2: Eliminare la cache serverless
Eliminare la cache.
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
Rimuovi utenti e gruppi di utenti.
```
aws elasticache delete-user \
--user-id default-user-disabled
aws elasticache delete-user \
--user-id iam-user-01
aws elasticache delete-user-group \
--user-group-id iam-user-group-01
```
### Fase 4.3: Rimuovere il ruolo e le politiche IAM
```
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
aws iam delete-role \
--role-name "elasticache-iam-auth-app"
aws iam delete-policy \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```