Jak automatycznie aktualizować kontenery docker, jeśli obrazy bazowe są aktualizowane

Używamy skryptu, który sprawdza, czy uruchomiony kontener jest uruchomiony z najnowszym obrazem. Używamy również skryptów startowych init do uruchamiania obrazu dokera.

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

I init wygląda jak

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

'docker way' to użycie Docker hub automated builds . Funkcja repozytorium Links odbuduje kontener po przebudowaniu kontenera macierzystego, a funkcja Webhooks wyśle Ci powiadomienie.

Wygląda na to, że webhooki są ograniczone do wywołań HTTP POST. Musisz skonfigurować usługę, aby je złapać, a może użyć jednej z usług poczty e-mail.

Nie sprawdzałem, ale NOWY Docker Uniwersalna płaszczyzna Sterowania może mieć funkcję wykrywania zaktualizowanych kontenerów i ponownego wdrażania.

Miałem ten sam problem i pomyślałem, że można go po prostu rozwiązać, dzwoniąc codziennie do pracy crona.

Moim zamiarem jest to automatyczne i szybkie rozwiązanie, aby upewnić się, że kontener produkcyjny jest bezpieczny i aktualizowany, ponieważ może mi zająć trochę czasu, aby zaktualizować moje obrazy i wdrożyć nowy obraz dokera z najnowszymi aktualizacjami zabezpieczeń.

Możliwe jest również zautomatyzowanie tworzenia i wdrażania obrazów za pomocą Github hooks

I ' ve created a basic docker image dzięki temu automatycznie sprawdza i instaluje aktualizacje zabezpieczeń codziennie(może być uruchamiany bezpośrednio przez docker run itech/docker-unattended-upgrade).

Natknąłem się również na inne podejście , aby sprawdzić, czy kontener wymaga aktualizacji.

Moja pełna realizacja:

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

Helper scripts

install

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

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

Edit

Opracowałem małe narzędzie docker-run , które działa jako kontener Dockera i może być używane do aktualizacji pakietów wewnątrz wszystkich lub wybranych działających kontenerów, może być również używane do uruchamiania dowolnych poleceń.

Można łatwo przetestować za pomocą następującego polecenia:

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

, które domyślnie wykona date polecenie we wszystkich uruchomionych kontenerach i wyświetli wyniki. Jeśli przekażesz update zamiast exec, to wykonasz apt-get update, a następnie apt-get upgrade -y we wszystkich uruchomionych kontenerach

Możesz użyć Watchtower, aby obserwować aktualizacje obrazu, z którego powstaje kontener, i automatycznie pobrać aktualizację i ponownie uruchomić kontener przy użyciu zaktualizowanego obrazu. Jednak nie rozwiązuje to problemu przebudowy własnych obrazów niestandardowych, gdy nastąpi zmiana obrazu, na którym jest oparty. Można to zobaczyć jako dwuczęściowy problem: (1) wiedząc, kiedy obraz został zaktualizowany i (2) robi rzeczywisty obraz odbudować. (1) można rozwiązać dość łatwo, ale (2) zależy w dużej mierze od Twojego lokalnego środowiska/praktyk budowania, więc prawdopodobnie znacznie trudniej jest stworzyć uogólnione rozwiązanie.

Jeśli jesteś w stanie korzystać z Docker Hub ' s automated builds , cały problem można rozwiązać stosunkowo czysto za pomocą funkcji repozytorium links , która pozwala na automatyczne wywołanie odbudowy po zaktualizowaniu połączonego repozytorium (prawdopodobnie upstream). Możesz również skonfigurować webhook , aby powiadamiać Cię o automatycznym powstaje. Jeśli chcesz otrzymywać powiadomienia e-mail lub SMS, możesz podłączyć webhook do IFTTT Maker . Uważam, że interfejs użytkownika IFTTT jest trochę mylący, ale skonfigurowałbyś Docker webhook, aby pisał do https://maker.ifttt.com/trigger/docker_xyz_image_built/ with / key/your_key.

Jeśli chcesz budować lokalnie, możesz przynajmniej rozwiązać problem otrzymywania powiadomień po zaktualizowaniu obrazu macierzystego, tworząc atrapę repo w Docker Hub połączonym z Twoim repo odsetki. Jedynym celem atrapy repo byłoby uruchomienie webhooka po jego przebudowie (co oznacza, że jeden z jego połączonych repo został zaktualizowany). Jeśli jesteś w stanie otrzymać ten webhook, możesz nawet użyć go do uruchomienia odbudowy po twojej stronie.

Nie wiedziałbyś, że Twój kontener jest w tyle bez uruchomienia Docker pull . Następnie musisz przebudować lub przekomponować swój obraz.

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

Polecenia mogą być umieszczone w skrypcie wraz ze wszystkim innym niezbędnym do ukończenia aktualizacji, chociaż odpowiedni kontener nie będzie potrzebował niczego dodatkowego.

Nie będę wdawać się w całe pytanie, czy chcesz, czy nie, aktualizacje bez nadzoru w produkcji (myślę, że nie). Zostawiam to w celach informacyjnych, gdyby ktoś uznał to za przydatne. Zaktualizuj wszystkie obrazy dokera do najnowszej wersji za pomocą następującego polecenia w Terminalu:

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

Innym podejściem może być założenie, że bazowy obraz dość szybko się opóźnia (co jest bardzo prawdopodobne), i wymuszenie okresowo (np. co tydzień) kolejnej kompilacji obrazu aplikacji, a następnie ponowne wdrożenie, jeśli ulegnie zmianie.

Z tego, co wiem, popularne obrazy bazowe, takie jak oficjalny Debian czy Java, aktualizują swoje znaczniki, aby zapewnić poprawki bezpieczeństwa, więc znaczniki nie są niezmienne (jeśli chcesz mieć silniejszą gwarancję, musisz użyć referencji [1]). image:@digest], dostępne w nowszych wersjach Dockera). Dlatego, jeśli chcesz zbudować swój obraz za pomocą docker build --pull, Twoja aplikacja powinna uzyskać najnowszy i największy z podstawowego tagu obrazu, do którego się odnosisz.

Ponieważ zmienne znaczniki mogą być mylące, najlepiej jest zwiększyć numer wersji aplikacji za każdym razem, gdy to robisz, aby przynajmniej po twojej stronie rzeczy były czystsze.

Więc nie jestem pewien, czy skrypt zasugerowany w jednej z poprzednich odpowiedzi spełnia swoje zadanie, ponieważ nie Przebuduj obraz aplikacji - po prostu aktualizuje znacznik obrazu podstawowego, a następnie uruchamia ponownie kontener, ale nowy kontener nadal odwołuje się do starego skrótu obrazu podstawowego.

Nie opowiadałbym się za uruchamianiem zadań typu cron w kontenerach (lub jakichkolwiek innych procesach, chyba że jest to naprawdę konieczne), ponieważ jest to sprzeczne z mantrą uruchamiania tylko jednego procesu na kontener (istnieją różne argumenty na temat tego, dlaczego jest to lepsze, więc nie będę się w to wdawał tutaj).

Przesłanka do mojej odpowiedzi:

1. kontenery są uruchamiane tagami.
2. ten sam znacznik może być skierowany do innego identyfikatora uuid obrazu, jeśli chcemy / uważamy za stosowne.
3. aktualizacje obrazu mogą być przypisane do nowej warstwy obrazu

Podejście

1. Zbuduj wszystkie kontenery w pierwszej kolejności za pomocą skryptu aktualizacji poprawek zabezpieczeń
2. Zbuduj zautomatyzowany proces dla następujących
   • Uruchom istniejący obraz do nowego kontenera z skrypt poprawki bezpieczeństwa jako polecenie
   • zatwierdź zmiany w obrazie jako
     • istniejący znacznik - > po którym następuje ponowne uruchomienie kontenerów jeden po drugim
     • new version tag - > replace few containers with new tag -> validate - > move all containers to new tag

DODATKOWO, obraz bazowy może być uaktualniany/ kontener z zupełnie nowym obrazem bazowym może być budowany w regularnych odstępach czasu, zgodnie z odczuciem opiekuna necessary

Zalety

1. zachowujemy starą wersję obrazu podczas tworzenia nowego poprawionego obrazu bezpieczeństwa, dlatego w razie potrzeby możemy cofnąć do poprzedniego uruchomionego obrazu
2. zachowujemy pamięć podręczną Dockera, a więc mniej transferu sieciowego (tylko zmieniona warstwa dostaje się na przewód)
Proces aktualizacji można zweryfikować w staging przed przejściem do prod
3. może to być kontrolowany proces, stąd łatki bezpieczeństwa tylko wtedy, gdy konieczne / uznane za ważne można pchnąć.

Zarządzanie zależnościami dla obrazów Dokerów jest prawdziwym problemem. Jestem częścią zespołu, który zbudował narzędzie, MicroBadger , aby pomóc w tym, monitorując obrazy kontenerów i sprawdzając metadane. Jedną z jego funkcji jest umożliwienie skonfigurowania webhooka powiadomień, który zostanie wywołany, gdy zmieni się interesujący Cię obraz (np. obraz podstawowy).

Jest tu wiele odpowiedzi, ale żadna nie odpowiadała moim potrzebom. Chciałem odpowiedzi na pytanie #1 pytającego. Skąd mam wiedzieć, kiedy obraz jest aktualizowany na hub.docker.com?

Poniższy skrypt może być uruchamiany codziennie. Przy pierwszym uruchomieniu pobiera linię bazową znaczników i dat aktualizacji z rejestru HUB i zapisuje je lokalnie. Od tego czasu za każdym razem, gdy jest uruchomiony, sprawdza rejestr pod kątem nowych tagów i dat aktualizacji. Ponieważ zmienia się to za każdym razem, gdy pojawia się nowy obraz, mówi nam, czy obraz bazowy się zmienił. Oto skrypt:

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

Będziesz chciał zmienić zmienną DATAPATH u góry i zmienić polecenie powiadomienia e-mail na końcu, aby dostosować się do swoich potrzeb. Dla mnie mam go SSH na serwer w innej sieci, gdzie znajduje się mój SMTP. Ale możesz też łatwo użyć polecenia mail.

Teraz chcesz również sprawdzić zaktualizowane pakiety wewnątrz samych kontenerów. Jest to prawdopodobnie bardziej skuteczne niż "ciągnięcie", gdy kontenery są pracuję. Oto skrypt, aby to zrobić:

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

Powyższe odpowiedzi są również poprawne

Istnieją dwa podejścia

1. Użyj webhooków
2. Uruchom skrypt dla każdej konkretnej minuty, aby uzyskać świeże pobieranie obrazów dokera

Ja tylko dzielę się skryptem może być to pomocne dla Ciebie! Możesz go używać z cronjob, próbowałem z powodzeniem na 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

Oto mój plik 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