Leggi e scrivi dati nella cache - Amazon ElastiCache

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Leggi e scrivi dati nella cache

Questa sezione presuppone che tu abbia creato un'EC2istanza Amazon e che tu possa connetterti ad essa. Per istruzioni su come eseguire questa operazione, consulta la Amazon EC2 Getting Started Guide.

Per impostazione predefinita, ElastiCache crea una cache come impostazione predefinitaVPC. Assicurati che anche l'EC2istanza sia creata nell'impostazione predefinitaVPC, in modo che sia in grado di connettersi alla cache.

Ricerca dell'endpoint della cache

AWS Management Console

Per trovare l'endpoint della cache utilizzando la ElastiCache console:

  1. Accedi a AWS Management Console e apri la ElastiCache console Amazon all'indirizzo https://console.aws.amazon.com/elasticache/.

  2. Nel riquadro di navigazione sul lato sinistro della console scegli Cache Memcached.

  3. Sul lato destro della console fai clic sul nome della cache che hai appena creato.

  4. In Dettagli della cache individua e copia l'endpoint della cache.

AWS CLI

L' AWS CLI esempio seguente mostra come trovare l'endpoint per la nuova cache utilizzando il describe-serverless-caches comando. Dopo aver eseguito il comando, cerca il campo "Endpoint".

Linux

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

Windows

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

Per informazioni su come connettersi tramite OpenSSL, vedere ElastiCache crittografia in transito () TLS

Per informazioni su come eseguire la connessione tramite il client Memcached Java, consulta ElastiCache crittografia in transito () 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);
?>

Vedi 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"

Vedi https://github.com/electrode-io/memcache e memcache-client https://www.npmjs.com/package/

Installa usando npm i memcache-client.

Nell'applicazione, crea un client memcached come segue: TLS

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

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

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

Vedi 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")

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


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

Ora puoi procedere alla (Facoltativo) Pulizia.