Cara membuat skrip Python berjalan seperti layanan atau daemon di Linux

Anda memiliki dua opsi di sini.

1. Buat pekerjaan cron yang tepat yang memanggil skrip Anda. Cron adalah nama umum untuk daemon GNU/Linux yang meluncurkan skrip secara berkala sesuai dengan jadwal yang Anda tetapkan. Anda menambahkan skrip Anda ke crontab atau menempatkan symlink ke direktori khusus dan daemon menangani tugas meluncurkannya di latar belakang. Anda dapat membaca lebih lanjut di Wikipedia. Ada berbagai daemon cron yang berbeda, tetapi sistem GNU/Linux Anda seharusnya sudah menginstalnya.

2. Gunakan semacam pendekatan python (perpustakaan, misalnya) agar skrip Anda dapat melakukan daemonisasi sendiri. Ya, itu akan membutuhkan loop peristiwa sederhana (di mana peristiwa Anda memicu pengatur waktu, mungkin, disediakan oleh fungsi tidur).

Saya tidak akan merekomendasikan Anda untuk memilih 2., karena Anda sebenarnya akan mengulangi fungsi cron. Paradigma sistem Linux adalah membiarkan beberapa alat sederhana berinteraksi dan menyelesaikan masalah Anda. Kecuali ada alasan tambahan mengapa Anda harus membuat daemon (selain memicu secara berkala), pilih pendekatan lain.

Juga, jika Anda menggunakan daemonize dengan loop dan crash terjadi, tidak ada yang akan memeriksa email setelah itu (seperti yang ditunjukkan oleh Ivan Nevostruev dalam komentar untuk jawaban ini). Sedangkan jika skrip ditambahkan sebagai tugas cron, itu hanya akan memicu lagi.

Inilah kelas bagus yang diambil dari sini:

#!/usr/bin/env python

import sys, os, time, atexit
from signal import SIGTERM

class Daemon:
        """
        A generic daemon class.

        Usage: subclass the Daemon class and override the run() method
        """
        def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
                self.stdin = stdin
                self.stdout = stdout
                self.stderr = stderr
                self.pidfile = pidfile

        def daemonize(self):
                """
                do the UNIX double-fork magic, see Stevens' "Advanced
                Programming in the UNIX Environment" for details (ISBN 0201563177)
                http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
                """
                try:
                        pid = os.fork()
                        if pid > 0:
                                # exit first parent
                                sys.exit(0)
                except OSError, e:
                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
                        sys.exit(1)

                # decouple from parent environment
                os.chdir("/")
                os.setsid()
                os.umask(0)

                # do second fork
                try:
                        pid = os.fork()
                        if pid > 0:
                                # exit from second parent
                                sys.exit(0)
                except OSError, e:
                        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
                        sys.exit(1)

                # redirect standard file descriptors
                sys.stdout.flush()
                sys.stderr.flush()
                si = file(self.stdin, 'r')
                so = file(self.stdout, 'a+')
                se = file(self.stderr, 'a+', 0)
                os.dup2(si.fileno(), sys.stdin.fileno())
                os.dup2(so.fileno(), sys.stdout.fileno())
                os.dup2(se.fileno(), sys.stderr.fileno())

                # write pidfile
                atexit.register(self.delpid)
                pid = str(os.getpid())
                file(self.pidfile,'w+').write("%s\n" % pid)

        def delpid(self):
                os.remove(self.pidfile)

        def start(self):
                """
                Start the daemon
                """
                # Check for a pidfile to see if the daemon already runs
                try:
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                        pf.close()
                except IOError:
                        pid = None

                if pid:
                        message = "pidfile %s already exist. Daemon already running?\n"
                        sys.stderr.write(message % self.pidfile)
                        sys.exit(1)

                # Start the daemon
                self.daemonize()
                self.run()

        def stop(self):
                """
                Stop the daemon
                """
                # Get the pid from the pidfile
                try:
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                        pf.close()
                except IOError:
                        pid = None

                if not pid:
                        message = "pidfile %s does not exist. Daemon not running?\n"
                        sys.stderr.write(message % self.pidfile)
                        return # not an error in a restart

                # Try killing the daemon process       
                try:
                        while 1:
                                os.kill(pid, SIGTERM)
                                time.sleep(0.1)
                except OSError, err:
                        err = str(err)
                        if err.find("No such process") > 0:
                                if os.path.exists(self.pidfile):
                                        os.remove(self.pidfile)
                        else:
                                print str(err)
                                sys.exit(1)

        def restart(self):
                """
                Restart the daemon
                """
                self.stop()
                self.start()

        def run(self):
                """
                You should override this method when you subclass Daemon. It will be called after the process has been
                daemonized by start() or restart().
                """