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 „ EC2 Erste Schritte](https://aws.amazon.com/ec2/getting-started/)“. ElastiCache Erstellt standardmäßig einen Cache in Ihrer Standard-VPC. Stellen Sie sicher, dass Ihre EC2 Instance auch in der Standard-VPC erstellt wurde, damit sie eine Verbindung zum 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 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)](in-transit-encryption.md). ## Herstellen einer Verbindung mithilfe des Memcached-Java-Clients ``` 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](https://pymemcache.readthedocs.io/en/latest/getting_started.html)\$1started.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) [https://github.com/electrode-io/Siehe](https://github.com/electrode-io/memcache) Memcache und [https://www.npmjs.com/package/Memcache-Client](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](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) [https://github.com/bradfitz/Siehe 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) [Siehst du Dalli https://github.com/petergoldstein/](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.