Come aggiornare automaticamente il vostro mobile contenitori, se di base-le immagini vengono aggiornate

Dire che ho un banale contenitore in base al ubuntu:latest. Ora c’è un aggiornamento di sicurezza e ubuntu:latest è stato aggiornato nella finestra mobile repo .

  1. Come faccio a sapere la mia immagine locale e i relativi contenitori sono in esecuzione dietro?

  2. C’è qualche best practice per l’aggiornamento automatico di immagini locali e contenitori per seguire la finestra mobile repo updates, che in pratica sarebbe di dare la stessa sottigliezze di avere unattended-upgrades in esecuzione su un convenzionale ubuntu-macchina

  • Sto cercando una risposta a questa dall’inizio del mobile. Suo anche un po ‘ più complicato. Se installo apache (per esempio) e che viene aggiornato, la base dell’immagine non cambia, dal momento che l’ho installato in seguito. Vorrei comunque gli aggiornamenti automatici per apache. In realtà ho chiesto su IRC questo e l’ho “seguire a monte e ricostruire su aggiornamenti” come risposta…
  • Io non sono contento solo chiedendo. Sembra che lo sviluppo e la riproducibilità è più importante per la finestra mobile devs che sensato meccanismi di aggiornamento che abbiamo avuto per anni.
  • Il problema è che la finestra mobile è solo la tecnologia per i contenitori. Penso che ha bisogno di qualche tempo per un ecosistema di evolvere in giro che. Ci sono altri problemi di finestra mobile non affrontare la registrazione.
  • Grazie a tutti coloro che hanno risposto. Mi dispiace non ho potuto dividere il bottino. Anche se non c’era soluzione definitiva al mio problema, c’era una buona input da parte di tutti voi.
  • Per @Mathias, la soluzione che ho appena aggiunto uno script di controllo per gli aggiornamenti di sicurezza per i pacchetti installati nel contenitore post-pull. Essa ha anche uno script separato per il controllo dell’immagine di base.
  • Regola generale: non mettere qualcosa in un contenitore che non è possibile generare attraverso l’automazione più tardi.

InformationsquelleAutor hbogert | 2014-10-17



16 Replies
  1. 6

    Uno dei modi per farlo è quello di guidare attraverso la CI/CD sistemi. Una volta che il genitore è stato costruito a immagine, qualcosa che scansiona il tuo git repository di immagini utilizzando il genitore. Se trovato, devi inviare una richiesta di pull urto nuove versioni dell’immagine. La richiesta di pull, se tutti i test passano, sarebbe fusa e ti piacerebbe avere un nuovo bambino immagine basata sull’aggiornamento del genitore. Un esempio di strumento che prende questo approccio può essere trovato qui: https://engineering.salesforce.com/open-sourcing-dockerfile-image-update-6400121c1a75 .

    Se non hai il controllo di un genitore immagine, come sarebbe il caso se lei è a seconda ufficiale ubuntu immagine, è possibile scrivere alcuni utensili, che rileva i cambiamenti nel genitore tag di immagine e di richiamare i bambini immagine costruisce di conseguenza.

    • Wow questo è un grande martello, che ha detto: da quando ho fatto questa domanda ho anche capito che il server di compilazione è il luogo per affrontare questo problema. Sono contento di vedere alcuni utensili. Se spieghi il tuo approccio generico concetti (e non è il tuo strumento esatto/implementazione) in risposta io probabilmente accettare.
    • Grazie @hbogert ho modificato il sopra e includono anche un idea su cosa fare se avete a che fare con la pubblica immagini
  2. 114

    Si utilizza uno script che controlla se un container in esecuzione è iniziata con l’ultima immagine. Facciamo anche uso di upstart script di init per avviare la finestra mobile di immagine.

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

    docker run -t -i --name $NAME $im /bin/bash
    
    • Grazie mille per questo prezioso contributo. Questo mi sembra un buon modo per aggiornare l’immagine di base. Il restante domanda è, come fare l’aggiornamento di un’applicazione (ad esempio apache) che è stato installato per la distribuzione in dockerfile? O dovete utilizzare ready-made di base di immagini che solo bisogno del vostro codice dell’applicazione (ad esempio un sito web)?
    • Usiamo packer e burattini per configurare le nostre immagini. Le nostre immagini sono pronto ad andare in produzione dopo la loro creazione
    • vedere la mia cura rispondere ho un piccolo strumento mobile-run che sto usando per aggiornare linux (debian/ubuntu) pacchetti in tutti i container in esecuzione.
    • Se un’immagine ha lo stesso nome di un contenitore (ad esempio redis), LATEST=`docker inspect --format "{{.Id}}" $IMAGE` saranno mostrati anche il contenitore di informazioni. Aggiungere --type image per risolvere questo problema.
    • Grazie per il tuo post. L’ho modificata per avvolgere il tutto all’interno di un ciclo di ottenere immagini da mobile: for IMAGE in $(docker ps --format {{.Image}} -q | sort -u)
  3. 21

    Una ‘finestra mobile’ via sarebbe quella di utilizzare mobile hub le generazioni automatiche. Il Repository Link funzione ricostruire il vostro contenitore, quando a monte contenitore è ricostruita, e il Webhooks funzione invieremo una notifica.

    Sembra che il webhooks sono limitati a chiamate POST HTTP. È necessario impostare un servizio per la cattura di loro, o forse utilizzare uno dei POST di servizi e-mail là fuori.

    Non ho guardato, ma il nuovo Mobile Universale Del Piano Di Controllo potrebbe avere una funzione per il rilevamento aggiornato contenitori e ri-distribuzione.

  4. 19

    È possibile utilizzare Torre di guardia guardare per gli aggiornamenti l’immagine di un contenitore, viene creata un’istanza da e recuperare automaticamente l’aggiornamento e riavviare il contenitore, usando l’immagine aggiornata. Tuttavia, questo non risolve il problema della ricostruzione di immagini personalizzate quando c’è un cambiamento a monte immagine si basa su. Si potrebbe vedere questo come un doppio problema: (1) sapere quando un monte immagine è stata aggiornata, e (2) che fa l’immagine vera e propria ricostruzione. (1) può essere risolto abbastanza facilmente, ma (2) dipende molto dal tuo locale ambiente di compilazione/pratiche, quindi è probabilmente molto più difficile creare un generalizzato soluzione per questo.

    Se siete in grado di utilizzare la finestra Mobile Hub le generazioni automatiche, tutto il problema può essere risolto relativamente pulito utilizzando il repository link caratteristica, che consente di attivare una ricostruzione automaticamente quando collegato repository (probabilmente a monte) è aggiornato. È inoltre possibile configurare un webhook di notifica quando una generazione automatica si verifica. Se vuoi un e-mail o SMS di notifica, è possibile collegare il webhook per IFTTT Maker. Ho trovato il IFTTT interfaccia utente di essere una sorta di confusione, ma è necessario configurare la finestra Mobile webhook pubblicare https://maker.ifttt.com/trigger/docker_xyz_image_built/con/chiave/your_key.

    Se avete bisogno di costruire localmente, si può almeno risolvere il problema di ottenere le notifiche quando un monte immagine viene aggiornata con la creazione di un manichino repo nella finestra Mobile Hub collegato al tuo repo(s) di interesse. L’unico scopo del manichino repo sarebbe quella di attivare un webhook quando viene ricostruito (il che implica una sua collegata repos è stato aggiornato). Se siete in grado di ricevere questo webhook, è anche possibile utilizzare che per attivare una ricostruzione su un fianco.

    • Torre di guardia utilizza la finestra mobile socket però. Da un punto di vista della sicurezza che dà accesso root alla macchina host.
    • Inoltre, Torre di guardia non sembra essere in grado di aggiornare le immagini da privato repository diversi da scaricatore di porto Hub. Una fregatura per noi che utilizzare Azure.
    • È possibile utilizzare privato registri utilizzando REPO_USER e REPO_PASS variabili di ambiente. Date un’occhiata readme.md presso la Torre di guardia per maggiori informazioni: github.com/v2tec/watchtower#usage
    • Parola di avvertimento, torre di guardia è abbandonato dai suoi manutentore, e l’immagine in DockerHub non è ancora aggiornato con quello di github.
  5. 9

    Ho avuto lo stesso problema e ho pensato che può essere semplicemente risolto con un cron job chiamata unattended-upgrade quotidiana.

    La mia intenzione è di avere questo come automatica e rapida soluzione per garantire che la produzione del contenitore è sicuro e aggiornato, perché a me a volte per aggiornare le mie immagini e distribuire una nuova finestra mobile immagine con gli ultimi aggiornamenti di sicurezza.

    È anche possibile automatizzare la generazione di immagine e di distribuzione con Github ganci

    Ho creato una base mobile immagine con che controlla automaticamente e installa gli aggiornamenti di sicurezza al giorno (può essere eseguito direttamente da docker run itech/docker-unattended-upgrade ).

    Ho anche incontrato un altro di diversa approccio per verificare se il contenitore ha bisogno di un aggiornamento.

    Mia completa attuazione:

    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
    

    Script di supporto

    installare

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

    inizio

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

    Modifica

    Ho sviluppato un piccolo strumento mobile-eseguire che viene eseguito come mobile contenitore e può essere utilizzato per aggiornare i pacchetti all’interno di tutti o selezionati in esecuzione contenitori, può anche essere utilizzato per eseguire eventuali comandi arbitrari.

    Può essere facilmente testato con il seguente comando:

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

    che, per impostazione predefinita verrà eseguito date di comando in tutti i container in esecuzione e visualizzare i risultati. Se si passa update invece di exec eseguirà apt-get update seguita da apt-get upgrade -y in tutti i container in esecuzione

    • il mio riferimento alle automatica-aggiornamento era solo per mostrare l’analogia in un non-mobile ambiente. Il mio intento è quello di risolvere questo la finestra mobile modo (se esiste oc.) Con un ulteriore processo in un contenitore batte lo scopo di finestra mobile imo. Non patch il problema del ritardo tra monte di aggiornare la propria immagine e per voi, l’utente, in realtà depoying sopra il contenitore corrente. Anche se questo può richiedere fino a 1 giorno con unattended-upgrades così, così.. Anche github di riferimento non è soddisfacente, perché il meccanismo di aggiornamento è ora fortemente dipendente dal sistema operativo host.
    • La “finestra mobile modo in cui” non impedire l’esecuzione di altri processi nello stesso contenitore, se essi sono strettamente connessi, e non creare scalabilità collo di bottiglia. E questo particolare caso d’uso è un buon esempio di quando si può avere un contenitore con un altro processo in esecuzione. (ad esempio vedi immagine gitlab come funziona di più obbligatorio processi nello stesso contenitore).
    • Io non definirei un meccanismo di aggiornamento strettamente legate alla funzione principale di un’immagine. Questa soluzione è come dare ogni tipo di applicazione su una macchina convenzionale, il suo proprio meccanismo di aggiornamento, invece di mettere il peso su di un gestore di pacchetti. Anche se è una soluzione, non risponde alla mia domanda, aggiornando automaticamente le immagini locali e, quindi, i contenitori devono essere rieseguito. Con l’aggiornamento in contenitori stessi siamo l’introduzione di un sacco di stato di nuovo di cui non abbiamo idea, che è contro la finestra mobile modo (sempre imho).
    • Potreste avere bisogno di qualcosa di più elevato livello di finestra mobile, ad esempio Kubernetes, che è utile per le grandi infrastrutture di distribuzione, ma è ancora in fase di sviluppo da parte di Google. Al momento, è possibile automatizzare questo con un strumento di provisioning come Ansible in un modo abbastanza semplice.
    • Il citato “approccio diverso” potrebbe essere quello che stavo cercando. Il vostro contributo presenta come una valida alternativa per “grasso contenitori”. Io sicuramente aspetto sia un po ‘ di più, grazie per la tua risposta.
  6. 7

    Non si sa contenitore è dietro, senza l’esecuzione di mobile tirare. Quindi avresti bisogno di ricostruire o ricomporre immagine.

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

    I comandi possono essere inseriti in un copione, con quant’altro necessario a completare l’aggiornamento, anche se un apposito contenitore non avrebbe bisogno di qualcosa di aggiuntivo.

    • 1: ok, ma poi avrei dovuto guardare tutte le immagini, ottenere la loro base di immagini, tirare quelle. Quindi ricostruire le immagini la cui base le immagini sono state modificate. Quindi smettere di contenitori la cui immagine è cambiata e ricreare i contenitori con la ‘finestra mobile di esecuzione’ e i parametri necessari. Questo sembra eccessivamente manuale. Ma se questo è lo status quo, quindi io accettare la risposta.
    • Si prega di attendere prima di accettare. Forse c’è qualcosa là fuori. Sto usando la finestra mobile per 6 mesi, ma non sono stati al passo con gli ultimi sviluppi.
    • In qualche modo, al suo interno, la finestra Mobile è in grado di confrontare le immagini al fine di svolgere la sua ‘cache’ capacità. Forse si può trovare un modo per sfruttare CHE. In altre parole, controllare per vedere se il sottostante immagini (tutto il viaggio di ritorno alla base) è cambiato e quindi innescare un processo di ricostruzione. Purtroppo, la memorizzazione nella cache non vi aiuterà in questo caso: l’intera immagine viene ricostruita, perché l’immagine di base è cambiato.
  7. 4

    Non ho intenzione in tutta la questione di se o non si desidera automatica di aggiornamenti in produzione (penso di no). Sto solo lasciando questo qui per riferimento nel caso in cui qualcuno lo trova utile. Aggiornare tutti i docker immagini per la versione più recente con il seguente comando nel terminale:

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

    • Il comando è utile per l’aggiornamento di tutte le immagini, ma non cambia nulla in esecuzione in produzione. I contenitori ancora derivano da vecchie immagini, che ora sono senza tag.
    • Vero. E qui c’è un di più per i libri… Uso # docker system prune -a --volumes -f per pulire i vecchi (svincolato), le immagini, i volumi, etc.
  8. 4

    Dipendenza di gestione per la finestra Mobile di immagini, è un problema reale. Faccio parte di un team che ha realizzato un tool, MicroBadger per aiutare con questo monitoraggio contenitore di immagini e di ispezione di metadati. Una delle sue caratteristiche è che ti consente di impostare una notifica webhook che viene chiamata quando un’immagine che ti interessa (ad esempio un’immagine di base) modifiche.

  9. 4

    Ci sono un sacco di risposte qui, ma nessuno di loro è più adatto alle mie esigenze. Volevo una risposta concreta a asker #1 domanda. Come faccio a sapere quando un’immagine viene aggiornata hub.docker.com?

    Il seguente script può essere eseguito ogni giorno. Alla prima esecuzione, si ottiene una linea di base dei tag e aggiornamento date dal MOZZO del registro di sistema e li salva in locale. Da allora, ogni volta che viene eseguito, esso controlla il registro per i nuovi tag e aggiornare le date. Dal momento che questo cambia ogni volta che una nuova immagine esiste, ci dice se l’immagine di base è cambiato. Questo è lo 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: [email protected]${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;
    

    Si desidera modificare il DATAPATH variabile in cima, e modificare l’email di notifica di comando al fine di soddisfare le vostre esigenze. Per me, l’ho SSH ad un server su un’altra rete dove il mio SMTP è situato. Ma si può facilmente utilizzare il mail comando, troppo.

    Ora, anche voi volete controllare i pacchetti aggiornati all’interno dei contenitori stessi. Questo in realtà è probabilmente più efficace di fare una “tirata” una volta che i contenitori sono di lavoro. Ecco lo script per tirare fuori che:

    #!/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: [email protected]${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
    
    • mkdir in primo script, probabilmente, dovrebbe essere: mkdir -p inoltre, il primo script confronta VAR1 contro VAR2, si supponga che dovrebbe confrontare il VECCHIO contro il NUOVO. Se vero, questo significa che questo script non davvero fare quello che OP vogliono, a MENO che non fosse prima esecuzione al momento dell’installazione. Che è, non è davvero la determinazione di nulla di quello che è installato, solo se i risultati differiscono dalle precedenti corre…
  10. 4

    Un altro approccio potrebbe essere quello di assumere che l’immagine di base si mette dietro abbastanza rapidamente (il che è molto probabile che accada), e la forza di un’altra generazione di immagine della vostra applicazione periodicamente (ad esempio ogni settimana) e poi ri-distribuire se è cambiato.

    Per quanto posso dire, popolare immagini di base come ufficiale di Debian o di aggiornamento di Java le loro etichette per soddisfare le correzioni di sicurezza, in modo che i tag non sono immutabili (se si desidera una più forte garanzia di che avete bisogno per utilizzare il riferimento [image:@digest], disponibile in più recenti versioni Mobile). Pertanto, se si desidera costruire la vostra immagine con docker build --pull, l’applicazione dovrebbe ottenere l’ultima e più grande dell’immagine di base dei tag ti stai riferendo.

    Dal mutevole tag possono essere fonte di confusione, è meglio per incrementare il numero di versione dell’applicazione ogni volta che si fa questo in modo che almeno su un lato, le cose sono più puliti.

    Quindi non sono sicuro che lo script suggerito in una delle risposte precedenti e fa il lavoro, dal momento che non rigenerare l’applicazione dell’immagine – aggiorna solamente l’immagine di base dei tag e poi riavvia il contenitore, ma il nuovo contenitore fa ancora riferimento alla vecchia base hash dell’immagine.

    Non vorrei avvocato per l’esecuzione di cron-lavori in contenitori (o di eventuali altri processi, se non proprio necessario) questo va contro il mantra di esecuzione di un processo per contenitore (ci sono vari argomenti sul perché questo è meglio, così non ho intenzione di andare in qui).

  11. 3

    Premessa alla mia risposta:

    1. Contenitori vengono eseguiti con i tag.
    2. Lo stesso tag, può essere indicata immagine diversa UUID come noi, per favore ritieni opportuno.
    3. Gli aggiornamenti fatti per un’immagine può essere impegnato in un nuovo livello immagine

    Approccio

    1. Costruire tutti i contenitori, in primo luogo, con una sicurezza che la patch di aggiornamento di script
    2. Costruire un processo automatizzato per la seguente
      • Eseguire un’immagine esistente al nuovo contenitore con patch di protezione script come il comando
      • Eseguire il Commit delle modifiche all’immagine
        • tag esistente -> seguito da riavviare i contenitori, uno per uno,
        • nuova versione di tag -> sostituire alcuni contenitori con la nuova tag -> convalidare -> spostare tutti i contenitori per i nuovi tag

    Inoltre, l’immagine di base può essere aggiornato/contenitore con un completo nuova immagine di base può essere costruito a intervalli regolari, come il manutentore si sente necessario

    Vantaggi

    1. Stiamo conservando la vecchia versione dell’immagine, mentre la creazione di nuove patch di sicurezza di immagine, quindi possiamo rollback alla precedente immagine in esecuzione, se necessario
    2. Stiamo conservando la finestra mobile di cache, e quindi meno il trasferimento in rete (solo cambiato strato di sale sul filo)
    3. Il processo di aggiornamento può essere convalidato in sosta, prima di trasferirsi a prod
    4. Questo può essere un processo controllato, quindi le patch di sicurezza solo quando necessario/opportuno può essere spinto.
    • In un ambiente di produzione, anche se sono aggiornamenti di sicurezza, dubito che si vorrebbe avere automatica di aggiornamenti!!! Se avendo automatica degli aggiornamenti è necessario, il processo può essere eseguito a intervalli regolari, a seconda di come un cron job.
    • La mia premessa è che gli aggiornamenti di sicurezza dovrebbe venire da monte/immagini di base.
    • Io direi piuttosto che c’è una bella linea di differenziazione tra la teoria e la pratica. Quando le cose vengono in pratica, ci saranno molti aspetti esterni che devono essere presi in considerazione, come: i costi (non solo il valore del dollaro, ma anche di tempo) associati all’implementazione.
  12. 2

    Risposte di cui sopra sono corrette

    Ci sono due Approccio

    1. Utilizzare webhooks
    2. Di eseguire lo script, per ogni specifica minuti per ottenere fresca tirare di finestra mobile immagini

    Condivido script possono essere utili per voi!
    Si può utilizzare con cronjob, ho provato con successo su 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
    

    Qui è la mia finestra mobile-comporre file

    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
    
  13. 2

    AGGIORNAMENTO: Utilizzare Dependabot – https://dependabot.com/docker/

    BLUF: trovare il giusto punto di inserimento per il monitoraggio dei cambiamenti di un contenitore, è la sfida. Sarebbe bello se DockerHub potrebbe risolvere questo. (Repository Link sono stati citati, ma nota quando si imposta su DockerHub – “Innescare una build in questo repository ogni volta che l’immagine di base è aggiornato su Mobile Hub. Funziona solo per i non-immagini ufficiali.”)

    Durante il tentativo di risolvere questo io ho visto una serie di raccomandazioni per webhooks così ho voluto approfondire un paio di soluzioni che ho usato.

    1. Uso microbadger.com per tenere traccia delle modifiche in un contenitore e l’uso
      notifica webhook funzione per attivare un’azione. Questa
      con zapier.com (ma è possibile utilizzare qualsiasi personalizzabile webhook servizio)
      per creare un nuovo problema nel mio repository github che utilizza Alpino come un
      immagine di base.

      • Pro: È possibile rivedere le modifiche segnalate da microbadger in github prima di agire.
      • Contro: Microbadger non consente di tenere traccia di un tag specifico. Sembra che solo i brani ‘ultima’.
    2. Traccia il feed RSS per git commit a monte del contenitore. ex. https://github.com/gliderlabs/docker-alpine/commits/rootfs/library-3.8/x86_64. Ho usato zapier.com per monitorare questo feed e per innescare un meccanismo automatico di costruire il mio contenitore in Travis-CI in qualsiasi momento qualcosa si è impegnato. Questo è un po ‘ estrema, ma è possibile modificare il trigger per fare altre cose, come aprire un problema nel tuo repository git per un intervento manuale.

      • Pro: più Vicino ad un sistema automatizzato di pipline. La Travis-CI costruire solo controlla per vedere se il contenitore ha problemi con tutto ciò che era impegnata a base repository di immagini. Spetta a voi se il vostro servizio CI prende ogni ulteriore azione.
      • Contro: verifica il commit di alimentazione non è perfetto. Un sacco di cose avere commesso il repository che non influenzano la generazione dell’immagine di base. Non tener conto di eventuali problemi con frequenza/numero di commit e tutte le API di limitazione.
  14. 0

    Una semplice e la soluzione ideale è pastore

    • iiuc, questo non aiuta in senso generale, perché questo è accoppiato a Sciame e solo riavvia a monte, mentre noi vogliamo reagire, ricostruzione,ecc su cambiamenti a monte e non semplicemente riavviare.
    • Che suona come qualcosa che si dovrebbe fare in una CI pipeline
  15. 0

    Qui è un modo più semplice per aggiornare la finestra mobile contenitore automaticamente

    Mettere il lavoro via $ crontab -e:

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

    Creare dir ~/.docker con file 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
    

Lascia un commento