J'essaie d'exécuter un cronjob dans un conteneur docker qui invoque un script shell.

Hier, j'ai cherché partout sur le Web et les débordements de pile, mais je n'ai pas vraiment trouvé de solution qui fonctionne.
Comment puis-je faire ceci?

ÉDITER:

J'ai créé un référentiel github (commenté) avec un conteneur cron docker qui appelle un script shell à un intervalle donné.

Vous pouvez copier votre crontab dans une image, afin que le conteneur lancé à partir de cette image exécute le travail.

Voir " Exécuter un travail cron avec Docker " de Julien Boulay dans son Ekito/docker-cron:

Créons un nouveau fichier appelé " hello-cron" pour décrire notre travail.

* * * * * echo "Hello world" >> /var/log/cron.log 2>&1
# An empty line is required at the end of this file for a valid cron file.

Le Dockerfile suivant décrit toutes les étapes pour construire votre image

FROM ubuntu:latest
MAINTAINER docker@ekito.fr

RUN apt-get update && apt-get -y install cron

# Copy hello-cron file to the cron.d directory
COPY hello-cron /etc/cron.d/hello-cron

# Give execution rights on the cron job
RUN chmod 0644 /etc/cron.d/hello-cron

# Apply cron job
RUN crontab /etc/cron.d/hello-cron

# Create the log file to be able to run tail
RUN touch /var/log/cron.log

# Run the command on container startup
CMD cron && tail -f /var/log/cron.log

(voir Gaafar de » commentaire et Comment puis-je faire apt-getinstaller moins bruyants? :
apt-get -y install -qq --force-yes cronpeut fonctionner aussi)

Comme l'a noté Nathan Lloyd dans les commentaires :

Note rapide sur un problème:
si vous ajoutez un fichier de script et dites à cron de l'exécuter, n'oubliez pas que Cron échoue silencieusement si vous oubliez .
RUN chmod 0744 /the_script

OU, assurez-vous que votre travail lui-même redirige directement vers stdout / stderr au lieu d'un fichier journal, comme décrit dans la réponse de hugoShaka :

 * * * * * root echo hello > /proc/1/fd/1 2>/proc/1/fd/2

Remplacez la dernière ligne Dockerfile par

CMD ["cron", "-f"]

Voir aussi (à propos cron -f, c'est-à-dire cron "premier plan") " docker ubuntu cron -fne fonctionne pas "

Construisez-le et exécutez-le:

sudo docker build --rm -t ekito/cron-example .
sudo docker run -t -i ekito/cron-example

Soyez patient, attendez 2 minutes et votre ligne de commande devrait afficher:

Hello world
Hello world

Eric ajoute dans les commentaires :

Notez que taille fichier correct peut ne pas s'afficher s'il est créé lors de la création de l'image.
Si tel est le cas, vous devez créer ou toucher le fichier pendant l'exécution du conteneur afin que tail récupère le fichier correct.

Voir " Sortie de tail -fà la fin d'un docker CMDne s'affiche pas ".

La solution adoptée peut être dangereuse dans un environnement de production .

Dans Docker, vous ne devez exécuter qu'un seul processus par conteneur, car si vous ne le faites pas, le processus qui a bifurqué et est passé en arrière-plan n'est pas surveillé et peut s'arrêter à votre insu.

Lorsque vous utilisez CMD cron && tail -f /var/log/cron.logessentiellement le processus cron fork pour exécuter cronen arrière-plan, le processus principal se termine et vous permet d'exécuter tailfen premier plan. Le processus cron en arrière-plan peut s'arrêter ou échouer, vous ne le remarquerez pas, votre conteneur fonctionnera toujours en mode silencieux et votre outil d'orchestration ne le redémarrera pas.

Vous pouvez éviter une telle chose en redirigeant directement la sortie des commandes du cron dans votre docker stdoutet stderrqui se trouvent respectivement dans /proc/1/fd/1et /proc/1/fd/2.

En utilisant les redirections de base du shell, vous voudrez peut-être faire quelque chose comme ceci:

* * * * * root echo hello > /proc/1/fd/1 2>/proc/1/fd/2

Et votre CMD sera: CMD ["cron", "-f"]

Pour ceux qui souhaitent utiliser une image simple et légère:

FROM alpine:3.6

# copy crontabs for root user
COPY config/cronjobs /etc/crontabs/root

# start crond with log level 8 in foreground, output to stderr
CMD ["crond", "-f", "-d", "8"]

Où cronjobs est le fichier qui contient vos cronjobs, sous cette forme:

* * * * * echo "hello stackoverflow" >> /test_file 2>&1
# remember to end this file with an empty new line

Ce que @VonC a suggéré est bien, mais je préfère faire toute la configuration des tâches cron sur une seule ligne. Cela éviterait les problèmes multiplates-formes comme l'emplacement des tâches cron et vous n'avez pas besoin d'un fichier cron distinct.

FROM ubuntu:latest

# Install cron
RUN apt-get -y install cron

# Create the log file to be able to run tail
RUN touch /var/log/cron.log

# Setup cron job
RUN (crontab -l ; echo "* * * * * echo "Hello world" >> /var/log/cron.log") | crontab

# Run the command on container startup
CMD cron && tail -f /var/log/cron.log

Après avoir exécuté votre conteneur Docker, vous pouvez vous assurer que le service cron fonctionne en:

# To check if the job is scheduled
docker exec -ti <your-container-id> bash -c "crontab -l"
# To check if the cron service is running
docker exec -ti <your-container-id> bash -c "pgrep cron"

Si vous préférez avoir ENTRYPOINT au lieu de CMD, vous pouvez remplacer le CMD ci-dessus par

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

Il y a une autre façon de le faire, c'est d'utiliser Tasker , un tâches qui prend en charge cron (un planificateur).

Pourquoi ? Parfois, pour exécuter un travail cron, vous devez mélanger votre image de base (python, java, nodejs, ruby) avec le crond. Cela signifie une autre image à maintenir. Tasker éviter cela en découplant le crond et votre conteneur. Vous pouvez simplement vous concentrer sur l'image sur laquelle vous souhaitez exécuter vos commandes et configurer Tasker pour l'utiliser.

Voici un docker-compose.ymlfichier, qui va exécuter quelques 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: hello
                    - every: minute
                      task: helloFromPython
                    - every: minute
                      task: helloFromNode
                tasks:
                    docker:
                        - name: hello
                          image: debian:jessie
                          script:
                              - echo Hello world from Tasker
                        - name: helloFromPython
                          image: python:3-slim
                          script:
                              - python -c 'print("Hello world from python")'
                        - name: helloFromNode
                          image: node:8
                          script:
                              - node -e 'console.log("Hello from node")'

Il y a 3 tâches là-bas, toutes s'exécuteront toutes les minutes ( every: minute), et chacune exécutera le scriptcode, à l'intérieur de l'image définie dansimage section.

Il suffit de courir docker-compose upet de le voir fonctionner. Voici le dépôt Tasker avec la documentation complète:

http://github.com/opsxcq/tasker

La réponse de VonC est assez complète. De plus, j'aimerais ajouter une chose qui m'a aidé. Si vous voulez simplement exécuter un travail cron sans suivre un fichier, vous seriez tenté de simplement supprimer le && tail -f /var/log/cron.logde la commande cron.

Cependant, cela entraînera la fermeture du conteneur Docker peu de temps après l'exécution, car lorsque la commande cron se termine, Docker pense que la dernière commande a été fermée et tue donc le conteneur. Cela peut être évité en exécutant cron au premier plan via cron -f.

Bien que cela vise à exécuter des travaux à côté d'un processus en cours d'exécution dans un conteneur via Docker exec interface , cela peut vous intéresser.

J'ai écrit un démon qui observe les conteneurs et planifie les travaux, définis dans leurs métadonnées, sur eux. Exemple:

version: '2'

services:
  wordpress:
    image: wordpress
  mysql:
    image: mariadb
    volumes:
      - ./database_dumps:/dumps
    labels:
      deck-chores.dump.command: sh -c "mysqldump --all-databases > /dumps/dump-$$(date -Idate)"
      deck-chores.dump.interval: daily

Une configuration «classique» de type cron est également possible.

Voici les documents , voici le référentiel d'images .

J'ai créé une image Docker basée sur les autres réponses, qui peut être utilisée comme

docker run -v "/path/to/cron:/etc/cron.d/crontab" gaafar/cron

où /path/to/cron: chemin absolu vers le fichier crontab, ou vous pouvez l'utiliser comme base dans un Dockerfile:

FROM gaafar/cron

# COPY crontab file in the cron directory
COPY crontab /etc/cron.d/crontab

# Add your commands here

Pour référence, l'image est ici .

Lorsque vous déployez votre conteneur sur un autre hôte, notez simplement qu'il ne démarrera aucun processus automatiquement. Vous devez vous assurer que le service «cron» fonctionne à l'intérieur de votre conteneur. Dans notre cas, j'utilise Supervisord avec d'autres services pour démarrer le service cron.

[program:misc]
command=/etc/init.d/cron restart
user=root
autostart=true
autorestart=true
stderr_logfile=/var/log/misc-cron.err.log
stdout_logfile=/var/log/misc-cron.out.log
priority=998

Définissez le cronjob dans un conteneur dédié qui exécute la commande via docker exec à votre service.

Il s'agit d'une cohésion plus élevée et le script en cours d'exécution aura accès aux variables d'environnement que vous avez définies pour votre service.

#docker-compose.yml
version: "3.3"
services:
    myservice:
      environment:
        MSG: i'm being cronjobbed, every minute!
      image: alpine
      container_name: myservice
      command: tail -f /dev/null

    cronjobber:
     image: docker:edge
     volumes:
      - /var/run/docker.sock:/var/run/docker.sock
     container_name: cronjobber
     command: >
          sh -c "
          echo '* * * * * docker exec myservice printenv | grep MSG' > /etc/crontabs/root
          && crond -f"

Si vous utilisez Docker pour Windows, n'oubliez pas que vous devez changer votre format de fin de ligne de CRLF à LF (c'est-à-dire de dos à Unix) si vous avez l'intention d'importer votre fichier crontab de Windows vers votre conteneur Ubuntu. Sinon, votre cron-job ne fonctionnera pas. Voici un exemple de travail:

FROM ubuntu:latest

RUN apt-get update && apt-get -y install cron
RUN apt-get update && apt-get install -y dos2unix

# Add crontab file (from your windows host) to the cron directory
ADD cron/hello-cron /etc/cron.d/hello-cron

# Change line ending format to LF
RUN dos2unix /etc/cron.d/hello-cron

# Give execution rights on the cron job
RUN chmod 0644 /etc/cron.d/hello-cron

# Apply cron job
RUN crontab /etc/cron.d/hello-cron

# Create the log file to be able to run tail
RUN touch /var/log/hello-cron.log

# Run the command on container startup
CMD cron && tail -f /var/log/hello-cron.log

Cela m'a effectivement pris des heures à comprendre, car le débogage des tâches cron dans les conteneurs Docker est une tâche fastidieuse. J'espère que cela aide toute autre personne qui ne peut pas faire fonctionner son code!

À partir des exemples ci-dessus, j'ai créé cette combinaison:

Alpine Image & Edit à l'aide de Crontab dans Nano (je déteste vi)

FROM alpine

RUN apk update
RUN apk add curl nano

ENV EDITOR=/usr/bin/nano 

# start crond with log level 8 in foreground, output to stderr
CMD ["crond", "-f", "-d", "8"]

# Shell Access
# docker exec -it <CONTAINERID> /bin/sh

# Example Cron Entry
# crontab -e
# * * * * * echo hello > /proc/1/fd/1 2>/proc/1/fd/2
# DATE/TIME WILL BE IN UTC

Configurer un cron en parallèle à un travail ponctuel

Créez un fichier de script, par exemple run.sh, avec le travail qui est censé s'exécuter périodiquement.

#!/bin/bash
timestamp=`date +%Y/%m/%d-%H:%M:%S`
echo "System path is $PATH at $timestamp"

Sauvegarder et quitter.

Utilisez Entrypoint au lieu de CMD

Si vous avez plusieurs tâches à lancer pendant la conteneurisation du docker, utilisez le fichier de point d'entrée pour les exécuter toutes.

Le fichier Entrypoint est un fichier de script qui entre en action lorsqu'une commande d'exécution de docker est émise. Ainsi, toutes les étapes que nous voulons exécuter peuvent être placées dans ce fichier de script.

Par exemple, nous avons 2 tâches à exécuter:

Exécuter une fois le travail : echo "Docker container has been started"

Exécuter un travail périodique : run.sh

Créez entrypoint.sh

#!/bin/bash

# Start the run once job.
echo "Docker container has been started"

# Setup a cron schedule
echo "* * * * * /run.sh >> /var/log/cron.log 2>&1
# This extra line makes it a valid cron" > scheduler.txt

crontab scheduler.txt
cron -f

Comprenons la crontab qui a été configurée dans le fichier

* * * * *: Horaire Cron; le travail doit s'exécuter toutes les minutes. Vous pouvez mettre à jour le calendrier en fonction de vos besoins.

/run.sh: Chemin d'accès au fichier de script à exécuter périodiquement

/var/log/cron.log: Nom de fichier pour enregistrer la sortie du travail cron planifié.

2>&1: Les journaux d'erreurs (le cas échéant) seront également redirigés vers le même fichier de sortie utilisé ci-dessus.

Remarque : N'oubliez pas d'ajouter une nouvelle ligne supplémentaire, car cela en fait un cron valide. Scheduler.txt: la configuration complète de cron sera redirigée vers un fichier.

Utilisation de variables d'environnement spécifiques au système / utilisateur dans cron

Mon travail cron réel attendait la plupart des arguments lorsque les variables d'environnement étaient passées à la commande docker run. Mais, avec bash, je n'ai pu utiliser aucune des variables d'environnement appartenant au système ou au conteneur Docker.

Ensuite, cela est venu comme une solution à ce problème:

1. Ajoutez la ligne suivante dans le point d'entrée.sh

declare -p | grep -Ev 'BASHOPTS|BASH_VERSINFO|EUID|PPID|SHELLOPTS|UID' > /container.env

2. Mettez à jour la configuration cron et spécifiez-

SHELL=/bin/bash
BASH_ENV=/container.env

Enfin, vous entrypoint.shdevriez ressembler à

#!/bin/bash

# Start the run once job.
echo "Docker container has been started"

declare -p | grep -Ev 'BASHOPTS|BASH_VERSINFO|EUID|PPID|SHELLOPTS|UID' > /container.env

# Setup a cron schedule
echo "SHELL=/bin/bash
BASH_ENV=/container.env
* * * * * /run.sh >> /var/log/cron.log 2>&1
# This extra line makes it a valid cron" > scheduler.txt

crontab scheduler.txt
cron -f

Dernier point mais non le moindre: créer un Dockerfile

FROM ubuntu:16.04
MAINTAINER Himanshu Gupta

# Install cron
RUN apt-get update && apt-get install -y cron

# Add files
ADD run.sh /run.sh
ADD entrypoint.sh /entrypoint.sh

RUN chmod +x /run.sh /entrypoint.sh

ENTRYPOINT /entrypoint.sh

C'est tout. Créez et exécutez l'image Docker!

Les tâches Cron sont stockées dans / var / spool / cron / crontabs (endroit commun dans toutes les distributions que je connais). BTW, vous pouvez créer un onglet cron dans bash en utilisant quelque chose comme ça:

crontab -l > cronexample
echo "00 09 * * 1-5 echo hello" >> cronexample
crontab cronexample
rm cronexample

Cela va créer un fichier temporaire avec la tâche cron, puis le programmer en utilisant crontab. La dernière ligne supprime le fichier temporaire.

Lors de l'exécution sur certaines images réduites qui limitent l'accès root, j'ai dû ajouter mon utilisateur aux sudoers et exécuter en tant que sudo cron

FROM node:8.6.0
RUN apt-get update && apt-get install -y cron sudo

COPY crontab /etc/cron.d/my-cron
RUN chmod 0644 /etc/cron.d/my-cron
RUN touch /var/log/cron.log

# Allow node user to start cron daemon with sudo
RUN echo 'node ALL=NOPASSWD: /usr/sbin/cron' >>/etc/sudoers

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

Peut-être que cela aide quelqu'un

Donc, mon problème était le même. Le correctif consistait à modifier la section de commande dans le docker-compose.yml.

De

commande: crontab / etc / crontab && tail -f / etc / crontab

À

commande: crontab / etc / crontab

commande: tail -f / etc / crontab

Le problème était le «&&» entre les commandes. Après avoir supprimé cela, tout allait bien.

Le moyen le plus robuste que j'ai trouvé jusqu'à présent est d'exécuter un conteneur Cron indépendant - installez le client Docker et liez le support de la chaussette Docker pour pouvoir parler au serveur Docker sur l'hôte.

Ensuite, utilisez simplement env vars pour chaque tâche cron et un script de point d'entrée pour générer le fichier / etc / crontab

Voici une image que j'ai créée en utilisant ce principe et en l'utilisant en production depuis 3-4 ans.

https://www.vip-consult.solutions/post/better-docker-cron#content

Essayez d'utiliser un joyau d'horlogerie pour planifier des tâches. Suivez les étapes fournies dans ce lien.

http://fuzzyblog.io/blog/rails/2017/05/11/adding-cron-to-a-dockerized-rails-application-using-clockwork.html

Vous pouvez appeler la tâche de râteau dans le fichier lib / clock.rb comme ci-dessous.

every(1.day, 'Import large data from csv files', :at => '5:00') do |job|
  `rake 'portal:import_data_from_csv'`
end

Créez un conteneur séparé dans le fichier docker-compose et exécutez la commande ci-dessous à l'intérieur du conteneur.

command: bundle exec clockwork lib/clock.rb