Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation de la découverte automatique
<a name="AutoDiscovery.Using"></a>

Pour commencer à utiliser Auto Discovery avec ElastiCache for Memcached, procédez comme suit :
+ [Obtenir le point de terminaison de configuration](#AutoDiscovery.Using.ConfigEndpoint)
+ [Téléchargez le client ElastiCache de cluster](#AutoDiscovery.Using.ClusterClient)
+ [Modifiez votre programme de candidature](#AutoDiscovery.Using.ModifyApp)

## Obtenir le point de terminaison de configuration
<a name="AutoDiscovery.Using.ConfigEndpoint"></a>

Pour se connecter à un cluster, les programmes clients doivent connaître le point de terminaison de configuration du cluster. Consultez la rubrique [Trouver les points de terminaison d'un cluster (console) (Memcached)](Endpoints.md#Endpoints.Find.Memcached)

Vous pouvez également utiliser la commande `aws elasticache describe-cache-clusters` avec le paramètre `--show-cache-node-info` :

Quelle que soit la méthode que vous utilisez pour trouver les points de terminaison du cluster, le point de terminaison de configuration aura toujours **.cfg** dans son adresse.

**Example Recherche de points de terminaison à l'aide du for AWS CLI ElastiCache**  
Pour Linux, macOS ou Unix :  

```
aws elasticache describe-cache-clusters \
    --cache-cluster-id mycluster \
    --show-cache-node-info
```
Pour Windows :  

```
aws elasticache describe-cache-clusters ^
    --cache-cluster-id mycluster ^
    --show-cache-node-info
```
Cette opération produit une sortie similaire à la sortie suivante (format 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"
        }
    ]
}
```

## Téléchargez le client ElastiCache de cluster
<a name="AutoDiscovery.Using.ClusterClient"></a>

Pour pouvoir bénéficier de la découverte automatique, les programmes clients doivent utiliser le *client de cluster ElastiCache*. Le client de ElastiCache cluster est disponible pour Java, PHP et .NET et contient toute la logique nécessaire pour découvrir et se connecter à tous vos nœuds de cache.

**Pour télécharger le client ElastiCache de cluster**

1. Connectez-vous à la console AWS de gestion et ouvrez-la à l' ElastiCache adresse [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. Dans la ElastiCache console, choisissez **ElastiCache Cluster Client**, puis **Download**.

Le code source du client ElastiCache Cluster pour Java est disponible à l'adresse [https://github.com/amazonwebservices/aws-elasticache-cluster-client- memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Cette bibliothèque est basée sur le client Spymemcached populaire. Le client de ElastiCache cluster est publié sous la licence logicielle Amazon [https://aws.amazon.com/asl.](https://aws.amazon.com/asl) Vous êtes libre de modifier le code source selon vos besoins. Vous pouvez même incorporer le code dans d'autres bibliothèques Memcached open source, ou dans votre propre code client.

**Note**  
Pour utiliser le client de ElastiCache cluster pour PHP, vous devez d'abord l'installer sur votre EC2 instance Amazon. Pour de plus amples informations, veuillez consulter [Installation du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoverySetup.md).  
Pour un client qui prend en charge TLS, téléchargez le binaire avec PHP version 7.4 ou supérieure.  
Pour utiliser le client de ElastiCache cluster pour .NET, vous devez d'abord l'installer sur votre EC2 instance Amazon. Pour de plus amples informations, veuillez consulter [Installation du client de ElastiCache cluster pour .NET](Appendix.DotNETAutoDiscoverySetup.md).

## Modifiez votre programme de candidature
<a name="AutoDiscovery.Using.ModifyApp"></a>

Modifiez votre programme d'application afin qu'il utilise la découverte automatique. Les sections suivantes montrent comment utiliser le client de ElastiCache cluster pour Java, PHP et .NET. 

**Important**  
Lorsque vous spécifiez le point de terminaison de configuration du cluster, assurez-vous que le point de terminaison a « .cfg » dans son adresse comme illustré ici. N'utilisez pas un CNAME ou un point de terminaison sans « .cfg ».   

```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
 Si vous ne spécifiez pas explicitement le point de terminaison de configuration du cluster, la configuration se fait sur un nœud spécifique.

# Utilisation du client de ElastiCache cluster pour Java
<a name="AutoDiscovery.Using.ModifyApp.Java"></a>

Le programme ci-dessous montre comment utiliser le client de ElastiCache cluster pour se connecter à un point de terminaison de configuration de cluster et ajouter un élément de données au cache. L'utilisation de la découverte automatique permet au programme de connecter tous les nœuds du cluster sans aucune autre intervention.

```
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");
    }
}
```

# Utilisation du client de ElastiCache cluster pour PHP
<a name="AutoDiscovery.Using.ModifyApp.PHP"></a>

Le programme ci-dessous montre comment utiliser le client de ElastiCache cluster pour se connecter à un point de terminaison de configuration de cluster et ajouter un élément de données au cache. L'utilisation de la découverte automatique permettra au programme de se connecter à tous les nœuds du cluster sans aucune autre intervention.

Pour utiliser le client de ElastiCache cluster pour PHP, vous devez d'abord l'installer sur votre EC2 instance Amazon. Pour de plus amples informations, consultez [Installation du client de ElastiCache cluster pour PHP](Appendix.PHPAutoDiscoverySetup.md).

```
<?php
	
 /**
  * Sample PHP code to show how to integrate with the Amazon ElastiCache
  * Auto Discovery feature.
  */

  /* Configuration endpoint to use to initialize memcached client. 
   * This is only an example. 	*/
  $server_endpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
  
  /* Port for connecting to the ElastiCache cluster. 
   * This is only an example 	*/
  $server_port = 11211;

 /**
  * The following will initialize a Memcached client to utilize the Auto Discovery feature.
  * 
  * By configuring the client with the Dynamic client mode with single endpoint, the
  * client will periodically use the configuration endpoint to retrieve the current cache
  * cluster configuration. This allows scaling the cluster up or down in number of nodes
  * without requiring any changes to the PHP application. 
  *
  * By default the Memcached instances are destroyed at the end of the request. 
  * To create an instance that persists between requests, 
  *    use persistent_id to specify a unique ID for the instance. 
  * All instances created with the same persistent_id will share the same connection. 
  * See [http://php.net/manual/en/memcached.construct.php](http://php.net/manual/en/memcached.construct.php) for more information.
  */
  $dynamic_client = new Memcached('persistent-id');
  $dynamic_client->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');  
  ?>
```

Pour un exemple d'utilisation du client de ElastiCache cluster avec TLS activé, voir [Utilisation du chiffrement en transit avec PHP et Memcached](in-transit-encryption.md#in-transit-encryption-connect-php-mc).

# Utilisation du client de ElastiCache cluster pour .NET
<a name="AutoDiscovery.Using.ModifyApp.DotNET"></a>

**Note**  
Le client de cluster ElastiCache .NET est devenu obsolète en mai 2022.

Le client .NET pour ElastiCache est open source à l'adresse [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).

 Les applications .NET obtiennent généralement leur configuration à partir de leur fichier de configuration. Le fichier ci-dessous est un exemple de fichier de configuration.

```
<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <configSections>
        <section 
            name="clusterclient" 
            type="Amazon.ElastiCacheCluster.ClusterConfigSettings, Amazon.ElastiCacheCluster" />
    </configSections>

    <clusterclient>
        <!-- the hostname and port values are from step 1 above -->
        <endpoint hostname="mycluster.fnjyzo.cfg.use1.cache.amazonaws.com" port="11211" />
    </clusterclient>
</configuration>
```

Le programme C\$1 ci-dessous montre comment utiliser le client de ElastiCache cluster pour se connecter à un point de terminaison de configuration de cluster et ajouter un élément de données au cache. L'utilisation de la découverte automatique permettra au programme de se connecter à tous les nœuds du cluster sans aucune autre intervention.

```
// *****************
// 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
```