what is a robust way to execute long-running tasks/batches under Django?
I'm not sure how your celery configuration makes it unstable but sounds like it's still the best fit for your problem. I'm using redis as the queue system and it works better than rabbitmq from my own experience. Maybe you can try it see if it improves things.
Otherwise, just use cron as a driver to run periodic tasks. You can just let it run your script periodically and update the database, your UI component will poll the database with no conflict.
I have a Django app that is intended to be run on Virtualbox VMs on LANs.  The basic user will be a savvy IT end-user, not a sysadmin.
Part of that app's job is to connect to external databases on the LAN, run some python batches against those databases and save the results in its local db.  The user can then explore the systems using Django pages.
Run time for the batches isn't all that long, but runs to minutes, tens of minutes potentially, not seconds.  Run frequency is infrequent at best, I think you could spend days without needing a refresh.
This is not celery's normal use case of long tasks which will eventually push the results back into the web UI via ajax and/or polling.  It is more similar to a dev's occasional use of the django-admin commands, but this time intended for an end user.
The user should be able to initiate a run of one or several of those batches when they want in order to refresh the calculations of a given external database (the target db is a parameter to the batch).
Until the batches are done for a given db, the app really isn't useable.  You  can access its pages, but many functions won't be available.
It is very important, from a support point of view that the batches remain easily runnable at all times.  Dropping down to the VMs SSH would probably require frequent handholding which wouldn't be good - it is best that you could launch them from the Django webpages.
What I currently have:
Each batch is in its own script.  

I can run it on the command line (via if __name__ == "main":).
The batches are also hooked up as celery tasks and work fine that way.
Given the way I have written them, it would be relatively easy for me to allow running them from subprocess calls in Python.  I haven't really looked into it, but I suppose I could make them into django-admin commands as well.
The batches already have their own rudimentary status checks.  For example, they can look at the calculated data and tell whether they have been run and display that in Django pages without needing to look at celery task status backends.
The batches themselves are relatively robust and I can make them more so.  This is about their launch mechanism.

What's not so great.
In Mac dev environment I find the celery/celerycam/rabbitmq stack to be somewhat unstable.  It seems as if sometime rabbitmqs daemon balloons up in CPU/RAM use and then needs to be terminated.  That mightily confuses the celery processes and I find I have to kill -9 various tasks and relaunch them manually.  Sometimes celery still works but celerycam doesn't so no task updates.  Some of these issues may be OSX specific or may be due to the DEBUG flag being switched for now, which celery warns about.
So then I need to run the batches on the command line, which is what I was trying to avoid, until the whole celery stack has been reset.
This might be acceptable on a normal website, with an admin watching over it.  But I can't have that happen on a remote VM to which only the user has access.
Given that these are somewhat fire-and-forget batches, I am wondering if celery isn't overkill at this point.
Some options I have thought about:

writing a cleanup shell/Python script to restart rabbitmq/celery/celerycam and generally make it more robust.  i.e. whatever is required to make celery & all more stable.  I've already used psutil to figure out rabbit/celery process are running and display their status in Django.
Running the batches via subprocess instead and avoiding celery.  What about django-admin commands here?  Does that make a difference?  Still needs to be run from the web pages.
an alternative task/process manager to celery with less capability but also less moving parts?
not using subprocess but relying on Python multiprocessing module?  To be honest, I have no idea how that compares to launches via subprocess.

environment:
  nginx, wsgi, ubuntu on virtualbox, chef to build VMs.