Leia e grave dados no cache - Amazon ElastiCache

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Leia e grave dados no cache

Esta seção pressupõe que você criou uma EC2 instância da Amazon e pode se conectar a ela. Para obter instruções sobre como fazer isso, consulte o Amazon EC2 Getting Started Guide.

Por padrão, ElastiCache cria um cache em seu padrãoVPC. Certifique-se de que sua EC2 instância também seja criada no padrãoVPC, para que ela possa se conectar ao cache.

Encontre o endpoint do cache

AWS Management Console

Para encontrar o endpoint do seu cache usando o ElastiCache console:

  1. Faça login no AWS Management Console e abra o ElastiCache console da Amazon em https://console.aws.amazon.com/elasticache/.

  2. No painel de navegação, no lado esquerdo do console, escolha Caches do Memcached.

  3. No lado direito do console, clique no nome do cache que você acabou de criar.

  4. Nos Detalhes do cache, localize e copie o endpoint do cache.

AWS CLI

O AWS CLI exemplo a seguir mostra como encontrar o endpoint para seu novo cache usando o describe-serverless-caches comando. Depois de executar o comando, procure o campo “Endpoint”.

Linux

aws elasticache describe-serverless-caches \
		--serverless-cache-name CacheName

Windows

aws elasticache describe-serverless-caches ^
		--serverless-cache-name CacheName

Para obter informações sobre como se conectar usando o OpenSSL, consulte ElastiCache criptografia em trânsito () TLS

Para obter informações sobre como se conectar usando o cliente Java do Memcached, consulte ElastiCache criptografia em 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 https://pymemcache.readthedocs.io/en/latest/getting_started.html

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 e https://www.npmjs.com/package/ memcache-client

Instalar por meio de npm i memcache-client

No aplicativo, crie um TLS cliente memcached da seguinte forma:

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 e 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();

Veja 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)

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

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


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

Agora você já pode avançar para Limpar (opcional).