Dragonfly database services for production teams.
JusDB provides Dragonfly database services for scoped projects, ongoing remote DBA coverage, production support, moves from Redis and Valkey, and high availability. We work on your own servers and cloud VMs, on Kubernetes with the Dragonfly Operator, and on Dragonfly Cloud. 24x7 on-call is available under your service agreement.
Or request a free audit of one database instance. Already in an incident? See how incidents are handled.
- NDA before access
- Read-only by default
- Changes measured against your baseline
Dragonfly version status
Pick the version you run
Dragonfly 2.0
Newest majorReleased on 16 September 2026, with patch 2.0.2 on 7 October 2026. It caps the replication backlog by age and size.
Earlier releases cannot read Valkey 9 snapshot files, so loading one needs Dragonfly 2.0 or later.
Plan the upgrade to 2.0Dragonfly 1.40
Previous releaseReleased on 4 August 2026, with patch 1.40.2 on 3 September 2026. It added WAIT, which blocks until replicas confirm earlier writes.
Releases before 1.40 have no WAIT, so code that relies on it needs 1.40 or later.
Plan an upgrade from 1.40Dragonfly Operator 1.7
Newest releaseVersion 1.7.1, released on 16 October 2026, deploys Dragonfly 2.0.2 when a Dragonfly resource names no image.
Version 1.7.0 removed the operator-managed NetworkPolicy, so stored manifests that still set networkPolicyEnabled can fail strict validation.
Plan Dragonfly on KubernetesVersion status from the Dragonfly releases, the Dragonfly Operator releases, and the Dragonfly replication documentation, checked 28 October 2026.
- Platforms
- Your own servers and cloud VMs, Kubernetes with the Dragonfly Operator, and Dragonfly Cloud
- High availability
- Replicas promoted by Redis Sentinel, the Dragonfly Operator, or Dragonfly Cloud
- Incidents
- Initial-response targets are set in your service agreement. See the targets
Symptoms
Eight Dragonfly problems we are asked to fix
Each one has a cause we can measure. The scoping call starts from the symptom you see, the Dragonfly version, and where it runs.
A Lua script fails right after the move from Redis because Dragonfly rejects any key the script did not declare in KEYS, unless the allow-undeclared-keys flag is set.
Every command stalls while one Lua script runs because a script allowed to touch undeclared keys makes Dragonfly stop all other operations until it finishes.
One core is saturated while the others sit idle because each key belongs to one shard, owned by a single thread, so the work on a hot key stays on one core.
Writes fail with out-of-memory errors at the memory limit because Dragonfly evicts keys only in cache mode (--cache_mode), which is off by default.
Dragonfly exits at start under a small memory limit because it needs at least 256 MB of maxmemory per thread, and by default it starts one thread per CPU core.
Replicas run full syncs after short network drops because from Dragonfly 2.0 the replication backlog keeps about 5 seconds of writes by default (--shard_repl_backlog_time_ms).
Replicating from a Redis 7 primary is unsupported because Dragonfly supports replication only from Redis OSS 6.2 and earlier, so the data moves another way, such as an RDB snapshot.
Redis Functions and modules do not carry over because Dragonfly does not support FCALL, FUNCTION, or MODULE LOAD, although it implements JSON, search, and Bloom filter commands itself.
If one of these is costing your team time, a scoping call is the place to start.
Book a 30-min scoping call (opens Google Calendar in a new tab)Durability
How a crash can lose confirmed Dragonfly writes
Dragonfly has no append-only file (AOF), so a restarted node comes back with only its last snapshot. Replicas copy writes asynchronously, so a promoted replica can also miss the last writes the primary confirmed.
One primary, one replica, three outcomes
Choose a state to see which writes survive.
Clients and failover
Clients send writes to the primary and can read from the replica.
Primary
Confirms each write without waiting for the replica
Healthy
Replica
Applies the primary's stream of changes a moment later
Slightly behind
Snapshot
The last one saved to disk, loaded if the node restarts
On disk
For a moment after each write, the newest data exists only in the primary's memory.
Clients and failover
No Redis Sentinel or Dragonfly Operator watches this pair, so clients wait for the old primary to restart.
Old primary
Crashed, then restarted from the snapshot saved at its last clean shutdown
Stale data
Replica
Reconnected and copied the restarted primary's older data
Overwritten
Snapshot
Saved only at shutdown, because --snapshot_cron was never set
Out of date
The team expected an append-only file to replay recent writes, as Redis does with appendonly yes. Dragonfly has none, so every write since that shutdown is gone, from the replica too.
Clients and failover
Redis Sentinel or the Dragonfly Operator promotes the replica, and clients follow the new primary.
Old primary
Restarted as a replica of the new primary
Following
Replica, promoted
Holds every write except those still in flight when the primary failed
New primary
Snapshot
Saved on a --snapshot_cron schedule, with restores tested on a copy
Tested
Writes the old primary confirmed but had not yet streamed can still be lost. WAIT narrows that window but does not close it. If both nodes fail, the snapshot limits the loss to writes made since it was saved.
We decide per workload how much loss is acceptable, because a session cache can restart empty and a job queue cannot. We set --snapshot_cron, --dir, and --dbfilename to match, and copy snapshots off the host. Where a write must reach a replica first, we use WAIT, available from Dragonfly 1.40.
Dragonfly does not fail over by itself, so we use three or more Redis Sentinels, the Dragonfly Operator, or the failover built into Dragonfly Cloud. We alert on replica lag from INFO REPLICATION and rehearse a failover and a snapshot restore on a copy. For planned switchovers we use REPLTAKEOVER, which waits until the replica has applied every write.
What we cover
Full-spectrum Dragonfly engineering
From one hot key to a move off Redis: INFO, SLOWLOG, Prometheus metrics, and the command compatibility list drive every change.
Performance engineering
We find the limit first, whether a hot key, a slow script, or memory, and measure each change against your baseline.
- Hot keys found and spread across several keys
- SLOWLOG and INFO read on the real workload
- Lua scripts checked for undeclared keys
Vertical scaling
We size one node's threads and memory before you move Redis Cluster shards onto it.
- --proactor_threads matched to the cores you run
- --maxmemory set below the host or container limit
- Emulated cluster mode for Redis Cluster clients
High availability
Failover planned around the data loss and downtime you can accept (RPO and RTO), then rehearsed.
- Three or more Redis Sentinels, or the Dragonfly Operator
- WAIT for writes that must reach a replica first
- Planned switchovers with REPLTAKEOVER
Redis and Memcached compatibility
We check the commands, scripts, and client libraries your workload uses before any cutover, and plan a rollback.
- Unsupported commands such as FCALL and SWAPDB found early
- Snapshot moves, or replication from Redis OSS 6.2 and earlier
- Memcached clients served on --memcached_port
Cloud and Kubernetes
Your own servers, Kubernetes with the Dragonfly Operator, or Dragonfly Cloud, chosen by who should run failover and snapshots.
- Operator failover and rolling updates
- Snapshots to persistent volumes or Amazon S3
- Dragonfly Swarm when data outgrows one node
Managed DBA
Ongoing monitoring, maintenance, and incident response for Dragonfly under an agreed scope.
- Prometheus metrics in your dashboards
- Alerts on memory headroom, replica lag, and snapshot age
- Snapshot restores tested on a copy
Incident support
A critical (P1) page, answered within your agreement's target
JusDB keeps your recovery procedures (runbooks) written down, so an incident starts from a known plan instead of a blank page.
Initial-response targets
2 to 4 hours
Business hours
During covered business hours
15 minutes
24x7 on-call
P1 incidents
Production database down, primary unreachable, data corruption risk, or active failover event.
Severe latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.
Non-critical slow query regression, staging issue, backup warning, or replication check alert.
Configuration question, index advisory, planned schema review, or general operational request.
Our engineering team is in India; business-hours coverage is Mon–Fri 09:00–18:00 IST (UTC+5:30), and 24x7 on-call is available under your service agreement.
Initial-response targets, not resolution guarantees. The target for your engagement is set in your service agreement.
What happens on a P1 page
Page
You page the on-call engineer
Through the escalation path your service agreement names.
Triage
Root cause from INFO, SLOWLOG, and Prometheus metrics
Hot keys, slow scripts, memory pressure, and replica full syncs traced to the key or setting behind them.
Mitigate
Stabilize first, from the runbook
Fail over to a current replica, close the offending client connections, or shed load, then fix the cause once production is steady.
After
A review after every P1
What happened, why, and the change that stops it happening again.
Before and between incidents
- Your setup, written down firstDuring onboarding we record your Dragonfly versions, flags, replication layout, failover method, and snapshot schedule, so an incident starts with context.
- One escalation path, in writingYour service agreement names the on-call contact, the hours, and the Dragonfly deployments covered.
- Reviews between incidentsWe review memory headroom, hot keys, replica lag, and snapshot restores, and report open risks with recommended next steps.
- Version dates trackedWe track Dragonfly and Dragonfly Operator releases for the versions you run, and plan each upgrade from its release notes.
Process
How a Dragonfly engagement runs, step by step
Written findings come before any change. Your team approves production changes, except routine actions you have pre-approved.
Scoping call
Your Dragonfly deployments, versions, platforms, and what you need covered.
Read-only review under NDA
Our engineers use named ACL users with only the permissions the review needs, then read your flags, INFO, SLOWLOG, replication state, and snapshot schedule.
A written report before any change
Each finding comes with the change we propose, how we will measure it, and a way to undo it (a rollback plan).
Changes, then handover
We rehearse risky changes on a replica or a copy, apply them in the windows you approve, measure them against the baseline, and hand over updated operating instructions (runbooks).
Step one is a 30-minute scoping call.
Book a 30-min scoping call (opens Google Calendar in a new tab)Ways to work
Choose the Dragonfly service your team needs
Start with the responsibility you need covered. Each engagement has its own scope, deliverables, access requirements, and acceptance criteria.
Projects
Scoped Dragonfly projects
A defined piece of work with written findings, hands-on changes, and validation against your baseline.
- Dragonfly consultingCores, memory, snapshots, and replication reviewed, with command coverage checked against your workload.
- Dragonfly on KubernetesOperator deployment, snapshots to volumes or Amazon S3, failover, and rolling upgrades.
- Migration and upgradesMoves from Redis or Valkey, and Dragonfly version upgrades, with a rollback plan.
- High availabilityReplicas, Sentinel or Operator failover, and drills against your targets.
- Performance tuningThreads, memory, hot keys, and scripts, measured before and after.
- Backup and recoverySnapshot schedules, and restores tested on a copy.
Ongoing
Ongoing coverage and support
JusDB monitors the databases, carries out the agreed maintenance, and responds to incidents during the coverage the proposal names. The team keeps a change record, recovery procedures, and a review after every P1.
Where your Dragonfly runs, and the tools around it
Your team and ours
What a managed Dragonfly service still leaves to your team
Managed cloud databases automate much of the infrastructure layer, but your team still owns query performance, capacity, cost, and incident decisions.
| Question | Managed cloud service | Your own servers or Kubernetes |
|---|---|---|
| Servers, patches, and upgrades | Dragonfly Cloud runs them. | Your team, or JusDB under your agreement. |
| Snapshots and restores | Manual and scheduled backups are built in. Testing a restore is still your team's job. | You set --snapshot_cron and --dir. By default, Dragonfly saves a snapshot only when it shuts down. |
| Failover | Built in once you add replicas. Your application still has to reconnect cleanly. | You run Redis Sentinel or the Dragonfly Operator, because Dragonfly does not fail over by itself. |
| Memory and eviction | Yours. You pick No Eviction or Cache for the data store. | Yours. Cache mode is off by default, so a full node rejects writes. |
| Scaling past one node | Dragonfly Swarm shards the data and moves slots for you, and needs Redis Cluster clients. | Multi-shard Dragonfly Cluster has no control plane, so failover and slot moves are yours to build. |
| License terms | Your Dragonfly Cloud agreement with the vendor applies. | BSL 1.1 allows production use within your own product or service, but not an in-memory data store offering or a hosted Dragonfly service for others. |
Your team keeps control
- Set business priorities, application requirements, and release plans
- Approve production changes, except routine actions you have pre-approved
- Own your cloud accounts, access policies, and vendor relationships
- Decide when maintenance can happen and how quickly service must recover
- Move the work in-house or to another provider after your agreement's notice period, with your data returned or deleted and the transition help your agreement sets out (Terms, section 8)
JusDB handles the agreed database work
- Monitor database health, investigate alerts, and involve the right people
- Review query performance, replication, capacity, and backup health
- Carry out approved changes and update the operating instructions they affect
- Report completed work, open risks, and recommended next steps
Weighing Dragonfly Cloud against running Dragonfly yourself? We compare both against your workload on a scoping call.
Book a 30-min scoping call (opens Google Calendar in a new tab)Further reading
Redis guides that apply to Dragonfly
Dragonfly implements the Redis API, so these Redis guides apply. Each card notes where Dragonfly differs.
Guide
Redis Sentinel vs Redis Cluster
Sentinel can fail over Dragonfly too, and emulated cluster mode serves Redis Cluster clients.
Guide
Redis persistence: RDB and AOF
What each mode recovers in Redis. Dragonfly saves snapshots only, with no append-only file.
Comparison
Redis vs Memcached
Data types, persistence, and threading compared. Dragonfly serves both protocols, sharing database 0.
FAQ
Common Dragonfly questions
What buyers ask about Dragonfly, Redis compatibility, Redis Cluster, and support hours.
Still have a question?
Ask it on a scoping call. No production access needed.
Book a 30-min scoping call (opens Google Calendar in a new tab)What is Dragonfly?
JusDB works with Dragonfly, an in-memory data store that speaks the Redis and Memcached protocols. It runs as one multi-threaded process that splits the keys into shards, each owned by a single thread (a shared-nothing design). Dragonfly uses the Business Source License 1.1 (BSL 1.1). The license allows production use within your own product or service. It does not allow an in-memory data store offering, or a hosted Dragonfly service for others. Each release converts to the Apache License 2.0 on its change date or four years after it ships, whichever comes first (September 2030 for 2.0.0). Your legal team should confirm what applies.
Is Dragonfly a drop-in replacement for Redis?
Not for every workload, so JusDB checks yours before any cutover. Redis client libraries connect to Dragonfly over the same protocol. It does not support Redis Functions, module loading, or commands such as SWAPDB. Its Lua scripts must declare every key they touch, unless a flag allows otherwise. It also has no append-only file (AOF), so recovery depends on snapshots and replicas.
How does Dragonfly compare to a Redis Cluster?
JusDB compares the two against your workload. Redis Cluster spreads keys across several nodes and limits multi-key commands to keys in one hash slot. One Dragonfly node uses every core it is given and keeps single-node behavior for multi-key commands. Its emulated cluster mode (--cluster_mode=emulated) lets Redis Cluster clients connect to that node. Past one node, Dragonfly Swarm in Dragonfly Cloud shards the data, while self-managed Dragonfly Cluster has no control plane for failover or rebalancing.
Do you offer 24/7 Dragonfly support?
Yes. JusDB provides 24x7 on-call for Dragonfly under your service agreement; without it, coverage is business hours. Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.
Next step
Talk to a Dragonfly engineer about your databases
Tell us what is slow, fragile, or due to change. The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance, subject to availability: mutual NDA before read-only access, a prioritized report within one week after access is ready, and no obligation.
NDA before access, read-only by default, and written scope first
Compare with other databases
If you are weighing alternatives, these are the databases most often compared with this one.
Redis
Dragonfly implements the Redis API. Compare compatibility for the commands you use, persistence, and licensing.
Valkey
The Linux Foundation fork of Redis 7.2.4, with I/O threading improved in Valkey 8.0. Teams compare it with Dragonfly on multi-core servers.
Aerospike
For data sets larger than memory, Aerospike keeps its index in memory and the data on flash.
MongoDB
A cache in front of a document store of record is a common pairing for read-heavy session and catalog data.