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.
# Administración de clústeres en ElastiCache
Un *clúster* es una colección de uno o varios nodos de caché que, en conjunto, ejecutan una instancia de software del motor de Valkey, Memcached o Redis OSS. Al crear un clúster, debe especificar el motor y la versión que se va a utilizar en todos los nodos.
**Clústeres de Valkey y Redis OSS**
En el siguiente diagrama, se ilustra un clúster típico de Valkey o Redis OSS. Estos clústeres pueden contener un solo nodo o hasta seis nodos dentro de una partición (API/CLI: grupo de nodos). Los clústeres de Valkey o Redis OSS con un solo nodo (modo de clúster deshabilitado) no tienen particiones, mientras que los clústeres de Valkey o Redis OSS (modo de clúster deshabilitado) con varios nodos tienen una única partición. Los clústeres de Valkey o Redis OSS (modo de clúster habilitado) pueden tener hasta 500 particiones, con sus datos divididos entre las particiones. El límite de nodos o particiones se puede aumentar a un máximo de 500 por clúster si la versión del motor es Valkey 7.2 y posteriores o Redis OSS 5.0.6 y posteriores. Por ejemplo, puede elegir configurar un clúster de 500 nodos que oscila entre 83 particiones (uno primario y 5 réplicas por partición) y 500 particiones (único primario y sin réplicas). Asegúrese de que hay suficientes direcciones IP disponibles para acomodar el aumento. Algunos problemas comunes incluyen que las subredes del grupo de subredes tienen un rango CIDR demasiado pequeño o que otros clústeres comparten y utilizan considerablemente las subredes. Para obtener más información, consulte [Creación de un grupo de subredes](SubnetGroups.Creating.md). Para las versiones inferiores a 5.0.6, el límite es de 250 por clúster.
Para solicitar un aumento del límite, consulte [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) y elija el tipo de límite **Nodes per cluster per instance type** (Nodos por clúster por tipo de instancias).
Si tiene varios nodos en una partición de Valkey o Redis OSS, uno de los nodos será un nodo principal de lectura/escritura. Todos los demás nodos de la partición son réplicas de solo lectura.
Los clústeres de Valkey o Redis OSS típicos son similares a los que se muestran a continuación.
![\[Imagen: clústeres de Valkey o Redis OSS típicos\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Redis.png)
**Clústeres de Memcached**
Los clústeres de Memcached típicos son similares a los que se muestran a continuación. Los clústeres de Memcached contienen entre 1 y 60 nodos entre los que se particionan los datos horizontalmente.
![\[Imagen: clúster típico de Memcached\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
**Operaciones de ElastiCache para Valkey, Memcached y Redis OSS**
La mayoría de las operaciones de ElastiCache se realizan en el clúster. Puede configurar un clúster con un número específico de nodos y un grupo de parámetros que controle las propiedades de cada nodo. Todos los nodos de un clúster están diseñados para ser del mismo tipo y tener los mismos valores de configuración de parámetros y grupo de seguridad.
Cada clúster debe tener un identificador de clúster. El identificador del clúster es un nombre suministrado por el cliente para el clúster. Este identificador especifica un clúster determinado al interactuar con los comandos de la AWS CLI y la API de ElastiCache. El identificador del clúster debe ser único para ese cliente en una región de AWS.
ElastiCache admite varias versiones del motor. A menos que tenga motivos específicos, recomendamos que utilice la versión más reciente.
Los clústeres de ElastiCache se han diseñado para que se tenga acceso a ellos mediante una instancia de Amazon EC2. Si el clúster se lanza en una nube virtual privada (VPC) en función del servicio de Amazon VPC, se puede acceder a él desde fuera de AWS. Para obtener más información, consulte [Acceder a ElastiCache los recursos desde el exterior AWS](accessing-elasticache.md#access-from-outside-aws).
Para obtener una lista de las versiones compatibles, consulte [Motores y versiones compatibles](VersionManagement.md#supported-engine-versions), [Versiones compatibles del motor de Redis OSS](engine-versions.md#supported-engine-versions.redis) y [Compatible con las ElastiCache versiones de Memcached](engine-versions.md#supported-engine-versions-mc).
# Elegir un tipo de red en ElastiCache
ElastiCache es compatible con las versiones 4 y 6 (IPv4 y IPv6) del Protocolo de Internet, lo que le permite configurar el clúster para que acepte:
+ solo IPv4 conexiones,
+ solo IPv6 conexiones,
+ ambos IPv4 y IPv6 conexiones (doble pila)
IPv6 [es compatible con las cargas de trabajo que utilizan Valkey 7.2 y versiones posteriores, o Redis OSS 6.2 y versiones posteriores, en todas las instancias integradas en el sistema Nitro.](https://aws.amazon.com/ec2/nitro/) No hay cargos adicionales por acceder a más de. ElastiCache IPv6
**nota**
No se admite la migración de clústeres creados antes de la disponibilidad de IPV6 /dual-stack. Tampoco se admite el cambio entre tipos de red en los clústeres recién creados.
IPv6 [es compatible con las cargas de trabajo que utilizan Memcached a partir de la versión 1.6.6 en adelante en todas las instancias integradas en el sistema Nitro.](https://aws.amazon.com/ec2/nitro/) No hay cargos adicionales por acceder a más de. ElastiCache IPv6
## Configuración de subredes para el tipo de red
Si crea un clúster en una Amazon VPC, debe especificar un grupo de subredes. ElastiCache usa ese grupo de subredes para elegir una subred y direcciones IP dentro de esa subred para asociarlas a sus nodos. ElastiCache Los clústeres requieren una subred de doble pila con ambas IPv6 direcciones asignadas para funcionar en el modo de doble pila IPv4 y una IPv6 subred «solo» para funcionar como «solo». IPv6
## Usar doble pila
Cuando se utiliza ElastiCache para Redis OSS en modo clúster activado, desde el punto de vista de una aplicación, conectarse a todos los nodos del clúster a través del punto final de configuración no es diferente a conectarse directamente a un nodo de caché individual. Para lograr esto, un cliente que tiene en cuenta los clústeres debe interactuar en un proceso de detección de clústeres y solicitar la información de configuración de todos los nodos. El protocolo de detección de Redis solo admite una IP por nodo.
Cuando creas un clúster con ElastiCache Memcache y eliges una pila doble como tipo de red, tendrás que designar un tipo de detección de IP, ya sea o no. IPv4 IPv6 ElastiCache utilizará de forma predeterminada el tipo de red y la detección de IP IPv6, pero eso se puede cambiar. Si utiliza la detección automática, solo las direcciones IP del tipo de IP elegido se devolverán al cliente de Memcached. Para obtener más información, consulte [Identificación automática de los nodos en el clúster (Memcached)](AutoDiscovery.md).
Para mantener la compatibilidad con versiones anteriores de todos los clientes existentes, se ha introducido la detección de IP, que permite seleccionar el tipo de IP (es decir, IPv4 o IPv6) que se va a anunciar en el protocolo de detección. Si bien esto limita el descubrimiento automático a un solo tipo de IP, la doble pila sigue siendo beneficiosa para las cargas de trabajo habilitadas para el modo de clúster, ya que permite migraciones (o retrocesos) de un tipo de IP IPv4 a un tipo de IP de IPv6 descubrimiento sin tiempo de inactividad.
## Clústeres de doble pila compatibles con TLS ElastiCache
Cuando el TLS está habilitado para ElastiCache los clústeres, las funciones de detección de clústeres`cluster slots`, como`cluster shards`, y `cluster nodes` con Valkey o Redis OSS y Memcached devuelven los nombres de `config get cluster` host en lugar de. IPs A continuación, los nombres de host se utilizan en lugar de utilizarse para conectarse IPs al clúster y realizar un protocolo de enlace TLS ElastiCache . Esto significa que los clientes no se verán afectados por el parámetro de detección de IP. *En el caso de los clústeres habilitados para TLS, el parámetro de detección de IP no tiene ningún efecto en el protocolo IP preferido.* En cambio, el protocolo IP utilizado se determinará según el protocolo IP que prefiera el cliente al resolver los nombres de host de DNS.
Para ver ejemplos sobre cómo configurar una preferencia de protocolo IP al resolver nombres de host DNS, consulte [Clústeres de ElastiCache de doble pila compatibles con TLS](BestPractices.md#network-type-configuring-tls-enabled-dual-stack).
## Uso del Consola de administración de AWS(OSS de Valkey y Redis)
Al crear un clúster mediante la Consola de administración de AWS opción **Conectividad**, elija un tipo de red **IPv4**, **IPv6**ya sea una **pila doble**. Si va a crear un clúster OSS (modo de clúster habilitado) de Valkey o Redis y elige doble pila, debe seleccionar un **tipo de IP de descubrimiento**, ya sea o IPv6 . IPv4
Para obtener más información, consulte [Creación de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) o [Creación un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) (consola)](Clusters.Create.md#Clusters.Create.CON.Redis).
Al crear un grupo de replicación mediante Consola de administración de AWS, elija un tipo de red **IPv4**, **IPv6**ya sea una pila **doble**. Si elige doble pila, debe seleccionar un **tipo de IP de descubrimiento**, ya sea IPv6 o IPv4.
Para obtener más información, consulte [Creación de un grupo de replicación de Valkey o Redis OSS (modo de clúster deshabilitado) desde cero](Replication.CreatingReplGroup.NoExistingCluster.Classic.md) o [Creación de un grupo de replicación en Valkey o Redis OSS (modo de clúster habilitado) desde cero](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md).
## Usando el Consola de administración de AWS(Memcached)
Al crear un clúster mediante la Consola de administración de AWS opción **Conectividad**, elija un tipo de red **IPv4**, **IPv6**ya sea una **pila doble**. Si elige una pila doble, debe seleccionar un **tipo de IP de detección**, ya sea IPv6 o IPv4.
Para obtener más información, consulte [Creación de un clúster de Memcached (consola)](Clusters.Create-mc.md#Clusters.Create.CON.Memcached).
## Uso de la CLI con Valkey, Memcached o Redis OSS.
**Redis OSS**
Al crear un clúster con Valkey o Redis OSS mediante la CLI, utilice el [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)comando y especifique los parámetros `NetworkType` y`IPDiscovery`:
Para Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine redis \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine redis ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Al crear un grupo de replicación con el modo de clúster desactivado mediante la CLI, utilice el [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)comando y especifique los `IPDiscovery` parámetros `NetworkType` y:
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01 \
--network-type dual_stack \
--ip-discovery ipv4
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Al crear un grupo de replicación con el modo de clúster habilitado y utilizarlo IPv4 para la detección de IP mediante la CLI, utilice el [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)comando y especifique los `IPDiscovery` parámetros `NetworkType` y:
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv4 \
--region us-east-1
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv4 ^
--region us-east-1
```
Al crear un grupo de replicación con el modo de clúster habilitado y utilizarlo IPv6 para la detección de IP mediante la CLI, utilice el [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)comando y especifique los `IPDiscovery` parámetros `NetworkType` y:
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv6 \
--region us-east-1
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv6 ^
--region us-east-1
```
**Memcached**
Al crear un clúster con Memcached mediante la CLI, se utiliza el [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)comando y se especifican los parámetros `NetworkType` y`IPDiscovery`:
Para Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine memcached \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine memcached ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
# 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.
# Organización de datos en niveles en ElastiCache
Los clústeres de ElastiCache para Valkey o Redis OSS que componen un grupo de replicación y utilizan un tipo de nodo de la familia r6gd tienen sus datos organizados en niveles entre la memoria y el almacenamiento SSD local (unidades de estado sólido). La organización de datos en niveles proporciona una nueva opción de precio-rendimiento para las cargas de trabajo de Valkey o Redis OSS mediante el uso de unidades de estado sólido (SSD) de menor costo en cada nodo de clúster, además de almacenar datos en la memoria. Es ideal para cargas de trabajo que acceden regularmente hasta un 20 por ciento de su conjunto de datos general y para aplicaciones que pueden tolerar latencia adicional al acceder a los datos en SSD.
En clústeres con organización de datos en niveles de ElastiCache, ElastiCache supervisa la última hora de acceso de cada elemento que almacena. Cuando la memoria disponible (DRAM) se consume por completo, ElastiCache utiliza un algoritmo menos usado recientemente (LRU) para mover automáticamente los elementos a los que se accede con poca frecuencia de la memoria a la SSD. Cuando se accede posteriormente a los datos de SSD, ElastiCache los mueve de nuevo a la memoria de forma automática y asincrónica antes de procesar la solicitud. Si tiene una carga de trabajo que solo accede a un subconjunto de sus datos regularmente, la organización de datos en niveles es una forma óptima de escalar su capacidad de forma rentable.
Tenga en cuenta que cuando se utiliza la organización de datos en niveles, las propias claves siempre permanecen en la memoria, mientras que la LRU rige la ubicación de los valores en la memoria frente al disco. En general, recomendamos que los tamaños de las claves sean más pequeños que los tamaños de los valores al usar la organización de datos en niveles.
La organización de datos en niveles está diseñada para tener un impacto mínimo en el rendimiento de las cargas de trabajo Por ejemplo, suponiendo valores de cadena de 500 bytes, puede esperar 300 microsegundos adicionales de latencia en promedio para las solicitudes de datos almacenados en SSD en comparación con las solicitudes de datos de la memoria.
Con el mayor tamaño de nodo de organización de datos en niveles (cache.r6gd.16xlarge), puede almacenar hasta 1 petabyte en un solo clúster de 500 nodos (500 TB cuando se utiliza 1 réplica de lectura). La organización de datos en niveles es compatible con todos los comandos y estructuras de datos de Valkey o Redis OSS compatibles con ElastiCache. No es necesario cambiar el lado del cliente para usar esta característica.
**Topics**
+ [Prácticas recomendadas](#data-tiering-best-practices)
+ [Limitaciones](#data-tiering-prerequisites)
+ [Precios](#data-tiering-pricing)
+ [Monitorización](#data-tiering-monitoring)
+ [Uso de la organización de datos en niveles](#data-tiering-enabling)
+ [Restauración de datos desde copias de seguridad en clústeres con la organización de datos en niveles](#data-tiering-enabling-snapshots)
## Prácticas recomendadas
Recomendamos que siga las siguientes prácticas recomendadas:
+ La organización de datos en niveles es ideal para cargas de trabajo que acceden regularmente hasta un 20 % de su conjunto de datos general y para aplicaciones que pueden tolerar latencia adicional al acceder a los datos en SSD.
+ Al utilizar la capacidad de SSD disponible en nodos con niveles de datos, recomendamos que el tamaño del valor sea mayor que el tamaño de la clave. Cuando se mueven elementos entre DRAM y SSD, las claves siempre permanecerán en la memoria y solo los valores se moverán al nivel de SSD.
## Limitaciones
La organización de datos en niveles tiene las siguientes restricciones:
+ Solo puede utilizar la organización de datos en niveles en clústeres que forman parte de un grupo de replicación.
+ El tipo de nodo que utilice debe pertenecer a la familia r6gd, que está disponible en las siguientes regiones: `us-east-2`, `us-east-1`, `us-west-2`, `us-west-1`, `eu-west-1`, `eu-central-1`, `eu-north-1`, `eu-west-3`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` y `sa-east-1`.
+ Debe utilizar un motor que sea Valkey 7.2 o una versión posterior, o Redis OSS 6.2 o una versión posterior.
+ No se puede restaurar una copia de seguridad de un clúster r6gd en otro clúster a menos que utilice también r6gd.
+ No se puede exportar una copia de seguridad a Amazon S3 para clústeres de organización de datos en niveles.
+ La migración en línea no se admite para clústeres que se ejecutan en el tipo de nodo r6gd.
+ No se admite el escalado desde un clúster de organización de datos en niveles (por ejemplo, un clúster que utiliza un tipo de nodo r6gd) a un clúster que no utiliza la organización de datos en niveles (por ejemplo, un clúster que utiliza un tipo de nodo r6g). Para obtener más información, consulte [Escalado ElastiCache](Scaling.md).
+ El escalado automático se admite en los clústeres que utilizan la organización de datos en niveles para Valkey 7.2 y versiones posteriores y Redis OSS 7.0.7 y versiones posteriores. Para obtener más información, consulte [Clústeres de escalado automático de Valkey y Redis OSS](AutoScaling.md)
+ La organización de datos en niveles solo admite las políticas maxmemory `volatile-lru`, `allkeys-lru`, `volatile-lfu`, `allkeys-lfu` y `noeviction`.
+ Valkey 7.2 y versiones posteriores y Redis OSS 7.0.7 y versiones posteriores admiten el guardado sin ramificaciones. Para obtener más información, consulte [Cómo se implementan la sincronización y la copia de seguridad](Replication.Redis.Versions.md).
+ Los artículos de más de 128 MiB no se mueven a SSD.
+ A partir de Valkey 8.1 y versiones posteriores, un elemento cuyo tamaño de clave y valor sea inferior a 40 bytes no se moverá al SSD.
## Precios
Los nodos R6gd tienen 4,8 veces más capacidad total (memoria \$1 SSD) y pueden ayudarle a ahorrar más del 60 por ciento cuando se ejecuta con la máxima utilización en comparación con los nodos R6g (solo memoria). Para obtener más información, consulte [Precios de ElastiCache](https://aws.amazon.com/elasticache/pricing/).
## Monitorización
ElastiCache ofrece métricas diseñadas específicamente para supervisar los clústeres de rendimiento que utilizan la organización de datos en niveles. Para supervisar la proporción de elementos en DRAM en comparación con SSD, puede utilizar la métrica `CurrItems` en [Métricas de Valkey y Redis OSS](CacheMetrics.Redis.md). Puede calcular el porcentaje de la siguiente manera: *(CurrItems con dimensión: Nivel = Memoria \$1 100)/(CurrItems sin filtro de dimensión)*.
Si la política de expulsión configurada lo permite, ElastiCache empezará a expulsar elementos cuando el porcentaje de estos en la memoria disminuya por debajo del 5 %. En los nodos configurados con una política de no expulsión, en las operaciones de escritura aparecerá un error de memoria insuficiente.
Se sigue recomendando que considere la posibilidad de escalar horizontalmente los clústeres con el modo de clúster habilitado o de escalar verticalmente los clústeres con el modo de clúster deshabilitado cuando el porcentaje de elementos en memoria disminuya por debajo del 5 %. Para obtener más información sobre el escalado, consulte [Escalado de clústeres de Valkey o Redis OSS (modo de clúster habilitado)](scaling-redis-cluster-mode-enabled.md). Para obtener más información sobre las métricas para clústeres de Valkey o Redis OSS que utilizan la organización de datos en niveles, consulte [Métricas de Valkey y Redis OSS](CacheMetrics.Redis.md).
## Uso de la organización de datos en niveles
### Uso de la organización de datos en niveles mediante la Consola de administración de AWS
Al crear un clúster como parte de un grupo de replicación, se utiliza la organización de datos en niveles seleccionando un tipo de nodo de la familia r6gd, como *cache.r6gd.xlarge*. La selección de ese tipo de nodo habilita automáticamente la organización de datos en niveles.
Para obtener más información sobre la creación de clústeres, consulte [Creación de un clúster para Valkey o Redis OSS](Clusters.Create.md).
### Activación de la organización de datos en niveles mediante la AWS CLI
Al crear un grupo de replicación de utilizando la AWS CLI, puede utilizar la organización de datos en niveles seleccionando un tipo de nodo de la familia r6gd, como *cache.r6gd.xlarge*y configurar el parámetro `--data-tiering-enabled`.
No puede excluirse de la organización de datos en niveles al seleccionar un tipo de nodo de la familia r6gd. Si configura el parámetro `--no-data-tiering-enabled`, la operación no se llevará a cabo correctamente.
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled
```
Después de ejecutar esta operación, verá una respuesta parecida a la siguiente:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
## Restauración de datos desde copias de seguridad en clústeres con la organización de datos en niveles
Puede restaurar una copia de seguridad en un nuevo clúster con la organización de datos en niveles habilitada mediante la (Consola), (AWS CLI) o (API de ElastiCache). Cuando crea un clúster mediante tipos de nodos de la familia r6gd, se habilita la organización de datos en niveles.
### Restauración de datos desde la copia de seguridad en clústeres con la organización de datos en niveles activada (consola)
**Para restaurar una copia de seguridad a un nuevo clúster con la organización de datos en niveles habilitada (consola)**
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, seleccione **Backups (Copias de seguridad)**.
1. En la lista de copias de seguridad, active la casilla situada a la izquierda del nombre de la copia de seguridad que desea restaurar.
1. Elija **Restore (Restaurar)**.
1. Complete el cuadro de diálogo **Restore Cluster**. Asegúrese de completar todos los campos **Required** (Obligatorios) y los demás campos cuyos valores predeterminados desee modificar.
1. **ID del clúster**: obligatorio. Se trata del nombre del nuevo clúster.
1. **Modo de clúster habilitado (escalado horizontal)**: elija esta opción para clústeres de Valkey o Redis OSS (modo de clúster habilitado).
1. **Tipo de nodo**: especificar **cache.r6gd.xlarge** o cualquier otro tipo de nodo de la familia r6gd.
1. **Number of Shards**: elija el número de fragmentos que desea en el nuevo clúster (API/CLI: grupos de nodos).
1. **Replicas per Shard**: elija el número de nodos de réplica de lectura que desea en cada fragmento.
1. **Ranuras y espacios de claves**: elija cómo desea que se distribuyan las claves entre las particiones. Si decide especificar las distribuciones de claves, complete la tabla especificando los rangos de claves para cada fragmento.
1. **Availability zone(s)**: especifique cómo desea que se seleccionen las zonas de disponibilidad del clúster.
1. **Port**: modifique este valor solo si desea que el nuevo clúster use un puerto distinto.
1. **Choose a VPC**: elija la VPC en la que va a crear este clúster.
1. **Grupo de parámetros**: elija un grupo de parámetros que reserve memoria suficiente para la sobrecarga de Valkey o Redis OSS del tipo de nodo que haya seleccionado.
1. Cuando esté conforme con los ajustes, elija **Crear**.
Para obtener más información sobre la creación de clústeres, consulte [Creación de un clúster para Valkey o Redis OSS](Clusters.Create.md).
### Restauración de datos desde copias de seguridad en clústeres con la organización de datos en niveles habilitada (AWS CLI)
Al crear un grupo de replicación de utilizando la AWS CLI, la organización de datos en niveles se utiliza de forma predeterminada seleccionando un tipo de nodo de la familia r6gd, como *cache.r6gd.xlarge* y configurar el parámetro `--data-tiering-enabled`.
No puede excluirse la organización de datos en niveles al seleccionar un tipo de nodo de la familia r6gd. Si configura el parámetro `--no-data-tiering-enabled`, la operación no se llevará a cabo correctamente.
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled \
--snapshot-name my-snapshot
```
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled ^
--snapshot-name my-snapshot
```
Después de ejecutar esta operación, verá una respuesta parecida a la siguiente:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
# Preparación de un clúster en ElastiCache
A continuación, puede encontrar instrucciones sobre cómo crear un clúster a través de la consola de ElastiCache, la AWS CLI o la API de ElastiCache.
También puede crear un clúster de ElastiCache con [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html). Para obtener más información, consulte [AWS::ElastiCache::CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html) en la *Guía del usuario de AWS CloudFormation*, que contiene directrices acerca de cómo implementar este enfoque.
Siempre que cree un clúster o un grupo de reproducción, es conveniente realizar algunos preparativos para que no sea necesario actualizar o efectuar cambios de inmediato.
**Topics**
+ [Determinación de los requisitos del clúster de ElastiCache](cluster-create-determine-requirements.md)
+ [Elección del tamaño del nodo](CacheNodes.SelectSize.md)
# Determinación de los requisitos del clúster de ElastiCache
**Preparación**
Conocer las respuestas a las siguientes preguntas ayuda a que la creación del clúster de ElastiCache sea más fluida:
+ ¿Qué tipo de instancia de nodo necesita?
Para obtener instrucciones sobre cómo elegir un tipo de nodo de instancia, consulte [Elección del tamaño del nodo](CacheNodes.SelectSize.md).
+ ¿Lanzará su clúster en una nube virtual privada (VPC) en función de Amazon VPC?
**importante**
Si va a lanzar su clúster en una VPC, debe asegurarse de crear un grupo de subredes en la misma VPC antes de comenzar a crear un clúster. Para obtener más información, consulte [Subredes y grupos de subredes](SubnetGroups.md).
ElastiCache se ha diseñado para el acceso desde AWS mediante Amazon EC2. Sin embargo, si se lanza en una VPC basada en Amazon VPC y el clúster se encuentra en una VPC, se puede proporcionar acceso desde fuera de AWS. Para obtener más información, consulte [Acceder a ElastiCache los recursos desde el exterior AWS](accessing-elasticache.md#access-from-outside-aws).
+ ¿Necesita personalizar los valores de algún parámetro?
Si lo hace, cree un grupo de parámetros personalizado. Para obtener más información, consulte [Creación de un grupo de parámetros de ElastiCache](ParameterGroups.Creating.md).
Si ejecuta Valkey o Redis OSS, considere establecer `reserved-memory` o `reserved-memory-percent`. Para obtener más información, consulte [Administración de la memoria reservada para Valkey y Redis OSS](redis-memory-management.md).
+ ¿Necesita crear su propio *grupo de seguridad de VPC*?
Para obtener más información, consulte [Seguridad en la VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ ¿Cómo pretende implementar la tolerancia a errores?
Para obtener más información, consulte [Mitigación de errores](disaster-recovery-resiliency.md#FaultTolerance).
**Topics**
+ [Requisitos de procesador y memoria de ElastiCache](#cluster-create-determine-requirements-memory)
+ [Configuración de los clústeres de Memcached](#memcached-cluster-configuration)
+ [Configuración de clústeres de Valkey y Redis OSS](#redis-cluster-configuration)
+ [Requisitos de escalado de ElastiCache](#cluster-create-determine-requirements-scaling)
+ [Requisitos de acceso a ElastiCache](#cluster-create-determine-requirements-access)
+ [Requisitos de región, zona de disponibilidad y zona local para ElastiCache](#cluster-create-determine-requirements-region)
## Requisitos de procesador y memoria de ElastiCache
El componente básico de Amazon ElastiCache es el nodo. Los nodos se configuran individualmente o en agrupaciones para formar clústeres. A la hora de determinar el tipo de nodo que desea utilizar para el clúster, tenga en cuenta la configuración del nodo del clúster y la cantidad de datos que tiene que almacenar.
El motor Memcached tiene varios subprocesos, por lo que el número de núcleos de un nodo repercute en la potencia de cómputo disponible para el clúster.
## Configuración de los clústeres de Memcached
Los clústeres de ElastiCache for Memcached se componen de 1 a 60 nodos. Los datos de un clúster de Memcached están particionados entre los nodos del clúster. La aplicación se conecta con un clúster de Memcached mediante una dirección de red denominada punto de enlace. Cada nodo de un clúster de Memcached tiene su propio punto de enlace. La aplicación utiliza este punto de enlace para leer o escribir en dicho nodo. Además de los puntos de enlace del nodo, el clúster de Memcached tiene un punto de enlace denominado *punto de enlace de configuración*. Su aplicación puede usar este punto de conexión para leer o escribir en el clúster; de este modo, es posible dejar que la detección automática determine en qué nodo leer o escribir.
![\[Imagen que muestra cómo un clúster de Memcached está particionado entre los nodos del clúster.\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
Para obtener más información, consulte [Administración de clústeres en ElastiCache](Clusters.md).
## Configuración de clústeres de Valkey y Redis OSS
Los clústeres de ElastiCache para Valkey y Redis OSS constan de 0 a 500 particiones (también denominadas grupos de nodos). Los datos de un clúster de Valkey o Redis OSS se dividen entre las particiones del clúster. La aplicación se conecta con un clúster de Valkey o Redis OSS a través una dirección de red denominada punto de conexión. Los nodos de una partición de Valkey o Redis OSS adoptan uno de estos dos roles: uno adopta el rol de nodo principal de lectura/escritura y los otros adoptan el rol de nodos secundarios de solo lectura (llamados también réplicas de lectura). Además de los puntos de conexión del nodo, el clúster de Valkey o Redis OSS tiene un punto de conexión denominado *punto de conexión de configuración*. Su aplicación puede utilizar este punto de conexión para leer o escribir en el clúster y no tener que determinar de qué nodo efectuar la lectura o hasta cuál escribir en ElastiCache para Redis OSS.
![\[Imagen que compara un clúster de Valkey o Redis OSS en el modo de clúster deshabilitado y en el modo de clúster habilitado.\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-Redis-ClustersRGs.png)
Para obtener más información, consulte [Administración de clústeres en ElastiCache](Clusters.md).
## Requisitos de escalado de ElastiCache
Todos los clústeres pueden ampliarse mediante la creación de un nuevo clúster con el nuevo tipo de nodo, que es más grande. Al escalar verticalmente un clúster de Memcached, el nuevo clúster comenzará vacío. Al escalar verticalmente un clúster de Valkey o Redis OSS, puede inicializarlo desde una copia de seguridad para evitar que el nuevo clúster esté vacío.
Los clústeres de Amazon ElastiCache for Memcached pueden reducirse o escalarse horizontalmente. Para escalar un clúster de Memcached de forma ascendente o descendente, simplemente agregue o quite nodos del clúster. Si ha habilitado la detección automática y su aplicación se conecta al punto de enlace de configuración del clúster, no es necesario que realice ningún cambio en la aplicación al agregar o quitar nodos.
Para obtener más información, consulte la sección [Escalado ElastiCache](Scaling.md) de esta guía.
## Requisitos de acceso a ElastiCache
Por diseño, el acceso a los clústeres de Amazon ElastiCache se realiza desde instancias de Amazon EC2. El acceso de red a un clúster de ElastiCache se encuentra limitado a la cuenta que ha creado el clúster. Por lo tanto, antes de poder acceder a un clúster desde una instancia de Amazon EC2, debe autorizar a dicha instancia para el acceso al clúster. Los pasos para ello varían en función de si realiza el lanzamiento en EC2-VPC o en EC2-Classic.
Si ha lanzado el clúster en EC2-VPC, necesita conceder acceso de red al clúster. Si ha lanzado un clúster en EC2-Classic, debe conceder al grupo de seguridad de Amazon Elastic Compute Cloud (EC2) asociado a la instancia acceso a su grupo de seguridad de ElastiCache. Para obtener instrucciones detalladas, consulte [Paso 3. Autorización del acceso al clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) en esta guía.
## Requisitos de región, zona de disponibilidad y zona local para ElastiCache
Amazon ElastiCache admite todos las regiones de AWS. Al ubicar sus clústeres de ElastiCache en una región de AWS cercana a su aplicación, puede reducir la latencia. Si el clúster tiene varios nodos, ubicar los nodos en distintas zonas de disponibilidad o en Local Zones puede reducir el impacto de los errores en el clúster.
Para obtener más información, consulte los siguientes temas:
+ [Elección de regiones y zonas de disponibilidad para ElastiCache](RegionsAndAZs.md)
+ [Uso de Local Zones con ElastiCache](Local_zones.md)
+ [Mitigación de errores](disaster-recovery-resiliency.md#FaultTolerance)
# Elección del tamaño del nodo
El tamaño del nodo que seleccione para el clúster de ElastiCache afectará a los costos, al rendimiento y a la tolerancia a errores.
## Tamaño del nodo (Valkey y Redis OSS)
Para obtener información sobre las ventajas de los procesadores Graviton, consulte [Procesador AWS Graviton](https://aws.amazon.com/pm/ec2-graviton/).
Responder las siguientes preguntas puede ayudar a determinar el tipo de nodo mínimo que necesita para su implementación de Valkey o Redis OSS:
+ ¿Espera cargas de trabajo limitadas por el rendimiento con múltiples conexiones de cliente?
Si este es el caso y está ejecutando la versión 5.0.6 o posteriores de Redis OSS, puede obtener un mejor rendimiento y latencia con nuestra característica de E/S mejorada, donde las CPU disponibles se utilizan para descargar las conexiones del cliente en nombre del motor de Redis OSS. Si ejecuta la versión 7.0.4 o posteriores de Redis OSS, además de la E/S mejorada, obtendrá una aceleración adicional con la multiplexación de E/S mejorada, en la que cada subproceso de E/S de red específico canaliza los comandos desde varios clientes al motor de Redis OSS, aprovechando así la capacidad de Redis OSS de procesar comandos en lotes de manera eficiente. En ElastiCache para Redis 7.1 y versiones posteriores, hemos ampliado la funcionalidad mejorada de los subprocesos de E/S para gestionar también la lógica de la capa de presentación. Al hablar de la capa de presentación, nos referimos a los subprocesos de E/S mejorados. Ahora, no solo leen la entrada del cliente, sino que también analizan la entrada en el formato de comandos binarios de Redis OSS; luego, se envía al subproceso principal para la ejecución, lo que aumenta el rendimiento. Consulte la [entrada de blog](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/) y la página de [versiones compatibles](VersionManagement.md#supported-engine-versions) para obtener más información.
+ ¿Tiene cargas de trabajo que acceden regularmente a un pequeño porcentaje de sus datos?
Si este es el caso y está ejecutando en el motor de Redis OSS versión 6.2 o posteriores, puede aprovechar la organización de datos en niveles eligiendo el tipo de nodo r6gd. Con la organización de datos en niveles, los datos menos usados recientemente se almacenan en SSD. Cuando se recupera, hay un pequeño costo de latencia, que se equilibra con el ahorro de costos. Para obtener más información, consulte [Organización de datos en niveles en ElastiCache](data-tiering.md).
Para obtener más información, consulte [Tipos de nodos compatibles](CacheNodes.SupportedTypes.md).
+ ¿Cuánta memoria total necesita para sus datos?
Para obtener una estimación general, tome el tamaño de los elementos que desea almacenar en la caché. Multiplique este tamaño por el número de elementos que desea conservar en la caché al mismo tiempo. Para obtener una estimación razonable del tamaño de los elementos, serialice los elementos de la caché y cuente los caracteres. A continuación, divida esto entre el número de particiones de su clúster.
Para obtener más información, consulte [Tipos de nodos compatibles](CacheNodes.SupportedTypes.md).
+ ¿Qué versión de Redis OSS está ejecutando?
Las versiones de Redis OSS anteriores a la 2.8.22 requieren que reserve más memoria para la conmutación por error, la sincronización de instantáneas y la promoción de réplicas a operaciones principales. Este requisito se debe a que debe disponer de suficiente memoria disponible para todas las operaciones de escritura que se producen durante el proceso.
La versión 2.8.22 de Redis OSS y las versiones posteriores usan un proceso de guardado sin ramificaciones que requiere menos memoria disponible que el proceso anterior.
Para obtener más información, consulte los siguientes temas:
+ [Cómo se implementan la sincronización y la copia de seguridad](Replication.Redis.Versions.md)
+ [Forma de garantizar que dispone de memoria suficiente para crear una instantánea de Valkey o Redis OSS](BestPractices.BGSAVE.md)
+ ¿Qué volumen de operaciones de escritura realiza su aplicación?
Las aplicaciones que realizan un elevado volumen de operaciones de escritura pueden requerir un mayor volumen de memoria disponible (memoria no usada por los datos) a la hora de tomar instantáneas o en casos de conmutación por error. Cuando se aplica el proceso `BGSAVE`, debe tener suficiente memoria que no sea utilizada por los datos para alojar todas las escrituras que se producen durante el proceso `BGSAVE`. Algunos ejemplos son: tomar una instantánea, sincronizar un clúster principal con una réplica en un clúster y habilitar la característica de archivo de solo anexado (AOF). Otro ejemplo es cuando se promueve una réplica a principal (si tiene habilitado Multi-AZ). El peor de los casos es cuando todos los datos se reescriben durante el proceso. En este caso, necesita un tamaño de instancia de nodo con el doble de la memoria necesaria solo para los datos.
Para obtener información más detallada, consulte [Forma de garantizar que dispone de memoria suficiente para crear una instantánea de Valkey o Redis OSS](BestPractices.BGSAVE.md).
+ ¿Su implementación será un clúster de Valkey o Redis OSS independiente (modo de clúster deshabilitado) o un clúster de Valkey o Redis OSS (modo de clúster habilitado) con varias particiones?
**Clúster de Valkey o Redis OSS (modo de clúster deshabilitado)**
Si va a implementar un clúster de Valkey o Redis OSS (modo de clúster deshabilitado), su tipo de nodo debe tener capacidad para todos los datos más una capacidad adicional, tal como se describe en el punto anterior.
Por ejemplo, supongamos que estima que el tamaño total de todos los elementos es de 12 GB. En este caso, puede utilizar un nodo de `cache.m3.xlarge` con 13.3 GB de memoria o un nodo de `cache.r3.large` con 13.5 GB de memoria. Sin embargo, es posible que necesite más memoria para las operaciones `BGSAVE`. Si la aplicación tiene un gran volumen de operaciones de escritura, duplique los requisitos de memoria a 24 GB como mínimo. Por lo tanto, utilice un `cache.m3.2xlarge` con 27.9 GB de memoria o un `cache.r3.xlarge` con 30.5 GB de memoria.
**Valkey o Redis OSS (modo de clúster habilitado) con varias particiones**
Si va a implementar un clúster de Valkey o Redis OSS (modo de clúster habilitado) con varias particiones, el tipo de nodo debe tener capacidad para `bytes-for-data-and-overhead / number-of-shards` bytes de datos.
Por ejemplo, suponga que estima que el tamaño total de todos los elementos es de 12 GB y tiene dos particiones. En este caso, puede utilizar un nodo de `cache.m3.large` con 6.05 GB de memoria (12 GB/2). Sin embargo, es posible que necesite más memoria para las operaciones `BGSAVE`. Si la aplicación tiene un gran volumen de operaciones de escritura, duplique los requisitos de memoria a 12 GB por partición como mínimo. Por lo tanto, utilice un `cache.m3.xlarge` con 13.3 GB de memoria o un `cache.r3.large` con 13.5 GB de memoria.
+ ¿Utiliza Local Zones?
[Local Zones](Local_zones.md) permite colocar recursos como un clúster de ElastiCache en varias ubicaciones cercanas a los usuarios. Sin embargo, cuando elija el tamaño del nodo, tenga en cuenta que, independientemente de los requisitos de capacidad, los tamaños de nodo disponibles tienen los siguientes límites en este momento:
+ Generación actual:
**Tipos de nodos M:** `cache.m5.large`, `cache.m5.xlarge`, `cache.m5.2xlarge`, `cache.m5.4xlarge`, `cache.m5.12xlarge`, `cache.m5.24xlarge`
**Tipos de nodos R:** `cache.r5.large`, `cache.r5.xlarge`, `cache.r5.2xlarge`, `cache.r5.4xlarge`, `cache.r5.12xlarge`, `cache.r5.24xlarge`
**Tipos de nodos T:** `cache.t3.micro`, `cache.t3.small`, `cache.t3.medium`
Mientras el clúster se está ejecutando, podrá monitorear el uso de memoria, el uso del procesador, las métricas de los errores de caché y los aciertos de caché que se publican en CloudWatch. Es posible que observe que el clúster no tiene la tasa de aciertos que desea o que las claves se expulsan con demasiada frecuencia. En estos casos, puede elegir un tamaño de nodo diferente con mayores especificaciones de memoria y CPU.
Cuando supervise el uso de la CPU, recuerde que Valkey y Redis OSS tienen un subproceso único. Por lo tanto, multiplique el uso de la CPU por el número de núcleos de CPU para obtener el uso real. Por ejemplo, una CPU de cuatro núcleos cuya tasa de uso es del 20 % indica que el núcleo de Redis OSS se encuentra en uso al 80 %.
## Tamaño del nodo (Memcached)
Los clústeres de Memcached contienen uno o varios nodos entre los que se particionan los datos del clúster. Por ello, las necesidades de memoria del clúster y la memoria de un nodo están relacionadas, pero no son la misma cosa. Puede alcanzar la capacidad de memoria del clúster necesaria con varios nodos de gran tamaño o varios nodos más pequeños. Además, a medida que cambien sus necesidades, puede agregar nodos al clúster o eliminarlos y, por lo tanto, pagar solo por aquello que necesite.
La capacidad total de memoria de su clúster se calcula multiplicando el número de nodos del clúster por la capacidad de RAM de cada nodo, tras haberle restado la carga general del sistema. La capacidad de cada nodo depende del tipo de nodo.
```
cluster_capacity = number_of_nodes * (node_capacity - system_overhead)
```
El número de nodos del clúster es un factor clave para la disponibilidad de su clúster con Memcached. El error de un único nodo puede repercutir en la disponibilidad de su aplicación y en la carga de la base de datos de backend. En tal caso, ElastiCache aprovisiona un nodo de reemplazo para el nodo con error y propaga los datos. Para reducir este impacto en la disponibilidad, distribuya su memoria y su capacidad informática en un mayor número de nodos, cada uno con menos capacidad, en lugar de usar menos nodos de mayor capacidad.
En un escenario en el que desea disponer de 35 GB de memoria caché, puede realizar cualquiera de las siguientes configuraciones:
+ 11 `cache.t2.medium` nodos con 3,22 GB de memoria y 2 subprocesos en cada uno = 35,42 GB y 22 subprocesos.
+ 6 `cache.m4.large` nodos con 6,42 GB de memoria y 2 subprocesos en cada uno = 38,52 GB y 12 subprocesos.
+ 3 `cache.r4.large` nodos con 12,3 GB de memoria y 2 subprocesos en cada uno = 36,90 GB y 6 subprocesos.
+ 3 `cache.m4.xlarge` nodos con 14,28 GB de memoria y 4 subprocesos en cada uno = 42,84 GB y 12 subprocesos.
**Comparación de opciones de nodos**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/CacheNodes.SelectSize.html)
Estas opciones proporcionan una capacidad de memoria similar pero con diferencias de costo y capacidad de cómputo. Para comparar los costos de sus opciones específicas, consulte [Precios de Amazon ElastiCache](https://aws.amazon.com/elasticache/pricing/).
Para clústeres que ejecutan Memcached, parte de la memoria disponible en cada nodo se usa para la conexión. Para obtener más información, consulte [Capacidad adicional para conexiones de Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead).
El uso de varios nodos requiere distribuir las claves entre ellos. Cada nodo tiene su propio punto de conexión. Para facilitar la administración de los puntos de enlace, utilice la característica de detección automática de ElastiCache, que permite a los programas de cliente identificar de forma automática todos los nodos de un clúster. Para obtener más información, consulte [Identificación automática de los nodos en el clúster (Memcached)](AutoDiscovery.md).
En algunos casos, es posible que no se encuentre seguro de cuánta capacidad necesita. Si es así, para las pruebas recomendamos comenzar con un nodo `cache.m5.large`. A continuación, monitoree el uso de memoria, el uso de la CPU y la tasa de aciertos de caché con las métricas de ElastiCache que se publican en Amazon CloudWatch. A fin de obtener más información sobre las métricas de CloudWatch para ElastiCache, consulte [Supervisión del uso con CloudWatch métricas](CacheMetrics.md). Para las cargas de trabajo de mayor tamaño y de producción, los nodos R5 ofrecen el mejor rendimiento y el precio de RAM más ajustado.
Si su clúster no tiene la tasa deseada, podrá agregar más nodos fácilmente para aumentar la memoria total disponible en el clúster.
Si el clúster se encuentra limitado por la CPU pero tiene una tasa suficiente, configure un clúster nuevo con un tipo de nodo que ofrezca mayor potencia informática.
# Creación de un clúster para Valkey o Redis OSS
Los siguientes ejemplos muestran cómo crear un clúster OSS de Valkey o Redis mediante la API Consola de administración de AWSAWS CLI y ElastiCache .
## Creación un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) (consola)
ElastiCache admite la replicación cuando se utiliza el motor OSS de Valkey o Redis. Para supervisar la latencia entre el momento en que los datos se escriben en un clúster read/write principal de OSS de Valkey o Redis y el momento en que se propagan a un clúster secundario de solo lectura, ElastiCache añada al clúster una clave especial,. `ElastiCacheMasterReplicationTimestamp` Esta clave es la hora de tiempo universal (UCT). Puesto que se puede añadir un clúster de Valkey o Redis OSS más adelante a un grupo de replicación, esta clave se incluye en todos los clústeres de Valkey o Redis OSS, incluso si inicialmente no son miembros de un grupo de replicación. Para obtener más información acerca de los grupos de reproducción, consulte [Alta disponibilidad a través de grupos de reproducción](Replication.md).
Para crear un clúster de Valkey o Redis OSS (modo clúster deshabilitado), siga los pasos de [Creación de un clúster de Valkey (modo de clúster deshabilitado) (consola)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs).
En cuanto el estado de tu clúster esté *disponible*, podrás conceder a Amazon EC2 acceso a él, conectarse a él y empezar a usarlo. Para obtener más información, consulte [Paso 3. Autorización del acceso al clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) y [Paso 4. Conexión al nodo de un clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**importante**
Cuando su clúster esté disponible, se cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando de forma activa. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
## Creación de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)
Si ejecuta Redis OSS 3.2.4 o una versión posterior, puede crear un clúster de Valkey o Redis OSS (modo de clúster habilitado). Los clústeres de Valkey o Redis OSS (modo de clúster habilitado) permiten dividir los datos entre 1 y 500 particiones (API/CLI: grupos de nodos), pero con algunas limitaciones. Para obtener una comparación de Valkey o Redis OSS (modo de clúster deshabilitado) y Valkey o Redis OSS (modo de clúster habilitado), consulte [Motores y versiones compatibles](VersionManagement.md#supported-engine-versions).
**Para crear un clúster OSS (modo de clúster activado) de Valkey o Redis mediante la consola ElastiCache**
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En la lista de la esquina superior derecha, selecciona la AWS región en la que quieres lanzar este clúster.
1. En el panel de navegación, seleccione **Get started (Introducción)**.
1. Elija **Create VPC** (Crear una VPC) y siga los pasos que se detallan en [Creating a Virtual Private Cloud (VPC)](VPCs.CreatingVPC.md) (Creación de una nube privada virtual).
1. En la página del ElastiCache panel, elija **Crear clúster** y, a continuación, elija **Crear clúster de Valkey o Crear clúster** **de Redis** OSS.
1. En **Cluster settings** (Configuración de clúster), realice la siguiente operación:
1. Elija **Configure and create a new cluster** (Configurar y crear un nuevo clúster).
1. Para **Cluster mode** (Modo clúster), elija **Enabled** (Habilitado).
1. Para **Cluster info** (Información del clúster) introduzca un valor para **Name** (Nombre).
1. (Opcional) Introduzca un valor para **Description** (Descripción).
1. En **Location** (Ubicación):
------
#### [ AWS Cloud ]
1. Para **Nube de AWS**, le recomendamos que acepte la configuración predeterminada de **Multi-AZ** y **Conmutación por error automática**. Para obtener más información, consulte [Minimizar el tiempo de inactividad en ElastiCache Redis OSS](AutoFailover.md) con Multi-AZ.
1. En **Cluster settings** (Configuración del clúster)
1. Para **Engine version** (Versión del motor), elija una versión disponible.
1. En **Port** (Puerto), utilice el puerto predeterminado, 6379. Si tiene un motivo para utilizar un puerto diferente, escriba el número de puerto.
1. En **Grupo de parámetros**, elija un grupo de parámetros o cree uno nuevo. Los grupos de parámetros controlan los parámetros de tiempo de ejecución de su clúster. Para obtener más información acerca de los grupos de parámetros, consulte [Parámetros de Valkey y Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis) y [Creación de un grupo de parámetros de ElastiCache](ParameterGroups.Creating.md).
**nota**
Cuando se selecciona un grupo de parámetros para definir los valores de configuración del motor, dicho grupo de parámetros se aplica a todos los clústeres del almacén de datos global. En la página **Parameter Groups (Grupos de parámetros)**, el atributo **Global** sí/no, indica si un grupo de parámetros forma parte de un almacén de datos global.
1. Para **Node type**, elija la flecha hacia abajo (![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)). En el cuadro de diálogo **Cambiar tipo de nodo**, elija un valor para **Familia de instancias** para el tipo de nodo que desea. A continuación, elija el tipo de nodo que desea utilizar para este clúster y, a continuación, elija **Guardar**.
Para obtener más información, consulte [Elección del tamaño del nodo](CacheNodes.SelectSize.md).
Si elige un tipo de nodo r6gd, la organización de datos en niveles se activará automáticamente. Para obtener más información, consulte [Organización de datos en niveles en ElastiCache](data-tiering.md).
1. En **Número de particiones**, elija el número de particiones (particiones/grupos de nodos) que desea para este clúster de Valkey o Redis OSS (modo de clúster habilitado).
En algunas versiones de Valkey o Redis OSS (modo de clúster habilitado), puede cambiar dinámicamente el número de particiones del clúster:
+ **Redis OSS 3.2.10 y versiones posteriores**: si el clúster ejecuta Redis OSS 3.2.10 o versiones posteriores, puede cambiar el número de particiones del clúster de forma dinámica. Para obtener más información, consulte [Escalado de clústeres de Valkey o Redis OSS (modo de clúster habilitado)](scaling-redis-cluster-mode-enabled.md).
+ **Otras versiones de Redis OSS**: si su clúster ejecuta una versión de Redis OSS anterior a 3.2.10, existe otro enfoque. Para cambiar el número de particiones del clúster en este caso, cree un nuevo clúster con el nuevo número de particiones. Para obtener más información, consulte [Restauración desde una copia de seguridad a una nueva caché](backups-restoring.md).
1. En **Réplicas por partición**, elija el número de nodos de réplica de lectura que desea en cada partición.
Existen las siguientes restricciones para Valkey o Redis OSS (modo de clúster habilitado).
+ Si tiene habilitado Multi-AZ, asegúrese de tener al menos una réplica por partición.
+ El número de réplicas es el mismo para cada fragmento al crear el clúster utilizando la consola.
+ El número de réplicas de lectura por fragmento es fijo y no puede modificarse. Si se da cuenta de que necesita más o menos réplicas por fragmento (API/CLI: grupo de nodos), debe crear un nuevo clúster con el nuevo número de réplicas. Para obtener más información, consulte [Tutorial: propagación de un nuevo clúster basado en nodos con una copia de seguridad creada externamente](backups-seeding-redis.md).
1. En **Connectivity** (Conectividad)
1. Para el **Network type** (Tipo de red), elija las versiones IP que admitirá este clúster.
1. En el **caso de los grupos de subredes**, elija la subred que desee aplicar a este clúster. ElastiCache usa ese grupo de subredes para elegir una subred y las direcciones IP dentro de esa subred para asociarlas a los nodos. ElastiCache Los clústeres requieren una subred de doble pila con ambas IPv6 direcciones asignadas para funcionar en el modo de doble pila IPv4 y una IPv6 subred «solo» para funcionar como «solo». IPv6
Al crear un nuevo grupo de subredes, escriba el **VPC ID** (ID de VPC) al que pertenece.
Seleccione un **Discovery IP type** (Tipo de IP de detección). Solo se devuelven las direcciones IP del protocolo elegido.
Para obtener más información, consulte lo siguiente:
+ [Elegir un tipo de red en ElastiCache](network-type.md).
+ [Cree una subred en la VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet).
Si es [Uso de Local Zones con ElastiCache](Local_zones.md), debe crear o elegir una subred que se encuentre en la zona local.
Para obtener más información, consulte [Subredes y grupos de subredes](SubnetGroups.md).
1. En **Availability zone placements** Ubicaciones de las zonas de disponibilidad), tiene dos opciones:
+ **Sin preferencia**: elige la zona de disponibilidad. ElastiCache
+ **Specify availability zones** (Especificar zonas de disponibilidad): especifique la zona de disponibilidad para cada clúster.
Si decide especificar las zonas de disponibilidad, para cada clúster en cada fragmento, elija la zona de disponibilidad de la lista.
Para obtener más información, consulte [Elección de regiones y zonas de disponibilidad para ElastiCache](RegionsAndAZs.md).
1. Elija **Next** (Siguiente).
1. En **Configuración avanzada de Valkey** o **Configuración avanzada de Redis OSS** o
1. Para **Security** (Seguridad):
1. Para cifrar sus datos, tiene las siguientes opciones:
+ **Encryption at rest** (Cifrado en reposo): permite el cifrado de los datos almacenados en el disco. Para obtener más información, consulte [Cifrado en reposo](at-rest-encryption.md).
**nota**
Tiene la opción de proporcionar una clave de cifrado diferente. Para ello, elija la **clave AWS KMS gestionada por el cliente** y elija la clave. Para obtener más información, consulte [Uso de claves de AWS KMS administradas por el cliente](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ **Encryption in-transit** (Cifrado en tránsito): permite el cifrado de datos del cable. Para obtener más información, consulte [Cifrado en tránsito](in-transit-encryption.md). Para Valkey 7.2 y versiones posteriores o Redis OSS 6.0 y posteriores, si habilita el cifrado en tránsito, se le pedirá que especifique una de las siguientes opciones de **Control de acceso**:
+ **No Access Control** (Sin control de acceso): este es el valor predeterminado. Esto indica que no hay restricciones en el acceso de los usuarios al clúster.
+ **User Group Access Control List** (Lista de control de acceso del grupo de usuarios): seleccione un grupo de usuarios con un conjunto definido de usuarios que pueden acceder al clúster. Para obtener más información, consulte [Administración de grupos de usuarios con la consola y la CLI](Clusters.RBAC.md#User-Groups).
+ **Usuario predeterminado con el comando AUTH**: un mecanismo de autenticación para el servidor de Valkey o Redis OSS. Para obtener más información, consulte [AUTH](auth.md).
+ **AUTH**: un mecanismo de autenticación para el servidor de Valkey o Redis OSS. Para obtener más información, consulte [AUTH](auth.md).
**nota**
Para las versiones de Redis OSS a partir de la 3.2.6, excepto la versión 3.2.10, AUTH es la única opción.
1. En **Grupos de seguridad**, elija los grupos de seguridad que desea para este clúster. Un *grupo de seguridad* actúa como un firewall para controlar el acceso de red al clúster. Puede utilizar el grupo de seguridad predeterminado para la VPC o crear uno nuevo.
Para obtener más información sobre los grupos de seguridad, consulte [Grupos de seguridad de su VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) en la *Guía del usuario de Amazon VPC*.
1. En las copias de seguridad automáticas programadas regularmente, seleccione **Enable automatic backups** (Habilitar copias de seguridad automáticas) y, a continuación, escriba el número de días que desea conservar cada copia de seguridad automática antes de que se elimine automáticamente. Si no quiere tener copias de seguridad automáticas programadas regularmente, desactive la casilla de verificación **Enable automatic backups (Habilitar copias de seguridad automáticas)**. En cualquier caso, siempre tendrá la opción de crear copias de seguridad manuales.
Para obtener más información acerca de la copia de seguridad y restauración, consulte [Instantánea y restauración](backups.md).
1. (Opcional) Especifique un periodo de mantenimiento. El *periodo de mantenimiento* hace alusión al tiempo, generalmente una hora, de cada semana en la que ElastiCache programa el mantenimiento del sistema para su clúster. Puede permitir a ElastiCache elegir el día y la hora de su periodo de mantenimiento (*No preference*), o bien puede elegir el día, la hora y la duración usted mismo (*Specify maintenance window*). Si elige *Especificar el periodo de mantenimiento* en las listas, seleccione *Día de inicio*, *Hora de inicio* y *Duración* (en horas) para el periodo de mantenimiento. Todas las horas se indican en UCT.
Para obtener más información, consulte [Administración del mantenimiento de clústeres de ElastiCache](maintenance-window.md).
1. (Opcional) Para **Logs** (Registros):
+ En **Log format** (Formato de registro), elija **Text** o **JSON**.
+ En **Tipo de destino**, elija **CloudWatch Logs** o **Kinesis Firehose**.
+ En **Destino del registro**, elija **Crear nuevo** e introduzca el nombre del grupo de CloudWatch registros de Logs o el nombre de la transmisión de Firehose, o bien elija **Seleccionar existente** y, a continuación, elija el nombre del grupo de CloudWatch registros de Logs o el nombre de la transmisión de Firehose,
1. En el caso de las **etiquetas**, para ayudarte a gestionar tus clústeres y otros ElastiCache recursos, puedes asignar tus propios metadatos a cada recurso en forma de etiquetas. Para obtener más información, consulte [Etiquetar sus recursos ElastiCache](Tagging-Resources.md).
1. Elija **Siguiente**.
1. Revise todas las entradas y opciones y, a continuación, realice todos los cambios necesarios. Cuando haya terminado, elija **Create** (Crear).
------
#### [ On premises ]
1. Para **On premises** (En las instalaciones), le recomendamos que deje **Auto-failover** (Conmutación por error automática) habilitada. Para obtener más información, consulte [Minimizar el tiempo de inactividad en ElastiCache Redis OSS con Multi-AZ](AutoFailover.md)
1. Siga los pasos de [Uso de Outposts](ElastiCache-Outposts.md).
------
Para crear el equivalente mediante la ElastiCache API o AWS CLI en lugar de la ElastiCache consola, consulte lo siguiente:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
En cuanto el estado de tu clúster esté *disponible*, podrás concederle EC2 acceso, conectarte a él y empezar a usarlo. Para obtener más información, consulte [Paso 3. Autorización del acceso al clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) y [Paso 4. Conexión al nodo de un clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**importante**
Cuando su clúster esté disponible, se cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando de forma activa. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
## Creación de un clúster (AWS CLI)
Para crear un clúster mediante el AWS CLI, usa el `create-cache-cluster` comando.
**importante**
Cuando su clúster esté disponible, se cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando de forma activa. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
### Creación de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) (CLI)
**Example – Un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) sin réplicas de lectura**
El siguiente código de la CLI crea un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) sin réplicas.
Al crear clúster utilizando un tipo de nodo de la familia r6gd, debe pasar el parámetro `data-tiering-enabled`.
Para Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--cache-parameter-group default.redis6.x \
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--cache-parameter-group default.redis6.x ^
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
### Creación de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (AWS CLI)
Los clústeres de Valkey o Redis OSS (modo de clúster habilitado) (API/CLI: grupos de replicación) no se pueden crear con la operación `create-cache-cluster`. Para crear un clúster de Valkey o Redis OSS (modo de clúster habilitado) (API/CLI: grupo de replicación), consulte [Creación de un grupo de replicación de Valkey o Redis OSS (modo de clúster habilitado) desde cero (AWS CLI)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI).
Para obtener más información, consulte el tema AWS CLI de ElastiCache referencia [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html).
## Creación de un clúster para Valkey o Redis OSS (API) ElastiCache
Para crear un clúster mediante la ElastiCache API, utilice la `CreateCacheCluster` acción.
**importante**
Cuando su clúster esté disponible, se le cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
**Topics**
+ [Crear un clúster (API) de Valkey o Redis OSS (modo de clúster desactivado) ElastiCache](#Clusters.Create.API.Redis)
+ [Crear un clúster en Valkey o Redis OSS (modo de clúster activado) (API) ElastiCache](#Clusters.Create.API.RedisCluster)
### Crear un clúster (API) de Valkey o Redis OSS (modo de clúster desactivado) ElastiCache
El siguiente código crea un clúster (API) de Valkey o Redis OSS (modo de clúster desactivado). ElastiCache
Se agregan saltos de línea para facilitar la lectura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&CacheParameterGroup=default.redis3.2
&Engine=redis
&EngineVersion=3.2.4
&NumCacheNodes=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SnapshotArns.member.1=arn%3Aaws%3As3%3A%3A%3AmyS3Bucket%2Fdump.rdb
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
### Crear un clúster en Valkey o Redis OSS (modo de clúster activado) (API) ElastiCache
Los clústeres de Valkey o Redis OSS (modo de clúster habilitado) (API/CLI: grupos de replicación) no se pueden crear con la operación `CreateCacheCluster`. Para crear un clúster de Valkey o Redis OSS (modo de clúster habilitado) (API/CLI: grupo de replicación), consulte [Creación de un grupo de replicación en Valkey o Redis OSS (modo de clúster habilitado) desde cero (API de ElastiCache)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API).
Para obtener más información, consulte el tema de referencia de la ElastiCache API. [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
# Creación de un clúster para Memcached
Los siguientes ejemplos muestran cómo crear un clúster mediante la Consola de administración de AWS ElastiCache API AWS CLI y.
## Creación de un clúster de Memcached (consola)
Cuando utilizas el motor Memcached, Amazon ElastiCache admite la partición horizontal de los datos en varios nodos. Memcached permite la detección automática, por lo que no es necesario realizar un seguimiento de los puntos de enlace de cada nodo. Memcached realiza un seguimiento del punto de conexión de cada nodo, actualizando la lista de puntos de conexión a medida que se agregan y eliminan nodos. Todo lo que necesita su aplicación para interactuar con el clúster es el punto de conexión de configuración.
Para crear un clúster de Memcached mediante la consola, siga los pasos de [Creación de un clúster de Valkey (modo de clúster deshabilitado) (consola)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Cuando llegue al paso cinco, seleccione **Crear caché de Memcached**.
En cuanto el estado de tu clúster esté *disponible*, podrás conceder a Amazon EC2 acceso a él, conectarse a él y empezar a usarlo. Para obtener más información, consulte los pasos similares [Paso 3. Autorización del acceso al clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) y [Paso 4. Conexión al nodo de un clúster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**importante**
Cuando su clúster esté disponible, se cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando de forma activa. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
## Creación de un clúster (AWS CLI)
Para crear un clúster mediante el AWS CLI, usa el `create-cache-cluster` comando.
**importante**
Cuando su clúster esté disponible, se cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando de forma activa. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
### Creación de un clúster de caché de Memcached (AWS CLI)
El siguiente código de la CLI crea un clúster de Memcached con tres nodos.
Para Linux, macOS o Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine memcached \
--engine-version 1.4.24 \
--cache-parameter-group default.memcached1.4 \
--num-cache-nodes 3
```
Para Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine memcached ^
--engine-version 1.4.24 ^
--cache-parameter-group default.memcached1.4 ^
--num-cache-nodes 3
```
## Crear un clúster para Memcached (API) ElastiCache
Para crear un clúster mediante la ElastiCache API, utilice la `CreateCacheCluster` acción.
**importante**
Cuando su clúster esté disponible, se le cobrará por cada hora u hora parcial que el clúster esté activo, incluso si no lo está utilizando. Para dejar de incurrir en cargos por este clúster, debe eliminarlo. Consulte [Eliminar un clúster en ElastiCache](Clusters.Delete.md).
**Topics**
+ [Crear un clúster de Memcached (API) ElastiCache](#Clusters.Create.API.Memcached)
### Crear un clúster de Memcached (API) ElastiCache
El siguiente código crea un clúster de Memcached con 3 nodos (API). ElastiCache
Se agregan saltos de línea para facilitar la lectura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&Engine=memcached
&NumCacheNodes=3
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
# Visualización de los detalles de un clúster de ElastiCache
Puede consultar información detallada acerca de uno o varios clústeres mediante la consola de ElastiCache, la AWS CLI o la API de ElastiCache.
## Visualización de los detalles de un clúster de Memcached (consola)
Puede ver los detalles de un clúster de Memcached con la consola de ElastiCache, la AWS CLI de ElastiCache o la API de ElastiCache.
El siguiente procedimiento detalla cómo consultar los detalles de un clúster de Memcached con la consola de ElastiCache.
**Para ver los detalles de un clúster de Memcached**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon ElastiCache en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En la lista de la esquina superior derecha, elija la región de AWS que le interese.
1. En el panel del motor de ElastiCache, elija **Memcached**. Al hacerlo, se muestra una lista de todos los clústeres que se ejecutan en el motor de Memcached.
1. Para ver los detalles de un clúster, elija el cuadro situado a la izquierda del nombre del clúster.
1. Para ver la información de los nodos, elija la pestaña **Nodes** (Nodos), que muestra información sobre el estado de los nodos y el punto de conexión.
1. Para ver las métricas, elija la pestaña **Metrics** (Métricas), que muestra las métricas pertinentes de todos los nodos del clúster. Para obtener más información, consulte [Supervisión del uso con CloudWatch métricas](CacheMetrics.md)
1. Elija la pestaña **Network and security** (Red y seguridad) para ver los detalles sobre la configuración de la conectividad de red y el grupo de subredes del clúster y el grupo de seguridad de VPC. Para obtener más información, consulte [Subredes y grupos de subredes](SubnetGroups.md).
1. Elija la pestaña **Maintenance** (Mantenimiento) para ver los detalles en la configuración de mantenimiento del clúster. Para obtener más información, consulte [Administración del mantenimiento de clústeres de ElastiCache](maintenance-window.md).
1. Elija la pestaña **Tags** (Etiquetas) para ver los detalles de las etiquetas aplicadas a los recursos del clúster. Para obtener más información, consulte [Etiquetar sus recursos ElastiCache](Tagging-Resources.md).
## Visualización de los detalles de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) (consola)
Puede ver los detalles de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) con la consola de ElastiCache, la AWS CLI de ElastiCache o la API de ElastiCache.
El siguiente procedimiento detalla cómo consultar los detalles de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) con la consola de ElastiCache.
**Visualización de los detalles de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado)**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon ElastiCache en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel del motor de ElastiCache, elija **Valkey** o **Redis OSS** para ver una lista de todos los clústeres que se ejecutan en ese motor.
1. Para ver los detalles de un clúster, seleccione la casilla de verificación situada a la izquierda del nombre del clúster. Asegúrese de seleccionar un clúster que ejecute el motor de Valkey o Redis OSS, no Valkey en clúster ni Redis OSS en clúster. Al hacerlo se muestran los detalles sobre el clúster, incluido su punto de conexión principal.
1. Para ver la información de los nodos:
1. Elija el nombre del clúster.
1. Elija la pestaña **Shards and nodes** (Particiones y nodos). Se mostrarán los detalles de cada nodo, incluido el punto de conexión del nodo que tiene que usar para leer del clúster.
1. Para ver las métricas, elija la pestaña **Metrics** (Métricas), que muestra las métricas pertinentes de todos los nodos del clúster. Para obtener más información, consulte [Supervisión del uso con CloudWatch métricas](CacheMetrics.md)
1. Para ver los registros, elija la pestaña **Logs** (Registros), que indica si el clúster utiliza registros lentos o registros del motor y proporciona los detalles pertinentes. Para obtener más información, consulte [Entrega de registro](Log_Delivery.md).
1. Elija la pestaña **Network and security** (Red y seguridad) para ver los detalles sobre la conectividad de red del clúster y la configuración del grupo de subredes. Para obtener más información, consulte [Subredes y grupos de subredes](SubnetGroups.md).
1. Elija la pestaña **Maintenance** (Mantenimiento) para ver los detalles en la configuración de mantenimiento del clúster. Para obtener más información, consulte [Administración del mantenimiento de clústeres de ElastiCache](maintenance-window.md).
1. Elija la pestaña **Service updates** (Actualizaciones de servicio) para ver los detalles de las actualizaciones de servicio disponibles junto con la fecha de caducidad recomendada. Para obtener más información, consulte [Actualizaciones de servicios en ElastiCache](Self-Service-Updates.md).
1. Elija la pestaña **Tags** (Etiquetas) para ver los detalles de las etiquetas aplicadas a los recursos del clúster. Para obtener más información, consulte [Etiquetar sus recursos ElastiCache](Tagging-Resources.md).
## Visualización de los detalles de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)
Puede ver los detalles de un clúster de Valkey o Redis OSS (modo de clúster habilitado) con la consola de ElastiCache, la AWS CLI de ElastiCache o la API de ElastiCache.
El siguiente procedimiento detalla cómo consultar los detalles de un clúster de Valkey o Redis OSS (modo de clúster habilitado) con la consola de ElastiCache.
**Visualización de los detalles de un clúster de Valkey o Redis OSS (modo de clúster habilitado)**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon ElastiCache en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En la lista de la esquina superior derecha, elija la región de AWS que le interese.
1. En el panel del motor de ElastiCache, elija **Valkey** o **Redis OSS** para ver una lista de todos los clústeres que se ejecutan en ese motor.
1. Para ver los detalles de un clúster de Valkey o Redis OSS (modo de clúster habilitado), elija la casilla situada a la izquierda del nombre del clúster. Asegúrese de elegir un clúster que ejecute el motor de Valkey o Redis OSS en clúster.
La pantalla se ampliará para mostrar el clúster y los detalles sobre el clúster, incluido el punto de conexión de configuración del clúster.
1. Para ver una lista de las particiones del clúster y el número de nodos en cada partición, elija la pestaña **Shards and nodes** (Particiones y nodos).
1. Para ver información específica sobre un nodo:
1. Elija el ID del fragmento.
Al hacerlo, se muestra información sobre cada nodo, incluido el punto de conexión de cada nodo que debe utilizar para leer datos del clúster.
1. Para ver las métricas, elija la pestaña **Metrics** (Métricas), que muestra las métricas pertinentes de todos los nodos del clúster. Para obtener más información, consulte [Supervisión del uso con CloudWatch métricas](CacheMetrics.md)
1. Para ver los registros, elija la pestaña **Logs** (Registros), que indica si el clúster utiliza registros lentos o registros del motor y proporciona los detalles pertinentes. Para obtener más información, consulte [Entrega de registro](Log_Delivery.md).
1. Elija la pestaña **Network and security** (Red y seguridad) para ver los detalles sobre la configuración de la conectividad de red y el grupo de subredes del clúster, el grupo de seguridad de la VPC y qué, si lo hay, método de cifrado está habilitado en el clúster. Para obtener más información, consulte [Subredes y grupos de subredes](SubnetGroups.md) y [Seguridad de datos en Amazon ElastiCache](encryption.md).
1. Elija la pestaña **Maintenance** (Mantenimiento) para ver los detalles en la configuración de mantenimiento del clúster. Para obtener más información, consulte [Administración del mantenimiento de clústeres de ElastiCache](maintenance-window.md).
1. Elija la pestaña **Service updates** (Actualizaciones de servicio) para ver los detalles de las actualizaciones de servicio disponibles junto con la fecha de caducidad recomendada. Para obtener más información, consulte [Actualizaciones de servicios en ElastiCache](Self-Service-Updates.md).
1. Elija la pestaña **Tags** (Etiquetas) para ver los detalles de las etiquetas aplicadas a los recursos del clúster. Para obtener más información, consulte [Etiquetar sus recursos ElastiCache](Tagging-Resources.md).
## Visualización de los detalles de un clúster de ElastiCache (AWS CLI)
El siguiente código muestra los detalles para *my-cluster*:
```
aws elasticache describe-cache-clusters --cache-cluster-id my-cluster
```
Sustituya *my-cluster* por el nombre del clúster en caso de que el clúster se cree con 1 nodo de caché y 0 particiones mediante el comando `create-cache-cluster`.
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"Engine": "redis",
"PreferredMaintenanceWindow": "wed:12:00-wed:13:00",
"CacheSubnetGroupName": "default",
"SnapshotWindow": "08:30-09:30",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"CacheClusterId": "my-cluster1",
"CacheClusterCreateTime": "2018-02-26T21:06:43.420Z",
"PreferredAvailabilityZone": "us-west-2c",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"AutoMinorVersionUpgrade": true,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
]
}
```
En un caso en el que el clúster se cree mediante la Consola de administración de AWS (nodo de clúster habilitado o desactivado con 1 o más particiones), utilice el siguiente comando para describir los detalles del clúster (sustituya *my-cluster* por el nombre del grupo de replicación (nombre del clúster):
```
aws elasticache describe-replication-groups --replication-group-id my-cluster
```
Para obtener más información, consulte la AWS CLI para el tema de ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
## Visualización de los detalles de un clúster de ElastiCache (API de ElastiCache)
Puede ver los detalles de un clúster con la acción `DescribeCacheClusters` de la API de ElastiCache. Si se incluye el parámetro `CacheClusterId`, se devolverán detalles del clúster especificado. Si el parámetro `CacheClusterId` se omite, se devolverán los detalles de hasta `MaxRecords` clústeres (el valor predeterminado es 100). El valor de `MaxRecords` no puede ser inferior a 20 ni superior a 100.
El siguiente código enumera los detalles de `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
El siguiente código enumera los detalles de hasta 25 clústeres.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Para obtener más información, consulte el tema de referencia de la API de ElastiCache [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html).
# Modificación de un clúster de ElastiCache
Además de añadir o quitar nodos de un clúster de ElastiCache, puede que haya veces en las que necesite realizar otros cambios, como, por ejemplo, añadir un grupo de seguridad o cambiar el periodo de mantenimiento o un grupo de parámetros.
Recomendamos que el periodo de mantenimiento corresponda al momento de mínimo uso. Esto puede requerir alguna modificación de vez en cuando.
Cuando se modifican los parámetros de un clúster, el cambio se aplica al clúster inmediatamente o después de reiniciarlo. Esto es cierto tanto si se modifica el propio grupo de parámetros del clúster como si se modifica el valor de un parámetro del grupo. Para determinar cuándo se aplica un cambio de parámetros determinado, consulte la sección **Aplicación de los cambios** de la columna **Detalles** en las tablas para [Parámetros específicos de Memcached](ParameterGroups.Engine.md#ParameterGroups.Memcached) y [Parámetros de Valkey y Redis OSS](ParameterGroups.Engine.md#ParameterGroups.Redis). Para obtener información acerca de cómo reiniciar los nodos de un clúster, consulte [Reinicio de nodos](nodes.rebooting.md).
## Uso de la Consola de administración de AWS de ElastiCache
**Pasos para modificar un clúster**
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 lista de la esquina superior derecha, elija la región de AWS en la que se encuentra el clúster que desea modificar.
1. En el panel de navegación, elija el motor que se ejecuta en el clúster que desea modificar.
Se mostrará una lista de los clústeres del motor elegido.
1. En la lista de clústeres, para el clúster que desea modificar, elija su nombre.
1. Elija **Actions** (Acciones) y después **Modify** (Modificar).
Aparecerá la ventana **Modify Cluster**.
1. En la ventana **Modificar clúster**, haga las modificaciones que desee. Las opciones son:
+ Descripción
+ Modo de clúster: Para modificar el modo de clúster de **desactivado** a **habilitado**, primero debe establecer el modo de clúster en **compatible**.
El modo compatible permite que los clientes de Valkey o Redis OSS se conecten mediante el modo clúster habilitado y el modo clúster desactivado. Después de migrar todos los clientes de Valkey o Redis OSS para usar el modo de clúster habilitado, puede completar la configuración del modo de clúster y establecer el modo de clúster en **Habilitado**.
+ Compatibilidad de la versión del motor
**importante**
Puede actualizar a versiones de motor más recientes. Si actualiza las versiones principales del motor, por ejemplo de 5.0.6 a 6.0, debe seleccionar una familia de grupos de parámetros que sea compatible con la versión del motor nueva. Para obtener más información sobre cómo hacerlo, consulte [Administración de versiones para ElastiCache](VersionManagement.md). Sin embargo, no se puede volver a versiones del motor anteriores, salvo si se elimina el clúster existente y se vuelve a crear.
+ Grupos de seguridad de VPC.
+ Grupo de parámetros
+ Tipo de nodo
**nota**
Si el clúster utiliza un tipo de nodo de la familia r6gd, solo puede elegir un tamaño de nodo diferente dentro de esa familia. Si elige un tipo de nodo de la familia r6gd, la organización de datos en niveles se activará automáticamente. Para obtener más información, consulte [Organización de datos en niveles](data-tiering.md).
+ Multi-AZ
+ Conmutación por error automática (solo modo de clúster deshabilitado)
+ Habilitar copias de seguridad automáticas
+ ID del nodo de copia de seguridad
+ Backup Retention Period
+ Periodo de copia de seguridad
+ Tema para la notificación de SNS
+ Compatibilidad de la versión del motor de Memcached
+ Tipo de red
**nota**
Si va a cambiar de IPv4 a IPv6, debe seleccionar o crear grupos de subredes compatibles con IPv6. Para obtener más información, consulte [Elegir un tipo de red en ElastiCache](network-type.md).
+ Grupos de seguridad de VPC.
+ Grupo de parámetros
+ Periodo de mantenimiento
+ Tema para la notificación de SNS
El cuadro **Aplicar inmediatamente** solo se aplica a las modificaciones del tipo de nodo y de versión del motor. Para aplicar los cambios inmediatamente, active la casilla **Apply Immediately (Aplicar inmediatamente)**. Si no se elige esta casilla, las modificaciones en la versión del motor se aplicarán durante el próximo periodo de mantenimiento. Otras modificaciones, como el cambio del periodo de mantenimiento, se aplican inmediatamente.
**Habilitación/deshabilitación de la entrega de registros para Redis**
1. En la lista de clústeres, elija el clúster que desea modificar. Elija el **Cluster name** (Nombre del clúster) y no la casilla de verificación al lado.
1. En la página **Detalles del clúster**, seleccione la pestaña **Registros**.
1. Para habilitar/deshabilitar los registros lentos, elija **Habilitar** o **Deshabilitar**.
Si elige habilitar:
1. En **Log format** (Formato de registro), elija **Text** (Texto) o **JSON**.
1. En **Log destination Type** (Tipo de destino de registro), elija **CloudWatch Logs** o **Kinesis Firehose**.
1. En **Destino del registro**, elija **Crear nuevo** e introduzca el nombre del grupo de registro de Registros de CloudWatch o el nombre del flujo de Kinesis Data Firehose. O elija **Seleccionar existente** y, a continuación, elija el nombre del grupo de registros de Registros de CloudWatch o el nombre del flujo de Kinesis Data Firehose.
1. Seleccione **Habilitar**.
**Cambio de su configuración para Redis**
1. Elija **Modificar**.
1. En **Log format** (Formato de registro), elija **Text** (Texto) o **JSON**.
1. En **Destination Type** (Tipo de destino), elija **CloudWatch Logs** o **Kinesis Firehose**.
1. En **Log destination** (Destino del registro), elija **Create new** (Crear nuevo) e ingrese el nombre del grupo de registro de CloudWatchLogs o el nombre de la secuencia de Kinesis Data Firehose. O elija **Select existing** (Seleccionar existente) y, a continuación, elija el nombre del grupo de registro de CloudWatchLogs o el nombre de la secuencia de Kinesis Data Firehose.
## Uso de la AWS CLI con ElastiCache
Puede modificar un clúster existente con la operación AWS CLI de `modify-cache-cluster`. Para modificar un valor de configuración de un clúster, especifique el ID del clúster, el parámetro que desea cambiar y el nuevo valor del parámetro. El siguiente ejemplo cambia el periodo de mantenimiento de un clúster denominado `my-cluster` y aplica el cambio inmediatamente.
**importante**
Puede actualizar a versiones del motor más recientes de Memcached. Para obtener más información sobre cómo hacerlo, consulte [Administración de versiones para ElastiCache](VersionManagement.md). Sin embargo, no se puede volver a versiones del motor anteriores, salvo si se elimina el clúster existente y se vuelve a crear.
**importante**
Puede actualizar a versiones del motor más recientes de Valkey o Redis OSS. Si actualiza las versiones principales del motor, por ejemplo de Redis OSS 5.0.6 a Redis OSS 6.0, debe seleccionar una familia de grupos de parámetros que sea compatible con la versión del motor nueva. Para obtener más información sobre cómo hacerlo, consulte [Administración de versiones para ElastiCache](VersionManagement.md). Sin embargo, no se puede volver a versiones del motor anteriores, salvo si se elimina el clúster existente y se vuelve a crear.
Para Linux, macOS o Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Para Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
El parámetro `--apply-immediately` solo se aplica a modificaciones en el tipo de nodo, la versión del motor y el número de nodos de un clúster. Si desea aplicar cualquiera de estos cambios de forma inmediata, utilice el parámetro `--apply-immediately`. Si prefiere aplazar estos cambios al siguiente periodo de mantenimiento, utilice el parámetro `--no-apply-immediately`. Otras modificaciones, como el cambio del periodo de mantenimiento, se aplican inmediatamente.
Para obtener más información, consulte la AWS CLI para el tema de ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Uso de la API de ElastiCache
Puede modificar un clúster existente con la operación `ModifyCacheCluster` de la API de ElastiCache. Para modificar un valor de configuración de un clúster, especifique el ID del clúster, el parámetro que desea cambiar y el nuevo valor del parámetro. El siguiente ejemplo cambia el periodo de mantenimiento de un clúster denominado `my-cluster` y aplica el cambio inmediatamente.
**importante**
Puede actualizar a versiones del motor más recientes de Memcached. Para obtener más información sobre cómo hacerlo, consulte [Administración de versiones para ElastiCache](VersionManagement.md). Sin embargo, no se puede volver a versiones del motor anteriores, salvo si se elimina el clúster existente y se vuelve a crear.
**importante**
Puede actualizar a versiones del motor más recientes de Valkey o Redis OSS. Si actualiza las versiones principales del motor, por ejemplo de Redis OSS 5.0.6 a Redis OSS 6.0, debe seleccionar una familia de grupos de parámetros que sea compatible con la versión del motor nueva. Para obtener más información sobre cómo hacerlo, consulte [Administración de versiones para ElastiCache](VersionManagement.md). Sin embargo, no se puede volver a versiones del motor anteriores, salvo si se elimina el clúster existente y se vuelve a crear.
Se agregan saltos de línea para facilitar la lectura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150901T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150901T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
El parámetro `ApplyImmediately` solo se aplica a modificaciones en el tipo de nodo, la versión del motor y el número de nodos de un clúster. Si desea aplicar cualquiera de estos cambios de forma inmediata, establezca el parámetro `ApplyImmediately` en `true`. Si prefiere aplazar estos cambios al siguiente periodo de mantenimiento, establezca el parámetro `ApplyImmediately` en `false`. Otras modificaciones, como el cambio del periodo de mantenimiento, se aplican inmediatamente.
Para obtener más información, consulte el tema de referencia de la API de ElastiCache [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Añadir nodos a un ElastiCache clúster
Si se agregan nodos a un clúster de Memcached, se incrementa el número de particiones del clúster. Cuando se modifica el número de particiones de un clúster, algunos de los espacios de claves deben reasignarse para que se correspondan con el nodo adecuado. Si los espacios de clave se reasignan temporalmente, aumentará el número de errores de caché en el clúster. Para obtener más información, consulte [Configuración de su ElastiCache cliente para un equilibrio de carga eficiente (Memcached)](BestPractices.LoadBalancing.md).
Para volver a configurar el clúster de Valkey o Redis OSS (modo de clúster habilitado), consulte [Escalado de clústeres de Valkey o Redis OSS (modo de clúster habilitado)](scaling-redis-cluster-mode-enabled.md).
Puede usar la consola ElastiCache de administración, la ElastiCache API AWS CLI o la API para agregar nodos al clúster.
## Usando el ElastiCache Consola de administración de AWS
Si desea añadir un nodo a un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) de un solo nodo (uno sin la replicación habilitada), el proceso conlleva dos pasos: en primer lugar, añadir la replicación y, a continuación, añadir un nodo de réplica.
**Temas**
+ [Adición de replicación a un clúster de Valkey o Redis OSS sin particiones](#AddReplication.CON)
+ [Para añadir nodos a un ElastiCache clúster (consola)](#AddNode.CON)
El siguiente procedimiento añade la replicación a un clúster de Valkey o Redis OSS de un solo nodo sin la replicación habilitada. Al agregar la reproducción, el nodo existente se convierte en el nodo principal en el clúster con la reproducción habilitada. Tras agregar la reproducción, puede agregar hasta 5 nodos de réplica al clúster.
**Adición de replicación a un clúster de Valkey o Redis OSS sin particiones**
1. Inicie sesión en Consola de administración de AWS y abra la ElastiCache consola en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación, elija **Clústeres de Valkey** o **Clústeres de Redis OSS**.
Se mostrará una lista de clústeres que ejecutan el motor.
1. Elija el nombre de un clúster al que desea agregar nodos, pero no la casilla situada a la izquierda del nombre del clúster.
En un clúster de Redis OSS que no tiene la replicación habilitada, se dan las siguientes condiciones:
+ Ejecuta Redis OSS, no Redis OSS en clúster.
+ No tiene ningún fragmento.
Si el clúster tiene algún fragmento, la reproducción ya está habilitada y podrá continuar con [Para añadir nodos a un ElastiCache clúster (consola)](#AddNode.CON).
1. Seleccione **Add replication** (Agregar reproducción).
1. En **Agregar reproducción**, escriba una descripción para este clúster con la reproducción habilitada.
1. Elija **Añadir**.
Cuando el estado del clúster vuelva a ser *available*, podrá continuar con el siguiente procedimiento y agregar réplicas al clúster.
**Para añadir nodos a un ElastiCache clúster (consola)**
El siguiente procedimiento se puede utilizar para agregar nodos a un clúster.
1. Inicie sesión en Consola de administración de AWS y abra la ElastiCache consola en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el panel de navegación, elija el motor que se ejecuta en el clúster en el que desea agregar nodos.
Se mostrará una lista de los clústeres que ejecutan el motor elegido.
1. En la lista de clústeres, para el clúster al que desea agregar un nodo, elija su nombre.
Si el clúster es un clúster de Valkey o Redis OSS (modo de clúster habilitado), consulte [Escalado de clústeres de Valkey o Redis OSS (modo de clúster habilitado)](scaling-redis-cluster-mode-enabled.md).
Si el clúster es un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) sin particiones, en primer lugar, complete los pasos de [Adición de replicación a un clúster de Valkey o Redis OSS sin particiones](#AddReplication.CON).
1. Elija **Add node** (Agregar nodo).
1. Rellene la información que se solicita en el cuadro de diálogo **Add Node** (Agregar nodo).
1. Seleccione el botón **Apply Immediately - Yes** (Aplicar inmediatamente: sí) para aplicar este cambio de inmediato o seleccione **No** para aplazar el cambio hasta el próximo periodo de mantenimiento del clúster.
**Impacto de las nuevas solicitudes de adición y eliminación en las solicitudes pendientes**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/Clusters.AddNode.html)
Para determinar qué operaciones se encuentran pendientes, elija la pestaña de **Description** (Descripción) y verifique cuántas creaciones o eliminaciones pendientes se muestran. No puede tener creaciones y eliminaciones pendientes al mismo tiempo.
1. Seleccione el botón **Add** (Agregar).
Después de unos minutos, los nuevos nodos deberían aparecer en la lista de nodos con el estado **creating**. Si no aparecen, actualice página del navegador. Cuando el estado cambie a nodo *disponible* el nuevo nodo puede usarse.
## Usando el AWS CLI con ElastiCache
Para añadir nodos a un clúster mediante el AWS CLI, utilice la AWS CLI operación `modify-cache-cluster` con los siguientes parámetros:
+ `--cache-cluster-id` El ID del clúster al que desea agregar nodos.
+ `--num-cache-nodes` El parámetro `--num-cache-nodes` especifica el número de nodos que desea en este clúster una vez aplicada la modificación. Para añadir nodos a este clúster, el valor de `--num-cache-nodes` debe ser mayor que el número actual de nodos en este clúster. Si este valor es inferior al número actual de nodos, se ElastiCache espera que el parámetro `cache-node-ids-to-remove` y una lista de nodos se eliminen del clúster. Para obtener más información, consulte [Usando el con AWS CLI ElastiCache](Clusters.DeleteNode.md#Clusters.DeleteNode.CLI).
+ `--apply-immediately` o `--no-apply-immediately`, que especifica si desea añadir estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
Para Linux, macOS o Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--num-cache-nodes 5 \
--apply-immediately
```
Para Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--num-cache-nodes 5 ^
--apply-immediately
```
Esta operación produce un resultado similar al siguiente (formato JSON):
```
{
"CacheCluster": {
"Engine": "memcached",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "my-cluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "rlh-mem000.7alc7bf-example.cfg.usw2.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-21T16:28:28.973Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {
"NumCacheNodes": 5
},
"PreferredMaintenanceWindow": "sat:09:00-sat:10:00",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
}
}
```
Para obtener más información, consulte el AWS CLI tema [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Uso del AWS CLI con ElastiCache
Si desea añadir nodos a un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) existente que no tiene la replicación habilitada, primero debe crear el grupo de replicación y establecer el clúster existente como principal. Para obtener más información, consulte [Creación de un grupo de replicación mediante un clúster de Valkey o Redis OSS disponible (AWS CLI)](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.CLI). Una vez que el estado del grupo de replicación sea *available*, puede continuar con el siguiente proceso.
Para añadir nodos a un clúster mediante el AWS CLI, utilice la AWS CLI operación `increase-replica-count` con los siguientes parámetros:
+ `--replication-group-id`: el ID del grupo de reproducción al que desea agregar nodos.
+ `--new-replica-count` especifica el número de nodos que desea en este grupo de reproducción una vez que se aplica la modificación. Para añadir nodos a este clúster, el valor de `--new-replica-count` debe ser mayor que el número actual de nodos en este clúster.
+ `--apply-immediately` o `--no-apply-immediately`, que especifica si desea añadir estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
Para Linux, macOS o Unix:
```
aws elasticache increase-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 4 \
--apply-immediately
```
Para Windows:
```
aws elasticache increase-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 4 ^
--apply-immediately
```
Esta operación produce un resultado similar al siguiente (formato JSON):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test",
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Para obtener más información, consulte el AWS CLI tema [https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html).
## Uso de la ElastiCache API
Si desea añadir nodos a un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) existente que no tiene la replicación habilitada, primero debe crear el grupo de replicación y establecer el clúster existente como principal. Para obtener más información, consulte [Añadir réplicas a un clúster (API) independiente de Valkey o Redis OSS (modo de clúster desactivado) ElastiCache](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.API). Una vez que el estado del grupo de replicación sea *available*, puede continuar con el siguiente proceso.
**Para añadir nodos a un clúster (ElastiCache API)**
+ Realice una llamada a la operación API `IncreaseReplicaCount` con los parámetros siguientes:
+ `ReplicationGroupId` El ID del clúster al que desea agregar nodos.
+ `NewReplicaCount` El parámetro `NewReplicaCount` especifica el número de nodos que desea en este clúster una vez aplicada la modificación. Para añadir nodos a este clúster, el valor de `NewReplicaCount` debe ser mayor que el número actual de nodos en este clúster. Si este valor es menor que el número actual de nodos, utilice la API `DecreaseReplicaCount` con el número de nodos que se debe quitar del clúster.
+ `ApplyImmediately` especifica si desea añadir estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
+ `Region`Especifica la AWS región del clúster a la que desea agregar nodos.
En el siguiente ejemplo se muestra una llamada para añadir nodos a un clúster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=true
&NumCacheNodes=4
&ReplicationGroupId=my-replication-group
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obtener más información, consulte el tema ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html).
## Uso de la ElastiCache API
**Para añadir nodos a un clúster (ElastiCache API)**
+ Realice una llamada a la operación API `ModifyCacheCluster` con los parámetros siguientes:
+ `CacheClusterId` El ID del clúster al que desea agregar nodos.
+ `NumCacheNodes` El parámetro `NumCachNodes` especifica el número de nodos que desea en este clúster una vez aplicada la modificación. Para añadir nodos a este clúster, el valor de `NumCacheNodes` debe ser mayor que el número actual de nodos en este clúster. Si este valor es inferior al número actual de nodos, se ElastiCache espera que el parámetro `CacheNodeIdsToRemove` con una lista de nodos se elimine del clúster (consulte[Uso de la ElastiCache API con Memcached](Clusters.DeleteNode.md#Clusters.DeleteNode.API)).
+ `ApplyImmediately` especifica si desea añadir estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
+ `Region`Especifica la AWS región del clúster a la que desea agregar nodos.
En el siguiente ejemplo se muestra una llamada para añadir nodos a un clúster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&NumCacheNodes=5
&CacheClusterId=my-cluster
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obtener más información, consulte el tema ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Eliminar nodos de un ElastiCache clúster
Puede eliminar un nodo de un clúster OSS de Valkey, Memcached o Redis mediante la Consola de administración de AWS, la o la API AWS CLI. ElastiCache
**nota**
Cada vez que cambie el número de nodos de un clúster de Memcached, debe volver a asignar al menos algunos de su espacio de claves para que se asocien al nodo correcto. Para obtener información más detallada sobre cómo equilibrar la carga de un clúster de Memcached, consulte [Configuración de su ElastiCache cliente para un equilibrio de carga eficiente (Memcached)](BestPractices.LoadBalancing.md).
## Mediante el ElastiCache Consola de administración de AWS
**Para eliminar nodos de un clúster (consola)**
1. Inicie sesión en Consola de administración de AWS y abra la ElastiCache consola en [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En la lista de la esquina superior derecha, selecciona la AWS región del clúster de la que quieres eliminar los nodos.
1. En el panel de navegación, elija el motor que se ejecuta en el clúster del que desea quitar un nodo.
Se mostrará una lista de los clústeres que ejecutan el motor elegido.
1. En la lista de clústeres, elija el nombre del clúster del que desea quitar un nodo.
Aparecerá una lista de nodos del clúster.
1. Elija la casilla situada a la izquierda del ID del nodo que desee quitar. Con la consola de ElastiCache , solo puede eliminar un nodo a la vez, por lo que elegir varios nodos significa que no puede usar el botón **Eliminar nodo**.
Aparecerá la página *Eliminar nodo*.
1. Para eliminar el nodo, complete la página **Eliminar nodo** y elija **Eliminar nodo**. Para mantener el nodo, elija **Cancelar**.
**importante**
Con Valkey o Redis OSS, si va a eliminar los resultados de los nodos del clúster que ya no son compatibles con multi-AZ, asegúrese de desactivar primero la casilla de verificación **Multi-AZ** y, a continuación, elimine el nodo. Si desactiva la casilla de verificación **Multi-AZ** puede elegir habilitar la **Conmutación por error automática**.
**Impacto de las nuevas solicitudes de adición y eliminación en las solicitudes pendientes**
| Escenarios | Operación pendiente | Solicitud nueva | Resultados |
| --- | --- | --- | --- |
| Escenario 1 | Eliminar | Eliminar | La nueva solicitud de eliminación, pendiente o inmediata, reemplaza a la solicitud de eliminación pendiente. Por ejemplo, si los nodos 0001, 0003 y 0007 se encuentran pendientes de eliminación y se emite una solicitud nueva para eliminar los nodos 0002 y 0004, solo se eliminarán los nodos 0002 y 0004. Los nodos 0001, 0003 y 0007 no se eliminarán. |
| Escenario 2 | Eliminar | Crear | La nueva solicitud de creación, pendiente o inmediata, reemplaza a la solicitud de eliminación pendiente. Por ejemplo, si los nodos 0001, 0003 y 0007 se encuentran pendientes de eliminación y se emite una solicitud nueva para crear un nodo, se creará un nodo nuevo y no se eliminarán los nodos 0001, 0003 y 0007. |
| Escenario 3 | Crear | Eliminar | La nueva solicitud de eliminación, pendiente o inmediata, reemplaza a la solicitud de creación pendiente. Por ejemplo, si hay una solicitud pendiente para crear dos nodos y se emite una solicitud nueva para eliminar el nodo 0003, no se crearán nodos nuevos y se eliminará el nodo 0003. |
| Escenario 4 | Crear | Crear | La nueva solicitud de creación se agrega a la solicitud de creación pendiente. Por ejemplo, si hay una solicitud pendiente para crear dos nodos y se emite una solicitud nueva para crear tres nodos, las solicitudes nuevas se agregarán a la solicitud pendiente y se crearán cinco nodos. Si la nueva solicitud de creación se establece en **Apply Immediately - Yes** (Aplicar de inmediato: sí), todas las solicitudes de creación se ejecutan de inmediato. Si la nueva solicitud de creación se establece en **Apply Immediately - No** (Aplicar de inmediato: no), todas las solicitudes de creación quedarán pendientes. |
Para determinar qué operaciones se encuentran pendientes, elija la pestaña de **Description** (Descripción) y verifique cuántas creaciones o eliminaciones pendientes se muestran. No puede tener creaciones y eliminaciones pendientes al mismo tiempo.
## Usando el con AWS CLI ElastiCache
1. Identifique IDs los nodos que desea eliminar. Para obtener más información, consulte [Visualización de los detalles de un clúster de ElastiCache](Clusters.ViewDetails.md).
1. Utilice la operación `decrease-replica-count` de la CLI con una lista de los nodos que desea quitar, como en el siguiente ejemplo.
Para quitar nodos de un clúster a través de la interfaz de línea de comandos, utilice el comando `decrease-replica-count` con los siguientes parámetros:
+ `--replication-group-id`: el ID del grupo de reproducción del que desea eliminar nodos.
+ `--new-replica-count` El parámetro `--new-replica-count` especifica el número de nodos que desea en este clúster una vez aplicada la modificación.
+ `--replicas-to-remove`Una lista de los nodos IDs que desea eliminar de este clúster.
+ `--apply-immediately` o `--no-apply-immediately` especifican si desea quitar estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
+ `--region`Especifica la AWS región del clúster de la que desea eliminar los nodos.
**nota**
Solo puede pasar uno de los parámetros `--replicas-to-remove` o `--new-replica-count` al llamar a esta operación.
Para Linux, macOS o Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 2 \
--region us-east-2 \
--apply-immediately
```
Para Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 3 ^
--region us-east-2 ^
--apply-immediately
```
Esta operación produce un resultado similar al siguiente (formato JSON):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test"
},
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005",
"node-test-006"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test-ro.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-004",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-004.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-005",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-005.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-006",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-006.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
También puede llamar a `decrease-replica-count` y en lugar de pasar el parámetro `--new-replica-count`, podría pasar el parámetro `--replicas-to-remove`, como se muestra a continuación:
Para Linux, macOS o Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--replicas-to-remove node-test-003 \
--region us-east-2 \
--apply-immediately
```
Para Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--replicas-to-remove node-test-003 ^
--region us-east-2 ^
--apply-immediately
```
Para obtener más información, consulte los AWS CLI temas [https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html).
## Uso de la ElastiCache API con Valkey o Redis OSS
Para eliminar nodos mediante la ElastiCache API, llame a la operación de la `DecreaseReplicaCount` API con el ID del grupo de replicación y una lista de los nodos que desee eliminar, como se muestra a continuación:
+ `ReplicationGroupId`: el ID del grupo de reproducción del que desea eliminar nodos.
+ `ReplicasToRemove` El parámetro `ReplicasToRemove` especifica el número de nodos que desea en este clúster una vez aplicada la modificación.
+ `ApplyImmediately` especifica si desea quitar estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
+ `Region`Especifica la AWS región del clúster de la que desea eliminar un nodo.
En el ejemplo siguiente, se quitan de inmediato los nodos 0004 y 0005 del clúster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ReplicationGroupId=my-replication-group
&ApplyImmediately=true
&ReplicasToRemove=node-test-003
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obtener más información, consulte el tema ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html).
## Uso de la ElastiCache API con Memcached
Para eliminar nodos mediante la ElastiCache API, llame a la operación de la `ModifyCacheCluster` API con el ID del clúster de caché y una lista de los nodos que desee eliminar, como se muestra a continuación:
+ `CacheClusterId` El ID del clúster del que desea quitar nodos.
+ `NumCacheNodes` El parámetro `NumCacheNodes` especifica el número de nodos que desea en este clúster una vez aplicada la modificación.
+ `CacheNodeIdsToRemove.member.n`La lista de nodos IDs que se van a eliminar del clúster.
+ `CacheNodeIdsToRemove.member.1=0004`
+ `CacheNodeIdsToRemove.member.1=0005`
+ `ApplyImmediately` especifica si desea quitar estos nodos de forma inmediata o durante el próximo periodo de mantenimiento.
+ `Region`Especifica la AWS región del clúster de la que desea eliminar un nodo.
En el ejemplo siguiente, se quitan de inmediato los nodos 0004 y 0005 del clúster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&ApplyImmediately=true
&CacheNodeIdsToRemove.member.1=0004
&CacheNodeIdsToRemove.member.2=0005
&NumCacheNodes=3
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Para obtener más información, consulte el tema ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Cancelación de operaciones pendientes de adición o eliminación de nodos en ElastiCache
Si ha optado por no aplicar un cambio de clúster de ElastiCache de forma inmediata, la operación tiene el estado **Pendiente** hasta que se realice en el próximo periodo de mantenimiento. Puede cancelar cualquier operación de adición o eliminación pendiente.
Para cancelar una operación para añadir o eliminar nodos que haya quedado pendiente en la AWS CLI, utilice el comando `modify-cache-cluster`. Establezca `num-cache-nodes` igual al número actual de nodos de caché del clúster y, a continuación, añada el indicador `--apply-immediately`. Esto anulará el cambio pendiente.
Para cancelar la adición o eliminación de un nodo pendiente:
```
aws elasticache modify-cache-cluster
--cache-cluster-id
--num-cache-nodes
--apply-immediately
```
Si no está claro si las adiciones o eliminaciones de nodos están pendientes, puede confirmar su estado con el comando `describe-cache-clusters`:
```
aws elasticache describe-cache-clusters
--cache-cluster-id
```
Todos los nodos pendientes deberían aparecer en la salida `PendingModifiedValues`. Por ejemplo:
```
"PendingModifiedValues": {
"NumCacheNodes": 3
},
```
# Eliminar un clúster en ElastiCache
Mientras un ElastiCache clúster esté en estado *disponible*, se le cobrará por él, independientemente de que lo utilice activamente o no. Para que dejen de devengarse cargos, elimine el clúster.
**aviso**
Al eliminar un ElastiCache clúster, se conservan las instantáneas manuales. También puede crear una instantánea final antes de eliminar el clúster. Por el contrario, las instantáneas de caché automáticas no se conservan.
## Usando el Consola de administración de AWS
El siguiente procedimiento elimina un único clúster de su implementación. Para eliminar varios clústeres, repita el procedimiento por cada clúster que desee eliminar. No es necesario esperar a un clúster para terminar de eliminarlo antes de empezar el procedimiento para eliminar otro clúster.
**Para eliminar un clúster**
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el ElastiCache panel de control del motor, selecciona el motor que se está ejecutando en el clúster que deseas eliminar.
Se mostrará una lista de todos los clústeres que ejecutan ese motor.
1. Para elegir el clúster que se va a eliminar, elija el nombre del clúster de la lista de clústeres.
**importante**
Solo puede eliminar un clúster a la vez desde la ElastiCache consola. Al elegir varios clústeres, se deshabilita la operación de eliminación.
1. En **Actions (Acciones)**, seleccione **Delete (Eliminar)**.
1. En la pantalla de confirmación **Delete Cluster (Eliminar clúster)**, elija **Delete (Eliminar)** para eliminar el clúster o elija **Cancel (Cancelar)** para conservarlo.
Si elige **Delete**, el estado del clúster cambia a *deleting*.
En cuanto el clúster desaparezca de la lista de clústeres, dejará de incurrir en gastos.
## Utilización de AWS CLI para eliminar un ElastiCache clúster
El código siguiente elimina el ElastiCache clúster`my-cluster`.
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
La acción `delete-cache-cluster` de la CLI solo elimina un clúster. Para eliminar varios clústeres, llame a `delete-cache-cluster` por cada clúster de caché que desee eliminar. No es necesario esperar a que se termine de eliminar un clúster antes de eliminar otro.
Para Linux, macOS o Unix:
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
Para Windows:
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
Para obtener más información, consulte el ElastiCache tema AWS CLI[https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html)for.
## Uso de la ElastiCache API
El código siguiente elimina el clúster `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheCluster
&CacheClusterId=my-cluster
&Region us-east-2
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150202T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
La operación de API `DeleteCacheCluster` solo elimina un clúster. Para eliminar varios clústeres, llame a `DeleteCacheCluster` por cada clúster que desee eliminar. No es necesario esperar a que se termine de eliminar un clúster antes de eliminar otro.
Para obtener más información, consulta el tema de referencia de la ElastiCache API [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html).
# Acceso a su ElastiCache clúster o grupo de replicación
Tus ElastiCache instancias de Amazon están diseñadas para que puedas acceder a ellas a través de una EC2 instancia de Amazon.
Si lanzó la ElastiCache instancia en una Amazon Virtual Private Cloud (Amazon VPC), puede acceder a la ElastiCache instancia desde una instancia de Amazon en la EC2 misma Amazon VPC. O bien, mediante la interconexión de VPC, puedes acceder a tu ElastiCache instancia desde una Amazon EC2 en una Amazon VPC diferente.
Si lanzaste tu ElastiCache instancia en EC2 Classic, permites que la EC2 instancia acceda a tu clúster al conceder al grupo de EC2 seguridad de Amazon asociado a la instancia acceso a tu grupo de seguridad de caché. De forma predeterminada, el acceso a un clúster está restringido a la cuenta que lanzó el clúster.
**Topics**
+ [Conceder acceso al clústero al grupo de reproducción](#grant-access)
## Conceder acceso al clústero al grupo de reproducción
### Lanzó su clúster en EC2 -VPC
Si lanzó el clúster en una Amazon Virtual Private Cloud (Amazon VPC), solo podrá conectarse al ElastiCache clúster desde una EC2 instancia de Amazon que se ejecute en la misma Amazon VPC. En este caso, necesitará conceder acceso de red al clúster.
**nota**
Si utiliza *Local Zones*, asegúrese de haberlo habilitado. Para obtener más información, consulte [Habilitar Local Zones](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/using-regions-availability-zones.html#opt-in-local-zone). Al hacerlo, la VPC se extiende a esa zona local y tratará la subred como cualquier subred en cualquier otra zona de disponibilidad. Las gateways relevantes, las tablas de enrutamiento y otras consideraciones del grupo de seguridad se ajustarán de forma automática.
**Para conceder acceso de red desde un grupo de seguridad de Amazon VPC a un clúster**
1. Inicia sesión en la EC2 consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el panel de navegación, en **Network & Security** (Redes y seguridad), seleccione **Security Groups**(Grupos de seguridad).
1. En la lista de grupos de seguridad, elija el grupo de seguridad para su Amazon VPC. A menos que hayas creado un grupo de seguridad para ElastiCache su uso, este grupo de seguridad se denominará *predeterminado*.
1. Elija la pestaña **Inbound** y haga lo siguiente:
1. Elija **Editar**.
1. Seleccione **Agregar regla**.
1. En la columna **Type**, elija **Custom TCP rule**.
1. En el cuadro **Port range**, escriba el número de puerto para su nodo de clúster. Este número debe ser el mismo que especificó cuando lanzó el clúster. El puerto predeterminado para Memcached es **11211**. El puerto predeterminado para Valkey y Redis OSS es **6379**.
1. En el cuadro **Fuente**, selecciona Cualquier **lugar** que tenga el rango de puertos (0.0.0.0/0) para que cualquier EC2 instancia de Amazon que lances dentro de tu Amazon VPC pueda conectarse a tus nodos. ElastiCache
**importante**
Abrir el ElastiCache clúster a 0.0.0.0/0 no lo expone a Internet porque no tiene una dirección IP pública y, por lo tanto, no se puede acceder a él desde fuera de la VPC. Sin embargo, el grupo de seguridad predeterminado se puede aplicar a otras EC2 instancias de Amazon en la cuenta del cliente y esas instancias pueden tener una dirección IP pública. Si se está ejecutando algo en el puerto predeterminado, ese servicio podría exponerse de forma involuntaria. Por lo tanto, recomendamos crear un grupo de seguridad de VPC que se use exclusivamente ElastiCache. Para obtener más información, consulte [Grupos de seguridad personalizados](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Seleccione **Save**.
Cuando lances una EC2 instancia de Amazon en tu Amazon VPC, esa instancia podrá conectarse a tu ElastiCache clúster.
### Acceder a ElastiCache los recursos desde el exterior AWS
Amazon ElastiCache es un AWS servicio que proporciona un almacén de valores clave en memoria basado en la nube. El servicio está diseñado para que se pueda acceder exclusivamente desde dentro.AWS Sin embargo, si el ElastiCache clúster está alojado en una VPC, puede usar una instancia de traducción de direcciones de red (NAT) para proporcionar acceso externo.
#### Requisitos
Debe cumplir los siguientes requisitos para poder acceder a sus ElastiCache recursos desde el exterior AWS:
+ El clúster debe estar en una VPC y el acceso debe hacerse a través de una instancia de Traducción de direcciones de red (NAT). Este requisito no tiene excepciones.
+ La instancia NAT debe lanzarse en la misma VPC que el clúster.
+ La instancia NAT debe lanzarse en una subred pública distinta de la del clúster.
+ Es necesario asociar una dirección IP elástica (EIP) a la instancia NAT. La característica de reenvío de puertos de las tablas IP se usa para reenviar un puerto de la instancia NAT al puerto del nodo de caché de la VPC.
#### Consideraciones
Tenga en cuenta las consideraciones siguientes a la hora de acceder a sus recursos de ElastiCache desde fuera de ElastiCache.
+ Los clientes se conectan a la EIP y al puerto de caché de la instancia NAT. El reenvío de puertos de la instancia NAT reenvía el tráfico al nodo de clúster adecuado.
+ Si un nodo del clúster se añade o se reemplaza, las reglas de tablas IP deben actualizarse para reflejar este cambio.
#### Limitaciones
Este enfoque solo debe usarse con fines de prueba y desarrollo. No se recomienda su uso para la producción debido a las limitaciones siguientes:
+ La instancia NAT actúa como proxy entre los clientes y múltiples clústeres. La adición de un proxy afecta al rendimiento del clúster. El impacto aumenta con el número de clústeres a los que se accede mediante la instancia NAT.
+ El tráfico de los clientes a la instancia NAT está sin cifrar. Por lo tanto, debe evitar el envío de información confidencial a través de la instancia NAT.
+ La instancia NAT requiere, además, el mantenimiento de otra instancia.
+ La instancia NAT sirve como único punto de error. Para obtener información acerca de cómo configurar NAT de alta disponibilidad en una VPC, consulte [Alta disponibilidad para instancias NAT de Amazon VPC: un ejemplo](https://aws.amazon.com/articles/2781451301784570).
#### ¿Cómo acceder a ElastiCache los recursos desde el exterior AWS
El siguiente procedimiento muestra cómo conectarse a ElastiCache los recursos mediante una instancia de NAT.
En los pasos que se describen a continuación se da por sentado lo siguiente:
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379`
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379`
A continuación, necesita NAT en la dirección opuesta:
`iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 10.0.0.55`
También debe activar el reenvío de IP, que está desactivado de forma predeterminada:
`sudo sed -i 's/net.ipv4.ip_forward=0/net.ipv4.ip_forward=1/g' /etc/sysctl.conf sudo sysctl --system`
+ Está accediendo a un clúster de Memcached con:
+ Dirección IP: *10.0.1.230*
+ Puerto de Memcached predeterminado: *11 211*
+ Grupo de seguridad: *\$110\$1.0\$1.0\$1.55\$1*
+ Está accediendo a un clúster de Valkey o Redis OSS con:
+ Dirección IP: *10.0.1.230*
+ Puerto predeterminado: *6379*
+ Grupo de seguridad: *sg-bd56b7da*
+ AWS dirección IP de la instancia: *198.99.100.27*
+ El cliente tiene de confianza tiene la dirección IP *198.51.100.27*.
+ La instancia NAT tiene la dirección IP elástica *203.0.113.73*.
+ La instancia NAT tiene el grupo de seguridad *sg-ce56b7a9*.
**Para conectarse a sus ElastiCache recursos mediante una instancia NAT**
1. Cree una instancia NAT en la misma VPC que su clúster, pero en una subred pública.
De forma predeterminada, el asistente de VPC lanzara el tipo de nodo *cache.m1.small*. Seleccione un tamaño de nodo en función de sus necesidades. Debe utilizar la AMI de EC2 NAT para poder acceder ElastiCache desde el exterior AWS.
Para obtener información sobre la creación de una instancia de NAT, consulte [Instancias de NAT](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html) en la Guía del usuario de la AWS VPC.
1. Cree reglas de grupo de seguridad para el clúster y la instancia NAT.
El grupo de seguridad de la instancia NAT y la instancia del clúster deben tener las siguientes reglas:
+ Dos reglas de entrada
+ Con Memcached, la primera regla es permitir las conexiones de TCP desde los clientes de confianza a cada puerto de caché que se reenvía desde la instancia de NAT (11211 - 11213).
+ Con Valkey y Redis OSS, la primera regla es permitir las conexiones de TCP desde los clientes de confianza a cada puerto de caché que se reenvía desde la instancia de NAT (6379 - 6381).
+ Una segunda regla es permitir el acceso de SSH a los clientes de confianza.
**Grupo de seguridad de instancias de NAT: reglas de entrada con Memcached**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/accessing-elasticache.html)
**Grupo de seguridad de instancias de NAT: reglas de entrada con Valkey o Redis OSS**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Memcached, una regla de salida para permitir las conexiones de TCP con el puerto de caché (11211).
**Grupo de seguridad de la instancia NAT: regla saliente**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Valkey o Redis OSS, una regla de salida que permite las conexiones de TCP con el puerto de caché (6379).
**Grupo de seguridad de la instancia NAT: regla saliente**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Memcached, una regla de entrada del grupo de seguridad del clúster que permite conexiones de TCP entre la instancia de NAT y el puerto de caché (11211).
**Grupo de seguridad de la instancia del clúster: regla entrante**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Con Valkey o Redis OSS, una regla de entrada del grupo de seguridad del clúster que permite conexiones de TCP entre la instancia de NAT y el puerto de caché (6379).
**Grupo de seguridad de la instancia del clúster: regla entrante**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/accessing-elasticache.html)
1. Valide las reglas.
+ Confirme que el cliente de confianza es capaz de conectarse mediante SSH a la instancia NAT.
+ Confirme que el cliente de confianza es capaz de conectarse al clúster desde la instancia NAT.
1. **Memcached**
Añada una regla de tablas IP a la instancia NAT.
La regla de tablas de IP deben añadirse a la tabla NAT para que todos los nodos del clúster reenvíen el puerto de caché de la instancia NAT al nodo del clúster. Un ejemplo de esto sería el siguiente:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
```
El número de puerto debe ser único para cada nodo del clúster. Por ejemplo, si trabaja con un clúster de Memcached de tres nodos que usan los puertos 11211 - 11213, las reglas deben ser similares a las que se muestran a continuación:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11212 -j DNAT --to 10.0.1.231:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11213 -j DNAT --to 10.0.1.232:11211
```
Confirme que el cliente de confianza es capaz de conectarse al clúster.
El cliente de confianza deben conectarse a la EIP asociada con la instancia NAT y el puerto del clúster correspondiente al nodo de clúster adecuado. Por ejemplo, la cadena de conexión para PHP puede ser parecida a la siguiente:
```
$memcached->connect( '203.0.113.73', 11211 );
$memcached->connect( '203.0.113.73', 11212 );
$memcached->connect( '203.0.113.73', 11213 );
```
También puede usar un cliente de Telnet para comprobar la conexión. Por ejemplo:
```
telnet 203.0.113.73 11211
telnet 203.0.113.73 11212
telnet 203.0.113.73 11213
```
**Valkey o Redis OSS**
Añada una regla de tablas IP a la instancia NAT.
La regla de tablas de IP deben añadirse a la tabla NAT para que todos los nodos del clúster reenvíen el puerto de caché de la instancia NAT al nodo del clúster. Un ejemplo de esto sería el siguiente:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
```
El número de puerto debe ser único para cada nodo del clúster. Por ejemplo, si trabaja con un clúster de Redis OSS de tres nodos que utiliza los puertos 6379 - 6381, las reglas serían similares a las que se muestran a continuación:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379
```
Confirme que el cliente de confianza es capaz de conectarse al clúster.
El cliente de confianza deben conectarse a la EIP asociada con la instancia NAT y el puerto del clúster correspondiente al nodo de clúster adecuado. Por ejemplo, la cadena de conexión para PHP puede ser parecida a la siguiente:
```
redis->connect( '203.0.113.73', 6379 );
redis->connect( '203.0.113.73', 6380 );
redis->connect( '203.0.113.73', 6381 );
```
También puede usar un cliente de Telnet para comprobar la conexión. Por ejemplo:
```
telnet 203.0.113.73 6379
telnet 203.0.113.73 6380
telnet 203.0.113.73 6381
```
1. Guarde la configuración de tablas IP.
Guarde las reglas tras realizar las pruebas y verificarlas. Si usa una distribución de Linux basada en Redhat (como Amazon Linux) ejecute el comando siguiente:
```
service iptables save
```
#### Temas relacionados
Los temas siguientes pueden ser de su interés.
+ [Patrones de acceso para obtener acceso a una caché de ElastiCache en una Amazon VPC](elasticache-vpc-accessing.md)
+ [Acceso a una caché de ElastiCache desde una aplicación en ejecución en un centro de datos del cliente](elasticache-vpc-accessing.md#elasticache-vpc-accessing-data-center)
+ [Instancias NAT](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+ [Configuración de clientes ElastiCache ](ClientConfig.md)
+ [Alta disponibilidad para instancias NAT de Amazon VPC: un ejemplo](https://aws.amazon.com/articles/2781451301784570)
# Búsqueda de puntos de conexión en ElastiCache
Su aplicación se conecta a su clúster de ElastiCache mediante puntos de conexión. Un punto de conexión es un nodo o la dirección única del clúster.
Puede establecer una conexión privada entre los puntos de conexión de la VPC y la API de ElastiCache mediante la creación de un punto de conexión de VPC de interfaz desde AWS PrivateLink. Para obtener más información, consulte [ElastiCache Puntos finales de VPC de API e interfaz ()AWS PrivateLink](elasticache-privatelink.md).
**Puntos de conexión que se deben usar con Valkey o Redis OSS.**
+ Para el **Nodo independiente**, use el punto de conexión del nodo para las operaciones de lectura y escritura.
+ Para **Clústeres de Valkey o Redis OSS (modo de clúster desactivado)**, utilice el *Punto de conexión principal* para todas las operaciones de escritura. Use el *punto de conexión de lector* para dividir de manera uniforme las conexiones entrantes al punto de enlace entre todas las réplicas de lectura. Use los *puntos de conexión del nodo* para las operaciones de lectura (en la API/CLI, estas se denominan puntos de conexión de lectura).
+ Para **Clústeres de Valkey o Redis OSS (modo de clúster activado)**, utilice el *Punto de conexión de configuración* del clúster para todas las operaciones que admiten comandos del modo de clúster activado. Debe usar un cliente que admita clústeres de Valkey o Redis OSS en Redis OSS 3.2 y versiones posteriores. También podrá realizar operaciones de lectura desde puntos de conexión de nodos individuales (en la API/CLI, estas se denominan puntos de conexión de lectura).
Las secciones siguientes le guiarán en el proceso de detección de los puntos de conexión que necesitará para el motor que esté usando.
**Puntos de conexión que se deben usar con Memcached.**
Para **Caché sin servidor de ElastiCache con Memcached**, basta con adquirir el DNS del punto de conexión del clúster y el puerto desde la consola.
Desde AWS CLI, utilice el comando `describe-serverless-caches` para adquirir información sobre el punto de conexión.
Linux
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Windows
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
La salida de la operación anterior tendrá un aspecto similar al siguiente (formato JSON):
```
{
"ServerlessCaches": [
{
"ServerlessCacheName": "serverless-memcached",
"Description": "test",
"CreateTime": 1697659642.136,
"Status": "available",
"Engine": "memcached",
"MajorEngineVersion": "1.6",
"FullEngineVersion": "21",
"SecurityGroupIds": [
"sg-083eda453e1e51310"
],
"Endpoint": {
"Address": "serverless-memcached-01.amazonaws.com",
"Port":11211
},
"ARN": "",
"SubnetIds": [
"subnet-0cf759df15bd4dc65",
"subnet-09e1307e8f1560d17"
],
"SnapshotRetentionLimit": 0,
"DailySnapshotTime": "03:00"
}
]
}
```
**Para un clúster de Memcached basado en instancias**, si usa la función de detección automática, puede usar el *punto de conexión de configuración* del clúster para configurar el cliente de Memcached. Esto significa que debe usar un cliente que admita la función de detección automática.
Si opta por no usar la función de detección automática, deberá configurar su cliente para usar los puntos de conexión individuales para las operaciones de lectura y escritura. También deberá realizar un seguimiento conforme agregue y elimine nodos.
## Búsqueda de puntos de conexión de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) (consola)
Si un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) solo tiene un nodo, el punto de conexión de dicho nodo se utiliza tanto para las operaciones de lectura como de escritura. Si un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) tiene varios nodos, hay tres tipos de puntos de conexión: el *punto de conexión principal*, el *punto de conexión del lector* y los *puntos de conexión de nodo*.
El punto de conexión principal es un nombre de DNS que siempre se resuelve en el nodo principal del clúster. El punto de conexión principal es inmune a los cambios en el clúster, como la promoción de una réplica de lectura a la función principal. Para una actividad de escritura, recomendamos que sus aplicaciones se conecten al punto de conexión principal.
Un punto de conexión del lector dividirá de manera uniforme las conexiones entrantes al punto de conexión entre todas las réplicas de lectura de un clúster de ElastiCache para Redis OSS. Factores adicionales como cuando la aplicación crea las conexiones o cómo la aplicación (re)utiliza las conexiones determinará la distribución del tráfico. Los puntos de enlace de lector se mantienen actualizados con los cambios del clúster en tiempo real cuando se añaden o eliminan réplicas. Puede colocar las diferentes réplicas de lectura del clúster de ElastiCache para Redis OSS en distintas zonas de disponibilidad (AZ) de AWS para garantizar la alta disponibilidad de los puntos de conexión del lector.
**nota**
Un punto de conexión del lector no es un equilibrador de carga. Se trata de un registro de DNS que se resolverá en una dirección IP de uno de los nodos de réplica en forma de turno rotativo.
Para la actividad de lectura, las aplicaciones pueden conectarse también a cualquier nodo del clúster. A diferencia del punto de conexión principal, los puntos de conexión de nodo se resuelven en puntos de enlace específicos. Si realiza un cambio en su clúster, como añadir o eliminar una réplica, debe actualizar los puntos de enlace del nodo en su aplicación.
**Búsqueda de puntos de conexión de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado)**
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, elija **Clústeres de Valkey** o **Clústeres de Redis OSS**.
Aparecerá la pantalla de clústeres con una lista de clústeres de Valkey o Redis OSS (modo de clúster deshabilitado) y de clústeres de Valkey o Redis OSS (modo de clúster habilitado).
1. Para buscar los puntos de conexión principal o de lector, elija el nombre del clúster (no el botón a su izquierda).
![\[Imagen: punto de conexión principal de un clúster de Valkey o Redis OSS (modo de clúster deshabilitado)\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Puntos de conexión del lector y principal para un clúster de Valkey o Redis OSS (modo de clúster deshabilitado)*
Si el clúster tiene solo un nodo, quiere decir que no hay punto de conexión principal y, por lo tanto, puede continuar con el paso siguiente.
1. Si el clúster de Valkey o Redis OSS (modo de clúster deshabilitado) tiene nodos de réplica, puede encontrar los puntos de conexión del nodo de réplica del clúster eligiendo el nombre del clúster y, a continuación, la pestaña **Nodos**.
Aparecerá la pantalla de nodos con los nodos del clúster, principal y réplicas; cada uno con su punto de conexión.
![\[Imagen: puntos de conexión del nodo para un clúster de Valkey o Redis OSS (modo de clúster deshabilitado)\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Puntos de conexión del nodo para un clúster de Valkey o Redis OSS (modo de clúster deshabilitado)*
1. Para copiar un punto de conexión al portapapeles:
1. Un punto de conexión cada vez, encuentre el punto de conexión que desea copiar.
1. Elija el icono de copia directamente delante del punto de conexión.
El punto de conexión se ha copiado ahora en el portapapeles. Para obtener información sobre el uso del punto de conexión a fin de conectarse a un nodo, consulte [Conexión a los nodos de Memcached](nodes-connecting.md#nodes-connecting.mem).
Un punto de conexión principal de Valkey o Redis OSS (modo de clúster deshabilitado) tiene un aspecto parecido al siguiente. Existe una diferencia dependiendo de si está habilitado el cifrado en tránsito o no lo está.
**Cifrado en tránsito no habilitado**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**Cifrado en tránsito habilitado**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
## Búsqueda de puntos de conexión para un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)
Un clúster de Valkey o Redis OSS (modo de clúster habilitado) tiene un único punto de conexión de configuración. Al conectarse al punto de conexión de configuración, la aplicación puede detectar los puntos de conexión principal y de lectura de cada partición del clúster.
**Búsqueda de puntos de conexión del clúster de Valkey o Redis OSS (modo de clúster habilitado)**
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, elija **Clústeres de Valkey** o **Clústeres de Redis OSS**.
Aparecerá la pantalla de clústeres con una lista de clústeres. Haga clic en el clúster al que desea conectarse.
1. Para buscar el punto de conexión de configuración del clúster, elija el nombre del clúster (no el botón de opción).
1. El **Configuration endpoint** (Punto de conexión de configuración) se muestra en **Cluster details**(Detalles de clúster). Para copiarlo, elija el ícono *copiar* a la izquierda del punto de conexión.
## Búsqueda de puntos de conexión de un clúster (consola) (Memcached)
Todos los puntos de conexión de Memcached son de lectura/escritura. Para conectarse a los nodos de un clúster de Memcached, su aplicación puede usar los puntos de conexión de cada nodo o el punto de conexión de configuración del clúster con la función de detección automática. Para usar la función de detección automática, debe usar un cliente que admita la función de detección automática.
Cuando se usa la función de detección automática, la aplicación cliente se conecta a su clúster de Memcached mediante el punto de conexión de configuración. A medida que amplíe su clúster agregando o quitando nodos, su aplicación "sabrá" automáticamente los nodos que hay en el clúster y se podrá conectar a cualquiera de ellos. Sin la función de detección automática, su aplicación tendría que averiguar los nodos existentes o tendría que actualizar manualmente los puntos de conexión de su aplicación cada vez que se agrega o quita un nodo.
Para copiar un punto de conexión, elija el icono de copia situado justo delante de la dirección del punto de conexión. Para obtener información sobre el uso del punto de conexión a fin de conectarse a un nodo, consulte [Conexión a los nodos de Memcached](nodes-connecting.md#nodes-connecting.mem).
Los puntos de conexión de configuración y del nodo son muy similares. A continuación se muestran las diferencias resaltadas en **negrita**.
```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port # node endpoint for node 0001
```
**importante**
Si decide crear un CNAME para su punto de conexión de Memcached, para que el cliente de detección automática reconozca el CNAME como un punto de conexión de configuración, deberá incluir `.cfg.` en el CNAME.
## Búsqueda de puntos de conexión (AWS CLI)
Para Memcached, puede utilizar la AWS CLI de Amazon ElastiCache para detectar los puntos de conexión de los nodos y los clústeres.
Para Redis OSS, puede utilizar la AWS CLI de Amazon ElastiCache para detectar los puntos de conexión de los nodos, los clústeres y los grupos de replicación.
**Topics**
+ [Búsqueda de puntos de conexión para nodos y clústeres (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Búsqueda de los puntos de conexión de los grupos de replicación de Valkey o Redis OSS (AWS CLI)](#Endpoints.Find.CLI.ReplGroups)
### Búsqueda de puntos de conexión para nodos y clústeres (AWS CLI)
Puede usar AWS CLI para detectar los puntos de enlace de un clúster y sus nodos con el comando `describe-cache-clusters`. Para clústeres de Valkey o Redis OSS, el comando devuelve el punto de conexión del clúster. Para clústeres de Memcached, el comando devuelve el punto de conexión de configuración. Si incluye el parámetro opcional `--show-cache-node-info`, el comando también devolverá los puntos de conexión de los nodos individuales del clúster.
**Example**
El comando siguiente recupera el punto de conexión de configuración (`ConfigurationEndpoint`) y los puntos de conexión de nodos individuales (`Endpoint`) para el clúster de Memcached *mycluster*.
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
```
La salida de la operación anterior tendrá un aspecto similar al siguiente (formato JSON).
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0003",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-22T21:30:29.967Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 3,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "mon:09:00-mon:10:00",
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled"
}
]
}
```
Si decide crear un CNAME para su punto de conexión de Memcached, a fin de que el cliente de detección automática reconozca el CNAME como un punto de conexión de configuración, deberá incluir `.cfg.` en el CNAME. Por ejemplo, incluya `mycluster.cfg.local` en el archivo php.ini en el parámetro `session.save_path`.
**Example**
Para Valkey o Redis OSS, el siguiente comando recupera información del clúster para el clúster de nodo único *mycluster*.
El parámetro `--cache-cluster-id` se puede utilizar con el ID de clúster de Valkey o Redis OSS (modo de clúster deshabilitado) con un solo nodo o con los ID de un nodo específico de los grupos de replicación. El valor de `--cache-cluster-id` de un grupo de replicación es un valor de 4 dígitos; por ejemplo, `0001`. Si `--cache-cluster-id` es la identificación de un clúster (nodo) de un grupo de replicación, `replication-group-id` se incluye en la salida.
Para Linux, macOS o Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id redis-cluster \
--show-cache-node-info
```
Para Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id redis-cluster ^
--show-cache-node-info
```
La salida de la operación anterior tendrá un aspecto similar al siguiente (formato JSON).
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"SecurityGroupId": "sg-77186e0d",
"Status": "active"
}
],
"CacheNodes": [
{
"CustomerAvailabilityZone": "us-east-1b",
"CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
"CacheNodeStatus": "available",
"CacheNodeId": "0001",
"Endpoint": {
"Address": "redis-cluster.amazonaws.com",
"Port": 6379
},
"ParameterGroupStatus": "in-sync"
}
],
"AtRestEncryptionEnabled": false,
"CacheClusterId": "redis-cluster",
"TransitEncryptionEnabled": false,
"CacheParameterGroup": {
"ParameterApplyStatus": "in-sync",
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis3.2"
},
"NumCacheNodes": 1,
"PreferredAvailabilityZone": "us-east-1b",
"AutoMinorVersionUpgrade": true,
"Engine": "redis",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
"CacheSecurityGroups": [],
"CacheSubnetGroupName": "default",
"CacheNodeType": "cache.t2.small",
"DataTiering": "disabled"
"EngineVersion": "3.2.10",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
}
]
}
```
Para obtener más información, consulte el tema [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).
### Búsqueda de los puntos de conexión de los grupos de replicación de Valkey o Redis OSS (AWS CLI)
Puede usar la AWS CLI para detectar los puntos de enlace de un grupo de reproducción y sus clústeres con el comando `describe-replication-groups`. El comando devuelve el punto de conexión principal del grupo de reproducción y una lista de todos los clústeres (nodos) del grupo de reproducción con sus puntos de conexión, junto con el punto de conexión de lector.
La operación siguiente recupera el punto de conexión principal y el punto de conexión de lector para el grupo de reproducción `myreplgroup`. Use el punto de conexión principal para todas las operaciones de escritura.
```
aws elasticache describe-replication-groups \
--replication-group-id myreplgroup
```
Para Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id myreplgroup
```
La salida de esta operación anterior tendrá un aspecto similar al siguiente (formato JSON).
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-001.amazonaws.com"
},
"CacheClusterId": "myreplgroup-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-002.amazonaws.com"
},
"CacheClusterId": "myreplgroup-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-003.amazonaws.com"
},
"CacheClusterId": "myreplgroup-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "myreplgroup.amazonaws.com"
},
"ReaderEndpoint": {
"Port": 6379,
"Address": "myreplgroup-ro.amazonaws.com"
}
}
],
"ReplicationGroupId": "myreplgroup",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "myreplgroup-002",
"MemberClusters": [
"myreplgroup-001",
"myreplgroup-002",
"myreplgroup-003"
],
"PendingModifiedValues": {}
}
]
}
```
Para obtener más información, consulte [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) en la *Referencia de los comandos de la AWS CLI*.
## Búsqueda de puntos de enlace (API de ElastiCache)
Para Memcached, puede utilizar la API de Amazon ElastiCache para detectar los puntos de conexión de los nodos y los clústeres.
Para Redis OSS, puede utilizar la API de Amazon ElastiCache para detectar los puntos de conexión de los nodos, los clústeres y los grupos de replicación.
**Topics**
+ [Búsqueda de puntos de enlace para nodos y clústeres (API de ElastiCache)](#Endpoints.Find.API.Nodes)
+ [Búsqueda de puntos de conexión de grupos de replicación de Valkey o Redis OSS (API de ElastiCache)](#Endpoints.Find.API.ReplGroups)
### Búsqueda de puntos de enlace para nodos y clústeres (API de ElastiCache)
Puede utilizar la API de ElastiCache para detectar los puntos de enlace de un clúster y sus nodos con la acción `DescribeCacheClusters`. Para clústeres de Valkey o Redis OSS, el comando devuelve el punto de conexión del clúster. Para clústeres de Memcached, el comando devuelve el punto de conexión de configuración. Si incluye el parámetro opcional `ShowCacheNodeInfo`, la acción también devuelve los puntos de conexión de los nodos individuales del clúster.
**Example**
Para Memcached, el comando siguiente recupera el punto de conexión de configuración (`ConfigurationEndpoint`) y los puntos de conexión de nodos individuales (`Endpoint`) para el clúster de Memcached *mycluster*.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=mycluster
&ShowCacheNodeInfo=true
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Si decide crear un CNAME para su punto de conexión de Memcached, a fin de que el cliente de detección automática reconozca el CNAME como un punto de conexión de configuración, deberá incluir `.cfg.` en el CNAME. Por ejemplo, incluya `mycluster.cfg.local` en el archivo php.ini en el parámetro `session.save_path`.
### Búsqueda de puntos de conexión de grupos de replicación de Valkey o Redis OSS (API de ElastiCache)
Puede utilizar la API de ElastiCache para detectar los puntos de enlace de un grupo de reproducción y sus clústeres con la acción `DescribeReplicationGroups`. La acción devuelve el punto de conexión principal del grupo de reproducción y una lista de todos los clústeres del grupo de reproducción con sus puntos de enlace, junto con el punto de conexión de lector.
La operación siguiente recupera el punto de conexión principal (PrimaryEndpoint), el punto de conexión de lector (ReaderEndpoint) y los punto de conexión de nodo (ReadEndpoint) del grupo de reproducción `myreplgroup`. Use el punto de conexión principal para todas las operaciones de escritura.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myreplgroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Para obtener más información, consulte [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html).
# Uso de particiones en ElastiCache
Una partición (API/CLI: grupo de nodos) es una colección de entre uno y seis nodos de ElastiCache para Valkey o Redis OSS. Un clúster de Valkey o Redis OSS (modo de clúster deshabilitado) nunca tendrá más de una partición. Con las particiones, puede separar las bases de datos de gran tamaño en unas partes más pequeñas, rápidas y fáciles de administrar denominadas particiones de datos. Esto puede aumentar la eficiencia de la base de datos al distribuir las operaciones en varias secciones independientes. El uso de particiones puede tener muchas ventajas, como la mejora del rendimiento, la escalabilidad y la rentabilidad.
Puede crear un clúster con un mayor número de particiones y un menor número de réplicas con un total de hasta 90 nodos por clúster. Esta configuración de clúster puede variar desde 90 particiones y 0 réplicas hasta 15 particiones y 5 réplicas, que es el número máximo de réplicas permitido. Los datos del clúster están particionados en las distintas particiones del clúster. Si hay más de un nodo en una partición, esta implementa la reproducción con un nodo, siendo el nodo principal de lectura/escritura y los demás, nodos de réplica de solo lectura.
El límite de nodos o particiones se puede aumentar a un máximo de 500 por clúster si la versión del motor es Valkey 7.2 y posteriores o Redis OSS 5.0.6 a 7.1. Por ejemplo, puede elegir configurar un clúster de 500 nodos que oscila entre 83 particiones (uno primario y 5 réplicas por partición) y 500 particiones (único primario y sin réplicas). Asegúrese de que hay suficientes direcciones IP disponibles para acomodar el aumento. Algunos problemas comunes incluyen que las subredes del grupo de subredes tienen un rango CIDR demasiado pequeño o que otros clústeres comparten y utilizan considerablemente las subredes. Para obtener más información, consulte [Creación de un grupo de subredes](SubnetGroups.Creating.md).
Para las versiones inferiores a 5.0.6, el límite es de 250 por clúster.
Para solicitar un aumento del límite, consulte [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) y elija el tipo de límite **Nodes per cluster per instance type** (Nodos por clúster por tipo de instancias).
Cuando crea un clúster de Valkey o Redis OSS (modo de clúster habilitado) con la consola de ElastiCache, debe especificar el número de particiones del clúster y el número de nodos de las particiones. Para obtener más información, consulte [Creación de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Si utiliza la AWS CLI o la API de ElastiCache para crear un clúster (denominado *grupo de reproducción* en la API/CLI), puede configurar el número de nodos de una partición (API/CLI: grupo de nodos) de manera independiente. Para obtener más información, consulte los siguientes temas:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Los nodos de las particiones tienen las mismas especificaciones de memoria, almacenamiento y computación. La API de ElastiCache permite controlar los atributos de toda la partición, como el número de nodos, la configuración de seguridad y los periodos de mantenimiento del sistema.
![\[Imagen: configuraciones de particiones de Valkey o Redis OSS.\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisShards.png)
*Configuraciones de particiones de Valkey o Redis OSS*
Para obtener más información, consulte [Cambio de particiones sin conexión para Valkey o Redis OSS (modo de clúster habilitado)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-offline) y [Cambio de particiones en línea para Valkey o Redis OSS (modo de clúster habilitado)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online).
## Búsqueda del ID de una partición
Puede encontrar el ID de una partición con la Consola de administración de AWS, la AWS CLI o la API de ElastiCache.
### Uso de Consola de administración de AWS
**Topics**
+ [Para Valkey o Redis OSS (modo de clúster deshabilitado)](#shard-find-id-con-classic)
+ [Para Valkey o Redis OSS (modo de clúster habilitado)](#shard-find-id-con-cluster)
#### Para Valkey o Redis OSS (modo de clúster deshabilitado)
Los ID de partición del grupo de replicación de Valkey o Redis OSS (modo de clúster deshabilitado) son siempre `0001`.
#### Para Valkey o Redis OSS (modo de clúster habilitado)
En el siguiente procedimiento, se utiliza la Consola de administración de AWS para buscar un ID de partición del grupo de replicación de Valkey o Redis OSS (modo de clúster habilitado).
**Búsqueda del ID de partición en un grupo de replicación de Valkey o Redis OSS (modo de clúster habilitado)**
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, elija **Valkey** o **Redis OSS** y, a continuación, el nombre del grupo de replicación de Valkey o Redis OSS (modo de clúster habilitado) cuyo ID de partición desea buscar.
1. En la columna de **Shard Name** (Nombre de la partición), el ID de partición lo forman los cuatro últimos dígitos del nombre de la partición.
### Uso de AWS CLI
Para buscar los ID de partición (grupo de nodos) de los grupos de replicación de Valkey o Redis OSS (modo de clúster deshabilitado) o Valkey o Redis OSS (modo de clúster habilitado), utilice la operación `describe-replication-groups` de la AWS CLI con el siguiente parámetro opcional.
+ **`--replication-group-id`**—un parámetro opcional que, cuando se utiliza, limita los resultados de los detalles del grupo de reproducción especificado. Si se omite este parámetro, se devuelven los detalles de hasta 100 grupos de reproducción.
**Example**
Este comando devuelve los detalles de `sample-repl-group`.
Para Linux, macOS o Unix:
```
aws elasticache describe-replication-groups \
--replication-group-id sample-repl-group
```
Para Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id sample-repl-group
```
La salida de este comando es similar a la siguiente. Aquí están *resaltados* los ID de fragmento (grupo de nodos) para que resulte más fácil encontrarlos.
```
{
"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": "sample-repl-group-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "sample-repl-group.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
]
}
```
### Uso de la API de ElastiCache
Para buscar los ID de partición (grupo de nodos) de los grupos de replicación de Valkey o Redis OSS (modo de clúster deshabilitado) o Valkey o Redis OSS (modo de clúster habilitado), utilice la operación `describe-replication-groups` de la AWS CLI con el siguiente parámetro opcional.
+ **`ReplicationGroupId`**—un parámetro opcional que, cuando se utiliza, limita los resultados de los detalles del grupo de reproducción especificado. Si se omite este parámetro, se devuelven los detalles de hasta *xxx* grupos de reproducción.
**Example**
Este comando devuelve los detalles de `sample-repl-group`.
Para Linux, macOS o Unix:
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroup
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```