Daten in den Cache lesen und in den Cache schreiben - Amazon ElastiCache

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Daten in den Cache lesen und in den Cache schreiben

In diesem Abschnitt wird davon ausgegangen, dass Sie eine EC2 Amazon-Instance erstellt haben und eine Verbindung zu ihr herstellen können. Eine Anleitung dazu finden Sie im Amazon-Leitfaden „EC2Erste Schritte“.

ElastiCache Erstellt standardmäßig einen Cache in Ihrer StandardeinstellungVPC. Stellen Sie sicher, dass Ihre EC2 Instance auch standardmäßig erstellt wurdeVPC, damit sie eine Verbindung zum Cache herstellen kann.

Finden Ihres Cache-Endpunkts

AWS Management Console

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

  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

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

Informationen zum Herstellen einer Verbindung mithilfe des Memcached-Java-Clients finden Sie unter ElastiCache Verschlüsselung bei der Übertragung () 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);
?>

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

Siehe https://github.com/electrode-io/Memcache und Memcache-Client https://www.npmjs.com/package/

Installieren über npm i memcache-client

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

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

Siehe https://crates.io/crates/memcache und 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/Siehe 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)

Siehst du 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")

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


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

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