> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monk.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Redis Cloud

> Managed Redis databases with Essentials and Pro tiers.

## What is this integration?

Redis Cloud is a fully managed Redis service that offers both Essentials (shared) and Pro (dedicated) database tiers with automatic failover, backups, and scaling.

## What Monk manages

* Essentials Subscription, Essentials Database
* Pro Subscription, Pro Database

## What the Agent can do and how to use it

* **Subscription Management**: Create and manage Essentials and Pro subscriptions
* **Database Provisioning**: Deploy Redis databases with configurable memory, persistence, and modules
* **Backup & Recovery**: Create on-demand snapshots and restore from external backups
* **Security**: Configure TLS, IP access lists, and authentication
* **High Availability**: Enable replication and multi-zone deployments (Pro)
* **Clustering**: Configure Redis Cluster with sharding (Pro)

Steps:

1. Set Redis Cloud API secrets
2. monk update \<namespace>/\<name>

## Obtaining Redis Cloud Credentials

To use Redis Cloud with Monk, you'll need API keys from your Redis Cloud account.

### What You'll Need

* **Account Key** - Redis Cloud Account API key
* **User Key** - Redis Cloud User API key
* **Database Password** - Password for database access (Monk can generate this)

### Step-by-Step

1. **Log into Redis Cloud** at [https://app.redislabs.com/](https://app.redislabs.com/)
2. Navigate to **Account Settings** (gear icon)
3. Go to **API Keys** section
4. Find your **Account Key** and **User Key**
   * If no keys exist, contact Redis Cloud support to enable API access
5. **Copy both keys** and save them securely
6. **Choose a database password** - or let Monk generate a secure one

### Providing to Monk

When using Redis Cloud, ask Monk:

```
use Redis Cloud instead of self-hosted Redis
```

Monk will request your Redis Cloud credentials if not already configured.

### Security Best Practices

✅ **Keep keys secure** - API keys have full account access
✅ **Use strong database passwords** - Let Monk generate them
✅ **Enable IP access lists** - Restrict database access to your application IPs
✅ **Monitor usage** - Check Redis Cloud activity logs

## Auth

* Uses Monk secrets for Redis Cloud API credentials:
  * `redis-cloud-account-key`: Account API key
  * `redis-cloud-user-key`: User API key
  * `redis-cloud-db-password`: Database password

## Getting Started

1. Provide credentials to Monk when deploying:

```
use Redis Cloud for caching
```

### CLI Reference (Advanced)

For manual secret management:

```bash theme={null}
monk secrets add -g redis-cloud-account-key="YOUR_ACCOUNT_KEY"
monk secrets add -g redis-cloud-user-key="YOUR_USER_KEY"
monk secrets add -g redis-cloud-db-password="SECURE_PASSWORD"
```

2. Define an Essentials database (save as redis.yaml):

```yaml theme={null}
namespace: my-app

my-subscription:
  defines: redis-cloud/essentials-subscription
  account_key_secret: redis-cloud-account-key
  user_key_secret: redis-cloud-user-key
  name: My-Subscription
  size: 30
  provider: AWS
  region: us-east-1
  permitted-secrets:
    redis-cloud-account-key: true
    redis-cloud-user-key: true

my-redis:
  defines: redis-cloud/essentials-database
  subscription_id: <- connection-target("sub") entity-state get-member("id")
  account_key_secret: redis-cloud-account-key
  user_key_secret: redis-cloud-user-key
  name: my-redis-db
  connections:
    sub:
      runnable: my-app/my-subscription
      service: subscription
  depends:
    wait-for:
      runnables:
        - my-app/my-subscription
      timeout: 300
```

3. Create/update:

```bash theme={null}
monk update my-app/my-subscription
monk update my-app/my-redis
monk describe my-app/my-redis
```

## Pro Database (Dedicated Clusters)

For production workloads requiring dedicated resources, clustering, and advanced features:

```yaml theme={null}
namespace: my-app

pro-subscription:
  defines: redis-cloud/pro-subscription
  account_key_secret: redis-cloud-account-key
  user_key_secret: redis-cloud-user-key
  name: Pro-Subscription
  payment_method_type: Visa
  permitted-secrets:
    redis-cloud-account-key: true
    redis-cloud-user-key: true

pro-redis:
  defines: redis-cloud/pro-database
  name: production-redis
  subscription_id: <- connection-target("sub") entity-state get-member("id")
  dataset_size_in_gb: 1
  data_persistence: aof-every-1-second
  replication: true
  remote_backup:
    active: true
    interval: every-6-hours
    storage_type: s3
    storage_path: s3://my-backups/redis/
  connections:
    sub:
      runnable: my-app/pro-subscription
      service: subscription
```

**Pro Features:**

* Dedicated infrastructure with configurable memory/storage
* Redis modules (RediSearch, RedisJSON, RedisTimeSeries, etc.)
* Active-Active geo-replication
* Scheduled remote backups to S3/GCS/Azure
* VPC peering and private endpoints

## Backup & Snapshot Actions

| Action               | Description                              |
| -------------------- | ---------------------------------------- |
| `get-backup-info`    | View backup configuration and status     |
| `create-snapshot`    | Create an on-demand backup snapshot      |
| `list-snapshots`     | List available backups                   |
| `restore`            | Restore/import data from external backup |
| `get-restore-status` | Check restore task progress              |

```bash theme={null}
# View backup configuration
monk do my-app/my-redis/get-backup-info

# Create a backup snapshot
monk do my-app/my-redis/create-snapshot

# List available backups
monk do my-app/my-redis/list-snapshots

# Restore from S3 backup
monk do my-app/my-redis/restore source_type="aws-s3" source_uri="s3://bucket/backup.rdb"

# Check restore task progress
monk do my-app/my-redis/get-restore-status task_id="xxx"
```