Windows run python script as service

This answer is plagiarizer from several sources on StackOverflow — most of them above, but I’ve forgotten the others — sorry. It’s simple and scripts run «as is». For releases you test you script, then copy it to the server and Stop/Start the associated service. And it should work for all scripting languages (Python, Perl, node.js), plus batch scripts such as GitBash, PowerShell, even old DOS bat scripts.
pyGlue is the glue that sits between Windows Services and your script.

'''
A script to create a Windows Service, which, when started, will run an executable with the specified parameters.
Optionally, you can also specify a startup directory

To use this script you MUST define (in class Service)
1. A name for your service (short - preferably no spaces)
2. A display name for your service (the name visibile in Windows Services)
3. A description for your service (long details visible when you inspect the service in Windows Services)
4. The full path of the executable (usually C:/Python38/python.exe or C:WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe
5. The script which Python or PowerShell will run(or specify None if your executable is standalone - in which case you don't need pyGlue)
6. The startup directory (or specify None)
7. Any parameters for your script (or for your executable if you have no script)

NOTE: This does not make a portable script.
The associated '_svc_name.exe' in the dist folder will only work if the executable,
(and any optional startup directory) actually exist in those locations on the target system

Usage: 'pyGlue.exe [options] install|update|remove|start [...]|stop|restart [...]|debug [...]'
Options for 'install' and 'update' commands only:
        --username domain\username : The Username the service is to run under
        --password password : The password for the username
        --startup [manual|auto|disabled|delayed] : How the service starts, default = manual
        --interactive : Allow the service to interact with the desktop.
        --perfmonini file: .ini file to use for registering performance monitor data
        --perfmondll file: .dll file to use when querying the service for performance data, default = perfmondata.dll
Options for 'start' and 'stop' commands only:
        --wait seconds: Wait for the service to actually start or stop.
                If you specify --wait with the 'stop' option, the service and all dependent services will be stopped,
                each waiting the specified period.
'''

# Import all the modules that make life easy
import servicemanager
import socket
import sys
import win32event
import win32service
import win32serviceutil
import win32evtlogutil
import os
from logging import Formatter, Handler
import logging
import subprocess


# Define the win32api class
class Service (win32serviceutil.ServiceFramework):
        # The following variable are edited by the build.sh script
        _svc_name_ = "TestService"
        _svc_display_name_ = "Test Service"
        _svc_description_ = "Test Running Python Scripts as a Service"
        service_exe = 'c:/Python27/python.exe'
        service_script = None
        service_params = []
        service_startDir = None

        # Initialize the service
        def __init__(self, args):
                win32serviceutil.ServiceFramework.__init__(self, args)
                self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
                self.configure_logging()
                socket.setdefaulttimeout(60)

        # Configure logging to the WINDOWS Event logs
        def configure_logging(self):
                self.formatter = Formatter('%(message)s')
                self.handler = logHandler()
                self.handler.setFormatter(self.formatter)
                self.logger = logging.getLogger()
                self.logger.addHandler(self.handler)
                self.logger.setLevel(logging.INFO)

        # Stop the service
        def SvcStop(self):
                self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
                win32event.SetEvent(self.hWaitStop)

        # Run the service
        def SvcDoRun(self):
                self.main()

        # This is the service
        def main(self):

                # Log that we are starting
                servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE, servicemanager.PYS_SERVICE_STARTED,
                                                          (self._svc_name_, ''))

                # Fire off the real process that does the real work
                logging.info('%s - about to call Popen() to run %s %s %s', self._svc_name_, self.service_exe, self.service_script, self.service_params)
                self.process = subprocess.Popen([self.service_exe, self.service_script] + self.service_params, shell=False, cwd=self.service_startDir)
                logging.info('%s - started process %d', self._svc_name_, self.process.pid)

                # Wait until WINDOWS kills us - retrigger the wait for stop every 60 seconds
                rc = None
                while rc != win32event.WAIT_OBJECT_0:
                        rc = win32event.WaitForSingleObject(self.hWaitStop, (1 * 60 * 1000))

                # Shut down the real process and exit
                logging.info('%s - is terminating process %d', self._svc_name_, self.process.pid)
                self.process.terminate()
                logging.info('%s - is exiting', self._svc_name_)


class logHandler(Handler):
        '''
Emit a log record to the WINDOWS Event log
        '''

        def emit(self, record):
                servicemanager.LogInfoMsg(record.getMessage())


# The main code
if __name__ == '__main__':
        '''
Create a Windows Service, which, when started, will run an executable with the specified parameters.
        '''

        # Check that configuration contains valid values just in case this service has accidentally
        # been moved to a server where things are in different places
        if not os.path.isfile(Service.service_exe):
                print('Executable file({!s}) does not exist'.format(Service.service_exe), file=sys.stderr)
                sys.exit(0)
        if not os.access(Service.service_exe, os.X_OK):
                print('Executable file({!s}) is not executable'.format(Service.service_exe), file=sys.stderr)
                sys.exit(0)
        # Check that any optional startup directory exists
        if (Service.service_startDir is not None) and (not os.path.isdir(Service.service_startDir)):
                print('Start up directory({!s}) does not exist'.format(Service.service_startDir), file=sys.stderr)
                sys.exit(0)

        if len(sys.argv) == 1:
                servicemanager.Initialize()
                servicemanager.PrepareToHostSingle(Service)
                servicemanager.StartServiceCtrlDispatcher()
        else:
                # install/update/remove/start/stop/restart or debug the service
                # One of those command line options must be specified
                win32serviceutil.HandleCommandLine(Service)

Now there’s a bit of editing and you don’t want all your services called ‘pyGlue’. So there’s a script (build.sh) to plug in the bits and create a customized ‘pyGlue’ and create an ‘.exe’. It is this ‘.exe’ which gets installed as a Windows Service. Once installed you can set it to run automatically.

#!/bin/sh
# This script build a Windows Service that will install/start/stop/remove a service that runs a script
# That is, executes Python to run a Python script, or PowerShell to run a PowerShell script, etc

if [ $# -lt 6 ]; then
        echo "Usage: build.sh Name Display Description Executable Script StartupDir [Params]..."
        exit 0
fi

name=$1
display=$2
desc=$3
exe=$4
script=$5
startDir=$6
shift; shift; shift; shift; shift; shift
params=
while [ $# -gt 0 ]; do
        if [ "${params}" != "" ]; then
                params="${params}, "
        fi
        params="${params}'$1'"
        shift
done

cat pyGlue.py | sed -e "s/pyGlue/${name}/g" | 
        sed -e "/_svc_name_ =/s?=.*?= '${name}'?" | 
        sed -e "/_svc_display_name_ =/s?=.*?= '${display}'?" | 
        sed -e "/_svc_description_ =/s?=.*?= '${desc}'?" | 
        sed -e "/service_exe =/s?=.*?= '$exe'?" | 
        sed -e "/service_script =/s?=.*?= '$script'?" | 
        sed -e "/service_params =/s?=.*?= [${params}]?" | 
        sed -e "/service_startDir =/s?=.*?= '${startDir}'?" > ${name}.py

cxfreeze ${name}.py --include-modules=win32timezone

Installation — copy the ‘.exe’ the server and the script to the specified folder. Run the ‘.exe’, as Administrator, with the ‘install’ option. Open Windows Services, as Adminstrator, and start you service. For upgrade, just copy the new version of the script and Stop/Start the service.

Now every server is different — different installations of Python, different folder structures. I maintain a folder for every server, with a copy of pyGlue.py and build.sh. And I create a ‘serverBuild.sh’ script for rebuilding all the service on that server.

# A script to build all the script based Services on this PC
sh build.sh AutoCode 'AutoCode Medical Documents' 'Autocode Medical Documents to SNOMED_CT and AIHW codes' C:/Python38/python.exe autocode.py C:/Users/russell/Documents/autocoding -S -T

Headless processes (with no UI) in Windows are called Services. They can be controlled (started, stopped, etc) using standard Windows controls such as the command console, Powershell or the Services tab in Task Manager. A good example might be an application that provides network services, such as a web application, or maybe a backup application that performs various background archival tasks. There are several ways to create and install a Python application as a Service in Windows.

# A Python script that can be run as a service

The modules used in this example are part of pywin32 (opens new window) (Python for Windows extensions). Depending on how you installed Python, you might need to install this separately.

This is just boilerplate. Your application code, probably invoking a separate script, would go in the main() function.

You will also need to install this as a service. The best solution for this at the moment appears to be to use Non-sucking Service Manager (opens new window). This allows you to install a service and provides a GUI for configuring the command line the service executes. For Python you can do this, which creates the service in one go:

Where my_script.py is the boilerplate script above, modified to invoke your application script or code in the main() function. Note that the service doesn’t run the Python script directly, it runs the Python interpreter and passes it the main script on the command line.

Alternatively you can use tools provided in the Windows Server Resource Kit for your operating system version so create the service.

# Running a Flask web application as a service

This is a variation on the generic example. You just need to import your app script and invoke it’s run() method in the service’s main() function. In this case we’re also using the multiprocessing module due to an issue accessing WSGIRequestHandler.

Adapted from http://stackoverflow.com/a/25130524/318488 (opens new window)

Hi guys, today’s post is just for the ones of you that work with the “OS of the misoriented slashes”: Microsoft Windows.

Have you ever had the need of writing a Python script that could run in background as a Windows Service? In this post, you will learn how to do it in less than 10 minutes, no jokes.

I will skip all the introduction about Windows Services, how convenient they could be, how much could be appreciated the fact that they can be run in background even when the user is logged off etc… I mean, if you can code in Python and you use Windows I bet you already know what a Windows Service is, don’t you?

So, first of all, let’s start by installing the Python for Windows extensions:

c:test> pip install pywin32

Once you have done it, let’s write this base class, your Windows service will be a subclass of this base class.

 1'''
 2SMWinservice
 3by Davide Mastromatteo
 4
 5Base class to create winservice in Python
 6-----------------------------------------
 7
 8Instructions:
 9
101. Just create a new class that inherits from this base class
112. Define into the new class the variables
12   _svc_name_ = "nameOfWinservice"
13   _svc_display_name_ = "name of the Winservice that will be displayed in scm"
14   _svc_description_ = "description of the Winservice that will be displayed in scm"
153. Override the three main methods:
16    def start(self) : if you need to do something at the service initialization.
17                      A good idea is to put here the inizialization of the running condition
18    def stop(self)  : if you need to do something just before the service is stopped.
19                      A good idea is to put here the invalidation of the running condition
20    def main(self)  : your actual run loop. Just create a loop based on your running condition
214. Define the entry point of your module calling the method "parse_command_line" of the new class
225. Enjoy
23'''
24
25import socket
26
27import win32serviceutil
28
29import servicemanager
30import win32event
31import win32service
32
33
34class SMWinservice(win32serviceutil.ServiceFramework):
35    '''Base class to create winservice in Python'''
36
37    _svc_name_ = 'pythonService'
38    _svc_display_name_ = 'Python Service'
39    _svc_description_ = 'Python Service Description'
40
41    @classmethod
42    def parse_command_line(cls):
43        '''
44        ClassMethod to parse the command line
45        '''
46        win32serviceutil.HandleCommandLine(cls)
47
48    def __init__(self, args):
49        '''
50        Constructor of the winservice
51        '''
52        win32serviceutil.ServiceFramework.__init__(self, args)
53        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
54        socket.setdefaulttimeout(60)
55
56    def SvcStop(self):
57        '''
58        Called when the service is asked to stop
59        '''
60        self.stop()
61        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
62        win32event.SetEvent(self.hWaitStop)
63
64    def SvcDoRun(self):
65        '''
66        Called when the service is asked to start
67        '''
68        self.start()
69        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,
70                              servicemanager.PYS_SERVICE_STARTED,
71                              (self._svc_name_, ''))
72        self.main()
73
74    def start(self):
75        '''
76        Override to add logic before the start
77        eg. running condition
78        '''
79        pass
80
81    def stop(self):
82        '''
83        Override to add logic before the stop
84        eg. invalidating running condition
85        '''
86        pass
87
88    def main(self):
89        '''
90        Main class to be ovverridden to add logic
91        '''
92        pass
93
94# entry point of the module: copy and paste into the new module
95# ensuring you are calling the "parse_command_line" of the new created class
96if __name__ == '__main__':
97    SMWinservice.parse_command_line()

Let’s examine the class we have just introduced a little.

def SvcDoRun(self): it’s the method that will be called when the service is requested to start.

def SvcStop(self): it’s the method that will be called when the service is requested to stop.

def start(self): it’s a method that you will be asked to override if you need to do something when the service is starting (before started)

def stop(self): it’s the method that you will be asked to override if you need to do something when the service is stopping (before stopped)

def main(self): it’s the method that will contain the logic of your script, usually in a loop that keeps it alive until the service is stopped.

def parse_command_line(cls): it’s the method that handles the command line interface that you can use to install and update your windows service

Can you see how easy it is with pywin32 to interface with the system to create a Windows Service? The last mention is for the following variables:

1svc_name = "PythonCornerExample"
2svc_display_name = "Python Corner's Winservice Example"
3svc_description = "That's a great winservice! :)"

These are just three variables that contain the name of the service, the “friendly name” that will be used by Windows to display the name on the mmc console and a short description of your service.

As always, enough talk, let’s code something useful!

Let’s pretend that we want to create a Winservice that, when started, creates a random file on our C: drive every 5 seconds.

What? Do you think it is stupid?
Well, install it on your boss PC, set the destination folder as its user’s desktop and you will change your mind.

However, how can you achieve this result? Super easy.

• Subclass the SMWinservice class we have just met.
• On the new class, override the three variables svc_name, svc_display_name and svc_description.
• Override the “start” method to set the running condition. Setting a boolean variable will be enough for that.
• Override the “stop” method to invalidate the running condition when the service is requested to be stopped.
• Override the “main” method to add the logic of creating a random file every 5 seconds
• Add the call at the “parse_command_line” function to handle the command line interface.

The result should be something like this:

 1import time
 2import random
 3from pathlib import Path
 4from SMWinservice import SMWinservice
 5
 6class PythonCornerExample(SMWinservice):
 7    _svc_name_ = "PythonCornerExample"
 8    _svc_display_name_ = "Python Corner's Winservice Example"
 9    _svc_description_ = "That's a great winservice! :)"
10
11    def start(self):
12        self.isrunning = True
13
14    def stop(self):
15        self.isrunning = False
16
17    def main(self):
18        i = 0
19        while self.isrunning:
20            random.seed()
21            x = random.randint(1, 1000000)
22            Path(f'c:{x}.txt').touch()
23            time.sleep(5)
24
25if __name__ == '__main__':
26    PythonCornerExample.parse_command_line()

That’s it! Now it’s time to install our newly created winservice. Just open a command prompt, navigate to your script directory and install the service with the command:

C:test> python PythonCornerExample.py install
Installing service PythonCornerExample
Service installed

In the future, if you want to change the code of your service, just modify it and reinstall the service with

C:test> python PythonCornerExample.py update
Changing service configuration
Service updated

Now, open the “Services” msc snap in

C:test> mmc Services.msc

locate your new PythonCornerExample winservice, and right click and choose properties. Here you can start your service and configure it at your will.

Now try to start your service and go to see your C: folder contents.

Can you see all these files being created to your C: folder? Yeah, that’s working!

But now it’s time to stop it!  You can do it from the previous windows or just by using the command line

C:test> net stop PythonCornerExample

Il servizio Python Corner's Winservice Example sta per essere arrestato.. 
Servizio Python Corner's Winservice Example arrestato.

If something goes wrong…

There are a couple of known problems that can happen writing Windows Services in Python. If you have successfully installed the service but starting it you get an error, follow this iter to troubleshoot your service:

• Check if Python is in your PATH variable. It MUST be there. To check this, just open a command prompt and try starting the python interpreter by typing “python”. If it starts, you are ok.
• Be sure to have the file C:Program FilesPython36Libsite-packageswin32pywintypes36.dll (please note that “36” is the version of your Python installation). If you don’t have this file, take it from C:Program FilesPython36Libsite-packagespywin32_system32pywintypes36.dll and copy it into C:Program FilesPython36Libsite-packageswin32

If you still have problems, try executing your Python script in debug mode. To try this with our previous example, open a terminal, navigate to the directory where the script resides and type

c:test> python PythonCornerExample.py debug

Ok, that’s all for today, this was just a brief introduction to developing Windows Services with Python. Try it by yourself and … happy coding!

D.

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%Documentsqr-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%Documentsqr-code-app-env"

After the command completes, you will find the Python 3 virtual environment within the %systemdrive%%homepath%Documentsqr-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%Documentsqr-code-app-envScriptsactivate.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%Documentsqr-code-apprequirements.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%Documentsqr-code-app folder with the following content:

call ..qr-code-app-envScriptsactivate.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.24win64 folder.

Run a command prompt instance as administrator

In order to avoid being prompted for administrator access for subsequent calls to C:nssm-2.24win64, 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.24win64, we can then use the following command to install our Python application as a Windows Service:

C:nssm-2.24win64nssm install qrcodeapp "%systemdrive%%homepath%Documentsqr-code-apprun_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.24win64nssm edit qrcodeapp

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

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

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.24win64nssm 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.