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 Amazon-EC2-Instance erstellt haben und eine Verbindung mit ihr möglich ist. Anweisungen dazu finden Sie im [Amazon-EC2-Erste-Schritte-Leitfaden](https://aws.amazon.com/ec2/getting-started/). 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. **Finden Ihres Cache-Endpunkts** **AWS-Managementkonsole** So finden Sie den Endpunkt Ihres Caches mithilfe der ElastiCache Konsole: 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Klicken Sie im Navigationsbereich auf der linken Seite der Konsole auf **Memcached-Caches**. 1. Klicken Sie auf der rechten Seite der Konsole auf den Namen des Caches, den Sie gerade erstellt haben. 1. Suchen Sie in den **Cache-Details** den Cache-Endpunkt und kopieren Sie ihn. **AWS CLI** Das folgende AWS CLI Beispiel zeigt, wie Sie den Endpunkt für Ihren neuen Cache mithilfe des Befehls describe-serverless-caches finden. 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)](in-transit-encryption.md). ## Herstellen einer Verbindung mithilfe des Memcached-Java-Clients **Anmerkung** [Das folgende Beispiel verwendet den AWS Fork des Spymemcached-Clients aws-elasticache-cluster-client-memcached-for-java.](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-java) Die `setSSLContext` Methode ist nur in diesem Fork verfügbar und nicht Teil der standardmäßigen Open-Source-Spymemcached-Bibliothek. ``` import java.security.KeyStore; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManagerFactory; import net.spy.memcached.AddrUtil; import net.spy.memcached.ConnectionFactoryBuilder; import net.spy.memcached.FailureMode; import net.spy.memcached.MemcachedClient; public class TLSDemo { public static void main(String[] args) throws Exception { ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder(); // Build SSLContext TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init((KeyStore) null); SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, tmf.getTrustManagers(), null); // Create the client in TLS mode connectionFactoryBuilder.setSSLContext(sslContext); // Set Failure Mode to Retry connectionFactoryBuilder.setFailureMode(FailureMode.Retry); MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster-fnjyzo.serverless.use1.cache.amazonaws.com:11211")); // Store a data item for an hour. client.set("theKey", 3600, "This is the data value"); } } ``` ## Herstellen einer Verbindung mithilfe des Memcached-PHP-Clients ``` 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](https://pymemcache.readthedocs.io/en/latest/getting_started.html) ``` import ssl from pymemcache.client.base import Client context = ssl.create_default_context() cluster_endpoint = 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" ``` ## Connect mit dem NodeJS/TS Memcached-Client her (Electrode-IO Memcache) Siehe und [https://github.com/electrode-io/memcache[https://www.npmjs.com/package/memcache-client](https://www.npmjs.com/package/memcache-client)](https://github.com/electrode-io/memcache) 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) Siehe [https://crates.io/crates/memcache](https://crates.io/crates/memcache) und [https://github.com/aisk/rust-memcache](https://github.com/aisk/rust-memcache). ``` // create connection with to memcached server node: let client = memcache::connect("memcache+tls://: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](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](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(":11211", :ssl_context => ssl_context); client.get("abc") ``` ## Connect mit Memcached.NET-Client herstellen () EnyimMemcachedCore Siehe [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore) ``` "MemcachedClient": { "Servers": [ { "Address": "{cluster_endpoint}", "Port": 11211 } ], "UseSslStream": true } ``` Sie können jetzt mit [(Optional) Bereinigen](read-write-cleanup-mem.md) fortfahren.