Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Lire et écrire des données dans le cache Cette section part du principe que vous avez créé une EC2 instance Amazon et que vous pouvez vous y connecter. Pour obtenir des instructions sur la procédure à suivre, consultez le [guide de EC2 démarrage Amazon](https://aws.amazon.com/ec2/getting-started/). Par défaut, ElastiCache crée un cache dans votre VPC par défaut. Assurez-vous que votre EC2 instance est également créée dans le VPC par défaut, afin qu'elle puisse se connecter au cache. **Recherche du point de terminaison de votre cache** **AWS Management Console** Pour trouver le point de terminaison de votre cache à l'aide de la ElastiCache console : 1. Connectez-vous à la ElastiCache console Amazon AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Dans le volet de navigation à gauche de la console, choisissez **Caches Memcached**. 1. À droite de la console, cliquez sur le nom du cache que vous venez de créer. 1. Dans **Détails du cache**, localisez et copiez le point de terminaison du cache. **AWS CLI** L'AWS CLI exemple suivant montre comment rechercher le point de terminaison de votre nouveau cache à l'aide de la describe-serverless-caches commande. Une fois que vous avez exécuté la commande, recherchez le champ « Endpoint ». **Linux** ``` aws elasticache describe-serverless-caches \ --serverless-cache-name CacheName ``` **Windows** ``` aws elasticache describe-serverless-caches ^ --serverless-cache-name CacheName ``` ## Connexion à l’aide d’OpenSSL Pour en savoir plus sur la connexion à l’aide d’OpenSSL, consultez [ElastiCache chiffrement en transit (TLS)](in-transit-encryption.md). ## Connexion à l’aide du client Java Memcached ``` 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"); } } ``` ## Connexion à l’aide du client PHP Memcached ``` 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); ?> ``` ## Connexion à l’aide du client Python Memcached (Pymemcache) Voir [https://pymemcache.readthedocs. io/en/latest/getting](https://pymemcache.readthedocs.io/en/latest/getting_started.html)\$1started.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" ``` ## Connectez-vous à l'aide du NodeJS/TS client Memcached (Memcache Electrode-IO) [Voir [https://github.com/electrode-io/memcache et memcache-client](https://github.com/electrode-io/memcache) https://www.npmjs.com/package/](https://www.npmjs.com/package/memcache-client) Procédez à l’installation via `npm i memcache-client` Dans l’application, créez un client TLS Memcached comme suit : ``` var memcache = require("memcache-client"); const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}}); client.set("key", "value"); ``` ## Connexion à l’aide du client Rust Memcached (rust-memcache) Voir [https://crates. io/crates/memcache](https://crates.io/crates/memcache)et [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(); ``` ## Connexion à l’aide du client Go Memcached (Gomemcache) Voir [https://github.com/bradfitz/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) ``` ## Connexion à l’aide du client Ruby Memcached (Dalli) Voir [https://github.com/petergoldstein/Dalli](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 à l'aide du client .NET Memcached () EnyimMemcachedCore Consultez [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore) ``` "MemcachedClient": { "Servers": [ { "Address": "{cluster_endpoint}", "Port": 11211 } ], "UseSslStream": true } ``` Vous pouvez maintenant passer à l’[(Facultatif) Nettoyer](read-write-cleanup-mem.md).