Schritt 2: Daten lesen und in den Cache schreiben

In diesem Abschnitt wird davon ausgegangen, dass Sie eine Amazon-EC2-Instance erstellt haben und eine Verbindung mit ihr möglich ist. Anweisungen dazu finden Sie im Amazon-EC2-Erste-Schritte-Leitfaden.

ElastiCache Erstellt standardmäßig einen Cache in Ihrer Standard-VPC. Stellen Sie sicher, dass Ihre EC2-Instance ebenfalls in der Standard-VPC erstellt wird, damit sie eine Verbindung mit dem Cache herstellen kann.

Konfiguration

Bevor Sie beginnen, stellen Sie sicher, dass Sie die richtigen Ports für den Zugriff zur Verfügung haben.

Primärer Port: 11211

Leseoptimierter Port: 11212

Serverlose Memcached-Caches kündigen zwei Ports mit demselben Hostnamen an. Der primäre Port ermöglicht Schreib- und Lesevorgänge mit denselben Konsistenzgarantien wie OSS Memcached. Der leseoptimierte Port ermöglicht Schreibvorgänge und zusätzlich eine geringere Latenz, sodass letztendlich konsistente Lesevorgänge möglich sind.

Finden Ihres Cache-Endpunkts

AWS Management Console

So finden Sie den Endpunkt Ihres Caches mithilfe der Konsole: ElastiCache

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die ElastiCache Amazon-Konsole unter https://console.aws.amazon.com/elasticache/.

2. Klicken Sie im Navigationsbereich auf der linken Seite der Konsole auf Memcached-Caches.

3. Klicken Sie auf der rechten Seite der Konsole auf den Namen des Caches, den Sie gerade erstellt haben.

4. Suchen Sie in den Cache-Details den Cache-Endpunkt und kopieren Sie ihn.

AWS CLI

Das folgende AWS CLI Beispiel zeigt, wie Sie mit dem describe-serverless-caches Befehl den Endpunkt für Ihren neuen Cache ermitteln können. Nachdem Sie den Befehl ausgeführt haben, suchen Sie nach dem Feld „Endpunkt“.

Linux

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

Windows

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

Herstellen einer Verbindung mithilfe von OpenSSL

Weitere Informationen zum Herstellen einer Verbindung mithilfe von OpenSSL finden Sie unter ElastiCache Verschlüsselung bei der Übertragung (TLS).

Herstellen einer Verbindung mithilfe des Memcached-Java-Clients

Informationen zum Herstellen einer Verbindung mithilfe des Memcached-Java-Clients finden Sie unter ElastiCache Verschlüsselung bei der Übertragung (TLS).

Herstellen einer Verbindung mithilfe des Memcached-PHP-Clients

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

Herstellen einer Verbindung mithilfe des Memcached-Python-Clients (Pymemcache)

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

Herstellen einer Verbindung mithilfe des Memcached-NodeJS/TS-Clients (Electrode-IO Memcache)

Siehe https://github.com/electrode-io/memcache und https://www.npmjs.com/package/memcache-client

Installieren über npm i memcache-client

Erstellen Sie in der Anwendung wie folgt einen Memcached-TLS-Client:

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

Herstellen einer Verbindung mithilfe des Memcached-Rust-Clients (rust-memcache)

Weitere Informationen finden Sie unter https://crates.io/crates/memcache and 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();

Herstellen einer Verbindung mithilfe des Memcached-Go-Clients (Gomemcache)

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

Herstellen einer Verbindung mithilfe des Memcached-Ruby-Clients (Dalli)

Siehe 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 mit dem Memcached.NET-Client her () EnyimMemcachedCore

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

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

Sie können jetzt mit Schritt 3: (Optional) Bereinigen fortfahren.