As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Como usar a Descoberta automática
<a name="AutoDiscovery.Using"></a>

Para começar a usar a Descoberta automática com o ElastiCache para Memcached, siga estas etapas:
+ [Obter o endpoint de configuração](#AutoDiscovery.Using.ConfigEndpoint)
+ [Baixe o cliente de cluster do ElastiCache](#AutoDiscovery.Using.ClusterClient)
+ [Modificar seu programa aplicativo](#AutoDiscovery.Using.ModifyApp)

## Obter o endpoint de configuração
<a name="AutoDiscovery.Using.ConfigEndpoint"></a>

Para se conectar a um cluster, os programas cliente devem conhecer o endpoint de configuração de cluster. Consulte o tópico [Localização de endpoints de um cluster (console) (Memcached)](Endpoints.md#Endpoints.Find.Memcached)

Você também pode usar o comando `aws elasticache describe-cache-clusters` com o parâmetro `--show-cache-node-info`:

Seja qual for o método usado para encontrar os endpoints do cluster, o endpoint de configuração sempre terá **.cfg** em seu endereço.

**Example Localização de endpoints usando a AWS CLI para o ElastiCache**  
Para Linux, macOS ou Unix:  

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

```
aws elasticache describe-cache-clusters ^
    --cache-cluster-id mycluster ^
    --show-cache-node-info
```
Esta operação produz uma saída semelhante à seguinte (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"
        }
    ]
}
```

## Baixe o cliente de cluster do ElastiCache
<a name="AutoDiscovery.Using.ClusterClient"></a>

Para tirar proveito da Descoberta automática, os programas cliente devem usar o *cliente de cluster do ElastiCache*. O cliente de cluster do ElastiCache está disponível para Java, PHP e .NET e contém toda a lógica necessária para descobrir e conectar-se a todos os seus nós de cache.

**Para baixar o cliente de cluster do ElastiCache**

1. Faça login no Console de Gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. No console do ElastiCache, escolha **Cliente de cluster do ElastiCache**, e depois escolha **Baixar**.

O código-fonte do cliente de cluster do ElastiCache para Java está disponível em [https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Essa biblioteca se baseia no popular cliente Spymemcached. O cliente de cluster do ElastiCache é lançado sob a Licença de software da Amazon [https://aws.amazon.com/asl](https://aws.amazon.com/asl). Você tem a liberdade de modificar o código-fonte como você bem entender. Você pode até mesmo incorporar o código em outras bibliotecas Memcached de código aberto ou no seu próprio código de cliente.

**nota**  
Para usar o cliente de cluster do ElastiCache para PHP, você precisa primeiro instalá-lo na sua instância do Amazon EC2. Para obter mais informações, consulte [Instalação do cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoverySetup.md).  
Para clientes compatíveis com TLS, baixe o binário com PHP versão 7.4 ou superior.  
Para usar o cliente de cluster do ElastiCache para .NET, você precisa primeiro instalá-lo na sua instância do Amazon EC2. Para obter mais informações, consulte [Instalação do cliente de cluster do ElastiCache para .NET](Appendix.DotNETAutoDiscoverySetup.md).

## Modificar seu programa aplicativo
<a name="AutoDiscovery.Using.ModifyApp"></a>

Modifique seu programa aplicativo para que ele use a Descoberta automática. As seções a seguir mostram como usar o cliente de cluster do ElastiCache para Java, PHP e .NET. 

**Importante**  
Ao especificar o endpoint de configuração do cluster, certifique-se de que o endpoint tenha ".cfg" em seu endereço, conforme mostrado aqui. Não use um CNAME ou um endpoint sem ".cfg".   

```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
 Se o endpoint de configuração de cluster não for especificado explicitamente, a configuração ocorrerá para um nó específico.

# Uso do cliente de cluster do ElastiCache para Java
<a name="AutoDiscovery.Using.ModifyApp.Java"></a>

O programa abaixo demonstra como usar o cliente de cluster do ElastiCache para se conectar a um endpoint de configuração de cluster e adicionar um item de dados ao cache. Usando a Descoberta automática, o programa se conecta a todos os nós do cluster sem qualquer intervenção adicional.

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

# Usando o ElastiCache Cluster Client para PHP
<a name="AutoDiscovery.Using.ModifyApp.PHP"></a>

O programa abaixo demonstra como usar o ElastiCache Cluster Client para se conectar a um endpoint de configuração de cluster e adicionar um item de dados ao cache. Usando a Descoberta automática, o programa se conectará a todos os nós do cluster sem qualquer intervenção adicional.

Para usar o ElastiCache Cluster Client para PHP, primeiro você precisará instalá-lo na sua EC2 instância da Amazon. Para obter mais informações, consulte [Instalação do cliente de cluster do ElastiCache para 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');  
  ?>
```

Para ver um exemplo de como usar o ElastiCache Cluster Client com o TLS ativado, consulte [Usando criptografia em trânsito com PHP e Memcached](in-transit-encryption.md#in-transit-encryption-connect-php-mc).

# Uso do cliente de cluster do ElastiCache para .NET
<a name="AutoDiscovery.Using.ModifyApp.DotNET"></a>

**nota**  
O cliente de cluster ElastiCache .NET foi suspenso em maio de 2022.

Ocliente .NET para o ElastiCache é um código aberto que pode se encontrado em [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).

 Em geral, os aplicativos .NET obtém suas configurações de seu arquivo de configuração. O seguinte é um exemplo de arquivo de configuração de aplicativo.

```
<?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>
```

O programa em C\$1 abaixo demonstra como usar o cliente de cluster do ElastiCache para se conectar a um endpoint de configuração de cluster e adicionar um item de dados ao cache. Usando a Descoberta automática, o programa se conectará a todos os nós do cluster sem qualquer intervenção adicional.

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