Fase 2: lettura e scrittura di dati nella cache

Questa sezione presuppone che sia stata creata un'istanza Amazon EC2 ed eseguita la connessione alla stessa. Per istruzioni su come procedere, consoluta la Guida alle operazioni di base di Amazon EC2.

Per impostazione predefinita, ElastiCache crea una cache nel tuo VPC predefinito. Assicurati che anche l'istanza EC2 sia creata nel VPC predefinito, in modo da potersi connettere alla cache.

Configurazione

Prima di iniziare, assicurati di avere le porte giuste disponibili per l'accesso.

Porta principale: 11211

Porta ottimizzata per la lettura: 11212

Le cache Memcached serverless pubblicizzano due porte con lo stesso nome host. La porta principale consente scritture e letture con le stesse garanzie di coerenza di OSS Memcached. La porta ottimizzata per la lettura consente scritture e inoltre letture a latenza inferiore, alla fine coerenti.

Ricerca dell'endpoint della cache

AWS Management Console

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

1. Accedi 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

Connessione tramite OpenSSL

Per informazioni su come eseguire la connessione tramite OpenSSL, consulta ElastiCache crittografia in transito () TLS.

Connessione tramite il client Memcached Java

Per informazioni su come eseguire la connessione tramite il client Memcached Java, consulta ElastiCache crittografia in transito () TLS

Connessione tramite il client Memcached PHP

<?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);
?>

Connessione tramite il client Memcached Python (Pymemcache)

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

Connessione tramite il client Memcached NodeJS/TS (Electrode-IO memcache)

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

Installa usando npm i memcache-client.

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

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

Connessione tramite il client Memcached Rust (rust-memcache)

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

Connessione tramite il client Memcached Go (Gomemcache)

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

Connessione tramite il client Memcached Ruby (Dalli)

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

Connect utilizzando il client Memcached .NET () EnyimMemcachedCore

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

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

Ora puoi procedere alla Fase 3: (facoltativo) pulizia.