如何在 docker 容器中运行 cron 作业？

您可以将 crontab 复制到映像中，以便从所述映像启动的容器运行作业。

请参阅他的 Ekito/docker-cron 中来自 Julien Boulay 的“Run a cron job with Docker”：

让我们创建一个名为“hello-cron”的新文件来描述我们的工作。

# must be ended with a new line "LF" (Unix) and not "CRLF" (Windows)
* * * * * 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.

如果您想知道什么是 2>&1，Ayman Hourieh explains。

以下 Dockerfile 描述了构建映像的所有步骤

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

（参见 Gaafar 的 comment 和 How do I make apt-get install less noisy?：
apt-get -y install -qq --force-yes cron 也可以）

如 the comments 中的 Nathan Lloyd 所述：

关于一个陷阱的快速说明：如果您要添加一个脚本文件并告诉 cron 运行它，请记住 RUN chmod 0744 /the_script 如果您忘记了，Cron 会静默失败。

或者，确保您的作业本身直接重定向到 stdout/stderr 而不是日志文件，如 hugoShaka 的 answer 中所述：

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

将最后 Dockerfile 行替换为

CMD ["cron", "-f"]

另请参见（关于 cron -f，即 cron “前景”）“docker ubuntu cron -f is not working”

构建并运行它：

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

请耐心等待 2 分钟，您的命令行应该会显示：

Hello world
Hello world

Eric 添加 in the comments：

请注意，如果在映像构建期间创建尾部，它可能不会显示正确的文件。如果是这种情况，您需要在容器运行时创建或触摸文件，以便 tail 获取正确的文件。

请参阅“Output of tail -f at the end of a docker CMD is not showing”。

在 Jason Kulatunga 的“Running Cron in Docker”（2021 年 4 月）中查看更多信息，因为他commented below

查看 Jason 的图片 AnalogJ/docker-cron，基于：

Dockerfile 安装 cronie/crond，取决于发行版。

初始化 /etc/environment 然后调用 cron -f -l 2 的入口点

---

接受的答案在生产环境中可能是危险的。

在 docker 中，每个容器应该只执行一个进程，因为如果不这样做，分叉并进入后台的进程不会受到监控，并且可能会在您不知情的情况下停止。

当您使用 CMD cron && tail -f /var/log/cron.log 时，cron 进程基本上 fork 以便在后台执行 cron，主进程退出并让您在前台执行 tailf。后台 cron 进程可能会停止或失败，您不会注意到，您的容器仍将静默运行，并且您的编排工具不会重新启动它。

您可以通过将 cron 的命令输出直接重定向到分别位于 /proc/1/fd/1 和 /proc/1/fd/2 中的 docker stdout 和 stderr 来避免这种情况。

使用基本的 shell 重定向，您可能想要执行以下操作：

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

您的 CMD 将是：CMD ["cron", "-f"]

---

对于那些想要使用简单轻量级图像的人：

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"]

其中 cronjobs 是包含您的 cronjobs 的文件，格式如下：

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

---

@VonC 的建议很好，但我更喜欢在一行中完成所有 cron 作业配置。这将避免像 cronjob 位置这样的跨平台问题，并且您不需要单独的 cron 文件。

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

运行 docker 容器后，您可以通过以下方式确定 cron 服务是否正常工作：

# 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"

如果您更喜欢使用 ENTRYPOINT 而不是 CMD，那么您可以将上面的 CMD 替换为

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

---

还有另一种方法是使用 Tasker，它是一个支持 cron（调度程序）的任务运行程序。

为什么 ？有时要运行 cron 作业，您必须将基础映像（python、java、nodejs、ruby）与 crond 混合。这意味着要维护另一个图像。 Tasker 通过分离 crond 和你的容器来避免这种情况。您可以只关注要执行命令的图像，并配置 Tasker 以使用它。

这是一个 docker-compose.yml 文件，它将为您运行一些任务

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")'

那里有 3 个任务，它们都将每分钟运行一次 (every: minute)，每个任务都将执行 script 代码，位于 image 部分中定义的图像内。

只需运行 docker-compose up，就可以看到它工作正常。这是包含完整文档的 Tasker 存储库：

http://github.com/opsxcq/tasker

---

尽管这旨在通过 Docker 的 exec 接口在容器中正在运行的进程旁边运行作业，但您可能对此感兴趣。

我编写了一个守护程序，用于观察容器并在其元数据中定义的作业调度。例子：

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

“经典”，类似 cron 的配置也是可能的。

这是 docs，这是 image repository。

---

VonC's 答案非常彻底。此外，我想补充一件对我有帮助的事情。如果您只想运行 cron 作业而不拖尾文件，您可能会很想从 cron 命令中删除 && tail -f /var/log/cron.log。

然而，这将导致 Docker 容器在运行后不久退出，因为当 cron 命令完成时，Docker 认为最后一个命令已经退出并因此终止容器。这可以通过 cron -f 在前台运行 cron 来避免。

---

如果您使用 docker for windows，请记住，如果您打算将 crontab 文件从 windows 导入到 ubuntu 容器，则必须将行尾格式从 CRLF 更改为 LF（即从 dos 到 unix）。如果没有，您的 cron-job 将无法工作。这是一个工作示例：

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

这实际上花了我几个小时才弄清楚，因为在 docker 容器中调试 cron 作业是一项乏味的任务。希望它可以帮助其他无法让他们的代码工作的人！

---

不幸的是，上述答案都没有对我有用，尽管所有答案都会导致解决方案并最终导致我的解决方案，如果它对某人有帮助，这里是片段。谢谢

这可以通过 bash 文件解决，由于 Docker 的分层架构，cron 服务不会通过 RUN/CMD/ENTRYPOINT 命令启动。

只需添加一个 bash 文件，该文件将启动 cron 和其他服务（如果需要）

DockerFile

FROM gradle:6.5.1-jdk11 AS build
# apt
RUN apt-get update
RUN apt-get -y install cron
# Setup cron to run every minute to print (you can add/update your cron here)
RUN touch /var/log/cron-1.log
RUN (crontab -l ; echo "* * * * * echo testing cron.... >> /var/log/cron-1.log 2>&1") | crontab
# entrypoint.sh
RUN chmod +x entrypoint.sh
CMD ["bash","entrypoint.sh"]

入口点.sh

#!/bin/sh
service cron start & tail -f /var/log/cron-2.log

如果还需要任何其他服务与 cron 一起运行，则在同一命令中使用 & 添加该服务，例如：/opt/wildfly/bin/standalone.sh & service cron start & tail -f /var/log/cron-2.log

进入 docker 容器后，您可以看到 testing cron.... 将在文件中每分钟打印一次：/var/log/cron-1.log

---

我根据其他答案创建了一个 Docker 映像，可以像这样使用

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

其中 /path/to/cron：crontab 文件的绝对路径，或者您可以将其用作 Dockerfile 中的基础：

FROM gaafar/cron

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

# Add your commands here

供参考，图像 is here。

---

在专用容器中定义 cronjob，该容器通过 docker exec 向您的服务运行命令。

这是更高的内聚性，正在运行的脚本将可以访问您为服务定义的环境变量。

#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"

---

我决定使用busybox，因为它是最小的图像之一。

crond 在前台执行（-f），日志发送到 stderr（-d），我没有选择更改日志级别。 crontab 文件被复制到默认路径：/var/spool/cron/crontabs

FROM busybox:1.33.1

# Usage: crond [-fbS] [-l N] [-d N] [-L LOGFILE] [-c DIR]
#
#   -f  Foreground
#   -b  Background (default)
#   -S  Log to syslog (default)
#   -l N    Set log level. Most verbose 0, default 8
#   -d N    Set log level, log to stderr
#   -L FILE Log to FILE
#   -c DIR  Cron dir. Default:/var/spool/cron/crontabs

COPY crontab /var/spool/cron/crontabs/root

CMD [ "crond", "-f", "-d" ]

---

当您在另一台主机上部署容器时，请注意它不会自动启动任何进程。您需要确保“cron”服务在您的容器内运行。在我们的例子中，我使用 Supervisord 和其他服务来启动 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

---

设置一个与一次性作业并行的 cron

创建一个脚本文件，比如 run.sh，其中包含应该定期运行的作业。

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

保存并退出。

使用入口点而不是 CMD

如果您在 docker 容器化期间有多个工作要启动，请使用入口点文件来运行它们。

入口点文件是一个脚本文件，它在发出 docker run 命令时生效。所以，我们想要运行的所有步骤都可以放在这个脚本文件中。

例如，我们有 2 个作业要运行：

运行一次作业：echo “Docker 容器已启动”

运行定期作业：run.sh

创建 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

让我们了解一下文件中已经设置好的crontab

* * * * *：Cron 计划；作业必须每分钟运行一次。您可以根据您的要求更新计划。

/run.sh：要定期运行的脚本文件的路径

/var/log/cron.log：保存计划 cron 作业输出的文件名。

2>&1：错误日志（如果有）也将被重定向到上面使用的相同输出文件。

注意：不要忘记添加一个额外的新行，因为它使它成为一个有效的 cron。 Scheduler.txt：完整的 cron 设置将被重定向到一个文件。

在 cron 中使用系统/用户特定的环境变量

我实际的 cron 工作期望将大多数参数作为传递给 docker run 命令的环境变量。但是，使用 bash，我无法使用属于系统或 docker 容器的任何环境变量。

然后，这是解决此问题的方法：

在 entrypoint.sh 中添加以下行

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

更新 cron 设置并指定 -

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

最后，您的 entrypoint.sh 应如下所示

#!/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

最后但并非最不重要的一点：创建 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

而已。构建并运行 Docker 镜像！

---

从上面的例子中，我创建了这个组合：

在 Nano 中使用 Crontab 进行高山图像和编辑（我讨厌 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

---

这是我基于 docker-compose 的解决方案：

  cron:
    image: alpine:3.10
    command: crond -f -d 8
    depends_on:
      - servicename
    volumes:
      - './conf/cron:/etc/crontabs/root:z'
    restart: unless-stopped

带有 cron 条目的行位于 ./conf/cron 文件中。

注意：这不会运行不在 alpine 映像上的命令。

---

这个问题有很多答案，但有些很复杂，有些有一些缺点。我尝试解释问题并尝试提供解决方案。

cron-entrypoint.sh：

#!/bin/bash

# copy machine environment variables to cron environment
printenv | cat - /etc/crontab > temp && mv temp /etc/crontab

## validate cron file
crontab /etc/crontab

# cron service with SIGTERM support
service cron start
trap "service cron stop; exit" SIGINT SIGTERM

# just dump your logs to std output
tail -f  \
    /app/storage/logs/laravel.log \
    /var/log/cron.log \
    & wait $!

解决的问题

环境变量在 cron 环境中不可用（如 env vars 或 kubernetes 机密）

当 crontab 文件无效时停止

当机器收到 SIGTERM 信号时，优雅地停止 cron 作业

对于上下文，我在 Kubernetes 上使用以前的脚本和 Laravel 应用程序。

---

这条线是帮助我运行我预先安排的任务的那条线。

ADD mycron/root /etc/cron.d/root

RUN chmod 0644 /etc/cron.d/root

RUN crontab /etc/cron.d/root

RUN touch /var/log/cron.log

CMD ( cron -f -l 8 & ) && apache2-foreground # <-- run cron

--> 我的项目在里面运行：FROM php:7.2-apache

---

在一些限制 root 访问的精简图像上运行时，我必须将我的用户添加到 sudoers 并以 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

也许这可以帮助某人

---

所以，我的问题是一样的。解决方法是更改 docker-compose.yml 中的命令部分。

从

命令：crontab /etc/crontab && tail -f /etc/crontab

至

命令：crontab /etc/crontab

命令：tail -f /etc/crontab

问题是命令之间的“&&”。删除后，一切都很好。

---

专注于在接收到 SIGTERM 或 SIGQUIT 信号时（例如，在运行 docker stop 时）优雅地停止 cronjobs。

这不太容易。默认情况下，cron 进程只是被杀死而没有注意运行 cronjobs。我正在详细说明 pablorsk's answer：

Dockerfile：

FROM ubuntu:latest

RUN apt-get update \
    && apt-get -y install cron procps \
    && rm -rf /var/lib/apt/lists/*

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

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

# similarly prepare the default cronjob scripts
COPY run_cronjob.sh /root/run_cronjob.sh
RUN chmod +x /root/run_cronjob.sh
COPY run_cronjob_without_log.sh /root/run_cronjob_without_log.sh
RUN chmod +x /root/run_cronjob_without_log.sh

# Apply cron job
RUN crontab /etc/cron.d/cronjobs

# to gain access to environment variables, we need this additional entrypoint script
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

# optionally, change received signal from SIGTERM TO SIGQUIT
#STOPSIGNAL SIGQUIT

# Run the command on container startup
ENTRYPOINT ["/entrypoint.sh"]

entrypoint.sh：

#!/bin/bash
# make global environment variables available within crond, too
printenv | grep -v "no_proxy" >> /etc/environment

# SIGQUIT/SIGTERM-handler
term_handler() {
  echo 'stopping cron'
  service cron stop
  echo 'stopped'
  echo 'waiting'
  x=$(($(ps u -C run_cronjob.sh | wc -l)-1))
  xold=0
  while [ "$x" -gt 0 ]
  do
    if [ "$x" != "$xold" ]; then
      echo "Waiting for $x running cronjob(s):"
      ps u -C run_cronjob.sh
      xold=$x
      sleep 1
    fi
    x=$(($(ps u -C run_cronjob.sh | wc -l)-1))
  done
  echo 'done waiting'
  exit 143; # 128 + 15 -- SIGTERM
}

# cron service with SIGTERM and SIGQUIT support
service cron start
trap "term_handler" QUIT TERM

# endless loop
while true
do
  tail -f /dev/null & wait ${!}
done

cronjobs

* * * * * ./run_cronjob.sh cron1
*/2 * * * * ./run_cronjob.sh cron2
*/3 * * * * ./run_cronjob.sh cron3

假设您将所有 cronjobs 包装在一个 run_cronjob.sh 脚本中。这样，您可以执行关闭将正常等待的任意代码。

run_cronjobs.sh（保持 cronjob 定义干净的可选帮助脚本）

#!/bin/bash

DIR_INCL="${BASH_SOURCE%/*}"
if [[ ! -d "$DIR_INCL" ]]; then DIR_INCL="$PWD"; fi
cd "$DIR_INCL"

# redirect all cronjob output to docker
./run_cronjob_without_log.sh "$@" > /proc/1/fd/1 2>/proc/1/fd/2

run_cronjob_without_log.sh

your_actual_cronjob_src()

顺便说一句，当收到 SIGKILL 时，容器仍会立即关闭。这样，您可以使用像 docker-compose stop -t 60 cron-container 这样的命令来等待 60 秒以使 cronjobs 正常完成，但在超时后仍然可以肯定地终止它们。

---