I container ti consentono di creare pacchetti della tua applicazione in un modo portatile che può essere eseguito in molti ambienti. La piattaforma container più popolare è Docker.
Questo tutorial spiegherà come utilizzare la build cache di Docker a tuo vantaggio.
Cache di compilazione Docker
La creazione di immagini dovrebbe essere veloce, efficiente e affidabile. Il concetto di immagini Docker viene fornito con livelli immutabili. Ogni comando eseguito risulta in un nuovo livello che contiene le modifiche rispetto al livello precedente.
Tutti i livelli creati in precedenza vengono memorizzati nella cache e possono essere riutilizzati. Tuttavia, se l'installazione dipende da risorse esterne, la cache Docker può causare problemi.
Come sfruttare la cache di compilazione Docker
Per comprendere i problemi della cache di compilazione di Docker, creiamo una semplice applicazione Docker nginx personalizzata. Prima di creare l'immagine, crea un Dockerfile che aggiorni le librerie e aggiunga una pagina iniziale personalizzata:
FROM nginx:1.21.6
# Update all packages
RUN apt-get update && apt-get -y upgrade
# Use a custom startpage
RUN echo '<html><bod>My Custom Startpage</body></html>' > /usr/share/nginx/html/index.htmlOra puoi creare l'immagine Docker:
$ docker build -t my-custom-nginx .
=> [1/3] FROM docker.io/library/nginx:1.21.6@sha256:e12... 5.8s
=> [2/3] RUN apt-get update && apt-get -y upgrade 3.6s
=> [3/3] RUN echo '<html><bod>My Custom Startpage... 0.2s
=> exporting to image 0.1s
=> exporting layers 0.1s
=> writing image 0.0s
=> naming to docker.io/library/my-custom-nginx
[+] Building 11.3s (7/7) FINISHED
In questo esempio, ho rimosso alcuni output per la leggibilità. Se costruisci l'immagine la prima volta, vedi che ci vuole un bel po' di tempo, nel mio caso 11.3s .
Un lungo passaggio di esecuzione è apt-get update && apt-get -y upgrade a seconda di quante dipendenze vengono aggiornate e di quanto è veloce la tua velocità di Internet. Controlla gli aggiornamenti dei pacchetti sul sistema operativo e li installa se disponibili.
Ora lo esegui di nuovo e trarrai vantaggio dalla build cache di Docker:
$ docker build -t my-custom-nginx .
=> [1/3] FROM docker.io/library/nginx:1.21.6@sha256:e1211ac1… 0.0s
=> CACHED [2/3] RUN apt-get update && apt-get -y upgrade 0.0s
=> CACHED [3/3] RUN echo '<html><bod>My Custom Startpage... 0.0s
=> exporting to image 0.0s
=> exporting layers 0.0s
=> writing image 0.0s
=> naming to docker.io/library/my-custom-nginx
Building 1.1s (7/7) FINISHEDQuesta volta, la creazione dell'immagine è molto veloce perché può riutilizzare tutte le immagini create in precedenza. Quando personalizzi la tua pagina iniziale nel Dockerfile, vedi come viene influenzato il comportamento della memorizzazione nella cache:
FROM nginx:1.21.6
# Update all packages
RUN apt-get update && apt-get -y upgrade
# Use a custom startpage
RUN echo '<html><bod>New Startpage</body></html>' > /usr/share/nginx/html/index.htmlOra, costruisci di nuovo l'immagine:
$ docker build -t my-custom-nginx .
=> [1/3] FROM docker.io/library/nginx:1.21.6@sha256:e1211ac1… 0.0s
=> CACHED [2/3] RUN apt-get update && apt-get -y upgrade 0.0s
=> [3/3] RUN echo '<html><bod>My Custom Startpage... 0.2s
=> exporting to image 0.0s
=> exporting layers 0.0s
=> writing image 0.0s
=> naming to docker.io/library/my-custom-nginx
Building 2.1s (7/7) FINISHED
Questa volta ha ricostruito solo l'ultimo livello perché ha riconosciuto che il RUN comando era cambiato. Tuttavia, ha riutilizzato l'intenso secondo passaggio di compilazione e non ha aggiornato le dipendenze del sistema operativo.
Il comportamento di memorizzazione nella cache è intelligente. Una volta che 1 passaggio deve essere ricostruito, ogni passaggio successivo viene ricostruito di nuovo. Pertanto, è bene inserire le parti che cambiano frequentemente alla fine di un Dockerfile per riutilizzare i livelli di costruzione precedenti.
Tuttavia, forse vuoi forzare una ricostruzione di un livello memorizzato nella cache per forzare un aggiornamento del pacchetto. Può essere necessario forzare una ricostruzione perché vuoi mantenere la tua applicazione al sicuro e utilizzare gli aggiornamenti più recenti quando disponibili.
Come utilizzare la build Docker --no-cache Opzione
Ci possono essere diversi motivi per disabilitare la build-cache. Puoi ricostruire l'immagine dall'immagine di base senza utilizzare livelli memorizzati nella cache utilizzando --no-cache opzione.
$ docker build -t my-custom-nginx .
=> CACHED [1/3] FROM docker.io/library/nginx:1.21.6@sha256:... 0.0s
=> [2/3] RUN apt-get update && apt-get -y upgrade 3.5s
=> [3/3] RUN echo '<html><bod>My Custom Startpage... 0.2s
=> exporting to image 0.1s
=> exporting layers 0.0s
=> writing image 0.0s
=> naming to docker.io/library/my-custom-nginx
Building 5.5s (7/7) FINISHED
Nuovi strati sono stati costruiti e utilizzati. La docker build esegue entrambi i comandi questa volta, che viene fornito con un approccio tutto o niente. O fornisci il --no-cache opzione che esegue tutti i comandi o memorizzerai nella cache il più possibile.
Come utilizzare gli argomenti Docker per il busting della cache
Un'altra opzione consente di fornire un piccolo punto di partenza nel Dockerfile. Devi modificare il tuo Dockerfile in questo modo:
FROM nginx:1.21.6
# Update all packages
RUN apt-get update && apt-get -y upgrade
# Custom cache invalidation
ARG CACHEBUST=1
# Use a custom startpage
RUN echo '<html><bod>New Startpage</body></html>' > /usr/share/nginx/html/index.html
Aggiungi un CACHEBUST argomento al tuo Dockerfile nella posizione in cui vuoi imporre una ricostruzione. Ora puoi creare l'immagine Docker e fornire un valore sempre diverso che fa sì che tutti i seguenti comandi vengano eseguiti nuovamente:
$ docker build -t my-custom-nginx --build-arg CACHEBUST=$(date +%s) .
=> [1/3] FROM docker.io/library/nginx:1.21.6@sha256:e1211ac1... 0.0s
=> CACHED [2/3] RUN apt-get update && apt-get -y upgrade 0.0s
=> [3/3] RUN echo '<html><bod>My Custom Startpage... 0.3s
=> exporting to image 0.0s
=> exporting layers 0.0s
=> writing image 0.0s
=> naming to docker.io/library/my-custom-nginx
Building 1.0s (7/7) FINISHED
Fornendo --build-arg CACHEBUST=$(date +%s) , imposti il parametro su un valore sempre diverso che provoca la ricostruzione di tutti i livelli successivi.