Leer y escribir datos en la memoria caché - Amazon ElastiCache

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.

Leer y escribir datos en la memoria 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.

De forma predeterminada, ElastiCache crea una caché en su configuración predeterminadaVPC. Asegúrese de que la EC2 instancia también se cree de forma predeterminada VPC para que pueda conectarse a la memoria caché.

Buscar el punto de conexión de la caché

AWS Management Console

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 AWS Management Console y ábrela en https://console.aws.amazon.com/elasticache/.

  2. En el panel de navegación del lado izquierdo de la consola, elija Cachés de Memcached.

  3. En la parte derecha de la consola, haga clic en el nombre de la caché que acaba de crear.

  4. 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

Para obtener información sobre cómo conectarse mediante OpenSSL, consulte ElastiCache cifrado en tránsito () TLS

Para obtener información sobre cómo conectarse mediante el cliente Java de Memcached, consulte ElastiCache cifrado en tránsito () TLS

<?php
$cluster_endpoint = "mycluster.serverless.use1.cache.amazonaws.com";
$server_port = 11211; 

/* Initialize a persistent Memcached client in TLS mode */
$tls_client = new Memcached('persistent-id');
$tls_client->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);
?>

Consulte memcache.readthedocs.io/en/latest/getting_started.html https://py

import ssl
from pymemcache.client.base import Client
		
context = ssl.create_default_context()
cluster_endpoint = <To be taken from the AWS CLI / console>
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"

Consulte https://github.com/electrode-io/memcache y memcache-client https://www.npmjs.com/package/

Instalación mediante npm i memcache-client

En la aplicación, cree un cliente memcached de la siguiente manera: TLS

var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");

Consulte https://crates.io/crates/memcache y https://github.com/aisk/rust-memcache.

// create connection with to memcached server node:
let client = memcache::connect("memcache+tls://<cluster_endpoint>:11211?verify_mode=none").unwrap();
				
// set a string value
client.set("foo", "bar", 0).unwrap();

https://github.com/bradfitz/Consulte 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)

Ver dalli https://github.com/petergoldstein/

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("<cluster_endpoint>:11211", :ssl_context => ssl_context); 
client.get("abc")

Consulte https://github.com/cnblogs/EnyimMemcachedCore


"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream":  true
}

Ahora puede pasar a (Opcional) Limpieza.