Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Identificación automática de los nodos en el clúster (Memcached)
Para los clústeres que ejecutan el motor Memcached, ElastiCache es compatible con la *detección automática*: la capacidad de los programas cliente de identificar automáticamente todos los nodos de un clúster e iniciar y mantener las conexiones con todos estos nodos.
**nota**
Se añade la detección automática para los clústeres que se ejecutan en Amazon ElastiCache Memcached. La detección automática no está disponible para los motores de Valkey o Redis OSS.
Con la función Auto Discovery, su aplicación no necesita conectarse manualmente a los nodos de caché individuales; en su lugar, la aplicación se conecta a un nodo de Memcached y recupera la lista de nodos. Con esa lista, su aplicación identificará los demás nodos del clúster y se podrá conectar a cualquiera de ellos. Por lo tanto, no tendrá que codificar de forma rígida los puntos de enlace de nodo de caché en su aplicación.
Si utiliza un tipo de red de doble pila en su clúster, Auto Discovery solo devolverá IPv6 direcciones IPv4 o direcciones, según la que seleccione. Para obtener más información, consulte [Elegir un tipo de red en ElastiCache](network-type.md) .
Todos los nodos de caché del clúster mantienen una lista de metadatos de todos los demás nodos. Estos metadatos se actualizan cuando se agregan o se borran nodos del clúster.
**Topics**
+ [Ventajas de la detección automática con Memcached](AutoDiscovery.Benefits.md)
+ [Funcionamiento de la detección automática](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [Uso de la detección automática](AutoDiscovery.Using.md)
+ [Conexión manual a los nodos de caché de Memcached](AutoDiscovery.Manual.md)
+ [Adición de detección automática a la biblioteca cliente de Memcached](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache clientes con detección automática](Clients.md)
# Ventajas de la detección automática con Memcached
La detección automática tiene las siguientes ventajas cuando se utiliza con Memcached:
+ Al aumentar el número de nodos en un clúster, los nuevos nodos se registran con el punto de conexión de configuración y con todos los demás nodos. Al eliminar nodos del clúster de caché, los nodos salientes cancelan su registro. En ambos casos, todos los demás nodos del clúster se actualizan con los metadatos de nodos de caché más recientes.
+ Los errores de nodos de caché se detectan automáticamente y los nodos que presentan errores se reemplazan automáticamente.
**nota**
Los nodos con error seguirán dando error hasta que se complete su reemplazo.
+ Los programas cliente solo necesitan conectarse al punto de enlace de configuración. Tras realizar la conexión, la biblioteca de la función Auto Discovery se conecta a todos los demás nodos del clúster.
+ Los programas cliente sondean el clúster una vez por minuto (este intervalo puede ajustarse si es necesario). Si se producen cambios en la configuración del clúster como, por ejemplo, al agregar nuevos nodos o eliminar nodos, el cliente recibe una lista actualizada de metadatos. A continuación, el cliente se conecta a estos nodos o se desconecta de ellos según sea necesario.
La detección automática está habilitada en todos los clústeres de ElastiCache Memcached. Por lo tanto, no es necesario reiniciar ninguno de los nodos de caché para usar esta funcionalidad.
# Funcionamiento de la detección automática
**Topics**
+ [Conexión a los nodos de caché](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [Operaciones de clúster normales](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [Otras operaciones](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
En esta sección, se describe cómo las aplicaciones cliente utilizan ElastiCache Cluster Client para administrar las conexiones de nodo de caché e interactuar con los elementos de datos de la caché.
## Conexión a los nodos de caché
Desde el punto de vista de la aplicación, la conexión al punto de enlace de configuración del clúster no es distinta de la conexión directa a un nodo de caché individual. El siguiente diagrama de secuencias muestra el proceso de enlace a los nodos de caché.
![\[Conexión a los nodos de caché\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**Proceso de enlace a los nodos de caché**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/1.png) | La aplicación resuelve el nombre de DNS del punto de enlace de configuración. Puesto que el punto de enlace de configuración mantiene las entradas de CNAME para todos los nodos de caché, el nombre de DNS se resuelve en uno de los nodos. De este modo, el cliente puede conectarse a dicho nodo. |
| ![\[2\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/2.png) | El cliente solicita la información de configuración para todos los demás nodos. Puesto que cada nodo mantiene información de configuración para todos los nodos del clúster, cualquier nodo puede pasar la información de configuración al cliente bajo petición. |
| ![\[3\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/3.png) | El cliente recibe la lista actual de direcciones IP y nombres de host de los nodos de caché. De este modo, se puede conectar a todos los demás nodos del clúster. |
**nota**
El programa cliente actualiza su lista de direcciones IP y nombres de host de los nodos de caché una vez por minuto. Este intervalo de sondeo se puede ajustar si es necesario.
## Operaciones de clúster normales
Cuando la aplicación se ha conectado a todos los nodos de caché, ElastiCache Cluster Client determina qué nodos deben almacenar elementos de datos individuales y a qué nodos es necesario consultar dichos elementos de datos más adelante. El siguiente diagrama de secuencias muestra el proceso de las operaciones de clúster normales.
![\[Operaciones de clúster normales\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**Proceso de operaciones de clúster normales**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/1.png) | La aplicación emite una solicitud get para obtener un elemento de datos determinado identificado por su clave. |
| ![\[2\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/2.png) | El cliente usa un algoritmo de hash con la clave para determinar qué nodo de caché contiene el elemento de datos. |
| ![\[3\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/3.png) | El elemento de datos se solicita desde el nodo adecuado. |
| ![\[4\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/callouts/4.png) | El elemento de datos se devuelve a la aplicación. |
## Otras operaciones
En algunas situaciones, puede realizar un cambio en los nodos de un clúster. Por ejemplo, puede agregar un nodo adicional para adaptarse a la demanda adicional o eliminar un nodo a fin de ahorrar dinero durante periodos de demanda reducida. O puede reemplazar un nodo debido a un error de nodo de un tipo u otro.
Cuando se produce un cambio en el clúster que requiere actualizar los metadatos con los puntos de enlace del clúster, dicho cambio se realiza en todos los nodos al mismo tiempo. De este modo se consigue que los metadatos de un nodo determinado coincidan con los de los demás nodos del clúster.
En cada uno de estos casos, los metadatos son siempre homogéneos entre todos los nodos, ya que los metadatos se actualizan al mismo tiempo en todos los nodos del clúster. Use siempre el punto de enlace de configuración para obtener los puntos de enlace a los distintos nodos del clúster. Al usar el punto de enlace de configuración, se asegurará de no obtener datos de puntos de enlace de un nodo que “desaparecerá”.
### Agregar un nodo
Durante la activación del nodo, su punto de enlace no se incluye en los metadatos. Tan pronto como el nodo esté disponible, el punto de enlace se agrega a los metadatos de cada uno de los nodos del clúster. En este caso, los metadatos son coherentes entre todos los nodos. De este modo, solo podrá interactuar con el nuevo nodo en cuanto esté disponible. Antes de que el nodo esté disponible, no sabrá que existe e interactuará con los nodos del clúster como si el nuevo nodo no existiese.
### Eliminación de un nodo
Cuando se elimina un nodo, su punto de enlace se elimina primero de los metadatos. A continuación, el nodo se elimina del clúster. En este caso, los metadatos de todos los nodos son homogéneos, por lo que no contendrán en ningún momento el punto de enlace del nodo que se va a eliminar mientras el nodo no esté disponible. Durante la eliminación del nodo, el punto de enlace no estará incluido en los metadatos y su aplicación solo interactuará con los nodos restantes (n-1), como si el nodo no existiese.
### Reemplazo de un nodo
En caso de error en un nodo, ElastiCache elimina dicho nodo y pone en marcha un reemplazo. El proceso de reemplazo tarda unos minutos. Durante este tiempo, los metadatos de todos los nodos seguirán mostrando el punto de enlace del nodo con error; sin embargo, toda interacción con el nodo generará un error. Por lo tanto, su lógica debe incluir siempre una lógica de reintentos.
# Uso de la detección automática
Para empezar a usar la detección automática con ElastiCache para Memcached, siga estos pasos:
+ [Obtención del punto de conexión de configuración](#AutoDiscovery.Using.ConfigEndpoint)
+ [Descarga de ElastiCache Cluster Client](#AutoDiscovery.Using.ClusterClient)
+ [Modificación de su programa de aplicación](#AutoDiscovery.Using.ModifyApp)
## Obtención del punto de conexión de configuración
Para conectarse a un clúster, los programas cliente deben conocer el punto de conexión de configuración del clúster. Consulte el tema [Búsqueda de puntos de conexión de un clúster (consola) (Memcached)](Endpoints.md#Endpoints.Find.Memcached)
También puede usar el comando `aws elasticache describe-cache-clusters` con el parámetro `--show-cache-node-info`:
Sea cual sea el método que use para buscar los puntos de enlace del clúster, el punto de conexión de configuración siempre tendrá la cadena **.cfg** en su dirección.
**Example Búsqueda de puntos de enlace con la AWS CLI de ElastiCache**
Para Linux, macOS o 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 operación produce un resultado similar al siguiente (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"
}
]
}
```
## Descarga de ElastiCache Cluster Client
Para sacar el máximo partido a la detección automática, los programas de cliente deben utilizar *ElastiCache Cluster Client*. ElastiCache Cluster Client se encuentra disponible para Java, PHP y .NET, y contiene toda la lógica necesaria a fin de detectar todos los nodos de caché y conectarse a ellos.
**Para descargar ElastiCache Cluster Client**
1. Inicie sesión en la consola de administración de AWS y abra la consola de ElastiCache en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Desde la consola de ElastiCache, elija **ElastiCache Cluster Client** y, a continuación, **Download** (Descargar).
El código fuente de ElastiCache Cluster Client para Java se encuentra disponible en [https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java). Esta biblioteca se basa en el popular cliente Spymemcached. ElastiCache Cluster Client se encuentra sujeto a la licencia de software de Amazon [https://aws.amazon.com/asl](https://aws.amazon.com/asl). Podrá modificar el código fuente de la manera que estime más conveniente. Podrá incluso incorporar el código a bibliotecas de Memcached de código abierto o al código de su propio cliente.
**nota**
A fin de utilizar ElastiCache Cluster Client para PHP, primero debe instalarlo en su instancia de Amazon EC2. Para obtener más información, consulte [Instalación de ElastiCache Cluster Client para .PHP](Appendix.PHPAutoDiscoverySetup.md).
Para un cliente compatible con TLS, descargue el binario con PHP versión 7.4 o superior.
A fin de utilizar ElastiCache Cluster Client para .NET, primero debe instalarlo en su instancia de Amazon EC2. Para obtener más información, consulte [Instalación de ElastiCache Cluster Client para .NET](Appendix.DotNETAutoDiscoverySetup.md).
## Modificación de su programa de aplicación
Modifique su programa de aplicación para que pueda usar la función Auto Discovery. Las siguientes secciones muestran cómo utilizar ElastiCache Cluster Client para Java, PHP y .NET.
**importante**
Cuando especifique el punto de conexión de la configuración del clúster, asegúrese de que el punto de conexión tenga la cadena ".cfg" en su dirección, tal como se muestra aquí. No use un CNAME o un punto de conexión que no tengan la cadena ".cfg".
```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
Si no especifica de forma explícita el punto de conexión de la configuración del clúster, realizará la configuración de un nodo específico.
# Uso de ElastiCache Cluster Client para Java
El siguiente programa indica cómo utilizar ElastiCache Cluster Client para conectarse a un punto de enlace de configuración del clúster y agregar un elemento de datos a la caché. Con la función Auto Discovery, el programa se conectará a todos los nodos del clúster sin necesidad de ninguna intervención 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");
}
}
```
# Uso del cliente ElastiCache de clústeres para PHP
El siguiente programa muestra cómo utilizar el cliente de ElastiCache clúster para conectarse a un punto final de configuración de clúster y añadir un elemento de datos a la memoria caché. Con la función Auto Discovery, el programa se conectará a todos los nodos del clúster sin necesidad de ninguna intervención adicional.
Para usar el ElastiCache Cluster Client para PHP, primero tendrás que instalarlo en tu EC2 instancia de Amazon. Para obtener más información, consulte [Instalación de ElastiCache Cluster Client 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 un ejemplo de cómo usar el cliente de ElastiCache clúster con TLS activado, consulta Cómo [usar el cifrado en tránsito con PHP y Memcached](in-transit-encryption.md#in-transit-encryption-connect-php-mc).
# Uso de ElastiCache Cluster Client para .NET
**nota**
El cliente de clúster .NET de ElastiCache quedó obsoleto en mayo de 2022.
El cliente .NET para ElastiCache es un programa de código abierto que se encuentra disponible en [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
Las aplicaciones .NET suelen recibir sus configuraciones de los archivos de configuración. A continuación se muestra un archivo de configuración de ejemplo.
```
```
El programa C\$1 indica cómo utilizar ElastiCache Cluster Client para conectarse a un punto de conexión de configuración del clúster y agregar un elemento de datos a la caché. Con la función Auto Discovery, el programa se conectará a todos los nodos del clúster sin necesidad de ninguna intervención 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
```
# Conexión manual a los nodos de caché de Memcached
Si su programa cliente no usa la detección automática, puede conectarse manualmente a cada uno de los nodos de caché de Memcached. Este es el comportamiento predeterminado para los clientes de Memcached.
Puede obtener una lista de nombres anfitriones y números de puerto de los nodos de caché en [AWS Management Console](https://aws.amazon.com/console/). También puede utilizar el AWS CLI`aws elasticache describe-cache-clusters` comando con el `--show-cache-node-info` parámetro.
**Example**
El fragmento de código Java siguiente muestra cómo conectarse a todos los nodos en un clúster de cuatro nodos:
```
...
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**
Si escala o reduce su clúster verticalmente agregando o eliminando nodos, deberá actualizar la lista de nodos en el código del cliente.
# Adición de detección automática a la biblioteca cliente de Memcached
La información de configuración de la detección automática se almacena de forma redundante en cada nodo del clúster de Memcached. Las aplicaciones cliente pueden consultar cualquier nodo de caché y obtener la información de configuración para todos los nodos del clúster.
El modo en que una aplicación realiza esta consulta depende de la versión del motor de caché:
+ Si la versión del motor de caché es la **1.4.14 o superior**, use el comando `config`.
+ Si la versión del motor de caché es **inferior a la 1.4.14**, use el comando `get AmazonElastiCache:cluster`.
Las salidas de estos dos comandos son idénticas y se describen en la sección [Output Format (Formato de salida)](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) siguiente.
## Versión del motor de caché 1.4.14 o superior
Si la versión del motor de caché es la 1.4.14 o superior, use el comando `config`. Este comando ha sido agregado a los protocolos ASCII y binario de Memcached y está implementado en el ElastiCache Cluster Client. ElastiCache Si desea usar la función Auto Discovery con otra biblioteca de cliente, dicha biblioteca deberá ampliarse para ser compatible con el comando `config`.
**nota**
La documentación siguiente pertenece al protocolo ASCII; sin embargo, el comando `config` también admite el código ASCII y binario. Si desea añadir compatibilidad con la detección automática mediante el protocolo binario, consulte el [código fuente 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
**Sintaxis**
`config [sub-command] [key]`
### Opciones
| Name | Description (Descripción) | Obligatorio |
| --- | --- | --- |
| sub-command | Subcomando que se usa para interactuar con un nodo de caché. Para la función Auto Discovery, el subcomando es `get`. | Sí |
| key | Clave en la que se almacena la configuración del clúster. Para la función Auto Discovery, la clave se denomina `cluster`. | Sí |
Para obtener la información de configuración del clúster, use el comando siguiente:
```
config get cluster
```
## Versión del motor de caché 1.4.14 o inferior
Para obtener la información de configuración del clúster, use el comando siguiente:
```
get AmazonElastiCache:cluster
```
**nota**
No manipule la clave «:clusterAmazonElastiCache», ya que aquí es donde reside la información de configuración del clúster. Si sobrescribe esta clave, es posible que el cliente se configure incorrectamente durante un breve período de tiempo (no más de 15 segundos) antes de que actualice la información de configuración de ElastiCache forma automática y correcta.
## Output Format (Formato de salida)
Tanto si usa `config get cluster` o `get AmazonElastiCache:cluster`, la respuesta se compone de dos líneas:
+ Número de versión de la información de configuración. Cada vez que se agrega o elimina un nodo del clúster, el número de versión aumenta un valor.
+ Lista de nodos de caché. Cada nodo de la lista se representa con un grupo *hostname\$1ip-address\$1port* y cada se delimita con un espacio.
Al final de cada línea encontrará un retorno de carro y un carácter de salto de línea (CR \$1 LF). La línea de datos contiene un carácter de salto de línea (LF) y se le agregan el retorno de carro y el carácter de salto de línea (CR \$1 LF). La línea de la versión de configuración termina con el carácter de salto de línea (LF) sin retorno de carro (CR).
A continuación se muestra cómo se representaría un clúster con tres nodos:
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
Cada nodo se muestra con el CNAME y la dirección IP privada. El CNAME siempre estará presente; si la dirección IP privada no está disponible, esta no se mostrará, aunque sí se imprimirán los caracteres de barra vertical "`|`".
**Example**
A continuación se muestra un ejemplo de la carga que se obtiene al consultar la información de configuración:
```
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 segunda línea indica que la información de configuración se ha modificado doce veces hasta el momento.
En la tercera línea, la lista de nodos se muestra por orden alfabético según el nombre de host. Este orden puede ser distinto del que usa actualmente en su aplicación cliente.
# ElastiCache clientes con detección automática
Los programas cliente de clúster pueden identificar todos los nodos del clúster que ejecutan el motor de Memcached y conectarse a ellos automáticamente.
En esta sección se describe la instalación y la configuración de los clientes ElastiCache PHP y .NET para su uso con la detección automática.
**Topics**
+ [Instalación y compilación de clientes de clúster](Appendix.InstallingClients.md)
+ [Configuración de clientes de ElastiCache](ClientConfig.md)
# Instalación y compilación de clientes de clúster
En esta sección se aborda la instalación, la configuración y la compilación de clientes de clúster de detección automática PHP y .NET de Amazon ElastiCache.
**Topics**
+ [Instalación de ElastiCache Cluster Client para .NET](Appendix.DotNETAutoDiscoverySetup.md)
+ [Instalación de ElastiCache Cluster Client para .PHP](Appendix.PHPAutoDiscoverySetup.md)
+ [Compilación del código fuente de ElastiCache Cluster Client para PHP](Appendix.PHPAutoDiscoveryCompile.md)
# Instalación de ElastiCache Cluster Client para .NET
Encontrará el código de ElastiCache Cluster Client para .NET como código abierto en [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
En esta sección se describe cómo instalar, actualizar y eliminar los componentes .NET de ElastiCache Cluster Client en instancias de Amazon EC2. Para obtener más información acerca de la detección automática, consulte [Identificación automática de los nodos en el clúster (Memcached)](AutoDiscovery.md). Para obtener código .NET de muestra para usar el cliente, consulte [Uso de ElastiCache Cluster Client para .NET](AutoDiscovery.Using.ModifyApp.DotNET.md).
**Topics**
+ [Instalación de .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [Descargar ElastiCache Cluster Client para .NET para ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [Instalar ensamblajes de AWS con NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing)
## Instalación de .NET
Debe tener .NET 3.5 o posterior instalado a fin de poder utilizar el SDK .NET de AWS para ElastiCache. Si no dispone de .NET 3.5 o posterior, puede descargar e instalar la versión más reciente desde [http://www.microsoft.com/net](http://www.microsoft.com/net).
## Descargar ElastiCache Cluster Client para .NET para ElastiCache
**A fin de descargar ElastiCache Cluster Client para .NET para ElastiCache**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de ElastiCache en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación, haga clic en **ElastiCache Cluster Client** (Cliente de clúster ElastiCache).
1. En la lista **Download ElastiCache Memcached Cluster Client** (Descargar cliente de clíuster de ElastiCache Memcached), seleccione **.NET** y, a continuación, haga clic en **Download.**
## Instalar ensamblajes de AWS con NuGet
NuGet es un sistema de administración de paquetes de la plataforma .NET. NuGet tiene en cuenta las dependencias de los ensamblajes e instala todos los archivos necesarios de forma automática. Los ensamblajes de NuGet instalados se almacenan con su solución, en lugar de en una ubicación central como, por ejemplo, `Program Files`. De este modo, podrá instalar versiones específicas para una aplicación sin crear problemas de compatibilidad.
### Instalación de NuGet
NuGet puede instalarse desde la Galería de instalación de MSDN. Para ello, consulte [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c). Si usa Visual Studio 2010 o posterior, NuGet se instalará automáticamente.
Puede usar NuGet desde el **Explorador de soluciones** o la **Consola del administrador de paquetes**.
### Uso de NuGet desde el Explorador de soluciones
**Para usar NuGet desde el Explorador de soluciones de Visual Studio 2010**
1. Desde el menú **Herramientas**, seleccione **Administrador de paquetes de biblioteca**.
1. Haga clic en **Consola del administrador de paquetes**.
**Para usar NuGet desde el Explorador de soluciones de Visual Studio 2012 o Visual Studio 2013**
1. Desde el menú **Herramientas**, seleccione **Administrador de paquetes de NuGet**.
1. Haga clic en **Consola del administrador de paquetes**.
Desde la línea de comandos, puede instalar los ensamblajes mediante `Install-Package`, tal y como se muestra a continuación.
```
Install-Package Amazon.ElastiCacheCluster
```
Para ver una página con todos los paquetes disponibles a través de NuGet, como los ensamblajes AWSSDK y AWS.Extensions, consulte el sitio web de NuGet en [http://www.nuget.org](http://www.nuget.org). La página de cada paquete incluye una línea de comandos de muestra para la instalación del paquete mediante la consola, así como una lista de las versiones anteriores del paquete que están disponibles a través de NuGet.
Para obtener más información acerca de los comandos de la **Consola del administrador de paquetes**, 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).
# Instalación de ElastiCache Cluster Client para .PHP
En esta sección se describe cómo instalar, actualizar y eliminar los componentes PHP de ElastiCache Cluster Client en instancias de Amazon EC2. Para obtener más información acerca de la detección automática, consulte [Identificación automática de los nodos en el clúster (Memcached)](AutoDiscovery.md). Para obtener código PHP de muestra para usar el cliente, consulte [Uso del cliente ElastiCache de clústeres para PHP](AutoDiscovery.Using.ModifyApp.PHP.md).
**Topics**
+ [Descarga del paquete de instalación](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [Para los usuarios que ya tengan instalada la extensión *php-memcached*](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [Pasos de instalación para usuarios nuevos](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [Eliminación de Cluster Client para PHP](Appendix.PHPAutoDiscoverySetup.Removing.md)
# Descarga del paquete de instalación
A fin de garantizar que utiliza la versión correcta de ElastiCache Cluster Client para PHP, tendrá que saber qué versión de PHP tiene instalada en su instancia de Amazon EC2. También necesitará saber si su instancia de Amazon EC2 ejecuta una versión de Linux de 64 o 32 bits.
**Para determinar la versión de PHP que tiene instalada en su instancia de Amazon EC2**
+ En el símbolo del sistema, ejecute el siguiente comando:
```
php -v
```
La versión de PHP se mostrará en la salida, como en el ejemplo siguiente:
```
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**
Si sus versiones de PHP y de Memcached son incompatibles, se mostrará un mensaje similar al siguiente:
```
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
```
Si esto ocurre, deberá compilar el módulo desde el código fuente. Para obtener más información, consulte [Compilación del código fuente de ElastiCache Cluster Client para PHP](Appendix.PHPAutoDiscoveryCompile.md).
**Para determinar su arquitectura de AMI de Amazon EC2 (de 64 o 32 bits)**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En la lista de **Instances** (Instancias), haga clic en su instancia de Amazon EC2.
1. En la pestaña **Description**, busque el campo **AMI:**. Una instancia de 64 bits debe tener `x86_64` como parte de la descripción, mientras que la instancia de 32 bits deberá tener el valor `i386` o `i686` en este campo.
Ahora ya puede descargar ElastiCache Cluster Client.
**A fin de descargar ElastiCache Cluster Client para PHP**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de ElastiCache en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En la consola de ElastiCache, elija **ElastiCache Cluster Client**.
1. Desde la lista de **Download ElastiCache Memcached Cluster Client** (Descargar ElastiCache Cluster Client para Memcached), elija el ElastiCache Cluster Client que coincida con su versión de PHP y su arquitectura AMI. A continuación, elija el botón **Download** (Descargar).
## Para los usuarios que ya tengan instalada la extensión *php-memcached*
**Para actualizar la instalación de `php-memcached`**
1. Elimine la instalación anterior de la extensión de Memcached para PHP tal y como se describe en el tema [Eliminación de Cluster Client para PHP](Appendix.PHPAutoDiscoverySetup.Removing.md).
1. Instale la nueva extensión `php-memcached` de ElastiCache tal y como se ha descrito anteriormente en [Pasos de instalación para usuarios nuevos](Appendix.PHPAutoDiscoverySetup.Installing.md).
# Pasos de instalación para usuarios nuevos
**Topics**
+ [Instalación de PHP 7.x. para usuarios nuevos](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [Instalación de PHP 5.x para usuarios nuevos](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## Instalación de PHP 7.x. para usuarios nuevos
**Topics**
+ [Instalación de PHP 7 en la AMI de Ubuntu Server 14.04 LTS (64 y 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [Para instalar PHP 7 AMI de Amazon Linux 201609](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [Para instalar PHP 7 en una AMI de SUSE Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### Instalación de PHP 7 en la AMI de Ubuntu Server 14.04 LTS (64 y 32 bits)
1. Lance una instancia nueva desde la AMI.
1. Ejecute los comandos siguientes:
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. Instale PHP 7.
```
sudo yum install php70
```
1. Descargue Amazon ElastiCache Cluster Client.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. EXTRACT `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Con permisos raíz, copie el archivo de artefacto extraído `amazon-elasticache-cluster-client.so` a `/usr/lib/php/20151012`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. Inserte la línea `extension=amazon-elasticache-cluster-client.so` en el archivo `/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 o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar PHP 7 AMI de Amazon Linux 201609
1. Lance una instancia nueva desde la AMI.
1. Ejecuta el siguiente comando:
```
sudo yum install gcc-c++
```
1. Instale PHP 7.
```
sudo yum install php70
```
1. Descargue Amazon ElastiCache Cluster Client.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. EXTRACT `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Con permisos raíz, copie el archivo de artefacto extraído `amazon-elasticache-cluster-client.so` a `/usr/lib64/php/7.0/modules/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. Creación del archivo `50-memcached.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar PHP 7 en una AMI de SUSE Linux
1. Lance una instancia nueva desde la AMI.
1. Ejecuta el siguiente comando:
```
sudo zypper install gcc
```
1. Instale PHP 7.
```
sudo yum install php70
```
1. Descargue Amazon ElastiCache Cluster Client.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. EXTRACT `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Con permisos raíz, copie el archivo de artefacto extraído `amazon-elasticache-cluster-client.so` a `/usr/lib64/php7/extensions/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. Inserte la línea `extension=amazon-elasticache-cluster-client.so` en el archivo `/etc/php7/cli/php.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
## Instalación de PHP 5.x para usuarios nuevos
**Topics**
+ [Para instalar PHP 5 en una AMI de Amazon Linux 2014.03 (64 y 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [Para instalar PHP 5 en una AMI de Red Hat Enterprise Linux 7.0 (64 y 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [Para instalar PHP 5 en la AMI de Ubuntu Server 14.04 LTS (64 y 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [A fin de instalar PHP 5 para la AMI de SUSE Linux Enterprise Server 11 (64 o 32 bits)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [Otras distribuciones de Linux](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### Para instalar PHP 5 en una AMI de Amazon Linux 2014.03 (64 y 32 bits)
1. Lance una instancia de Amazon Linux (de 64 o 32 bits) e inicie sesión en ella.
1. Instale las dependencias de PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Descargue el paquete `php-memcached` correcto para su instancia de Amazon EC2 y su versión de PHP. Para obtener más información, consulte [Descarga del paquete de instalación](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar `php-memcached`. El URI debe ser la ruta de descarga del paquete de instalación:
```
sudo pecl install
```
A continuación se muestra un ejemplo de comando de instalación para PHP 5.4, Linux de 64 bits. En este ejemplo, reemplace *X.Y.Z* con el número de versión real:
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**nota**
Asegúrese de que utiliza la versión más reciente del artefacto de instalación.
1. Con el permiso root/sudo, agregue un nuevo archivo denominado `memcached.ini` en el directorio `/etc/php.d` e inserte “extension=amazon-elasticache-cluster-client.so” en el archivo:
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar PHP 5 en una AMI de Red Hat Enterprise Linux 7.0 (64 y 32 bits)
1. Lance una instancia de Red Hat Enterprise Linux (de 64 o 32 bits) e inicie sesión en ella.
1. Instale las dependencias de PHP:
```
sudo yum install gcc-c++ php php-pear
```
1. Descargue el paquete `php-memcached` correcto para su instancia de Amazon EC2 y su versión de PHP. Para obtener más información, consulte [Descarga del paquete de instalación](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar `php-memcached`. El URI debe ser la ruta de descarga del paquete de instalación:
```
sudo pecl install
```
1. Con el permiso root/sudo, añada un nuevo archivo denominado `memcached.ini` en el directorio `/etc/php.d` e inserte `extension=amazon-elasticache-cluster-client.so` en el archivo.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
### Para instalar PHP 5 en la AMI de Ubuntu Server 14.04 LTS (64 y 32 bits)
1. Lance una instancia de Ubuntu Linux (de 64 o 32 bits) e inicie sesión en ella.
1. Instale las dependencias de PHP:
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. Descargue el paquete `php-memcached` correcto para su instancia de Amazon EC2 y su versión de PHP. Para obtener más información, consulte [Descarga del paquete de instalación](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar `php-memcached`. El URI debe ser la ruta de descarga del paquete de instalación.
```
sudo pecl install
```
**nota**
Este paso de instalación instala el artefacto de compilación `amazon-elasticache-cluster-client.so` en el directorio `/usr/lib/php5/20121212*`. Compruebe la ruta completa del artefacto de compilación, ya que la necesitará en el siguiente paso.
Si el comando anterior no funciona, deberá extraer manualmente el artefacto del cliente de PHP `amazon-elasticache-cluster-client.so` del archivo `*.tgz` descargado y copiarlo en el directorio `/usr/lib/php5/20121212*`.
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. Con el permiso root/sudo, agregue un nuevo archivo denominado `memcached.ini` en el directorio `/etc/php5/cli/conf.d` e inserte “extension=” en el archivo.
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
### A fin de instalar PHP 5 para la AMI de SUSE Linux Enterprise Server 11 (64 o 32 bits)
1. Lance una instancia de SUSE Linux (de 64 o 32 bits) e inicie sesión en ella.
1. Instale las dependencias de PHP:
```
sudo zypper install gcc php53-devel
```
1. Descargue el paquete `php-memcached` correcto para su instancia de Amazon EC2 y su versión de PHP. Para obtener más información, consulte [Descarga del paquete de instalación](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Instalar `php-memcached`. El URI debe ser la ruta de descarga del paquete de instalación.
```
sudo pecl install
```
1. Con el permiso root/sudo, añada un nuevo archivo denominado `memcached.ini` en el directorio `/etc/php5/conf.d` e inserte **extension=`amazon-elasticache-cluster-client.so`** en el archivo.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
**nota**
Si el paso 5 no funciona en ninguna de las plataformas anteriores, compruebe la ruta de instalación de `amazon-elasticache-cluster-client.so`. Además, especifique la ruta completa del archivo binario en la extensión. Compruebe además que el PHP en uso es una versión compatible. Se admiten las versiones de la 5.3 a la 5.5.
### Otras distribuciones de Linux
En algunos sistemas, especialmente en CentOS7 y Red Hat Enterprise Linux (RHEL) 7.1, `libsasl2.so.3` ha reemplazado a `libsasl2.so.2`. En estos sistemas, al cargar el cliente del clúster de ElastiCache, este intenta buscar y cargar , pero obtiene un error `libsasl2.so.2`. Para solucionar este problema, cree un enlace a simbólico a `libsasl2.so.3` para que cuando el cliente intente cargar libsasl2.so.2, se redirija a `libsasl2.so.3`. El código siguiente crea este enlace simbólico.
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# Eliminación de Cluster Client para PHP
**Topics**
+ [Eliminación de una versión anterior a PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [Eliminación de una versión anterior a PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## Eliminación de una versión anterior a PHP 7
**Para eliminar una versión anterior a PHP 7**
1. Elimine el archivo `amazon-elasticache-cluster-client.so` del directorio de biblioteca PHP correspondiente, tal como se indica en las instrucciones de instalación. Consulte la sección correspondiente a su instalación en [Para los usuarios que ya tengan instalada la extensión *php-memcached*](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting).
1. Elimine la línea `extension=amazon-elasticache-cluster-client.so` del archivo `php.ini`.
1. Inicie o reinicie su servidor de Apache.
```
sudo /etc/init.d/httpd start
```
## Eliminación de una versión anterior a PHP 5
**Para eliminar una versión anterior a PHP 5**
1. Elimine la extensión `php-memcached`:
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. Elimine el archivo `memcached.ini` que se añadió en el directorio correspondiente tal como se indica en los pasos de instalación anteriores.
# Compilación del código fuente de ElastiCache Cluster Client para PHP
En esta sección se explica cómo obtener y compilar el código fuente de ElastiCache Cluster Client para PHP.
Existen dos paquetes que debe extraer de GitHub y compilar; [aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) y [aws-elasticache-cluster-client-memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php).
**Topics**
+ [Compilación de la biblioteca libmemcached](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [Compilación del cliente de detección automática de ElastiCache for Memcached para PHP](#Appendix.PHPAutoDiscoveryCompile.Client)
## Compilación de la biblioteca libmemcached
**Para compilar la biblioteca aws-elasticache-cluster-client-libmemcached**
1. Lance una instancia de Amazon EC2.
1. Instale las dependencias de la biblioteca.
+ En AMI de Amazon Linux 201509
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ En AMI de Ubuntu 14.04
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. Extraiga el repositorio y compile el 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)
```
## Compilación del cliente de detección automática de ElastiCache for Memcached para PHP
En las secciones siguientes se describe cómo compilar el cliente de detección automática de ElastiCache for Memcached.
**Topics**
+ [Compilación del cliente de ElastiCache for Memcached para PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [Compilación del cliente de ElastiCache para Memcached para PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5)
### Compilación del cliente de ElastiCache for Memcached para PHP 7
Ejecute el siguiente conjunto de comandos en el directorio 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**
Puede vincular estáticamente la biblioteca de libmemcached en el binario de PHP para poder transferirla entre varias plataformas de Linux. Para ello, ejecute el siguiente comando antes de `make`:
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### Compilación del cliente de ElastiCache para Memcached para PHP 5
Compile el `aws-elasticache-cluster-client-memcached-for-php` ejecutando los siguientes comandos en la carpeta `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
```
# Configuración de clientes de ElastiCache
Un clúster de ElastiCache utiliza un protocolo compatible con Valkey, Memcached y Redis OSS. El código, las aplicaciones y las herramientas más populares que se usan hoy en día con el entorno existente funcionarán a la perfección con este servicio.
En esta sección se explican las consideraciones específicas para la conexión a los nodos de caché en ElastiCache.
**Topics**
+ [Comandos restringidos](ClientConfig.RestrictedCommands.md)
+ [Búsqueda de números de puertos y puntos de enlace de los nodos](ClientConfig.FindingEndpointsAndPorts.md)
+ [Conexión para utilizar la detección automática](ClientConfig.AutoDiscovery.md)
+ [Conexión a nodos en un clúster de Valkey o Redis OSS](ClientConfig.ReplicationGroup.md)
+ [Nombres de DNS e IP subyacentes](ClientConfig.DNS.md)
# Comandos restringidos
Para ofrecer una experiencia de servicio gestionado, ElastiCache restringe el acceso a determinados comandos específicos del motor de caché que requieren privilegios avanzados. A continuación se detallan los comandos que no están disponibles para los clústeres que ejecutan Redis OSS:
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# Búsqueda de números de puertos y puntos de enlace de los nodos
Para conectarse a un nodo de caché, su aplicación necesita conocer el punto de enlace y el número de puerto de dicho nodo.
## Búsqueda de números de puertos y puntos de enlace de los nodos (consola)
**Para determinar los números de puertos y puntos de enlace de nodos**
1. Inicie sesión en la [consola de administración de Amazon ElastiCache](https://aws.amazon.com/elasticache) y elija el motor que se ejecuta en el clúster.
Se mostrará una lista de todos los clústeres que ejecutan el motor elegido.
1. Continúe con el procedimiento que se describe a continuación en función del motor y la configuración que esté ejecutando.
1. Elija el nombre del clúster que le interese.
1. Localice las columnas **Port** y **Endpoint** del nodo que le interese.
## Búsqueda de números de puertos y puntos de enlace de nodos de caché (AWS CLI)
Para determinar los números de puertos y puntos de enlace de nodos de caché, use el comando `describe-cache-clusters` con el parámetro `--show-cache-node-info`.
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
Los números de puertos y los nombres DNS completos se encuentran en la sección de punto de enlace de la salida.
## Búsqueda de números de puertos y puntos de enlace de nodos de caché (API de ElastiCache)
Para determinar los números de puertos y puntos de enlace de nodos de caché, use la acción `DescribeCacheClusters` con el 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
```
# Conexión para utilizar la detección automática
Si sus aplicaciones usan la función de detección automática, solo necesita conocer el punto de enlace del clúster, más que los puntos de enlace individuales de cada nodo de caché. Para obtener más información, consulte [Identificación automática de los nodos en el clúster (Memcached)](AutoDiscovery.md).
**nota**
En este momento, la función de detección automática solo está disponible para los clústeres que ejecutan Memcached.
# Conexión a nodos en un clúster de Valkey o Redis OSS
**nota**
En este momento, los clústeres (API/CLI: grupos de replicación) que admiten la replicación y las réplicas de lectura solo son compatibles con los clústeres que ejecutan Valkey o Redis OSS.
Para los clústeres, ElastiCache proporciona las interfaces de la API, la CLI y la consola a fin de obtener la información de conexión de los nodos individuales.
Para la actividad de solo lectura, las aplicaciones pueden conectarse a cualquier nodo del clúster. Sin embargo, para la actividad de escritura, recomendamos que sus aplicaciones se conecten al punto de conexión principal (Valkey o Redis OSS [modo de clúster deshabilitado]) o al punto de conexión de configuración (Valkey o Redis OSS [modo de clúster habilitado]) del clúster en lugar de conectarse directamente a un nodo. De este modo, se asegurará de que sus aplicaciones siempre puedan encontrar el nodo correcto, incluso si decide volver a configurar su clúster promocionando una réplica de lectura a la función principal.
## Conexión con los clústeres de un grupo de reproducción (consola)
**Para determinar los números de puertos y puntos de enlace**
+ Consulte el tema, [Búsqueda de puntos de conexión de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) (consola)](Endpoints.md#Endpoints.Find.Redis).
## Conexión con los clústeres de un grupo de reproducción (AWS CLI)
**Para determinar los números de puertos y los puntos de enlace de los nodos de caché**
Use el comando `describe-replication-groups` con el nombre de su grupo de reproducción:
```
aws elasticache describe-replication-groups redis2x2
```
Este comando debería producir un resultado similar al siguiente:
```
{
"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": {}
}
]
}
```
## Conexión con los clústeres de un grupo de reproducción (API de ElastiCache)
**Para determinar los números de puertos y los puntos de enlace de los nodos de caché**
Llame a `DescribeReplicationGroups` con el siguiente parámetro:
`ReplicationGroupId` = nombre de su grupo de reproducción.
**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=
```
# Nombres de DNS e IP subyacentes
Los clientes conservan una lista de servidores con las direcciones y los puertos de los servidores donde se almacenan los datos de la caché. Cuando se utiliza ElastiCache, la API DescribeCacheClusters (o la utilidad de la línea de comandos describe-cache-clusters) devuelve una entrada de DNS completa y un número de puerto que podrá utilizar para la lista de servidores.
**importante**
Es importante que las aplicaciones cliente estén configuradas para resolver los nombres de DNS con frecuencia de los nodos de caché cuando intenten conectarse a un punto de enlace de nodo de caché.
ElastiCache garantiza que el nombre de DNS de los nodos de caché no se modifiquen al recuperar los nodos de caché en caso de error.
De forma predeterminada, la mayoría de las bibliotecas de cliente admiten las conexiones de nodo de caché persistentes Se recomienda utilizar conexiones de nodo de caché persistentes cuando utilice ElastiCache. El almacenamiento en caché de DNS del lado del cliente puede producirse en varios lugares, incluidas las bibliotecas de cliente, el tiempo de ejecución del lenguaje o el sistema operativo del cliente. Debe revisar la configuración de su aplicación en cada capa para garantizar que las direcciones IP de sus nodos de caché se resuelven con frecuencia.