Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Identifica automaticamente i nodi del cluster (Memcached) Per i cluster che utilizzano il motore Memcached, ElastiCache supporta *Auto Discovery*, la capacità dei programmi client di identificare automaticamente tutti i nodi di un cluster e di avviare e mantenere le connessioni a tutti questi nodi. **Nota** L'individuazione automatica viene aggiunta per i cluster in esecuzione su Amazon ElastiCache Memcached. Auto Discovery non è disponibile per i motori Valkey o Redis OSS. Con Individuazione automatica, non occorre collegare manualmente l'applicazione ai singoli nodi di cache; invece, l'applicazione si collega a un nodo Memcached e recupera l'elenco di nodi. Da tale elenco l'applicazione è in grado di conoscere il resto dei nodi nel cluster e può connettersi a uno qualsiasi di essi. Non è necessario codificare gli endpoint dei singoli nodi di cache nell'applicazione. Se si utilizza un tipo di rete dual stack sul cluster, Auto Discovery restituirà solo IPv6 gli indirizzi IPv4 o, a seconda di quello selezionato. Per ulteriori informazioni, consulta [Scelta del tipo di rete in ElastiCache](network-type.md). Tutti i nodi di cache nel cluster mantengono un elenco di metadati relativi a tutti gli altri nodi. Questi metadati vengono aggiornati ogni volta che si aggiungono o rimuovono nodi dal cluster. **Topics** + [Vantaggi dell'individuazione automatica con Memcached](AutoDiscovery.Benefits.md) + [Funzionamento di Individuazione automatica](AutoDiscovery.HowAutoDiscoveryWorks.md) + [Uso di Individuazione automatica](AutoDiscovery.Using.md) + [Connessione manuale ai nodi Memcached Cache](AutoDiscovery.Manual.md) + [Aggiungere Auto Discovery alla libreria client Memcached](AutoDiscovery.AddingToYourClientLibrary.md) + [ElastiCache clienti con rilevamento automatico](Clients.md) # Vantaggi dell'individuazione automatica con Memcached Quando si utilizza Memcached, Auto Discovery offre i seguenti vantaggi: + Quando si aumenta il numero di nodi in un cluster, i nuovi nodi si registrano con l'endpoint di configurazione e con tutti gli altri nodi. Quando si rimuovono nodi dal cluster di cache, i nodi che vengono a mancare annullano automaticamente la loro registrazione. In entrambi i casi, tutti gli altri nodi nel cluster vengono aggiornati con i metadati di nodi di cache più recenti. + Guasti nei nodi di cache vengono rilevati automaticamente; nodi non riusciti vengono sostituiti automaticamente. **Nota** Finché la sostituzione del nodo non viene completata, il nodo continuerà a restituire un errore. + Un programma client deve solo connettersi all'endpoint di configurazione. Successivamente, la libreria di Individuazione automatica si collega a tutti gli altri nodi nel cluster. + I programmi client eseguono il polling del cluster una volta il minuto (questo intervallo può essere modificato se necessario). In caso di modifiche alla configurazione del cluster, ad esempio nodi nuovi o eliminati, il client riceve un elenco aggiornato di metadati. Quindi il client si collega a, o si scollega da, questi nodi in base alle esigenze. Auto Discovery è abilitato su tutti i cluster ElastiCache Memcached. Per utilizzare questa caratteristica non è necessario riavviare i nodi di cache. # Funzionamento di Individuazione automatica **Topics** + [Connessione ai nodi di cache](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting) + [Operazioni cluster normali](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps) + [Altre operazioni](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps) Questa sezione descrive come le applicazioni client utilizzano il ElastiCache Cluster Client per gestire le connessioni dei nodi di cache e interagire con gli elementi di dati nella cache. ## Connessione ai nodi di cache Dal punto di vista dell'applicazione, la connessione all'endpoint di configurazione del cluster non è diverso dalla connessione diretta a un singolo nodo di cache. Il diagramma di sequenza seguente mostra il processo di connessione ai nodi di cache. ![\[Connessione ai nodi di cache\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png) **Processo di connessione ai nodi di cache** | | | | --- |--- | | ![\[1\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/1.png) | L'applicazione risolve il nome DNS dell'endpoint di configurazione. Poiché l'endpoint di configurazione mantiene le voci CNAME per tutti i nodi di cache, il nome DNS viene risolto in uno dei nodi; il client può quindi connettersi a tale nodo. | | ![\[2\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/2.png) | Il client richiede le informazioni di configurazione per tutti gli altri nodi. Poiché ogni nodo mantiene informazioni di configurazione per tutti i nodi nel cluster, qualsiasi nodo può passare informazioni di configurazione al client su richiesta. | | ![\[3\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/3.png) | Il client riceve l'elenco corrente di nomi host e indirizzi IP dei nodi di cache. Può quindi connettersi a tutti gli altri nodi nel cluster. | **Nota** Il programma client aggiorna il suo elenco di nomi host e indirizzi IP dei nodi di cache una volta il minuto. Questo intervallo di polling può essere modificato se necessario. ## Operazioni cluster normali Quando l'applicazione è connessa a tutti i nodi di cache, ElastiCache Cluster Client determina quali nodi devono archiviare i singoli elementi di dati e quali nodi devono essere interrogati per tali elementi di dati in un secondo momento. Il diagramma di sequenza seguente mostra il processo di operazioni cluster normali. ![\[Operazioni cluster normali\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png) **Processo di operazioni cluster normali** | | | | --- |--- | | ![\[1\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/1.png) | L'applicazione emette una richiesta get per un particolare item di dati, identificato dalla sua chiave. | | ![\[2\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/2.png) | Il client utilizza un algoritmo di hashing rispetto alla chiave per determinare quale nodo di cache contiene l'item di dati. | | ![\[3\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/3.png) | L'item di dati viene richiesto dal nodo appropriato. | | ![\[4\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/callouts/4.png) | L'item di dati viene restituito all'applicazione. | ## Altre operazioni In alcune situazioni, è possibile effettuare una modifica ai nodi di un cluster. Ad esempio, è possibile aggiungere un nodo aggiuntivo per soddisfare una domanda aggiuntiva oppure eliminare un nodo per risparmiare denaro durante i periodi di domanda ridotta. Oppure potresti sostituire un nodo a causa di un errore di un nodo di un tipo o di un altro. In presenza di una modifica nel cluster che richiede un aggiornamento dei metadati negli endpoint del cluster, tale modifica viene apportata a tutti i nodi contemporaneamente. Pertanto, i metadati in qualsiasi nodo specificato sono coerenti con i metadati in tutti gli altri nodi nel cluster. In ciascuno di questi casi, i metadati sono coerenti tra tutti i nodi in qualsiasi momento poiché i metadati vengono aggiornati contemporaneamente per tutti i nodi nel cluster. Si consiglia di utilizzare sempre l'endpoint di configurazione per ottenere gli endpoint dei diversi nodi nel cluster. L'uso dell'endpoint di configurazione evita che vengano ricevuti dati dell'endpoint da un nodo che "scompare". ### Aggiunta di un nodo Durante il periodo di attivazione del nodo, il suo endpoint non è incluso nei metadati. Non appena il nodo diventa disponibile, viene aggiunto ai metadati di ciascuno dei nodi del cluster. In questo scenario, i metadati sono coerenti tra tutti i nodi e sarai in grado di interagire con il nuovo nodo solo dopo che questo diventa disponibile. Il nodo non è noto prima che diventi disponibile e l'interazione con i nodi nel cluster avviene come se il nuovo nodo non esistesse. ### Eliminazione di un nodo Quando un nodo viene rimosso, il relativo endpoint viene rimosso innanzitutto dai metadati e quindi il nodo viene rimosso dal cluster. In questo scenario, i metadati in tutti i nodi sono coerenti e in nessun momento conterranno l'endpoint per il nodo che deve essere rimosso mentre il nodo non è disponibile. Durante la rimozione del nodo il tempo non è segnalato nei metadati e pertanto l'applicazione interagisce solo con gli n-1 nodi rimanenti, come se il nodo non esistesse. ### Sostituzione di un nodo Se un nodo ElastiCache si guasta, lo rimuove e ne avvia uno sostitutivo. Il processo di sostituzione richiede alcuni minuti. Durante questo periodo di tempo i metadati in tutti i nodi mostrano ancora l'endpoint per il nodo non riuscito, ma qualsiasi tentativo di interagire con il nodo restituisce un errore. Pertanto, la logica deve sempre includere la logica di ripetizione. # Uso di Individuazione automatica Per iniziare a utilizzare Auto Discovery with ElastiCache for Memcached, segui questi passaggi: + [Ottenete l'endpoint di configurazione](#AutoDiscovery.Using.ConfigEndpoint) + [Scarica il ElastiCache Cluster Client](#AutoDiscovery.Using.ClusterClient) + [Modifica il tuo programma applicativo](#AutoDiscovery.Using.ModifyApp) ## Ottenete l'endpoint di configurazione Per connettersi a un cluster, i programmi client devono conoscere l'endpoint di configurazione del cluster. Consulta l'argomento [Individuazione degli endpoint di un cluster (console) (Memcached)](Endpoints.md#Endpoints.Find.Memcached) Puoi anche utilizzare il comando `aws elasticache describe-cache-clusters` con il parametro `--show-cache-node-info`: Qualunque sia il metodo utilizzato per trovare gli endpoint del cluster, l'indirizzo dell'endpoint di configurazione conterrà sempre **.cfg**. **Example Ricerca degli endpoint utilizzando il comando for AWS CLI ElastiCache** Per Linux, macOS o Unix: ``` aws elasticache describe-cache-clusters \ --cache-cluster-id mycluster \ --show-cache-node-info ``` Per Windows: ``` aws elasticache describe-cache-clusters ^ --cache-cluster-id mycluster ^ --show-cache-node-info ``` Questa operazione genera un output simile al seguente (formato JSON): ``` { "CacheClusters": [ { "Engine": "memcached", "CacheNodes": [ { "CacheNodeId": "0001", "Endpoint": { "Port": 11211, "Address": "mycluster.fnjyzo.cfg.0001.use1.cache.amazonaws.com" }, "CacheNodeStatus": "available", "ParameterGroupStatus": "in-sync", "CacheNodeCreateTime": "2016-10-12T21:39:28.001Z", "CustomerAvailabilityZone": "us-east-1e" }, { "CacheNodeId": "0002", "Endpoint": { "Port": 11211, "Address": "mycluster.fnjyzo.cfg.0002.use1.cache.amazonaws.com" }, "CacheNodeStatus": "available", "ParameterGroupStatus": "in-sync", "CacheNodeCreateTime": "2016-10-12T21:39:28.001Z", "CustomerAvailabilityZone": "us-east-1a" } ], "CacheParameterGroup": { "CacheNodeIdsToReboot": [], "CacheParameterGroupName": "default.memcached1.4", "ParameterApplyStatus": "in-sync" }, "CacheClusterId": "mycluster", "PreferredAvailabilityZone": "Multiple", "ConfigurationEndpoint": { "Port": 11211, "Address": "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com" }, "CacheSecurityGroups": [], "CacheClusterCreateTime": "2016-10-12T21:39:28.001Z", "AutoMinorVersionUpgrade": true, "CacheClusterStatus": "available", "NumCacheNodes": 2, "ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:", "CacheSubnetGroupName": "default", "EngineVersion": "1.4.24", "PendingModifiedValues": {}, "PreferredMaintenanceWindow": "sat:06:00-sat:07:00", "CacheNodeType": "cache.r3.large" } ] } ``` ## Scarica il ElastiCache Cluster Client Per sfruttare Individuazione automatica, i programmi client devono utilizzare il *Client del cluster ElastiCache*. Il ElastiCache Cluster Client è disponibile per Java, PHP e.NET e contiene tutta la logica necessaria per scoprire e connettersi a tutti i nodi della cache. **Per scaricare il ElastiCache Cluster Client** 1. Accedi alla console di AWS gestione e apri la ElastiCache console all'indirizzo [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Dalla ElastiCache console, scegli **ElastiCache Cluster Client**, quindi scegli **Scarica**. Il codice sorgente per ElastiCache Cluster Client for Java è disponibile all'indirizzo [https://github.com/amazonwebservices/aws-elasticache-cluster-client- memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Questa libreria è basata sul client Spymemcached di uso comune. Il ElastiCache Cluster Client è rilasciato con la licenza Amazon Software [https://aws.amazon.com/asl](https://aws.amazon.com/asl). Sei libero di modificare il codice fonte come meglio credi. Puoi persino incorporare il codice in altre librerie Memcached open source o nel tuo codice client. **Nota** Per utilizzare ElastiCache Cluster Client for PHP, devi prima installarlo sulla tua EC2 istanza Amazon. Per ulteriori informazioni, consulta [Installazione del client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoverySetup.md). Per un client con supporto TLS, scarica il file binario con PHP versione 7.4 o superiore. Per utilizzare il ElastiCache Cluster Client for .NET, devi prima installarlo sulla tua EC2 istanza Amazon. Per ulteriori informazioni, consulta [Installazione del client ElastiCache cluster per.NET](Appendix.DotNETAutoDiscoverySetup.md). ## Modifica il tuo programma applicativo Modifica il programma dell'applicazione in modo che utilizzi Individuazione automatica. Le seguenti sezioni mostrano come utilizzare il ElastiCache Cluster Client per Java, PHP e.NET. **Importante** Durante la specifica dell'endpoint di configurazione del cluster, assicurati che l'indirizzo dell'endpoint contenga ".cfg" come mostrato qui. Non utilizzare un CNAME o un endpoint che non contiene ".cfg" al suo interno. ``` "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"; ``` La mancata specifica esplicita dell'endpoint di configurazione del cluster determina la configurazione di un nodo specifico. # Utilizzo del ElastiCache Cluster Client per Java Il programma seguente mostra come utilizzare il ElastiCache Cluster Client per connettersi a un endpoint di configurazione del cluster e aggiungere un elemento di dati alla cache. Utilizzando Individuazione automatica, il programma si connette a tutti i nodi nel cluster senza ulteriori interventi. ``` package com.amazon.elasticache; import java.io.IOException; import java.net.InetSocketAddress; // Import the &AWS;-provided library with Auto Discovery support import net.spy.memcached.MemcachedClient; public class AutoDiscoveryDemo { public static void main(String[] args) throws IOException { String configEndpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"; Integer clusterPort = 11211; MemcachedClient client = new MemcachedClient( new InetSocketAddress(configEndpoint, clusterPort)); // The client will connect to the other cache nodes automatically. // Store a data item for an hour. // The client will decide which cache host will store this item. client.set("theKey", 3600, "This is the data value"); } } ``` # Utilizzo del ElastiCache Cluster Client per PHP Il programma seguente mostra come utilizzare il ElastiCache Cluster Client per connettersi a un endpoint di configurazione del cluster e aggiungere un elemento di dati alla cache. Utilizzando Individuazione automatica, il programma si connette a tutti i nodi in un cluster senza ulteriori interventi. Per utilizzare ElastiCache Cluster Client for PHP, devi prima installarlo sulla tua EC2 istanza Amazon. Per ulteriori informazioni, consulta [Installazione del client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoverySetup.md) ``` setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE); $dynamic_client->addServer($server_endpoint, $server_port); /** * Store the data for 60 seconds in the cluster. * The client will decide which cache host will store this item. */ $dynamic_client->set('key', 'value', 60); /** * Configuring the client with Static client mode disables the usage of Auto Discovery * and the client operates as it did before the introduction of Auto Discovery. * The user can then add a list of server endpoints. */ $static_client = new Memcached('persistent-id'); $static_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::STATIC_CLIENT_MODE); $static_client->addServer($server_endpoint, $server_port); /** * Store the data without expiration. * The client will decide which cache host will store this item. */ $static_client->set('key', 'value'); ?> ``` Per un esempio su come utilizzare il ElastiCache Cluster Client con TLS abilitato, consulta [Utilizzo della crittografia in transito con PHP](in-transit-encryption.md#in-transit-encryption-connect-php-mc) e Memcached. # Utilizzo del ElastiCache Cluster Client per.NET **Nota** Il client del cluster ElastiCache .NET è obsoleto a maggio 2022. Il client.NET per ElastiCache è open source all'indirizzo. [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net) Le applicazioni .NET in genere recuperano le loro configurazioni dal file config. Di seguito viene riportato un file config dell'applicazione di esempio. ```
``` Il programma C\$1 riportato di seguito mostra come utilizzare il ElastiCache Cluster Client per connettersi a un endpoint di configurazione del cluster e aggiungere un elemento di dati alla cache. Utilizzando Individuazione automatica, il programma si connette a tutti i nodi in un cluster senza ulteriori interventi. ``` // ***************** // Sample C# code to show how to integrate with the Amazon ElastiCcache Auto Discovery feature. using System; using Amazon.ElastiCacheCluster; using Enyim.Caching; using Enyim.Caching.Memcached; public class DotNetAutoDiscoveryDemo { public static void Main(String[] args) { // instantiate a new client. ElastiCacheClusterConfig config = new ElastiCacheClusterConfig(); MemcachedClient memClient = new MemcachedClient(config); // Store the data for 3600 seconds (1hour) in the cluster. // The client will decide which cache host will store this item. memClient.Store(StoreMode.Set, 3600, "This is the data value."); } // end Main } // end class DotNetAutoDiscoverDemo ``` # Connessione manuale ai nodi Memcached Cache Se il programma client non utilizza Auto Discovery, può connettersi manualmente a ciascuno dei nodi di cache Memcached. Questo è il comportamento di default per i client Memcached. Puoi ottenere un elenco di nomi host e numeri porta dei nodi di cache dalla [AWS Console di gestione](https://aws.amazon.com/console/). È inoltre possibile utilizzare il AWS CLI`aws elasticache describe-cache-clusters` comando con il `--show-cache-node-info` parametro. **Example** Il seguente frammento di codice Java mostra come connettersi a tutti i nodi di un cluster a quattro nodi: ``` ... ArrayList cacheNodes = new ArrayList( Arrays.asList( "mycachecluster.fnjyzo.0001.use1.cache.amazonaws.com:11211", "mycachecluster.fnjyzo.0002.use1.cache.amazonaws.com:11211", "mycachecluster.fnjyzo.0003.use1.cache.amazonaws.com:11211", "mycachecluster.fnjyzo.0004.use1.cache.amazonaws.com:11211")); MemcachedClient cache = new MemcachedClient(AddrUtil.getAddresses(cacheNodes)); ... ``` **Importante** Se si aumenta o si riduce il cluster aggiungendo o rimuovendo nodi, sarà necessario aggiornare l'elenco dei nodi nel codice client. # Aggiungere Auto Discovery alla libreria client Memcached Le informazioni di configurazione per Auto Discovery sono archiviate in modo ridondante in ogni nodo del cluster Memcached. Le applicazioni client possono eseguire la query di qualsiasi nodo di cache e ottenere le informazioni di configurazione per tutti i nodi nel cluster. Il modo utilizzato dall'applicazione dipende dalla versione del motore della cache: + Se la versione del motore della cache è **1.4.14 o successive**, utilizza il comando `config`. + Se la versione del motore della cache è **precedente alla 1.4.14**, utilizza il comando `get AmazonElastiCache:cluster`. I risultati di questi due comandi sono identici e vengono descritti nella sezione [Formato di output](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) sottostante. ## Motore di cache versione 1.4.14 o successiva Per versioni del motore della cache 1.4.14 o successive, utilizza il comando `config`. Questo comando è stato aggiunto ai protocolli Memcached ASCII e binari da ElastiCache, ed è implementato nel Cluster Client. ElastiCache Se desideri utilizzare Individuazione automatica con un'altra libreria client, allora sarà necessario espandere tale libreria per supportare il comando `config`. **Nota** La documentazione seguente è relativa al protocollo ASCII; tuttavia, il comando `config` supporta ASCII e binario. Se desideri aggiungere il supporto Auto Discovery utilizzando il protocollo binario, fai riferimento al [codice sorgente del Cluster Client](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary). ElastiCache **Sintassi** `config [sub-command] [key]` ### Opzioni | Nome | Description | Richiesto | | --- | --- | --- | | sub-command | Il sottocomando utilizzando per interagire con un nodo di cache. Per Individuazione automatica, questo sottocomando è `get`. | Sì | | key | La chiave sotto cui viene archiviata la configurazione cluster. Per Individuazione automatica, questa chiave è denominata `cluster`. | Sì | Per ottenere le informazioni di configurazione del cluster, utilizza il seguente comando: ``` config get cluster ``` ## Motore di cache versione 1.4.14 o precedente Per ottenere le informazioni di configurazione del cluster, utilizza il seguente comando: ``` get AmazonElastiCache:cluster ``` **Nota** Non manomettere la chiave «:clusterAmazonElastiCache», poiché è qui che risiedono le informazioni di configurazione del cluster. Se si sovrascrive questa chiave, è possibile che il client venga configurato in modo errato per un breve periodo di tempo (non più di 15 secondi) prima di aggiornare ElastiCache automaticamente e correttamente le informazioni di configurazione. ## Formato di output A prescindere che utilizzi `config get cluster` o `get AmazonElastiCache:cluster`, la risposta è costituita sempre da due righe: + Il numero di versione delle informazioni di configurazione. Ogni volta che un nodo viene aggiunto o rimosso dal cluster, il numero di versione aumenta di uno. + Un elenco di nodi di cache. Ogni nodo nell'elenco è rappresentato da un gruppo *hostname\$1ip-address\$1port* e ogni nodo è delimitato da uno spazio. Alla fine di ciascuna riga vengono visualizzati un carattere di ritorno a capo e un carattere di avanzamento riga (CR \$1 LF). La riga di dati contiene un carattere di avanzamento riga (LF) alla fine, cui viene aggiunto CR \$1 LF. La riga di versione config è terminata da LF senza CR. Un cluster contenente tre nodi sarebbe rappresentato come segue: ``` configversion\n hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n ``` Ogni nodo viene mostrato con il CNAME e l'indirizzo IP privato. Il CNAME è sempre presente; se l'indirizzo IP privato non è disponibile, non verrà visualizzato; tuttavia, i caratteri pipe "`|`" verranno ancora stampati. **Example** Di seguito è riportato un esempio del payload restituito quando si esegue la query delle informazioni di configurazione: ``` CONFIG cluster 0 136\r\n 12\n myCluster.pc4ldq.0001.use1.cache.amazonaws.com|10.82.235.120|11211 myCluster.pc4ldq.0002.use1.cache.amazonaws.com|10.80.249.27|11211\n\r\n END\r\n ``` **Nota** La seconda riga indica che le informazioni di configurazione sono state modificate dodici volte finora. Nella terza riga, l'elenco dei nodi è in ordine alfabetico per nome host. Questo ordinamento deve essere in una sequenza diversa da quella attualmente in uso nell'applicazione client. # ElastiCache clienti con rilevamento automatico I programmi client del cluster possono identificare e connettersi automaticamente a tutti i nodi del cluster che eseguono il motore Memcached. Questa sezione descrive l'installazione e la configurazione dei client ElastiCache PHP e.NET da utilizzare con l'individuazione automatica. **Topics** + [Installazione e compilazione di client del cluster](Appendix.InstallingClients.md) + [Configurazione dei client ElastiCache](ClientConfig.md) # Installazione e compilazione di client del cluster Questa sezione tratta l'installazione, la configurazione e la compilazione dei client PHP e.NET Amazon ElastiCache auto discovery cluster. **Topics** + [Installazione del client ElastiCache cluster per.NET](Appendix.DotNETAutoDiscoverySetup.md) + [Installazione del client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoverySetup.md) + [Compilazione del codice sorgente per il client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoveryCompile.md) # Installazione del client ElastiCache cluster per.NET È possibile trovare il codice open source di ElastiCache .NET Cluster Client all'indirizzo [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net). Questa sezione descrive come installare, aggiornare e rimuovere i componenti.NET per il ElastiCache Cluster Client sulle EC2 istanze Amazon. Per ulteriori informazioni sull'individuazione automatica, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md). Per il codice .NET di esempio per utilizzare il client, consulta [Utilizzo del ElastiCache Cluster Client per.NET](AutoDiscovery.Using.ModifyApp.DotNET.md). **Topics** + [Installazione di .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET) + [Scarica il client cluster ElastiCache .NET per ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading) + [Installa AWS gli assiemi con NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing) ## Installazione di .NET È necessario che sia installato .NET 3.5 o versione successiva per utilizzare AWS .NET SDK per. ElastiCache In caso contrario, puoi scaricare e installare la versione più recente da [http://www.microsoft.com/net](http://www.microsoft.com/net). ## Scarica il client cluster ElastiCache .NET per ElastiCache **Per scaricare il client del cluster ElastiCache .NET** 1. Accedere a Console di gestione AWS e aprire la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Nel riquadro di navigazione, fai clic su **ElastiCache Cluster Client**. 1. **Nell'elenco **Scarica ElastiCache Memcached Cluster Client**, **seleziona.NET**, quindi fai clic su Scarica.** ## Installa AWS gli assiemi con NuGet NuGet è un sistema di gestione dei pacchetti per la piattaforma .NET. NuGet è consapevole delle dipendenze dell'assieme e installa automaticamente tutti i file richiesti. NuGet gli assembly installati vengono archiviati con la soluzione, anziché in una posizione centrale, ad esempio`Program Files`, in modo da poter installare versioni specifiche di un'applicazione senza creare problemi di compatibilità. ### Installazione NuGet NuGet può essere installato dalla Galleria di installazione su MSDN; vedere [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c). Se si utilizza Visual Studio NuGet 2010 o versione successiva, viene installato automaticamente. È possibile utilizzare NuGet da **Solution Explorer** o dalla **console di Package Manager**. ### Utilizzo NuGet da Solution Explorer **NuGet Da utilizzare da Solution Explorer in Visual Studio 2010** 1. Dal menu **Strumenti**, scegli **Gestione pacchetti libreria**. 1. Fai clic su **Console di Gestione pacchetti**. **NuGet Da utilizzare da Solution Explorer in Visual Studio 2012 o Visual Studio 2013** 1. Dal menu **Strumenti**, selezionare **NuGet Package Manager**. 1. Fai clic su **Console di Gestione pacchetti**. Dalla riga di comando, è possibile installare gli assembly utilizzando `Install-Package`, come mostrato di seguito. ``` Install-Package Amazon.ElastiCacheCluster ``` [Per visualizzare una pagina per ogni pacchetto disponibile tramite NuGet, ad esempio gli assembly AWS SDK AWS e.Extensions, visitate il sito Web all' NuGet indirizzo http://www.nuget.org.](http://www.nuget.org) La pagina di ogni pacchetto include una riga di comando di esempio per l'installazione del pacchetto tramite la console e un elenco delle versioni precedenti del pacchetto disponibili tramite. NuGet Per ulteriori informazioni sui comandi di **Package Manager Console (Console di Gestione pacchetti)**, consulta [http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29](http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29). # Installazione del client ElastiCache cluster per PHP Questa sezione descrive come installare, aggiornare e rimuovere i componenti PHP per il ElastiCache Cluster Client sulle EC2 istanze Amazon. Per ulteriori informazioni sull'individuazione automatica, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md). Per il codice PHP di esempio per utilizzare il client, consulta [Utilizzo del ElastiCache Cluster Client per PHP](AutoDiscovery.Using.ModifyApp.PHP.md). **Topics** + [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md) + [Per utenti con già installata l'estensione *php-memcached*](#Appendix.PHPAutoDiscoverySetup.InstallingExisting) + [Fasi di installazione per nuovi utenti](Appendix.PHPAutoDiscoverySetup.Installing.md) + [Rimozione del client del cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md) # Download del pacchetto di installazione Per assicurarti di utilizzare la versione corretta di ElastiCache Cluster Client for PHP, devi sapere quale versione di PHP è installata sulla tua istanza Amazon EC2 . Dovrai anche sapere se la tua EC2 istanza Amazon esegue una versione di Linux a 64 o 32 bit. **Per determinare la versione di PHP installata sulla tua istanza Amazon EC2** + Dal prompt dei comandi, eseguire il seguente comando: ``` php -v ``` La versione PHP verrà visualizzata nell'output, come nel seguente esempio: ``` PHP 5.4.10 (cli) (built: Jan 11 2013 14:48:57) Copyright (c) 1997-2012 The PHP Group Zend Engine v2.4.0, Copyright (c) 1998-2012 Zend Technologies ``` **Nota** Se le versioni PHP e Memcached non sono compatibili, verrà restituito un messaggio di errore simile al seguente: ``` PHP Warning: PHP Startup: memcached: Unable to initialize module Module compiled with module API=20100525 PHP compiled with module API=20131226 These options need to match in Unknown on line 0 ``` In tal caso, occorre compilare il modulo dal codice fonte. Per ulteriori informazioni, consulta [Compilazione del codice sorgente per il client ElastiCache cluster per PHP](Appendix.PHPAutoDiscoveryCompile.md). **Per determinare la tua architettura Amazon EC2 AMI (64 bit o 32 bit)** 1. Accedi a Console di gestione AWS e apri la EC2 console Amazon all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Nell'elenco **Istanze**, fai clic sulla tua EC2 istanza Amazon. 1. Nella scheda **Description (Descrizione)**, cercare il campo **AMI:**. Un'istanza a 64 bit deve includere `x86_64` come parte della descrizione; per un'istanza a 32 bit, cercare `i386` o `i686` in questo campo. Ora sei pronto per scaricare il ElastiCache Cluster Client. **Per scaricare il client ElastiCache cluster per PHP** 1. Accedi a Console di gestione AWS e apri la ElastiCache console all'indirizzo [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Dalla ElastiCache console, scegli **ElastiCache Cluster Client**. 1. **Dall'elenco **Scarica ElastiCache Memcached Cluster Client**, scegli il ElastiCache Cluster Client che corrisponde alla tua versione PHP e all'architettura AMI, quindi scegli il pulsante Download.** ## Per utenti con già installata l'estensione *php-memcached* **Per aggiornare l'installazione `php-memcached`** 1. Rimuovere l'installazione precedente dell'estensione Memcached per PHP come descritto dall'argomento [Rimozione del client del cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md). 1. Installa la nuova ElastiCache `php-memcached` estensione come descritto in precedenza in. [Fasi di installazione per nuovi utenti](Appendix.PHPAutoDiscoverySetup.Installing.md) # Fasi di installazione per nuovi utenti **Topics** + [Installazione di PHP 7.x per nuovi utenti](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x) + [Installazione di PHP 5.x per nuovi utenti](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x) ## Installazione di PHP 7.x per nuovi utenti **Topics** + [Per installare PHP 7 su un server Ubuntu 14.04 AMI LTS (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu) + [Per installare PHP 7 su un'AMI Amazon Linux 201609](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux) + [Per installare PHP 7 su un'AMI SUSE Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux) ### Per installare PHP 7 su un server Ubuntu 14.04 AMI LTS (64 bit e 32 bit) 1. Avviare una nuova istanza dall'AMI. 1. Esegui i comandi seguenti: ``` sudo apt-get update sudo apt-get install gcc g++ ``` 1. Installare PHP 7. ``` sudo yum install php70 ``` 1. Scarica Amazon ElastiCache Cluster Client. ``` wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit ``` 1. Estrarre `latest-64bit`. ``` tar -zxvf latest-64bit ``` 1. Con autorizzazioni root, copiare il file dell'artefatto estratto `amazon-elasticache-cluster-client.so` in `/usr/lib/php/20151012`. ``` sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012 ``` 1. Inserire la riga `extension=amazon-elasticache-cluster-client.so` nel file `/etc/php/7.0/cli/php.ini`. ``` echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php/7.0/cli/php.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ```   ### Per installare PHP 7 su un'AMI Amazon Linux 201609 1. Avviare una nuova istanza dall'AMI. 1. Esegui il comando seguente: ``` sudo yum install gcc-c++ ``` 1. Installare PHP 7. ``` sudo yum install php70 ``` 1. Scarica Amazon ElastiCache Cluster Client. ``` wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit ``` 1. Estrarre `latest-64bit`. ``` tar -zxvf latest-64bit ``` 1. Con autorizzazione root, copiare il file dell'artefatto estratto `amazon-elasticache-cluster-client.so` in `/usr/lib64/php/7.0/modules/`. ``` sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/ ``` 1. Crea il file `50-memcached.ini`. ``` echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ```   ### Per installare PHP 7 su un'AMI SUSE Linux 1. Avviare una nuova istanza dall'AMI. 1. Esegui il comando seguente: ``` sudo zypper install gcc ``` 1. Installare PHP 7. ``` sudo yum install php70 ``` 1. Scarica Amazon ElastiCache Cluster Client. ``` wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit ``` 1. Estrarre `latest-64bit`. ``` tar -zxvf latest-64bit ``` 1. Con autorizzazione root, copiare il file dell'artefatto estratto `amazon-elasticache-cluster-client.so` in `/usr/lib64/php7/extensions/`. ``` sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/ ``` 1. Inserire la riga `extension=amazon-elasticache-cluster-client.so` nel file `/etc/php7/cli/php.ini`. ``` echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ```   ## Installazione di PHP 5.x per nuovi utenti **Topics** + [Per installare PHP 5 su un'AMI Amazon Linux 2014.03 (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux) + [Per installare PHP 5 su un'AMI Red Hat Enterprise Linux 7.0 (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL) + [Per installare PHP 5 su un'AMI Ubuntu Server 14.04 LTS (64 bit e 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu) + [Per installare PHP 5 per l'AMI SUSE Linux Enterprise Server 11 (64 bit o 32 bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux) + [Altre distribuzioni Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other) ### Per installare PHP 5 su un'AMI Amazon Linux 2014.03 (64 bit e 32 bit) 1. Avviare un'istanza Amazon Linux (a 64 bit o 32 bit) ed eseguire l'accesso. 1. Installare le dipendenze PHP: ``` sudo yum install gcc-c++ php php-pear ``` 1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md). 1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione: ``` sudo pecl install ``` Di seguito è riportato un comando di installazione di esempio per PHP 5.4, Linux a 64 bit. In questo esempio, sostituisci *X.Y.Z* con il numero di versione effettivo: ``` sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz ``` **Nota** Assicurati di utilizzare la versione più recente dell'artefatto di installazione. 1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php.d` directory e inserisci «extension= amazon-elasticache-cluster-client .so» nel file: ``` echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ```   ### Per installare PHP 5 su un'AMI Red Hat Enterprise Linux 7.0 (64 bit e 32 bit) 1. Avviare un'istanza Red Hat Enterprise Linux (64 bit o 32 bit) ed eseguire l'accesso. 1. Installare le dipendenze PHP: ``` sudo yum install gcc-c++ php php-pear ``` 1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md). 1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione: ``` sudo pecl install ``` 1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php.d` directory e inseriscilo `extension=amazon-elasticache-cluster-client.so` nel file. ``` echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ```   ### Per installare PHP 5 su un'AMI Ubuntu Server 14.04 LTS (64 bit e 32 bit) 1. Avviare un'istanza Ubuntu Linux (a 64 bit o 32 bit) ed eseguire l'accesso. 1. Installare le dipendenze PHP: ``` sudo apt-get update sudo apt-get install gcc g++ php5 php-pear ``` 1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md). 1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione. ``` sudo pecl install ``` **Nota** Questa fase di installazione consente di installare l'artefatto di compilazione `amazon-elasticache-cluster-client.so` nella directory `/usr/lib/php5/20121212*`. Verifica il percorso assoluto dell'artefatto di compilazione perché è richiesto nella fase successiva. Se il comando precedente non funziona, occorre estrarre manualmente l'artefatto client PHP `amazon-elasticache-cluster-client.so` dal file `*.tgz` scaricato e copiarlo nella directory `/usr/lib/php5/20121212*`. ``` tar -xvf cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/ ``` 1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php5/cli/conf.d` directory e inserisci «extension=» nel file. ``` echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ```   ### Per installare PHP 5 per l'AMI SUSE Linux Enterprise Server 11 (64 bit o 32 bit) 1. Avviare un'istanza SUSE Linux (64 bit o 32 bit) ed eseguire l'accesso. 1. Installare le dipendenze PHP: ``` sudo zypper install gcc php53-devel ``` 1. Scarica il `php-memcached` pacchetto corretto per la tua EC2 istanza Amazon e la versione PHP. Per ulteriori informazioni, consulta [Download del pacchetto di installazione](Appendix.PHPAutoDiscoverySetup.Downloading.md). 1. Installare `php-memcached`. L'URI deve essere il percorso di download per il pacchetto di installazione. ``` sudo pecl install ``` 1. Con root/sudo l'autorizzazione, aggiungi un nuovo file denominato `memcached.ini` nella `/etc/php5/conf.d` directory e inseriscilo **extension=`amazon-elasticache-cluster-client.so`** nel file. ``` echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini ``` 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ``` **Nota** Se la Fase 5 non funziona per una delle piattaforme precedenti, verifica il percorso di installazione di `amazon-elasticache-cluster-client.so`. Specifica inoltre il percorso completo del file binario nell'estensione. Inoltre, verifica che la versione del PHP in uso sia supportata. Sono supportate le versioni da 5.3 a 5.5.   ### Altre distribuzioni Linux Su alcuni sistemi, in particolare Cent OS7 e Red Hat Enterprise Linux (RHEL) 7.1, `libsasl2.so.3` è stata sostituita. `libsasl2.so.2` Su questi sistemi, quando si carica il client del ElastiCache cluster, questo tenta e fallisce di trovare e caricare. `libsasl2.so.2` Per risolvere questo problema, crea un collegamento simbolico a `libsasl2.so.3` in modo che quando il client tenta di caricare libsasl2.so.2, viene reindirizzato a `libsasl2.so.3`. Il codice seguente crea questo collegamento simbolico: ``` cd /usr/lib64 sudo ln libsasl2.so.3 libsasl2.so.2 ``` # Rimozione del client del cluster PHP **Topics** + [Rimozione di una versione precedente di PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x) + [Rimozione di una versione precedente di PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x) ## Rimozione di una versione precedente di PHP 7 **Per rimuovere una versione precedente di PHP 7** 1. Rimuovi il file `amazon-elasticache-cluster-client.so` dalla directory lib PHP appropriata, come indicato in precedenza nelle istruzioni di installazione. Per informazioni sull'installazione consulta la sezione in [Per utenti con già installata l'estensione *php-memcached*](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting). 1. Rimuovi la riga `extension=amazon-elasticache-cluster-client.so` dal file `php.ini`. 1. Avviare o riavviare il server Apache. ``` sudo /etc/init.d/httpd start ``` ## Rimozione di una versione precedente di PHP 5 **Per rimuovere una versione precedente di PHP 5** 1. Rimuovi l'estensione `php-memcached`: ``` sudo pecl uninstall __uri/AmazonElastiCacheClusterClient ``` 1. Rimuovi il file `memcached.ini` aggiunto nella directory appropriata come indicato nelle fasi di installazione precedenti. # Compilazione del codice sorgente per il client ElastiCache cluster per PHP Questa sezione spiega come ottenere e compilare il codice sorgente per il ElastiCache Cluster Client for PHP. [Ci sono due pacchetti da cui estrarre GitHub e compilare; [aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) e -. aws-elasticache-cluster-client memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php) **Topics** + [Compilazione della libreria libmemcached](#Appendix.PHPAutoDiscoveryCompile.Libmemcached) + [Compilazione del client di auto discovery ElastiCache Memcached per PHP](#Appendix.PHPAutoDiscoveryCompile.Client) ## Compilazione della libreria libmemcached **Per compilare la libreria -libmemcached aws-elasticache-cluster-client** 1. Avvia un' EC2 istanza Amazon. 1. Installare le dipendenze di libreria. + In Amazon Linux 201509 AMI ``` sudo yum install gcc gcc-c++ autoconf libevent-devel ``` + In Ubuntu 14.04 AMI ``` sudo apt-get update sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev ``` 1. Estrarre il repository e compilare il codice. ``` Download and install [ https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz]( https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz) ``` ## Compilazione del client di auto discovery ElastiCache Memcached per PHP Le seguenti sezioni descrivono come compilare il Memcached Auto Discovery Client ElastiCache **Topics** + [Compilazione del client ElastiCache Memcached per PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7) + [Compilazione del client Memcached per ElastiCache PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5) ### Compilazione del client ElastiCache Memcached per PHP 7 Esegui il set di comandi seguente nella directory del codice. ``` git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git cd aws-elasticache-cluster-client-memcached-for-php git checkout php7 sudo yum install php70-devel phpize ./configure --with-libmemcached-dir= --disable-memcached-sasl make make install ``` **Nota** Puoi collegare staticamente la libreria libmemcached nel file binario PHP per consentirne la portabilità tra diverse piattaforme Linux. A questo scopo, esegui il comando seguente prima di `make`: ``` sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile ``` ### Compilazione del client Memcached per ElastiCache PHP 5 Compila `aws-elasticache-cluster-client-memcached-for-php` eseguendo i comandi seguenti nella cartella `aws-elasticache-cluster-client-memcached-for-php/`. ``` git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git cd aws-elasticache-cluster-client-memcached-for-php sudo yum install zlib-devel phpize ./configure --with-libmemcached-dir= make make install ``` # Configurazione dei client ElastiCache Un ElastiCache cluster è conforme al protocollo con Valkey, Memcached e Redis OSS. Il codice, le applicazioni e gli strumenti più diffusi che utilizzate oggi con l'ambiente esistente funzioneranno perfettamente con il servizio. In questa sezione vengono trattate considerazioni specifiche per la connessione ai nodi di cache in ElastiCache. **Topics** + [Comandi limitati](ClientConfig.RestrictedCommands.md) + [Individuazione di endpoint e numeri di porta dei nodi](ClientConfig.FindingEndpointsAndPorts.md) + [Connessione per l'utilizzo di Individuazione automatica](ClientConfig.AutoDiscovery.md) + [Connessione ai nodi in un cluster Valkey o Redis OSS](ClientConfig.ReplicationGroup.md) + [Nomi DNS e IP sottostante](ClientConfig.DNS.md) # Comandi limitati Per offrire un'esperienza di servizio gestito, ElastiCache limita l'accesso a determinati comandi specifici del motore di cache che richiedono privilegi avanzati. Per i cluster che eseguono Redis OSS, i seguenti comandi non sono disponibili: + `bgrewriteaof` + `bgsave` + `config` + `debug` + `migrate` + `replicaof` + `save` + `slaveof` + `shutdown` + `sync` # Individuazione di endpoint e numeri di porta dei nodi Per effettuare la connessione a un nodo di cache, l'applicazione deve conoscere l'endpoint e il numero di porta per tale nodo. ## Individuazione di endpoint e numeri di porta dei nodi (console) **Per determinare gli endpoint e i numeri di porta dei nodi** 1. Accedi alla [console di ElastiCache gestione Amazon](https://aws.amazon.com/elasticache) e scegli il motore in esecuzione sul tuo cluster. Viene visualizzato un elenco di tutti i cluster che eseguono il motore scelto. 1. Proseguire di seguito per il motore e la configurazione in esecuzione. 1. Scegliere il nome del cluster di interesse. 1. Individuare le colonne **Port (Porta)** ed **Endpoint** per il nodo desiderato. ## Individuazione di endpoint e numeri di porta dei nodi di cache (AWS CLI) Per determinare gli endpoint e i numeri di porta dei nodi di cache, utilizza il comando `describe-cache-clusters` con il parametro `--show-cache-node-info`. ``` aws elasticache describe-cache-clusters --show-cache-node-info ``` I nomi DNS completi e i numeri di porta si trovano nella sezione Endpoint dell'output. ## Ricerca degli endpoint e dei numeri di porta (ElastiCache API) dei nodi di cache Per determinare gli endpoint e i numeri di porta dei nodi di cache, utilizza l'operazione `DescribeCacheClusters` con il parametro `ShowCacheNodeInfo=true`. **Example** ``` 1. https://elasticache.us-west-2.amazonaws.com / 2. ?Action=DescribeCacheClusters 3. &ShowCacheNodeInfo=true 4. &SignatureVersion=4 5. &SignatureMethod=HmacSHA256 6. &Timestamp=20140421T220302Z 7. &Version=2014-09-30 8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256 9. &X-Amz-Credential= 10. &X-Amz-Date=20140421T220302Z 11. &X-Amz-Expires=20140421T220302Z 12. &X-Amz-Signature= 13. &X-Amz-SignedHeaders=Host ``` # Connessione per l'utilizzo di Individuazione automatica Se le applicazioni utilizzano Individuazione automatica, è sufficiente conoscere l'endpoint di configurazione per il cluster, anziché i singoli endpoint per ogni nodo di cache. Per ulteriori informazioni, consulta [Identifica automaticamente i nodi del cluster (Memcached)](AutoDiscovery.md). **Nota** Al momento, Auto Discovery è disponibile solo per i cluster che eseguono Memcached. # Connessione ai nodi in un cluster Valkey o Redis OSS **Nota** Al momento, i cluster (API/CLI: gruppi di replica) che supportano la replica e le repliche di lettura sono supportati solo per i cluster che eseguono Valkey o Redis OSS. Per i cluster, ElastiCache fornisce interfacce console, CLI e API per ottenere informazioni di connessione per i singoli nodi. Per attività di sola lettura, le applicazioni possono connettersi a qualsiasi nodo nel cluster. Tuttavia, per le attività di scrittura, consigliamo che le applicazioni si connettano all'endpoint principale (Valkey o Redis OSS (modalità cluster disabilitata)) o all'endpoint di configurazione (Valkey o Redis OSS (modalità cluster abilitata)) del cluster anziché connettersi direttamente a un nodo. In questo modo, l'applicazione può sempre trovare il nodo corretto, anche se si sceglie di riconfigurare il cluster promuovendo una replica di lettura al ruolo primario. ## Connessione a cluster in un gruppo di replica (Console) **Per determinare gli endpoint e i numeri di porta** + Consulta l'argomento [Ricerca degli endpoint (console) del cluster Valkey o Redis OSS (modalità cluster disabilitata)](Endpoints.md#Endpoints.Find.Redis) ## Connessione a cluster in un gruppo di replica (AWS CLI) **Per determinare gli endpoint e i numeri di porta dei nodi di cache** Utilizzare il comando `describe-replication-groups` con il nome del gruppo di replica: ``` aws elasticache describe-replication-groups redis2x2 ``` Questo comando dovrebbe generare un output simile al seguente: ``` { "ReplicationGroups": [ { "Status": "available", "Description": "2 shards, 2 nodes (1 + 1 replica)", "NodeGroups": [ { "Status": "available", "Slots": "0-8191", "NodeGroupId": "0001", "NodeGroupMembers": [ { "PreferredAvailabilityZone": "us-west-2c", "CacheNodeId": "0001", "CacheClusterId": "redis2x2-0001-001" }, { "PreferredAvailabilityZone": "us-west-2a", "CacheNodeId": "0001", "CacheClusterId": "redis2x2-0001-002" } ] }, { "Status": "available", "Slots": "8192-16383", "NodeGroupId": "0002", "NodeGroupMembers": [ { "PreferredAvailabilityZone": "us-west-2b", "CacheNodeId": "0001", "CacheClusterId": "redis2x2-0002-001" }, { "PreferredAvailabilityZone": "us-west-2a", "CacheNodeId": "0001", "CacheClusterId": "redis2x2-0002-002" } ] } ], "ConfigurationEndpoint": { "Port": 6379, "Address": "redis2x2.9dcv5r.clustercfg.usw2.cache.amazonaws.com" }, "ClusterEnabled": true, "ReplicationGroupId": "redis2x2", "SnapshotRetentionLimit": 1, "AutomaticFailover": "enabled", "SnapshotWindow": "13:00-14:00", "MemberClusters": [ "redis2x2-0001-001", "redis2x2-0001-002", "redis2x2-0002-001", "redis2x2-0002-002" ], "CacheNodeType": "cache.m3.medium", "PendingModifiedValues": {} } ] } ``` ## Connessione ai cluster in un gruppo di replica (API) ElastiCache **Per determinare gli endpoint e i numeri di porta dei nodi di cache** Chiama `DescribeReplicationGroups` con il seguente parametro: `ReplicationGroupId` = il nome del gruppo di replica. **Example** ``` 1. https://elasticache.us-west-2.amazonaws.com / 2. ?Action=DescribeCacheClusters 3. &ReplicationGroupId=repgroup01 4. &Version=2014-09-30 5. &SignatureVersion=4 6. &SignatureMethod=HmacSHA256 7. &Timestamp=20140421T220302Z 8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256 9. &X-Amz-Date=20140421T220302Z 10. &X-Amz-SignedHeaders=Host 11. &X-Amz-Expires=20140421T220302Z 12. &X-Amz-Credential= 13. &X-Amz-Signature= ``` # Nomi DNS e IP sottostante I client mantengono un elenco di server contenente gli indirizzi e i numeri di porta dei server che detengono i dati di cache. Quando viene utilizzata ElastiCache, l' DescribeCacheClusters API (o l'utilità della riga di describe-cache-clusters comando) restituisce una voce DNS completa e un numero di porta che possono essere utilizzati per l'elenco dei server. **Importante** È importante che le applicazioni client siano configurate per risolvere frequentemente nomi DNS di nodi di cache quando tentano di connettersi a un endpoint del nodo di cache. ElastiCache assicura che il nome DNS dei nodi di cache rimanga lo stesso quando i nodi di cache vengono ripristinati in caso di errore. La maggior parte delle librerie client supportano connessioni ai nodi di cache persistenti per impostazione predefinita. Ti consigliamo di utilizzare connessioni a nodi di cache persistenti durante l'utilizzo di ElastiCache. Il caching DNS lato client si può verificare in più punti, inclusi librerie client, il runtime del linguaggio di programmazione o il sistema operativo del client. È opportuno rivedere la configurazione dell'applicazione a ogni livello per essere certi di risolvere frequentemente indirizzi IP per i nodi di cache.