Como atualizar automaticamente os contêineres do Docker, se as imagens de base forem atualizadas

Digamos que eu tenha um contêiner trivial baseado no ubuntu:latest. Agora, há uma atualização de segurança e ubuntu:latesté atualizada no repositório de encaixe.

1. Como saberia se minha imagem local e seus contêineres estão atrasados?

2. Existe alguma prática recomendada para atualizar automaticamente imagens e contêineres locais para seguir as atualizações de repositório do docker, que na prática dariam as mesmas vantagens de ter atualizações autônomas em execução em uma máquina ubuntu convencional

Uma das maneiras de fazer isso é direcionar isso pelos sistemas de CI / CD. Depois que sua imagem pai for criada, tenha algo que varre seus repositórios git em busca de imagens usando esse pai. Se encontrado, você enviaria uma solicitação de recebimento para encontrar novas versões da imagem. A solicitação de recebimento, se todos os testes forem aprovados, seria mesclada e você teria uma nova imagem filha com base no pai atualizado. Um exemplo de ferramenta que adota essa abordagem pode ser encontrado aqui: https://engineering.salesforce.com/open-sourcing-dockerfile-image-update-6400121c1a75 .

Se você não controlar sua imagem pai, como seria o caso, dependendo da ubuntuimagem oficial , poderá escrever algumas ferramentas que detectam alterações na tag ou na soma de verificação da imagem pai (não é a mesma coisa, as tags são mutáveis) e invocar filhos que a imagem cria de acordo.

Usamos um script que verifica se um contêiner em execução é iniciado com a imagem mais recente. Também usamos scripts init iniciados para iniciar a imagem do 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

E init parece

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

Uma 'maneira do docker' seria usar as compilações automatizadas do hub do docker . O recurso Links de Repositório reconstruirá seu contêiner quando um contêiner upstream for reconstruído, e o recurso Webhooks enviará uma notificação.

Parece que os webhooks estão limitados a chamadas HTTP POST. Você precisaria configurar um serviço para capturá-los ou talvez usar um dos POST para enviar serviços por e-mail.

Ainda não examinei, mas o novo Docker Universal Control Plane pode ter um recurso para detectar contêineres atualizados e reimplementar.

Você pode usar a Torre de Vigia para procurar atualizações na imagem da qual um contêiner é instanciado, puxar automaticamente a atualização e reiniciar o contêiner usando a imagem atualizada. No entanto, isso não resolve o problema de reconstruir suas próprias imagens personalizadas quando há uma alteração na imagem upstream em que ela se baseia. Você pode ver isso como um problema de duas partes: (1) saber quando uma imagem upstream foi atualizada e (2) fazer a reconstrução real da imagem. (1) pode ser resolvido com bastante facilidade, mas (2) depende muito do seu ambiente / práticas de construção local, por isso é provavelmente muito mais difícil criar uma solução generalizada para isso.

Se você puder usar as compilações automatizadas do Docker Hub , todo o problema poderá ser resolvido de forma relativamente limpa usando o recurso de links do repositório , que permite ativar uma reconstrução automaticamente quando um repositório vinculado (provavelmente um upstream) é atualizado. Você também pode configurar um webhook para notificá-lo quando ocorrer uma compilação automatizada. Se desejar uma notificação por email ou SMS, você poderá conectar o webhook ao IFTTT Maker . Achei a interface do usuário IFTTT um pouco confusa, mas você configuraria o webhook do Docker para postar em https://maker.ifttt.com/trigger/docker_xyz_image_built / com / key / your_key.

Se precisar criar localmente, você pode pelo menos resolver o problema de receber notificações quando uma imagem upstream for atualizada criando um repositório fictício no Docker Hub vinculado aos seus repositórios de interesse. O único objetivo do repositório fictício seria acionar um webhook quando ele fosse reconstruído (o que implica que um de seus repositórios vinculados foi atualizado). Se você conseguir receber esse webhook, poderá usá-lo para desencadear uma reconstrução do seu lado.

Eu tive o mesmo problema e pensei que ele pode ser simplesmente resolvido por um trabalho cron ligando unattended-upgradediariamente.

Minha intenção é ter isso como uma solução automática e rápida para garantir que o contêiner de produção seja seguro e atualizado, pois pode levar algum tempo para atualizar minhas imagens e implantar uma nova imagem de janela de encaixe com as atualizações de segurança mais recentes.

Também é possível automatizar a criação e implantação da imagem com ganchos do Github

Criei uma imagem básica do Docker, que verifica e instala automaticamente atualizações de segurança diariamente (pode ser executada diretamente por docker run itech/docker-unattended-upgrade).

Também deparei com outra abordagem diferente para verificar se o contêiner precisa de uma atualização.

Minha implementação completa:

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

Scripts auxiliares

instalar

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

começar

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

Editar

Desenvolvi uma pequena ferramenta docker-run que é executada como contêiner de docker e pode ser usada para atualizar pacotes dentro de todos ou em contêineres em execução selecionados; também pode ser usada para executar qualquer comando arbitrário.

Pode ser facilmente testado com o seguinte comando:

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

que por padrão executará o datecomando em todos os contêineres em execução e exibirá os resultados. Se você passar em updatevez execdele, será executado apt-get updateseguido por apt-get upgrade -ytodos os contêineres em execução

Você não saberia que seu contêiner está atrasado sem executar o docker pull . Você precisará reconstruir ou recompor sua imagem.

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

Os comandos podem ser colocados em um script junto com qualquer outra coisa necessária para concluir a atualização, embora um contêiner adequado não precise de mais nada.

O gerenciamento de dependências para imagens do Docker é um problema real. Faço parte de uma equipe que construiu uma ferramenta, o MicroBadger , para ajudar com isso, monitorando imagens de contêineres e inspecionando metadados. Um de seus recursos é permitir que você configure um webhook de notificação chamado quando uma imagem em que você está interessado (por exemplo, uma imagem de base) é alterada.

Há muitas respostas aqui, mas nenhuma delas atendeu às minhas necessidades. Eu queria uma resposta real para a pergunta nº 1 do autor. Como sei quando uma imagem é atualizada no hub.docker.com?

O script abaixo pode ser executado diariamente. Na primeira execução, ele obtém uma linha de base das tags e atualiza as datas do registro do HUB e as salva localmente. Desde então, toda vez que é executado, ele verifica o registro em busca de novas tags e datas de atualização. Como isso muda toda vez que uma nova imagem existe, informa se a imagem base foi alterada. Aqui está o script:

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

Você deseja alterar a DATAPATHvariável na parte superior e o comando de notificação por email no final para atender às suas necessidades. Para mim, eu tenho o SSH em um servidor em outra rede onde meu SMTP está localizado. Mas você também pode usar o mailcomando facilmente .

Agora, você também deseja verificar os pacotes atualizados dentro dos próprios contêineres. Isso é provavelmente mais eficaz do que fazer um "puxão" quando seus contêineres estiverem funcionando. Aqui está o script para fazer isso:

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

Outra abordagem pode ser assumir que sua imagem de base fica para trás rapidamente (e é muito provável que isso aconteça) e forçar outra compilação de imagem de seu aplicativo periodicamente (por exemplo, toda semana) e depois reimplantá-lo se ele tiver sido alterado.

Até onde eu sei, imagens de base populares como o Debian ou Java oficial atualizam suas tags para atender a correções de segurança, para que as tags não sejam imutáveis ​​(se você quiser uma garantia mais forte de que precisa usar a referência [image: @digest ], disponível nas versões mais recentes do Docker). Portanto, se você construir sua imagem docker build --pull, seu aplicativo deverá obter a melhor e mais recente etiqueta de imagem básica à qual você está referenciando.

Como as tags mutáveis ​​podem ser confusas, é melhor aumentar o número da versão do seu aplicativo toda vez que você fizer isso, para que pelo menos do seu lado tudo fique mais limpo.

Portanto, não tenho certeza de que o script sugerido em uma das respostas anteriores funcione, pois ele não reconstrói a imagem do aplicativo - apenas atualiza a tag da imagem base e reinicia o contêiner, mas o novo contêiner ainda faz referência o antigo hash da imagem base.

Eu não recomendaria a execução de tarefas do tipo cron em contêineres (ou qualquer outro processo, a menos que seja realmente necessário), pois isso contraria o mantra de executar apenas um processo por contêiner (existem vários argumentos sobre por que isso é melhor, então eu ' não vou entrar aqui).

Não vou entrar na questão de saber se você deseja ou não atualizações autônomas na produção (acho que não). Só estou deixando isso aqui para referência, caso alguém ache útil. Atualize todas as imagens do docker para a versão mais recente com o seguinte comando no seu terminal:

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

ATUALIZAÇÃO: Use Dependabot - https://dependabot.com/docker/

BLUF: encontrar o ponto de inserção correto para monitorar alterações em um contêiner é o desafio. Seria ótimo se o DockerHub resolvesse isso. (Os links do repositório foram mencionados, mas observe ao configurá-los no DockerHub - " Acione uma compilação neste repositório sempre que a imagem base for atualizada no Docker Hub. Funciona apenas para imagens não oficiais." )

Enquanto tentava resolver isso sozinho, vi várias recomendações para webhooks, por isso queria elaborar algumas soluções que usei.

1. Use o microbadger.com para rastrear alterações em um contêiner e use o recurso de webhook de notificação para acionar uma ação. Configurei isso com o zapier.com (mas você pode usar qualquer serviço personalizável de webhook) para criar um novo problema no meu repositório do github que usa o Alpine como imagem de base.

   • Prós: Você pode revisar as alterações relatadas pelo microbadger no github antes de tomar uma ação.
   • Contras: O Microbadger não permite rastrear uma tag específica. Parece que apenas rastreia 'mais recentes'.

2. Acompanhe o feed RSS para as confirmações do git em um contêiner upstream. ex. https://github.com/gliderlabs/docker-alpine/commits/rootfs/library-3.8/x86_64 . Usei o zapier.com para monitorar este feed e acionar uma compilação automática do meu contêiner no Travis-CI sempre que algo for confirmado. Isso é um pouco extremo, mas você pode alterar o gatilho para fazer outras coisas, como abrir um problema no seu repositório git para intervenção manual.

   • Prós: Mais perto de um pipline automatizado. A construção do Travis-CI apenas verifica se o seu contêiner tem problemas com o que foi confirmado no repositório de imagens base. Depende de você se o seu serviço de IC tomar outra ação.
   • Contras: acompanhar o feed de confirmação não é perfeito. Muitas coisas são comprometidas com o repositório que não afetam a construção da imagem base. Não leva em consideração nenhum problema com a frequência / número de confirmações e qualquer otimização da API.

Premissa para a minha resposta:

1. Os contêineres são executados com tags.
2. A mesma tag pode ser apontada para UUID de imagem diferente, conforme desejamos.
3. As atualizações feitas em uma imagem podem ser confirmadas em uma nova camada de imagem

Abordagem

1. Crie todos os contêineres em primeiro lugar com um script de atualização de patch de segurança
2. Crie um processo automatizado para os seguintes
   • Execute uma imagem existente para um novo contêiner com script de patch de segurança como o comando
   • Confirme as alterações na imagem como
     • tag existente -> seguida pela reinicialização dos contêineres, um por um
     • nova tag de versão -> substitua alguns contêineres por uma nova tag -> validar -> mova todos os contêineres para a nova tag

Além disso, a imagem de base pode ser atualizada / o contêiner com uma nova imagem de base completa pode ser construído em intervalos regulares, conforme o mantenedor achar necessário

Vantagens

1. Estamos preservando a versão antiga da imagem enquanto criamos a nova imagem corrigida de segurança; portanto, podemos reverter para a imagem em execução anterior, se necessário
2. Estamos preservando o cache do docker, portanto, menos transferência de rede (somente a camada alterada entra em ação)
3. O processo de atualização pode ser validado na preparação antes de passar para prod
4. Este pode ser um processo controlado, portanto, os patches de segurança somente quando necessários / considerados importantes podem ser enviados.

As respostas acima também estão corretas

Existem duas abordagens

1. Use webhooks
2. Execute o script a cada minuto específico para obter novas imagens das janelas de encaixe

Estou apenas compartilhando script, pode ser que seja útil para você! Você pode usá-lo com cronjob, tentei com sucesso no 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

Aqui está o meu arquivo 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

Aqui está uma maneira mais simples de atualizar o contêiner do docker automaticamente

Coloque o trabalho via $ crontab -e:

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

Crie o diretório ~/.dockercom o arquivo 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

você já tentou isso: https://github.com/v2tec/watchtower . é uma ferramenta simples em execução no contêiner do docker que observa outros contêineres; se a imagem base for alterada, ela será puxada e reimplantada.

Uma solução simples e ótima é pastor