Run python as windows service

Быстрый ответ

Для того чтобы Python-скрипт мог работать в роли службы Windows, рекомендуется использовать библиотеку pywin32. Создайте класс службы, который будет унаследован от win32serviceutil.ServiceFramework, а затем переопределите методы SvcDoRun и SvcStop для управления запуском и остановкой службы. Установка и управление службой происходит через командную строку. Пример кода представлен ниже:

Для установки и запуска службы воспользуйтесь следующими командами:

Данный метод позволит вам работать со скриптом Python как с службой Windows.

Картинка с сайта: sky.pro

Расширение функционала вашей службы

Использование NSSM для упрощённого управления службами

NSSM (Non-Sucking Service Manager) предлагает комфортный графический интерфейс для управления службами, облегчая настройку использования скриптов и переменных среды.

Регистрация вашей службы с помощью sc.exe

Можно зарегистрировать ваш скрипт как службу, используя команду sc.exe:

Применение Python и Django для управления службами

Python и Django предоставляют возможность создавать веб-интерфейсы для управления службами, улучшая удобство и гибкость их использования.

Использование опыта работы с демонами в Linux

Если у вас имеется опыт работы с демонами в Linux, то вы усвоите создание служб для Windows быстрее, несмотря на специфику реализации в этих системах.

Визуализация

Представьте себе Python-скрипт, превращающийся в службу Windows, как робот (🤖), которы работает в автономном режиме:

Изначально Python-скрипт — это просто набор команд (📜), но после аккуратной настройки (🔧👨‍🔧), он превращается в полноценно функционирующую службу (🤖).

Решение возникающих проблем

Журналирование работы службы и обработка ошибок

Servicemanager поможет вести журнал работы службы и адекватно обрабатывать возникающие ошибки, давая полное представление о функционировании службы и возможных проблемах.

Управление переменными окружения

Использование динамической конфигурации на основе переменных окружения позволит службе адаптироваться к различным условиям работы: отладка, предпродакшн, продакшн.

Управление зависимостями

Работа службы может требовать конкретные версии библиотек или внешние модули Python. Для этого используются виртуальные среды и PyInstaller, который создаёт исполняемые файлы со всеми необходимыми зависимостями.

Продвинутое управление службой

Масштабирование службы

Для организации управления нагрузкой на службы можно применить виртуальное окружение, что упростит изоляцию и решение потенциальных проблем, связанных с масштабированием.

Тонкая настройка службы через реестр

Можно детально настроить поведение службы на уровне реестра Windows по адресу HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services.

Бесперебойные обновления и поддержка служб

Обеспечивайте возможности «горячего» обновления и «мягкого» завершения работы службы для сокращения времени простоя. Нужно продумать надежный механизм обновлений, который позволит внедрять новые версии службы без ручного вмешательства.

Полезные материалы

1. NSSM – the Non-Sucking Service Manager — инструмент для простого управления Python-службами.
2. Как запустить скрипт Python как службу в Windows на Stack Overflow — обсуждения и решения от сообщества разработчиков.
3. Полный пример службы от Microsoft — официальные рекомендации по созданию служб Windows.
4. Руководство по PyInstaller — создание автономных исполняемых файлов из Python-скриптов.
5. Планировщик задач для разработчиков от Microsoft — использование Планировщика задач Windows для автоматизации Python-скриптов.
6. Supervisor: Система контроля процессов — мониторинг и контроль над продолжительными службами на Python.

WINDOWS

When automating tasks on a Windows machine, running a Python script as a Windows service can be incredibly beneficial. Services are background processes that can start up automatically when the system boots, allowing your script to run without the need for a user to be logged in. This guide will help you navigate around Windows permissions issues, user logins, and set up your Python script to run smoothly anytime your computer is on.

Why Run a Python Script as a Windows Service?

Running scripts as services has several advantages:

• Automatic Start: Services can start when the system boots up, ensuring that your script is always running.

• No User Session Required: Unlike running scripts from a user account, services can run without any user logged in.

• Better Management: Being able to start, stop, or restart applications through the Services management console can make your life easier.

Prerequisites

Before diving in, ensure you have the following:

• Python installed on your Windows machine (preferably the latest version).

• pywin32 package, which provides access to many Windows APIs from Python, including service functionalities.

You can install the required pywin32 library using pip:

Step-by-Step Guide to Create a Windows Service for Your Python Script

Step 1: Create Your Python Script

Before creating the service, you need a functional Python script. Here is a simple example script that writes the current time to a log file every minute:

import time
import logging

# Set up logging
logging.basicConfig(filename='example.log', level=logging.INFO)

while True:
    logging.info("Current time is: {}".format(time.ctime()))
    time.sleep(60)  # Wait for one minute

Step 2: Creating the Service Script

You will need to create another Python script that defines the service itself. Here’s how to do it:

import time
import servicemanager
import win32service
import win32serviceutil
import logging
import os

class PythonService(win32serviceutil.ServiceFramework):
    _svc_name_ = "PythonService"
    _svc_display_name_ = "Python Service Example"
    _svc_description_ = "Python Service that logs time to a file."

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.stop_event = win32event.CreateEvent(None, 0, 0, None)
        self.running = True
        self.log_file = 'example.log'
        logging.basicConfig(filename=self.log_file, level=logging.INFO)

    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.stop_event)
        self.running = False

    def SvcDoRun(self):
        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,
                               servicemanager.PYS_SERVICE_STARTED,
                               (self._svc_name_, ''))
        self.main()

    def main(self):
        while self.running:
            logging.info("Current time is: {}".format(time.ctime()))
            time.sleep(60)  # Wait for one minute

if __name__ == '__main__':
    win32serviceutil.HandleCommandLine(PythonService)

Step 3: Install the Service

To install the service, open a command prompt with administrative privileges and run the following command:

python your_service_script.py install

Replace your_service_script.py with the name of the service script you just created.

Step 4: Start the Service

Once installed, you can start the service using:

python your_service_script.py start

Alternatively, you can manage your service through the Windows Services management console.

Step 5: Debugging and Logs

Check the example.log file to see if it is logging the time as expected. In case something goes wrong, you can troubleshoot by running the service script directly in a terminal (not as a service) to see if any errors are raised.

Step 6: Stop and Uninstall the Service

To stop the service, use:

python your_service_script.py stop

And to uninstall it, run:

python your_service_script.py remove

Managing Permissions and User Logins

Running scripts as a service might raise issues related to permissions. Here are a few tips to manage these:

• User Account: When setting up the service, ensure it runs under a user account with the right permissions to access files or external resources used by the script.

• Interactive Services: Windows services typically cannot interact with the desktop. If your script requires user input, consider redesigning it to operate without interaction.

• Logs: Always include logging in your script, so any issues can be diagnosed easily. Make sure the account running the service has write permissions to the log location.

Conclusion

Running a Python script as a Windows service can enhance automation by ensuring your tasks run consistently in the background, regardless of user logins. Utilizing the pywin32 library simplifies creating and managing services, alleviating many common permissions issues. By following this guide, you can effectively automate your processes, ensuring they are executed whenever your machine is turned on.

Key Takeaways

• Automate tasks by running Python scripts as Windows services.

• Utilize the pywin32 library for service creation.

• Manage service permissions carefully to avoid runtime issues.

• Implement logging for easier troubleshooting.

By applying this knowledge, you can make full use of your Python scripts in a Windows environment and streamline your workflow efficiently.

Suggested Articles

Need to continuously run Python scripts for ongoing automation and scheduling? Configuring scripts as long-running services can be a robust solution.

In this comprehensive, 2200+ word guide, we’ll walk through the steps to run Python scripts as system services on both Linux and Windows.

We’ll cover:

• Key benefits of using services for automation
• How Linux systemd and Windows Service Control Manager work
• Configuring systemd units to manage Python services
• Building Windows services with pywin32
• Simplifying Windows services with NSSM
• Tips for security, logging, and troubleshooting

Follow along and you’ll gain the knowledge to configure your Python automation scripts to run reliably as services on any system!

Why Run Python Scripts as Services?

Running scripts via python script.py works fine for one-off jobs. But for recurring automation tasks, dedicated services provide important benefits:

Scheduled Execution

Services run continuously in the background rather than needing manual starts. This enables python scripts to be run on schedules.

Automatic Restarts

Crashed or stopped services can restart automatically. This results in resilient automation.

Centralized Control

Tools like systemd and the Windows Service Control Manager provide one place to monitor, configure, and manage services.

Security

Services can run under isolated users and permissions for reduced risk.

Common examples of Python scripts that work well as services:

• Web scraping scripts that need to run regularly to fetch updated data
• Machine learning model training that is resource-intensive if run too often
• Cron-style scheduled jobs like cleaning temp files or synchronizing caches

Next, we‘ll look at how Linux systemd and Windows Service Control Manager enable running scripts as managed services.

An Introduction to Service Managers

Modern operating systems come equipped with service managers that handle launching, monitoring, and stopping services.

systemd

The most widely used service manager on Linux is systemd. It acts as the init system for most major distros like Ubuntu, Debian, RHEL.

systemd is powerful not only because it handles service processes, but also because it manages system startup, devices, sockets, timers, and more.

Key capabilities provided by systemd for services:

• Service lifecycle management – start, stop, restart
• Configurable restart policies – always restart, on-failure, etc
• Resource limitation – set memory, CPU, IO limits
• Log integration with journald
• Dependency ordering – start service X after Y

Services are configured by creating unit files, typically stored in /etc/systemd/system.

Windows Service Control Manager

This is the service manager built into Windows for handling long-running backend processes. It provides similar capabilities to systemd, such as:

• Automated startup of services
• Monitoring service state – running, stopped, etc
• Centralized control for starting, stopping services
• Configurable restart settings and recovery actions

Services register themselves with the SCM and provide lifecycle event handlers. The net command is used to manage services.

Now that we‘ve seen how Linux and Windows enable services, let‘s walk through configuring Python scripts on each!

Step-by-Step: Creating systemd Services for Python

On Linux, we can leverage systemd to run Python scripts as managed services. This offers standardized configs and tight integration with the OS.

Let‘s look at how to configure a Python script as a systemd service on Linux:

1. First, create a Python script with the logic you want to run continuously:

    import requests
   
    def main():
        response = requests.get("https://www.example.com")
        print(response.status_code)
   
    if __name__ == "__main__":
        main() 

2. Next, create a systemd service file like /etc/systemd/system/myscript.service:

    [Unit]
    Description=My Script Service
   
    [Service]
    ExecStart=/usr/bin/python3 /opt/scripts/myscript.py 
    Restart=on-failure
    RestartSec=10
   
    [Install]
    WantedBy=multi-user.target

   Let‘s explain some key points:

   • The [Unit] section provides metadata like a description
   • [Service] defines the script path for ExecStart and restart policy
   • [Install] says to start on system boot as a multi-user service
3. Now reload systemd and start the service:

    sudo systemctl daemon-reload
    sudo systemctl start myscript.service

4. Check status with systemctl status myscript or view logs via journalctl -u myscript

And we have a Python service managed by systemd! The script will run continuously, logging to journald, and auto-restart on failures.

Some more tips for robust Python systemd services:

• Use ExecStartPre and ExecStartPost to add prep/cleanup logic
• Set resource limits under [Service] like MemoryMax=200M
• Make the service a template file at /etc/systemd/system/[email protected] for multiple instances

Overall systemd provides a powerful way to deploy Python scripts as managed Linux services.

Creating Windows Services in Python with pywin32

On Windows, we can use the pywin32 library to directly create services using Python.

The steps are:

1. Structure the Python script to handle service commands
2. Subclass win32serviceutil.ServiceFramework
3. Implement lifecycle event handlers like SvcDoRun
4. Install and run the service

Here is an example Python Windows service:

import win32serviceutil
import win32service

class PySvc(win32serviceutil.ServiceFramework):
    _svc_name_ = "PyService"
    _svc_display_name_ = "Python Sample Service"

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)

    def SvcDoRun(self):
        self.ReportServiceStatus(win32service.SERVICE_RUNNING) 
        # service logic goes here

    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOPPED)
        # shutdown logic goes here 

if __name__ == ‘__main__‘: 
    win32serviceutil.HandleCommandLine(PySvc)

To install:

pyinstaller --onefile pyservice.py
pyservice.exe --install  
net start PyService

This allows full control over the Python service logic. But the pywin32 APIs can be verbose and low-level.

Simplifying Windows Services with NSSM

An alternative to pywin32 for running Python scripts as Windows services is the NSSM – the Non-Sucking Service Manager.

NSSM makes it very easy to wrap executables as Windows services with just a few commands:

nssm install MyService C:\Python\myscript.exe
nssm set MyService AppParameters "--log=C:\logs\mylog.txt"
nssm start MyService

Advantages of using NSSM over pywin32:

• No need to write Python service classes
• Easily pass arguments with AppParameters
• Management via concise commands like nssm [action] [service]
• Monitor stdout/stderr, set working directory, etc

So if you just need to quickly run a Python script as a Windows service, definitely give NSSM a try!

Securing and Troubleshooting Python Services

When running Python scripts as persistent services, we also need to consider security, logging, and troubleshooting.

Here are some tips:

• Run under a limited user – Don‘t give the service account more permissions than necessary
• Enable logging – For systemd, integrate with journald. For Windows, redirect to a log file
• Limit restart attempts – In case of crashes, don‘t restart endlessly
• Sandbox the environment – Use virtual environments and AppArmor profiles
• Review logs – journalctl and event viewer are key troubleshooting tools
• Monitor processes – Check systemctl status or task manager for resource usage
• Use service management commands – systemctl, nssm, and net start/stop services
• Know how to disable services – Run systemctl disable or sc config [Service] start= disabled

Taking these best practices into account will help keep Python services running smoothly and securely.

Alternative Service Managers

While systemd and Windows SCM are native solutions, there are also some cross-platform alternatives:

• supervisord – Popular for managing Python and Go services
• pm2 – Node.js service manager with a large ecosystem

Both allow configuring services in ini-style config files and provide features like monitoring and log aggregation.

For simpler scripts, systemd or NSSM may be preferable. But supervisord and pm2 are worth evaluating if you need broader language support.

Key Takeaways

We‘ve covered a lot of ground on running Python scripts as managed services! Here are some key tips to remember:

• Use systemd on Linux and SCM on Windows for native OS integration
• Familiarize yourself with journald and event viewer for logging
• systemd uses unit files, SCM uses registry keys
• For Windows, NSSM makes deployment easy
• Control service lifecycles via systemctl, net stop, etc
• Follow security best practices like limited accounts
• Set restart policies to balance availability and recoverability

Whether you‘re on Linux or Windows, you now have the knowledge to configure Python scripts as services! Automating recurring tasks with Python is now easy and reliable.

If you want to run a Python 3 application as a Windows Service, then you are going to love NSSM. Since NSSM handles the life cycle of a Windows Service for our Python 3 application, we can keep it platform agnostic.

Previously, we saw how we can use a Python 3 virtual environment in Windows 10. Given that, let’s see how we can use NSSM to run a Python 3 application as a Windows Service in its own Python 3 virtual environment.

Creating a sample Python 3 application

In order to simplify this tutorial, let’s attempt to run the Python 3 Flask application with an API endpoint that generates a QR Code image as a Windows Service.

In addition to that, let us place requirements.txt and run_app.py into the %systemdrive%%homepath%\Documents\qr-code-app folder.

Contents of requirements.txt

flask-restplus==0.12.1
Pillow==6.0.0
qrcode==6.1

Contents of run_app.py

from flask import Flask, Blueprint, request, send_file
from flask_restplus import Api, Namespace, Resource, fields
# import library to help us with file IO
from io import BytesIO
 
import os, qrcode
 
# Create Flask app
app = Flask(__name__)
 
# Associate Api with Blueprint
api_blueprint = Blueprint('API', __name__)
api = Api(api_blueprint,
    title='Api for QR code app',
    version='1.0',
    description='This is an API for QR code app',
    # All API metadatas
)
 
# Create namespace for containing Qr Code related operations
qrcode_namespace = Namespace('QrCode', description='Qr code related operations')
# Specify uri of qrcode namespace as /qrcode
api.add_namespace(qrcode_namespace, path='/qrcode')
# Specify uri of api blueprint as /api
app.register_blueprint(api_blueprint, url_prefix='/api')
 
# Define input model
qrcode_creation_input = qrcode_namespace.model('QRCode creation Input', {
    'value': fields.String(required=True, description='The value that is supposed to be encoded into qrcode'),
})
 
 
# Define API endpoint for creating Qr Code image
@qrcode_namespace.route('/')
@qrcode_namespace.doc('Creates a QRCode image based on a string value.')
class QrCodeRoot(Resource):
 
    @qrcode_namespace.expect(qrcode_creation_input)
    @qrcode_namespace.produces(['image/png'])
    @qrcode_namespace.response(200, description='Return QR Code png image file.')
    @qrcode_namespace.response(400, description='Invalid input provided.')
    def post(self):
 
        # Get value to encode into QR Code
        json_input = request.get_json()
        value_to_turn_into_qrcode = json_input['value']
 
        # Create qr code image and return it as HTTP response
        pil_img = qrcode.make(value_to_turn_into_qrcode)
        img_io = BytesIO()
        pil_img.save(img_io, 'PNG')
        img_io.seek(0)
        return send_file(img_io, mimetype='image/png')
 
 
if __name__ == '__main__':
    port = int(os.getenv("PORT", "5678"))
    app.run(host='0.0.0.0', port=port)

Preparing the virtual environment to run our Python 3 application

Before continuing on, be sure to go through the tutorial on how to use a Python 3 virtual environment in Windows 10. After you had gone through the tutorial, you would have installed Python 3 on your Windows machine. In addition to that, you will understand how to create, activate and install dependencies into a virtual environment.

Creating the virtual environment to run our Python 3 application

Given these points, let us first create the virtual environment to run our Python 3 application. In order to do so, start a command prompt window and type in the following command:

python -m venv "%systemdrive%%homepath%\Documents\qr-code-app-env"

After the command completes, you will find the Python 3 virtual environment within the %systemdrive%%homepath%\Documents\qr-code-app-env folder.

Installing the application dependencies into the virtual environment

Next, activate your Python 3 virtual environment by running the following command:

"%systemdrive%%homepath%\Documents\qr-code-app-env\Scripts\activate.bat"

After your Python 3 virtual environment got activated, run the following command to install the Python dependencies for the application:

pip install -r "%systemdrive%%homepath%\Documents\qr-code-app\requirements.txt"

When the dependencies are installed, you will be able to run your Python application within the virtual environment.

Creating the .bat file to run our Python 3 application in its own virtual environment

At this point in time, you are ready to create a .bat file to start your application within the virtual environment. Given that, create a run_app.bat in the %systemdrive%%homepath%\Documents\qr-code-app folder with the following content:

call ..\qr-code-app-env\Scripts\activate.bat
call python run_app.py

Downloading a copy of NSSM

After you had created the windows batch file to run the your Python application within the virtual environment, proceed to download NSSM. Save the .zip file and extract its content. After extracting the content, you will find a nssm.exe file inside the win32 and win64 folder.

Depending on whether your Windows is 32 bit or 64 bit, you will use the corresponding nssm.exe file to install your Python application as a Windows Service.

For the purpose of this tutorial, let’s assume that we want to use the nssm.exe in the C:\nssm-2.24\win64 folder.

Run a command prompt instance as administrator

In order to avoid being prompted for administrator access for subsequent calls to C:\nssm-2.24\win64, let’s run a command prompt instance as administrator.

We will run the subsequent commands in this command prompt instance.

Installing your Python application as a Windows Service with nssm.exe

Given that our nssm.exe is located in C:\nssm-2.24\win64, we can then use the following command to install our Python application as a Windows Service:

C:\nssm-2.24\win64\nssm install qrcodeapp "%systemdrive%%homepath%\Documents\qr-code-app\run_app.bat"

When you run the command, NSSM will install your Python 3 application as a Windows Service.

At this point in time, your Windows Service is not yet started.

Enabling log files for your Python 3 application

When you start your Windows Service at this point in time, it will not generate any log files when it runs.

Therefore, let’s configure it to channel application output to log files.

In order to do so, first start NSSM service editor with the following command:

C:\nssm-2.24\win64\nssm edit qrcodeapp

After the command run, NSSM service editor will appear for enabling log files for your Python 3 application.

Картинка с сайта: www.techcoil.com

Given that, click on the I/O tab and enter the paths that you want the log files to appear:

Картинка с сайта: www.techcoil.com

Once you are done with that, click Edit service.

Starting your Python application as a Windows Service

In order to start the Windows Service for your Python application, run the following command:

C:\nssm-2.24\win64\nssm start qrcodeapp

Since Startup Type for the Windows Service is set to Automatic, our Python 3 Flask application will run automatically when we had started our Windows machine.

Further usages of NSSM

At this point in time, we will have fulfilled our goal of using NSSM to run a Python 3 application as a Windows Service in its own Python 3 virtual environment.

In addition to what I had covered, the nssm.exe contains several other functionalities.

In case you need to use other functionalities of NSSM, you can refer to NSSM usage page for more information.