如果更新基本映像，如何自动更新docker容器

时间：2014-10-17 10:56:29

标签： docker automatic-updates

假设我有一个基于ubuntu:latest的简单容器。现在有一个安全更新，并且在docker repo中更新了ubuntu:latest。

  1. 我怎么知道我的本地图像及其容器在后面运行？

  2. 是否有一些自动更新本地图像和容器以遵循docker repo更新的最佳做法，这在实践中会为您提供在传统ubuntu机器上运行无人值守升级的相同细节

16 个答案:

答案 0 :(得分：109)

我们使用一个脚本来检查正在运行的容器是否以最新映像启动。我们还使用upstart init脚本来启动docker镜像。

#!/usr/bin/env bash
set -e
BASE_IMAGE="registry"
REGISTRY="registry.hub.docker.com"
IMAGE="$REGISTRY/$BASE_IMAGE"
CID=$(docker ps | grep $IMAGE | awk '{print $1}')
docker pull $IMAGE

for im in $CID
do
    LATEST=`docker inspect --format "{{.Id}}" $IMAGE`
    RUNNING=`docker inspect --format "{{.Image}}" $im`
    NAME=`docker inspect --format '{{.Name}}' $im | sed "s/\///g"`
    echo "Latest:" $LATEST
    echo "Running:" $RUNNING
    if [ "$RUNNING" != "$LATEST" ];then
        echo "upgrading $NAME"
        stop docker-$NAME
        docker rm -f $NAME
        start docker-$NAME
    else
        echo "$NAME up to date"
    fi
done

init看起来像

docker run -t -i --name $NAME $im /bin/bash

答案 1 :(得分：21)

'docker way'将使用docker hub automated builds。 {/ 3}}功能将在重建上游容器时重建容器，Repository Links功能将向您发送通知。

看起来webhooks仅限于HTTP POST调用。您需要设置一个服务来捕获它们，或者使用POST之一来发送电子邮件服务。

我没有调查过，但新的Webhooks可能具有检测更新容器和重新部署的功能。

答案 2 :(得分：17)

您可以使用Watchtower来监视容器实例化的映像的更新，并使用更新的映像自动提取更新并重新启动容器。但是，当基于它的上游图像发生变化时，这并不能解决重建自定义图像的问题。您可以将其视为一个由两部分组成的问题：（1）知道上游图像何时更新，以及（2）进行实际图像重建。 （1）可以很容易地解决，但（2）很大程度上取决于你的本地构建环境/实践，因此为此创建一个通用的解决方案可能要困难得多。

如果您能够使用Docker Hub automated builds，则可以使用repository links功能相对干净地解决整个问题，这样您就可以自动触发重建链接存储库（可能是上游存储库）已更新。您还可以配置webhook以在发生自动构建时通知您。如果您需要电子邮件或短信通知，可以将webhook连接到IFTTT Maker。我发现IFTTT用户界面有点令人困惑，但您可以将Docker webhook配置为使用/ key / docker_xyz_image_built发布到https://maker.ifttt.com/trigger/ your_key /。

如果您需要在本地构建，您至少可以通过在Docker Hub中创建与您感兴趣的回购链接相关联的虚拟仓库来解决在更新上游映像时获取通知的问题。虚拟仓库的唯一目的是在重建时触发webhook（这意味着其中一个链接的repos已更新）。如果您能够接收此webhook，您甚至可以使用它来触发您的重建。

答案 3 :(得分：9)

我遇到了同样的问题，并认为可以通过每天调用unattended-upgrade的cron作业来解决这个问题。

我的目的是将此作为一种自动且快速的解决方案，以确保生产容器的安全性和更新，因为我可能需要一段时间来更新我的映像并使用最新的安全更新部署新的docker映像。

还可以使用Github hooks

自动执行图像构建和部署

我创建了一个基本的docker image，每天自动检查并安装安全更新（可以由docker run itech/docker-unattended-upgrade直接运行）。

我还遇到另一个不同的approach来检查容器是否需要更新。

我的完整实施：

<强> Dockerfile 

FROM ubuntu:14.04   

RUN apt-get update \
&& apt-get install -y supervisor unattended-upgrades \
&& rm -rf /var/lib/apt/lists/*

COPY install /install
RUN chmod 755 install
RUN /install

COPY start /start
RUN chmod 755 /start

帮助程序脚本

安装 

#!/bin/bash
set -e

cat > /etc/supervisor/conf.d/cron.conf <<EOF
[program:cron]
priority=20
directory=/tmp
command=/usr/sbin/cron -f
user=root
autostart=true
autorestart=true
stdout_logfile=/var/log/supervisor/%(program_name)s.log
stderr_logfile=/var/log/supervisor/%(program_name)s.log
EOF

rm -rf /var/lib/apt/lists/*

ENTRYPOINT ["/start"]

启动的

#!/bin/bash

set -e

echo "Adding crontab for unattended-upgrade ..."
echo "0 0 * * * root /usr/bin/unattended-upgrade" >> /etc/crontab

# can also use @daily syntax or use /etc/cron.daily

echo "Starting supervisord ..."
exec /usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf

修改

我开发了一个小工具docker-run，它作为docker容器运行，可以用来更新所有或选定的运行容器中的包，它也可以用来运行任意命令。

可以使用以下命令轻松测试：

docker run --rm -v /var/run/docker.sock:/tmp/docker.sock itech/docker-run exec

默认情况下会在所有正在运行的容器中执行date命令并显示结果。如果您通过update而不是exec，则会在所有正在运行的容器中执行apt-get update后跟apt-get upgrade -y

答案 4 :(得分：7)

如果不运行docker pull，您就不会知道您的容器落后了。然后，您需要rebuild或recompose您的图片。

docker pull image:tag
docker-compose -f docker-compose.yml -f production.yml up -d --build

这些命令可以放在脚本中以及完成升级所需的任何其他内容，尽管适当的容器不需要任何其他内容。

答案 5 :(得分：7)

其中一种方法是通过CI / CD系统进行驱动。构建父映像后，请使用该父映像扫描git repos中的映像。如果找到，则您将发送拉取请求以更改到该图像的新版本。如果所有测试均通过，则请求请求将被合并，并且您将具有基于更新的父级的新子级图像。可以在此处找到采用这种方法的工具示例：https://engineering.salesforce.com/open-sourcing-dockerfile-image-update-6400121c1a75。

如果您不控制父映像，例如，如果您依赖于官方ubuntu映像，可以编写一些工具来检测父映像标签中的更改并调用子映像构建相应地。

答案 6 :(得分：4)

另一种方法可能是假设您的基本图像很快落后（并且很可能发生），并定期强制执行应用程序的另一个图像构建（例如每周），然后重新部署它如果它已经改变了。

据我所知，流行的基础图像，如官方Debian或Java更新其标签以满足安全修复，因此标签不是不可变的（如果你想要更强的保证，你需要使用参考[图像] ：@digest]，可在更新的Docker版本中使用）。因此，如果您使用docker build --pull构建图像，那么您的应用程序应该获得您引用的最新且最好的基本图像标记。

由于可变标签可能令人困惑，因此每次执行此操作时最好增加应用程序的版本号，以便至少在您身边更清洁。

所以我不确定上一个答案中建议的脚本是否有效，因为它不会重建应用程序的图像 - 它只是更新基本图像标签然后它重新启动容器，但新容器仍引用旧的基本映像哈希。

我不会主张在容器（或任何其他进程，除非确实需要）中运行cron类型的作业，因为这违背了每个容器只运行一个进程的咒语（关于为什么这是更好，所以我不打算在这里讨论它。）

答案 7 :(得分：4)

我没有涉及到你是否想在生产中进行无人值守更新的整个问题（我认为不是）。我将此处留在此处以供参考，以防任何人发现它有用。使用终端中的以下命令将所有docker镜像更新到最新版本：

# docker images | awk '(NR>1) && ($2!~/none/) {print $1":"$2}' | xargs -L1 docker pull

答案 8 :(得分：4)

Docker镜像的依赖管理是一个真正的问题。我是构建工具MicroBadger的团队的一员，通过监控容器图像和检查元数据来帮助实现这一点。它的一个功能是让您设置一个通知webhook，当您感兴趣的图像（例如基本图像）发生变化时，该通知会被调用。

答案 9 :(得分：4)

这里有很多答案，但它们都不符合我的需求。我想要问问题＃1问题的实际答案。我如何知道hub.docker.com上何时更新图像？

以下脚本可以每天运行。在第一次运行时，它获取标签的基线并从HUB注册表更新日期并在本地保存它们。从那时起，每次运行它都会检查注册表中的新标签和更新日期。由于每次存在新图像时都会更改，因此它会告诉我们基本图像是否已更改。这是脚本：

#!/bin/bash

DATAPATH='/data/docker/updater/data'

if [ ! -d "${DATAPATH}" ]; then
        mkdir "${DATAPATH}";
fi
IMAGES=$(docker ps --format "{{.Image}}")
for IMAGE in $IMAGES; do
        ORIGIMAGE=${IMAGE}
        if [[ "$IMAGE" != *\/* ]]; then
                IMAGE=library/${IMAGE}
        fi
        IMAGE=${IMAGE%%:*}
        echo "Checking ${IMAGE}"
        PARSED=${IMAGE//\//.}
        if [ ! -f "${DATAPATH}/${PARSED}" ]; then
                # File doesn't exist yet, make baseline
                echo "Setting baseline for ${IMAGE}"
                curl -s "https://registry.hub.docker.com/v2/repositories/${IMAGE}/tags/" > "${DATAPATH}/${PARSED}"
        else
                # File does exist, do a compare
                NEW=$(curl -s "https://registry.hub.docker.com/v2/repositories/${IMAGE}/tags/")
                OLD=$(cat "${DATAPATH}/${PARSED}")
                if [[ "${VAR1}" == "${VAR2}" ]]; then
                        echo "Image ${IMAGE} is up to date";
                else
                        echo ${NEW} > "${DATAPATH}/${PARSED}"
                        echo "Image ${IMAGE} needs to be updated";
                        H=`hostname`
                        ssh -i /data/keys/<KEYFILE> <USER>@<REMOTEHOST>.com "{ echo \"MAIL FROM: root@${H}\"; echo \"RCPT TO: <USER>@<EMAILHOST>.com\"; echo \"DATA\"; echo \"Subject: ${H} - ${IMAGE} needs update\"; echo \"\"; echo -e \"\n${IMAGE} needs update.\n\ndocker pull ${ORIGIMAGE}\"; echo \"\"; echo \".\"; echo \"quit\"; sleep 1; } | telnet <SMTPHOST> 25"
                fi

        fi
done;

您需要更改顶部的DATAPATH变量，并在最后更改电子邮件通知命令以满足您的需要。对我来说，我将它连接到我的SMTP所在的另一个网络上的服务器。但您也可以轻松使用mail命令。

现在，您还想检查容器内部的更新包。这实际上可能比做＆＃34;拉＆＃34;更有效。一旦你的容器工作。这是解决这个问题的脚本：

#!/bin/bash


function needsUpdates() {
        RESULT=$(docker exec ${1} bash -c ' \
                if [[ -f /etc/apt/sources.list ]]; then \
                grep security /etc/apt/sources.list > /tmp/security.list; \
                apt-get update > /dev/null; \
                apt-get upgrade -oDir::Etc::Sourcelist=/tmp/security.list -s; \
                fi; \
                ')
        RESULT=$(echo $RESULT)
        GOODRESULT="Reading package lists... Building dependency tree... Reading state information... Calculating upgrade... 0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded."
        if [[ "${RESULT}" != "" ]] && [[ "${RESULT}" != "${GOODRESULT}" ]]; then
                return 0
        else
                return 1
        fi
}

function sendEmail() {
        echo "Container ${1} needs security updates";
        H=`hostname`
        ssh -i /data/keys/<KEYFILE> <USRER>@<REMOTEHOST>.com "{ echo \"MAIL FROM: root@${H}\"; echo \"RCPT TO: <USER>@<EMAILHOST>.com\"; echo \"DATA\"; echo \"Subject: ${H} - ${1} container needs security update\"; echo \"\"; echo -e \"\n${1} container needs update.\n\n\"; echo -e \"docker exec ${1} bash -c 'grep security /etc/apt/sources.list > /tmp/security.list; apt-get update > /dev/null; apt-get upgrade -oDir::Etc::Sourcelist=/tmp/security.list -s'\n\n\"; echo \"Remove the -s to run the update\"; echo \"\"; echo \".\"; echo \"quit\"; sleep 1; } | telnet <SMTPHOST> 25"
}

CONTAINERS=$(docker ps --format "{{.Names}}")
for CONTAINER in $CONTAINERS; do
        echo "Checking ${CONTAINER}"
        if needsUpdates $CONTAINER; then
                sendEmail $CONTAINER
        fi
done

答案 10 :(得分：3)

前言我的回答：

  1. 容器使用标记运行。
  2. 同样的标签可以指向不同的图像UUID，因为我们喜欢/感觉合适。
  3. 对图像所做的更新可以提交到新的图像层

    4. <强>方法

    1. 首先使用安全补丁更新脚本构建所有容器
    2. 为以下内容构建自动化流程
      • 使用安全补丁脚本作为命令
        • 将现有映像运行到新容器
      • 提交对图像的更改为
        • 现有代码 - ＆gt;然后逐个重新启动容器
        • 新版本标签 - ＆gt;用新标签替换少量容器 - ＆gt;验证 - ＆gt;将所有容器移至新标签

      3. 此外，基础图像可以升级/具有完整新基础图像的容器可以定期构建，因为维护者认为有必要

      <强>优点

      1. 我们在创建新的安全修补映像时保留旧版本的映像，因此我们可以在必要时回滚到以前运行的映像
      2. 我们正在保留docker缓存，因此网络传输更少（只有更改的图层才能通过网络传输）
      3. 升级过程可以在转移到prod
        4. 之前在分段中验证
      4. 这可以是一个受控制的过程，因此只有在必要/认为重要时才能推送安全补丁。

答案 11 :(得分：2)

以上答案也是正确的

有两种方法

  
      
  1. 使用网络挂钩
    2.   
  2. 每隔一分钟运行一次脚本，以获取最新的docker镜像
    3.   

我只是分享脚本，可能会对您有所帮助！ 您可以将其与c​​ronjob一起使用，我在OSX上成功尝试了

#!/bin/bash
##You can use below commented line for setting cron tab for running cron job and to store its O/P in one .txt file  
#* * * * * /usr/bin/sudo -u admin -i bash -c /Users/Swapnil/Documents/checkimg.sh > /Users/Swapnil/Documents/cron_output.log 2>&1
# Example for the Docker Hub V2 API
# Returns all images and tags associated with a Docker Hub organization account.
# Requires 'jq': https://stedolan.github.io/jq/

# set username, password, and organization
# Filepath where your docker-compose file is present
FILEPATH="/Users/Swapnil/Documents/lamp-alpine"
# Your Docker hub user name
UNAME="ur username"
# Your Docker hub user password
UPASS="ur pwd"
# e.g organisation_name/image_name:image_tag
ORG="ur org name"
IMGNAME="ur img name"
IMGTAG="ur img tag"
# Container name
CONTNAME="ur container name"
# Expected built mins
BUILDMINS="5"
#Generally cronjob frequency
CHECKTIME="5"
NETWORKNAME="${IMGNAME}_private-network"
#After Image pulling, need to bring up all docker services?
DO_DOCKER_COMPOSE_UP=true
# -------
echo "Eecuting Script @ date and time in YmdHMS: $(date +%Y%m%d%H%M%S)"
set -e
PIDFILE=/Users/Swapnil/Documents/$IMGNAME/forever.pid
if [ -f $PIDFILE ]
then
  PID=$(cat $PIDFILE)
  ps -p $PID > /dev/null 2>&1
  if [ $? -eq 0 ]
  then
    echo "Process already running"
    exit 1
  else
    ## Process not found assume not running
    echo $$
    echo $$ > $PIDFILE
    if [ $? -ne 0 ]
    then
      echo "Could not create PID file"
      exit 1
    fi
  fi
else
  echo $$ > $PIDFILE
  if [ $? -ne 0 ]
  then
    echo "Could not create PID file"
    exit 1
  fi
fi

# Check Docker is running or not; If not runing then exit
if docker info|grep Containers ; then
    echo "Docker is running"
else
    echo "Docker is not running"
    rm $PIDFILE
    exit 1
fi

# Check Container is running or not; and set variable
CONT_INFO=$(docker ps -f "name=$CONTNAME" --format "{{.Names}}")
if [ "$CONT_INFO" = "$CONTNAME" ]; then
    echo "Container is running"
    IS_CONTAINER_RUNNING=true
else
    echo "Container is not running"
    IS_CONTAINER_RUNNING=false
fi


# get token
echo "Retrieving token ..."
TOKEN=$(curl -s -H "Content-Type: application/json" -X POST -d '{"username": "'${UNAME}'", "password": "'${UPASS}'"}' https://hub.docker.com/v2/users/login/ | jq -r .token)

# get list of repositories
echo "Retrieving repository list ..."
REPO_LIST=$(curl -s -H "Authorization: JWT ${TOKEN}" https://hub.docker.com/v2/repositories/${ORG}/?page_size=100 | jq -r '.results|.[]|.name')

# output images & tags
echo "Images and tags for organization: ${ORG}"
echo
for i in ${REPO_LIST}
do
  echo "${i}:"
  # tags
  IMAGE_TAGS=$(curl -s -H "Authorization: JWT ${TOKEN}" https://hub.docker.com/v2/repositories/${ORG}/${i}/tags/?page_size=100 | jq -r '.results|.[]|.name')
  for j in ${IMAGE_TAGS}
  do
    echo "  - ${j}"
  done
  #echo
done

# Check Perticular image is the latest or not
#imm=$(curl -s -H "Authorization: JWT ${TOKEN}" https://hub.docker.com/v2/repositories/${ORG}/${IMGNAME}/tags/?page_size=100)
echo "-----------------"
echo "Last built date details about Image ${IMGNAME} : ${IMGTAG} for organization: ${ORG}"
IMAGE_UPDATED_DATE=$(curl -s -H "Authorization: JWT ${TOKEN}" https://hub.docker.com/v2/repositories/${ORG}/${IMGNAME}/tags/?page_size=100 | jq -r '.results|.[]|select(.name | contains("'${IMGTAG}'")).last_updated')
echo "On Docker Hub IMAGE_UPDATED_DATE---$IMAGE_UPDATED_DATE"
echo "-----------------"

IMAGE_CREATED_DATE=$(docker image inspect ${ORG}/${IMGNAME}:${IMGTAG} | jq -r '.[]|.Created')
echo "Locally IMAGE_CREATED_DATE---$IMAGE_CREATED_DATE"

updatedDate=$(date -jf '%Y-%m-%dT%H:%M' "${IMAGE_UPDATED_DATE:0:16}" +%Y%m%d%H%M%S) 
createdDate=$(date -jf '%Y-%m-%dT%H:%M' "${IMAGE_CREATED_DATE:0:16}" +%Y%m%d%H%M%S)
currentDate=$(date +%Y%m%d%H%M%S)

start_date=$(date -jf "%Y%m%d%H%M%S" "$currentDate" "+%s")
end_date=$(date -jf "%Y%m%d%H%M%S" "$updatedDate" "+%s")
updiffMins=$(( ($start_date - $end_date) / (60) ))
if [[ "$updiffMins" -lt $(($CHECKTIME+1)) ]]; then
        if [ ! -d "${FILEPATH}" ]; then
            mkdir "${FILEPATH}";
        fi
        cd "${FILEPATH}"
        pwd
        echo "updatedDate---$updatedDate" > "ScriptOutput_${currentDate}.txt"
        echo "createdDate---$createdDate" >> "ScriptOutput_${currentDate}.txt"
        echo "currentDate---$currentDate" >> "ScriptOutput_${currentDate}.txt"
        echo "Found after regular checking time -> Docker hub's latest updated image is new; Diff ${updiffMins} mins" >> "ScriptOutput_${currentDate}.txt"
        echo "Script is checking for latest updates after every ${CHECKTIME} mins" >> "ScriptOutput_${currentDate}.txt"
        echo "Fetching all new"
        echo "---------------------------"
        if $IS_CONTAINER_RUNNING ; then
            echo "Container is running"         
        else
            docker-compose down
            echo "Container stopped and removed; Network removed" >> "ScriptOutput_${currentDate}.txt"
        fi
        echo "Image_Created_Date=$currentDate" > ".env"
        echo "ORG=$ORG" >> ".env"
        echo "IMGNAME=$IMGNAME" >> ".env"
        echo "IMGTAG=$IMGTAG" >> ".env"
        echo "CONTNAME=$CONTNAME" >> ".env"
        echo "NETWORKNAME=$NETWORKNAME" >> ".env"
        docker-compose build --no-cache
        echo "Docker Compose built" >> "ScriptOutput_${currentDate}.txt"
        if $DO_DOCKER_COMPOSE_UP ; then
            docker-compose up -d
            echo "Docker services are up now, checked in" >> "ScriptOutput_${currentDate}.txt"  
        else
            echo "Docker services are down, checked in" >> "ScriptOutput_${currentDate}.txt"
        fi
elif [[ "$updatedDate" -gt "$createdDate" ]]; then 
    echo "Updated is latest"
    start_date=$(date -jf "%Y%m%d%H%M%S" "$updatedDate" "+%s")
    end_date=$(date -jf "%Y%m%d%H%M%S" "$createdDate" "+%s")
    diffMins=$(( ($start_date - $end_date) / (60) ))
    if [[ "$BUILDMINS" -lt "$diffMins" ]]; then
        if [ ! -d "${FILEPATH}" ]; then
            mkdir "${FILEPATH}";
        fi
        cd "${FILEPATH}"
        pwd
        echo "updatedDate---$updatedDate" > "ScriptOutput_${currentDate}.txt"
        echo "createdDate---$createdDate" >> "ScriptOutput_${currentDate}.txt"
        echo "currentDate---$currentDate" >> "ScriptOutput_${currentDate}.txt"
        echo "Found after comparing times -> Docker hub's latest updated image is new; Diff ${diffMins} mins" >> "ScriptOutput_${currentDate}.txt"
        echo "Actual image built time is less i.e. ${diffMins} mins than MAX expexted BUILD TIME i.e. ${BUILDMINS} mins" >> "ScriptOutput_${currentDate}.txt"
        echo "Fetching all new" >> "ScriptOutput_${currentDate}.txt"
        echo "-----------------------------"
        if $IS_CONTAINER_RUNNING ; then
            echo "Container is running"         
        else
            docker-compose down
            echo "Container stopped and removed; Network removed" >> "ScriptOutput_${currentDate}.txt"
        fi
        echo "Image_Created_Date=$currentDate" > ".env"
        echo "ORG=$ORG" >> ".env"
        echo "IMGNAME=$IMGNAME" >> ".env"
        echo "IMGTAG=$IMGTAG" >> ".env"
        echo "CONTNAME=$CONTNAME" >> ".env"
        echo "NETWORKNAME=$NETWORKNAME" >> ".env"
        docker-compose build --no-cache
        echo "Docker Compose built" >> "ScriptOutput_${currentDate}.txt"
        if $DO_DOCKER_COMPOSE_UP ; then
            docker-compose up -d
            echo "Docker services are up now" >> "ScriptOutput_${currentDate}.txt"  
        else
            echo "Docker services are down" >> "ScriptOutput_${currentDate}.txt"
        fi
    elif [[ "$BUILDMINS" -gt "$diffMins" ]]; then
        echo "Docker hub's latest updated image is NOT new; Diff ${diffMins} mins"
        echo "Docker images not fetched"
    else
        echo "Docker hub's latest updated image is NOT new; Diff ${diffMins} mins"
        echo "Docker images not fetched"
    fi
elif [[ "$createdDate" -gt "$updatedDate" ]]; then 
    echo "Created is latest"
    start_date=$(date -jf "%Y%m%d%H%M%S" "$createdDate" "+%s")
    end_date=$(date -jf "%Y%m%d%H%M%S" "$updatedDate" "+%s")
    echo "Docker hub has older docker image than local; Older than $(( ($start_date - $end_date) / (60) ))mins"
fi
echo 
echo "------------end---------------"
rm $PIDFILE

这是我的docker-compose文件

version:  "3.2"
services:
  lamp-alpine:
    build:
      context: .
    container_name: "${CONTNAME}"
    image: "${ORG}/${IMGNAME}:${IMGTAG}"
    ports:
      - "127.0.0.1:80:80"
    networks:
      - private-network 

networks:
  private-network:
    driver: bridge

答案 12 :(得分：2)

BLUF：寻找正确的插入点以监视容器的更改是一个挑战。如果DockerHub能够解决这个问题，那将是很棒的。 （已经提到了存储库链接，但是在DockerHub上进行设置时请注意-“只要在Docker Hub上更新基础映像，就会在此存储库中触发构建。仅适用于非官方映像。” ） / p>

在尝试自己解决此问题时，我看到了一些有关Webhooks的建议，所以我想详细说明一下我使用过的几种解决方案。

  1. 使用microbadger.com跟踪容器中的更改并使用它 通知webhook功能来触发操作。我设置好了 使用zapier.com（但您可以使用任何可自定义的Webhook服务） 在我的github仓库中使用Alpine作为一个新问题 基本图片。

    • 优点：在采取行动之前，您可以查看github中microbadger报告的更改。
    • 缺点：Microbadger不允许您跟踪特定标签。看起来它只跟踪“最新”。

  2. 跟踪RSS提要，以确保git提交到上游容器。例如https://github.com/gliderlabs/docker-alpine/commits/rootfs/library-3.8/x86_64。我使用zapier.com监视此提要，并在发生任何问题时在Travis-CI中触发我的容器的自动构建。这有点极端，但是您可以更改触发器以执行其他操作，例如在git存储库中打开问题以进行手动干预。

    • 优点：更接近自动管路。 Travis-CI构建仅检查容器是否存在与提交给基本映像存储库有关的任何问题。您的CI服务是否需要采取进一步的措施，完全取决于您。
    • 缺点：跟踪提交提要并不完美。很多事情都提交给存储库，不会影响基础映像的构建。不会考虑任何与频率/提交次数和API节流有关的问题。

答案 13 :(得分：0)

A030109

是一个简单而出色的解决方案

答案 14 :(得分：0)

  

这是自动更新docker容器的最简单方法

通过$ crontab -e放置作业：

0 * * * * sh ~/.docker/cron.sh

使用文件~/.docker创建目录cron.sh：

#!/bin/sh
if grep -Fqe "Image is up to date" << EOF
`docker pull ubuntu:latest`
EOF
then
    echo "no update, just do cleaning"
    docker system prune --force
else
    echo "newest exist, recompose!"
    cd /path/to/your/compose/file
    docker-compose down --volumes
    docker-compose up -d
fi

答案 15 :(得分：-1)

您是否尝试过此操作：https://github.com/v2tec/watchtower。 这是一个在docker容器中运行的简单工具，用于监视其他容器，如果它们的基本映像发生更改，它将拉动并重新部署。

相关问题
最新问题