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à. # 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)