如何使 Python 脚本像 Linux 中的服务或守护进程一样运行

Question

我编写了一个 Python 脚本来检查某个电子邮件地址并将新电子邮件传递给外部程序。我怎样才能让这个脚本24/7执行，比如把它变成Linux中的守护进程或服务。我是否还需要一个在程序中永远不会结束的循环，或者可以通过多次重新执行代码来完成吗？

Answer 1

这里你有两个选择。

1. 创建一个适当的cron 作业来调用您的脚本。 Cron 是 GNU/Linux 守护程序的通用名称，它根据您设置的时间表定期启动脚本。您将脚本添加到 crontab 中或将其符号链接放置到特殊目录中，守护程序将处理在后台启动它的工作。您可以在维基百科上了解更多内容。有多种不同的 cron 守护进程，但您的 GNU/Linux 系统应该已经安装了它。

2. 使用某种python 方法（例如，一个库）让您的脚本能够自行守护进程。是的，它将需要一个简单的事件循环（其中您的事件是计时器触发，可能由睡眠函数提供）。

我不建议您选择 2.，因为实际上您会重复 cron 功能。 Linux系统范式是让多个简单的工具交互并解决你的问题。除非有其他原因需要创建守护程序（除了定期触发），否则请选择其他方法。

另外，如果您在循环中使用 daemonize 并且发生崩溃，则此后没有人会检查邮件（正如 Ivan 所指出的） Nevostruev 在对 这个答案）。而如果脚本被添加为 cron 作业，它只会再次触发。

Answer 2

这是一个很好的课程，取自

#!/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().
                """

Answer 3

假设您确实希望循环作为后台服务 24/7 运行

对于不涉及使用库注入代码的解决方案，您可以简单地创建一个服务模板，因为您正在使用linux：

[Unit]
Description = <Your service description here>
After = network.target # Assuming you want to start after network interfaces are made available
 
[Service]
Type = simple
ExecStart = python <Path of the script you want to run>
User = # User to run the script as
Group = # Group to run the script as
Restart = on-failure # Restart when there are errors
SyslogIdentifier = <Name of logs for the service>
RestartSec = 5
TimeoutStartSec = infinity
 
[Install]
WantedBy = multi-user.target # Make it accessible to other users

将该文件放在守护程序服务文件夹（通常为 /etc/systemd/system/）中的 *.service 文件中，并使用以下 systemctl 命令安装它（可能需要 sudo 权限）：

systemctl enable <service file name without .service extension>

systemctl daemon-reload

systemctl start <service file name without .service extension>

然后您可以使用以下命令检查您的服务是否正在运行：

systemctl | grep running

Answer 4

您应该使用 python-daemon 库，它会处理一切。

来自 PyPI：用于实现行为良好的 Unix 守护进程的库。

Answer 5

您可以使用 fork() 将脚本与 tty 分离并让它继续运行，如下所示：

import os, sys
fpid = os.fork()
if fpid!=0:
  # Running as daemon now. PID is fpid
  sys.exit(0)

当然您还需要实现一个无限循环，例如

while 1:
  do_your_check()
  sleep(5)

希望这能让您开始。

Answer 6

一个简单且受支持的版本是Daemonize。

从 Python Package Index (PyPI) 安装它：

$ pip install daemonize

然后使用如下：

...
import os, sys
from daemonize import Daemonize
...
def main()
      # your code here

if __name__ == '__main__':
        myname=os.path.basename(sys.argv[0])
        pidfile='/tmp/%s' % myname       # any name
        daemon = Daemonize(app=myname,pid=pidfile, action=main)
        daemon.start()

Answer 7

您还可以使用 shell 脚本使 python 脚本作为服务运行。首先创建一个 shell 脚本来运行 python 脚本，如下所示（scriptname 任意名称）

#!/bin/sh
script='/home/.. full path to script'
/usr/bin/python $script &

现在在 /etc/init.d/scriptname 中创建一个文件

#! /bin/sh

PATH=/bin:/usr/bin:/sbin:/usr/sbin
DAEMON=/home/.. path to shell script scriptname created to run python script
PIDFILE=/var/run/scriptname.pid

test -x $DAEMON || exit 0

. /lib/lsb/init-functions

case "$1" in
  start)
     log_daemon_msg "Starting feedparser"
     start_daemon -p $PIDFILE $DAEMON
     log_end_msg $?
   ;;
  stop)
     log_daemon_msg "Stopping feedparser"
     killproc -p $PIDFILE $DAEMON
     PID=`ps x |grep feed | head -1 | awk '{print $1}'`
     kill -9 $PID       
     log_end_msg $?
   ;;
  force-reload|restart)
     $0 stop
     $0 start
   ;;
  status)
     status_of_proc -p $PIDFILE $DAEMON atd && exit 0 || exit $?
   ;;
 *)
   echo "Usage: /etc/init.d/atd {start|stop|restart|force-reload|status}"
   exit 1
  ;;
esac

exit 0

现在您可以使用命令 /etc/init.d/scriptname 启动和停止 python 脚本开始或停止。

Answer 8

对于许多用途来说，cron 显然是一个不错的选择。但是，它不会按照您在 OP 中请求的那样创建服务或守护程序。 cron 只是定期运行作业（意味着作业启动和停止），并且频率不超过每分钟一次。 cron 存在问题 - 例如，如果下次 cron 计划出现并启动新实例时，您的脚本的先前实例仍在运行，那么是不是好的？ cron 不处理依赖关系；它只是尝试按照时间表开始工作。

如果您发现确实需要守护进程（一个永不停止运行的进程）的情况，请查看 supervisord。它提供了一种简单的方法来包装普通的非守护程序脚本或程序，并使其像守护程序一样运行。这是比创建本机 Python 守护程序更好的方法。

Answer 9

Ubuntu 有一种非常简单的方法来管理服务。
对于 python，区别在于所有依赖项（包）必须位于运行主文件的同一目录中。

我只是设法创建这样的服务来向我的客户提供天气信息。
步骤：

• 像平常一样创建 Python 应用程序项目。

• 在本地安装所有依赖项，如下所示：
  sudo pip3 install package_name -t 。

• 创建命令行变量并在代码中处理它们（如果需要）

• 创建服务文件。一些（极简主义），例如：

  <前><代码> [单位]
  描述=1Droid 天气中间件提供商

  [服务]
  重新启动=始终
  用户=root
  工作目录=/home/ubuntu/天气
  ExecStart=/usr/bin/python3 /home/ubuntu/weather/main.py httpport=9570 提供商=OWMap

  [安装]
  WantedBy=多用户.target

• 将文件另存为 myweather.service（例如）

• 确保您的应用程序在当前目录中启动时运行

   python3 main.py httpport=9570 提供者=OWMap
  

• 上面生成的名为 myweather.service 的服务文件（重要的是具有扩展名 .service）将被系统视为您的服务名称。这是您将用来与服务交互的名称。

• 复制服务文件：

   sudo cp myweather.service /lib/systemd/system/myweather.service
  

• 刷新恶魔注册表：

   sudo systemctl daemon-reload
  

• 停止服务（如果它正在运行）

   sudo service myweather stop
  

• 启动服务：

   sudo service myweather start
  

• 检查状态（包含打印语句所在位置的日志文件）：

  <前><代码> tail -f /var/log/syslog

• 或检查状态：

   sudo service myweather 状态
  

• 如果需要，请返回到开头进行另一次迭代

该服务现在正在运行，即使您注销它也不会受到影响。
是的，如果主机关闭并重新启动，该服务将重新启动......

Answer 10

在 Linux 上使用 $nohup 命令怎么样？

我用它在 Bluehost 服务器上运行命令。

如果我错了请指教。

Answer 11

如果您使用终端（ssh 或其他），并且希望在从终端注销后保持脚本长时间运行，您可以尝试以下操作：

screen

apt-get install screen

在里面创建一个虚拟终端（即 abc）： screen -dmS abc

现在我们连接到 abc： screen -r abc

所以，现在我们可以运行 python 脚本: python keep_sending_mails.py

从现在开始，您可以直接关闭终端，但是 python 脚本将继续运行而不是被关闭

因为这个 keep_sending_mails.py 的 PID 是虚拟屏幕的子进程而不是
终端（ssh）

如果你想返回检查脚本运行状态，你可以再次使用 screen -r abc

Answer 12

首先，阅读邮件别名。邮件别名将在邮件系统内执行此操作，而无需您使用守护程序或服务或任何类似的东西。

您可以编写一个简单的脚本，每次将邮件消息发送到特定邮箱时，sendmail 都会执行该脚本。

请参阅 http://www.feep.net/sendmail/tutorial/intro/aliases .html

如果你真的想编写一个不必要的复杂服务器，你可以这样做。

nohup python myscript.py &

仅此而已。您的脚本只是循环并休眠。

import time
def do_the_work():
    # one round of polling -- checking email, whatever.
while True:
    time.sleep( 600 ) # 10 min.
    try:
        do_the_work()
    except:
        pass

Answer 13

我会推荐这个解决方案。您需要继承并重写方法run。

import sys
import os
from signal import SIGTERM
from abc import ABCMeta, abstractmethod



class Daemon(object):
    __metaclass__ = ABCMeta


    def __init__(self, pidfile):
        self._pidfile = pidfile


    @abstractmethod
    def run(self):
        pass


    def _daemonize(self):
        # decouple threads
        pid = os.fork()

        # stop first thread
        if pid > 0:
            sys.exit(0)

        # write pid into a pidfile
        with open(self._pidfile, 'w') as f:
            print >> f, os.getpid()


    def start(self):
        # if daemon is started throw an error
        if os.path.exists(self._pidfile):
            raise Exception("Daemon is already started")

        # create and switch to daemon thread
        self._daemonize()

        # run the body of the daemon
        self.run()


    def stop(self):
        # check the pidfile existing
        if os.path.exists(self._pidfile):
            # read pid from the file
            with open(self._pidfile, 'r') as f:
                pid = int(f.read().strip())

            # remove the pidfile
            os.remove(self._pidfile)

            # kill daemon
            os.kill(pid, SIGTERM)

        else:
            raise Exception("Daemon is not started")


    def restart(self):
        self.stop()
        self.start()

Answer 14

要创建像服务一样运行的东西，您可以使用这个东西：

您必须做的第一件事是安装 水泥框架：
Cement 框架是一个 CLI 框架，您可以在其上部署应用程序。

应用程序的命令行界面：

interface.py

 from cement.core.foundation import CementApp
 from cement.core.controller import CementBaseController, expose
 from YourApp import yourApp

 class Meta:
    label = 'base'
    description = "your application description"
    arguments = [
        (['-r' , '--run'],
          dict(action='store_true', help='Run your application')),
        (['-v', '--version'],
          dict(action='version', version="Your app version")),
        ]
        (['-s', '--stop'],
          dict(action='store_true', help="Stop your application")),
        ]

    @expose(hide=True)
    def default(self):
        if self.app.pargs.run:
            #Start to running the your app from there !
            YourApp.yourApp()
        if self.app.pargs.stop:
            #Stop your application
            YourApp.yourApp.stop()

 class App(CementApp):
       class Meta:
       label = 'Uptime'
       base_controller = 'base'
       handlers = [MyBaseController]

 with App() as app:
       app.run()

YourApp.py 类：

 import threading

 class yourApp:
     def __init__:
        self.loger = log_exception.exception_loger()
        thread = threading.Thread(target=self.start, args=())
        thread.daemon = True
        thread.start()

     def start(self):
        #Do every thing you want
        pass
     def stop(self):
        #Do some things to stop your application

请记住，您的应用程序必须在线程上运行才能成为守护进程

要运行应用程序，只需在命令行中执行此操作

python 接口.py --help

Answer 15

使用您的系统提供的任何服务管理器 - 例如在 Ubuntu 下使用 upstart。这将为您处理所有细节，例如启动时启动、崩溃时重新启动等。

Answer 16

您可以在脚本或另一个脚本中将进程作为子进程运行，

subprocess.Popen(arguments, close_fds=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL)

或者使用现成的实用程序

https://github.com/megashchik/d-handler