Checking Database Size and Related Issues

As your Redis data grows especially when using persistence modes like RDB or AOF it’s important to track how storage is being used. Unchecked growth can lead to full disks, failed writes, longer startup times, and backup complications. While Elestio handles the hosting, Redis storage tuning and cleanup remain your responsibility. This guide explains how to inspect keyspace size, analyze persistence files, detect unnecessary memory usage, and optimize Redis storage under a Docker Compose setup.
Checking Keyspace Usage and Persistence File Size
Redis doesn’t have schemas or tables, but its memory and disk footprint can be analyzed using built-in commands.
Check total memory used by Redis
From your terminal, connect to the container:
docker-compose exec redis redis-cli INFO memory
This displays current memory stats. Look for the used_memory_human and maxmemory fields to understand real usage versus limits.
Inspect key count and usage by database
docker-compose exec redis redis-cli INFO keyspace
Output looks like:
db0:keys=1250,expires=1200,avg_ttl=34560000
This tells you how many keys exist, how many have TTLs set, and their average lifespan. If most keys never expire, your dataset may grow indefinitely.
View on-disk file sizes
Inside the Redis container, persistent files live under /data:
docker-compose exec redis sh -c "ls -lh /data"
Check the sizes of:
dump.rdb (if RDB is enabled)
appendonly.aof (if AOF is enabled)
These files represent your on-disk dataset and can become large if not managed
Detecting Bloat and Unused Space
Redis may accumulate unnecessary memory usage due to expired keys not yet evicted, inefficient data structures, or infrequent AOF rewrites.
Estimate memory usage by key pattern
Redis doesn’t provide per-key memory stats natively, but you can sample keys and estimate memory usage:
docker-compose exec redis redis-cli --bigkeys
This scans a portion of the keyspace and reports the largest keys by type. If a single key is taking excessive space (e.g., a massive list or set), it may need to be split or purged.
Analyze memory per key (sample)
Use the MEMORY USAGE command to analyze specific keys:
docker-compose exec redis redis-cli MEMORY USAGE some:key
You can script this to scan high-traffic prefixes and locate heavy keys.
Check fragmentation
Redis may fragment memory, reducing efficiency:
docker-compose exec redis redis-cli INFO memory | grep fragmentation
A mem_fragmentation_ratio significantly above 1.2 suggests internal fragmentation.
Optimizing and Reclaiming Redis Storage
Once you’ve identified memory-heavy keys or large persistence files, Redis offers several tools to optimize space usage.
Trigger AOF rewrite (compacts the appendonly file)
If AOF is enabled, it grows over time. To reduce its size:
docker-compose exec redis redis-cli BGREWRITEAOF
This background process creates a smaller version of the AOF file without data loss.
Delete or expire unused keys
Manually delete stale keys or add TTLs to ensure automatic cleanup:
docker-compose exec redis redis-cli DEL obsolete:key
Or set expiration:
docker-compose exec redis redis-cli EXPIRE session:1234 3600
Use patterns to delete multiple keys (carefully!):
docker-compose exec redis redis-cli --scan --pattern "temp:*" | xargs -n 100 redis-cli DEL
Avoid FLUSHALL or bulk deletes in production unless absolutely necessary.
Tune maxmemory and eviction policy
To enforce automatic eviction when nearing memory limits, In redis.conf (mounted via Docker volume):
maxmemory 512mb
maxmemory-policy allkeys-lru
Restart the container to apply changes. This keeps Redis performant under constrained storage.
Managing and Optimizing Redis Files on Disk
Monitor data directory inside Docker
Redis typically writes to /data in the container (mapped from a host volume). Check usage from the host:
docker system df
List all Docker volumes:
docker volume ls
Check Redis volume size (replace <volume_name>):
sudo du -sh /var/lib/docker/volumes/<volume_name>/_data
Clean up RDB snapshots and old backups
RDB snapshots (e.g. dump.rdb) are stored in /data. Clean up old or unneeded ones manually:
docker-compose exec redis rm /data/dump-<timestamp>.rdb
Ensure backups are offloaded to external storage and not stored alongside the live database.
Best Practices for Redis Storage Management
Use TTLs liberally: Set expiration on all temporary/session keys to prevent unbounded growth.
Avoid storing large binary blobs: Store images, files, or videos outside Redis. Use Redis for metadata only.
Rotate logs: If Redis logs to file (e.g., /var/log/redis.log), rotate them via Docker logging options or tools like logrotate.
In docker-compose.yml
logging:
  driver: "json-file"
  options:
    max-size: "10m"
    max-file: "3"
Use efficient data structures: Prefer HASH or SET over storing large JSON blobs as strings.
Monitor AOF size and compaction frequency: If AOF is growing too fast, adjust these in redis.conf:
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
Archive analytics data: For time-series or metrics data, periodically move old entries to cold storage.
Back up to offsite storage: Avoid keeping snapshots on the same disk or volume. Use Elestio’s backup integrations to store them in cloud or remote storage.