Cet article est le 14ème jour du Docker Advent Calendar 2015.
Summary
Cette histoire est tirée de la session de discussion PyCon JP 2015 "[Baseball Hack! ~ Analyse et visualisation de données avec Python](http://www.slideshare.net/shinyorke/hackpython-pyconjp" Baseball Hack! ~ Données utilisant Python Ceci est un extrait et une version explicative détaillée de l'histoire "J'ai fait un lot pour acquérir des données de baseball avec Docker et parse-crontab!" Cela a été montré dans la seconde moitié de "Analysis and Visualization") ".
Fondamentalement, il y a beaucoup de parties que j'écris pour ma commodité et mes pensées, alors j'attends votre avis Proposition Tsukkomi m (_ _) m
Aussi, en fabriquant ce matériau,
** Implémentation du traitement d'exécution programmée en Python (GAUJIN.JP/Gojin) **
J'ai fait référence à l'entrée ci-dessus.
[Annonce du XP Festival 2015] avant PyCon JP 2015 ,,, [http://www.slideshare.net/shinyorke/agile-baseball-science-52692504 "Science du baseball agile - Science du baseball agile qui fonctionne bien pour le cerveau Hanashi ") avait besoin de données sur le baseball et a commencé le développement.
Je venais de faire une annonce pour PyCon JP 2015, alors j'ai demandé sur Twitter de "le réimprimer!" → Merci pour votre aimable consentement.
Le code du baseball est un peu compliqué (et je ne veux pas trop en expliquer), alors j'ai fait un échantillon.
python-crontab-docker-example(GitHub)
L'environnement recommandé est Python 3.4.x ou supérieur.
Au fait, cela fonctionne bien avec la dernière version Python 3.5.1 pour le moment (2015/12/14)!
Définissez un JobController qui exécute le lot et les JobSettings qui gèrent la prochaine heure d'exécution et l'intervalle jusqu'à l'exécution.
L'argument de JobController.run () est le paramètre crontab familier (* * * * *).
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):
"""
Contrôleur d'exécution des travaux
"""
@classmethod
def run(cls, crontab):
"""
Exécution du traitement
: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):
"""
Paramètres de sortie
"""
def __init__(self, crontab):
"""
:param crontab: crontab.CronTab
"""
self._crontab = crontab
def schedule(self):
"""
Prochaine exécution
:return: datetime
"""
crontab = self._crontab
return datetime.now() + timedelta(seconds=math.ceil(crontab.next()))
def interval(self):
"""
Heure de la prochaine exécution
:return: seconds
"""
crontab = self._crontab
return math.ceil(crontab.next())
Importez JobController, regroupez le processus à exécuter et exécutez-le en parallèle.
L'échantillon est réalisé tous les vendredis soirs au Tamori Club et tous les jours à 18h00 comme l'enseignement du baseball.
Comme un point à noter
C'est à peu près ça.
batch.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import logging
from multiprocessing import Pool
from scheduler.job import JobController
__author__ = 'Shinichi Nakagawa'
#Notez que le fuseau horaire de Docker Image est UTC!
@JobController.run("20 15 * * 5")
def notice_tmr_club():
"""
Il est temps pour Tamori Club(Tokyo)
:return: None
"""
logging.info("Le Tamori Club va commencer! !! !!")
#Notez que le fuseau horaire de Docker Image est UTC!(Je l'ai dit deux fois parce que c'est important)
@JobController.run("00 9 * * *")
def notice_baseball():
"""
Enseigner le temps de Yakiu
:return: None
"""
logging.info("Il est temps de partir! !! !! !!")
def main():
"""
méthode pour exécuter crontab
:return: None
"""
#Paramètres du journal(Niveau d'information, format, horodatage)
logging.basicConfig(
level=logging.INFO,
format="time:%(asctime)s.%(msecs)03d\tprocess:%(process)d" + "\tmessage:%(message)s",
datefmt="%Y-%m-%d %H:%M:%S"
)
#Enregistrez la tâche que vous souhaitez exécuter avec crontab
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
C'est simple.
Incluez le code GitHub, lancez et quittez.
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
Écrivez les paramètres de démarrage du docker dans docker-compose.yml.
Cependant, déplacez batch.py et terminez.
docker-compose.yml
batch:
build: .
dockerfile: ./Dockerfile
command: python batch.py
container_name: python_crontab_example
Si vous composez un docker (ou exécutez un docker) et que vous vous déplacez comme ça, c'est OK.
$ 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
Merci @tamai.
Recommended Posts