วิธีอัปเดตคอนเทนเนอร์นักเทียบท่าของคุณโดยอัตโนมัติหากอัปเดตภาพฐาน

ว่าฉันมีภาชนะเล็ก ๆ น้อย ๆ ubuntu:latestอยู่บนพื้นฐานของ ขณะนี้มีการปรับปรุงความปลอดภัยและubuntu:latestได้รับการปรับปรุงใน repo นักเทียบท่า

1. ฉันจะรู้ได้อย่างไรว่าภาพในตัวเครื่องของฉันและที่บรรจุอยู่นั้นกำลังทำงานอยู่?

2. มีวิธีปฏิบัติที่ดีที่สุดสำหรับการอัปเดตรูปภาพและตู้คอนเทนเนอร์ในเครื่องโดยอัตโนมัติเพื่อติดตามการอัพเดท repo docker หรือไม่

อีกวิธีหนึ่งที่สามารถทำได้คือการขับผ่านระบบ CI / CD ของคุณ เมื่อสร้างภาพหลักของคุณแล้วให้มีสิ่งที่สแกน repos git ของคุณเพื่อดูภาพโดยใช้ภาพหลัก หากพบว่าคุณส่งคำขอดึงเพื่อชนภาพเวอร์ชันใหม่ คำขอดึงหากการทดสอบทั้งหมดผ่านจะถูกรวมเข้าด้วยกันและคุณจะมีภาพลูกใหม่โดยยึดตามพาเรนต์ที่อัปเดตแล้ว ตัวอย่างของเครื่องมือที่ใช้วิธีนี้สามารถพบได้ที่นี่: https://engineering.salesforce.com/open-sourcing-dockerfile-image-update-6400121c1a75

หากคุณไม่ได้ควบคุมภาพหลักของคุณอย่างเช่นในกรณีที่คุณขึ้นอยู่กับubuntuภาพอย่างเป็นทางการคุณสามารถเขียนเครื่องมือบางอย่างที่ตรวจพบการเปลี่ยนแปลงในแท็กภาพหลักหรือการตรวจสอบ (ไม่ใช่สิ่งเดียวกันแท็กที่ไม่แน่นอน) และ เรียกเด็กสร้างภาพตาม

เราใช้สคริปต์ที่ตรวจสอบว่าคอนเทนเนอร์ที่ใช้เริ่มต้นด้วยอิมเมจล่าสุดหรือไม่ นอกจากนี้เรายังใช้สคริปต์เริ่มต้นพุ่งพรวดสำหรับการเริ่มต้นภาพนักเทียบท่า

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

A 'วิธีที่นักเทียบท่า' จะใช้นักเทียบท่าศูนย์กลาง อัตโนมัติสร้าง Repository ลิงก์คุณลักษณะจะสร้างภาชนะของคุณเมื่อภาชนะต้นน้ำจะสร้างใหม่และWebhooksคุณลักษณะจะส่งการแจ้งเตือน

ดูเหมือนว่า webhooks จะถูก จำกัด การโทร HTTP POST คุณต้องตั้งค่าบริการเพื่อรับบริการหรืออาจใช้ POST หนึ่งในบริการอีเมลที่นั่น

ฉันยังไม่ได้ตรวจสอบ แต่Docker Universal Control Plane ใหม่อาจมีคุณสมบัติในการตรวจจับคอนเทนเนอร์ที่อัปเดตแล้วและนำไปใช้งานอีกครั้ง

คุณสามารถใช้หอสังเกตการณ์เพื่อดูการอัปเดตของภาพที่มีการสร้างคอนเทนเนอร์จากและดึงการอัปเดตและรีสตาร์ทคอนเทนเนอร์โดยอัตโนมัติโดยใช้ภาพที่อัปเดต อย่างไรก็ตามนั่นไม่ได้แก้ปัญหาของการสร้างภาพที่กำหนดเองของคุณขึ้นมาใหม่เมื่อมีการเปลี่ยนแปลงภาพต้นน้ำที่เกิดขึ้น คุณสามารถดูได้ว่านี่เป็นปัญหาสองส่วน: (1) การรู้ว่าเมื่อใดที่อิมเมจอัปสตรีมได้รับการอัพเดตและ (2) ทำการสร้างอิมเมจจริง (1) สามารถแก้ไขได้ค่อนข้างง่าย แต่ (2) ขึ้นอยู่กับสภาพแวดล้อม / แนวทางปฏิบัติในท้องถิ่นของคุณดังนั้นมันอาจจะยากกว่าที่จะสร้างโซลูชันทั่วไปสำหรับสิ่งนั้น

หากคุณสามารถใช้งานสร้างอัตโนมัติของ Docker Hub ปัญหาทั้งหมดสามารถแก้ไขได้อย่างหมดจดโดยใช้คุณลักษณะลิงก์ที่เก็บซึ่งช่วยให้คุณสามารถเรียกใช้งานสร้างใหม่โดยอัตโนมัติเมื่อมีการอัปเดตที่เก็บที่เชื่อมโยง (อาจเป็นอัปสตรีม) นอกจากนี้คุณยังสามารถกำหนดค่าwebhookเพื่อแจ้งให้คุณทราบเมื่อมีการสร้างอัตโนมัติ หากคุณต้องการการแจ้งเตือนทางอีเมลหรือ SMS คุณสามารถเชื่อมต่อ webhook เพื่อIFTTT ชง ผมพบว่าส่วนติดต่อผู้ใช้ IFTTT จะเป็นชนิดของความสับสน แต่คุณจะกำหนดค่าเทียบท่า webhook โพสต์ไปhttps://maker.ifttt.com/trigger/docker_xyz_image_built / มีคีย์ / your_key/

หากคุณต้องการสร้างในพื้นที่อย่างน้อยที่สุดคุณสามารถแก้ปัญหาการรับการแจ้งเตือนเมื่อมีการอัปเดตรูปภาพ upstream โดยสร้าง dummy repo ใน Docker Hub ที่เชื่อมโยงกับ repo ที่คุณสนใจ จุดประสงค์เดียวของ repo ตัวแทนคือจะเรียก webhook เมื่อมันถูกสร้างขึ้นมาใหม่ (ซึ่งหมายถึงหนึ่งใน repos ที่เชื่อมโยงได้รับการปรับปรุง) หากคุณสามารถรับ webhook นี้ได้คุณสามารถใช้สิ่งนั้นเพื่อเรียกการสร้างใหม่ที่ด้านข้างของคุณ

ฉันมีปัญหาเดียวกันและคิดว่ามันสามารถแก้ไขได้ง่ายๆโดยงาน cron โทรunattended-upgradeทุกวัน

ความตั้งใจของฉันคือการให้สิ่งนี้เป็นโซลูชันอัตโนมัติและรวดเร็วเพื่อให้มั่นใจว่าคอนเทนเนอร์การผลิตมีความปลอดภัยและได้รับการอัปเดตเพราะอาจทำให้ฉันต้องอัปเดตรูปภาพของฉันในบางครั้งและปรับใช้อิมเมจนักเทียบท่าใหม่

นอกจากนี้ยังเป็นไปได้ที่จะสร้างและปรับใช้อิมเมจโดยอัตโนมัติด้วยGithub hooks

ฉันได้สร้างรูปภาพนักเทียบท่าพื้นฐานโดยที่จะตรวจสอบและติดตั้งการปรับปรุงความปลอดภัยทุกวัน (สามารถเรียกใช้โดยตรงdocker run itech/docker-unattended-upgrade)

ฉันเจอวิธีอื่นที่แตกต่างกันเพื่อตรวจสอบว่าคอนเทนเนอร์ต้องการการอัพเดตหรือไม่

การใช้งานของฉันเสร็จสมบูรณ์:

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 --rm -v /var/run/docker.sock:/tmp/docker.sock itech/docker-run exec

ซึ่งโดยค่าเริ่มต้นจะดำเนินการdateคำสั่งในคอนเทนเนอร์ที่ใช้งานอยู่ทั้งหมดและแสดงผลลัพธ์ ถ้าคุณผ่านupdateแทนexecก็จะดำเนินการapt-get updateตามapt-get upgrade -yในภาชนะบรรจุที่กำลังทำงานอยู่ทั้งหมด

คุณจะไม่ทราบภาชนะของคุณอยู่หลังโดยไม่ต้องใช้ดึงนักเทียบท่า จากนั้นคุณจะต้องสร้างใหม่หรือจัดองค์ประกอบภาพของคุณใหม่

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

คำสั่งสามารถใส่ในสคริปต์พร้อมกับสิ่งอื่นที่จำเป็นในการอัปเกรดให้เสร็จสมบูรณ์แม้ว่าคอนเทนเนอร์ที่เหมาะสมจะไม่ต้องการอะไรเพิ่มเติม

การจัดการการพึ่งพาสำหรับอิมเมจ Docker เป็นปัญหาจริง ฉันเป็นส่วนหนึ่งของทีมที่สร้างเครื่องมือMicroBadgerเพื่อช่วยในเรื่องนี้โดยการตรวจสอบรูปคอนเทนเนอร์และตรวจสอบข้อมูลเมตา หนึ่งในคุณสมบัติของมันคือให้คุณตั้งค่า webhook การแจ้งเตือนที่ถูกเรียกเมื่อรูปภาพที่คุณสนใจ (เช่นภาพฐาน) เปลี่ยนแปลง

มีคำตอบมากมายที่นี่ แต่ไม่มีคำตอบใดที่ตรงกับความต้องการของฉัน ฉันต้องการคำตอบจริงสำหรับคำถาม # 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ตัวแปรที่ด้านบนและแก้ไขคำสั่งการแจ้งเตือนทางอีเมลที่ส่วนท้ายเพื่อให้เหมาะกับความต้องการของคุณ สำหรับฉันฉันมี SSH ลงในเซิร์ฟเวอร์ในเครือข่ายอื่นที่ตั้งอยู่ SMTP ของฉัน แต่คุณสามารถใช้mailคำสั่งได้ง่ายเช่นกัน

ตอนนี้คุณต้องการตรวจสอบแพ็คเกจที่อัพเดตภายในคอนเทนเนอร์ด้วยตนเอง นี่อาจมีประสิทธิภาพมากกว่าการทำ "pull" เมื่อคอนเทนเนอร์ของคุณทำงาน นี่คือสคริปต์ที่จะดึงออก:

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

อีกวิธีหนึ่งคือสมมติว่าภาพฐานของคุณล้าหลังอย่างรวดเร็ว (และเป็นไปได้มากที่จะเกิดขึ้น) และบังคับให้สร้างรูปภาพอื่นของแอปพลิเคชันของคุณเป็นระยะ (เช่นทุกสัปดาห์) จากนั้นปรับใช้อีกครั้งหากมีการเปลี่ยนแปลง

เท่าที่ฉันสามารถบอกได้ภาพพื้นฐานที่เป็นที่นิยมเช่น Debian หรือ Java อัปเดตแท็กเพื่อแก้ไขปัญหาความปลอดภัยดังนั้นแท็กจึงไม่เปลี่ยนรูป (ถ้าคุณต้องการการรับประกันที่แข็งแกร่งกว่าคุณต้องใช้การอ้างอิง [image: @digest ] มีให้ใน Docker เวอร์ชั่นล่าสุด) ดังนั้นหากคุณต้องการสร้างภาพด้วย docker build --pullแอปพลิเคชันของคุณควรได้รับแท็กภาพพื้นฐานล่าสุดและยิ่งใหญ่ที่สุดที่คุณอ้างอิง

เนื่องจากแท็กที่ไม่แน่นอนสามารถสร้างความสับสนได้จึงเป็นการดีที่สุดที่จะเพิ่มหมายเลขเวอร์ชันของแอปพลิเคชันของคุณทุกครั้งที่คุณทำเช่นนี้

ดังนั้นฉันไม่แน่ใจว่าสคริปต์ที่แนะนำในหนึ่งในคำตอบก่อนหน้านี้ทำงานได้เนื่องจากมันไม่ได้สร้างอิมเมจของแอปพลิเคชันของคุณขึ้นมาใหม่เพียงแค่อัปเดตแท็กอิมเมจพื้นฐานจากนั้นรีสตาร์ทคอนเทนเนอร์ แฮชภาพฐานเก่า

ฉันจะไม่สนับสนุนการเรียกใช้งาน cron-type ใน container (หรือกระบวนการอื่น ๆ เว้นแต่จำเป็นจริงๆ) เพราะนี่ขัดกับมนต์ของการทำงานเพียงหนึ่งโพรเซสต่อคอนเทนเนอร์ (มีข้อโต้แย้งต่าง ๆ เกี่ยวกับสาเหตุที่ดีกว่าดังนั้นฉันจึง ฉันจะไม่เข้าไปที่นี่)

ฉันจะไม่ถามคำถามทั้งหมดว่าคุณต้องการรับการอัพเดทแบบไม่ต้องใส่ข้อมูลหรือไม่ ฉันแค่ปล่อยไว้ที่นี่เพื่ออ้างอิงในกรณีที่ใคร ๆ เห็นว่ามันมีประโยชน์ อัปเดตอิมเมจนักเทียบท่าทั้งหมดเป็นเวอร์ชั่นล่าสุดด้วยคำสั่งต่อไปนี้ในเครื่องเทอร์มินัลของคุณ:

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

อัปเดต: ใช้ Dependabot - https://dependabot.com/docker/

BLUF: การค้นหาจุดแทรกที่ถูกต้องสำหรับการตรวจสอบการเปลี่ยนแปลงของภาชนะบรรจุเป็นความท้าทาย มันจะดีถ้า DockerHub จะแก้ปัญหานี้ (ลิงก์ที่เก็บได้รับการกล่าวถึง แต่ทราบเมื่อตั้งค่าพวกเขาใน DockerHub - "ทริกเกอร์การสร้างในพื้นที่เก็บข้อมูลนี้เมื่อใดก็ตามที่ภาพพื้นฐานมีการปรับปรุงบน Docker Hub ใช้งานได้เฉพาะกับภาพที่ไม่เป็นทางการ" )

ในขณะที่พยายามแก้ไขปัญหานี้ด้วยตนเองฉันเห็นคำแนะนำหลายประการสำหรับเว็บบล็อกดังนั้นฉันจึงต้องการอธิบายรายละเอียดเกี่ยวกับวิธีแก้ปัญหาสองสามข้อที่ฉันใช้

1. ใช้ microbadger.com เพื่อติดตามการเปลี่ยนแปลงในคอนเทนเนอร์และใช้คุณสมบัติการแจ้งเตือนผ่านเว็บเพื่อเรียกการกระทำ ฉันตั้งค่านี้ด้วย zapier.com (แต่คุณสามารถใช้บริการ webhook ที่กำหนดเองได้) เพื่อสร้างปัญหาใหม่ในที่เก็บ github ของฉันที่ใช้อัลไพน์เป็นรูปภาพพื้นฐาน

   • ข้อดี: คุณสามารถตรวจสอบการเปลี่ยนแปลงที่รายงานโดย microbadger เป็น GitHub ก่อนดำเนินการ
   • จุดด้อย: Microbadger ไม่อนุญาตให้คุณติดตามแท็กเฉพาะ ดูเหมือนว่าจะติดตามเฉพาะ 'ล่าสุด'

2. ติดตามฟีด RSS สำหรับคอมไพล์ยอมรับกับคอนเทนเนอร์ต้นน้ำ อดีต https://github.com/gliderlabs/docker-alpine/commits/rootfs/library-3.8/x86_64 ฉันใช้ zapier.com เพื่อตรวจสอบฟีดนี้และเรียกใช้งานการสร้างคอนเทนเนอร์ของฉันอัตโนมัติใน Travis-CI ทุกครั้งที่มีอะไรเกิดขึ้น นี่คือสุดขีดเล็กน้อย แต่คุณสามารถเปลี่ยนทริกเกอร์ให้ทำสิ่งอื่นเช่นเปิดปัญหาในที่เก็บ git ของคุณเพื่อทำการแทรกแซงด้วยตนเอง

   • ข้อดี: ใกล้กับระบบอัตโนมัติ Travis-CI build เพียงตรวจสอบเพื่อดูว่าคอนเทนเนอร์ของคุณมีปัญหากับสิ่งใดที่ส่งไปยังที่เก็บรูปภาพพื้นฐานหรือไม่ ขึ้นอยู่กับคุณถ้าบริการ CI ของคุณดำเนินการใด ๆ เพิ่มเติม
   • ข้อด้อย: การติดตามฟีด commit ไม่สมบูรณ์แบบ มีหลายสิ่งที่เกิดขึ้นกับที่เก็บที่ไม่ส่งผลกระทบต่อการสร้างอิมเมจพื้นฐาน ไม่คำนึงถึงปัญหาใด ๆ เกี่ยวกับความถี่ / จำนวนการกระทำและการควบคุมปริมาณ API

ยืนยันคำตอบของฉัน:

1. ตู้คอนเทนเนอร์มีแท็ก
2. แท็กเดียวกันสามารถชี้ไปที่ภาพ UUID ที่แตกต่างกันในขณะที่เราโปรด / รู้สึกเหมาะสม
3. การอัพเดตที่ทำกับรูปภาพสามารถถูกคอมมิตเป็นเลเยอร์รูปภาพใหม่

เข้าใกล้

1. สร้างคอนเทนเนอร์ทั้งหมดตั้งแต่แรกด้วยสคริปต์ update-patch security
2. สร้างกระบวนการอัตโนมัติสำหรับสิ่งต่อไปนี้
   • รันอิมเมจที่มีอยู่ไปยังคอนเทนเนอร์ใหม่ด้วยสคริปต์แพตช์รักษาความปลอดภัยเป็นคำสั่ง
   • ส่งการเปลี่ยนแปลงกับรูปภาพเป็น
     • แท็กที่มีอยู่ -> ตามด้วยการรีสตาร์ทคอนเทนเนอร์ทีละหนึ่ง
     • แท็กเวอร์ชันใหม่ -> แทนที่คอนเทนเนอร์ไม่กี่รายการด้วยแท็กใหม่ -> ตรวจสอบความถูกต้อง -> ย้ายคอนเทนเนอร์ทั้งหมดไปยังแท็กใหม่

นอกจากนี้ภาพฐานสามารถอัพเกรด / ภาชนะที่มีภาพฐานใหม่ที่สมบูรณ์สามารถสร้างขึ้นในช่วงเวลาปกติตามที่ผู้ดูแลรู้สึกจำเป็น

ข้อดี

1. เรากำลังรักษาอิมเมจเวอร์ชันเก่าไว้ในขณะที่สร้างอิมเมจความปลอดภัยใหม่ที่แก้ไขแล้วดังนั้นเราสามารถย้อนกลับไปยังอิมเมจก่อนหน้านี้หากจำเป็น
2. เรากำลังรักษาแคชนักเทียบท่าดังนั้นการถ่ายโอนเครือข่ายน้อยลง (เฉพาะเลเยอร์ที่เปลี่ยนแปลงเท่านั้นที่รับสาย)
3. กระบวนการอัพเกรดสามารถตรวจสอบความถูกต้องในการ staging ก่อนที่จะย้ายไปยังผลิตภัณฑ์
4. นี่อาจเป็นกระบวนการควบคุมดังนั้นแพทช์รักษาความปลอดภัยก็ต่อเมื่อมีความจำเป็น / ถือว่ามีความสำคัญเท่านั้นที่สามารถผลักดันได้

คำตอบข้างต้นถูกต้องเช่นกัน

มีสองวิธี

1. ใช้ webhooks
2. เรียกใช้สคริปต์ทุก ๆ นาทีเพื่อรับภาพนักเทียบท่าใหม่ ๆ

ฉันแค่แชร์สคริปต์อาจเป็นประโยชน์สำหรับคุณ! คุณสามารถใช้กับ cronjob ได้ฉันลองใช้ 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

นี่คือไฟล์นักแต่งเพลงของฉัน

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

นี่เป็นวิธีที่ง่ายที่สุดในการอัปเดตคอนเทนเนอร์นักเทียบท่าโดยอัตโนมัติ

ใส่งานผ่าน$ crontab -e:

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

สร้าง dir ~/.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

มีคุณพยายามนี้: https://github.com/v2tec/watchtower มันเป็นเครื่องมือง่าย ๆ ที่ทำงานในตัวเทียบท่าที่ดูตู้คอนเทนเนอร์อื่น ๆ ถ้ารูปพื้นฐานเปลี่ยนไปมันจะดึงและจัดวางใหม่

ทางออกที่ง่ายและยอดเยี่ยมคือคนเลี้ยงแกะ