Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Lectura y escritura de datos en la caché En esta sección se asume que has creado una EC2 instancia de Amazon y que puedes conectarte a ella. Para obtener instrucciones sobre cómo hacerlo, consulta la [Guía de EC2 introducción de Amazon](https://aws.amazon.com/ec2/getting-started/). De forma predeterminada, ElastiCache crea una memoria caché en la VPC predeterminada. Asegúrese de que la EC2 instancia también se cree en la VPC predeterminada para que pueda conectarse a la memoria caché. **Buscar el punto de conexión de la caché** **Consola de administración de AWS** Para encontrar el punto final de la caché mediante la ElastiCache consola, sigue estos pasos: 1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. En el panel de navegación del lado izquierdo de la consola, elija **Cachés de Memcached**. 1. En la parte derecha de la consola, haga clic en el nombre de la caché que acaba de crear. 1. En los **Detalles de la caché**, busque y copie el punto de conexión de la caché. **AWS CLI** En el siguiente AWS CLI ejemplo, se muestra cómo encontrar el punto final de la nueva caché mediante el describe-serverless-caches comando. Cuando haya ejecutado el comando, busque el campo “Punto de conexión”. **Linux** ``` aws elasticache describe-serverless-caches \ --serverless-cache-name CacheName ``` **Windows** ``` aws elasticache describe-serverless-caches ^ --serverless-cache-name CacheName ``` ## Conexión mediante OpenSSL Para obtener información sobre cómo conectarse empleando OpenSSL, consulte [ElastiCache cifrado en tránsito (TLS)](in-transit-encryption.md). ## Conexión mediante el cliente Java de 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"); } } ``` ## Conexión mediante el cliente PHP de 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); ?> ``` ## Conexión mediante el cliente Python de Memcached (Pymemcache) Consulta [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" ``` ## Connect mediante el NodeJS/TS cliente Memcached (Electrode-IO memcache) [https://github.com/electrode-io/Consulte](https://github.com/electrode-io/memcache) memcache y [https://www.npmjs.com/package/memcache-client](https://www.npmjs.com/package/memcache-client) Instalación mediante `npm i memcache-client` En la aplicación, cree un cliente TLS de memcached de la siguiente manera: ``` var memcache = require("memcache-client"); const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}}); client.set("key", "value"); ``` ## Conexión mediante el cliente Rust de Memcached (rust-memcache) [Consulte https://crates. io/crates/memcache](https://crates.io/crates/memcache)y [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(); ``` ## Conexión mediante el cliente Go de Memcached (Gomemcache) [https://github.com/bradfitz/Véase 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) ``` ## Conexión mediante el cliente Ruby de Memcached (Dalli) [Ver 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") ``` ## Conéctese mediante el cliente .NET de Memcached () EnyimMemcachedCore Consulte [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore) ``` "MemcachedClient": { "Servers": [ { "Address": "{cluster_endpoint}", "Port": 11211 } ], "UseSslStream": true } ``` Ahora puede pasar a [(Opcional) Limpieza](read-write-cleanup-mem.md).