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á.
# Identificar automaticamente nós no seu cluster (Memcached)
Para clusters que executam o mecanismo Memcached, ElastiCache oferece suporte à *descoberta automática* — a capacidade dos programas cliente identificarem automaticamente todos os nós em um cluster e iniciarem e manterem conexões com todos esses nós.
**nota**
A descoberta automática é adicionada para clusters executados no Amazon ElastiCache Memcached. A Descoberta automática não está disponível para mecanismos Valkey ou Redis OSS.
Com a Descoberta automática, seu aplicativo não precisa se conectar manualmente a nós de cache individuais. Em vez disso, seu aplicativo se conecta a um nó Memcached e recupera a lista de nós. Nessa lista, seu aplicativo está ciente do restante dos nós no cluster e pode se conectar a qualquer um deles. Você não precisa embutir em código os endpoints de nó de cache individuais no seu aplicativo.
Se você estiver usando o tipo de rede dual stack em seu cluster, o Auto Discovery retornará somente IPv6 endereços IPv4 ou, dependendo de qual deles você selecionar. Para obter mais informações, consulte [Escolhendo um tipo de rede em ElastiCache](network-type.md).
Todos os nós de cache no cluster mantêm uma lista de metadados sobre todos os outros nós. Esses metadados são atualizados sempre que os nós são adicionados ou removidos do cluster.
**Topics**
+ [Benefícios da descoberta automática com o Memcached](AutoDiscovery.Benefits.md)
+ [Como a Descoberta automática funciona](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [Como usar a Descoberta automática](AutoDiscovery.Using.md)
+ [Conexão manual aos nós de cache do Memcached](AutoDiscovery.Manual.md)
+ [Adicionar a Descoberta automática à sua biblioteca de clientes do Memcached](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache clientes com descoberta automática](Clients.md)
# Benefícios da descoberta automática com o Memcached
Ao usar o Memcached, a descoberta automática oferece os seguintes benefícios:
+ Quando você aumenta o número de nós em um cluster, os novos nós se registram no endpoint da configuração e em todos os outros nós. Quando você remove os nós do cluster de cache, os nós de partida cancelam o registro. Em ambos os casos, todos os outros nós no cluster são atualizados com os metadados do nó de cache mais recentes.
+ As falhas de nós de cache são detectadas automaticamente. Os nós com falha são automaticamente substituídos.
**nota**
Até que a substituição dos nós seja concluída, o nó continuará a falhar.
+ Um programa cliente só precisa se conectar ao endpoint da configuração. Depois disso, a biblioteca da Descoberta automática se conecta a todos os outros nós do cluster.
+ Os programas cliente sondam o cluster uma vez por minuto (esse intervalo pode ser ajustado, se necessário). Se houver alguma alteração na configuração do cluster, como nós novos ou excluídos, o cliente receberá uma lista atualizada de metadados. Em seguida, o cliente se conecta ou desconecta desses nós conforme necessário.
A descoberta automática está ativada em todos os clusters do ElastiCache Memcached. Você não precisa reinicializar nenhum dos seus nós de cache para usar esse recurso.
# Como a Descoberta automática funciona
**Topics**
+ [Conexão com nós de cache](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [Operações normais de cluster](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [Outras operações](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
Esta seção descreve como os aplicativos cliente usam o cliente de cluster do ElastiCache para gerenciar conexões de nós de cache e interagir com itens de dados no cache.
## Conexão com nós de cache
Do ponto de vista do aplicativo, conectar-se ao endpoint de configuração de cluster não é diferente de conectar-se diretamente a um nó de cache individual. O diagrama de sequência a seguir mostra o processo de conexão com nós de cache.
![\[Conexão com nós de cache\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**Processo de conexão com nós de cache**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/1.png) | O aplicativo resolve o nome DNS do endpoint de configuração. Como o endpoint de configuração mantém entradas CNAME para todos os nós de cache, o nome DNS é resolvido para um dos nós. O cliente pode então se conectar a esse nó. |
| ![\[2\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/2.png) | O cliente solicita as informações de configuração para todos os outros nós. Como cada nó mantém informações de configuração para todos os nós do cluster, qualquer nó pode transmitir informações de configuração ao cliente mediante solicitação. |
| ![\[3\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/3.png) | O cliente recebe a lista atual de nomes de host e endereços IP de nós de cache. Em seguida, ele pode se conectar a todos os outros nós do cluster. |
**nota**
O programa cliente atualiza sua lista de nomes de host e endereços IP de nós de cache uma vez por minuto. Esse intervalo de sondagem pode ser ajustado se necessário.
## Operações normais de cluster
Quando a aplicação estiver conectada a todos os nós de cache, o cliente de cluster do ElastiCache determinará quais nós deverão armazenar os itens de dados individuais e quais nós deverão ser consultados para esses itens de dados mais tarde. O diagrama de sequência a seguir mostra o processo das operações normais de cluster.
![\[Operações normais de cluster\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**Processo das operações normais de cluster**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/1.png) | O aplicativo emite uma solicitação get para um item de dados específico, identificado por sua chave. |
| ![\[2\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/2.png) | O cliente usa um algoritmo de hash contra a chave para determinar qual nó de cache contém o item de dados. |
| ![\[3\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/3.png) | O item de dados é solicitado do nó apropriado. |
| ![\[4\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/callouts/4.png) | O item de dados é retornado ao aplicativo. |
## Outras operações
Em algumas situações, você pode alterar os nós de um cluster. Por exemplo, você pode acrescentar um nó adicional para acomodar demanda adicional ou excluir um nó para economizar dinheiro durante períodos de demanda reduzida. Ou você pode substituir um nó devido a uma falha de nó de uma ou outra classificação.
Quando há uma alteração no cluster que requer uma atualização de metadados para os endpoints do cluster, essa alteração é feita em todos os nós ao mesmo tempo. Portanto, os metadados em qualquer nó especificado são consistentes com os metadados em todos os outros nós do cluster.
Em cada um desses casos, os metadados são consistentes entre todos os nós em todos os momentos, já que os metadados são atualizados ao mesmo tempo para todos os nós do cluster. Você sempre deve usar o endpoint de configuração para obter os endpoints dos vários nós no cluster. Ao usar o endpoint de configuração, você garante que não obterá dados de endpoint de um nó que "desaparecerá".
### Adicionar um nó
Durante o tempo em que o nó está sendo configurado, seu endpoint não é incluído nos metadados. Assim que o nó estiver disponível, ele será adicionado aos metadados de cada um dos nós do cluster. Nesse cenário, os metadados são consistentes entre todos os nós, e você poderá interagir com o novo nó somente depois que ele estiver disponível. Antes de o nó estar disponível, você não saberá sobre ele e interagirá com os nós no seu cluster como se o novo nó não existisse.
### Excluir um nó
Quando um nó é removido, seu endpoint é primeiramente removido dos metadados e, em seguida, o nó é removido do cluster. Nesse cenário, os metadados em todos os nós são consistentes e em nenhuma ocasião ele conterá o endpoint para o nó a ser removido se esse nó não estiver disponível. Durante o tempo de remoção do nó, ele não é relatado nos metadados e, portanto, seu aplicativo só interagirá com os n-1 nós restantes, como se o nó não existisse.
### Substituir um nó
Se um nó falhar, o ElastiCache o retirará e configurará uma substituição. O processo de substituição demora alguns minutos. Durante esse tempo, os metadados em todos os nós ainda mostram o endpoint do nó com falha, mas qualquer tentativa de interação com esse nó falhará. Portanto, sua lógica sempre deve incluir uma lógica de nova tentativa.
# Como usar a Descoberta automática
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
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
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
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
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
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).
```
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
**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.
```
```
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
```
# Conexão manual aos nós de cache do Memcached
Se o seu programa cliente não usar a descoberta automática, ele poderá se conectar manualmente a cada um dos nós de cache do Memcached. Este é o comportamento padrão para clientes Memcached.
Você pode obter uma lista de nomes de host de nós de cache e números de portas no [Console de Gerenciamento da AWS](https://aws.amazon.com/console/). Você também pode usar o AWS CLI`aws elasticache describe-cache-clusters` comando com o `--show-cache-node-info` parâmetro.
**Example**
O seguinte trecho de código Java mostra como se conectar a todos os nós em um cluster de quatro nós:
```
...
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 você expandir ou reduzir seu cluster adicionando ou removendo nós, precisará atualizar a lista de nós no código do cliente.
# Adicionar a Descoberta automática à sua biblioteca de clientes do Memcached
As informações de configuração para Descoberta automática são armazenadas de forma redundante em cada nó de cluster Memcached. Os aplicativos cliente podem consultar qualquer nó de cache e obter as informações de configuração para todos os nós no cluster.
A maneira como um aplicativo faz isso depende da versão do mecanismo de cache:
+ Se a versão do mecanismo de cache for **1.4.14 ou superior**, use o comando `config`.
+ Se a versão do mecanismo de cache for **inferior a 1.4.14**, use o comando `get AmazonElastiCache:cluster`.
As saídas desses dois comandos são idênticas e estão descritas na seção [Output Format](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) abaixo.
## Versão do mecanismo de cache 1.4.14 ou superior
Para o mecanismo de cache versão 1.4.14 ou superior, use o comando `config`. Esse comando foi adicionado ao Memcached ASCII e aos protocolos binários por ElastiCache, e é implementado no Cluster Client. ElastiCache Se você quiser usar a Descoberta automática com outra biblioteca de cliente, essa biblioteca precisará ser estendida para oferecer suporte ao comando `config`.
**nota**
A seguinte documentação pertence ao protocolo ASCII. No entanto, o comando `config` oferece suporte para ASCII e binário. Se você quiser adicionar suporte à descoberta automática usando o protocolo binário, consulte o [código-fonte do ElastiCache Cluster Client](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary).
**Sintaxe**
`config [sub-command] [key]`
### Opções
| Name (Nome) | Description | Obrigatório |
| --- | --- | --- |
| sub-command | O subcomando usado para interagir com um nó de cache. Para a Descoberta automática, esse subcomando é `get`. | Sim |
| key | A chave na qual a configuração de cluster está armazenada. Para a Descoberta automática, essa chave se chama `cluster`. | Sim |
Para obter as informações de configuração do cluster, use o seguinte comando:
```
config get cluster
```
## Versão do mecanismo de cache 1.4.14 ou inferior
Para obter as informações de configuração do cluster, use o seguinte comando:
```
get AmazonElastiCache:cluster
```
**nota**
Não altere a chave “:clusterAmazonElastiCache”, pois é aqui que residem as informações de configuração do cluster. Se você sobrescrever essa chave, o cliente poderá ser configurado incorretamente por um breve período de tempo (não mais que 15 segundos) antes de atualizar ElastiCache automaticamente e corretamente as informações de configuração.
## Output Format
Se você usar `config get cluster` ou `get AmazonElastiCache:cluster`, a resposta consistirá em duas linhas:
+ O número de versão das informações de configuração. Cada vez que um nó é adicionado ou removido do cluster, o número da versão aumenta em um.
+ Uma lista de nós de cache. Cada nó na lista é representado por um grupo de *nome do host\$1endereço IP\$1porta*, e cada nó é delimitado por um espaço.
Um retorno de carro e um caractere de avanço de linha (CR \$1 LF) aparecem no final de cada linha. A linha de dados contém um caractere de avanço de linha (LF) no final, ao qual o CR\$1LF é adicionado. A linha de versão de configuração é encerrada por LF sem o CR.
Um cluster contendo três nós seria representado da seguinte maneira:
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
Cada nó é mostrado com o CNAME e o endereço IP privado. O CNAME sempre estará presente. Se o endereço IP privado não estiver disponível, ele não será mostrado. Entretanto, os caracteres de barra vertical "`|`" continuarão a ser impressos.
**Example**
Veja a seguir um exemplo da carga útil retornada quando você consulta as informações de configuração:
```
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**
A segunda linha indica que as informações de configuração foram modificadas doze vezes até agora.
Na terceira linha, a lista de nós está em ordem alfabética por nome de host. Essa ordem pode estar em uma sequência diferente da que você está usando no seu aplicativo cliente.
# ElastiCache clientes com descoberta automática
Os programas cliente de cluster podem identificar e se conectar automaticamente a todos os nós de cluster que executem o mecanismo Memcached.
Esta seção discute a instalação e a configuração dos clientes ElastiCache PHP e .NET para uso com descoberta automática.
**Topics**
+ [Instalação e compilação de clientes de cluster](Appendix.InstallingClients.md)
+ [Configuração do ElastiCache](ClientConfig.md)
# Instalação e compilação de clientes de cluster
Esta seção discute a instalação, a configuração e a compilação dos clientes de cluster de descoberta automática PHP e .NET do Amazon ElastiCache.
**Topics**
+ [Instalação do cliente de cluster do ElastiCache para .NET](Appendix.DotNETAutoDiscoverySetup.md)
+ [Instalação do cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoverySetup.md)
+ [Compilação do código-fonte para o cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoveryCompile.md)
# Instalação do cliente de cluster do ElastiCache para .NET
Você pode encontrar o código do cliente de cluster .NET do ElastiCache como código aberto em [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Esta seção descreve como instalar, atualizar e remover os componentes .NET do cliente de cluster do ElastiCache em instâncias do Amazon EC2. Para obter mais informações sobre a descoberta automática, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md). Para obter o código de exemplo do .NET para usar o cliente, consulte [Uso do cliente de cluster do ElastiCache para .NET](AutoDiscovery.Using.ModifyApp.DotNET.md).
**Topics**
+ [Instalar o .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [Baixar o cliente de cluster .NET do ElastiCache para ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [Instalar conjuntos da AWS com o NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing)
## Instalar o .NET
Você deve ter o .NET 3.5 ou posterior instalado para usar o SDK .NET da AWS para ElastiCache. Caso não tenha o .NET 3.5 ou posterior, pode fazer download e instalar a versão mais recente em [http://www.microsoft.com/net](http://www.microsoft.com/net).
## Baixar o cliente de cluster .NET do ElastiCache para ElastiCache
**Para baixar o cliente de cluster .NET 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 painel de navegação, clique em **ElastiCache Cluster Client**.
1. Na lista **Download ElastiCache Memcached Cluster Client**, selecione **.NET** e clique em **Download.**
## Instalar conjuntos da AWS com o NuGet
O NuGet é um sistema de gerenciamento de pacotes para a plataforma .NET. O NuGet está ciente das dependências de assembly e instala todos os arquivos necessários automaticamente. Os assemblies instalados pelo NuGet são armazenados com a sua solução, em vez de em uma localização central, como em `Program Files`, e, por isso, você pode instalar versões específicas para um aplicativo sem criar problemas de compatibilidade.
### Instalar o NuGet
O NuGet pode ser instalado da galeria de instalação no MSDN; consulte [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c). Se você estiver usando o Visual Studio 2010 ou posterior, o NuGet será instalado automaticamente.
Você pode usar o NuGet no **Gerenciador de Soluções** ou no **Console do Gerenciador de Pacotes**.
### Usar o NuGet no Gerenciador de Soluções
**Para usar o NuGet no Gerenciador de Soluções do Visual Studio 2010**
1. No menu **Ferramentas**, selecione **Gerenciador de Pacotes de Biblioteca**.
1. Clique em **Console do Gerenciador de Pacotes**.
**Para usar o NuGet no Solution Explorer do Visual Studio 2012 ou Visual Studio 2013**
1. No menu **Ferramentas**, selecione **Gerenciador de Pacotes NuGet**.
1. Clique em **Console do Gerenciador de Pacotes**.
Na linha de comando, você pode instalar os assemblies usando `Install-Package`, conforme mostrado a seguir.
```
Install-Package Amazon.ElastiCacheCluster
```
Para ver uma página de cada pacote disponível via NuGet, como os conjuntos SDK da AWS e extensões da AWS, consulte o site do NuGet em [http://www.nuget.org](http://www.nuget.org). A página de cada pacote inclui uma linha de comando de amostra para instalar o pacote usando o console e uma lista das versões anteriores desse pacote que estão disponíveis no NuGet.
Para obter mais informações sobre os comandos do **Console do Gerenciador de Pacotes**, consulte [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).
# Instalação do cliente de cluster do ElastiCache para PHP
Esta seção descreve como instalar, atualizar e remover os componentes de PHP do cliente de cluster do ElastiCache em instâncias do Amazon EC2. Para obter mais informações sobre a descoberta automática, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md). Para obter o código de exemplo do PHP para usar o cliente, consulte [Usando o ElastiCache Cluster Client para PHP](AutoDiscovery.Using.ModifyApp.PHP.md).
**Topics**
+ [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [Para usuários que já possuam a extensão *php-memcached* instalada](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [Etapas de instalação para novos usuários](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [Remoção do cliente de cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md)
# Para baixar o pacote de instalação
Para garantir que está usando a versão correta do cliente de cluster do ElastiCache para PHP, você precisa saber qual versão do PHP está instalada na sua instância do Amazon EC2. Você também precisará saber se a sua instância do Amazon EC2 está executando uma versão de 64 bits ou 32 bits do Linux.
**Para determinar a versão do PHP instalada na sua instância do Amazon EC2**
+ No prompt de comando, execute o seguinte comando:
```
php -v
```
A versão do PHP será mostrada na saída, como neste exemplo:
```
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 suas versões do PHP e do Memcached forem incompatíveis, você receberá uma mensagem de erro como a seguinte:
```
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
```
Se isso acontecer, será necessário compilar o módulo do código-fonte. Para obter mais informações, consulte [Compilação do código-fonte para o cliente de cluster do ElastiCache para PHP](Appendix.PHPAutoDiscoveryCompile.md).
**Para determinar a sua arquitetura de AMI do Amazon EC2 (64 bits ou 32 bits)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Na lista **Instances** (Instâncias), clique na sua instância do Amazon EC2.
1. Na guia **Description**, procure o campo **AMI:**. Uma instância de 64 bits deve ter `x86_64` como parte da descrição. Para uma instância de 32 bits, procure `i386` ou `i686` neste campo.
Agora, você está pronto para baixar o cliente de cluster do ElastiCache.
**Para baixar o cliente de cluster do ElastiCache para PHP**
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 **ElastiCache Cluster Client** (Cliente de cluster do ElastiCache.
1. Na lista **Download ElastiCache Memcached Cluster Client** (Baixar cliente de cluster Memcached do ElastiCache), escolha o cliente de cluster do ElastiCache que corresponda à sua versão do PHP e arquitetura da AMI e depois escolha o botão **Download** (Baixar).
## Para usuários que já possuam a extensão *php-memcached* instalada
**Para atualizar a instalação do `php-memcached`**
1. Remova a instalação anterior da extensão Memcached para PHP, conforme descrito pelo tópico [Remoção do cliente de cluster PHP](Appendix.PHPAutoDiscoverySetup.Removing.md).
1. Instale a nova extensão `php-memcached` do ElastiCache conforme descrito anteriormente em [Etapas de instalação para novos usuários](Appendix.PHPAutoDiscoverySetup.Installing.md).
# Etapas de instalação para novos usuários
**Topics**
+ [Instalação do PHP 7.x para novos usuários](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [Instalação do PHP 5.x para novos usuários](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## Instalação do PHP 7.x para novos usuários
**Topics**
+ [Para instalar o PHP 7 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [Para instalar o PHP 7 em uma AMI Amazon Linux 201609](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [Para instalar o PHP 7 em uma AMI SUSE Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### Para instalar o PHP 7 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)
1. Execute uma nova instância a partir da AMI.
1. Execute os seguintes comandos:
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. Instale o PHP 7.
```
sudo yum install php70
```
1. Baixe o cliente de cluster do Amazon ElastiCache.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extraia `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Com permissões de root, copie o arquivo de artefato extraído `amazon-elasticache-cluster-client.so` para `/usr/lib/php/20151012`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. Insira a linha `extension=amazon-elasticache-cluster-client.so` no arquivo `/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. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 7 em uma AMI Amazon Linux 201609
1. Execute uma nova instância a partir da AMI.
1. Execute o seguinte comando:
```
sudo yum install gcc-c++
```
1. Instale o PHP 7.
```
sudo yum install php70
```
1. Baixe o cliente de cluster do Amazon ElastiCache.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extraia `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Com permissão de root, copie o arquivo de artefato extraído `amazon-elasticache-cluster-client.so` para `/usr/lib64/php/7.0/modules/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. Crie o arquivo `50-memcached.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 7 em uma AMI SUSE Linux
1. Execute uma nova instância a partir da AMI.
1. Execute o seguinte comando:
```
sudo zypper install gcc
```
1. Instale o PHP 7.
```
sudo yum install php70
```
1. Baixe o cliente de cluster do Amazon ElastiCache.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extraia `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Com permissão de root, copie o arquivo de artefato extraído `amazon-elasticache-cluster-client.so` para `/usr/lib64/php7/extensions/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. Insira a linha `extension=amazon-elasticache-cluster-client.so` no arquivo `/etc/php7/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
## Instalação do PHP 5.x para novos usuários
**Topics**
+ [Para instalar o PHP 5 em uma AMI Amazon Linux 2014.03 (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [Para instalar o PHP 5 em uma AMI Red Hat Enterprise Linux 7.0 (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [Para instalar o PHP 5 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [Para instalar o PHP 5 para a AMI SUSE Linux Enterprise Server 11 (64 bits ou 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [Outras distribuições do Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### Para instalar o PHP 5 em uma AMI Amazon Linux 2014.03 (64 bits e 32 bits)
1. Inicie uma instância do Amazon Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação:
```
sudo pecl install
```
Veja a seguir um exemplo de comando de instalação para o PHP 5.4, Linux de 64 bits. Nessa amostra, substitua *X.Y.Z* pelo número de versão atual:
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**nota**
Use a versão recente do artefato de instalação.
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php.d` e insira "extension=amazon-elasticache-cluster-client.so" no arquivo:
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 5 em uma AMI Red Hat Enterprise Linux 7.0 (64 bits e 32 bits)
1. Execute uma instância do Red Hat Enterprise Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação:
```
sudo pecl install
```
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php.d` e insira `extension=amazon-elasticache-cluster-client.so` no arquivo.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 5 em uma AMI Ubuntu Server 14.04 LTS (64 bits e 32 bits)
1. Inicie uma instância do Ubuntu Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação.
```
sudo pecl install
```
**nota**
Essa etapa de instalação instala o artefato de build `amazon-elasticache-cluster-client.so` no diretório `/usr/lib/php5/20121212*`. Verifique o caminho absoluto do artefato de build, porque você precisa dele na próxima etapa.
Se o comando anterior não funcionar, você precisará extrair manualmente o artefato de cliente PHP `amazon-elasticache-cluster-client.so` do arquivo `*.tgz` obtido por download e copiá-lo para o diretório `/usr/lib/php5/20121212*`.
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php5/cli/conf.d` e insira "extension=" no arquivo.
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar o PHP 5 para a AMI SUSE Linux Enterprise Server 11 (64 bits ou 32 bits)
1. Inicie uma instância do SUSE Linux (64 bits ou 32 bits) e faça login nela.
1. Instalar dependências PHP:
```
sudo zypper install gcc php53-devel
```
1. Baixe o pacote `php-memcached` correto para sua instância do Amazon EC2 e versão do PHP. Para obter mais informações, consulte [Para baixar o pacote de instalação](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar o `php-memcached`. O URI deve ser o caminho de download para o pacote de instalação.
```
sudo pecl install
```
1. Com a permissão root/sudo, adicione um novo arquivo denominado `memcached.ini` no diretório `/etc/php5/conf.d` e insira **extension=`amazon-elasticache-cluster-client.so`** no arquivo.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
**nota**
Se a Etapa 5 não funcionar para nenhuma das plataformas anteriores, verifique o caminho de instalação para `amazon-elasticache-cluster-client.so`. Além disso, especifique o caminho completo do binário da extensão. Além disso, verifique se o PHP em uso é uma versão com suporte. Oferecemos suporte às versões 5.3 a 5.5.
### Outras distribuições do Linux
Em alguns sistemas, especialmente o CentOS7 e o Red Hat Enterprise Linux (RHEL) 7.1, `libsasl2.so.3` substituiu `libsasl2.so.2`. Nesses sistemas, quando você carrega o cliente de cluster ElastiCache, ele tenta e não consegue localizar e carregar `libsasl2.so.2`. Para resolver esse problema, crie um link simbólico para `libsasl2.so.3`, de forma que, quando o cliente tentar carregar libsasl2.so.2, ele seja redirecionado para `libsasl2.so.3`. O código a seguir cria esse link simbólico.
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# Remoção do cliente de cluster PHP
**Topics**
+ [Remover uma versão anterior do PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [Remover uma versão anterior do PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## Remover uma versão anterior do PHP 7
**Para remover uma versão anterior do PHP 7**
1. Remova o arquivo `amazon-elasticache-cluster-client.so` do diretório lib PHP apropriado, conforme indicado anteriormente nas instruções de instalação. Consulte a seção para a sua instalação em [Para usuários que já possuam a extensão *php-memcached* instalada](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting).
1. Remova a linha `extension=amazon-elasticache-cluster-client.so` do arquivo `php.ini`.
1. Inicie ou reinicie seu servidor Apache.
```
sudo /etc/init.d/httpd start
```
## Remover uma versão anterior do PHP 5
**Para remover uma versão anterior do PHP 5**
1. Remova a extensão `php-memcached`:
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. Remova o arquivo `memcached.ini` adicionado no diretório apropriado, conforme indicado nas etapas de instalação anteriores.
# Compilação do código-fonte para o cliente de cluster do ElastiCache para PHP
Esta seção discute como obter e compilar o código-fonte do cliente de cluster do ElastiCache para PHP.
Existem dois pacotes que você precisa extrair do GitHub e compilar; [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**
+ [Compilação da biblioteca libmemcached](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [Compilação do cliente de descoberta automática do Memcached do ElastiCache para PHP](#Appendix.PHPAutoDiscoveryCompile.Client)
## Compilação da biblioteca libmemcached
**Para compilar a biblioteca aws-elasticache-cluster-client-libmemcached**
1. Iniciar uma instância do Amazon EC2.
1. Instale as dependências da biblioteca.
+ Na AMI Amazon Linux 201509
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ Na AMI Ubuntu 14.04
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. Extraia o repositório e compile o código.
```
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)
```
## Compilação do cliente de descoberta automática do Memcached do ElastiCache para PHP
As seções a seguir descrevem como compilar o cliente de descoberta automática do Memcached do ElastiCache
**Topics**
+ [Compilação do cliente do Memcached do ElastiCache para PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [Compilação do cliente do Memcached do ElastiCache para PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5)
### Compilação do cliente do Memcached do ElastiCache para PHP 7
Execute o seguinte conjunto de comandos no diretório de código.
```
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**
Você pode vincular estaticamente a biblioteca libmemcached ao binário PHP para que ele possa ser compatibilizado em várias plataformas Linux. Para fazer isso, execute o seguinte comando antes de `make`:
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### Compilação do cliente do Memcached do ElastiCache para PHP 5
Compile o `aws-elasticache-cluster-client-memcached-for-php` executando os seguintes comandos na pasta `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
```
# Configuração do ElastiCache
Um cluster do ElastiCache tem conformidade de protocolo com o Valkey, Memcached e Redis OSS. O código, aplicações e as ferramentas mais populares que você usa hoje com seu ambiente existente funcionarão perfeitamente com o serviço.
Esta seção discute considerações específicas para se conectar a nós de cache no ElastiCache.
**Topics**
+ [Comandos restritos](ClientConfig.RestrictedCommands.md)
+ [Localização de endpoints de nó e números de porta](ClientConfig.FindingEndpointsAndPorts.md)
+ [Conexão para uso da descoberta automática](ClientConfig.AutoDiscovery.md)
+ [Conexão a nós em um cluster Valkey ou Redis OSS](ClientConfig.ReplicationGroup.md)
+ [Nomes de DNS e IP subjacente](ClientConfig.DNS.md)
# Comandos restritos
Para oferecer uma experiência de serviço gerenciado, ElastiCache restringe o acesso a determinados comandos específicos do mecanismo de cache que exigem privilégios avançados. Para clusters executando o Redis OSS, os seguintes comandos não estão disponíveis:
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# Localização de endpoints de nó e números de porta
Para se conectar a um nó de cache, seu aplicativo precisa conhecer o endpoint e o número da porta desse nó.
## Localização de endpoints de nó e números de porta (console)
**Para determinar os endpoints do nó e os números de porta**
1. Faça login no [ Console de Gerenciamento do Amazon ElastiCache](https://aws.amazon.com/elasticache) e escolha o mecanismo em execução no seu cluster.
É exibida uma lista de todos os clusters que executam o mecanismo escolhido.
1. Continue abaixo para o mecanismo e a configuração que você está executando.
1. Escolha o nome do cluster de interesse.
1. Localize as colunas **Port** e **Endpoint** para o nó em que você está interessado.
## Localização de endpoints de nó de cache e números de porta (AWS CLI)
Para determinar endpoints de nó de cache e números de porta, use o comando `describe-cache-clusters` com o parâmetro `--show-cache-node-info`.
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
Os nomes DNS e números de porta totalmente qualificados estão na seção Endpoint da saída.
## Localização de endpoints de nó de cache e números de porta (API do ElastiCache)
Para determinar endpoints de nó de cache e números de porta, use a ação `DescribeCacheClusters` com o parâmetro `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
```
# Conexão para uso da descoberta automática
Se os seus aplicativos usam a Descoberta automática, você só precisa conhecer o endpoint de configuração do cluster, e não os endpoints individuais de cada nó de cache. Para obter mais informações, consulte [Identificar automaticamente nós no seu cluster (Memcached)](AutoDiscovery.md).
**nota**
Neste momento, a Descoberta automática só está disponível para clusters executando o Memcached.
# Conexão a nós em um cluster Valkey ou Redis OSS
**nota**
Neste momento, os clusters (API/CLI: grupos de replicação) que oferecem suporte para replicação e réplicas de leitura têm suporte apenas para clusters que executam o Valkey ou o Redis OSS.
Para clusters, o ElastiCache fornece interfaces de console, CLI e API para informações de conexão de nós individuais.
Para atividades somente leitura, os aplicativos podem se conectar a qualquer nó no cluster. No entanto, para a atividade de gravação, recomendamos que suas aplicações se conectem ao endpoint primário (Valkey ou Redis OSS (modo cluster desabilitado)) ou ao endpoint de configuração (Valkey ou Redis OSS (modo cluster habilitado)) do cluster em vez de se conectarem diretamente a um nó. Isso garantirá que seus aplicativos sempre possam localizar o nó correto, mesmo que você decida reconfigurar seu cluster promovendo uma réplica de leitura para a função primária.
## Conexão a clusters em um grupo de replicação (console)
**Para determinar endpoints e números de porta**
+ Consulte o tópico, [Localização de endpoints de um cluster do Valkey ou do Redis OSS (modo cluster desabilitado) (console)](Endpoints.md#Endpoints.Find.Redis).
## Conexão a clusters em um grupo de replicação (AWS CLI)
**Para determinar endpoints de nó de cache e números de porta**
Use o comando `describe-replication-groups` com o nome do seu grupo de replicação:
```
aws elasticache describe-replication-groups redis2x2
```
Esse comando deve produzir um resultado semelhante ao seguinte:
```
{
"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": {}
}
]
}
```
## Conexão a clusters em um grupo de replicação (API do ElastiCache)
**Para determinar endpoints de nó de cache e números de porta**
Chame `DescribeReplicationGroups` com o seguinte parâmetro:
`ReplicationGroupId` = o nome do seu grupo de replicação.
**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=
```
# Nomes de DNS e IP subjacente
Os clientes mantêm uma lista de servidores contendo os endereços e as portas dos servidores que possuem os dados do cache. Ao usar o ElastiCache, a API DescribeCacheClusters (ou o utilitário de linha de comando describe-cache-clusters) retorna uma entrada DNS totalmente qualificada e um número de porta que podem ser usados para a lista de servidores.
**Importante**
É importante que os aplicativos do cliente estejam configurados para resolver frequentemente os nomes DNS dos nós de cache quando eles tentam se conectar a um endpoint do nó de cache.
O ElastiCache garante que o nome DNS dos nós de cache permaneçam os mesmos quando os nós de cache forem recuperados em caso de falha.
A maioria das bibliotecas de cliente oferece suporte para conexões persistentes de nó de cache por padrão. Recomendamos o uso de conexões de nó de cache persistentes ao usar o ElastiCache. O armazenamento em cache de DNS no lado do cliente pode ocorrer em vários locais, incluindo bibliotecas de clientes, runtime da linguagem ou sistema operacional do cliente. Você deve revisar a configuração do seu aplicativo em cada camada para garantir que esteja resolvendo os endereços IP frequentemente para seus nós de cache.