L'exécution de cron python emplois au sein de docker

Plusieurs problèmes que j'ai rencontrés tout en essayant d'obtenir une tâche cron s'exécute dans un conteneur docker ont été:

1. temps dans le conteneur docker est en UTC pas de temps local;
2. le docker de l'environnement n'est pas passé à cron;
3. comme Thomas l'a noté, cron journalisation laisse beaucoup à désirer, et y accéder via le panneau nécessite un panneau à base de solution.

Il y a cron-questions spécifiques et sont docker problèmes spécifiques dans la liste, mais en tout cas ils doivent être adressées à obtenir cron de travail.

À cette fin, mon travail actuel solution au problème posé dans la question est comme suit:

Créer un menu fixe le volume à laquelle tous les scripts en cours d'exécution en vertu de cron écrira:

# Dockerfile for test-logs

# BUILD-USING:        docker build -t test-logs .
# RUN-USING:          docker run  -d -v /t-logs --name t-logs test-logs
# INSPECT-USING:      docker run -t -i  --volumes-from t-logs ubuntu:latest /bin/bash

FROM stackbrew/busybox:latest

# Create logs volume
VOLUME /var/log

CMD  ["true"]

Le script qui sera exécuté en vertu de cron est test.py:

#!/usr/bin/env python

# python script which needs an environment variable and runs as a cron job
import datetime
import os

test_environ = os.environ["TEST_ENV"]
print "Cron job has run at %s with environment variable '%s'" %(datetime.datetime.now(), test_environ)

Afin de passer la variable d'environnement pour le script que je veux lancer sous cron, suivre la suggestion de Thomas et de mettre un crontab fragment pour chaque script (ou un groupe de scripts) qui a besoin d'un menu fixe variable d'environnement dans /etc/cron.d avec un espace réservé XXXXXXX qui doit être réglé.

# placed in /etc/cron.d 
# TEST_ENV is an docker environment variable that the script test.py need

TEST_ENV=XXXXXXX
#
* * * * * root python /test.py >> /var/log/test.log

Au lieu de l'appeler cron directement, enveloppez cron dans un script python qui ne fait les choses: 1. lit la variable d'environnement depuis le menu fixe variable d'environnement et définit la variable d'environnement dans une crontab fragment.

#!/usr/bin/env python

# run-cron.py
# sets environment variable crontab fragments and runs cron

import os
from subprocess import call
import fileinput

# read docker environment variables and set them in the appropriate crontab fragment
environment_variable = os.environ["TEST_ENV"]

for line in fileinput.input("/etc/cron.d/cron-python",inplace=1):
    print line.replace("XXXXXXX", environment_variable)

args = ["cron","-f", "-L 15"]
call(args)

La Dockerfile que pour le conteneur dans lequel les tâches cron run est comme suit:

# BUILD-USING:        docker build -t test-cron .
# RUN-USING docker run --detach=true --volumes-from t-logs --name t-cron test-cron

FROM debian:wheezy
#
# Set correct environment variables.
ENV HOME /root
ENV TEST_ENV test-value

RUN apt-get update && apt-get install -y software-properties-common python-software-properties && apt-get update

# Install Python Setuptools
RUN apt-get install -y python cron

RUN apt-get purge -y python-software-properties software-properties-common && apt-get clean -y && apt-get autoclean -y && apt-get autoremove -y && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

ADD cron-python /etc/cron.d/
ADD test.py /
ADD run-cron.py /

RUN chmod a+x test.py run-cron.py

# Set the time zone to the local time zone
RUN echo "America/New_York" > /etc/timezone && dpkg-reconfigure --frontend noninteractive tzdata

CMD ["/run-cron.py"]

Enfin, créer les conteneurs et les exécuter:

1. Créer le volume du journal (test-journaux) conteneur: docker build -t test-logs .
2. Exécuter volume du journal: docker run -d -v /t-logs --name t-logs test-logs
3. Créer le cron conteneur: docker build -t test-cron .
4. Exécuter le cron conteneur: docker run --detach=true --volumes-from t-logs --name t-cron test-cron
5. Pour inspecter les fichiers journaux des scripts en cours d'exécution en vertu de cron: docker run -t -i --volumes-from t-logs ubuntu:latest /bin/bash. Les fichiers journaux sont dans /var/log.

Ajoutant crontab fragments dans /etc/cron.d/ au lieu d'utiliser la racine du crontab serait peut-être préférable.

Ce serait:

• Vous permettent d'ajouter des tâches cron en les ajoutant à ce dossier.
• Vous sauver quelques couches.
• Émuler comment Debian distributions de le faire pour leurs propres paquets.

Observer que le format de ces fichiers est un peu différent d'une entrée crontab. Voici un échantillon de la distribution Debian package php:

# /etc/cron.d/php5: crontab fragment for php5
#  This purges session files older than X, where X is defined in seconds
#  as the largest value of session.gc_maxlifetime from all your php.ini
#  files, or 24 minutes if not defined.  See /usr/lib/php5/maxlifetime

# Look for and purge old sessions every 30 minutes
09,39 *     * * *     root   [ -x /usr/lib/php5/maxlifetime ] && [ -x /usr/lib/php5/sessionclean ] && [ -d /var/lib/php5 ] && /usr/lib/php5/sessionclean /var/lib/php5 $(/usr/lib/php5/maxlifetime)

Dans l'ensemble, à partir de l'expérience, l'exécution de cron dans un récipient fonctionne très bien (en plus de cron journalisation laissant beaucoup à désirer).

Nous utilisons ci-dessous la solution. Il supporte à la fois docker logs la fonctionnalité et la capacité à accrocher le cron processus dans le conteneur sur le PID 1 (si vous utilisez tail -f solutions de contournement fournies ci-dessus - si cron se bloque, docker ne suivra pas le redémarrage de la politique):

cron.sh:

#!/usr/bin/env bash

printenv | cat - /etc/cron.d/cron-jobs > ~/crontab.tmp \
    && mv ~/crontab.tmp /etc/cron.d/cron-jobs

chmod 644 /etc/cron.d/cron-jobs

tail -f /var/log/cron.log &

cron -f

Dockerfile:

RUN apt-get install --no-install-recommends -y -q cron 

ADD cron.sh /usr/bin/cron.sh
RUN chmod +x /usr/bin/cron.sh

ADD ./crontab /etc/cron.d/cron-jobs
RUN chmod 0644 /etc/cron.d/cron-jobs

RUN touch /var/log/cron.log

ENTRYPOINT ["/bin/sh", "/usr/bin/cron.sh"]

crontab:

* * * * * root <cmd> >> /var/log/cron.log 2>&1

Et s'il vous plaît n'oubliez pas d'ajouter la chair de poule nouvelle ligne dans votre crontab

Ne pas mélanger crond et votre image de base. Préférez utiliser une solution native pour votre langue (horaire ou crython comme dit par Anton), ou découpler il. Par découplage c'que je veux dire, de garder les choses séparées, de sorte que vous n'avez pas à maintenir une image tout à la fusion entre python et crond.

Vous pouvez utiliser Tasker, un groupe de coureur qui a cron (un planificateur de soutien, pour le résoudre, si vous voulez garder les choses découplés.

Ici un docker-compose.yml fichier, qui va exécuter certaines tâches pour vous

version: "2"

services:
    tasker:
        image: strm/tasker
        volumes:
            - "/var/run/docker.sock:/var/run/docker.sock"
        environment:
            configuration: |
                logging:
                    level:
                        ROOT: WARN
                        org.springframework.web: WARN
                        sh.strm: DEBUG
                schedule:
                    - every: minute
                      task: helloFromPython
                tasks:
                    docker:
                        - name: helloFromPython
                          image: python:3-slim
                          script:
                              - python -c 'print("Hello world from python")'

Il suffit d'exécuter docker-compose up, et de le voir travailler. Voici la Tasker repo avec la documentation complète:

http://github.com/opsxcq/tasker