我编写了一个 Python 脚本来检查某个电子邮件地址并将新电子邮件传递给外部程序。我怎样才能让这个脚本 24/7 执行，例如在 Linux 中把它变成守护进程或服务。我是否还需要一个永远不会在程序中结束的循环，还是可以通过多次重新执行代码来完成？
问问题
354782 次
15 回答
105
您在这里有两个选择。
进行适当的cron 作业来调用您的脚本。Cron 是 GNU/Linux 守护程序的通用名称，它根据您设置的计划定期启动脚本。您将脚本添加到 crontab 中或将符号链接放置到特殊目录中，守护程序会处理在后台启动它的工作。您可以在 Wikipedia上阅读更多内容。有多种不同的 cron 守护程序，但您的 GNU/Linux 系统应该已经安装了它。
使用某种python 方法（例如库）让您的脚本能够自行守护进程。是的，它需要一个简单的事件循环（您的事件是计时器触发，可能由睡眠功能提供）。
我不建议您选择 2.，因为实际上您会重复 cron 功能。Linux 系统范式是让多个简单的工具交互并解决您的问题。除非有其他原因需要您制作守护程序（除了定期触发），否则请选择其他方法。
此外，如果您将 daemonize 与循环一起使用并且发生崩溃，则此后没有人会检查邮件（正如Ivan Nevostruev在对此答案的评论中指出的那样）。而如果脚本作为 cron 作业添加，它将再次触发。
于 2009-10-21T19:43:06.880 回答
76
这是取自这里的一个很好的课程：
#!/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().
"""
于 2011-06-16T15:58:40.243 回答
62
您应该使用python-daemon库，它会处理所有事情。
来自 PyPI：库，用于实现行为良好的 Unix 守护进程。
于 2009-10-21T19:43:45.630 回答
41
您可以使用 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)
希望这能让你开始。
于 2009-10-21T19:45:12.023 回答
35
假设您真的希望您的循环作为后台服务运行 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
于 2020-06-29T17:37:35.250 回答
16
您还可以使用 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 start 或 stop 来启动和停止您的 python 脚本。
于 2013-10-22T09:56:08.620 回答
15
一个简单且受支持的版本是Daemonize.
从 Python 包索引 (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()
于 2016-04-03T11:08:46.620 回答
12
cron显然是许多用途的绝佳选择。但是，它不会按照您在 OP 中的要求创建服务或守护程序。 cron只是定期运行作业（意味着作业开始和停止），并且不超过一次/分钟。有一些问题cron——例如，如果您的脚本的先前实例仍在运行，下次cron计划出现并启动一个新实例时，可以吗？ cron不处理依赖关系；它只是在时间表要求时尝试开始工作。
如果您发现确实需要守护程序（永不停止运行的进程）的情况，请查看supervisord. 它提供了一种简单的方法来包装普通的、非守护程序的脚本或程序，并使其像守护程序一样运行。这比创建本地 Python 守护程序要好得多。
于 2013-10-22T10:36:53.417 回答
11
$nohup在linux上使用命令怎么样？
我用它在我的 Bluehost 服务器上运行我的命令。
如果我错了，请指教。
于 2012-01-21T21:00:02.227 回答
8
Ubuntu 有一种非常简单的方法来管理服务。对于 python，不同之处在于所有依赖项（包）都必须位于运行主文件的同一目录中。
我只是设法创建这样的服务来向我的客户提供天气信息。脚步：
像往常一样创建您的 python 应用程序项目。
在本地安装所有依赖项，例如： sudo pip3 install package_name -t 。
创建命令行变量并在代码中处理它们（如果需要）
创建服务文件。一些（极简主义）像：
[Unit] Description=1Droid Weather meddleware provider [Service] Restart=always User=root WorkingDirectory=/home/ubuntu/weather ExecStart=/usr/bin/python3 /home/ubuntu/weather/main.py httpport=9570 provider=OWMap [Install] WantedBy=multi-user.target将文件另存为 myweather.service（例如）
如果在当前目录中启动，请确保您的应用程序运行
python3 main.py httpport=9570 provider=OWMap上面生成的名为 myweather.service（扩展名为 .service 很重要）的服务文件将被系统视为您的服务名称。这是您将用于与服务交互的名称。
复制服务文件：
sudo cp myweather.service /lib/systemd/system/myweather.service刷新恶魔注册表：
sudo systemctl daemon-reload停止服务（如果它正在运行）
sudo service myweatherr stop启动服务：
sudo service myweather start检查状态（打印语句所在的日志文件）：
tail -f /var/log/syslog或通过以下方式检查状态：
sudo service myweather status如果需要，重新开始进行另一次迭代
此服务现在正在运行，即使您注销它也不会受到影响。是的，如果主机关闭并重新启动，此服务将重新启动...我的移动 android 应用程序的信息...
于 2020-08-19T11:57:25.900 回答
7
如果您正在使用终端（ssh 或其他东西），并且希望在从终端注销后保持长时间的脚本工作，您可以尝试以下操作：
screen
apt-get install screen
在里面创建一个虚拟终端（即abc）：screen -dmS abc
现在我们连接到 abc：screen -r abc
所以，现在我们可以运行 python 脚本了：python keep_sending_mails.py
从现在开始，您可以直接关闭终端，但是，python 脚本将继续运行而不是被关闭
由于 this
keep_sending_mails.py的 PID 是虚拟屏幕的子进程而不是终端（ssh）
如果你想回去检查你的脚本运行状态，你可以screen -r abc再次使用
于 2016-01-26T06:59:40.010 回答
4
首先，阅读邮件别名。邮件别名将在邮件系统内执行此操作，而无需您使用守护程序或服务或任何类似的东西。
您可以编写一个简单的脚本，每次将邮件发送到特定邮箱时，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
于 2009-10-21T19:44:22.447 回答
3
我会推荐这个解决方案。您需要继承和覆盖方法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()
于 2015-05-08T11:12:15.563 回答
2
要创建一些像服务一样运行的东西，你可以使用这个东西：
您必须做的第一件事是安装Cement框架：Cement 框架是一个 CLI 框架，您可以在其上部署应用程序。
应用程序的命令行界面：
接口.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 interface.py --help
于 2017-08-07T09:52:23.507 回答
1
使用您的系统提供的任何服务管理器 - 例如在 Ubuntu 下使用upstart。这将为您处理所有详细信息，例如启动时启动、崩溃时重新启动等。
于 2014-01-03T16:36:35.703 回答