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. # Création d'un cache sans serveur Memcached **AWS Management Console** Pour créer un nouveau cache sans serveur Memcached à l'aide de la console : ElastiCache 1. Connectez-vous à la ElastiCache console 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. Dans la partie droite de la console, choisissez **Créer un cache Memcached**. 1. Dans **Paramètres de cache**, entrez un **Nom**. Vous pouvez éventuellement entrer une **description** pour le cache. 1. Laissez les paramètres par défaut sélectionnés. 1. Cliquez sur **Créer** pour créer le cache. 1. Une fois que le cache est à l’état « ACTIVE », vous pouvez commencer à écrire et à lire des données sur le cache. Pour créer un nouveau cache à l'aide du AWS CLI L' AWS CLI exemple suivant crée un nouveau cache à l'aide de 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 ``` Notez que la valeur du champ Statut est définie sur `CREATING`. Pour vérifier que la création du cache ElastiCache est terminée, utilisez la `describe-serverless-caches` commande. **Linux** ``` aws elasticache describe-serverless-caches --serverless-cache-name CacheName ``` **Windows** ``` aws elasticache describe-serverless-caches --serverless-cache-name CacheName ``` Une fois le nouveau cache créé, passez à l’[Lire et écrire des données dans le cache](read-write-cache-mem.md). # 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). # (Facultatif) Nettoyer **À l'aide du AWS Management Console** La procédure suivante supprime un cache unique de votre déploiement. Pour supprimer plusieurs caches, répétez la procédure pour chaque cache à supprimer. Vous n’avez pas besoin d’attendre la fin de la suppression d’un cache avant de démarrer la procédure pour en supprimer un autre. **Pour supprimer un cache** 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 tableau de bord de la ElastiCache console, choisissez le moteur qui s'exécute sur le cache que vous souhaitez supprimer. La liste de tous les caches exécutant le moteur choisi s’affiche. 1. Pour choisir le cache à supprimer, choisissez son nom dans la liste des caches. **Important** Vous ne pouvez supprimer qu'un seul cache à la fois depuis la ElastiCache console. Le choix de plusieurs caches désactive l’opération de suppression. 1. Pour **Actions**, choisissez **Supprimer**. 1. Dans l’écran de confirmation **Supprimer le cache**, choisissez **Supprimer** pour supprimer le cache ou **Annuler** pour le conserver. 1. Si vous avez choisi **Supprimer**, le statut du cache passe à *deleting*. Dès que votre cache passe au statut **DELETING**, vous cessez d’être facturé pour celui-ci. **À l'aide du AWS CLI** Le code suivant supprime le cache my-cache. ``` aws elasticache delete-serverless-cache --serverless-cache-name my-cache ``` L'action delete-serverless-cache CLI ne supprime qu'un seul cache sans serveur. Pour supprimer plusieurs caches, appelez delete-serverless-cache chaque cache sans serveur que vous souhaitez supprimer. Vous n’avez pas besoin d’attendre que la suppression d’un cache sans serveur soit terminée avant d’en supprimer un autre. **Pour Linux, macOS ou Unix :** ``` aws elasticache delete-serverless-cache \ --serverless-cache-name my-cache ``` **Pour Windows:** ``` aws elasticache delete-serverless-cache ^ --serverless-cache-name my-cache ``` Pour plus d'informations, consultez AWS CLI la ElastiCache rubrique dédiée delete-serverless-cache. Vous pouvez maintenant passer à l’[Étapes suivantes](next-steps-mem.md). # Étapes suivantes Pour plus d'informations ElastiCache sur : + [Travailler avec ElastiCache](WorkingWithElastiCache.md) + [Dimensionnement ElastiCache](Scaling.md) + [Quotas pour ElastiCache](quota-limits.md) + [ElastiCache meilleures pratiques et stratégies de mise en cache](BestPractices.md) + [Affichage des ElastiCache événements](ECEvents.Viewing.md)