Using runit for maintaining services

Posted by Steve on Sat 4 Jan 2014 at 10:38

There are several programs, and systems, out there for supervising the execution of child-processes. Perhaps one of the most well-known is runit, which was modelled upon the daemontools software by djb.

Once installed the runit package allows you to easily deploy and control services:

  • Finding them.
  • Starting them.
  • Stopping them.

One of the biggest reasons for using runit is that services restart automatically when they crash, or otherwise exit. For that purpose I use it to launch the vast majority of my node.js applications.

Although we've been talking about the control of services I should make it clear that we're not talking about system servers - although runit could be used in that way if you prefer, we're explicitly not talking about replacing init, we're talking about controlling user-installed services.

To get started install the package:

root@shelob:~# apt-get install runit

Once you've done that you'll find a new daemon has been launched, via an addition to your /etc/inittab file. There are a few processes involved but we mostly don't need to care about them. The important thing about runit is that it launches processes by scanning a particular directory - /etc/service - looking for subdirectories which contain executable scripts named run.

If you create a new directory, and inside that create an executable file called run it will be launched, and relaunched if it exits.

For example if you were to create the directory /etc/service/test, then save the following contents to the file /etc/service/test/run you'd have created a new service:

#!/bin/sh
touch /tmp/blah

This service would run, executing the run script, and then it would exit. Then it would start again, over and over again until you stopped it.

Stopping the service is a matter of using the most useful command installed via runit: sv. The sv command can be used to check on the statutus of a service:

root@shelob:~# sv status /etc/service/test
down: /etc/service/test: 0s, normally up, want up

root@shelob:~# sv status /etc/service/test
down: /etc/service/test: 1s, normally up, want up

It can also be used to start a service, or stop it:

root@shelob:~# sv stop /etc/service/test/
ok: down: /etc/service/test/: 0s, normally up, want up

root@shelob:~# sv status /etc/service/test/
down: /etc/service/test/: 17s, normally up

This trivial service isn't terribly interesting, continuously touching a file. But for simple deamons such as node.js-based servers it can be very useful.

Simply create a directory, and inside that place an executable script named run with contents such as this:

#!/bin/sh
#
# Run our BlogSpam.net API - v2 - restarting on failure.
#


#
#  Steve deploys node beneath /opt/node
#
if [ -d /opt/node ]; then
    export PATH=/opt/node/bin:$PATH
fi


#
# Ensure we're current.
#
git pull --update --quiet


#
# Install any missing modules, via npm.
#
if [ -e "package.json" ]; then
    npm install
fi

#
#  Finally launch the service, with suitable logging.
#
exec node server.js 2>&1 >> /var/log/node.js.log

That's all it takes to :

  • Refresh the service from a remote git repository.
  • Launch it.
    • Being confident that when the service exits it will be automatically restarted.

If ever I want to update my service I can either run sv stop ..", followed by "sv start ..", or I can run:

root@shelob:~# sv restart /etc/service/blogspam.js/
ok: run: /etc/service/blogspam.js/: (pid 14712) 0s

It is possible to run many scripts like this, for example you can launch SSH under runit by removing the standard init-script, and creating a file /etc/service/sshd/run:

#!/bin/sh
exec /usr/sbin/sshd -D

You'd not see much gain, or difference, but if your system ran out of RAM and the SSH service died it would be restarted if you went down this route. Similarly you can deploy a service that a user can have permission to restart, simply execute the process under their user-ID, and they have permission to "kill -9" it, and it will then restart:

#!/bin/sh
su - user -c "exec /home/user/daemon.sh"

I've used that technique before to ensure a particular webserver deamons are running, and still allowing the users to restart them if they wished:

#!/bin/sh
exec thttpd -D -C /srv/steve.org.uk/thttpd.conf -M 3600

In this case the thttpd webserver changes to a particular user-id after it launches:

root@www ~# ps -ef | grep s-steve
s-steve   7792  2752  0 04:25 ?        00:00:00 thttpd -D -C /srv/steve.org.uk/thttpd.conf -M 3600

Now that user can kill it, to trigger a restart:

s-steve@www:~$ kill 7792

As expected the service is alive again:

root@www~# sv status /etc/service/steve.org.uk/
run: /etc/service/steve.org.uk/: (pid 16948) 32s

The runit website contains a small collection of run-scripts which can be useful to examine; they've very handy if you have a deamon, or two, which you need to launch and which doesn't come with a real initscript.

 

 

Sign In

Username:

Password:

[Register|Advanced]

 

Flattr

 

Current Poll

Which init system are you using in Debian?






( 1024 votes ~ 6 comments )