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. # Creación de una caché sin servidor de Memcached **Consola de administración de AWS** Para crear una nueva caché sin servidor de Memcached con la consola de ElastiCache: 1. Inicie sesión en la Consola de administración de AWS y abra la consola de ElastiCache 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 el lado derecho de la consola, elija **Crear caché de Memcached**. 1. En **Configuración de caché**, introduzca un **Nombre**. Si lo desea, puede especificar una **descripción** para la caché. 1. Deje seleccionado el ajuste predeterminado. 1. Haga clic en **Crear** para crear la caché. 1. Una vez que la caché esté en estado “ACTIVO”, puede empezar a escribir y leer datos en ella. Para crear una nueva caché con la AWS CLI En el siguiente ejemplo de la AWS CLI, se crea una nueva caché mediante 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 ``` Como puede ver, el valor del campo Estado es `CREATING`. Para comprobar que ElastiCache haya terminado de crear la caché, utilice el comando `describe-serverless-caches`. **Linux** ``` aws elasticache describe-serverless-caches --serverless-cache-name CacheName ``` **Windows** ``` aws elasticache describe-serverless-caches --serverless-cache-name CacheName ``` Después de crear la caché, continúe con [Lectura y escritura de datos en la caché](read-write-cache-mem.md). # 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). # (Opcional) Limpieza **Uso del Consola de administración de AWS** El siguiente procedimiento elimina una sola caché de su implementación. Para eliminar varias cachés, repita el procedimiento por cada caché que desee eliminar. No es necesario esperar a que una caché se elimine por completo antes de empezar a eliminar otra. **Para eliminar una caché** 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 control de la ElastiCache consola, elige el motor que se ejecuta en la memoria caché que deseas eliminar. Se mostrará una lista de todas las cachés que ejecutan ese motor. 1. Para elegir la caché que se va a eliminar, elija el nombre de la caché en la lista. **importante** Solo puedes eliminar una caché a la vez desde la ElastiCache consola. Al elegir varias cachés, se deshabilita la operación de eliminación. 1. En **Actions (Acciones)**, seleccione **Delete (Eliminar)**. 1. En la pantalla de confirmación **Eliminar caché**, elija **Eliminar** para eliminar la caché o elija **Cancelar** para conservarla. 1. Si elige **Eliminar**, el estado de la caché cambiará a *eliminando*. En cuanto la caché pase al estado **DELETING**, dejará de generar gastos. **Usando el AWS CLI** El siguiente código elimina my-cache de la caché. ``` aws elasticache delete-serverless-cache --serverless-cache-name my-cache ``` La acción delete-serverless-cache CLI solo elimina una memoria caché sin servidor. Para eliminar varias cachés, llame a delete-serverless-cache cada caché sin servidor que desee eliminar. No es necesario esperar a que una caché sin servidor acabe de eliminarse antes de eliminar otra. **Para Linux, macOS o Unix**: ``` aws elasticache delete-serverless-cache \ --serverless-cache-name my-cache ``` **Para Windows:** ``` aws elasticache delete-serverless-cache ^ --serverless-cache-name my-cache ``` Para obtener más información, consulte el AWS CLI tema ElastiCache delete-serverless-cache Ahora puede pasar a [Siguientes pasos](next-steps-mem.md). # Siguientes pasos Para obtener más información sobre ElastiCache, consulte + [Trabajando con ElastiCache](WorkingWithElastiCache.md) + [Escalado ElastiCache](Scaling.md) + [Cuotas de ElastiCache](quota-limits.md) + [Procedimientos recomendados y estrategias de almacenamiento en caché de ElastiCache](BestPractices.md) + [Visualización de ElastiCache eventos](ECEvents.Viewing.md)