Back up and export a database

Overview

The backup options for Redis Cloud databases depend on your plan:

- Redis Cloud Pro subscriptions can back up or export a database on-demand and schedule daily backups that occur during a set hour.

- Paid Redis Cloud Essentials plans can back up or export a database on-demand and schedule backups that occur every 24 hours.

- Free plans cannot back up or export a database through the Redis Cloud console.

The number of database backups that can run simultaneously on a subscription is limited to 4 by default.

Backups are saved to predefined storage locations available to your subscription. Backup locations need to be available before you turn on database backups.  To learn more, see [Set up backup storage locations](#set-up-backup-storage-locations).

Backups are saved in RDB format. If the database is comprised of multiple shards, an RDB file will be created for each shard of the database. For more information on restoring data from a backup, see [Restore from an RDB file]().

Here, you'll learn how to store backups using different cloud providers.

Turn on backups

To turn on database backups:

1. Sign in to the [Redis Cloud console](https://cloud.redis.io/).

1.  Select the database to open the **Database** page and then select **Edit**.

1.  In the **Durability** section of the **Configuration** tab, locate the **Remote backup** setting:

When you enable **Remote backup**, additional options appear.  The options vary according to your subscription.

|Setting name|Description|
|:-----------|:----------|
| **Interval** | Defines the frequency of automatic backups.  Paid Redis Cloud Essentials databases are backed up every 24 hours.  Redis Cloud Pro databases can be set to 24, 12, 6, 4, 2, or 1 hour backup intervals. |
| **Set backup time** | When checked, this lets you set the hour of the **Backup time**. (_Redis Cloud Pro only_) |
| **Backup time** | Defines the hour automatic backups are made.  Note that actual backup times will vary up in order to minimize customer access disruptions.  (_Redis Cloud Pro only_)<br/> Times are expressed in [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) (UTC).|
| **Storage type** | Defines the provider of the storage location, which can be: `AWS S3`, `Google Cloud Storage`, `Azure Blob Storage`, or `FTP` (FTPS). |
| **Backup destination** | Defines a URI representing the backup storage location. |

Back up and export data on demand

After backups are turned on, you can back up your data at any time.  Use the **Backup now** button in the **Durability** section.

You can only use the **Backup now** button after you turn on backups.

Set up backup storage locations

Database backups can be stored to a cloud provider service or saved to a URI using FTP/FTPS.

Your subscription needs the ability to view permissions and update objects in the storage location.  Specific details vary according to the provider.  To learn more, consult the provider's documentation.

Be aware that provider features change frequently.  For best results, use your provider's documentation for the latest info.

Select the tab for your storage location type.

**AWS S3:**

To store backups in an Amazon Web Services (AWS) Simple Storage Service (S3) [bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html):

1. In the [AWS Management Console](https://console.aws.amazon.com/), use the **Services** menu to locate and select **Storage** > **S3**.  This takes you to the Amazon S3 admin panel.

1.  Use the **Buckets** list to locate and select your bucket.  When the settings appear, select the **Permissions** tab, locate the **Bucket policy** section, and then click **Edit**.

    -  If there is no existing bucket policy, add the following JSON bucket policy. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.

        [code example]

    - If a bucket policy already exists, add the following JSON policy statement to the list of statements. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.

        [code example]

1. Save your changes.

1. If the bucket is encrypted using [SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html), add the following statement to your [key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html). If you do not have a key policy, see [Creating a key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html). Replace `UNIQUE-BUCKET-NAME` with the name of your bucket and `CUSTOM-KEY-ARN` with your key's [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html).

    [code example]

Once the bucket is available and the permissions are set, use the name of your bucket as the **Backup destination** for your database's Remote backup settings. For example, suppose your bucket is named *backups-bucket*.  In that case, set **Backup destination** to `s3://backups-bucket`.

To learn more, see [Using bucket policies](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) on the AWS docs.

An AWS S3 bucket can be used by only one Redis Cloud account. If you have more than one Redis Cloud account, repeat the setup steps for multiple buckets.

**Google Cloud Storage:**

To store backups in a Google Cloud Storage [bucket](https://cloud.google.com/storage/docs/creating-buckets):

1. Sign in to the Google Cloud console.

1. In the console menu, locate the _Storage_ section, then select **Cloud Storage > Buckets**.

1. Create or select a bucket.

1. Select the **Permissions** tab.

1. Select the **Grant Access** button and then add:

    [code example]

1. Set **Role** to **Storage Legacy Bucket Writer**.

1. Save your changes.

Use the bucket details **Configuration** tab to locate the **gsutil URI**.  This is the value you'll assign to your resource's backup path.

To learn more, see [Use IAM permissions](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-iam).

**Azure Blob Storage:**

To store your backup in Microsoft Azure Blob Storage, sign in to the Azure portal and then:

1. [Create an Azure Storage account](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create) if you do not already have one.

1. [Create a container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container) if you do not already have one.

1. Find your storage account's primary access key. See [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage) for instructions.

Set your resource's **Backup Path** to the path of your storage account.

The syntax for creating the backup varies according to your authorization mechanism.  For example:

[code example]

Where:

- *storage_account_access_key:* the primary access key to the
    storage account
- *storage_account_name:* the storage account name
- *container_name:* the name of the container, if needed.
- *path*: the backups path, if needed.

To learn more, see [Authorizing access to data in Azure Storage](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth).

**FTP/FTPS Server:**

To store your backups on an FTP server, set its **Backup Path** using the following syntax:

[code example]

Where:

- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
- *username*: your username, if needed.
- *password*: your password, if needed.
- *hostname*: the hostname or IP address of the server.
- *port*: the port number of the server, if needed.
- *path*: the backup path, if needed.

If your FTP username or password contains special characters such as `@`, `\`, or `:`, you must URL encode (also known as Percent encode) these special characters. If you don't, your database may become stuck.

The user account needs permission to write files to the server.

kms:Encrypt kms:Decrypt kms:ReEncrypt* kms:GenerateDataKey* kms:DescribeKey


Advanced capabilities

Summary: Describes Redis Cloud Advanced capability options.

Overview

Advanced capabilities extend Redis database functionality by adding new features and data types.

Available options depend on your database plan and **Type**.

Redis Cloud Essentials {#essentials}

All Redis Cloud Essentials databases with versions prior to Redis 8.0 support [Redis Stack](), which enables the most frequently used capabilities.

When the database **Type** is set to _Redis_, the Advanced capabilities section of the database details page displays the advanced capabilities included with the database and their versions.

Starting with Redis 8.0, all advanced capabilities provided by Redis Stack are included in Redis by default.

Redis Cloud is updated on a regular basis, which includes the advanced capabilities supported by the service. Versions displayed by the Redis Cloud console may vary from those shown above.  For the latest details of any capability, see [Redis Stack and Redis Software](). For more information about Redis Cloud version management, see [Redis version management]().

Redis Cloud Pro {#pro}

By default, Redis Cloud Pro databases load all supported advanced capabilities. For versions prior to Redis 8.0, you can choose to load specific capabilities when you create your database. To choose which capabilities to load for your Pro database, [create it with custom settings]() and select **More options** when adding your database in the **Sizing tab** to view advanced capability settings.

You can select more than one advanced capability for a database, though there are limits:

- The following advanced capabilities can be combined in Pro databases:

    - Search and query
    - JSON
    - Time series
    - Probabilistic

- [Active-Active databases]() only support JSON and Search and query.

To remove a selected capability, clear its checkbox.

Starting with Redis 8.0, all advanced capabilities provided by Redis Stack are included in Redis by default.

To learn more, see [Redis Stack]() and [Redis Stack and Redis Software](). For more information about Redis Cloud version management, see [Redis version management]().

Search and query sizing

When you create a Pro database with [Search and Query](), you must consider the sizing and throughput requirements for search and query when you define the dataset size and throughput for your database.

Use the [Search and query sizing calculator](https://redis.io/redisearch-sizing-calculator/) to estimate your index size and throughput requirements.

- **Dataset Size**: Add the estimated index size from the Sizing calculator to your expected dataset size.
- **Throughput**: Enter the total estimated throughput from the Sizing calculator when you enter your throughput.
- **Query performance factor**: The query performance factor adds extra power specifically for search and query. Select a factor to increase your queries per second by that amount.

#### Query performance factor

The query performance factor adds extra compute power specifically for search and query. When you create a Pro database with search and query, you can increase your search queries per second by the selected factor.

We recommend testing your application with a test database to see your baseline queries per second and determine how much you want to boost your query performance. After you have determined your queries per second and your desired performance factor, [create a new database]() with the desired performance factor and [migrate data]() from the test database to your new database.

For more info on how to use scalable search, see [Best practices for scalable Redis Search]().

The query performance factor is available for Redis Cloud Pro databases on Redis 7.2 and later.


Clustering Redis Databases

Summary: Redis Cloud uses clustering to manage very large databases (25 GB and larger). Here, you'll learn how to manage clustering and how to use hashing policies to control how data is managed.

Overview

For very large databases, Redis Cloud distributes database data to different cloud instances.  For example:

- When data grows beyond the RAM resources of a single server.

    Multiple shards should be used when data grows to 25 GB (50 GB for Auto Tiering) to create multiple shards.

- The operations performed against the database are CPU intensive enough to degrade performance.

    Clustering distributes operational load, whether to instances on the same server or across multiple servers.

This distribution is called _clustering_ because it manages the way data is distributed throughout the cluster of nodes that support the database.

How data is distributed

A Redis Cloud cluster is a set of managed Redis processes and cloud instances,
with each process managing a subset of the database keyspace.
Clustering uses multiple cores and resources of multiple instances to overcome scaling challenges.

In a Redis Cloud cluster, the keyspace is partitioned into hash
slots. At any given time a hash slot resides on and is managed by a single
Redis server.

An instance that belongs to a cluster can manage multiple hash
slots. This division of the key space, known as _sharding_, is achieved by
hashing the key names, or parts of these (key hash tags), in order to
obtain the hash slot in which a key should reside. Redis Cloud supports several [hashing policies](#manage-the-hashing-policy).

Even when using multiple Redis processes, the use of a Redis
Enterprise Cloud cluster is nearly transparent to the application that
uses it. The cluster is accessible via a single endpoint that
automatically routes all operations to the relevant shards, without the
complexity of a cluster-aware Redis client. This allows applications to
benefit from using the cluster without performing any code changes, even
if they were not designed to use it beforehand.

When creating or editing a Redis database on Redis Cloud, the
system automatically calculates the number of shards needed based on
the database memory limit and required throughput.

Multi-key operations {#multikey-operations}

Operations on multiple keys in a sharded Redis Cloud cluster
are supported, with the following limitations:

1. **Multi-key commands:** Redis offers several commands that accept
    multiple keys as arguments. In a sharded setup, you can run multi-key commands
    only if all the affected keys reside in the same slot (thus on the same shard).
    This restriction applies to all mulit-key commands, including BITOP, BLPOP, BRPOP, BRPOPLPUSH, MSETNX,
    RPOPLPUSH, SDIFF, SDIFFSTORE, SINTER, SINTERSTORE, SMOVE, SORT,
    SUNION, XREAD, XREADGROUP, ZINTER, ZINTERSTORE, ZUNION, ZUNIONSTORE, ZDIFF, ZDIFFSTORE
1. **Geo commands:** In GEORADIUS/GEORADIUSBYMEMBER/GEOSEARCHSTORE commands, the
    STORE and STOREDIST options can only be used when all affected keys
    reside in the same slot.
1. **Transactions:** All operations within a WATCH/MULTI/EXEC block
    should be performed on keys that are in the same slot.
1. **Lua scripts:** All keys that are used by the script must reside in
    the same slot and need to be provided as arguments to the
    EVAL/EVALSHA commands (as per the Redis specification).
1. **Renaming/Copy keys:** The use of the RENAME/RENAMENX/COPY commands is
    allowed only when both the key's original name and its new name are
    mapped to the same hash slot.
1. **Variadic commands**: The use of (MGET, MSET, HMGET, HMSET, etc..)
    and pipelining are supported with Redis Cloud cluster
    like if it were a non-cluster DB.

Hashing policies and hash tags {#manage-the-hashing-policy}

The hashing policy determines how data is distributed across multiple Redis processes of a database. It uses a hashing function to map keys to hash slots in these processes, ensuring an even distribution of data for optimal performance and scalability.

The hashing function uses the entire key name to calculate the hash slot, unless the key name contains a **hash tag**, represented by a `{...}` pattern.

If the key contains a `{...}` pattern, only the substring between `{` and `}` is hashed in order to obtain the hash slot.

You can use the `{...}` pattern to direct related keys to the same hash slot, so that multi-key operations are supported on them. On the other hand, not using a hashtag in the key's name results in a (statistically) even distribution of keys across the keyspace's shards, which improves resource utilization. If your application does not perform multi-key operations, you don't need to construct key names with hashtags.

Redis Cloud offers 3 hashing policies, which differ in how hash tags are processed. These hashing policies are not always available.

Redis Cloud defaults to the [Redis hashing policy](#redis-hashing-policy) **when creating a new database**. You can select a different hashing policy during database creation, but you cannot change the hashing policy to or from the Redis hashing policy after the database is created.

Redis hashing policy

The Redis hashing policy is identical to the [hashing policy used by Redis Open Source](). This policy is recommended for most users and you should select it if any of the following conditions apply:
- This is your first Redis Cloud account, and you are starting fresh.
- You are migrating data from Redis Open Source or other Redis-managed platforms.
- Your application does not use hashtags in database key names.
- Your application uses binary data as key names.

The Redis hashing policy allows for faster scaling where available.

Standard hashing policy

The Standard hashing policy is mostly consistent with the Redis hashing policy, and will generate the same hash-slot calculation in the following cases:
1. Keys with a single hashtag: a key's hashtag is any substring between '{' and '}' in the key's name. That means that when a key's name includes the pattern '{...}', the hashtag is used as input for the hashing function. For example, the following key names have the same hashtag and are mapped to the same slot: foo{bar}, {bar}baz & foo{bar}baz.
1. Keys without a hashtag: when a key doesn't contain the '{...}' pattern, the entire key's name is used for hashing

In some cases, the Standard hashing policy behaves differently from the Redis hashing policy:
1. Using empty hashtags ("{}"): the Standard hashing policy does not ignore empty hashtags, so two keys that start with empty hashtags will be hashed to the same hashslot (while the Redis hashing policy would ignore them).
    For example: given 2 keys {}foo and {}bar, hashing would be:
    - Standard hashing policy: to the same hash slot
    - Redis hashing policy: to different hash slots
2. Using multiple curly brackets: when a key’s name contains multiple curly brackets, the Standard hashing calculation might be different than the Redis hashing policy.
    For example: given 2 keys {foo}bar} and {foo}qux}:
    - Standard hashing policy: substrings "foo}bar" and "foo}qux" will be used for the 1st and 2nd key respectively, hashed each key to a different hash-slot.
    - Redis hashing policy: the substring "foo" will be used for both keys, hashing them to the same slot.

To allow seamless transition between hashing policies, the following techniques are not recommended:
- Using empty hashtags to hash different keys to the same hashslot
- Using multiple curly brackets within a key’s name

Custom hashing policy

The custom hashing policy is not available for accounts created after March 31, 2025.

For all other accounts, this policy is not recommended and will be deprecated in the future. Select this option only if you are already using a custom hashing policy with your existing Redis Cloud databases.

A Redis Cloud  cluster can be configured to use a custom hashing
policy. A custom hashing policy is required when different keys need to
be kept together on the same shard to allow multi-key operations. Redis
Cloud's custom hashing policy is provided via a set of Perl
Compatible Regular Expressions (PCRE) rules that describe the dataset's
key name patterns.

To configure a custom hashing policy, enter regular expression (RegEx)
rules that identify the substring in the key's name - hashtag - on
which hashing will be done. The hashing tag is denoted in the RegEx by
the use of the \`tag\` named subpattern. Different keys that have the
same hashtag will be stored and managed in the same slot.

Once you enable the custom hashing policy, the Redis Cloud's
default RegEx rules that implement the standard hashing policy are:

| RegEx Rule | Description |
|-----------|-----------------|
| .\*{(?\<tag\>.\*)}.\* | Hashing is done on the substring between the curly braces. |
| (?\<tag\>.\*) | The entire key's name is used for hashing. |

You can modify existing rules, add new ones, delete rules, or change
their order to suit your application's requirements.

If the Custom hashing policy is available, you can change the hashing policy between Standard and Custom after you create your database. However, hashing policy changes delete existing data
(using [`FLUSHDB`]()) before they're applied.

These changes include:

1. Changing the hashing policy, either from standard to custom or vice versa.
1. Changing the order of custom hashing policy rules.
1. Adding rules before existing ones in the custom hashing policy.
1. Deleting rules from the custom hashing policy.
1. Disabling clustering for the database.

Custom hashing policy notes and limitations

1. You can define up to 32 RegEx rules, each up to 256 characters.
1. RegEx rules are evaluated by their order.
1. The first rule matched is used; strive to place common key name
    patterns at the beginning of the rule list.
1. Key names that do not match any of the RegEx rules trigger an
    error.
1. The '.\*(?\<tag\>)' RegEx rule forces keys into a single slot as the
    hash key is always empty. When used, this should be the last
    catch-all rule.
1. The following flag is enabled in our regular expression parser:
   - **PCRE_ANCHORED:** the pattern is constrained to match only at
        the start of the string which is being searched.

OSS Cluster API {#oss-cluster-api}

The OSS Cluster API is only supported on Redis Cloud Pro databases. You can enable it in the **Performance** section of the configuration screen.

After you select OSS Cluster API, you can select **Use external endpoint** if you want to use the external endpoint for the database. Selecting **Use external endpoint** will block the private endpoint for this database.

The OSS Cluster API is supported only when a database uses the [standard hashing policy](#standard-hashing-policy).

Review [OSS Cluster API architecture]() to determine if you should enable this feature for your database.


Data eviction

Summary: Data eviction policies control what happens when new data exceeds the memory limits of a database. Here, you'll learn the available policies and how to change which one is used for a database.

Overview

The data eviction policy of a database controls what happens when new data exceeds the memory size of a database.  Typically, such situations require _evicting_ (or deleting) data previously added to the database.

You can [edit database details]() to change the **Data eviction policy** setting at the database level.

Available policies

For each database, you can choose from these data eviction policies:

| **Available policies** | **Description** |
|:------------|:-----------------|
| allkeys-lru | Keeps most recently used keys; removes least recently used (LRU) keys |
| allkeys-lfu | Keeps frequently used keys; removes least frequently used (LFU) keys |
| allkeys-random | Randomly removes keys |
| volatile-lru | Removes least recently used keys with `expire` field set to true (*Default*) |
| volatile-lfu | Removes least frequently used keys with `expire` field set to true |
| volatile-random | Randomly removes keys with `expire` field set to true |
| volatile-ttl | Removes keys with expire field set to true and the shortest remaining time-to-live (TTL) value |
| no eviction | New values aren't saved when memory limit is reached

When a database uses replication, this applies to the primary database |

Prevent data eviction

To avoid data eviction, make sure your database is large enough to hold required values.

Redis Cloud supports [Auto Tiering]() on Redis Cloud Pro and [Redis Flex]() on Redis Cloud Essentials
to prevent data eviction but maintain high performance.

Auto Tiering and Redis Flex can extend your database across RAM and Flash Memory and intelligently manage "hot" (active) data in RAM and "cold" (less active) data in Flash memory (SSD).

Active-Passive replication considerations

When using [Active-Passive replication](), eviction and expiration only operate on the source (active) database. The target database does not evict or expire data while Active-Passive is enabled.

Do not write to the target database while Active-Passive is enabled. Doing so can cause the following issues:

- The target database cannot rely on eviction or expiration to manage local writes, requiring sufficient memory to handle both replicated data and local writes.
- Local writes create differences between the source and target databases, causing replicated commands to behave differently on each database.
- Inconsistent data can cause replicated commands to fail with errors, which will cause the synchronization process to exit and break replication.

Active-Active replication considerations

The eviction policy mechanism for [Active-Active databases]() kicks in earlier than for standalone databases because it requires propagation to all regions. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit. If memory usage continues to rise while the keys are being evicted, the rate of eviction will increase to prevent reaching the Out-of-Memory state.


Data persistence

Summary: Data persistence enables recovery in the event of memory loss or other catastrophic failure. Here, you learn data persistence options, when they're available, and how to apply specific settings to individual databases.

Overview

Redis Cloud can persist data to enable recovery in the event of memory loss or other catastrophic failure.  When you enable data persistence, in-memory data is copied to persistent storage attached to the underlying cloud instance.

Persistence options

Data can be persisted in one of two ways:

- An _Append-Only File_ (AOF) maintains a record (sometimes called a _redo log_ or _journal_) of write operations.  This allows the data to be restored by using the record to reconstruct the database up to the point of failure.

    The AOF file records write operations made to the database; it can be updated every second or on every write (_Redis Cloud Pro plans only_).

- Snapshots are copies of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time.

AOF files provide greater protection (durability) than snapshots at the cost of resources and recovery time.
Although snapshot recovery is faster, the risk of data loss is higher, depending on the time between failure and the most recent snapshot.

If you turn off data persistence, data is lost when the database goes down.

Configure data persistence

In Redis Cloud, data persistence is a database configuration setting that can be changed by [editing your database]() settings.

The availability of the setting depends on your plan:

- Free Redis Cloud Essentials plans do not support data persistence; the setting is disabled entirely.

- Paid Redis Cloud Essentials plans support AOF every second and all snapshot options.

- Redis Cloud Pro enables data persistence settings for every database.

When enabled, you can change the **Data persistence** setting to one of the following values:

| **Options** | **Description** |
|------------|-----------------|
|  None | Data is not persisted to disk at all. |
|  Append Only File (AoF) every write | _(Redis Cloud Pro only)_ Every write is recorded (synchronized to disk using `fsync`) |
|  Append Only File (AoF) every 1 second | Record is updated every second (synchronized to disk using `fsync`)|
|  Snapshot every 1 hour | A snapshot of the database is created every hour |
|  Snapshot every 6 hours | A snapshot of the database is created every 6 hours |
|  Snapshot every 12 hours | A snapshot of the database is created every 12 hours |

When you save changes to data persistence settings, the updates are applied in the background.  This means there is a brief delay while the new settings are applied.

When replication is enabled for a database, persistence is performed against replicas (copies) to reduce performance impact on the primary (_master_) database.


High availability and replication

Summary: Describes database replication and high availability as it affects Redis Cloud.

Overview

Database replication helps ensure high availability.

When replication is enabled, your dataset is duplicated to create a replica that is synchronized with the primary dataset.

Replication allows for automatic failover and greater fault tolerance.  It can prevent data loss in the event of a hardware or zone failure.

Options and plan support

Redis Cloud supports three levels of replication:

- _No replication_ means that you will have a single copy of your database.

- _Single-zone replication_ means that your database will have a primary and a replica located in the same cloud zone. If anything happens to the primary, the replica takes over and becomes the new primary.

- _Multi-zone replication_ means that the primary and its replicas are stored in different zones. This means that your database can remain online even if an entire zone becomes unavailable.

Your replication options depend on your [subscription plan]():

- Free Redis Cloud Essentials plans do not support replication.
- Paid Redis Cloud Essentials plans and Redis Cloud Pro plans let you choose between multi-zone or single-zone replication when creating a subscription. You can also turn off replication.

Whether or not you can change your replication settings after database creation depends on your plan type and what type of replication you originally selected.

- For Redis Cloud Essentials, you select the kind of replication when you create your database. If you selected Multi-zone replication when you created your database, you can't change it to Single-zone or turn it off after database creation. However, if you selected No Replication or Single-zone replication, you can switch between the two at any time by [editing your Essentials subscription]().
- For Redis Cloud Pro, you select whether you want a multi-zone deployment during subscription creation. You can't change this setting or any [Zone settings]() after subscription creation. However, you can activate or deactivate replication for each database within the subscription at any time by [editing your database]().

Performance impact

Replication can affect performance as traffic increases to synchronize all copies.

Dataset size

For both Redis Cloud Essentials and Redis Cloud Pro, replication requires a memory limit that is double the dataset size of your database.

For Redis Cloud Essentials, the size of the plan you choose includes replication. Therefore, if you choose replication, the dataset size you can use is half of the stated plan size. For example, if you choose a 1 GB plan, Redis allocates 512 MB for the dataset size, and the other 512 MB for replication.

For Redis Cloud Pro, you select your dataset size when you create your database, and we calculate your memory limit based on the replication settings you choose.

Zone setting maintenance

Zone settings can only be defined when a subscription is created.  You cannot change these settings once the subscription becomes active.

This means you can't convert a multi-zone subscription to a single zone (or vice-versa).

To use different zone settings, create a new subscription with the preferred settings and then [migrate data]() from the original subscription.

Availability zones

You can reduce network transfer costs and network latency by ensuring your Redis Cloud Pro cluster and your application are located in the same availability zone.

To specify the availability zone(s) for your cluster, [create your Pro database with custom settings](), and select *Manual Selection* under **Allowed Availability Zones** in **Advanced options**.

For Google Cloud clusters and [Redis Cloud BYOC](), select an availability zone from the **Zone name** list.

For all other AWS clusters, select an availability zone ID from the **Zone IDs** list. For more information on how to find an availability zone ID, see the [AWS docs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones).

If **Multi-AZ** is enabled, you must select three availability zones from the list.

For more information on availability zones, see the [Google Cloud docs](https://cloud.google.com/compute/docs/regions-zones/#available) or the [AWS docs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones).

More info

To learn more about high availability and replication, see:
- [Highly Available Redis]()
- [Database replication]()


Configure databases

Summary: Provides background information to help you configure Redis Cloud databases to best fit your needs.

Advanced capabilities

Clustering Redis Databases

Data eviction

Data persistence

High availability and replication

Summary: Describes sizing considerations for your Redis Cloud database, including throughput and dataset size.

Size a Redis Cloud database

Content

Here, you'll find background info and conceptual details to help you customize your Redis Cloud databases to meet your needs.


Size a Redis Cloud database

Dataset size {#dataset-size}

The dataset size of a database is a part of the full memory limit for the database. The memory limit represents the maximum amount of memory for the database, which includes data values, keys, module data, and overhead for specific features.  High availability features, such as replication and Active-Active,  increase memory consumption, so your dataset size and memory limit will be different.

For Redis Cloud Essentials, the plan size refers to the full memory limit, not the dataset size. Both the total memory limit and dataset size are listed under **Database details** when you create an Essentials database.

For Redis Cloud Pro, you define your dataset size when you create the database, and we calculate your total memory limit based on the features you choose.

Here are some general guidelines:

- Memory limit represents an upper limit.  You cannot store more data than the memory limit.  Depending on your other selections, available memory for data may be less than expected.

- [Replication]() doubles memory consumption; that is, 512 MB of data requires at least 1 GB of memory limit when replication is enabled. This affects both Redis Cloud Pro and Redis Cloud Essentials. For example, if you subscribe to a 1 GB Essentials plan, Redis will allocate 512 MB for your dataset and the other 512 MB for replication.

- [Active-Active]() also doubles memory consumption and the effect is cumulative with the impact of replication. Since Active-Active requires replication to be turned on, the memory limit impact can be as large as four times (4x) the original data size.

- [Advanced capabilities]() also consume memory. For search databases, consider index size when you size your database. See [Search and query sizing]() for more info.

Memory limits in Redis Cloud are subject to the same considerations as Redis Software; to learn more, see [Database memory limits]().

Throughput

Throughput is the number of operations a database can handle over a certain period of time. For Redis Cloud databases, throughput is defined in operations per second (ops/sec).

For a Redis Cloud Pro subscription, you define throughput for a database when you create it. For a Redis Cloud Essentials subscription, your maximum throughput depends on your plan.

We use this setting to guide the allocation of compute power and network bandwidth, ensuring your database can handle the expected workload. However, the throughput specified is not guaranteed - actual throughput may be higher or lower depending on your workload and database configuration.

Throughput factors and variability

Some factors that can affect throughput include:
- **Request size**: Smaller requests (under 3KB) consume less network bandwidth and may result in more operations per second than requested, while larger requests may result in fewer operations per second.
- **Command complexity**: Simple commands, like `GET` and `SET`, are faster and require fewer resources, whereas more complex commands involve more processing time and can reduce throughput. See the [Command list]() to see which commands are more complex than others.
- **Replication**: Using [multi-zone replication]() affects throughput as each write operation is executed asynchronously in each zone.
- **Security**: Some security options, such as [transport layer security](), may affect throughput.
- **Number of client connections**: The number of client connections affects throughput. Increasing or decreasing the number of client connections can result in higher or lower throughput.

Optimize throughput

Here are some things to keep in mind for optimizing throughput:
- Optimize capacity planning and sizing of your Redis Cloud databases to meet your app performance requirements.
- Benchmark your app to understand what latency expectations are required, and adjust throughput accordingly.
- Test and monitor your app's performance and adjust the set ops/sec based on how if performs in real-world conditions.
- If your average request size is larger than 3KB, consider setting your throughput higher than expected.
- Track the slow logs using the [`SLOWLOG` command]() or the **Slowlog** tab on the [database screen]().
- Use [pipelining]() and [concurrent connections]() effectively to optimize throughput and latency.
- Search databases have their own throughput requirements. See [Search and query sizing]() for more info.

Frequently asked questions

**Can my workload exceed the configured throughput?**

Yes, many workloads perform better than expected, especially with optimized configurations and ideal conditions.

**Why is my application getting less throughput than what I set?**

Factors like high connection counts, complex commands, large payloads, and network limitations can affect throughput. Test and adjust based on your application’s needs.

**How do I know the optimal throughput for my application?**

Start with the expected ops/sec. Most of the time, it’s more than enough. For an average request size of less than 3KB, we suggest specifying lower ops/sec than expected to reduce costs. For request sizes higher than 3 KB, we suggest specifying higher ops/sec than your target. Benchmarking your application under production-like conditions will help you find the best configuration.

**How does network bandwidth impact throughput?**

Insufficient bandwidth can bottleneck performance, especially with large request sizes.

**What is the expected latency for my application?**

Latency expectations vary by use case. Some applications tolerate milliseconds, while others require sub-millisecond performance. Benchmark your application to understand its latency profile.


Connect to a Redis Cloud database

Summary: Shows how to open your database in a browser-based version of Redis Insight and lists the features that are available.

Use Redis Insight on Redis Cloud

Overview

After you [create your database](), you can connect to it.

To connect to the database, you need your username and password. By default, your database is protected by a [**Default user**]() called `default` and a masked **Default user password**. You can see the default user password in the **Security** section of the **Configuration** details for your database. Select the eye icon to show or hide the password.

If you've turned on [Role-based access control]() for your database and [turned off the default User](), use the username and password for your data access role.

Once you have the username and password, select **Connect** to open the connection wizard.

For [Active-Active databases](), you connect to one of the database instances. Choose the region you want to connect to from the region selection to access the connection information for that instance.

The connection wizard provides the following database connection methods:

- [Redis Insight](#using-redisinsight)

- [`redis-cli`](#using-rediscli) utility

- [Redis client](#using-redis-client) for your preferred programming language

Redis Insight {#using-redisinsight}

[Redis Insight]() is a free Redis GUI that lets you visualize your Redis data and learn more about Redis.

You can connect to your database with Redis Insight in two ways:

1. [Open your database in Redis Insight in your browser](#ri-browser).

1. [Download and Install Redis Insight](#ri-app) on Windows, macOS, and Linux.

Open in your browser {#ri-browser}

Opening your database with Redis Insight in your browser is only available for Essentials databases. For all other databases, [Download and install Redis Insight](#ri-app) on your computer.

If Redis Insight on Redis Cloud is available for your database, select **Launch Redis Insight web** from the connection wizard to open it.

You can also select **Launch** from the database page under **View and manage data with Redis Insight** to open Redis Insight in your browser.

Redis Insight will open in a new tab.

This browser-based version of Redis Insight has a subset of the features of Redis Insight. For more information, see [Open with Redis Insight on Redis Cloud]().

Install and open on your computer {#ri-app}

1. If you haven't downloaded Redis Insight, select **Download** under **Redis Insight** in the Connection wizard to download it.

1. [Install Redis Insight]().

1. Once installed, select **Open with Redis Insight**.

1. A pop-up asks if you wish to open the link with Redis Insight. Select **Open Redis Insight** to connect to your database with Redis Insight.

If you get an error when connecting with Redis Insight, [manually connect to your database]() from Redis Insight.

You can use Redis Insight to view your data, run Redis commands, and analyze database performance. See the [Redis Insight docs]() for more info.

Redis client {#using-redis-client}

A Redis client is a software library or tool that enables applications to interact with a Redis server. Each client has its own syntax and installation process. For help with a specific client, see the client's documentation.

The connection wizard provides code snippets to connect to your database with the following programming languages:

- .NET using [NRedisStack]()
- node.js using [node-redis]()
- Python using [redis-py]()
- Java using [Jedis]() and [Lettuce]()
- Go using [go-redis]()
- PHP using [Predis]()

If the username and password are not already filled in, replace `<username>` and `<password>` with your username and password.

See [Clients]() to learn how to connect with the official Redis clients.

redis-cli {#using-rediscli}

The [`redis-cli`]() utility is installed when you install Redis.  It provides a command-line interface that lets you work with your database using core [Redis commands]().

To run `redis-cli`, [install Redis]() on your machine. After it's installed, copy the `redis-cli` command under **Redis CLI** in the connection wizard and enter it into your terminal. If the username and password are not already filled in, replace `<username>` and `<password>` with your username and password.

See [Redis CLI]() to learn how to use `redis-cli`.

More info

- [Connect your application]()
- [Connect with TLS]()
- [Default user]()
- [Role-based access control]()


Use Redis Insight on Redis Cloud

Overview

[Redis Insight]() is a free Redis GUI that lets you visualize your Redis data and learn more about Redis.

You can either [install Redis Insight]() on your computer, or you can open your database in Redis Insight directly on Redis Cloud.

Opening your database with Redis Insight in your browser is only available for Essentials databases. For all other databases, [install Redis Insight]() on your computer and [open Redis Insight]() from the database page.

To open your database with Redis Insight on Redis Cloud, select **Open with Redis Insight** on the [database screen]().

Redis Insight will open in a new tab.

This browser-based version of Redis Insight has a subset of the features of Redis Insight. For other Redis Insight features, [install Redis Insight]() on your computer and [open Redis Insight]() from the database page.

Browse

The **Browse** tab lets you browse, filter, and visualize your Redis data structures.

- Create, read, update, and delete lists, hashes, strings, sets, sorted sets, streams, and [JSON]()
- Filter keys by key name or pattern, and by key type
- Group keys according to their namespaces

- View, validate, and manage your key values in a human-readable format using formatters that prettify and highlight data in different formats (for example, Unicode, JSON, MessagePack, HEX, and ASCII)

- Search by key values using your [search indexes]()

If you don't have any Redis data yet, you can select **Load sample data** to add sample data into your database.

CLI and Command Helper

The **CLI** lets you run Redis commands directly.

The CLI integrates with a **Command Helper** that lets you search and read information about Redis commands.

Workbench

The **Workbench** is an advanced command line interface with intelligent command auto-complete and complex data visualization support.

Insights

The **Insights** panel provides interactive tutorials and recommendations to help you optimize your database performance and memory usage.

From the **Workbench** of an empty database, select **Explore** to view the **Insights** panel.

You can also select the **Insights** button in the top-right corner to view the **Insights** panel.


Create an Essentials database

Summary: Shows how to create an Essentials database.

Content

Redis Cloud Essentials is cost-efficient and designed for low-throughput scenarios. You can quickly scale up your Essentials database as your application grows.

3. Select the type of [subscription]() you need. For this guide, select **Essentials**.

This guide shows how to create a paid Essentials database.
- If you want to create a free Essentials database, see [Create a free database](). You can only have one free database per account.
- If you'd rather create a Redis Flex database on Redis Cloud Essentials, see [Create a Redis Flex database]()
- If you'd rather create a Pro database, see [Create a Pro database with a new subscription]().
- If you already have a Pro subscription and want to add a database to it, see [Create a Pro database in an existing subscription]().

    After you select **Essentials**, the rest of the database details will appear.

1. Redis will generate a database name for you. If you want to change it, you can do so in the **Name** field.

1. Choose a **Cloud vendor** for your database from the list. You can choose between **Amazon Web Services (AWS)**, **Google Cloud**, and **Microsoft Azure** for the Cloud Vendor.

1. Choose a **Region** from the list. See [Supported regions]() for a list of supported regions by cloud vendor.

1. Choose your **High availability (replication)** settings.

    Redis Cloud supports the following high availability settings:

    - **None**: You will have a single copy of your database without replication.
    - **Single-Zone**: Your database will have a primary and a replica located in the same cloud zone. If anything happens to the primary, the replica takes over and becomes the new primary.
    - **Multi-Zone**: The primary and its replicas are stored in different zones. This means that your database can remain online even if an entire zone becomes unavailable.

    See [High availability]() for more information about these settings.

1. Choose your **Data persistence** settings from the list.

    Redis Cloud supports the following Data persistence options:

    - An **Append-Only File** maintains a record (sometimes called a _redo log_ or _journal_) of write operations.  This allows the data to be restored by using the record to reconstruct the database up to the point of failure. For Essentials databases, Redis updates the Append-Only file every second.

    - A **Snapshot** is a copy of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time.

    See [Data persistence]() for more information about these settings.

1. Select the **Database version** you want to use.

1. The **Type** of database controls the protocol and advanced capabilities. Leave this as **Redis** unless you have a legacy application that uses **Memcached**.

1. Select your desired memory limit.

    For a comparison of available plans, see [Redis Cloud Essentials plans]().

1.  Enter your payment details.

    If you haven't previously entered a payment method, use the **Add Credit Card** button to add one.

1. Select **Confirm & pay** to create your database.

When you create your database, there's a brief pause while your request is processed and then the **Database details** page appears.

You can now [connect to your database]() and start working with Redis.


Create a Redis Flex database

Summary: Shows how to create an Redis Flex database on Redis Cloud and describes the best use cases for Redis Flex.

Overview

Redis Flex databases have a tiered solid state drive (SSD) and RAM architecture. Using SSDs instead of RAM significantly reduces infrastructure costs, which means developers can build applications that require large datasets using the same Redis API.

Redis Flex databases are compatible with most existing Redis applications, except for applications that use Search and Query and Time Series.

Redis Flex is available on both Redis Cloud Essentials and Redis Cloud Pro.

Redis Flex use cases

The benefits associated with Redis Flex are dependent on the use case.

Redis Flex is ideal when your:

- working set is significantly smaller than your dataset (high RAM hit rate)
- average key size is smaller than average value size
- most recent data is the most frequently used (high RAM hit rate)

Redis Flex is not recommended for:

- Broad access patterns (any value could be pulled into RAM)
- Large working sets (working set is stored in RAM)
- Frequently moved data (moving to and from RAM too often can impact performance)

Redis Flex is not intended to be used for persistent storage.

Where is my data?

When using Redis Flex, RAM storage holds:
- Key indexes
- Dictionaries
- Hot data (working set), including frequently accessed keys and values

All data is accessed through RAM. If a key or value in flash memory is accessed, it becomes part of the working set and is moved to RAM. This data is referred to as "hot data".

Inactive or infrequently accessed data is referred to as "warm data" and stored in flash memory. When more space is needed in RAM, warm keys and values are moved from RAM to flash storage.

Create a Redis Flex database on Redis Cloud Essentials

3. Select the type of [subscription]() you need. For this guide, select **Essentials - Flex**.

This guide shows how to create a Redis Flex database on Redis Cloud Essentials.
- If you'd rather create a Redis on RAM Essentials database, see [Create an Essentials database]().
- If you'd rather create a Pro database, see [Create a Pro database with a new subscription]().
- If you already have a Pro subscription and want to add a database to it, see [Create a Pro database in an existing subscription]().

    After you select **Essentials - Flex**, the rest of the database details will appear.

1. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.

1. Choose a **Region** on Amazon Web Services for your database. See [Supported regions]() for a list of supported regions by cloud vendor.

1. Choose your **High availability (replication)** settings from the list.

    Redis Cloud supports the following high availability settings with Redis Flex:

    - **None**: You will have a single copy of your database without replication.
    - **Single-Zone**: Your database will have a primary and a replica located in the same cloud zone. If anything happens to the primary, the replica takes over and becomes the new primary.

    See [High availability]() for more information about these settings.

1. Choose your **Data persistence** settings from the list.

    Redis Cloud supports the following Data persistence options:

    - An **Append-Only File** maintains a record (sometimes called a _redo log_ or _journal_) of write operations.  This allows the data to be restored by using the record to reconstruct the database up to the point of failure. For Essentials databases, Redis updates the Append-Only file every second.

    - A **Snapshot** is a copy of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time.

    See [Data persistence]() for more information about these settings.

1. Select the **Database version** you want to use.

1. Select your desired memory limit.

    For a comparison of available plans, see [Redis Cloud Essentials plans]().

1.  Enter your payment details.

    If you haven't previously entered a payment method, use the **Add Credit Card** button to add one.

1. Select **Confirm & pay** to create your database.

When you create your database, there's a brief pause while your request is processed and then the **Database details** page appears.

Create a Redis Flex database on Redis Cloud Pro

To create a Redis Flex database on Redis Cloud Pro, [create a new Pro database with custom settings]().

In the **Advanced options** of the **Setup** tab, select **Redis Flex**.

Continue with the instructions to [create your database]().


Create a free database

Summary: Shows how to create a free database.

Content

Free databases are perfect for learning and exploring Redis. You get 30 MB of space for you to learn Redis concepts and develop application prototypes.

You can only have one free database per account. If you already have a free database, you can [delete it]() or [upgrade it to a paid Essentials plan]() before creating a new one.

3. Select the type of [subscription]() you need. For this guide, select **Free**.

    After you select **Free**, the rest of the database settings will appear.

4. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.

1. Select the **Database version** you want to use.

1. Choose your **Cloud vendor** and **Region**. You can choose between **Amazon Web Services (AWS)**, **Google Cloud**, and **Microsoft Azure** for the Cloud Vendor.

    See [Supported regions]() for a list of supported regions by cloud vendor.

6. Select **Create database**.

    When you create your database, there's a brief pause while your request is processed and then the **Database details** page appears.

You can now [connect to your database]() and start working with Redis. Once your app is ready to scale up, you can [upgrade to a paid Essentials plan]() at any time.


Create a Pro database in an existing subscription

Summary: Shows how to create a Pro database in an existing subscription

Overview

This guide shows how to create a Pro database in an existing subscription.
- If you don't yet have a Pro subscription, see [Create a Pro database with a new subscription]().
- If you'd rather create an Essentials database, see [Create an Essentials database]().

To create a database in an already existing Pro subscription:

1. Sign in to the [Redis Cloud console](https://cloud.redis.io).

2. Select the **New database** button.

    This displays the **Create database** screen.

1. Select the type of [subscription]() you need. For this guide, select **Existing subscription**, and then select your existing Pro subscription from the list.

After you select your existing subscription from the list, select **Continue** to go to the **New database** page.

You can also select your subscription from the [subscription list]() and select **Create database in this subscription**.

The **New database** page is divided into sections, each dedicated to a specific category of settings. The following sections provide more details.

When you've configured your new database, click the **Activate database** button to create and activate it.

General section

The **General** section defines basic properties about your database.

The available settings vary according to your subscription plan:

| Setting name              | Description                                                                                |
|:--------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Subscription**          | Read-only description of your Pro subscription, including cloud provider and region                                                                                |
| **Database name**         | A name for your database (_required_)                                                                                |
| **Database port**         | Automatically or manually assigns a database port (range: 10000-19999).  You cannot assign a port that is reserved or already in use.                                                                                |
| **Database version**         | The Redis version of your database. We recommend you choose the latest available version.                                                                                |
| **Type**                  | Controls advanced database capabilities and protocol.  Supported values include _Redis_ and _Memcached_                                                                       |
| **Advanced capabilities** | [Advanced features and data types]() used by the database. Starting with Redis 8.0, all advanced capabilities are included in Redis by default. |
| **Query performance factor** | *(Search and query databases on Redis 7.2 or later only)* Adds additional compute power to process your query and vector search workloads and boost your queries per second. See [Search and query sizing]() for more information. |
| **Supported Protocol(s)** | Choose between RESP2 and RESP3 _(Redis 7.2 only)_. See [Redis serialization protocol](#resp-versions) for details                                                                                |

Performance section

The **Performance** section lets you manage the maximum size, throughput, and hashing policy for a database.

| Setting name        | Description                                                                                |
|:--------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Dataset size**    | Maximum size (in GB) for your dataset. See [Dataset size]() for sizing considerations.
 Databases with Search and query have specific size requirements, see [Search and query sizing]() for more information. |
| **Throughput**      | Defines throughput in terms of maximum operations per second for the database. See [Throughput]() for more info.
 Databases with Search and query have specific throughput requirements, see [Search and query sizing]() for more information. |
| **High availability**    | Indicates whether a replica copy of the database is maintained in case the primary database becomes unavailable. See [High availability]() for more info|
| **Query performance factor** | *(Search and query databases on Redis 7.2 or later)* Adds additional compute power to process your query and vector search workloads and boost your queries per second. See [Search and query sizing]() for more information. |
| **Hashing policy**  | Defines the [hashing policy]().  |
| **OSS Cluster API** | Activates the [OSS Cluster API]() for a database.
 After you select OSS Cluster API, you can select **Use external endpoint** if you want to use the external endpoint for the database. Selecting **Use external endpoint** will block the private endpoint for this database. |

Durability section

The **Durability** section helps you keep your database (and your data) available when problems occur.

| Setting name             | Description                                                                                |
|:-------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Data persistence**     | Defines the data persistence policy, if any. See [Data persistence]().            |
| **Data eviction policy** | Configures which [policy]() is applied when your database reaches its memory limit.              |
| **Remote backup**        | When enabled, identifies a location and interval for [data backups](). |
| **Active-Passive Redis** | When enabled, identifies a path to the linked database. See [Migrate data]() for more information.           |

Tags section

The **Tags** section lets you add [tags]() to the database.

Select **Add tag** to add a tag.

Security section

The **Security** section helps you control access to your database.

| Setting name                       | Description                                                                                |
|:-----------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Default user**                   | When enabled, permits access using the `default` username and a simple password (see [Default User]()). Turn on [Role-based access control]() to turn off this setting.              |
| **Default user password**                 | Password assigned to the database when created.                                                                                |
| **CIDR allow list**                | [Allow list]() of IP addresses/security groups permitted to access the database |
| **Transport layer security (TLS)** | Enables [transport layer security]() (TLS) encryption for database access.          |

Alerts section

The **Alerts** section defines notification emails sent to your account and the conditions that trigger them.

The available alerts vary according to the plan type. See [Configure alerts]() for more information.

Billing unit types


Create a Pro database with a new subscription

Summary: Shows how to create a Pro database with a new subscription

Overview

Redis Cloud Pro supports more databases, larger databases, greater throughput, and unlimited connections compared to Redis Cloud Essentials. Redis Cloud Pro databases are perfect for teams building mission-critical systems in the cloud.

3. Select the type of [subscription]() you need. For this guide, select **Pro**.

This guide shows how to create a Pro database with a new subscription.
- If you already have a Pro subscription and want to add a database to it, see [Create a Pro database in an existing subscription]().
- If you'd rather create an Essentials database, see [Create an Essentials database]().

After you select **Pro**, the **Database settings** section will appear.

You can choose to create your database in one of two ways:

- [**Easy create**](#easy-create) selects the optimal settings for you to get started faster.
- [**Custom settings**](#custom-settings) lets you select all of the configuration options for your new database.

Create database with Easy create {#easy-create}

If you choose to create your database with Easy create:

1. Choose a **Cloud Provider** and a **Region**.

1. Enter the following settings for your database:

    | Database setting | Description |
    |:---------|:-----------|
    | **Name** | The name for your database. Redis will generate a database name for you, but you can change it at any time.  |
    | **Dataset size (GB)** | The amount of data for your dataset. See [Dataset size]() for sizing considerations.
 Databases with Search and query have specific sizing requirements, see [Search and query sizing]() for more information. |
    | **Throughput** | Identifies maximum throughput for the database, which is specified in terms of operations per second (**Ops/sec**). See [Throughput]() for more information.
 Databases with Search and query have specific throughput requirements, see [Search and query sizing]() for more information. |
    | **High Availability** | Indicates whether a replica copy of the database is maintained in case the primary database becomes unavailable.  (Warning: doubles memory consumption). See [High Availability]().  |

1. Select **View all settings** to review the database settings that we selected for you.

    If you want to change these settings, select [**Switch to custom settings**](#custom-settings).

1. Enter your payment details.

    If you haven't previously entered a payment method, use the **Add Credit Card** button to add one.

 Select **Confirm & pay** to create your database.

Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes. This process generally takes 10-15 minutes.

Use the **Database list** to check the status of your databases.

Create database with Custom settings {#custom-settings}

If you choose to create your database with custom settings, you need to:

1. Set up the deployment options, including cloud vendor details, high availability settings, and advanced options.

2. Define the database size requirements.

3. Review your choices, provide payment details, and then create your databases.

The following sections provide more information.

Set up deployment details

The **Setup** tab specifies general settings for your Redis deployment.

There are two sections on this tab:

- [General settings](#general-settings) include the cloud provider details and specific configuration options.
- [Advanced options](#advanced-options) define settings for high availability and security. Configurable settings vary according to cloud provider.

#### General settings {#general-settings}

In the General settings of the **Setup** tab, you need to:

1. Select the public **Cloud vendor** to deploy your databases.

1. Select the **Region** where you want to deploy your database.

This guide is for single region database deployment. If you want to create a multi-region Active-Active database, see [Create an Active-Active database]() for specific steps and configuration options exclusive to Active-Active.

#### Advanced options {#advanced-options}

The following settings are defined in the **Advanced options** of the **Setup** tab:

| Advanced option | Description |
|---|---|
| **Redis Flex** | Determines if your databases are stored only in memory (RAM) or are split between memory and Flash storage (RAM+Flash).  See [Redis Flex]() for more information. |
| **BYOC account** | To deploy these databases to an existing cloud account, select it here.  Use the **Add** button to add a new cloud account.

(Available only if [Redis Cloud Bring your own Cloud]() is enabled) |
| **Multi-AZ** | Determines if replication spans multiple Availability Zones, which provides automatic failover when problems occur. See [High Availability](). |
| **VPC configuration** | Select **In a new VPC** to deploy to a new [virtual private cloud](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPC).

To deploy these databases to an existing virtual private cloud, select **In existing VPC** and then set VPC ID to the appropriate ID value.

(Available only if [Redis Cloud Bring your own Cloud]() is enabled and you have selected an existing BYOC account) |
| **Allowed Availability Zones** | The availability zones for your selected region.

If you choose **Manual selection**, you must select at least one zone ID from the **Zone IDs** list.  For more information, see [Availability zones](). |
| **Deployment CIDR** | The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) range of IP addresses for your deployment. Redis creates a new [subnet](https://en.wikipedia.org/wiki/Subnetwork) for the **Deployment CIDR** in your [virtual private cloud](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPC). It cannot overlap with the CIDR ranges of other subnets used by your account.

For deployments in an existing VPC, the **Deployment CIDR** must be within your VPC's **primary** CIDR range (secondary CIDRs are not supported). |
| **Public endpoint access** | Select whether or not to [block public endpoints]() for all databases in the subscription.  |
| **Maintenance windows** | Determines when Redis can perform [maintenance]() on your databases. Select **Manual** if you want to set [manual maintenance windows](). |

When finished, choose **Continue** to determine your size requirements.

Sizing tab

The **Sizing** tab helps you specify the database, memory, and throughput requirements for your subscription.

When you first visit the **Sizing** tab, there are no databases defined.  Select the **Add** button to create one.

This opens the **Database configurations** dialog, which lets you define the requirements for your new database.

By default, you're shown basic settings, which include:

| Database setting | Description |
|:---------|:-----------|
| **Name** | Redis Cloud generates a database name for you, but you can change it at any time. |
| **Version** | The Redis version for your database. We recommend you choose the latest available version. See [Redis version management]() for more information. |
| **Dataset size (GB)** | The amount of data for your dataset. Specify small sizes as decimals of 1.0 GB; example: `0.1` GB (minimum). We calculate the total memory limit for you based on the other settings you choose for your database.
 Databases with Search and query have specific sizing requirements, see [Search and query sizing]() for more information. |
| **High Availability** | Indicates whether a replica copy of the database is maintained in case the primary database becomes unavailable.  (Warning: Doubles memory consumption). See [High Availability]().  |
| **Throughput** | Identifies maximum throughput for the database, which is specified in terms of operations per second (**Ops/sec**). See [Throughput]() for more information.
 Databases with Search and query have specific throughput requirements. See [Search and query sizing]() for more information. |
| **Hashing policy** | Determines how data is distributed across multiple Redis processes of a database. Available options depend on your account creation date. See [Clustering]() for more information.  |
| **Query performance factor** | *(Search and query databases on Redis 7.2 or later only)* Adds additional compute power to process your query and vector search workloads and boost your queries per second. See [Search and query sizing]() for more information. |
| **Data Persistence** | Defines the data persistence policy, if any. See [Data persistence](). |

Select **More options** to specify values for the following settings.

| Database option | Description                                                                                |
|:---------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Advanced Capabilities** | [Advanced features and data types]() used by the database. Starting with Redis 8.0, all advanced capabilities are included in Redis by default. |
| **OSS Cluster API** | Enable to use the [OSS Cluster API]().                                                                                |
| **Type** | Set to **Redis**, otherwise **Memcached** database for legacy database support.                                                                                |
| **Supported Protocol(s)** | Choose between RESP2 and RESP3 _(Redis 7.2 and later only)_. See [Redis serialization protocol](#resp-versions) for details |
| **Quantity** | Number of databases to create with these settings.                                                                                |

When finished, select **Save configuration** to save your database configuration.

Use the **Add database** button to define additional databases or select the **Continue button** to display the **Review and create** tab.

Hover over a database to see the **Edit** and **Delete** icons. You can use the **Edit** icon to change a database or the **Delete** icon to remove a database from the list.

Review and Create tab

The **Review & Create** tab provides a cost estimate for your Redis Cloud Pro plan:

Redis breaks down your databases to Redis Billing Units (RBUs), each with their own size and throughput requirements. For more info, see [Billing unit types](#billing-unit-types).

The **Payment methods** section of this tab shows which payment method you're using for this database. Select the arrow on the top right of this section to view all available payment methods.

If you have not added a payment method or want to add a new payment method, select **Add credit card** to add a new credit card.

Select **Back to Sizing** to make changes or **Confirm & Pay** to create your databases.

Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes. This process generally takes 10-15 minutes.

Use the **Database list** to check the status of your databases.

Billing unit types


Create a database

Summary: Shows how to create a free database.

Create a free database

Create an Essentials database

Create a Redis Flex database

Content

A database is the heart of any Redis Cloud deployment.

The process for Creating a database depends on the type of [subscription plan]() you need.

An **Essentials** plan is a fixed monthly price for a single database. It is cost-efficient and designed for low-throughput scenarios. It supports a range of availability, persistence, and backup options. Pricing supports low throughput workloads.
- [Create an Essentials database]()
- [Create a Redis Flex database]()

A **Free** plan is a type of Essentials plan designed for learning and building test projects. It gives you enough space to learn Redis concepts and develop application prototypes. You can upgrade to a paid Essentials plan at any time.
- [Create a free database]()

A **Pro** plan is an hourly price based on capacity. It supports more databases, larger databases, greater throughput, and unlimited connections.
- [Create a Pro database with a new subscription]()
- [Create a Pro database in an existing subscription]()
- [Create an Active-Active database]()


Delete database

Content

To delete a database, use the **Delete** button located in the **Danger zone** section of the database's **Configuration** tab.

Deleting a database requires the Account Owner role.

Deleted databases cannot be recovered.  We recommend [making a backup](), just in case.

1. Sign in to the [Redis Cloud console](https://cloud.redis.io/).

1.  Select the database from the list.  The **Configuration** tab is selected by default.

1.  Scroll to the **Danger zone**.

1.  Select the **Delete** button.

1. The **Delete database** confirmation dialog appears. If this database is the only one in the subscription, you can also delete the subscription at this time.

    - Select **Delete my subscription and stop my payment** to delete both the database and the subscription.

    - Clear **Delete my subscription and stop my payment** to delete the database but keep the subscription.

You will continue to be charged for your subscription until you delete it, even if there are no databases in your subscription.

1. Select **Delete database** to confirm your choice.

When the operation completes, the database and its data are deleted.


Import data into a database

Overview

You can import an existing dataset into your Redis Cloud instance from an existing Redis server or an RDB file.

Data imported into an existing database overwrites existing data.
- If you import a dataset into the target database of an [Active-Passive setup](), the dataset will be overwritten by any changes to the source database.
- If you import a dataset into one region in an [Active-Active database](), the dataset will also be replicated across regions.

<br/>

Expired keys are not imported.
As a result, the number of keys in the source and destination databases can be different after the import is complete.

Prerequisites

Make sure the Redis version of the source database is compatible with the database where the data will be imported.

Import from a Redis server {#redis-server}

To import a dataset from any publicly available Redis Open Source server:

1. Select **Databases** from the Redis Cloud console menu and then select the target database from the database list.
1. Select **Import**.

1. Enter the source database details:
    - Source type - Select **Redis**.
    - Redis Hostname/IP Address - Enter the hostname or the public IP address of the source Redis server. Do not include the port number in the hostname.
    - Redis port - Enter the port of the source Redis server if it is not the default value of `6379`.
    - Password - Enter the password, if required by the source Redis database.
1. Select **Import**.

Restore from an RDB file

If you have an RDB or a compressed RDB file from a previous backup, you can restore data from that file into your Redis Cloud database.

Select the tab for your storage location type.

**FTP or HTTP server:**

1. Select **Databases** from the Redis Cloud console menu and then select your database from the list.
2. Select **Import**.
3. Enter the details for the RDB file:
    - Source type - Select **FTP** or **HTTP**.
    - Source path - Enter the URL for the RDB file:

    [code example]

    Where:

    - `protocol` - Server protocol: ftp, ftps, http, https
    - `username` - Your username, if necessary
    - `password` - Your password, if necessary
    - `hostname` - Hostname or IP address of the server
    - `port` - Port number of the server, if not `6379`
    - `path` - Path to the file, if necessary
    - `filename` - Filename of the RDB file, including the `.gz` suffix if the file is compressed

If your FTP username or password contains special characters such as `@`, `\`, or `:`, you must URL encode (also known as Percent encode) these special characters. If you don't, your database may become stuck.

4. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.

For sharded databases with multiple RDB files, make sure to add every file before proceeding.

5. Select **Import**.

**AWS S3:**

To use the Redis Cloud console to import your data, you must first share the file from the Amazon Web Services (AWS) management console.

To share and import an RDB file that is stored in an AWS Simple Storage Service (S3) bucket:

1. In the [AWS Management Console](https://console.aws.amazon.com/), configure the bucket's [bucket policy](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) to give access to Redis Cloud:
    1. Use the **Services** menu to locate and select **Storage** > **S3**.  This takes you to the Amazon S3 admin panel.

    1.  Use the **Buckets** list to locate and select your bucket.  When the settings appear, select the **Permissions** tab, locate the **Bucket policy** section, and then click **Edit**.

        -  If there is no existing bucket policy, add the following JSON bucket policy. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.

            [code example]

        - If a bucket policy already exists, add the following JSON policy statement to the list of statements. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.

            [code example]

    1. Save your changes.

    1. If the bucket is encrypted using [SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html), add the following statement to your [key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html). If you do not have a key policy, see [Creating a key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html). Replace `UNIQUE-BUCKET-NAME` with the name of your bucket and `CUSTOM-KEY-ARN` with your key's [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html).

        [code example]

1. In the [Redis Cloud console](https://cloud.redis.io/), select the target database from the database list.
1. Select **Import**.
1. Enter the details for the RDB file:
    - Source type - Select **AWS S3**.
    - Source path - Enter the URL for the RDB file:

    [code example]

    Where:

    - `bucketname` - Name of the S3 bucket
    - `path` - Path to the file, if necessary
    - `filename` - Filename of the RDB file, including the .gz suffix if the file is compressed

1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.

1. Select **Import**.

**Google Cloud Storage:**

To use the Redis Cloud console to import your data, you must first share the file from the Google Cloud console.

To share and import an RDB file that is stored in a Google Cloud Storage bucket:

1. In the Google Cloud Storage bucket, edit the file's Access Control List to give read access to Redis Cloud:
    1. Select **Edit access** in the RDB file menu.
    1. Select **Add item**.
    1. Enter the user details and access:
       - In the Entity field of the new item, select **User**.
       - In the Name field of the new item, enter: `service@redislabs-prod-clusters.iam.gserviceaccount.com`
       - In the Access field of the new item, select **Reader**.
    1. Select **Save**.

    For more info, see [Set ACLs](https://cloud.google.com/storage/docs/access-control/create-manage-lists#set-an-acl).

1. In the [Redis Cloud console](https://cloud.redis.io/), select the target database from the database list.
1. Select **Import**.
1. Enter the details for the RDB file:
    - Source type - Select **Google Cloud Storage**.
    - Source path - Enter the URL for the RDB file: `gs://bucketname/[path/]filename.rdb[.gz]`

        Where:
        - `bucketname` - Name of the GCS bucket
        - `path` - Path to the file
        - `filename` - Filename of the RDB file, including the .gz suffix if the file is compressed

1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.

1. Select **Import**.

**Azure Blob Storage:**

To import an RDB file stored in a Microsoft Azure Blog storage container:

1. In the Redis Cloud console, select the target database from the database list.
1. Select **Import**.
1. Enter the details for the RDB file:
    - Source type - Select **Azure Blob Storage**.
    - Source path - Enter the URL for the RDB file:
        [code example]

        Where:
        - `storage_account_access_key` - Primary access key to the storage account
        - `storage_account_name` - Name of the storage account
        - `url` - URL of the storage account
        - `container` - Name of the container, if necessary
        - `filename` - Filename of the RDB file, including the .gz suffix if the file is compressed

1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.

1. Select **Import**.


Manage databases

Create a database

Connect to a Redis Cloud database

View and edit databases

Import data into a database

Back up and export a database

Summary: Shows two ways to migrate data from one Redis Cloud database to another.

Migrate data between Redis Cloud databases

Manage database tags

Monitor database performance

Summary: Describes Redis Cloud supported database versions and upgrade options.

Redis version management

Summary: Overview of the Active-Active feature for Redis Cloud.

Active-Active Redis

Delete database

Configure databases

Summary: Use Redis Data Integration with Redis Cloud.

Data Integration

Overview

Databases are the heart of any Redis Cloud deployment.

Here's how to perform a variety of tasks:

Common database tasks

- [Create a database]()

    - [Create an Essentials database]()
    - [Create a Pro database with a new subscription]()
    - [Create a Pro database in an existing subscription]()
    - [Create an Active-Active database]()

- [View and edit databases]()

- [Delete database]()

If you're new to Redis Cloud, see the [Quick Start]().

Additional tasks

- [Monitor database performance]()

- [Import data into databases]()

- [Back up databases]()

- [Secure database access]()

Configuration details

These topics provide background details that can help you tailor your databases to better fit your needs.

- [Clustering Redis databases](): Redis Cloud uses clustering to manage very large databases (25 GB and larger). Learn how to manage clustering and how to use hashing policies to manage the process.

- [Data eviction policies](): Data eviction policies control what happens when new data exceeds the memory limits of a database. Learn the available policies and how to control them.

- [Data persistence](): Data persistence enables recovery in the event of memory loss or other catastrophic failure. Learn which options are available and how to apply specific settings to individual databases.

- [High availability and replication](): Replication allows for automatic failover and greater fault tolerance. It can prevent data loss in the event of a hardware or zone failure.  Learn which options are available for Redis Cloud subscriptions.

- [Advanced Capabilities](): Advanced capabilities extend Redis database functionality by adding new data types and options. Learn about the advanced capability options that are available for your database.

Compatibility

Redis Cloud does not support certain commands. Instead of using these commands, Redis Cloud automatically handles features like replication and lets you [manage your database]() from the [Redis Cloud console](https://cloud.redis.io/) or [Redis Cloud REST API]().

For more details, see:

- [Redis Cloud compatibility]()

- [Command compatibility]()

- [Configuration compatibility]()


Overview

There are times when you need to migrate data from one Redis Cloud database to another.

Here are two common ways to do this.

Each approach is suitable for different situations and the steps can vary according to your needs.

Transfer via import

The most common way to transfer data to a new database is to import a copy of the data into it.

Here's how it works:

1.  [Select an export storage destination]() and verify that it's ready for use and has sufficient space.

1.  [Export]() the data from the original database to the storage location.

1.  [Import]() the exported data into the target database, the one hosted by the new subscription.

The migrated data reflects the state of the data at the time it was originally exported.

If you have apps or other connections actively using the source database, consider scheduling downtime for the migration to avoid loss.

This approach also lets you transfer data between databases hosted by different services.

Sync using Active-Passive

If your target database is hosted on Redis Cloud Pro, you can use Active-Passive to sync the source database to the target database.  The source database can be hosted on Redis Cloud Pro or Redis Cloud Essentials.

The source database remains active while the data migrates.

The following sections describe Active-Passive syncing processes.

General Active-Passive syncing process

To migrate data using Active-Passive syncing, specify the target database as an Active-Passive replica of the source database:

1.  Get the source database's public endpoint from the **General** section of the database's **Configuration** tab.
2.  Activate the target database as an Active-Passive replica for the source.
3.  Stop all writes to the source database and wait for the data to sync.
4.  Turn off Active-Passive for the target database.
5.  Switch apps and other connections to the target database.

Before you use Active-Passive, be aware of the following limitations:

- An error will appear when syncing the two databases if the source and target databases are hosted on different Redis Cloud accounts. [Contact support](https://redis.io/support/) if you want to migrate a database between accounts using Active-Passive.

- As long as Active-Passive is enabled, data in the target database will not expire and will not be evicted regardless of the set [data eviction policy](). **Do not write to the target database while Active-Passive is enabled.** We recommend that you turn off Active-Passive after the databases are synced.

- Turning on Active-Passive will flush the target database. Make sure that your target database has no important data before you turn on Active-Passive.

Detailed Active-Passive syncing process {#sync-using-active-passive}

Follow these detailed steps to migrate data using Active-Passive syncing:

1.  Select **Databases** from the [Redis Cloud console](https://cloud.redis.io/) menu and select the target database in the list.

1.  From the **Configuration** tab of the target database, select **Edit**.

1.  In the **Durability** section, enable **Active-Passive Redis** and then select **Add Source**.

1. This will open the **Add Active-Passive Redis** screen. Select where the source database is located.

    - Select **Current account** if the source database is located in this Redis Cloud account.

        Select the source database from the **Source database** list. You can type in the database's name to find it.

    - If the source database is hosted externally, select **External**.

        1.  In the **Enter the source URI** field, type `redis://` and then paste in the public endpoint details.

        1. Select if the source database requires Transport Layer Security (TLS).

            - If the source database requires TLS, select **TLS** and enter the public server certificate in the **Server Certificate** field.

            - If the source database requires client authentication, select **Mutual TLS**.

                1. Enter the public server certificate in the **Server Certificate** field.

                1. Select **Download** to download the client certificate.

                1. Configure the source database to accept the client certificate.

1. Select **Save Active-Passive** to save your Active-Passive settings.

    For an external database, we'll verify the endpoint at this step. If the endpoint can't be verified, make sure that you've copied the details directly from the source database and that the value you entered starts with `redis://`.

1.  Select **Save Database** to begin updating the database.

    Initially, the database status is __Pending__, which means the update task is still running.

    The sync process doesn't begin until the database becomes `Active`.

    When data has fully migrated to the target database, database status reports `Synced`.

Active-Passive sync lets you migrate data while apps and other connections are using the source database.  Once the data is migrated, you should migrate active connections to the target database.

Do not write to the target database until turning off Active-Passive. Writing to the target database of an Active-Passive setup can cause data consistency issues and replication failures. See [Active-Passive replication considerations]() for more information.

Active-Passive memory requirements

Active-Passive sync requires more memory than data import.  On average, you need an extra 25% memory on top of other requirements, though specific requirements depend on the data types and other factors.

To illustrate, suppose you want to migrate a 1 GB source database without replication to a target database with replication enabled.  Here, the target database memory limit should be at least 2.5 GB to avoid data loss.

Once the databases are synced, you can disable Active-Passive for the target database.  Before doing so, however, verify that apps and other connections have switched to the target database; otherwise, you may lose data.


Monitor database performance

Overview

Redis Cloud provides a variety of metrics to help you monitor database performance.  You can view graphs of performance data at any time and receive emails when performance crosses defined thresholds.

View database metrics

The **Metrics** tab of the **View Database** screen provides a series of graphs showing performance data for your database.

Performance data provides insight into how your database is being used and how well it is performing.

The interval scrollbar controls the time period displayed in the graphs.

Promote metric graphs

The **Metrics** screen shows two primary graphs and a collection of smaller ones.  You can promote any smaller graph to a primary position.

When you use the mouse to point to a smaller graph, three things appear:

- A promotion icon pointing left
- A promotion icon pointing right
- A summary panel showing the minimum, average, maximum, and most recent values displayed in the graph.

Use the promotion icons to promote the smaller graph to one of the primary positions. The left icon promotes the smaller graph to the left position and the right icon promotes the smaller graph to the right position.

Metric definitions

Several metric graphs are available:

| **Metric** | **Description** |
|------------|-----------------|
| [Ops/sec]() | The number of overall operations per sec for all Redis commands |
| [Reads/sec]() | The number of read operations per second |
| [Writes/sec]() | The number of write operations per second |
| [Other cmds/sec]() | The number of other Redis commands per second |
| [Latency]() | Latency per operation, in milliseconds |
| [Reads latency]() | Latency per read operation, in milliseconds |
| [Writes latency]() | Latency per write operation, in milliseconds |
| [Other latency]() | Latency of other commands, in milliseconds |
| [Used memory]() | Amount of memory used by the database |
| [Total keys]() | Total number of keys in the database |
| [Connections]() | Total number of connections to the endpoint |
| [Evicted objects/sec]() | Number of objects evicted from the database per second. |
| [Expired objects/sec]() | Number of expired objects per second. An expired object is an object with expired TTL that was deleted from the database. |
| [Hit ratio]() | Percent of operations on existing keys out of the total number database operations |
| Network Ingress bytes/sec | Amount of traffic in bytes per second entering the database network |
| Network Egress bytes/sec | Amount of traffic in bytes per second exiting the database network |

For more detailed analysis, consider using [Redis Insight]() or [Prometheus and Grafana]().

Configure alerts {#configure-metric-alerts}

Depending on your subscription plan, you can enable alerts for several metrics for a given database.

To do so, go to the **Configuration** tab of the database and then locate the **Alerts** section.

| Setting name | Description | Default Value | Accepted Range |
|---|---|---|---|
| **Dataset size has reached** | Sends an alert when the dataset size reaches or exceeds the defined percentage of the memory limit. (_Pro only_) | 80% | 1-100% |
| **Total size of datasets under this plan reached** | Sends an alert when the total size of all datasets in the plan reaches or exceeds the defined percentage of the plan limit. (_Essentials only_) | 80% | 1-100% |
| **Throughput is higher than** | Sends an alert when throughput is over the defined limit in operations per second (ops/sec). (_Paid Essentials or Pro only_) | 1000 ops/sec | 1-10000000 ops/sec |
| **Throughput is lower than** | Sends an alert when throughput is under the defined limit in operations per second (ops/sec). (_Paid Essentials or Pro only_) | 10 ops/sec | 1-10000000 ops/sec |
| **Latency is higher than** | Sends an alert when the latency is over the defined limit in milliseconds (msec). (_Paid Essentials or Pro only_) | 10 msec | 1-10000 msec |
| **Number of connections** | Sends an alert when the number of connections exceeds the defined percentage of the plan limit.  (_Essentials only_) | 80% | 1-100% |
| **Replica Of - database unable to sync with source** | Sends an alert when the target database cannot sync with the source database after the defined number of seconds. (_Pro only_) | 1 second | 0-1 seconds |
| **Replica Of - sync lag is higher than** | Sends an alert if lag between the source and target databases exceeds the defined number of seconds. (_Pro only_) | 600 seconds | 1-86400 seconds |

Alert settings are specific to each database. Make sure you've configured alerts for all desired databases.

Change alert recipients

Any member of the account team can receive alert emails.

To update alert settings for one or more team members, select **Access Management** from the Redis Cloud console menu and then select the **Team** tab. For details, see [Access management]().

If you subscribe to Redis Cloud through a Platform-as-a-Service (PaaS) provider (such as Heroku), you will need to review your provider's documentation for help managing your team.

Continue learning with Redis University