{"id":1310,"date":"2024-07-23T12:20:15","date_gmt":"2024-07-23T12:20:15","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1310"},"modified":"2024-07-23T12:23:05","modified_gmt":"2024-07-23T12:23:05","slug":"dockerfile-onbuild","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-onbuild\/","title":{"rendered":"Dockerfile ONBUILD"},"content":{"rendered":"

Comprendere ONBUILD in Dockerfile: Un'immersione approfondita nelle tecniche avanzate di Dockerfile<\/h1>\n

Introduzione<\/h2>\n

Nel mondo della containerizzazione, Docker si \u00e8 affermato come lo standard de facto per il packaging di applicazioni e delle loro dipendenze in ambienti isolati noti come container. Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> \u00e8 uno script che contiene una serie di istruzioni su come costruire un Docker immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. Tra queste istruzioni, ONBUILD<\/code> stands out as a unique directive that allows a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to specify actions that should be executed when the immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is used as a base for a child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This article will delve into the intricacies of the ONBUILD<\/code> istruzione, i suoi casi d'uso, i vantaggi e le potenziali insidie, il tutto mirato a fornire una comprensione completa di questa funzionalit\u00e0 avanzata in Docker.<\/p>\n

Che cos'\u00e8 l'istruzione ONBUILD? \u00c8 un'istruzione speciale in Docker che viene attivata quando l'immagine viene utilizzata come base per un'altra build. L'istruzione ONBUILD aggiunge un trigger che verr\u00e0 eseguito nel contesto del Dockerfile figlio, automatizzando cos\u00ec operazioni come la copia di file o l'esecuzione di comandi durante la costruzione dell'immagine derivata.<\/h2>\n

The ONBUILD<\/code> Istruzione in un Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is used to trigger actions in a child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> that is built from a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. When a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> with an ONBUILD<\/code> instruction is used as the base for a new Docker immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, the specified instructions will automatically be executed in the context of the child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This allows for a level of abstraction and reuse that can streamline the Docker immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> creation process, especially in multi-tiered applications.<\/p>\n

Syntax of ONBUILD<\/h3>\n

The syntax for using ONBUILD<\/code> is straightforward. You simply prefix the command you want to be executed with ONBUILD<\/code>. Ecco un esempio:<\/p>\n

# Parent Dockerfile\nFROM node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:14\nALL'AVVIO DELLA BUILD RUN<\/a><\/span>\"RUN\" si riferisce a un comando in diversi linguaggi di programmazione e sistemi operativi per eseguire un programma o script specificato. Avvia processi, fornendo un ambiente controllato per l'esecuzione dei compiti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> npm install<\/code><\/pre>\n
In this example, when a new immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is built using this parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, it will automatically execute RUN<\/a><\/span>\"RUN\" si riferisce a un comando in diversi linguaggi di programmazione e sistemi operativi per eseguire un programma o script specificato. Avvia processi, fornendo un ambiente controllato per l'esecuzione dei compiti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> npm install<\/code> come parte del processo di compilazione.<\/p>\n
The Use Cases for ONBUILD<\/h2>\n
1. Simplifying Child Image Creation<\/h3>\n
Uno dei principali vantaggi dell'utilizzo ONBUILD<\/code> is the ability to simplify the creation of child images. For example, if you have a standard set of dependencies or configurations that need to be set up across multiple applications, you can encapsulate those in a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> con ONBUILD<\/code> directives. This way, the child images inherit the necessary setup without duplicating code.<\/p>\n
Scenario di Esempio<\/h4>\n
Consider a scenario where multiple applications require the same base setup for a web server. By creating a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> that installs common packages and configurations through ONBUILD<\/code>, Gli sviluppatori possono focalizzare i propri sforzi sugli aspetti unici delle loro applicazioni specifiche.<\/p>\n
2. Enforcing Best Practices<\/h3>\n
Usando ONBUILD<\/code> can also help enforce best practices across teams or projects. For example, you might want to ensure that every child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> performs specific security or performance optimizations. By embedding these instructions in a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, you can maintain consistency and reduce the likelihood of errors.<\/p>\n
3. Modularizzazione delle Immagini Docker<\/h3>\n
In un'architettura a microservizi, dove diversi servizi potrebbero condividere funzionalit\u00e0 comuni, ONBUILD<\/code> allows for modular Docker immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> design. Each servizio<\/a><\/span>Il servizio si riferisce all'atto di fornire assistenza o supporto per soddisfare esigenze o requisiti specifici. In vari ambiti, comprende il servizio clienti, il supporto tecnico e i servizi professionali, enfatizzando l'efficienza e la soddisfazione dell'utente. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> can inherit from a common base immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> that contains shared logic or dependencies, leading to cleaner and more maintainable codebases.<\/p>\n
Migliori pratiche per l'uso di ONBUILD<\/h2>\n
Mentre ONBUILD<\/code> can provide significant benefits, it is essential to use it judiciously. Here are some best practices to keep in mind:<\/p>\n
1. Documentare chiaramente le istruzioni ONBUILD<\/h3>\n
Poich\u00e9 ONBUILD<\/code> instructions will execute in a child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, it’s crucial to document what these instructions do and what assumptions they make. Failure to do so can lead to confusion, especially for new developers or teams that may not be aware of the inherited behaviors.<\/p>\n
2. Use ONBUILD Sparingly<\/h3>\n
Overuse of ONBUILD<\/code> can lead to complex and hard-to-debug build processes. Aim to use it only when there are clear benefits to abstracting away repeated logic. If the logic is unique to a specific application or microservice, it may be better to define it directly in the child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.<\/p>\n
3. Testare accuratamente le immagini dei genitori<\/h3>\n
Before deploying a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> con ONBUILD<\/code> instructions, make sure to test it thoroughly. Since the behavior of the child images will depend on these instructions, any issues in the parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> could propagate to all child images, causing widespread issues.<\/p>\n
4. Versioning Parent Images<\/h3>\n
As with any immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> in Docker, consider versioning your parent images. When making changes to an ONBUILD<\/code> instruction, you may inadvertently alter the behavior of existing child images. Proper versioning can help manage these changes and avoid breaking existing applications.<\/p>\n
Limitations of ONBUILD<\/h2>\n
Mentre ONBUILD<\/code> can be a powerful tool, it is essential to be aware of its limitations.<\/p>\n
1. Comportamento implicito<\/h3>\n
One of the most significant downsides of ONBUILD<\/code> is its implicit behavior. Developers using a child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> may not immediately realize that certain instructions are being executed without their explicit inclusion in the Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This can lead to unexpected results, especially if the ONBUILD<\/code> instructions involve complex operations or dependencies.<\/p>\n
2. Reduced Transparency<\/h3>\n
When using ONBUILD<\/code>, it can be challenging to understand the complete build process just by looking at the child image\u2019s Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This lack of transparency can complicate troubleshooting efforts when issues arise.<\/p>\n
3. Problemi di Compatibilit\u00e0<\/h3>\n
Modifiche al ONBUILD<\/code> instructions in a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> can lead to compatibility issues in child images. This is particularly true if the child images were built against an older version of the parent. Careful management of immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> versions is necessary to mitigate this risk.<\/p>\n
Practical Examples of Using ONBUILD<\/h2>\n
To illustrate the concept more clearly, let\u2019s explore some practical examples of how ONBUILD<\/code> can be utilized effectively.<\/p>\n
Example 1: Python Application Setup<\/h3>\n
Imagine you are developing a set of microservices in Python, and you want each servizio<\/a><\/span>Il servizio si riferisce all'atto di fornire assistenza o supporto per soddisfare esigenze o requisiti specifici. In vari ambiti, comprende il servizio clienti, il supporto tecnico e i servizi professionali, enfatizzando l'efficienza e la soddisfazione dell'utente. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to install common dependencies. You could create a parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> like this:<\/p>\n
# Parent Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> for Python apps\nFROM python:3.9\n\nONBUILD COPIA<\/a><\/span>COPY \u00e8 un comando nella programmazione informatica e nella gestione dei dati che facilita la duplicazione di file o dati da una posizione a un'altra, garantendo l'integrit\u00e0 e l'accessibilit\u00e0 dei dati. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> requirements.txt \/app\/\nONBUILD RUN<\/a><\/span>\"RUN\" si riferisce a un comando in diversi linguaggi di programmazione e sistemi operativi per eseguire un programma o script specificato. Avvia processi, fornendo un ambiente controllato per l'esecuzione dei compiti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> pip install -r \/app\/requirements.txt\nONBUILD COPIA<\/a><\/span>COPY \u00e8 un comando nella programmazione informatica e nella gestione dei dati che facilita la duplicazione di file o dati da una posizione a un'altra, garantendo l'integrit\u00e0 e l'accessibilit\u00e0 dei dati. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> . \/app\/<\/code><\/pre>\n
When a child immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is created from this parent, the specified ONBUILD<\/code> instructions will automatically copia<\/a><\/span>COPY \u00e8 un comando nella programmazione informatica e nella gestione dei dati che facilita la duplicazione di file o dati da una posizione a un'altra, garantendo l'integrit\u00e0 e l'accessibilit\u00e0 dei dati. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> il requirements.txt<\/code> e installare le dipendenze, assicurandosi che tutti i servizi abbiano i pacchetti necessari.<\/p>\n
Esempio 2: Inizializzazione dell'applicazione Node.js<\/h3>\n
Per Node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.js applications, you might want a similar pattern. Here is how that might look:<\/p>\n
# Parent Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> for Node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.js apps\nFROM node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:14\n\nONBUILD WORKDIR<\/a><\/span>L'istruzione `WORKDIR` nel Dockerfile imposta la directory di lavoro per le istruzioni successive. Semplifica la gestione dei percorsi, poich\u00e9 tutti i percorsi relativi verranno risolti a partire da questa directory, migliorando la chiarezza della build. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> \/usr\/src\/app\nONBUILD COPIA<\/a><\/span>COPY \u00e8 un comando nella programmazione informatica e nella gestione dei dati che facilita la duplicazione di file o dati da una posizione a un'altra, garantendo l'integrit\u00e0 e l'accessibilit\u00e0 dei dati. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> package*.json .\/\nONBUILD RUN<\/a><\/span>\"RUN\" si riferisce a un comando in diversi linguaggi di programmazione e sistemi operativi per eseguire un programma o script specificato. Avvia processi, fornendo un ambiente controllato per l'esecuzione dei compiti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> npm install\nONBUILD COPIA<\/a><\/span>COPY \u00e8 un comando nella programmazione informatica e nella gestione dei dati che facilita la duplicazione di file o dati da una posizione a un'altra, garantendo l'integrit\u00e0 e l'accessibilit\u00e0 dei dati. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> . .<\/code><\/pre>\n
With this setup, any Node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.js application that uses this parent immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> will automatically set up its working directory, copia<\/a><\/span>COPY \u00e8 un comando nella programmazione informatica e nella gestione dei dati che facilita la duplicazione di file o dati da una posizione a un'altra, garantendo l'integrit\u00e0 e l'accessibilit\u00e0 dei dati. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> its package files, and install its npm dependencies.<\/p>\n
Conclusione<\/h2>\n
The ONBUILD<\/code> instruction in Dockerfiles is a powerful feature that can enhance the usability and maintainability of Docker images. By allowing parent images to dictate behaviors for child images, it promotes code reuse and can help enforce best practices across teams and projects.<\/p>\n
However, with great power comes great responsibility. It is crucial to use ONBUILD<\/code> judiciously, ensuring that it does not lead to confusion or compatibility issues down the line. Documenting the behavior of ONBUILD<\/code> instructions, testing thoroughly, and managing versions carefully are essential practices for maintaining a healthy and efficient Docker ecosystem.<\/p>\n
By understanding and applying the knowledge of ONBUILD<\/code>, Docker users can streamline their image-building processes and foster a more modular and maintainable approach to containerized applications.<\/p>","protected":false},"excerpt":{"rendered":"
The `ONBUILD` instruction in a Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> ti permette di specificare azioni che devono essere eseguite quando le immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> viene utilizzato come base per un'altra build. Questa funzionalit\u00e0 \u00e8 utile per creare immagini riutilizzabili con comportamenti predefiniti.<\/p>","protected":false},"author":1,"featured_media":1937,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1310","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile ONBUILD - Dockerpros<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-onbuild\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile ONBUILD - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `ONBUILD` instruction in a Dockerfile allows you to specify actions that should be executed when the image is used as a base for another build. This feature is useful for creating reusable images with predefined behaviors.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-onbuild\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:23:05+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"800\" \/>\n\t<meta property=\"og:image:height\" content=\"600\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/\",\"name\":\"Dockerfile ONBUILD - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg\",\"datePublished\":\"2024-07-23T12:20:15+00:00\",\"dateModified\":\"2024-07-23T12:23:05+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-onbuild-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/dockerpros.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Glossary\",\"item\":\"https:\/\/dockerpros.com\/fr\/wiki\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Dockerfile ONBUILD\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/dockerpros.com\/#website\",\"url\":\"https:\/\/dockerpros.com\/\",\"name\":\"Dockerpros\",\"description\":\"DockerPros \u2013 Your Ultimate Docker Resource Hub\",\"publisher\":{\"@id\":\"https:\/\/dockerpros.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/dockerpros.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"width\":532,\"height\":114,\"caption\":\"Dockerpros\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Dockerfile ONBUILD - Dockerpros\n\nIn questo articolo, esploreremo il comando ONBUILD nel Dockerfile e come pu\u00f2 essere utilizzato per creare immagini Docker pi\u00f9 flessibili e riutilizzabili. Il comando ONBUILD \u00e8 un'istruzione speciale che consente di posticipare l'esecuzione di un comando fino a quando l'immagine non viene utilizzata come base per un'altra build.\n\nIl comando ONBUILD \u00e8 particolarmente utile quando si desidera creare un'immagine base che pu\u00f2 essere estesa da altre immagini. Ad esempio, se si dispone di un'immagine base che contiene un'applicazione web, \u00e8 possibile utilizzare ONBUILD per copiare automaticamente il codice sorgente dell'applicazione nella directory di lavoro dell'immagine figlia durante la build.\n\nEcco un esempio di come utilizzare ONBUILD in un Dockerfile:\n\n```dockerfile\nFROM node:14\n\nWORKDIR \/app\n\nONBUILD COPY . \/app\nONBUILD RUN npm install\n\nCMD [\"npm\", \"start\"]\n```\n\nIn questo esempio, l'immagine base \u00e8 basata su Node.js versione 14. Il comando ONBUILD COPY copia il codice sorgente dell'applicazione dalla directory corrente nella directory di lavoro dell'immagine figlia. Successivamente, il comando ONBUILD RUN esegue npm install per installare le dipendenze dell'applicazione.\n\nQuando un'immagine figlia viene creata utilizzando questa immagine base, i comandi ONBUILD verranno eseguiti automaticamente durante la build. Ci\u00f2 significa che non \u00e8 necessario copiare manualmente il codice sorgente o installare le dipendenze ogni volta che si crea una nuova immagine figlia.\n\n\u00c8 importante notare che i comandi ONBUILD vengono eseguiti solo durante la build dell'immagine figlia e non durante la build dell'immagine base stessa. Inoltre, i comandi ONBUILD vengono eseguiti nell'ordine in cui sono definiti nel Dockerfile.\n\nUn altro vantaggio dell'utilizzo di ONBUILD \u00e8 che consente di creare immagini base pi\u00f9 generiche e riutilizzabili. Ad esempio, \u00e8 possibile creare un'immagine base che contiene solo il runtime di un linguaggio di programmazione, come Python o Java, e utilizzare ONBUILD per copiare automaticamente il codice sorgente dell'applicazione durante la build dell'immagine figlia.\n\nTuttavia, \u00e8 importante utilizzare ONBUILD con cautela. Poich\u00e9 i comandi ONBUILD vengono eseguiti automaticamente durante la build dell'immagine figlia, \u00e8 possibile che si verifichino comportamenti imprevisti se i comandi ONBUILD non sono progettati correttamente. Inoltre, l'utilizzo eccessivo di ONBUILD pu\u00f2 rendere il Dockerfile pi\u00f9 complesso e difficile da comprendere.\n\nIn conclusione, il comando ONBUILD nel Dockerfile \u00e8 uno strumento potente per creare immagini Docker pi\u00f9 flessibili e riutilizzabili. Consente di posticipare l'esecuzione di comandi fino a quando l'immagine non viene utilizzata come base per un'altra build. Tuttavia, \u00e8 importante utilizzare ONBUILD con cautela e progettare attentamente i comandi ONBUILD per evitare comportamenti imprevisti.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-onbuild\/","og_locale":"it_IT","og_type":"article","og_title":"Dockerfile ONBUILD - Dockerpros","og_description":"The `ONBUILD` instruction in a Dockerfile allows you to specify actions that should be executed when the image is used as a base for another build. This feature is useful for creating reusable images with predefined behaviors.","og_url":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-onbuild\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:23:05+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Tempo di lettura stimato":"6 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/","name":"Dockerfile ONBUILD - Dockerpros\n\nIn questo articolo, esploreremo il comando ONBUILD nel Dockerfile e come pu\u00f2 essere utilizzato per creare immagini Docker pi\u00f9 flessibili e riutilizzabili. Il comando ONBUILD \u00e8 un'istruzione speciale che consente di posticipare l'esecuzione di un comando fino a quando l'immagine non viene utilizzata come base per un'altra build.\n\nIl comando ONBUILD \u00e8 particolarmente utile quando si desidera creare un'immagine base che pu\u00f2 essere estesa da altre immagini. Ad esempio, se si dispone di un'immagine base che contiene un'applicazione web, \u00e8 possibile utilizzare ONBUILD per copiare automaticamente il codice sorgente dell'applicazione nella directory di lavoro dell'immagine figlia durante la build.\n\nEcco un esempio di come utilizzare ONBUILD in un Dockerfile:\n\n```dockerfile\nFROM node:14\n\nWORKDIR \/app\n\nONBUILD COPY . \/app\nONBUILD RUN npm install\n\nCMD [\"npm\", \"start\"]\n```\n\nIn questo esempio, l'immagine base \u00e8 basata su Node.js versione 14. Il comando ONBUILD COPY copia il codice sorgente dell'applicazione dalla directory corrente nella directory di lavoro dell'immagine figlia. Successivamente, il comando ONBUILD RUN esegue npm install per installare le dipendenze dell'applicazione.\n\nQuando un'immagine figlia viene creata utilizzando questa immagine base, i comandi ONBUILD verranno eseguiti automaticamente durante la build. Ci\u00f2 significa che non \u00e8 necessario copiare manualmente il codice sorgente o installare le dipendenze ogni volta che si crea una nuova immagine figlia.\n\n\u00c8 importante notare che i comandi ONBUILD vengono eseguiti solo durante la build dell'immagine figlia e non durante la build dell'immagine base stessa. Inoltre, i comandi ONBUILD vengono eseguiti nell'ordine in cui sono definiti nel Dockerfile.\n\nUn altro vantaggio dell'utilizzo di ONBUILD \u00e8 che consente di creare immagini base pi\u00f9 generiche e riutilizzabili. Ad esempio, \u00e8 possibile creare un'immagine base che contiene solo il runtime di un linguaggio di programmazione, come Python o Java, e utilizzare ONBUILD per copiare automaticamente il codice sorgente dell'applicazione durante la build dell'immagine figlia.\n\nTuttavia, \u00e8 importante utilizzare ONBUILD con cautela. Poich\u00e9 i comandi ONBUILD vengono eseguiti automaticamente durante la build dell'immagine figlia, \u00e8 possibile che si verifichino comportamenti imprevisti se i comandi ONBUILD non sono progettati correttamente. Inoltre, l'utilizzo eccessivo di ONBUILD pu\u00f2 rendere il Dockerfile pi\u00f9 complesso e difficile da comprendere.\n\nIn conclusione, il comando ONBUILD nel Dockerfile \u00e8 uno strumento potente per creare immagini Docker pi\u00f9 flessibili e riutilizzabili. Consente di posticipare l'esecuzione di comandi fino a quando l'immagine non viene utilizzata come base per un'altra build. Tuttavia, \u00e8 importante utilizzare ONBUILD con cautela e progettare attentamente i comandi ONBUILD per evitare comportamenti imprevisti.","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg","datePublished":"2024-07-23T12:20:15+00:00","dateModified":"2024-07-23T12:23:05+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-onbuild_1310.jpg","width":800,"height":600,"caption":"dockerfile-onbuild-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-onbuild\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/dockerpros.com\/"},{"@type":"ListItem","position":2,"name":"Glossary","item":"https:\/\/dockerpros.com\/fr\/wiki\/"},{"@type":"ListItem","position":3,"name":"Dockerfile ONBUILD"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Esperti Docker","description":"DockerPros \u2013 Il tuo punto di riferimento definitivo per Docker","publisher":{"@id":"https:\/\/dockerpros.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/dockerpros.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Esperti Docker","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","width":532,"height":114,"caption":"Dockerpros"},"image":{"@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary\/1310","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary\/1310\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media\/1937"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media?parent=1310"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary-cat?post=1310"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}