Skip to main content

Redis

Redis is a high-performance, in-memory data store that DreamFactory uses for caching, session storage, and rate limiting. It provides sub-millisecond response times and supports advanced data structures for complex caching scenarios.


Use Cases​

  • API response caching: Store database query results for faster subsequent requests
  • Session storage: Distribute user sessions across multiple DreamFactory instances
  • Rate limiting: Track API request counts with automatic expiry
  • Queue backend: Process background jobs asynchronously
  • Pub/Sub messaging: Real-time event distribution (advanced)

Prerequisites​

Redis Server​

Install Redis on your server or use a managed service:

Ubuntu/Debian:

sudo apt update
sudo apt install redis-server
sudo systemctl enable redis-server
sudo systemctl start redis-server

Managed Services:

  • AWS ElastiCache for Redis
  • Azure Cache for Redis
  • Google Cloud Memorystore
  • Redis Cloud

Verify Installation​

redis-cli ping
# Expected response: PONG

Configuring Redis in DreamFactory​

System Cache Configuration​

Set Redis as the system cache backend in your DreamFactory environment file (.env):

CACHE_DRIVER=redis
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=your_secure_password
REDIS_DATABASE=0

Configuration Options​

VariableRequiredDefaultDescription
CACHE_DRIVERYesfileSet to redis to enable
REDIS_HOSTYeslocalhostRedis server hostname or IP
REDIS_PORTNo6379Redis server port
REDIS_PASSWORDNo-Redis authentication password
REDIS_DATABASENo0Redis database number (0-15)
REDIS_PREFIXNodreamfactoryKey prefix for namespacing

Session Storage​

To store sessions in Redis:

SESSION_DRIVER=redis

Queue Backend​

To use Redis for background job queues:

QUEUE_DRIVER=redis

Creating a Redis Cache Service​

In addition to system caching, you can create a Redis service for direct cache API access.

Step 1: Navigate to API Generation​

Log in to your DreamFactory instance and select API Generation & Connections. Set API Type to Cache.

Step 2: Create New Service​

Click the plus button and select Redis.

Step 3: Configure Service Details​

FieldDescriptionExample
NameService name (used in API URL)redis
LabelDisplay nameRedis Cache
DescriptionService descriptionApplication cache service

Step 4: Configure Connection​

FieldRequiredDefaultDescription
HostNo127.0.0.1Redis server hostname or IP
PortNo6379Redis port number
PasswordNo-Authentication password
Database IndexNo0Redis database number (0-15)
Default TTLNo300Time to live in seconds, used when a request does not set ttl

Step 5: Save and Test​

Save the service and use API Docs to test cache operations.


API Endpoints​

MethodEndpointDescription
GET/api/v2/{service}/{key}Get the value of one key
POST/api/v2/{service}Store one or more new keys. Fails if any key already exists
POST/api/v2/{service}/{key}Store one new key. Fails if the key already exists
PUT / PATCH/api/v2/{service}Store one or more keys, overwriting existing values
PUT / PATCH/api/v2/{service}/{key}Store one key, overwriting an existing value
DELETE/api/v2/{service}/{key}Delete one key

Every request works on named keys. There is no endpoint to list keys, read several keys at once, or flush the whole cache. A request without a key, such as GET /api/v2/{service}, returns 400.

Query parameterApplies toEffect
ttlPOST, PUT, PATCHTime to live in seconds. Defaults to the service's Default TTL
foreverPOST, PUT, PATCHtrue stores the value with no expiry
defaultGETValue to return when the key does not exist, instead of 404
pullGETtrue returns the value and deletes the key

API Examples​

Store Several Values​

Send the keys and values as one JSON object. The TTL goes in the query string, not in the body.

curl -X POST "https://example.com/api/v2/redis?ttl=3600" \
-H "X-DreamFactory-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"setting:theme": "dark",
"user:123:profile": {"name": "John Doe", "email": "john@example.com"}
}'

Response:

{"success": true}

If any of the keys already exists, POST stores nothing and returns 400. Use PUT to overwrite.

Store or Overwrite One Value​

With the key in the path, the whole request body is the value.

curl -X PUT "https://example.com/api/v2/redis/user:123:profile?ttl=300" \
-H "X-DreamFactory-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"name": "John Doe", "email": "john@example.com"}'

Response:

{"user:123:profile": {"name": "John Doe", "email": "john@example.com"}}

Retrieve a Value​

The response body is the stored value itself, not a wrapper object.

curl -X GET "https://example.com/api/v2/redis/user:123:profile" \
-H "X-DreamFactory-API-Key: YOUR_API_KEY"

Response:

{"name": "John Doe", "email": "john@example.com"}

A missing key returns 404 with the message No value found for key '...'. Add ?default=... to get a fallback value instead.

Delete a Key​

curl -X DELETE "https://example.com/api/v2/redis/user:123:profile" \
-H "X-DreamFactory-API-Key: YOUR_API_KEY"

Response:

{"success": true}

TTL (Time-To-Live)​

TTL is always in seconds, both for the ttl query parameter and for the service's Default TTL setting.

RequestBehavior
?ttl=N (N > 0)Expires after N seconds
no ttlUses the service's Default TTL (300 seconds unless changed)
?forever=trueNever expires
?ttl=0 or a negative valueNothing is stored. Use forever=true for no expiry
Data TypeTTL (seconds)Duration
Session data180030 minutes
User profiles3005 minutes
Reference data8640024 hours
Rate limit counters601 minute
Real-time data3030 seconds

Calling the Cache from Scripts​

Scripts call the cache service like any other service. In a Node.js script, platform.api takes (verb, path, payload, options, callback):

platform.api.call('PUT', 'redis/my_key', { token: 'abc' },
{ parameters: { ttl: 3300 } },
function (body, response) { /* response.statusCode */ });

To let a script use the cache without exposing it to API callers, give the role access to the cache service with requestor SCRIPT only.


Redis Configuration Best Practices​

Security​

Bind to localhost or private network:

# /etc/redis/redis.conf
bind 127.0.0.1

Require authentication:

requirepass your_strong_password_here

Disable dangerous commands:

rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""

Memory Management​

Set memory limit:

maxmemory 256mb

Configure eviction policy:

maxmemory-policy allkeys-lru
PolicyDescription
noevictionReturn error when memory limit reached
allkeys-lruEvict least recently used keys (recommended)
volatile-lruEvict LRU keys with TTL set
allkeys-randomRandom eviction

Persistence​

RDB snapshots (default):

save 900 1    # Save if 1 key changed in 900 seconds
save 300 10 # Save if 10 keys changed in 300 seconds
save 60 10000 # Save if 10000 keys changed in 60 seconds

AOF for durability:

appendonly yes
appendfsync everysec

High Availability​

Redis Sentinel​

For automatic failover:

REDIS_SENTINEL_HOST=sentinel1.example.com,sentinel2.example.com
REDIS_SENTINEL_PORT=26379
REDIS_SENTINEL_MASTER=mymaster

Redis Cluster​

For horizontal scaling, configure multiple Redis nodes with clustering enabled.


Monitoring​

Key Metrics to Watch​

MetricDescriptionAlert Threshold
used_memoryCurrent memory usage> 80% of maxmemory
connected_clientsActive connections> 80% of maxclients
keyspace_hitsCache hit count-
keyspace_missesCache miss countHigh miss ratio
evicted_keysKeys removed due to memoryAny eviction

Redis CLI Commands​

# Check server status
redis-cli info

# Monitor memory
redis-cli info memory

# Check connected clients
redis-cli client list

# Get hit/miss ratio
redis-cli info stats | grep keyspace

Common Errors​

Error CodeMessageCauseSolution
400Bad RequestInvalid key or valueCheck request format
401UnauthorizedMissing API keyAdd API key header
404Not FoundKey does not existHandle cache miss
500Connection refusedRedis server unreachableCheck Redis server status
500NOAUTHAuthentication requiredAdd REDIS_PASSWORD to .env

Troubleshooting Connection Issues​

# Test Redis connectivity
redis-cli -h localhost -p 6379 ping

# Test with password
redis-cli -h localhost -p 6379 -a your_password ping

# Check Redis logs
sudo tail -f /var/log/redis/redis-server.log

Performance Tuning​

Connection Pooling​

Configure persistent connections in Laravel/DreamFactory:

REDIS_CLIENT=phpredis

Pipelining​

For bulk operations, the API supports batch requests that are automatically pipelined.

Key Design​

  • Use colons : as separators: user:123:profile
  • Keep keys short but descriptive
  • Use consistent naming conventions
  • Avoid spaces and special characters

Next Steps​