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. # Einen serverlosen Memcached-Cache erstellen **AWS-Managementkonsole** So erstellen Sie mit der Konsole einen neuen serverlosen Memcached-Cache: ElastiCache 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache 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. Wählen Sie auf der rechten Seite der Konsole **Memcached-Cache erstellen** aus. 1. Geben Sie in den **Cache-Einstellungen** einen **Namen** ein. Sie können optional eine **Beschreibung** für den Cache eingeben. 1. Lassen Sie die Standardeinstellungen ausgewählt. 1. Klicken Sie auf **Erstellen**, um den Cache zu erstellen. 1. Sobald sich der Cache im Status „AKTIV“ befindet, können Sie mit dem Schreiben und Lesen von Daten in den Cache beginnen. Um einen neuen Cache mit dem zu erstellen AWS CLI Das folgende AWS CLI Beispiel erstellt einen neuen Cache mit create-serverless-cache. **Linux** ``` aws elasticache create-serverless-cache \ --serverless-cache-name CacheName \ --engine memcached ``` **Windows** ``` aws elasticache create-serverless-cache ^ --serverless-cache-name CacheName ^ --engine memcached ``` Beachten Sie, dass für das Feld „Status“ der Wert `CREATING` festgelegt ist. Verwenden Sie den `describe-serverless-caches` Befehl, ElastiCache um zu überprüfen, ob die Erstellung des Caches abgeschlossen ist. **Linux** ``` aws elasticache describe-serverless-caches --serverless-cache-name CacheName ``` **Windows** ``` aws elasticache describe-serverless-caches --serverless-cache-name CacheName ``` Fahren Sie nach dem Erstellen des neuen Caches mit [Daten in den Cache lesen und in den Cache schreiben](read-write-cache-mem.md) fort. # 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. # (Optional) Bereinigen **Mit dem AWS-Managementkonsole** Mit dem folgenden Verfahren wird ein einzelner Cache aus Ihrer Bereitstellung gelöscht. Wenn Sie mehrere Caches löschen möchten, wiederholen Sie das Verfahren für jeden Cache, den Sie löschen möchten. Sie brauchen nicht zu warten, bis ein Cache fertig gelöscht ist, bevor Sie den Vorgang zum Löschen eines anderen Caches starten. **So löschen Sie einen Cache** 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. Wählen Sie im ElastiCache Konsolen-Dashboard die Engine aus, die auf dem Cache läuft, den Sie löschen möchten. Es wird eine Liste mit allen Caches, in denen diese Engine ausgeführt wird, angezeigt. 1. Wählen Sie den Namen des Caches aus der Liste der Caches aus, um den zu löschenden Cache anzugeben. **Wichtig** Sie können jeweils nur einen Cache aus der ElastiCache Konsole löschen. Werden mehrere Caches ausgewählt, wird der Löschvorgang deaktiviert. 1. Klicken Sie bei ** Actions** auf **Delete**. 1. Wählen Sie auf dem Bestätigungsbildschirm **Cache löschen** die Option **Löschen** aus, um den Cache zu löschen, oder **Abbrechen**, wenn Sie den Cache luster beibehalten möchten. 1. Wenn Sie **Löschen** auswählen, ändert sich der Status des Caches in *deleting*. Sobald Ihr Cache in den Status **DELETING** wechselt, fallen für ihn keine Gebühren mehr an. **Mit dem AWS CLI** Der folgende Code löscht den Cache my-cache. ``` aws elasticache delete-serverless-cache --serverless-cache-name my-cache ``` Die delete-serverless-cache CLI-Aktion löscht nur einen serverlosen Cache. Um mehrere Caches zu löschen, rufen Sie delete-serverless-cache jeden serverlosen Cache auf, den Sie löschen möchten. Sie brauchen nicht zu warten, bis ein Serverless-Cache fertig gelöscht ist, bevor Sie einen anderen löschen. **Für Linux, macOS oder Unix:** ``` aws elasticache delete-serverless-cache \ --serverless-cache-name my-cache ``` **Für Windows:** ``` aws elasticache delete-serverless-cache ^ --serverless-cache-name my-cache ``` Weitere Informationen finden Sie im AWS CLI For-Thema. ElastiCache delete-serverless-cache Sie können jetzt mit [Nächste Schritte](next-steps-mem.md) fortfahren. # Nächste Schritte Weitere Informationen dazu finden ElastiCache Sie unter: + [Arbeiten mit ElastiCache](WorkingWithElastiCache.md) + [Skalierung ElastiCache](Scaling.md) + [Kontingente für ElastiCache](quota-limits.md) + [ElastiCache Best Practices und Caching-Strategien](BestPractices.md) + [ElastiCache Ereignisse anzeigen](ECEvents.Viewing.md)