

# Configuring engine parameters using ElastiCache parameter groups


Amazon ElastiCache uses parameters to control the runtime properties of your nodes and clusters. Generally, newer engine versions include additional parameters to support the newer functionality. For tables of Memcached parameters, see [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached). For tables of Valkey and Redis OSS parameters, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis). 

As you would expect, some parameter values, such as `maxmemory`, are determined by the engine and node type. For a table of these Memcached parameter values by node type, see [Memcached node-type specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached.NodeSpecific). For a table of these Valkey and Redis OSS parameter values by node type, see [Redis OSS node-type specific parameters](ParameterGroups.Engine.md#ParameterGroups.Redis.NodeSpecific).

**Note**  
For a list of Memcached-specific parameters, see [Memcached Specific Parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached).

**Topics**
+ [

# Parameter management in ElastiCache
](ParameterGroups.Management.md)
+ [

# Cache parameter group tiers in ElastiCache
](ParameterGroups.Tiers.md)
+ [

# Creating an ElastiCache parameter group
](ParameterGroups.Creating.md)
+ [

# Listing ElastiCache parameter groups by name
](ParameterGroups.ListingGroups.md)
+ [

# Listing an ElastiCache parameter group's values
](ParameterGroups.ListingValues.md)
+ [

# Modifying an ElastiCache parameter group
](ParameterGroups.Modifying.md)
+ [

# Deleting an ElastiCache parameter group
](ParameterGroups.Deleting.md)
+ [

# Engine specific parameters
](ParameterGroups.Engine.md)

# Parameter management in ElastiCache


ElastiCache parameters are grouped together into named parameter groups for easier parameter management. A parameter group represents a combination of specific values for the parameters that are passed to the engine software during startup. These values determine how the engine processes on each node behave at runtime. The parameter values on a specific parameter group apply to all nodes that are associated with the group, regardless of which cluster they belong to.

To fine-tune your cluster's performance, you can modify some parameter values or change the cluster's parameter group.
+ You cannot modify or delete the default parameter groups. If you need custom parameter values, you must create a custom parameter group.
+ For Memcached, the parameter group family and the cluster you're assigning it to must be compatible. For example, if your cluster is running Memcached version 1.4.8, you can only use parameter groups, default or custom, from the Memcached 1.4 family.

  For Redis OSS, the parameter group family and the cluster you're assigning it to must be compatible. For example, if your cluster is running Redis OSS version 3.2.10, you can only use parameter groups, default or custom, from the Redis OSS 3.2 family.
+ If you change a cluster's parameter group, the values for any conditionally modifiable parameter must be the same in both the current and new parameter groups.
+ For Memcached, when you change a cluster's parameters the change is applied to the cluster immediately. This is true whether you change the cluster's parameter group itself or a parameter value within the cluster's parameter group. To determine when a particular parameter change is applied, see the **Changes Take Effect** column in the tables for [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached). For information on rebooting a cluster's nodes, see [Rebooting clusters](Clusters.html#Rebooting).
+ For Redis OSS, when you change a cluster's parameters, the change is applied to the cluster either immediately or, with the exceptions noted following, after the cluster nodes are rebooted. This is true whether you change the cluster's parameter group itself or a parameter value within the cluster's parameter group. To determine when a particular parameter change is applied, see the **Changes Take Effect** column in the tables for [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis). 

  For more information on rebooting Valkey or Redis OSS nodes, see [Rebooting nodes](nodes.rebooting.md).
**Valkey or Redis OSS (Cluster Mode Enabled) parameter changes**  
If you make changes to the following parameters on a Valkey or Redis OSS (cluster mode enabled) cluster, follow the ensuing steps.  
activerehashing
databases
Create a manual backup of your cluster. See [Taking manual backups](backups-manual.md).
Delete the cluster. See [Deleting clusters](Clusters.html#Delete).
store the cluster using the altered parameter group and backup to seed the new cluster. See [Restoring from a backup into a new cache](backups-restoring.md).
Changes to other parameters do not require this.
+ You can associate parameter groups with Valkey and Redis OSS global datastores. *Global datastores *are a collection of one or more clusters that span AWS Regions. In this case, the parameter group is shared by all clusters that make up the global datastore. Any modifications to the parameter group of the primary cluster are replicated to all remaining clusters in the global datastore. For more information, see [Replication across AWS Regions using global datastores](Redis-Global-Datastore.md).

  You can check if a parameter group is part of a global datastore by looking in these locations:
  + On the ElastiCache console on the **Parameter Groups** page, the yes/no **Global** attribute 
  + The yes/no `IsGlobal` property of the [CacheParameterGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CacheParameterGroup.html) API operation

# Cache parameter group tiers in ElastiCache
Parameter group tiers in ElastiCache

Amazon ElastiCache has three tiers of cache parameter groups as shown following.

![\[Image: Amazon ElastiCache parameter group tiers\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/images/ElastiCache-ParameterGroups-Tiers.png)


*Amazon ElastiCache parameter group tiers*

**Global Default**

The top-level root parameter group for all Amazon ElastiCache customers in the region.

The global default cache parameter group:
+ Is reserved for ElastiCache and not available to the customer.

**Customer Default**

A copy of the Global Default cache parameter group which is created for the customer's use.

The Customer Default cache parameter group:
+ Is created and owned by ElastiCache.
+ Is available to the customer for use as a cache parameter group for any clusters running an engine version supported by this cache parameter group.
+ Cannot be edited by the customer.

**Customer Owned**

A copy of the Customer Default cache parameter group. A Customer Owned cache parameter group is created whenever the customer creates a cache parameter group.

The Customer Owned cache parameter group:
+ Is created and owned by the customer.
+ Can be assigned to any of the customer's compatible clusters.
+ Can be modified by the customer to create a custom cache parameter group. 

   Not all parameter values can be modified. For more information on Memcached values, see [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached). For more information on Valkey and Redis OSS values, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis).

# Creating an ElastiCache parameter group


You need to create a new parameter group if there is one or more parameter values that you want changed from the default values. You can create a parameter group using the ElastiCache console, the AWS CLI, or the ElastiCache API.

## Creating an ElastiCache parameter group (Console)


The following procedure shows how to create a parameter group using the ElastiCache console.

**To create a parameter group using the ElastiCache console**

1. Sign in to the AWS Management Console and open the ElastiCache console at [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. To see a list of all available parameter groups, in the left hand navigation pane choose **Parameter Groups**.

1. To create a parameter group, choose **Create Parameter Group**.

   The **Create Parameter Group** screen appears.

1. From the **Family** list, choose the parameter group family that will be the template for your parameter group.

   The parameter group family, such as *memcached1.4* or *redis3.2* defines the actual parameters in your parameter group and their initial values. The parameter group family must coincide with the cluster's engine and version.

1. In the **Name** box, type in a unique name for this parameter group.

   When creating a cluster or modifying a cluster's parameter group, you will choose the parameter group by its name. Therefore, we recommend that the name be informative and somehow identify the parameter group's family.

   Parameter group naming constraints are as follows:
   + Must begin with an ASCII letter.
   + Can only contain ASCII letters, digits, and hyphens.
   + Must be 1–255 characters long.
   + Can't contain two consecutive hyphens.
   + Can't end with a hyphen.

1. In the **Description** box, type in a description for the parameter group.

1. To create the parameter group, choose **Create**.

   To terminate the process without creating the parameter group, choose **Cancel**.

1. When the parameter group is created, it will have the family's default values. To change the default values you must modify the parameter group. For more information, see [Modifying an ElastiCache parameter group](ParameterGroups.Modifying.md).

## Creating an ElastiCache parameter group (AWS CLI)


To create a parameter group using the AWS CLI, use the command `create-cache-parameter-group` with these parameters.
+ `--cache-parameter-group-name` — The name of the parameter group.

  Parameter group naming constraints are as follows:
  + Must begin with an ASCII letter.
  + Can only contain ASCII letters, digits, and hyphens.
  + Must be 1–255 characters long.
  + Can't contain two consecutive hyphens.
  + Can't end with a hyphen.
+ `--cache-parameter-group-family` — The engine and version family for the parameter group.
+ `--description` — A user supplied description for the parameter group.

**Example**  
The following example creates a parameter group named *myMem14* using the memcached1.4 family as the template.   
For Linux, macOS, or Unix:  

```
aws elasticache create-cache-parameter-group \
    --cache-parameter-group-name myMem14  \
    --cache-parameter-group-family memcached1.4 \
    --description "My first parameter group"
```
For Windows:  

```
aws elasticache create-cache-parameter-group ^
    --cache-parameter-group-name myMem14  ^
    --cache-parameter-group-family memcached1.4 ^
    --description "My first parameter group"
```
The output from this command should look something like this.  

```
{
    "CacheParameterGroup": {
        "CacheParameterGroupName": "myMem14", 
        "CacheParameterGroupFamily": "memcached1.4", 
        "Description": "My first  parameter group"
    }
}
```

**Example**  
The following example creates a parameter group named *myRed28* using the redis2.8 family as the template.   
For Linux, macOS, or Unix:  

```
aws elasticache create-cache-parameter-group \
    --cache-parameter-group-name myRed28  \
    --cache-parameter-group-family redis2.8 \
    --description "My first parameter group"
```
For Windows:  

```
aws elasticache create-cache-parameter-group ^
    --cache-parameter-group-name myRed28  ^
    --cache-parameter-group-family redis2.8 ^
    --description "My first parameter group"
```
The output from this command should look something like this.  

```
{
    "CacheParameterGroup": {
        "CacheParameterGroupName": "myRed28", 
        "CacheParameterGroupFamily": "redis2.8", 
        "Description": "My first parameter group"
    }
}
```

When the parameter group is created, it will have the family's default values. To change the default values you must modify the parameter group. For more information, see [Modifying an ElastiCache parameter group](ParameterGroups.Modifying.md).

For more information, see [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-parameter-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-parameter-group.html).

## Creating an ElastiCache parameter group (ElastiCache API)


To create a parameter group using the ElastiCache API, use the `CreateCacheParameterGroup` action with these parameters.
+ `ParameterGroupName` — The name of the parameter group.

  Parameter group naming constraints are as follows:
  + Must begin with an ASCII letter.
  + Can only contain ASCII letters, digits, and hyphens.
  + Must be 1–255 characters long.
  + Can't contain two consecutive hyphens.
  + Can't end with a hyphen.
+ `CacheParameterGroupFamily` — The engine and version family for the parameter group. For example, `memcached1.4`.
+ `CacheParameterGroupFamily` — The engine and version family for the parameter group. For example, `redis2.8`.
+ `Description` — A user supplied description for the parameter group.

**Example**  
The following example creates a parameter group named *myMem14* using the memcached1.4 family as the template.   

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=CreateCacheParameterGroup
   &CacheParameterGroupFamily=memcached1.4
   &CacheParameterGroupName=myMem14
   &Description=My%20first%20parameter%20group
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action should look something like this.  

```
<CreateCacheParameterGroupResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <CreateCacheParameterGroupResult>
    <CacheParameterGroup>
      <CacheParameterGroupName>myMem14</CacheParameterGroupName>
      <CacheParameterGroupFamily>memcached1.4</CacheParameterGroupFamily>
      <Description>My first  parameter group</Description>
    </CacheParameterGroup>
  </CreateCacheParameterGroupResult>
  <ResponseMetadata>
    <RequestId>d8465952-af48-11e0-8d36-859edca6f4b8</RequestId>
  </ResponseMetadata>
</CreateCacheParameterGroupResponse>
```

**Example**  
The following example creates a parameter group named *myRed28* using the redis2.8 family as the template.   

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=CreateCacheParameterGroup
   &CacheParameterGroupFamily=redis2.8
   &CacheParameterGroupName=myRed28
   &Description=My%20first%20parameter%20group
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action should look something like this.  

```
<CreateCacheParameterGroupResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <CreateCacheParameterGroupResult>
    <CacheParameterGroup>
      <CacheParameterGroupName>myRed28</CacheParameterGroupName>
      <CacheParameterGroupFamily>redis2.8</CacheParameterGroupFamily>
      <Description>My first parameter group</Description>
    </CacheParameterGroup>
  </CreateCacheParameterGroupResult>
  <ResponseMetadata>
    <RequestId>d8465952-af48-11e0-8d36-859edca6f4b8</RequestId>
  </ResponseMetadata>
</CreateCacheParameterGroupResponse>
```

When the parameter group is created, it will have the family's default values. To change the default values you must modify the parameter group. For more information, see [Modifying an ElastiCache parameter group](ParameterGroups.Modifying.md).

For more information, see [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheParameterGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheParameterGroup.html).

# Listing ElastiCache parameter groups by name


You can list the parameter groups using the ElastiCache console, the AWS CLI, or the ElastiCache API.

## Listing parameter groups by name (Console)


The following procedure shows how to view a list of the parameter groups using the ElastiCache console.

**To list parameter groups using the ElastiCache console**

1. Sign in to the AWS Management Console and open the ElastiCache console at [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. To see a list of all available parameter groups, in the left hand navigation pane choose **Parameter Groups**.

## Listing ElastiCache parameter groups by name (AWS CLI)


To generate a list of parameter groups using the AWS CLI, use the command `describe-cache-parameter-groups`. If you provide a parameter group's name, only that parameter group will be listed. If you do not provide a parameter group's name, up to `--max-records` parameter groups will be listed. In either case, the parameter group's name, family, and description are listed.

**Example**  
The following sample code lists the parameter group *myMem14*.  
For Linux, macOS, or Unix:  

```
aws elasticache describe-cache-parameter-groups \
    --cache-parameter-group-name myMem14
```
For Windows:  

```
aws elasticache describe-cache-parameter-groups ^
    --cache-parameter-group-name myMem14
```
The output of this command will look something like this, listing the name, family, and description for the parameter group.  

```
{
    "CacheParameterGroups": [
	    {
	        "CacheParameterGroupName": "myMem14", 
	        "CacheParameterGroupFamily": "memcached1.4", 
	        "Description": "My first parameter group"
	    }
    ]
}
```

**Example**  
The following sample code lists the parameter group *myRed28*.  
For Linux, macOS, or Unix:  

```
aws elasticache describe-cache-parameter-groups \
    --cache-parameter-group-name myRed28
```
For Windows:  

```
aws elasticache describe-cache-parameter-groups ^
    --cache-parameter-group-name myRed28
```
The output of this command will look something like this, listing the name, family, and description for the parameter group.  

```
{
    "CacheParameterGroups": [
	    {
	        "CacheParameterGroupName": "myRed28", 
	        "CacheParameterGroupFamily": "redis2.8", 
	        "Description": "My first parameter group"
	    }
    ]
}
```

**Example**  
The following sample code lists the parameter group *myRed56* for parameter groups running on Redis OSS engine version 5.0.6 onwards. If the parameter group is part of a [Replication across AWS Regions using global datastores](Redis-Global-Datastore.md), the `IsGlobal` property value returned in the output will be `Yes`.  
For Linux, macOS, or Unix:  

```
aws elasticache describe-cache-parameter-groups \
    --cache-parameter-group-name myRed56
```
For Windows:  

```
aws elasticache describe-cache-parameter-groups ^
    --cache-parameter-group-name myRed56
```
The output of this command will look something like this, listing the name, family, isGlobal and description for the parameter group.  

```
{
    "CacheParameterGroups": [
	    {
	        "CacheParameterGroupName": "myRed56", 
	        "CacheParameterGroupFamily": "redis5.0", 	        
	        "Description": "My first parameter group",
	        "IsGlobal": "yes"	        
	    }
    ]
}
```

**Example**  
The following sample code lists up to 10 parameter groups.  

```
aws elasticache describe-cache-parameter-groups --max-records 10
```
The JSON output of this command will look something like this, listing the name, family, description and, in the case of redis5.6 whether the parameter group is part of a global datastore (isGlobal), for each parameter group.  

```
{
    "CacheParameterGroups": [
        {
            "CacheParameterGroupName": "custom-redis32", 
            "CacheParameterGroupFamily": "redis3.2", 
            "Description": "custom parameter group with reserved-memory > 0"
        }, 
        {
            "CacheParameterGroupName": "default.memcached1.4", 
            "CacheParameterGroupFamily": "memcached1.4", 
            "Description": "Default parameter group for memcached1.4"
        }, 
        {
            "CacheParameterGroupName": "default.redis2.6", 
            "CacheParameterGroupFamily": "redis2.6", 
            "Description": "Default parameter group for redis2.6"
        }, 
        {
            "CacheParameterGroupName": "default.redis2.8", 
            "CacheParameterGroupFamily": "redis2.8", 
            "Description": "Default parameter group for redis2.8"
        }, 
        {
            "CacheParameterGroupName": "default.redis3.2", 
            "CacheParameterGroupFamily": "redis3.2", 
            "Description": "Default parameter group for redis3.2"
        }, 
        {
            "CacheParameterGroupName": "default.redis3.2.cluster.on", 
            "CacheParameterGroupFamily": "redis3.2", 
            "Description": "Customized default parameter group for redis3.2 with cluster mode on"
        },
        {
            "CacheParameterGroupName": "default.redis5.6.cluster.on", 
            "CacheParameterGroupFamily": "redis5.0", 
            "Description": "Customized default parameter group for redis5.6 with cluster mode on",
            "isGlobal": "yes"
        },
    ]
}
```

For more information, see [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameter-groups.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameter-groups.html).

## Listing ElastiCache parameter groups by name (ElastiCache API)


To generate a list of parameter groups using the ElastiCache API, use the `DescribeCacheParameterGroups` action. If you provide a parameter group's name, only that parameter group will be listed. If you do not provide a parameter group's name, up to `MaxRecords` parameter groups will be listed. In either case, the parameter group's name, family, and description are listed.

**Example**  
The following sample code lists the parameter group *myMem14*.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DescribeCacheParameterGroups
   &CacheParameterGroupName=myMem14
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action will look something like this, listing the name, family, and description for each parameter group.  

```
<DescribeCacheParameterGroupsResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <DescribeCacheParameterGroupsResult>
    <CacheParameterGroups>
      <CacheParameterGroup>
        <CacheParameterGroupName>myMem14</CacheParameterGroupName>
        <CacheParameterGroupFamily>memcached1.4</CacheParameterGroupFamily>
        <Description>My custom Memcached 1.4 parameter group</Description>
      </CacheParameterGroup>
    </CacheParameterGroups>
  </DescribeCacheParameterGroupsResult>
  <ResponseMetadata>
    <RequestId>3540cc3d-af48-11e0-97f9-279771c4477e</RequestId>
  </ResponseMetadata>
</DescribeCacheParameterGroupsResponse>
```

**Example**  
The following sample code lists up to 10 parameter groups.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DescribeCacheParameterGroups
   &MaxRecords=10
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action will look something like this, listing the name, family, description and, in the case of redis5.6 if the parameter group belongs to a global datastore (isGlobal), for each parameter group.  

```
<DescribeCacheParameterGroupsResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <DescribeCacheParameterGroupsResult>
    <CacheParameterGroups>
      <CacheParameterGroup>
        <CacheParameterGroupName>myRedis28</CacheParameterGroupName>
        <CacheParameterGroupFamily>redis2.8</CacheParameterGroupFamily>
        <Description>My custom Redis 2.8 parameter group</Description>
      </CacheParameterGroup>
      <CacheParameterGroup>
        <CacheParameterGroupName>myMem14</CacheParameterGroupName>
        <CacheParameterGroupFamily>memcached1.4</CacheParameterGroupFamily>
        <Description>My custom Memcached 1.4 parameter group</Description>
      </CacheParameterGroup>
       <CacheParameterGroup>
        <CacheParameterGroupName>myRedis56</CacheParameterGroupName>
        <CacheParameterGroupFamily>redis5.0</CacheParameterGroupFamily>
        <Description>My custom redis 5.6 parameter group</Description>
        <isGlobal>yes</isGlobal>
      </CacheParameterGroup>
    </CacheParameterGroups>
  </DescribeCacheParameterGroupsResult>
  <ResponseMetadata>
    <RequestId>3540cc3d-af48-11e0-97f9-279771c4477e</RequestId>
  </ResponseMetadata>
</DescribeCacheParameterGroupsResponse>
```

**Example**  
The following sample code lists the parameter group *myRed28*.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DescribeCacheParameterGroups
   &CacheParameterGroupName=myRed28
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action will look something like this, listing the name, family, and description.  

```
<DescribeCacheParameterGroupsResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <DescribeCacheParameterGroupsResult>
    <CacheParameterGroups>
      <CacheParameterGroup>
        <CacheParameterGroupName>myRed28</CacheParameterGroupName>
        <CacheParameterGroupFamily>redis2.8</CacheParameterGroupFamily>
        <Description>My custom Redis 2.8 parameter group</Description>
      </CacheParameterGroup>
    </CacheParameterGroups>
  </DescribeCacheParameterGroupsResult>
  <ResponseMetadata>
    <RequestId>3540cc3d-af48-11e0-97f9-279771c4477e</RequestId>
  </ResponseMetadata>
</DescribeCacheParameterGroupsResponse>
```

**Example**  
The following sample code lists the parameter group *myRed56*.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DescribeCacheParameterGroups
   &CacheParameterGroupName=myRed56
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action will look something like this, listing the name, family, description and whether the parameter group is part of a global datastore (isGlobal).  

```
<DescribeCacheParameterGroupsResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <DescribeCacheParameterGroupsResult>
    <CacheParameterGroups>
      <CacheParameterGroup>
        <CacheParameterGroupName>myRed56</CacheParameterGroupName>
        <CacheParameterGroupFamily>redis5.0</CacheParameterGroupFamily>
        <Description>My custom Redis 5.6 parameter group</Description>
        <isGlobal>yes</isGlobal>
      </CacheParameterGroup>
    </CacheParameterGroups>
  </DescribeCacheParameterGroupsResult>
  <ResponseMetadata>
    <RequestId>3540cc3d-af48-11e0-97f9-279771c4477e</RequestId>
  </ResponseMetadata>
</DescribeCacheParameterGroupsResponse>
```

For more information, see [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameterGroups.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameterGroups.html).

# Listing an ElastiCache parameter group's values


You can list the parameters and their values for a parameter group using the ElastiCache console, the AWS CLI, or the ElastiCache API.

## Listing an ElastiCache parameter group's values (Console)


The following procedure shows how to list the parameters and their values for a parameter group using the ElastiCache console.

**To list a parameter group's parameters and their values using the ElastiCache console**

1. Sign in to the AWS Management Console and open the ElastiCache console at [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. To see a list of all available parameter groups, in the left hand navigation pane choose **Parameter Groups**.

1. Choose the parameter group for which you want to list the parameters and values by choosing the box to the left of the parameter group's name.

   The parameters and their values will be listed at the bottom of the screen. Due to the number of parameters, you may have to scroll up and down to find the parameter you're interested in.

## Listing a parameter group's values (AWS CLI)


To list a parameter group's parameters and their values using the AWS CLI, use the command `describe-cache-parameters`.

**Example**  
The following sample code list all the Memcached parameters and their values for the parameter group *myMem14*.  
For Linux, macOS, or Unix:  

```
aws elasticache describe-cache-parameters \
    --cache-parameter-group-name myMem14
```
For Windows:  

```
aws elasticache describe-cache-parameters ^
    --cache-parameter-group-name myMem14
```

**Example**  
The following sample code list all the parameters and their values for the parameter group *myRedis28*.  
For Linux, macOS, or Unix:  

```
aws elasticache describe-cache-parameters \
    --cache-parameter-group-name myRedis28
```
For Windows:  

```
aws elasticache describe-cache-parameters ^
    --cache-parameter-group-name myRed28
```

For more information, see [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-parameters.html).

## Listing a parameter group's values (ElastiCache API)


To list a parameter group's parameters and their values using the ElastiCache API, use the `DescribeCacheParameters` action.

**Example**  
The following sample code list all the Memcached parameters for the parameter group *myMem14*.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DescribeCacheParameters
   &CacheParameterGroupName=myMem14
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action will look something like this. This response has been truncated.  

```
<DescribeCacheParametersResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <DescribeCacheParametersResult>
    <CacheClusterClassSpecificParameters>
      <CacheNodeTypeSpecificParameter>
        <DataType>integer</DataType>
        <Source>system</Source>
        <IsModifiable>false</IsModifiable>
        <Description>The maximum configurable amount of memory to use to store items, in megabytes.</Description>
        <CacheNodeTypeSpecificValues>
          <CacheNodeTypeSpecificValue>
            <Value>1000</Value>
            <CacheClusterClass>cache.c1.medium</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          <CacheNodeTypeSpecificValue>
            <Value>6000</Value>
            <CacheClusterClass>cache.c1.xlarge</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          <CacheNodeTypeSpecificValue>
            <Value>7100</Value>
            <CacheClusterClass>cache.m1.large</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          <CacheNodeTypeSpecificValue>
            <Value>1300</Value>
            <CacheClusterClass>cache.m1.small</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          
...output omitted...

    </CacheClusterClassSpecificParameters>
  </DescribeCacheParametersResult>
  <ResponseMetadata>
    <RequestId>6d355589-af49-11e0-97f9-279771c4477e</RequestId>
  </ResponseMetadata>
</DescribeCacheParametersResponse>
```

**Example**  
The following sample code list all the parameters for the parameter group *myRed28*.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DescribeCacheParameters
   &CacheParameterGroupName=myRed28
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```
The response from this action will look something like this. This response has been truncated.  

```
<DescribeCacheParametersResponse xmlns="http://elasticache.amazonaws.com/doc/2013-06-15/">
  <DescribeCacheParametersResult>
    <CacheClusterClassSpecificParameters>
      <CacheNodeTypeSpecificParameter>
        <DataType>integer</DataType>
        <Source>system</Source>
        <IsModifiable>false</IsModifiable>
        <Description>The maximum configurable amount of memory to use to store items, in megabytes.</Description>
        <CacheNodeTypeSpecificValues>
          <CacheNodeTypeSpecificValue>
            <Value>1000</Value>
            <CacheClusterClass>cache.c1.medium</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          <CacheNodeTypeSpecificValue>
            <Value>6000</Value>
            <CacheClusterClass>cache.c1.xlarge</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          <CacheNodeTypeSpecificValue>
            <Value>7100</Value>
            <CacheClusterClass>cache.m1.large</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          <CacheNodeTypeSpecificValue>
            <Value>1300</Value>
            <CacheClusterClass>cache.m1.small</CacheClusterClass>
          </CacheNodeTypeSpecificValue>
          
...output omitted...

    </CacheClusterClassSpecificParameters>
  </DescribeCacheParametersResult>
  <ResponseMetadata>
    <RequestId>6d355589-af49-11e0-97f9-279771c4477e</RequestId>
  </ResponseMetadata>
</DescribeCacheParametersResponse>
```

For more information, see [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheParameters.html).

# Modifying an ElastiCache parameter group


**Important**  
You cannot modify any default parameter group.

You can modify some parameter values in a parameter group. These parameter values are applied to clusters associated with the parameter group. For more information on when a parameter value change is applied to a parameter group, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis) and [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached).

## Modifying a parameter group (Console)


The following procedure shows how to change the `cluster-enabled` parameter's value using the ElastiCache console. You would use the same procedure to change the value of any parameter.

**To change a parameter's value using the ElastiCache console**

1. Sign in to the AWS Management Console and open the ElastiCache console at [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. To see a list of all available parameter groups, in the left hand navigation pane choose **Parameter Groups**.

1. Choose the parameter group you want to modify by choosing the box to the left of the parameter group's name.

   The parameter group's parameters will be listed at the bottom of the screen. You may need to page through the list to see all the parameters.

1. To modify one or more parameters, choose **Edit Parameters**.

1. In the **Edit Parameter Group:** screen, scroll using the left and right arrows until you find the `binding_protocol` parameter, then type `ascii` in the **Value** column.

1. Choose **Save Changes**.

1. For Memcached, to find the name of the parameter you changed, see [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached). If changes to the parameter take place *After restart*, reboot every cluster that uses this parameter group. For more information, see [Rebooting clusters](Clusters.html#Rebooting).

1. With Valkey and Redis OSS, to find the name of the parameter you changed, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis). If you have a Valkey or Redis OSS (cluster mode disabled) cluster and make changes to the following parameters, you must reboot the nodes in the cluster:
   + activerehashing
   + databases

    For more information, see [Rebooting nodes](nodes.rebooting.md).
**Valkey or Redis OSS (Cluster Mode Enabled) parameter changes**  
If you make changes to the following parameters on a Valkey or Redis OSS (cluster mode enabled) cluster, follow the ensuing steps.  
activerehashing
databases
With Redis OSS, you can reate a manual backup of your cluster. See [Taking manual backups](backups-manual.md).
Delete the cluster. See [Deleting clusters](Clusters.html#Delete).
Restore the cluster using the altered parameter group and backup to seed the new cluster. See [Restoring from a backup into a new cache](backups-restoring.md).
Changes to other parameters do not require this.



## Modifying a parameter group (AWS CLI)


To change a parameter's value using the AWS CLI, use the command `modify-cache-parameter-group`.

**Example**  
With Memcached, to find the name and permitted values of the parameter you want to change, see [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached)  
The following sample code sets the value of two parameters, *chunk\$1size* and *chunk\$1size\$1growth\$1fact* on the parameter group `myMem14`.  
For Linux, macOS, or Unix:  

```
aws elasticache modify-cache-parameter-group \
    --cache-parameter-group-name myMem14 \
    --parameter-name-values \
        ParameterName=chunk_size,ParameterValue=96 \
        ParameterName=chunk_size_growth_fact,ParameterValue=1.5
```
For Windows:  

```
aws elasticache modify-cache-parameter-group ^
    --cache-parameter-group-name myMem14 ^
    --parameter-name-values ^
        ParameterName=chunk_size,ParameterValue=96 ^
        ParameterName=chunk_size_growth_fact,ParameterValue=1.5
```
Output from this command will look something like this.  

```
{
    "CacheParameterGroupName": "myMem14"
}
```

**Example**  
With Valkey and Redis OSS, to find the name and permitted values of the parameter you want to change, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis)  
The following sample code sets the value of two parameters, *reserved-memory-percent* and *cluster-enabled* on the parameter group `myredis32-on-30`. We set *reserved-memory-percent* to `30` (30 percent) and *cluster-enabled* to `yes` so that the parameter group can be used with Valkey or Redis OSS (cluster mode enabled) clusters (replication groups).  
For Linux, macOS, or Unix:  

```
aws elasticache modify-cache-parameter-group \
    --cache-parameter-group-name myredis32-on-30 \
    --parameter-name-values \
        ParameterName=reserved-memory-percent,ParameterValue=30 \
        ParameterName=cluster-enabled,ParameterValue=yes
```
For Windows:  

```
aws elasticache modify-cache-parameter-group ^
    --cache-parameter-group-name myredis32-on-30 ^
    --parameter-name-values ^
        ParameterName=reserved-memory-percent,ParameterValue=30 ^
        ParameterName=cluster-enabled,ParameterValue=yes
```
Output from this command will look something like this.  

```
{
    "CacheParameterGroupName": "my-redis32-on-30"
}
```

For more information, see [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-parameter-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-parameter-group.html).

To find the name of the parameter you changed, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis). 

 If you have a Valkey or Redis OSS (cluster mode disabled) cluster and make changes to the following parameters, you must reboot the nodes in the cluster:
+ activerehashing
+ databases

 For more information, see [Rebooting nodes](nodes.rebooting.md).

**Valkey or Redis OSS (Cluster Mode Enabled) parameter changes**  
If you make changes to the following parameters on a Valkey or Redis OSS (cluster mode enabled) cluster, follow the ensuing steps.  
activerehashing
databases
Create a manual backup of your cluster. See [Taking manual backups](backups-manual.md).
Delete the cluster. See [Deleting clusters](Clusters.html#Delete).
Restore the cluster using the altered parameter group and backup to seed the new cluster. See [Restoring from a backup into a new cache](backups-restoring.md).
Changes to other parameters do not require this.

## Modifying a parameter group (ElastiCache API)


To change a parameter group's parameter values using the ElastiCache API, use the `ModifyCacheParameterGroup` action.

**Example**  
With Memcached, to find the name and permitted values of the parameter you want to change, see [Memcached specific parameters](ParameterGroups.Engine.md#ParameterGroups.Memcached)  
The following sample code sets the value of two parameters, *chunk\$1size* and *chunk\$1size\$1growth\$1fact* on the parameter group `myMem14`.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=ModifyCacheParameterGroup
   &CacheParameterGroupName=myMem14
   &ParameterNameValues.member.1.ParameterName=chunk_size
   &ParameterNameValues.member.1.ParameterValue=96
   &ParameterNameValues.member.2.ParameterName=chunk_size_growth_fact
   &ParameterNameValues.member.2.ParameterValue=1.5
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```

**Example**  
With Valkey and Redis OSS, to find the name and permitted values of the parameter you want to change, see [Valkey and Redis OSS parameters](ParameterGroups.Engine.md#ParameterGroups.Redis)  
The following sample code sets the value of two parameters, *reserved-memory-percent* and *cluster-enabled* on the parameter group `myredis32-on-30`. We set *reserved-memory-percent* to `30` (30 percent) and *cluster-enabled* to `yes` so that the parameter group can be used with Valkey or Redis OSS (cluster mode enabled) clusters (replication groups).  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=ModifyCacheParameterGroup
   &CacheParameterGroupName=myredis32-on-30
   &ParameterNameValues.member.1.ParameterName=reserved-memory-percent
   &ParameterNameValues.member.1.ParameterValue=30
   &ParameterNameValues.member.2.ParameterName=cluster-enabled
   &ParameterNameValues.member.2.ParameterValue=yes
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```

For more information, see [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheParameterGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheParameterGroup.html).

If you have a Valkey or Redis OSS (cluster mode disabled) cluster and make changes to the following parameters, you must reboot the nodes in the cluster:
+ activerehashing
+ databases

 For more information, see [Rebooting nodes](nodes.rebooting.md).

**Valkey or Redis OSS (Cluster Mode Enabled) parameter changes**  
If you make changes to the following parameters on a Valkey or Redis OSS (cluster mode enabled) cluster, follow the ensuing steps.  
activerehashing
databases
Create a manual backup of your cluster. See [Taking manual backups](backups-manual.md).
Delete the cluster. See [Deleting a cluster in ElastiCache](Clusters.Delete.md).
Restore the cluster using the altered parameter group and backup to seed the new cluster. See [Restoring from a backup into a new cache](backups-restoring.md).
Changes to other parameters do not require this.

# Deleting an ElastiCache parameter group


You can delete a custom parameter group using the ElastiCache console, the AWS CLI, or the ElastiCache API.

You cannot delete a parameter group if it is associated with any clusters. Nor can you delete any of the default parameter groups.

## Deleting a parameter group (Console)


The following procedure shows how to delete a parameter group using the ElastiCache console.

**To delete a parameter group using the ElastiCache console**

1. Sign in to the AWS Management Console and open the ElastiCache console at [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. To see a list of all available parameter groups, in the left hand navigation pane choose **Parameter Groups**.

1. Choose the parameter groups you want to delete by choosing the box to the left of the parameter group's name.

   The **Delete** button will become active.

1. Choose **Delete**.

   The **Delete Parameter Groups** confirmation screen will appear.

1. To delete the parameter groups, on the **Delete Parameter Groups** confirmation screen, choose **Delete**.

   To keep the parameter groups, choose **Cancel**.

## Deleting a parameter group (AWS CLI)


To delete a parameter group using the AWS CLI, use the command `delete-cache-parameter-group`. For the parameter group to delete, the parameter group specified by `--cache-parameter-group-name` cannot have any clusters associated with it, nor can it be a default parameter group.

The following sample code deletes the *myMem14* parameter group.

**Example**  
For Linux, macOS, or Unix:  

```
aws elasticache delete-cache-parameter-group \
    --cache-parameter-group-name myRed28
```
For Windows:  

```
aws elasticache delete-cache-parameter-group ^
    --cache-parameter-group-name myRed28
```

For more information, see [https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-parameter-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-parameter-group.html).

## Deleting a parameter group (ElastiCache API)


To delete a parameter group using the ElastiCache API, use the `DeleteCacheParameterGroup` action. For the parameter group to delete, the parameter group specified by `CacheParameterGroupName` cannot have any clusters associated with it, nor can it be a default parameter group.

**Example**  
With Memcached, the following sample code deletes the *myMem14* parameter group.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DeleteCacheParameterGroup
   &CacheParameterGroupName=myMem14
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```

**Example**  
The following sample code deletes the *myRed28* parameter group.  

```
https://elasticache.us-west-2.amazonaws.com/
   ?Action=DeleteCacheParameterGroup
   &CacheParameterGroupName=myRed28
   &SignatureVersion=4
   &SignatureMethod=HmacSHA256
   &Timestamp=20150202T192317Z
   &Version=2015-02-02
   &X-Amz-Credential=<credential>
```

For more information, see [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheParameterGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheParameterGroup.html).

# Engine specific parameters


**Valkey and Redis OSS**

Most Valkey 8 parameters are compatible with Redis OSS 7.1 parameters. Valkey 7.2 parameters are the same as Redis OSS 7 parameters.

If you do not specify a parameter group for your Valkey or Redis OSS cluster, then a default parameter group appropriate to your engine version will be used. You can't change the values of any parameters in the default parameter group. However, you can create a custom parameter group and assign it to your cluster at any time as long as the values of conditionally modifiable parameters are the same in both parameter groups. For more information, see [Creating an ElastiCache parameter group](ParameterGroups.Creating.md).

**Topics**
+ [

## Valkey and Redis OSS parameters
](#ParameterGroups.Redis)
+ [

## Memcached specific parameters
](#ParameterGroups.Memcached)

## Valkey and Redis OSS parameters


**Topics**
+ [

### Valkey 8.2 parameter changes
](#ParameterGroups.Valkey.8.2)
+ [

### Valkey 8.1 parameter changes
](#ParameterGroups.Valkey.8.1)
+ [

### Valkey 8.0 parameter changes
](#ParameterGroups.Valkey.8)
+ [

### Valkey 7.2 and Redis OSS 7 parameter changes
](#ParameterGroups.Redis.7)
+ [

### Redis OSS 6.x parameter changes
](#ParameterGroups.Redis.6-x)
+ [

### Redis OSS 5.0.3 parameter changes
](#ParameterGroups.Redis.5-0-3)
+ [

### Redis OSS 5.0.0 parameter changes
](#ParameterGroups.Redis.5.0)
+ [

### Redis OSS 4.0.10 parameter changes
](#ParameterGroups.Redis.4-0-10)
+ [

### Redis OSS 3.2.10 parameter changes
](#ParameterGroups.Redis.3-2-10)
+ [

### Redis OSS 3.2.6 parameter changes
](#ParameterGroups.Redis.3-2-6)
+ [

### Redis OSS 3.2.4 parameter changes
](#ParameterGroups.Redis.3-2-4)
+ [

### Redis OSS 2.8.24 (enhanced) added parameters
](#ParameterGroups.Redis.2-8-24)
+ [

### Redis OSS 2.8.23 (enhanced) added parameters
](#ParameterGroups.Redis.2-8-23)
+ [

### Redis OSS 2.8.22 (enhanced) added parameters
](#ParameterGroups.Redis.2-8-22)
+ [

### Redis OSS 2.8.21 added parameters
](#ParameterGroups.Redis.2-8-21)
+ [

### Redis OSS 2.8.19 added parameters
](#ParameterGroups.Redis.2-8-19)
+ [

### Redis OSS 2.8.6 added parameters
](#ParameterGroups.Redis.2-8-6)
+ [

### Redis OSS 2.6.13 parameters
](#ParameterGroups.Redis.2-6-13)
+ [

### Redis OSS node-type specific parameters
](#ParameterGroups.Redis.NodeSpecific)

### Valkey 8.2 parameter changes


**Parameter group family:** valkey8

**Note**  
Valkey 8.2 parameter changes don't apply to Valkey 8.1
Valkey 8.0 and above parameter groups are incompatible with Redis OSS 7.2.4.
in Valkey 8.2, the following commands are unavailable for serverless caches: `commandlog`, `commandlog get`, `commandlog help`, `commandlog len`, and `commandlog reset.` 


**New parameter groups in Valkey 8.2**  

| Name | Details | Description | 
| --- | --- | --- | 
| search-fanout-target-mode (added in 8.2) | Default: client Type: string Modifiable: Yes Changes Take Effect: Immediately |   The search-fanout-target-mode configuration parameter controls how search queries are distributed across nodes in a Valkey cluster environment. This setting accepts two values: "throughput" which optimizes for maximum throughput by randomly distributing search queries across all cluster nodes regardless of client type or READONLY status, and "client" which respects client connection characteristics by routing non-READONLY clients to primary nodes only, READONLY clients on replica connections to replica nodes only, and READONLY clients on primary connections randomly across all nodes.  The default behavior is "client' mode, meaning the system will respect client connection types and READONLY status for query routing decisions. Use throughput mode for high-volume search workloads where maximum cluster resource utilization is desired, and client mode when you want to maintain read/write separation and respect application-level READONLY connection patterns. | 
| search-default-timeout-ms |  Default: 50000 Permitted values: 1 to 60000 Type: integer Modifiable: Yes Changes Take Effect: Immediately | The default Valkey search query timeout (in milliseconds). | 
| search-enable-partial-results | Default: yes Permitted values: yes, no Type: boolean Modifiable: Yes Changes Take Effect: Immediately | Configures the query failure behavior for Valkey search. When enabled, search queries will return partial results if timeouts occur on one or more shards. When disabled, any shard timeout will cause the entire search query to fail and return an error. | 

### Valkey 8.1 parameter changes


**Parameter group family:** valkey8

**Note**  
Valkey 8.1 parameter changes don't apply to Valkey 8.0
Valkey 8.0 and above parameter groups are incompatible with Redis OSS 7.2.4.
in Valkey 8.1, the following commands are unavailable for serverless caches: `commandlog`, `commandlog get`, `commandlog help`, `commandlog len`, and `commandlog reset.` 


**New parameter groups in Valkey 8.1**  

| Name | Details | Description | 
| --- | --- | --- | 
|  commandlog-request-larger-than (added in 8.1)  |  Default: 1048576 Type: integer Modifiable: Yes Changes Take Effect: Immediately  |  The maximum size, in bytes, for requests to be logged by the Valkey Command Log feature.  | 
|  commandlog-large-request-max-len (added in 8.1)  |  Default: 128 Permitted values: 0-1024 Type: integer Modifiable: Yes Changes Take Effect: Immediately  |  The maximum length of the Valkey Command Log for requests.  | 
|  commandlog-reply-larger-than (added in 8.1)  |  Default: 1048576 Type: integer Modifiable: Yes Changes Take Effect: Immediately  |  The maximum size, in bytes, for responses to be logged by the Valkey Command Log feature.  | 
|  commandlog-large-reply-max-len (added in 8.1)  |  Default: 128 Permitted values: 0-1024 Type: integer Modifiable: Yes Changes Take Effect: Immediately  |  The maximum length of the Valkey Command Log for responses.  | 

### Valkey 8.0 parameter changes


**Parameter group family:** valkey8

**Note**  
Redis OSS 7.2.4 is incompatible with Valkey 8 and above parameter groups.


**Specific parameter changes in Valkey 8.0**  

| Name | Details | Description | 
| --- | --- | --- | 
|  repl-backlog-size  |  Default: 10485760 Type: integer Modifiable: Yes Changes Take Effect: Immediately  |  The size, in bytes, of the primary node backlog buffer. The backlog is used for recording updates to data at the primary node. When a read replica connects to the primary, it attempts to perform a partial sync (psync), where it applies data from the backlog to catch up with the primary node. If the psync fails, then a full sync is required. The minimum value for this parameter is 16384. Note: Beginning with Redis OSS 2.8.22, this parameter applies to the primary cluster as well as the read replicas.  | 
|  maxmemory-samples  |  Default: 3 Permitted values: 1 to 64 Type: integer Modifiable: Yes Changes Take Effect: Immediately  |  For least-recently-used (LRU) and time-to-live (TTL) calculations, this parameter represents the sample size of keys to check. By default, Redis OSS chooses 3 keys and uses the one that was used least recently.  | 


**New parameter groups in Valkey 8.0**  

| Name | Details | Description | 
| --- | --- | --- | 
|  extended-redis-compatibility  |  Permitted values: yes, no Default: yes Type: boolean Modifiable: Yes Changes take place: immediately  |  Extended Redis OSS compatibility mode makes Valkey pretend to be Redis OSS 7.2. Enable this only if you have problems with tools or clients. Customer-facing impacts: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html)  | 


**Removed parameter groups in Valkey 8.0**  

| Name | Details | Description | 
| --- | --- | --- | 
|  lazyfree-lazy-eviction  |  Permitted values: yes, no Default: no Type: boolean Modifiable: Yes Changes take place: immediately  |  Performs an asynchronous delete on evictions.  | 
|  lazyfree-lazy-expire  |  Permitted values: yes, no Default: no Type: boolean Modifiable: Yes Changes take place: immediately  |  Performs an asynchronous delete on expired keys.  | 
|  lazyfree-lazy-server-del  |  Permitted values: yes, no Default: no Type: boolean Modifiable: Yes Changes take place: immediately  |  Performs an asynchronous delete for commands which update values.  | 
|  lazyfree-lazy-user-del  |  Default: no Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster  |   When the value is set to yes, the DEL command acts the same as UNLINK.  | 
|  replica-lazy-flush  |  Default: yes Type: boolean Modifiable: No Former name: slave-lazy-flush  |  Performs an asynchronous flushDB during replica sync.  | 

### Valkey 7.2 and Redis OSS 7 parameter changes


**Parameter group family:** valkey7

Valkey 7.2 default parameter groups are as follows:
+ `default.valkey7` – Use this parameter group, or one derived from it, for Valkey (cluster mode disabled) clusters and replication groups.
+ `default.valkey7.cluster.on` – Use this parameter group, or one derived from it, for Valkey (cluster mode enabled) clusters and replication groups.

**Parameter group family:** redis7

Redis OSS 7 default parameter groups are as follows:
+ `default.redis7` – Use this parameter group, or one derived from it, for Redis OSS (cluster mode disabled) clusters and replication groups.
+ `default.redis7.cluster.on` – Use this parameter group, or one derived from it, for Redis OSS (cluster mode enabled) clusters and replication groups.

**Specific parameter changes**

Parameters added in Redis OSS 7 are as follows. Valkey 7.2 also supports these parameters.


|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| cluster-allow-pubsubshard-when-down |  Permitted values: `yes`, `no` Default: `yes` Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | When set to the default of yes, allows nodes to serve pubsub shard traffic while the cluster is in a down state, as long as it believes it owns the slots.  | 
| cluster-preferred-endpoint-type |  Permitted values: `ip`, `tls-dynamic` Default: `tls-dynamic` Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | This value controls what endpoint is returned for MOVED/ASKING requests as well as the endpoint field for `CLUSTER SLOTS` and `CLUSTER SHARDS`. When the value is set to ip, the node will advertise its ip address. When the value is set to tls-dynamic, the node will advertise a hostname when encryption-in-transit is enabled and an ip address otherwise.  | 
| latency-tracking |  Permitted values: `yes`, `no` Default: `no` Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | When set to yes tracks the per command latencies and enables exporting the percentile distribution via the `INFO` latency statistics command, and cumulative latency distributions (histograms) via the `LATENCY` command.  | 
| hash-max-listpack-entries |  Permitted values: `0+` Default: `512` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | The maximum number of hash entries in order for the dataset to be compressed.  | 
| hash-max-listpack-value |  Permitted values: `0+` Default: `64` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | The threshold of biggest hash entries in order for the dataset to be compressed.  | 
| zset-max-listpack-entries |  Permitted values: `0+` Default: `128` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | The maximum number of sorted set entries in order for the dataset to be compressed.  | 
| zset-max-listpack-value |  Permitted values: `0+` Default: `64` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | The threshold of biggest sorted set entries in order for the dataset to be compressed.  | 

Parameters changed in Redis OSS 7 are as follows. 


|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| activerehashing |  Modifiable: `no`. In Redis OSS 7, this parameter is hidden and enabled by default. In order to disable it, you need to create a [support case](https://console.aws.amazon.com/support/home).  | Modifiable was yes.  | 

Parameters removed in Redis OSS 7 are as follows. 


|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| hash-max-ziplist-entries |  Permitted values: `0+` Default: `512` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | Use `listpack` instead of `ziplist` for representing small hash encoding  | 
| hash-max-ziplist-value |  Permitted values: `0+` Default: `64` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | Use `listpack` instead of `ziplist` for representing small hash encoding  | 
| zset-max-ziplist-entries |  Permitted values: `0+` Default: `128` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | Use `listpack` instead of `ziplist` for representing small hash encoding.  | 
| zset-max-ziplist-value |  Permitted values: `0+` Default: `64` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | Use `listpack` instead of `ziplist` for representing small hash encoding.  | 
| list-max-ziplist-size |  Permitted values: Default: `-2` Type: integer Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster. | The number of entries allowed per internal list node.  | 

### Redis OSS 6.x parameter changes


**Parameter group family:** redis6.x

Redis OSS 6.x default parameter groups are as follows:
+ `default.redis6.x` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode disabled) clusters and replication groups.
+ `default.redis6.x.cluster.on` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode enabled) clusters and replication groups.

**Note**  
 In Redis OSS engine version 6.2, when the r6gd node family was introduced for use with [Data tiering in ElastiCache](data-tiering.md), only *noeviction*, *volatile-lru* and *allkeys-lru* max-memory policies are supported with r6gd node types. 

For more information, see [ElastiCache version 6.2 for Redis OSS (enhanced)](engine-versions.md#redis-version-6.2) and [ElastiCache version 6.0 for Redis OSS (enhanced)](engine-versions.md#redis-version-6.0). 

Parameters added in Redis OSS 6.x are as follows. 


|  Details |  Description  | 
| --- | --- | 
| acl-pubsub-default (added in 6.2) |  Permitted values: `resetchannels`, `allchannels` Default: `allchannels` Type: string Modifiable: Yes Changes take effect: The existing Redis OSS users associated to the cluster will continue to have existing permissions. Either update the users or reboot the cluster to update the existing Redis OSS users. | Default pubsub channel permissions for ACL users deployed to this cluster.   | 
| cluster-allow-reads-when-down (added in 6.0) |  Default: no Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster | When set to yes, a Redis OSS (cluster mode enabled) replication group continues to process read commands even when a node is not able to reach a quorum of primaries.  When set to the default of no, the replication group rejects all commands. We recommend setting this value to yes if you are using a cluster with fewer than three node groups or your application can safely handle stale reads.   | 
| tracking-table-max-keys (added in 6.0) |  Default: 1,000,000 Type: number Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster | To assist client-side caching, Redis OSS supports tracking which clients have accessed which keys.  When the tracked key is modified, invalidation messages are sent to all clients to notify them their cached values are no longer valid. This value enables you to specify the upper bound of this table. After this parameter value is exceeded, clients are sent invalidation randomly. This value should be tuned to limit memory usage while still keeping track of enough keys. Keys are also invalidated under low memory conditions.   | 
| acllog-max-len (added in 6.0) |  Default: 128 Type: number Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster | This value corresponds to the max number of entries in the ACL log.   | 
| active-expire-effort (added in 6.0) |  Default: 1 Type: number Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster | Redis OSS deletes keys that have exceeded their time to live by two mechanisms. In one, a key is accessed and is found to be expired. In the other, a periodic job samples keys and causes those that have exceeded their time to live to expire. This parameter defines the amount of effort that Redis OSS uses to expire items in the periodic job.  The default value of 1 tries to avoid having more than 10 percent of expired keys still in memory. It also tries to avoid consuming more than 25 percent of total memory and to add latency to the system. You can increase this value up to 10 to increase the amount of effort spent on expiring keys. The tradeoff is higher CPU and potentially higher latency. We recommend a value of 1 unless you are seeing high memory usage and can tolerate an increase in CPU utilization.   | 
| lazyfree-lazy-user-del (added in 6.0) |  Default: no Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster | When the value is set to yes, the `DEL` command acts the same as `UNLINK`.   | 

Parameters removed in Redis OSS 6.x are as follows. 


|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| lua-replicate-commands |  Permitted values: yes/no Default: yes Type: boolean Modifiable: Yes Changes take effect: Immediately | Always enable Lua effect replication or not in Lua scripts  | 

### Redis OSS 5.0.3 parameter changes


**Parameter group family:** redis5.0

Redis OSS 5.0 default parameter groups
+ `default.redis5.0` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode disabled) clusters and replication groups.
+ `default.redis5.0.cluster.on` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode enabled) clusters and replication groups.


**Parameters added in Redis OSS 5.0.3**  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| rename-commands |  Default: none Type: string Modifiable: Yes Changes take effect: Immediately across all nodes in the cluster | A space-separated list of renamed Redis OSS commands. The following is a restricted list of commands available for renaming:  `APPEND AUTH BITCOUNT BITFIELD BITOP BITPOS BLPOP BRPOP BRPOPLPUSH BZPOPMIN BZPOPMAX CLIENT CLUSTER COMMAND DBSIZE DECR DECRBY DEL DISCARD DUMP ECHO EVAL EVALSHA EXEC EXISTS EXPIRE EXPIREAT FLUSHALL FLUSHDB GEOADD GEOHASH GEOPOS GEODIST GEORADIUS GEORADIUSBYMEMBER GET GETBIT GETRANGE GETSET HDEL HEXISTS HGET HGETALL HINCRBY HINCRBYFLOAT HKEYS HLEN HMGET HMSET HSET HSETNX HSTRLEN HVALS INCR INCRBY INCRBYFLOAT INFO KEYS LASTSAVE LINDEX LINSERT LLEN LPOP LPUSH LPUSHX LRANGE LREM LSET LTRIM MEMORY MGET MONITOR MOVE MSET MSETNX MULTI OBJECT PERSIST PEXPIRE PEXPIREAT PFADD PFCOUNT PFMERGE PING PSETEX PSUBSCRIBE PUBSUB PTTL PUBLISH PUNSUBSCRIBE RANDOMKEY READONLY READWRITE RENAME RENAMENX RESTORE ROLE RPOP RPOPLPUSH RPUSH RPUSHX SADD SCARD SCRIPT SDIFF SDIFFSTORE SELECT SET SETBIT SETEX SETNX SETRANGE SINTER SINTERSTORE SISMEMBER SLOWLOG SMEMBERS SMOVE SORT SPOP SRANDMEMBER SREM STRLEN SUBSCRIBE SUNION SUNIONSTORE SWAPDB TIME TOUCH TTL TYPE UNSUBSCRIBE UNLINK UNWATCH WAIT WATCH ZADD ZCARD ZCOUNT ZINCRBY ZINTERSTORE ZLEXCOUNT ZPOPMAX ZPOPMIN ZRANGE ZRANGEBYLEX ZREVRANGEBYLEX ZRANGEBYSCORE ZRANK ZREM ZREMRANGEBYLEX ZREMRANGEBYRANK ZREMRANGEBYSCORE ZREVRANGE ZREVRANGEBYSCORE ZREVRANK ZSCORE ZUNIONSTORE SCAN SSCAN HSCAN ZSCAN XINFO XADD XTRIM XDEL XRANGE XREVRANGE XLEN XREAD XGROUP XREADGROUP XACK XCLAIM XPENDING GEORADIUS_RO GEORADIUSBYMEMBER_RO LOLWUT XSETID SUBSTR`  | 

For more information, see [ElastiCache version 5.0.6 for Redis OSS (enhanced)](engine-versions.md#redis-version-5-0.6). 

### Redis OSS 5.0.0 parameter changes


**Parameter group family:** redis5.0

Redis OSS 5.0 default parameter groups
+ `default.redis5.0` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode disabled) clusters and replication groups.
+ `default.redis5.0.cluster.on` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode enabled) clusters and replication groups.


**Parameters added in Redis OSS 5.0**  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| stream-node-max-bytes |  Permitted values: 0\$1 Default: 4096 Type: integer Modifiable: Yes Changes take effect: Immediately | The stream data structure is a radix tree of nodes that encode multiple items inside. Use this configuration to specify the maximum size of a single node in radix tree in Bytes. If set to 0, the size of the tree node is unlimited.  | 
| stream-node-max-entries |  Permitted values: 0\$1 Default: 100 Type: integer Modifiable: Yes Changes take effect: Immediately | The stream data structure is a radix tree of nodes that encode multiple items inside. Use this configuration to specify the maximum number of items a single node can contain before switching to a new node when appending new stream entries. If set to 0, the number of items in the tree node is unlimited  | 
| active-defrag-max-scan-fields |  Permitted values: 1 to 1000000 Default: 1000 Type: integer Modifiable: Yes Changes take effect: Immediately | Maximum number of set/hash/zset/list fields that will be processed from the main dictionary scan  | 
| lua-replicate-commands |  Permitted values: yes/no Default: yes Type: boolean Modifiable: Yes Changes take effect: Immediately | Always enable Lua effect replication or not in Lua scripts  | 
| replica-ignore-maxmemory |  Default: yes Type: boolean Modifiable: No  | Determines if replica ignores maxmemory setting by not evicting items independent from the primary  | 

Redis OSS has renamed several parameters in engine version 5.0 in response to community feedback. For more information, see [What's New in Redis OSS 5?](https://aws.amazon.com/redis/Whats_New_Redis5/). The following table lists the new names and how they map to previous versions.


**Parameters renamed in Redis OSS 5.0**  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| replica-lazy-flush |  Default: yes Type: boolean Modifiable: No Former name: slave-lazy-flush  | Performs an asynchronous flushDB during replica sync. | 
| client-output-buffer-limit-replica-hard-limit | Default: For values see [Redis OSS node-type specific parameters](#ParameterGroups.Redis.NodeSpecific) Type: integer Modifiable: No Former name: client-output-buffer-limit-slave-hard-limit | For Redis OSS read replicas: If a client's output buffer reaches the specified number of bytes, the client will be disconnected. | 
| client-output-buffer-limit-replica-soft-limit | Default: For values see [Redis OSS node-type specific parameters](#ParameterGroups.Redis.NodeSpecific) Type: integer Modifiable: No Former name: client-output-buffer-limit-slave-soft-limit | For Redis OSS read replicas: If a client's output buffer reaches the specified number of bytes, the client will be disconnected, but only if this condition persists for client-output-buffer-limit-replica-soft-seconds. | 
| client-output-buffer-limit-replica-soft-seconds | Default: 60 Type: integer Modifiable: No Former name: client-output-buffer-limit-slave-soft-seconds  | For Redis OSS read replicas: If a client's output buffer remains at client-output-buffer-limit-replica-soft-limit bytes for longer than this number of seconds, the client will be disconnected. | 
| replica-allow-chaining | Default: no Type: string Modifiable: No Former name: slave-allow-chaining | Determines whether a read replica in Redis OSS can have read replicas of its own. | 
| min-replicas-to-write | Default: 0 Type: integer Modifiable: Yes Former name: min-slaves-to-write Changes Take Effect: Immediately | The minimum number of read replicas which must be available in order for the primary node to accept writes from clients. If the number of available replicas falls below this number, then the primary node will no longer accept write requests. If either this parameter or min-replicas-max-lag is 0, then the primary node will always accept writes requests, even if no replicas are available. | 
| min-replicas-max-lag  | Default: 10 Type: integer Modifiable: Yes Former name: min-slaves-max-lag Changes Take Effect: Immediately | The number of seconds within which the primary node must receive a ping request from a read replica. If this amount of time passes and the primary does not receive a ping, then the replica is no longer considered available. If the number of available replicas drops below min-replicas-to-write, then the primary will stop accepting writes at that point. If either this parameter or min-replicas-to-write is 0, then the primary node will always accept write requests, even if no replicas are available. | 
| close-on-replica-write  | Default: yes Type: boolean Modifiable: Yes Former name: close-on-slave-write Changes Take Effect: Immediately | If enabled, clients who attempt to write to a read-only replica will be disconnected. | 


**Parameters removed in Redis OSS 5.0**  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| repl-timeout |  Default: 60 Modifiable: No  | Parameter is not available in this version. | 

### Redis OSS 4.0.10 parameter changes


**Parameter group family:** redis4.0

Redis OSS 4.0.x default parameter groups
+ `default.redis4.0` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode disabled) clusters and replication groups.
+ `default.redis4.0.cluster.on` – Use this parameter group, or one derived from it, for Valkey or Redis OSS (cluster mode enabled) clusters and replication groups.


**Parameters changed in Redis OSS 4.0.10**  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| maxmemory-policy |  Permitted values: `allkeys-lru`, `volatile-lru`, **allkeys-lfu**, **volatile-lfu**, `allkeys-random`, `volatile-random`, `volatile-ttl`, `noeviction` Default: volatile-lru Type: string Modifiable: Yes Changes take place: immediately | maxmemory-policy was added in version 2.6.13. In version 4.0.10 two new permitted values are added: allkeys-lfu, which will evict any key using approximated LFU, and volatile-lfu, which will evict using approximated LFU among the keys with an expire set. In version 6.2, when the r6gd node family was introduced for use with data-tiering, only noeviction, volatile-lru and allkeys-lru max-memory policies are supported with r6gd node types.  | 


**Parameters added in Redis OSS 4.0.10**  

|  Name  |  Details |  Description  | 
| --- |--- |--- |
| **Async deletion parameters** | 
| --- |
| lazyfree-lazy-eviction |  Permitted values: yes/no Default: no Type: boolean Modifiable: Yes Changes take place: immediately | Performs an asynchronous delete on evictions. | 
| lazyfree-lazy-expire |  Permitted values: yes/no Default: no Type: boolean Modifiable: Yes Changes take place: immediately | Performs an asynchronous delete on expired keys. | 
| lazyfree-lazy-server-del |  Permitted values: yes/no Default: no Type: boolean Modifiable: Yes Changes take place: immediately | Performs an asynchronous delete for commands which update values. | 
| slave-lazy-flush |  Permitted values: N/A Default: no Type: boolean Modifiable: No Changes take place: N/A | Performs an asynchronous flushDB during slave sync. | 
| **LFU parameters** | 
| --- |
| lfu-log-factor |  Permitted values: any integer > 0 Default: 10 Type: integer Modifiable: Yes Changes take place: immediately | Set the log factor, which determines the number of key hits to saturate the key counter. | 
| lfu-decay-time |  Permitted values: any integer Default: 1 Type: integer Modifiable: Yes Changes take place: immediately | The amount of time in minutes to decrement the key counter. | 
| **Active defragmentation parameters** | 
| --- |
| activedefrag |  Permitted values: yes/no Default: no Type: boolean Modifiable: Yes Changes take place: immediately | Enables active defragmentation. In Valkey and Redis OSS versions 7.0 and above, AWS may automatically perform defragmentation when operationally necessary, regardless of this setting.  | 
| active-defrag-ignore-bytes |  Permitted values: 10485760-104857600 Default: 104857600 Type: integer Modifiable: Yes Changes take place: immediately | Minimum amount of fragmentation waste to start active defrag. | 
| active-defrag-threshold-lower |  Permitted values: 1-100 Default: 10 Type: integer Modifiable: Yes Changes take place: immediately | Minimum percentage of fragmentation to start active defrag. | 
| active-defrag-threshold-upper |  Permitted values: 1-100 Default: 100 Type: integer Modifiable: Yes Changes take place: immediately | Maximum percentage of fragmentation at which we use maximum effort. | 
| active-defrag-cycle-min |  Permitted values: 1-75 Default: 25 Type: integer Modifiable: Yes Changes take place: immediately | Minimal effort for defrag in CPU percentage. | 
| active-defrag-cycle-max |  Permitted values: 1-75 Default: 75 Type: integer Modifiable: Yes Changes take place: immediately | Maximal effort for defrag in CPU percentage. | 
| **Client output buffer parameters** | 
| --- |
| client-query-buffer-limit |  Permitted values: 1048576-1073741824 Default: 1073741824 Type: integer Modifiable: Yes Changes take place: immediately | Max size of a single client query buffer. | 
| proto-max-bulk-len |  Permitted values: 1048576-536870912 Default: 536870912 Type: integer Modifiable: Yes Changes take place: immediately | Max size of a single element request. | 

### Redis OSS 3.2.10 parameter changes


**Parameter group family: **redis3.2

ElastiCache for Redis OSS 3.2.10 there are no additional parameters supported.

### Redis OSS 3.2.6 parameter changes


**Parameter group family: **redis3.2

For Redis OSS 3.2.6 there are no additional parameters supported.

### Redis OSS 3.2.4 parameter changes


**Parameter group family:** redis3.2

Beginning with Redis OSS 3.2.4 there are two default parameter groups.
+ `default.redis3.2` – When running Redis OSS 3.2.4, specify this parameter group or one derived from it, if you want to create a Valkey or Redis OSS (cluster mode disabled) replication group and still use the additional features of Redis OSS 3.2.4.
+ `default.redis3.2.cluster.on` – Specify this parameter group or one derived from it, when you want to create a Valkey or Redis OSS (cluster mode enabled) replication group.

**Topics**
+ [

#### New parameters for Redis OSS 3.2.4
](#ParameterGroups.Redis.3-2-4.New)
+ [

#### Parameters changed in Redis OSS 3.2.4 (enhanced)
](#ParameterGroups.Redis.3-2-4.Changed)

#### New parameters for Redis OSS 3.2.4
New parameters

**Parameter group family:** redis3.2

For Redis OSS 3.2.4 the following additional parameters are supported.


****  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| list-max-ziplist-size | Default: -2 Type: integer Modifiable: No  | Lists are encoded in a special way to save space. The number of entries allowed per internal list node can be specified as a fixed maximum size or a maximum number of elements. For a fixed maximum size, use -5 through -1, meaning: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) | 
| list-compress-depth | Default: 0 Type: integer Modifiable: Yes Changes Take Effect: Immediately | Lists may also be compressed. Compress depth is the number of quicklist ziplist nodes from each side of the list to exclude from compression. The head and tail of the list are always uncompressed for fast push and pop operations. Settings are: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) | 
| cluster-enabled |  Default: no/yes \$1 Type: string Modifiable: No | Indicates whether this is a Valkey or Redis OSS (cluster mode enabled) replication group in cluster mode (yes) or a Valkey or Redis OSS (cluster mode enabled) replication group in non-cluster mode (no). Valkey or Redis OSS (cluster mode enabled) replication groups in cluster mode can partition their data across up to 500 node groups. \$1 Redis OSS 3.2.*x* has two default parameter groups. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html). | 
| cluster-require-full-coverage | Default: no Type: boolean Modifiable: yes Changes Take Effect: Immediately |  When set to `yes`, Valkey or Redis OSS (cluster mode enabled) nodes in cluster mode stop accepting queries if they detect there is at least one hash slot uncovered (no available node is serving it). This way if the cluster is partially down, the cluster becomes unavailable. It automatically becomes available again as soon as all the slots are covered again. However, sometimes you want the subset of the cluster which is working to continue to accept queries for the part of the key space that is still covered. To do so, just set the `cluster-require-full-coverage` option to `no`. | 
| hll-sparse-max-bytes | Default: 3000 Type: integer Modifiable: Yes Changes Take Effect: Immediately | HyperLogLog sparse representation bytes limit. The limit includes the 16 byte header. When a HyperLogLog using the sparse representation crosses this limit, it is converted into the dense representation. A value greater than 16000 is not recommended, because at that point the dense representation is more memory efficient. We recommend a value of about 3000 to have the benefits of the space-efficient encoding without slowing down PFADD too much, which is O(N) with the sparse encoding. The value can be raised to \$110000 when CPU is not a concern, but space is, and the data set is composed of many HyperLogLogs with cardinality in the 0 - 15000 range. | 
| reserved-memory-percent | Default: 25 Type: integer Modifiable: Yes Changes Take Effect: Immediately |  The percent of a node's memory reserved for nondata use. By default, the Redis OSS data footprint grows until it consumes all of the node's memory. If this occurs, then node performance will likely suffer due to excessive memory paging. By reserving memory, you can set aside some of the available memory for non-Redis OSS purposes to help reduce the amount of paging. This parameter is specific to ElastiCache, and is not part of the standard Redis OSS distribution. For more information, see `reserved-memory` and [Managing reserved memory for Valkey and Redis OSS](redis-memory-management.md). | 

#### Parameters changed in Redis OSS 3.2.4 (enhanced)
Changed parameters

**Parameter group family:** redis3.2

For Redis OSS 3.2.4 the following parameters were changed.


****  

|  Name  |  Details |  Change  | 
| --- | --- | --- | 
| activerehashing | Modifiable: Yes if the parameter group is not associated with any clusters. Otherwise, no. | Modifiable was No. | 
| databases | Modifiable: Yes if the parameter group is not associated with any clusters. Otherwise, no. | Modifiable was No. | 
| appendonly | Default: off Modifiable: No | If you want to upgrade from an earlier Redis OSS version, you must first turn `appendonly` off. | 
| appendfsync | Default: off Modifiable: No | If you want to upgrade from an earlier Redis OSS version, you must first turn `appendfsync` off. | 
| repl-timeout | Default: 60 Modifiable: No | Is now unmodifiable with a default of 60. | 
| tcp-keepalive | Default: 300 | Default was 0. | 
| list-max-ziplist-entries |  | Parameter is no longer available. | 
| list-max-ziplist-value |  | Parameter is no longer available. | 

### Redis OSS 2.8.24 (enhanced) added parameters


**Parameter group family:** redis2.8

For Redis OSS 2.8.24 there are no additional parameters supported.

### Redis OSS 2.8.23 (enhanced) added parameters


**Parameter group family:** redis2.8

For Redis OSS 2.8.23 the following additional parameter is supported.


****  

|  Name  |  Details |  Description  | 
| --- | --- | --- | 
| close-on-slave-write  | Default: yes Type: string (yes/no) Modifiable: Yes Changes Take Effect: Immediately | If enabled, clients who attempt to write to a read-only replica will be disconnected. | 

#### How close-on-slave-write works


The `close-on-slave-write` parameter is introduced by Amazon ElastiCache to give you more control over how your cluster responds when a primary node and a read replica node swap roles due to promoting a read replica to primary.

![\[Image: close-on-replica-write, everything working fine\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/images/ElastiCache-close-on-slave-write-01.png)


If the read-replica cluster is promoted to primary for any reason other than a Multi-AZ enabled replication group failing over, the client will continue trying to write to endpoint A. Because endpoint A is now the endpoint for a read-replica, these writes will fail. This is the behavior for Redis OSS before ElastiCache introducing `close-on-replica-write` and the behavior if you disable `close-on-replica-write`.

![\[Image: close-on-slave-write, writes failing\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/images/ElastiCache-close-on-slave-write-02.png)


With `close-on-replica-write` enabled, any time a client attempts to write to a read-replica, the client connection to the cluster is closed. Your application logic should detect the disconnection, check the DNS table, and reconnect to the primary endpoint, which now would be endpoint B.

![\[Image: close-on-slave-write, writing to new primary cluster\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/images/ElastiCache-close-on-slave-write-03.png)


#### When you might disable close-on-replica-write


If disabling `close-on-replica-write` results in writes to the failing cluster, why disable `close-on-replica-write`?

As previously mentioned, with `close-on-replica-write` enabled, any time a client attempts to write to a read-replica the client connection to the cluster is closed. Establishing a new connection to the node takes time. Thus, disconnecting and reconnecting as a result of a write request to the replica also affects the latency of read requests that are served through the same connection. This effect remains in place until a new connection is established. If your application is especially read-heavy or very latency-sensitive, you might keep your clients connected to avoid degrading read performance. 

### Redis OSS 2.8.22 (enhanced) added parameters


**Parameter group family:** redis2.8

For Redis OSS 2.8.22 there are no additional parameters supported.

**Important**  
Beginning with Redis OSS version 2.8.22, `repl-backlog-size` applies to the primary cluster as well as to replica clusters.
Beginning with Redis OSS version 2.8.22, the `repl-timeout` parameter is not supported. If it is changed, ElastiCache will overwrite with the default (60s), as we do with `appendonly`.

The following parameters are no longer supported.
+ *appendonly*
+ *appendfsync*
+ *repl-timeout*

### Redis OSS 2.8.21 added parameters


**Parameter group family:** redis2.8

For Redis OSS 2.8.21, there are no additional parameters supported.

### Redis OSS 2.8.19 added parameters


**Parameter group family:** redis2.8

For Redis OSS 2.8.19 there are no additional parameters supported.

### Redis OSS 2.8.6 added parameters


**Parameter group family:** redis2.8

For Redis OSS 2.8.6 the following additional parameters are supported.


****  

|  Name  |  Details  |  Description  | 
| --- | --- | --- | 
| min-slaves-max-lag  | Default: 10 Type: integer Modifiable: Yes Changes Take Effect: Immediately | The number of seconds within which the primary node must receive a ping request from a read replica. If this amount of time passes and the primary does not receive a ping, then the replica is no longer considered available. If the number of available replicas drops below min-slaves-to-write, then the primary will stop accepting writes at that point. If either this parameter or min-slaves-to-write is 0, then the primary node will always accept writes requests, even if no replicas are available. | 
| min-slaves-to-write | Default: 0 Type: integer Modifiable: Yes Changes Take Effect: Immediately | The minimum number of read replicas which must be available in order for the primary node to accept writes from clients. If the number of available replicas falls below this number, then the primary node will no longer accept write requests. If either this parameter or min-slaves-max-lag is 0, then the primary node will always accept writes requests, even if no replicas are available. | 
| notify-keyspace-events | Default: (an empty string) Type: string Modifiable: Yes Changes Take Effect: Immediately | The types of keyspace events that Redis OSS can notify clients of. Each event type is represented by a single letter: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) You can have any combination of these event types. For example, *AKE* means that Redis OSS can publish notifications of all event types. Do not use any characters other than those listed above; attempts to do so will result in error messages. By default, this parameter is set to an empty string, meaning that keyspace event notification is disabled. | 
| repl-backlog-size | Default: 1048576 Type: integer Modifiable: Yes Changes Take Effect: Immediately | The size, in bytes, of the primary node backlog buffer. The backlog is used for recording updates to data at the primary node. When a read replica connects to the primary, it attempts to perform a partial sync (`psync`), where it applies data from the backlog to catch up with the primary node. If the `psync` fails, then a full sync is required. The minimum value for this parameter is 16384.  Beginning with Redis OSS 2.8.22, this parameter applies to the primary cluster as well as the read replicas.  | 
| repl-backlog-ttl | Default: 3600 Type: integer Modifiable: Yes Changes Take Effect: Immediately | The number of seconds that the primary node will retain the backlog buffer. Starting from the time the last replica node disconnected, the data in the backlog will remain intact until `repl-backlog-ttl` expires. If the replica has not connected to the primary within this time, then the primary will release the backlog buffer. When the replica eventually reconnects, it will have to perform a full sync with the primary. If this parameter is set to 0, then the backlog buffer will never be released. | 
| repl-timeout | Default: 60 Type: integer Modifiable: Yes Changes Take Effect: Immediately | Represents the timeout period, in seconds, for: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html) | 

### Redis OSS 2.6.13 parameters


**Parameter group family:** redis2.6

Redis OSS 2.6.13 was the first version of Redis OSS supported by ElastiCache. The following table shows the Redis OSS 2.6.13 parameters that ElastiCache supports.


****  
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ParameterGroups.Engine.html)

**Note**  
If you do not specify a parameter group for your Redis OSS 2.6.13 cluster, then a default parameter group (`default.redis2.6`) will be used. You cannot change the values of any parameters in the default parameter group; however, you can always create a custom parameter group and assign it to your cluster at any time.

### Redis OSS node-type specific parameters


Although most parameters have a single value, some parameters have different values depending on the node type used. The following table shows the default values for the `maxmemory`, `client-output-buffer-limit-slave-hard-limit`, and `client-output-buffer-limit-slave-soft-limit` parameters for each node type. The value of `maxmemory` is the maximum number of bytes available to you for use, data and other uses, on the node. For more information, see [Available memory](https://aws.amazon.com/premiumsupport/knowledge-center/available-memory-elasticache-redis-node/).

**Note**  
The `maxmemory` parameter cannot be modified.


|  Node type  | Maxmemory  | Client-output-buffer-limit-slave-hard-limit | Client-output-buffer-limit-slave-soft-limit | 
| --- | --- | --- | --- | 
| cache.t1.micro | 142606336 | 14260633 | 14260633 | 
| cache.t2.micro | 581959680 | 58195968 | 58195968 | 
| cache.t2.small | 1665138688 | 166513868 | 166513868 | 
| cache.t2.medium | 3461349376 | 346134937 | 346134937 | 
| cache.t3.micro | 536870912 | 53687091 | 53687091 | 
| cache.t3.small | 1471026299 | 147102629 | 147102629 | 
| cache.t3.medium | 3317862236 | 331786223 | 331786223 | 
| cache.t4g.micro | 536870912 | 53687091 | 53687091 | 
| cache.t4g.small | 1471026299 | 147102629 | 147102629 | 
| cache.t4g.medium | 3317862236 | 331786223 | 331786223 | 
| cache.m1.small | 943718400 | 94371840 | 94371840 | 
| cache.m1.medium | 3093299200 | 309329920 | 309329920 | 
| cache.m1.large | 7025459200 | 702545920 | 702545920 | 
| cache.m1.xlarge | 14889779200 | 1488977920 | 1488977920 | 
| cache.m2.xlarge | 17091788800 | 1709178880 | 1709178880 | 
| cache.m2.2xlarge | 35022438400 | 3502243840 | 3502243840 | 
| cache.m2.4xlarge | 70883737600 | 7088373760 | 7088373760 | 
| cache.m3.medium | 2988441600 | 309329920 | 309329920 | 
| cache.m3.large | 6501171200 | 650117120 | 650117120 | 
| cache.m3.xlarge | 14260633600 | 1426063360 | 1426063360 | 
| cache.m3.2xlarge | 29989273600 | 2998927360 | 2998927360 | 
| cache.m4.large | 6892593152 | 689259315 | 689259315 | 
| cache.m4.xlarge | 15328501760 | 1532850176 | 1532850176 | 
| cache.m4.2xlarge | 31889126359 | 3188912636 | 3188912636 | 
| cache.m4.4xlarge | 65257290629 | 6525729063 | 6525729063 | 
| cache.m4.10xlarge | 166047614239 | 16604761424 | 16604761424 | 
| cache.m5.large | 6854542746 | 685454275  | 685454275 | 
| cache.m5.xlarge | 13891921715 | 1389192172 | 1389192172 | 
| cache.m5.2xlarge | 27966669210 | 2796666921 | 2796666921 | 
| cache.m5.4xlarge | 56116178125 | 5611617812 | 5611617812 | 
| cache.m5.12xlarge | 168715971994 | 16871597199 | 16871597199 | 
| cache.m5.24xlarge | 337500562842 | 33750056284 | 33750056284 | 
| cache.m6g.large | 6854542746 | 685454275 | 685454275 | 
| cache.m6g.xlarge | 13891921715 | 1389192172 | 1389192172 | 
| cache.m6g.2xlarge | 27966669210 | 2796666921 | 2796666921 | 
| cache.m6g.4xlarge | 56116178125 | 5611617812 | 5611617812 | 
| cache.m6g.8xlarge | 111325552312 | 11132555231 | 11132555231 | 
| cache.m6g.12xlarge | 168715971994 | 16871597199 | 16871597199 | 
| cache.m6g.16xlarge | 225000375228 | 22500037523 | 22500037523 | 
| cache.c1.xlarge | 6501171200 | 650117120 | 650117120 | 
| cache.r3.large | 14470348800 | 1468006400 | 1468006400 | 
| cache.r3.xlarge | 30513561600 | 3040870400 | 3040870400 | 
| cache.r3.2xlarge | 62495129600 | 6081740800 | 6081740800 | 
| cache.r3.4xlarge | 126458265600 | 12268339200 | 12268339200 | 
| cache.r3.8xlarge | 254384537600 | 24536678400 | 24536678400 | 
| cache.r4.large | 13201781556 | 1320178155 | 1320178155 | 
| cache.r4.xlarge | 26898228839 | 2689822883 | 2689822883 | 
| cache.r4.2xlarge | 54197537997 | 5419753799 | 5419753799 | 
| cache.r4.4xlarge | 108858546586 | 10885854658 | 10885854658 | 
| cache.r4.8xlarge | 218255432090 | 21825543209 | 21825543209 | 
| cache.r4.16xlarge | 437021573120 | 43702157312 | 43702157312 | 
| cache.r5.large | 14037181030 | 1403718103 | 1403718103 | 
| cache.r5.xlarge | 28261849702 | 2826184970 | 2826184970 | 
| cache.r5.2xlarge | 56711183565 | 5671118356 | 5671118356 | 
| cache.r5.4xlarge | 113609865216 | 11360986522 | 11360986522 | 
| cache.r5.12xlarge | 341206346547 | 34120634655 | 34120634655 | 
| cache.r5.24xlarge | 682485973811 | 68248597381 | 68248597381 | 
| cache.r6g.large | 14037181030 | 1403718103 | 1403718103 | 
| cache.r6g.xlarge | 28261849702 | 2826184970 | 2826184970 | 
| cache.r6g.2xlarge | 56711183565 | 5671118356 | 5671118356 | 
| cache.r6g.4xlarge | 113609865216 | 11360986522 | 11360986522 | 
| cache.r6g.8xlarge | 225000375228 | 22500037523 | 22500037523 | 
| cache.r6g.12xlarge | 341206346547 | 34120634655 | 34120634655 | 
| cache.r6g.16xlarge | 450000750456 | 45000075046 | 45000075046 | 
| cache.r6gd.xlarge | 28261849702 | 2826184970 | 2826184970 | 
| cache.r6gd.2xlarge | 56711183565 | 5671118356 | 5671118356 | 
| cache.r6gd.4xlarge | 113609865216 | 11360986522 | 11360986522 | 
| cache.r6gd.8xlarge | 225000375228 | 22500037523 | 22500037523 | 
| cache.r6gd.12xlarge | 341206346547 | 34120634655 | 34120634655 | 
| cache.r6gd.16xlarge | 450000750456 | 45000075046 | 45000075046 | 
| cache.r7g.large | 14037181030 | 1403718103 | 1403718103 | 
| cache.r7g.xlarge | 28261849702 | 2826184970 | 2826184970 | 
| cache.r7g.2xlarge | 56711183565 | 5671118356 | 5671118356 | 
| cache.r7g.4xlarge | 113609865216 | 11360986522 | 11360986522 | 
| cache.r7g.8xlarge | 225000375228 | 22500037523 | 22500037523 | 
| cache.r7g.12xlarge | 341206346547 | 34120634655 | 34120634655 | 
| cache.r7g.16xlarge | 450000750456 | 45000075046 | 45000075046 | 
| cache.m7g.large | 6854542746 | 685454275 | 685454275 | 
| cache.m7g.xlarge | 13891921715 | 1389192172 | 1389192172 | 
| cache.m7g.2xlarge | 27966669210 | 2796666921 | 2796666921 | 
| cache.m7g.4xlarge | 56116178125 | 5611617812 | 5611617812 | 
| cache.m7g.8xlarge | 111325552312 | 11132555231 | 11132555231 | 
| cache.m7g.12xlarge | 168715971994 | 16871597199 | 16871597199 | 
| cache.m7g.16xlarge | 225000375228 | 22500037523 | 22500037523 | 
| cache.c7gn.large | 3317862236 | 1403718103 | 1403718103 | 
| cache.c7gn.xlarge | 6854542746 | 2826184970 | 2826184970 | 
| cache.c7gn.2xlarge | 13891921715 | 5671118356 | 5671118356 | 
| cache.c7gn.4xlarge | 27966669210 | 11360986522 | 11360986522 | 
| cache.c7gn.8xlarge | 56116178125 | 22500037523 | 22500037523 | 
| cache.c7gn.12xlarge | 84357985997 | 34120634655 | 34120634655 | 
| cache.c7gn.16xlarge | 113609865216 | 45000075046 | 45000075046 | 

**Note**  
All current generation instance types are created in an Amazon Virtual Private Cloud VPC by default.  
T1 instances do not support Multi-AZ.  
T1 and T2 instances do not support Redis OSS AOF.  
Redis OSS configuration variables `appendonly` and `appendfsync` are not supported on Redis OSS version 2.8.22 and later.

## Memcached specific parameters


**Memcached**

If you do not specify a parameter group for your Memcached cluster, then a default parameter group appropriate to your engine version will be used. You can't change the values of any parameters in a default parameter group. However, you can create a custom parameter group and assign it to your cluster at any time. For more information, see [Creating an ElastiCache parameter group](ParameterGroups.Creating.md).

**Topics**
+ [

### Memcached 1.6.17 changes
](#ParameterGroups.Memcached.1.6.17)
+ [

### Memcached 1.6.6 added parameters
](#ParameterGroups.Memcached.1-6-6)
+ [

### Memcached 1.5.10 parameter changes
](#ParameterGroups.Memcached.1-5-10)
+ [

### Memcached 1.4.34 added parameters
](#ParameterGroups.Memcached.1-4-34)
+ [

### Memcached 1.4.33 added parameters
](#ParameterGroups.Memcached.1-4-33)
+ [

### Memcached 1.4.24 added parameters
](#ParameterGroups.Memcached.1-4-24)
+ [

### Memcached 1.4.14 added parameters
](#ParameterGroups.Memcached.1-4-14)
+ [

### Memcached 1.4.5 supported parameters
](#ParameterGroups.Memcached.1-4-5)
+ [

### Memcached connection overhead
](#ParameterGroups.Memcached.Overhead)
+ [

### Memcached node-type specific parameters
](#ParameterGroups.Memcached.NodeSpecific)

### Memcached 1.6.17 changes


From Memcached 1.6.17, we no longer support these administrative commands: `lru_crawler`, `lru`, and `slabs`. With these changes, you will not be able to enable/disable `lru_crawler` at runtime via commands. Please enable/disable `lru_crawler` by modifying your custom parameter group.

### Memcached 1.6.6 added parameters


For Memcached 1.6.6, no additional parameters are supported.

**Parameter group family:** memcached1.6

### Memcached 1.5.10 parameter changes


For Memcached 1.5.10, the following additional parameters are supported.

**Parameter group family:** memcached1.5


| Name | Details | Description | 
| --- | --- | --- | 
| no\$1modern  | Default: 1 Type: boolean Modifiable: Yes Allowed\$1Values: 0,1 Changes Take Effect: At launch  |  An alias for disabling `slab_reassign`, `lru_maintainer_thread`, `lru_segmented`, and`maxconns_fast` commands. When using Memcached 1.5 and higher, `no_modern` also sets the hash\$1algorithm to `jenkins`. In addition, when using Memcached 1.5.10, `inline_ascii_reponse` is controlled by the parameter `parallelly`. This means that if `no_modern` is disabled then `inline_ascii_reponse` is disabled. From Memcached engine 1.5.16 onward the `inline_ascii_response` parameter no longer applies, so `no_modern` being abled or disabled has no effect on `inline_ascii_reponse`. If `no_modern` is disabled, then `slab_reassign`, `lru_maintainer_thread`, `lru_segmented`, and `maxconns_fast` WILL be enabled. Since `slab_automove` and `hash_algorithm` parameters are not SWITCH parameters, their setting is based on the configurations in the parameter group. If you want to disable `no_modern` and revert to `modern`, you must configure a custom parameter group to disable this parameter and then reboot for these changes to take effect.   The default configuration value for this parameter has been changed from 0 to 1 as of August 20, 2021. The updated default value will get automatically picked up by new ElastiCache users for each regions after August 20th, 2021. Existing ElastiCache users in the regions before August 20th, 2021 need to manually modify their custom parameter groups in order to pick up this new change.   | 
| inline\$1ascii\$1resp  | Default: 0 Type: boolean Modifiable: Yes Allowed\$1Values: 0,1 Changes Take Effect: At launch  |  Stores numbers from `VALUE` response, inside an item, using up to 24 bytes. Small slowdown for ASCII `get`, `faster` sets.  | 

For Memcached 1.5.10, the following parameters are removed.


| Name | Details | Description | 
| --- | --- | --- | 
| expirezero\$1does\$1not\$1evict  | Default: 0 Type: boolean Modifiable: Yes Allowed\$1Values: 0,1 Changes Take Effect: At launch  |  No longer supported in this version. | 
| modern  | Default: 1 Type: boolean Modifiable: Yes (requires re-launch if set to `no_modern`) Allowed\$1Values: 0,1 Changes Take Effect: At launch  |  No longer supported in this version. Starting with this version, `no-modern` is enabled by default with every launch or re-launch.  | 

### Memcached 1.4.34 added parameters


For Memcached 1.4.34, no additional parameters are supported.

**Parameter group family:** memcached1.4

### Memcached 1.4.33 added parameters


For Memcached 1.4.33, the following additional parameters are supported.

**Parameter group family:** memcached1.4


| Name | Details | Description | 
| --- | --- | --- | 
|  modern  | Default: enabled Type: boolean Modifiable: Yes Changes Take Effect: At launch  |  An alias to multiple features. Enabling `modern` is equivalent to turning following commands on and using a murmur3 hash algorithm: `slab_reassign`, `slab_automove`, `lru_crawler`, `lru_maintainer`, `maxconns_fast`, and `hash_algorithm=murmur3`. | 
|  watch  | Default: enabled Type: boolean Modifiable: Yes Changes Take Effect: Immediately Logs can get dropped if user hits their `watcher_logbuf_size` and `worker_logbuf_size` limits.  |  Logs fetches, evictions or mutations. When, for example, user turns `watch` on, they can see logs when `get`, `set`, `delete`, or `update` occur. | 
|  idle\$1timeout  | Default: 0 (disabled) Type: integer Modifiable: Yes Changes Take Effect: At Launch  |  The minimum number of seconds a client will be allowed to idle before being asked to close. Range of values: 0 to 86400. | 
|  track\$1sizes  | Default: disabled Type: boolean Modifiable: Yes Changes Take Effect: At Launch  |  Shows the sizes each slab group has consumed. Enabling `track_sizes` lets you run `stats sizes` without the need to run `stats sizes_enable`. | 
|  watcher\$1logbuf\$1size  | Default: 256 (KB) Type: integer Modifiable: Yes Changes Take Effect: At Launch  |  The `watch` command turns on stream logging for Memcached. However `watch` can drop logs if the rate of evictions, mutations or fetches are high enough to cause the logging buffer to become full. In such situations, users can increase the buffer size to reduce the chance of log losses. | 
|  worker\$1logbuf\$1size  | Default: 64 (KB) Type: integer Modifiable: Yes Changes Take Effect: At Launch  |  The `watch` command turns on stream logging for Memcached. However `watch` can drop logs if the rate of evictions, mutations or fetches are high enough to cause logging buffer get full. In such situations, users can increase the buffer size to reduce the chance of log losses. | 
|  slab\$1chunk\$1max  | Default: 524288 (bytes)  Type: integer Modifiable: Yes Changes Take Effect: At Launch  |  Specifies the maximum size of a slab. Setting smaller slab size uses memory more efficiently. Items larger than `slab_chunk_max` are split over multiple slabs. | 
|  lru\$1crawler metadump [all\$11\$12\$13] | Default: disabled  Type: boolean Modifiable: Yes Changes Take Effect: Immediately  |  if lru\$1crawler is enabled this command dumps all keys. `all\|1\|2\|3` - all slabs, or specify a particular slab number | 

### Memcached 1.4.24 added parameters


For Memcached 1.4.24, the following additional parameters are supported.

**Parameter group family:** memcached1.4


| Name | Details | Description | 
| --- | --- | --- | 
|  disable\$1flush\$1all  | Default: 0 (disabled) Type: boolean Modifiable: Yes Changes Take Effect: At launch  |  Add parameter (`-F`) to disable flush\$1all. Useful if you never want to be able to run a full flush on production instances. Values: 0, 1 (user can do a `flush_all` when the value is 0). | 
|  hash\$1algorithm  | Default: jenkins Type: string Modifiable: Yes Changes Take Effect: At launch  | The hash algorithm to be used. Permitted values: murmur3 and jenkins. | 
|  lru\$1crawler  | Default: 0 (disabled) Type: boolean Modifiable: Yes Changes Take Effect: After restart  You can temporarily enable `lru_crawler` at runtime from the command line. For more information, see the Description column.   |  Cleans slab classes of items that have expired. This is a low impact process that runs in the background. Currently requires initiating a crawl using a manual command. To temporarily enable, run `lru_crawler enable` at the command line. `lru_crawler 1,3,5` crawls slab classes 1, 3, and 5 looking for expired items to add to the freelist. Values: 0,1  Enabling `lru_crawler` at the command line enables the crawler until either disabled at the command line or the next reboot. To enable permanently, you must modify the parameter value. For more information, see [Modifying an ElastiCache parameter group](ParameterGroups.Modifying.md).   | 
|  lru\$1maintainer  | Default: 0 (disabled) Type: boolean Modifiable: Yes Changes Take Effect: At launch  |  A background thread that shuffles items between the LRUs as capacities are reached. Values: 0, 1.  | 
|  expirezero\$1does\$1not\$1evict  | Default: 0 (disabled) Type: boolean Modifiable: Yes Changes Take Effect: At launch  |  When used with `lru_maintainer`, makes items with an expiration time of 0 unevictable.   This can crowd out memory available for other evictable items.   Can be set to disregard `lru_maintainer`. | 

### Memcached 1.4.14 added parameters


For Memcached 1.4.14, the following additional parameters are supported.

**Parameter group family:** memcached1.4


**Parameters added in Memcached 1.4.14**  

|  Name  |  Details  |  Description  | 
| --- | --- | --- | 
| config\$1max | Default: 16 Type: integer Modifiable: No | The maximum number of ElastiCache configuration entries. | 
| config\$1size\$1max | Default: 65536 Type: integer Modifiable: No | The maximum size of the configuration entries, in bytes. | 
| hashpower\$1init | Default: 16 Type: integer Modifiable: No | The initial size of the ElastiCache hash table, expressed as a power of two. The default is 16 (2^16), or 65536 keys. | 
| maxconns\$1fast | Default: 0 (false) Type: Boolean Modifiable: Yes Changes Take Effect: After restart | Changes the way in which new connections requests are handled when the maximum connection limit is reached. If this parameter is set to 0 (zero), new connections are added to the backlog queue and will wait until other connections are closed. If the parameter is set to 1, ElastiCache sends an error to the client and immediately closes the connection. | 
| slab\$1automove | Default: 0 Type: integer Modifiable: Yes Changes Take Effect: After restart | Adjusts the slab automove algorithm: If this parameter is set to 0 (zero), the automove algorithm is disabled. If it is set to 1, ElastiCache takes a slow, conservative approach to automatically moving slabs. If it is set to 2, ElastiCache aggressively moves slabs whenever there is an eviction. (This mode is not recommended except for testing purposes.) | 
| slab\$1reassign | Default: 0 (false) Type: Boolean Modifiable: Yes Changes Take Effect: After restart | Enable or disable slab reassignment. If this parameter is set to 1, you can use the "slabs reassign" command to manually reassign memory. | 

### Memcached 1.4.5 supported parameters


**Parameter group family:** memcached1.4

For Memcached 1.4.5, the following parameters are supported.


**Parameters added in Memcached 1.4.5**  

|  Name  |  Details  |  Description  | 
| --- | --- | --- | 
| backlog\$1queue\$1limit | Default: 1024 Type: integer Modifiable: No | The backlog queue limit. | 
| binding\$1protocol | Default: auto Type: string Modifiable: Yes Changes Take Effect: After restart | The binding protocol. Permissible values are: `ascii` and `auto`. For guidance on modifying the value of `binding_protocol`, see [Modifying an ElastiCache parameter group](ParameterGroups.Modifying.md). | 
| cas\$1disabled | Default: 0 (false) Type: Boolean Modifiable: Yes Changes Take Effect: After restart | If 1 (true), check and set (CAS) operations will be disabled, and items stored will consume 8 fewer bytes than with CAS enabled. | 
| chunk\$1size | Default: 48 Type: integer Modifiable: Yes Changes Take Effect: After restart | The minimum amount, in bytes, of space to allocate for the smallest item's key, value, and flags. | 
| chunk\$1size\$1growth\$1factor | Default: 1.25 Type: float Modifiable: Yes Changes Take Effect: After restart | The growth factor that controls the size of each successive Memcached chunk; each chunk will be chunk\$1size\$1growth\$1factor times larger than the previous chunk. | 
| error\$1on\$1memory\$1exhausted | Default: 0 (false) Type: Boolean Modifiable: Yes Changes Take Effect: After restart | If 1 (true), when there is no more memory to store items, Memcached will return an error rather than evicting items. | 
| large\$1memory\$1pages | Default: 0 (false) Type: Boolean Modifiable: No | If 1 (true), ElastiCache will try to use large memory pages. | 
| lock\$1down\$1paged\$1memory | Default: 0 (false) Type: Boolean Modifiable: No | If 1 (true), ElastiCache will lock down all paged memory. | 
| max\$1item\$1size | Default: 1048576 Type: integer Modifiable: Yes Changes Take Effect: After restart | The size, in bytes, of the largest item that can be stored in the cluster. | 
| max\$1simultaneous\$1connections | Default: 65000 Type: integer Modifiable: No | The maximum number of simultaneous connections. | 
| maximize\$1core\$1file\$1limit | Default: 0 (false) Type: Boolean Modifiable:  Changes Take Effect: After restart | If 1 (true), ElastiCache will maximize the core file limit. | 
| memcached\$1connections\$1overhead | Default: 100 Type: integer Modifiable: Yes Changes Take Effect: After restart | The amount of memory to be reserved for Memcached connections and other miscellaneous overhead. For information about this parameter, see [Memcached connection overhead](#ParameterGroups.Memcached.Overhead). | 
| requests\$1per\$1event | Default: 20 Type: integer Modifiable: No | The maximum number of requests per event for a given connection. This limit is required to prevent resource starvation. | 

### Memcached connection overhead


On each node, the memory made available for storing items is the total available memory on that node (which is stored in the `max_cache_memory` parameter) minus the memory used for connections and other overhead (which is stored in the `memcached_connections_overhead` parameter). For example, a node of type `cache.m1.small` has a `max_cache_memory` of 1300MB. With the default `memcached_connections_overhead` value of 100MB, the Memcached process will have 1200MB available to store items.

The default values for the `memcached_connections_overhead` parameter satisfy most use cases; however, the required amount of allocation for connection overhead can vary depending on multiple factors, including request rate, payload size, and the number of connections.

You can change the value of the `memcached_connections_overhead` to better suit the needs of your application. For example, increasing the value of the `memcached_connections_overhead` parameter will reduce the amount of memory available for storing items and provide a larger buffer for connection overhead. Decreasing the value of the `memcached_connections_overhead` parameter will give you more memory to store items, but can increase your risk of swap usage and degraded performance. If you observe swap usage and degraded performance, try increasing the value of the `memcached_connections_overhead` parameter.

**Important**  
For the `cache.t1.micro` node type, the value for `memcached_connections_overhead` is determined as follows:  
If you cluster is using the default parameter group, ElastiCache will set the value for `memcached_connections_overhead` to 13MB.
If your cluster is using a parameter group that you have created yourself, you can set the value of `memcached_connections_overhead` to a value of your choice.

### Memcached node-type specific parameters


Although most parameters have a single value, some parameters have different values depending on the node type used. The following table shows the default values for the `max_cache_memory` and `num_threads` parameters for each node type. The values on these parameters cannot be modified.


|  Node type  | max\$1cache\$1memory (in megabytes)  | num\$1threads  | 
| --- | --- | --- | 
| cache.t1.micro | 213  | 1 | 
| cache.t2.micro | 555 | 1 | 
| cache.t2.small | 1588 | 1 | 
| cache.t2.medium | 3301 | 2 | 
| cache.t3.micro | 512 | 2 | 
| cache.t3.small | 1402 | 2 | 
| cache.t3.medium | 3364 | 2 | 
| cache.t4g.micro | 512 | 2 | 
| cache.t4g.small | 1402 | 2 | 
| cache.t4g.medium | 3164 | 2 | 
| cache.m1.small | 1301 | 1 | 
| cache.m1.medium | 3350 | 1 | 
| cache.m1.large | 7100 | 2 | 
| cache.m1.xlarge | 14600  | 4 | 
| cache.m2.xlarge | 33800 | 2 | 
| cache.m2.2xlarge | 30412 | 4 | 
| cache.m2.4xlarge | 68000  | 16 | 
| cache.m3.medium | 2850 | 1 | 
| cache.m3.large | 6200 | 2 | 
| cache.m3.xlarge | 13600 | 4 | 
| cache.m3.2xlarge | 28600 | 8 | 
| cache.m4.large | 6573 | 2 | 
| cache.m4.xlarge | 11496  | 4 | 
| cache.m4.2xlarge | 30412 | 8 | 
| cache.m4.4xlarge | 62234 | 16 | 
| cache.m4.10xlarge | 158355 | 40 | 
| cache.m5.large | 6537 | 2 | 
| cache.m5.xlarge | 13248 | 4 | 
| cache.m5.2xlarge | 26671 | 8 | 
| cache.m5.4xlarge | 53516 | 16 | 
| cache.m5.12xlarge | 160900 | 48 | 
| cache.m5.24xlarge | 321865  | 96 | 
| cache.m6g.large | 6537 | 2 | 
| cache.m6g.xlarge | 13248 | 4 | 
| cache.m6g.2xlarge | 26671 | 8 | 
| cache.m6g.4xlarge | 53516 | 16 | 
| cache.m6g.8xlarge | 107000 | 32 | 
| cache.m6g.12xlarge | 160900 | 48 | 
| cache.m6g.16xlarge | 214577 | 64 | 
| cache.c1.xlarge | 6600 | 8 | 
| cache.r3.large | 13800 | 2 | 
| cache.r3.xlarge | 29100 | 4 | 
| cache.r3.2xlarge | 59600 | 8 | 
| cache.r3.4xlarge | 120600 | 16 | 
| cache.r3.8xlarge | 120600 | 32 | 
| cache.r4.large | 12590 | 2 | 
| cache.r4.xlarge | 25652 | 4 | 
| cache.r4.2xlarge | 51686 | 8 | 
| cache.r4.4xlarge | 103815 | 16 | 
| cache.r4.8xlarge | 208144 | 32 | 
| cache.r4.16xlarge | 416776 | 64 | 
| cache.r5.large | 13387 | 2 | 
| cache.r5.xlarge | 26953 | 4 | 
| cache.r5.2xlarge | 54084 | 8 | 
| cache.r5.4xlarge | 108347 | 16 | 
| cache.r5.12xlarge | 325400 | 48 | 
| cache.r5.24xlarge | 650869 | 96 | 
| cache.r6g.large | 13387 | 2 | 
| cache.r6g.xlarge | 26953 | 4 | 
| cache.r6g.2xlarge | 54084 | 8 | 
| cache.r6g.4xlarge | 108347 | 16 | 
| cache.r6g.8xlarge | 214577 | 32 | 
| cache.r6g.12xlarge | 325400 | 48 | 
| cache.r6g.16xlarge | 429154 | 64 | 
| cache.c7gn.large | 3164 | 2 | 
| cache.c7gn.xlarge | 6537 | 4 | 
| cache.c7gn.2xlarge | 13248 | 8 | 
| cache.c7gn.4xlarge | 26671 | 16 | 
| cache.c7gn.8xlarge | 53516 | 32 | 
| cache.c7gn.12xlarge | 325400 | 48 | 
| cache.c7gn.16xlarge | 108347 | 64 | 

**Note**  
All T2 instances are created in an Amazon Virtual Private Cloud (Amazon VPC).