These are some random operational things I learned about CouchDB. While I realize that my primary use-case (a CouchDB install with currently 230+ million documents) may be oversized for many, these are still things important things to know and to consider. And I would have loved to know of some of these before we grew that large.
I hope these findings are useful for others.
CouchDB doesn't take great care of diskspace — the assumption is that disk is cheap. To get on top of it, you should run database and view compaction as often as you can. And the good news is, these operations help you to reclaim a lot of space (e.g. I've seen an uncompacted view of 200 GB trim down to ~30 GB).
In case you changed the actual view code, make sure to run the clean-up command (
curl -X POST http://server/db/_view_cleanup) to regain disk space.
Database and view compaction (especially on larger sets) will slow down reads and writes considerably. Schedule downtime, or do it in off-peak hours if you think the operation is fast enough.
This is especially hideous when you run in a cloud environment where disk i/o generally sucks (OHAI, EBS!!!).
To stop either of those background-tasks, just restart CouchDB.
(Just fyi, the third option is of course to throw resources (hardware) at it.)
Resuming view compaction?
HA, HA! [Note, sarcasm!] — view compaction is not resumable, like database compaction.
I suggest you split views into several design documents — this will have the following benefit.
For each design document, CouchDB will create a
.view file (by default these are in
var/lib/couchdb/database-name/.database-name_design/). It's just faster to run compact and cleanup operation on multiple (hopefully smaller files) versus one giant file.
In the end, you don't run the operation against the file directly, but against CouchDB — but CouchDB will deal with a smaller file which makes the operation faster and generally shorter — I call this poor man's view partitioning.
Warming the cache
Cache warming is when a cache is populated with items in order to avoid the cache and server being hit with too much traffic when a server starts up and here is what you can do with CouchDB in this regard.
The basics are obvious — updates to a CouchDB view are performed when the view is requested. This has certain advantages and works well in most situations. Something I noticed is that especially on smaller VPS servers where resources tend to be oversold and and are rare in general, generating view updates can slow your application down to a full stop.
As a matter of fact and CouchDB does often not respond during that operation when the disk was saturated (take into account that even a 2 GB database will get hard to work with if you only have 1 GB of RAM for CouchDB and the OS, and whatever else is running on the same server).
The options are:
- To get more traffic so views are constantly update and the updates performed are kept at a minimum.
- Make your application query views with
?stale=ok and instead update the views on a set interval, for example via a curl request in a cronjob.
Cache-warming for dummies, the CouchDB way.
For various reasons such as space management and performance, it doesn't hurt to put all views on its own dedicated partition.
In order to do this, add the following to your
view_index_dir = /new_device
And assuming your database is called "helloworld" and the view dir is
.view-files will end up in
I've blogged on CouchDB and CouchDB-Lounge before. No matter if you use the Lounge or build sharding into your application — consider it. From what I learned it's better to shard earlier (= overshard), than when it's too late. The faster your CouchDB grows, the more painful it will be to deal with all the data stuck in.
My suggestion is that when you rapidly approach 50,000,000 documents and see yourself exceeding (and maybe doubling) this number soon, take a deep breath and think about a sharding strategy.
Oversharding has the advantage that for example you run 10 CouchDB instances on the same server and move each of them (or a couple) to their own dedicated hardware once they exceed the resources of the single hardware.
If sharding is not your cup of tea, just outsource to Cloudant — they do a great job.
CouchDB-Lounge is Meebo's python-based sharding framework for CouchDB. The lounge is essentially an nginx-webserver and a
twistd service which proxies your requests to different shards using a
shards.conf. The number of shards and also the level of redundancy are all defined in it.
CouchDB-Lounge is a great albeit young project. The current shortcomings IMHO include general stability of the
twistd service and absence of features such as
_bulk_docs which makes migrating a larger set into CouchDB-Lounge a tedious operation. Never the less, this is something to keep an eye on.
What I call Erlang-Lounge is Cloudant's internal erlang-based sharding framework for CouchDB. It's in production at Cloudant and to be released soon. From what I know Cloudant will probably offer a free opensource version and support once they released it.
Disk, CPU or memory — which is it?
This one is hard to say. But despite how awesome Erlang is, even CouchDB depends on the system's available resources. ;-)
For starters, disk i/o is almost always the bottleneck. To verify if this the bottleneck in your particular case, please run and analyze
[iostat] during certain operations which appear to be slow in your context. For everyone on AWS, consider a RAID-0 setup, for everyone else, buy faster disks.
The more CPU in a server, the more
beam processes. CouchDB (or Erlang) seem to take great advantage of this resource. I haven't really figured out a connection between CPU and general performance though because in my case memory and disk were always the bottleneck.
... seems to be another underestimated bottleneck. For example, I noticed that replication can slow down to a state where it seems faster to copy-paste documents from one instance to another when CouchDB is unable to cache an entire b-tree in RAM.
We've been testing some things on a nifty high-memory 4XL AWS instance and during a compact operation, almost 90% of my ram (70 GB) was used by the OS to cache. And don't make my mistake and rely on
(h)top to verify this,
cat /proc/meminfo instead.
Caching is trivial with CouchDB.
Each document and view responds with an
Etag header — here is an example:
curl -I http://foo:[email protected]:5984/foobar/till-laptop_1273064525
HTTP/1.1 200 OK
Server: CouchDB/0.11.0a-1.0.7 (Erlang OTP/R13B)
Date: Wed, 05 May 2010 13:20:12 GMT
Etag will only changes, when the data in the document change. Hence it's trivial to avoid hitting the database if you don't have to. The request above is a very lightweight
HEAD request which only gathers the data and does not pull the entire document.
_changes represents a live-update feed of your CouchDB database. It's located at
Whenever a data changing operation is completed,
_changes will reflect that, which makes it easy for a developer to stay on top to for example invalidate an application cache only when needed (and not like it's done usually when the cache expired).
First off, a lot of people run CouchDB from source which means that in 99% of all installs, the logrotation is not activated.
To fix this (on Ubuntu/Debian), do the following:
ln -s /usr/local/etc/logrotate.d/couch /etc/logrotate.d/couchdb
Make sure to familiarize yourself a little with
logrotatet because depending on space and business of your installation, you should adjust the config a little to not run out of diskspace. If CouchDB is unable to log, it will crash.
In most cases it's more than alright to just run with a log level of
Add the following to your
level = error
Still running out of diskspace? Add the following to your
file = /path/to/more/diskspace/couch.log
... if you adjusted the above, you will need to correct the config for logrotate.d as well.
Last but not least — if no logs are needed, just turn them off completely.
That's all kids.