Dieser Artikel ist der 14. Tag von Docker Adventskalender 2015.
Summary
Diese Geschichte stammt aus der PyCon JP 2015 Talk Session "[Baseball Hack! ~ Datenanalyse und -visualisierung mit Python](http://www.slideshare.net/shinyorke/hackpython-pyconjp" Baseball Hack! ~ Daten mit Python Dies ist ein Auszug und eine detaillierte Erklärungsversion der Geschichte "Ich habe einen Stapel erstellt, um Baseballdaten mit Docker und Parse-Crontab zu erfassen!", Die in der zweiten Hälfte von "Analyse und Visualisierung" gezeigt wurde.
Grundsätzlich gibt es viele Teile, die ich für meine Bequemlichkeit und Gedanken schreibe, also warte ich auf Ihre Meinung Tsukkomi Vorschlag m (_ _) m
Auch bei der Herstellung dieses Materials,
** Implementieren der geplanten Ausführungsverarbeitung in Python (GAUJIN.JP/Gojin) **
Ich habe auf den obigen Eintrag verwiesen.
[Ankündigung des XP Festivals 2015] vor PyCon JP 2015 ,,, [http://www.slideshare.net/shinyorke/agile-baseball-science-52692504 "Agile Baseball-Wissenschaft - Agile Baseball-Wissenschaft, die gut für das Gehirn funktioniert Hanashi ") brauchte Baseballdaten und begann mit der Entwicklung.
Ich habe gerade eine Ankündigung für PyCon JP 2015 gemacht und auf Twitter gebeten, sie erneut zu drucken. → Vielen Dank für Ihre freundliche Zustimmung.
Der Baseball-Code ist etwas kompliziert (und ich möchte nicht zu viel erklären), deshalb habe ich ein Beispiel gemacht.
python-crontab-docker-example(GitHub)
Die empfohlene Umgebung ist Python 3.4.x oder höher.
Übrigens funktioniert es momentan mit der neuesten Version Python 3.5.1 (14.12.2015) einwandfrei!
Definieren Sie einen JobController, der Batch ausführt, und JobSettings, die die nächste Ausführungszeit und das nächste Ausführungsintervall bis zur Ausführung verwalten.
Das Argument von JobController.run () ist die bekannte Crontab-Einstellung (* * * * *).
scheduler/job.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
import functools
import logging
from crontab import CronTab
from datetime import datetime, timedelta
import math
__author__ = 'Shinichi Nakagawa'
class JobController(object):
"""
Jobausführungscontroller
"""
@classmethod
def run(cls, crontab):
"""
Ausführung verarbeiten
:param crontab: job schedule
"""
def receive_func(job):
@functools.wraps(job)
def wrapper():
job_settings = JobSettings(CronTab(crontab))
logging.info("->- Process Start")
while True:
try:
logging.info(
"-?- next running\tschedule:%s" %
job_settings.schedule().strftime("%Y-%m-%d %H:%M:%S")
)
time.sleep(job_settings.interval())
logging.info("->- Job Start")
job()
logging.info("-<- Job Done")
except KeyboardInterrupt:
break
logging.info("-<- Process Done.")
return wrapper
return receive_func
class JobSettings(object):
"""
Ausgabeeinstellungen
"""
def __init__(self, crontab):
"""
:param crontab: crontab.CronTab
"""
self._crontab = crontab
def schedule(self):
"""
Nächster Lauf
:return: datetime
"""
crontab = self._crontab
return datetime.now() + timedelta(seconds=math.ceil(crontab.next()))
def interval(self):
"""
Zeit bis zur nächsten Ausführung
:return: seconds
"""
crontab = self._crontab
return math.ceil(crontab.next())
Importieren Sie JobController, bündeln Sie den auszuführenden Prozess und führen Sie ihn parallel aus.
Die Probe wird jeden Freitagabend im Tamori Club und jeden Tag um 18:00 Uhr gemacht, um Baseball zu unterrichten.
Als Punkt zu beachten
Das ist alles.
batch.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import logging
from multiprocessing import Pool
from scheduler.job import JobController
__author__ = 'Shinichi Nakagawa'
#Beachten Sie, dass die Zeitzone von Docker Image UTC ist!
@JobController.run("20 15 * * 5")
def notice_tmr_club():
"""
Es ist Zeit für den Tamori Club(Tokio)
:return: None
"""
logging.info("Der Tamori Club startet! !! !!")
#Beachten Sie, dass die Zeitzone von Docker Image UTC ist!(Ich habe es zweimal gesagt, weil es wichtig ist)
@JobController.run("00 9 * * *")
def notice_baseball():
"""
Lehre die Zeit von Yakiu
:return: None
"""
logging.info("Es ist Zeit zu gehen! !! !! !!")
def main():
"""
Methode zum Ausführen von crontab
:return: None
"""
#Protokolleinstellungen(Info-Level, Format, Zeitstempel)
logging.basicConfig(
level=logging.INFO,
format="time:%(asctime)s.%(msecs)03d\tprocess:%(process)d" + "\tmessage:%(message)s",
datefmt="%Y-%m-%d %H:%M:%S"
)
#Registrieren Sie den Job, den Sie mit crontab ausführen möchten
jobs = [notice_tmr_club, notice_baseball]
# multi process running
p = Pool(len(jobs))
try:
for job in jobs:
p.apply_async(job)
p.close()
p.join()
except KeyboardInterrupt:
logging.info("exit")
if __name__ == '__main__':
main()
Dockerfile
Das ist einfach.
Fügen Sie den GitHub-Code ein, starten und beenden Sie ihn.
Dockerfile
# Python crontab sample
FROM python:3.5.1
MAINTAINER Shinichi Nakagawa <[email protected]>
# add to application
RUN mkdir /app
WORKDIR /app
ADD requirements.txt /app/
RUN pip install -r requirements.txt
ADD ./scheduler /app/scheduler/
ADD *.py /app/
docker-compose
Schreiben Sie die Docker-Starteinstellungen in docker-compose.yml.
Verschieben Sie jedoch batch.py und beenden Sie den Vorgang.
docker-compose.yml
batch:
build: .
dockerfile: ./Dockerfile
command: python batch.py
container_name: python_crontab_example
Wenn Sie Docker-Compose erstellen (oder Docker ausführen) und sich so bewegen, ist dies in Ordnung.
$ docker-compose up
Creating python_crontab_example
Attaching to python_crontab_example
python_crontab_example | time:2015-12-13 13:45:09.463 process:9 message:->- Process Start
python_crontab_example | time:2015-12-13 13:45:09.464 process:8 message:->- Process Start
python_crontab_example | time:2015-12-13 13:45:09.465 process:9 message:-?- next running schedule:2015-12-18 15:20:00
python_crontab_example | time:2015-12-13 13:45:09.465 process:8 message:-?- next running schedule:2015-12-14 09:00:00
Vielen Dank, dass Sie @tamai.
Recommended Posts