Szkicuję architekturę dla zestawu programów, które współużytkują różne powiązane ze sobą obiekty przechowywane w bazie danych. Chcę, aby jeden z programów działał jako usługa, która zapewnia interfejs wyższego poziomu dla operacji na tych obiektach, a pozostałe programy miały dostęp do obiektów za pośrednictwem tej usługi.

Obecnie dążę do stworzenia Pythona i frameworka Django jako technologii do wdrożenia tej usługi. Jestem prawie pewien, że wymyślę sposób demonizacji programu Python w systemie Linux. Jest to jednak opcjonalny element specyfikacji, który system powinien obsługiwać system Windows. Mam niewielkie doświadczenie w programowaniu systemu Windows i wcale nie mam doświadczenia z usługami systemu Windows.

Czy można uruchomić programy w języku Python jako usługę systemu Windows (tj. Uruchomić je automatycznie bez logowania użytkownika)? Niekoniecznie będę musiał zaimplementować tę część, ale potrzebuję wstępnego pomysłu, jak to zrobić, aby zdecydować, czy projektować według tych zasad.

Edycja: Dzięki za wszystkie dotychczasowe odpowiedzi, są one dość wyczerpujące. Chciałbym wiedzieć jeszcze jedno: w jaki sposób system Windows jest świadomy mojej usługi? Czy mogę zarządzać za pomocą rodzimych narzędzi systemu Windows? Co jest równoważne z umieszczeniem skryptu start / stop w /etc/init.d?

Tak, możesz. Robię to za pomocą bibliotek pythoncom, które są dołączone do ActivePython lub mogą być instalowane z pywin32 (rozszerzenia Python dla Windows).

To jest podstawowy szkielet prostej usługi:

import win32serviceutil
import win32service
import win32event
import servicemanager
import socket


class AppServerSvc (win32serviceutil.ServiceFramework):
    _svc_name_ = "TestService"
    _svc_display_name_ = "Test Service"

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

    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.hWaitStop)

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

    def main(self):
        pass

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

Twój kod przejdzie do main()metody - zwykle z jakąś nieskończoną pętlą, która może zostać przerwana przez sprawdzenie flagi ustawionej w SvcStopmetodzie

Chociaż kilka tygodni temu głosowałem za wybraną odpowiedzią, tymczasem miałem więcej problemów z tym tematem. To tak, jakby mieć specjalną instalację Pythona i używanie specjalnych modułów do uruchamiania skryptu, ponieważ usługa jest po prostu niewłaściwym sposobem. Co z przenośnością i tym podobne?

Natknąłem się na wspaniałego Menedżera usług bez ssania , który sprawił, że obsługa Usług Windows była naprawdę prosta i rozsądna. Pomyślałem, że ponieważ mogę przekazać opcje do zainstalowanej usługi, równie dobrze mogę wybrać plik wykonywalny Python i przekazać skrypt jako opcję.

Jeszcze nie wypróbowałem tego rozwiązania, ale zrobię to teraz i zaktualizuję ten post w trakcie tego procesu. Interesuje mnie również korzystanie z virtualenvs w systemie Windows, więc prędzej czy później mogę wymyślić samouczek i link do niego tutaj.

Najprostszym sposobem jest użycie: NSSM - Menedżer usług niessących:

1 - wykonaj pobieranie na https://nssm.cc/download

2 - zainstaluj program python jako usługę: monit Win jako administrator

c:> nssm.exe zainstaluj WinService

3 - W konsoli NSSM:

ścieżka: C: \ Python27 \ Python27.exe

Katalog startowy: C: \ Python27

Argumenty: c: \ WinService.py

4 - sprawdź utworzone usługi w services.msc

Najprostszym sposobem na osiągnięcie tego jest użycie natywnego polecenia sc.exe:

sc create PythonApp binPath= "C:\Python34\Python.exe --C:\tmp\pythonscript.py"

Bibliografia:

1. https://technet.microsoft.com/en-us/library/cc990289(v=ws.11).aspx
2. Podczas tworzenia usługi za pomocą sc.exe, jak przekazać parametry kontekstowe?

Istnieje kilka alternatyw dla instalacji jako usługi praktycznie dowolnego pliku wykonywalnego Windows.

Metoda 1: Użyj instsrv i srvany z rktools.exe

W przypadku systemu Windows Home Server lub Windows Server 2003 (współpracuje również z WinXP), Zestaw narzędzi Windows Server 2003 Resource Kit Tools zawiera narzędzia, które mogą być używane w tym celu w tandemie, o nazwie instsrv.exe i srvany.exe . Zobacz artykuł KB137890 KB firmy Microsoft, aby uzyskać szczegółowe informacje na temat korzystania z tych narzędzi.

W przypadku systemu Windows Home Server istnieje świetne, przyjazne dla użytkownika opakowanie dla tych narzędzi o nazwie „ Any Service Installer ”.

Metoda 2: Użyj ServiceInstaller dla Windows NT

Istnieje inna alternatywa przy użyciu ServiceInstaller dla Windows NT (do pobrania tutaj ) z dostępnymi instrukcjami python . W przeciwieństwie do nazwy, działa zarówno z Windows 2000, jak i Windows XP. Oto kilka instrukcji, jak zainstalować skrypt Pythona jako usługę.

Instalowanie skryptu Python

Uruchom ServiceInstaller, aby utworzyć nową usługę. (W tym przykładzie zakłada się, że Python jest zainstalowany w katalogu c: \ python25)

Service Name  : PythonTest
Display Name : PythonTest 
Startup : Manual (or whatever you like)
Dependencies : (Leave blank or fill to fit your needs)
Executable : c:\python25\python.exe
Arguments : c:\path_to_your_python_script\test.py
Working Directory : c:\path_to_your_python_script

Po instalacji otwórz aplet Usługi Panelu sterowania, wybierz i uruchom usługę PythonTest.

Po mojej pierwszej odpowiedzi zauważyłem, że na SO zostały już ściśle powiązane pytania i odpowiedzi. Zobacz też:

Czy mogę uruchomić skrypt Pythona jako usługę (w systemie Windows)? W jaki sposób?

Jak uświadomić systemowi Windows usługę napisaną w języku Python?

Wyjaśnienie krok po kroku, jak to działa:

1- Najpierw utwórz plik python zgodnie z podstawowym szkieletem wspomnianym powyżej. I zapisz go na ścieżce, na przykład: „c: \ PythonFiles \ AppServerSvc.py”

import win32serviceutil
import win32service
import win32event
import servicemanager
import socket


class AppServerSvc (win32serviceutil.ServiceFramework):
    _svc_name_ = "TestService"
    _svc_display_name_ = "Test Service"


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

    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.hWaitStop)

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

    def main(self):
        # Your business logic or call to any class should be here
        # this time it creates a text.txt and writes Test Service in a daily manner 
        f = open('C:\\test.txt', 'a')
        rc = None
        while rc != win32event.WAIT_OBJECT_0:
            f.write('Test Service  \n')
            f.flush()
            # block for 24*60*60 seconds and wait for a stop event
            # it is used for a one-day loop
            rc = win32event.WaitForSingleObject(self.hWaitStop, 24 * 60 * 60 * 1000)
        f.write('shut down \n')
        f.close()

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

2 - Na tym etapie powinniśmy zarejestrować naszą usługę.

Uruchom wiersz polecenia jako administrator i wpisz:

sc create TestService binpath = "C: \ Python36 \ Python.exe c: \ PythonFiles \ AppServerSvc.py" DisplayName = "TestService" start = auto

pierwszym argumentem binpath jest ścieżka do python.exe

drugim argumentem binpath jest ścieżka do pliku Pythona, który już utworzyliśmy

Nie przegap, że po każdym znaku „ = ” należy umieścić jedną spację .

Jeśli wszystko jest w porządku, powinieneś zobaczyć

[SC] CreateService SUCCESS

Teraz Twoja usługa python jest teraz instalowana jako usługa Windows. Możesz to zobaczyć w Service Managerze i rejestrze pod:

HKEY_LOCAL_MACHINE \ SYSTEM \ CurrentControlSet \ Services \ TestService

3- OK. Możesz uruchomić usługę w menedżerze usług.

Możesz wykonać każdy plik Pythona, który udostępnia szkielet usługi.

pysc: Service Control Manager w Pythonie

Przykładowy skrypt do uruchomienia jako usługa pobrana z pythonhosted.org :

from xmlrpc.server import SimpleXMLRPCServer

from pysc import event_stop


class TestServer:

    def echo(self, msg):
        return msg


if __name__ == '__main__':
    server = SimpleXMLRPCServer(('127.0.0.1', 9001))

    @event_stop
    def stop():
        server.server_close()

    server.register_instance(TestServer())
    server.serve_forever()

Utwórz i uruchom usługę

import os
import sys
from xmlrpc.client import ServerProxy

import pysc


if __name__ == '__main__':
    service_name = 'test_xmlrpc_server'
    script_path = os.path.join(
        os.path.dirname(__file__), 'xmlrpc_server.py'
    )
    pysc.create(
        service_name=service_name,
        cmd=[sys.executable, script_path]
    )
    pysc.start(service_name)

    client = ServerProxy('http://127.0.0.1:9001')
    print(client.echo('test scm'))

Zatrzymaj i usuń usługę

import pysc

service_name = 'test_xmlrpc_server'

pysc.stop(service_name)
pysc.delete(service_name)

pip install pysc

Zacząłem hosting jako usługa z pywin32 .

Wszystko było dobrze, ale napotkałem problem polegający na tym, że usługa nie była w stanie uruchomić się w ciągu 30 sekund (domyślny limit czasu dla systemu Windows) po uruchomieniu systemu. Było to dla mnie bardzo ważne, ponieważ uruchomienie systemu Windows odbyło się jednocześnie na kilku maszynach wirtualnych hostowanych na jednej maszynie fizycznej, a obciążenie IO było ogromne. Komunikaty o błędach to:

Error 1053: The service did not respond to the start or control request in a timely fashion.

Error 7009: Timeout (30000 milliseconds) waiting for the <ServiceName> service to connect.

Dużo walczyłem z pywin, ale ostatecznie wykorzystałem NSSM, jak zaproponowano w tej odpowiedzi . Migracja do niego była bardzo łatwa.

nssm w python 3+

(Mój plik .py przekonwertowałem na .exe za pomocą programu pyinstaller )

nssm: jak powiedziano wcześniej

• uruchom nssm install {nazwa usługi}

• Na konsoli NSSM:

  ścieżka: ścieżka \ do \ twojego \ programu.exe

  Katalog startowy: ścieżka \ do \ twoja \ # nazwa jako ścieżka, ale bez programu.exe

  Argumenty: puste

Jeśli nie chcesz konwertować projektu do .exe

• utwórz plik .bat za pomocą python {{your python.py file name}}
• i ustaw ścieżkę do pliku .bat

Kompletny przykład pywin32 wykorzystujący pętlę lub wątek

Po kilku dniach pracy nad tym i wyłączaniu, oto odpowiedź, którą chciałbym znaleźć, używając pywin32, aby zachować ładność i spokój.

Jest to kompletny działający kod dla jednego rozwiązania opartego na pętli i jednego wątku. Może działać zarówno na Pythonie 2, jak i 3, chociaż najnowszą wersję testowałem tylko na wersjach 2.7 i Win7. Pętla powinna być odpowiednia do odpytywania kodu, a bieżnik powinien współpracować z kodem podobnym do serwerowego. Wygląda na to, że dobrze współpracuje z serwerem wsgi kelnerki , która nie ma standardowego sposobu na płynne zamknięcie.

Chciałbym również zauważyć, że wydaje się, że istnieje mnóstwo przykładów, takich jak te, które są prawie przydatne, ale w rzeczywistości wprowadzają w błąd, ponieważ ślepo wycięły i wkleiły inne przykłady. Mogę się mylić. ale po co tworzyć wydarzenie, jeśli nigdy na nie nie czekasz?

To powiedziawszy, nadal czuję, że jestem tutaj na nieco chwiejnym gruncie, szczególnie jeśli chodzi o to, jak czyste jest wyjście z wersji wątku, ale przynajmniej uważam, że nie ma tu niczego mylącego .

Aby uruchomić, po prostu skopiuj kod do pliku i postępuj zgodnie z instrukcjami.

aktualizacja:

Użyj prostej flagi, aby zakończyć wątek. Ważne jest to, że drukuje się „wątek zrobiony”.
Bardziej rozbudowany przykład wychodzenia z niechętnego wątku serwera znajduje się w moim poście o serwerze wsgi kelnerki .

# uncomment mainthread() or mainloop() call below
# run without parameters to see HandleCommandLine options
# install service with "install" and remove with "remove"
# run with "debug" to see print statements
# with "start" and "stop" watch for files to appear
# check Windows EventViever for log messages

import socket
import sys
import threading
import time
from random import randint
from os import path

import servicemanager
import win32event
import win32service
import win32serviceutil
# see http://timgolden.me.uk/pywin32-docs/contents.html for details


def dummytask_once(msg='once'):
    fn = path.join(path.dirname(__file__),
                '%s_%s.txt' % (msg, randint(1, 10000)))
    with open(fn, 'w') as fh:
        print(fn)
        fh.write('')


def dummytask_loop():
    global do_run
    while do_run:
        dummytask_once(msg='loop')
        time.sleep(3)


class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        global do_run
        do_run = True
        print('thread start\n')
        dummytask_loop()
        print('thread done\n')

    def exit(self):
        global do_run
        do_run = False


class SMWinservice(win32serviceutil.ServiceFramework):
    _svc_name_ = 'PyWinSvc'
    _svc_display_name_ = 'Python Windows Service'
    _svc_description_ = 'An example of a windows service in Python'

    @classmethod
    def parse_command_line(cls):
        win32serviceutil.HandleCommandLine(cls)

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.stopEvt = win32event.CreateEvent(None, 0, 0, None)  # create generic event
        socket.setdefaulttimeout(60)

    def SvcStop(self):
        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,
                            servicemanager.PYS_SERVICE_STOPPED,
                            (self._svc_name_, ''))
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.stopEvt)  # raise event

    def SvcDoRun(self):
        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,
                            servicemanager.PYS_SERVICE_STARTED,
                            (self._svc_name_, ''))
        # UNCOMMENT ONE OF THESE
        # self.mainthread()
        # self.mainloop()

    # Wait for stopEvt indefinitely after starting thread.
    def mainthread(self):
        print('main start')
        self.server = MyThread()
        self.server.start()
        print('wait for win32event')
        win32event.WaitForSingleObject(self.stopEvt, win32event.INFINITE)
        self.server.exit()
        print('wait for thread')
        self.server.join()
        print('main done')

    # Wait for stopEvt event in loop.
    def mainloop(self):
        print('loop start')
        rc = None
        while rc != win32event.WAIT_OBJECT_0:
            dummytask_once()
            rc = win32event.WaitForSingleObject(self.stopEvt, 3000)
        print('loop done')


if __name__ == '__main__':
    SMWinservice.parse_command_line()

Akceptowana odpowiedź przy użyciu win32serviceutildziała, ale jest skomplikowana i utrudnia debugowanie i zmiany. O wiele łatwiej jest korzystać z NSSM ( Menedżera usług niessących ) . Piszemy i wygodnie debugujemy normalny program w języku Python, a gdy w końcu zadziała, za pomocą NSSM zainstalujesz go jako usługę w mniej niż minutę:

Z wiersza polecenia z podwyższonym poziomem uprawnień (administratora) uruchamiasz nssm.exe install NameOfYourServicei wypełniasz następujące opcje:

• ścieżka : (np. ścieżka do python.exe C:\Python27\Python.exe)
• Argumenty : (ścieżka do skryptu Pythona, np. c:\path\to\program.py)

Nawiasem mówiąc, jeśli twój program drukuje przydatne wiadomości, które chcesz przechowywać w pliku dziennika, NSSM może również obsłużyć to i wiele więcej.

Dla każdego, kto chce stworzyć usługę w VENV lub Pycharm !!!!!!!

Po przeczytaniu wszystkich anwsers i utwórz kilka skryptów, jeśli możesz uruchomić python service.py installi python service.py debug, alepython service.py start nie ma odpowiedzi.

Być może jest to spowodowane problemem Venv, ponieważ usługa Windows uruchamia usługę przez exec PROJECT\venv\Lib\site-packages\win32\pythonservice.exe.

Możesz użyć powershelllub cmdprzetestować swoją usługę, aby znaleźć więcej szczegółów błędu.

PS C:\Users\oraant> E:

PS E:\> cd \Software\PythonService\venv\Lib\site-packages\win32

PS E:\Software\PythonService\venv\Lib\site-packages\win32> .\pythonservice.exe -debug ttttt
Debugging service ttttt - press Ctrl+C to stop.
Error 0xC0000004 - Python could not import the service's module

Traceback (most recent call last):
  File "E:\Software\PythonService\my_service.py", line 2, in <module>
    import win32serviceutil
ModuleNotFoundError: No module named 'win32serviceutil'

(null): (null)

Jeśli pojawi się jakiś błąd, taki jak ja, możesz sprawdzić moją odpowiedź w innym pytaniu, naprawiłem go i opublikowałem tutaj swój kod .

https://www.chrisumbel.com/article/windows_services_in_python

1. Kontynuuj PySvc.py

2. zmiana folderu dll

Wiem, że to stare, ale utknąłem w tym na zawsze. Dla mnie ten konkretny problem został rozwiązany przez skopiowanie tego pliku - pywintypes36.dll

Od -> Python36 \ Lib \ site-packages \ pywin32_system32

Do -> Python36 \ Lib \ site-packages \ win32

setx /M PATH "%PATH%;C:\Users\user\AppData\Local\Programs\Python\Python38-32;C:\Users\user\AppData\Local\Programs\Python\Python38-32\Scripts;C:\Users\user\AppData\Local\Programs\Python\Python38-32\Lib\site-packages\pywin32_system32;C:\Users\user\AppData\Local\Programs\Python\Python38-32\Lib\site-packages\win32

3. zmieniając ścieżkę do folderu python przez

cd C:\Users\user\AppData\Local\Programs\Python\Python38-32

4. NET START PySvc
5. NET STOP PySvc