Come utilizzare Dockerfile ONBUILD per eseguire trigger su build downstream

ONBUILD di Docker l'istruzione ti consente di impostare i trigger all'interno di un'immagine. I tuoi trigger verranno eseguiti in seguito, quando l'immagine verrà utilizzata come base per un'altra. Diventeranno parte del nuovo contesto dell'immagine a valle e non saranno livelli del filesystem nella tua docker build iniziale .

Aggiunta di trigger ONBUILD

ONBUILD è un'istruzione che scrivi nei tuoi Dockerfiles. È unico in quanto ne accetta un altro istruzione come argomento. Puoi specificare qualsiasi operazione Dockerfile, come COPY o RUN , e fallo eseguire durante la compilazione di un'immagine a valle.

ONBUILD RUN example-command

Questo esempio esegue example-command nell'immagine del bambino al momento della creazione. Ecco un altro caso in cui un file viene copiato dal contesto di compilazione dell'immagine downstream nel filesystem:

ONBUILD COPY assets.json /app/assets.json

ONBUILD le istruzioni non hanno alcun effetto sull'immagine prodotta dal Dockerfile in cui sono definite. La creazione del Dockerfile sopra non esegui example-command o includi assets.json nell'immagine:

# Does not include the extra instructions
docker build -t base-image:latest .

I trigger verranno utilizzati quando scrivi un altro Dockerfile che utilizza il primo come base:

FROM base-image:latest
RUN my-binary

docker build -t downstream-image:latest .

La creazione di questo Dockerfile eseguirà example-command , copia in assets.json , e infine esegui my-binary . Il ONBUILD i trigger vengono sempre eseguiti per primi, subito dopo il FROM istruzione nel Dockerfile a valle.

In che modo Docker riconosce i trigger?

ONBUILD non influisce sul filesystem del contenitore di base, ma Docker sa ancora che i trigger sono presenti quando crei un'immagine a valle. Il processo di compilazione tiene traccia di ONBUILD le istruzioni le trova e le registra nei metadati dell'immagine.

Docker esamina i metadati delle immagini a cui si fa riferimento in un FROM istruzione. Se l'immagine denominata include attivatori nei suoi metadati, tali istruzioni di attivazione vengono effettivamente incollate nella parte superiore del Dockerfile a valle prima dell'inizio della compilazione.

I trigger vengono effettivamente eseguiti come parte del FROM della build fase. Verranno eseguiti nell'ordine in cui sono stati scritti nel Dockerfile a monte. Se un ONBUILD istruzione fallisce, Docker annullerà la build e assomiglierà a FROM lo stadio era la causa.

Limitazioni

Puoi usare qualsiasi istruzione Dockerfile come argomento per un ONBUILD trigger con tre eccezioni:

• ONBUILD FROM – Questo non è consentito in quanto sovrascriverebbe l'immagine di base utilizzata per la build. Ogni Dockerfile deve ereditare da una singola base.
• ONBUILD MAINTAINER – Il MAINTAINER l'istruzione è deprecata e non deve essere utilizzata; le informazioni sulla paternità sono meglio fornite come etichetta. Il LABEL l'istruzione è compatibile con ONBUILD .
• ONBUILD ONBUILD – Concatenamento di ONBUILD le istruzioni non sono supportate. Tutti i trigger vengono eseguiti nell'immagine immediatamente a valle del Dockerfile. Non è possibile definire trigger destinati ad essere eseguiti nelle immagini "nipote" a due o più livelli al di sotto del Dockerfile che lo definisce.

Tutte le istruzioni sono definite allo stesso modo dei loro usi regolari. Scrivendo un passaggio normale nel Dockerfile, quindi anteponendolo a ONBUILD , lo sposterà fuori dal normale flusso di compilazione e ne farà invece un trigger di compilazione a valle.

Quando sono utili i trigger ONBUILD?

ONBUILD è più comunemente usato all'interno di immagini di utilità che automatizzano attività come la compilazione del codice. Questo tipo di procedura richiede generalmente diversi passaggi da eseguire in una sequenza specifica, con dipendenze come il codice sorgente aggiunto in un punto particolare.

Considera un'immagine di compilazione che cerca il codice sorgente in una directory, quindi esegue un comando per compilarlo. Non puoi semplicemente COPY e RUN all'interno del Dockerfile di quell'immagine poiché l'origine dell'utente finale non esisterebbe all'interno del tuo contesto di costruzione dell'immagine.

Usando ONBUILD ti consente di fornire un Dockerfile standard che i tuoi utenti possono estendere e docker build senza reinventare la funzionalità comune:

ENV BUILD_ENV=production
RUN init-build.sh

ONBUILD COPY /src /build
ONBUILD RUN compile.sh --destination=/bin

Questo esempio mostra come un'immagine del builder potrebbe fornire un ambiente di compilazione preconfigurato. Se utilizzato come immagine di base, il codice verrebbe compilato automaticamente dal contesto di compilazione downstream. Quell'immagine potrebbe interagire con l'output compilato in /bin all'interno delle proprie fasi Dockerfile.

Riepilogo

ONBUILD le istruzioni in Dockerfiles offrono un modo per eseguire i trigger come parte di una build downstream. Puoi usare qualsiasi altra istruzione Dockerfile come ONBUILD trigger, salvo alcune limitazioni.

Usando ONBUILD ti consente di fornire immagini Docker generiche che definiscono set riutilizzabili di funzionalità. Questo è più efficiente che fare in modo che gli utenti coprano il testo di esempio Dockerfiles testualmente, quindi aggiungano le proprie istruzioni in fondo. Puoi comunque modificare e aggiornare l'immagine di base senza richiedere l'intervento dei tuoi utenti.

Adozione di ONBUILD riduce la ripetizione e facilita le immagini di base Docker estensibili. ONBUILD vale la pena considerare le istruzioni quando crei un Dockerfile standard che dovrà essere personalizzato dagli utenti finali prima che l'ambiente del contenitore finale sia considerato completo.