{"id":1325,"date":"2024-07-23T12:20:47","date_gmt":"2024-07-23T12:20:47","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1325"},"modified":"2024-07-23T12:23:30","modified_gmt":"2024-07-23T12:23:30","slug":"dockerfile-multi-stage","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-multi-stage\/","title":{"rendered":"Dockerfile MULTI-STAGE"},"content":{"rendered":"

Mastering Dockerfile Multi-Stage Builds: A Comprehensive Guide<\/h1>\n

What is a Multi-Stage Build?<\/h2>\n

A Multi-Stage Build<\/a><\/span>A multi-stage build is a Docker optimization technique that enables the separation of build and runtime environments. By using multiple FROM statements in a single Dockerfile, developers can streamline image size and enhance security by excluding unnecessary build dependencies in the final image. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> in Docker is an advanced feature that allows developers to define multiple FROM<\/code> statements in a single Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, enabling the construction of more complex and efficient images. This method helps to separate the build environment from the runtime environment, thereby optimizing the final image<\/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> size and security by excluding unnecessary files and dependencies. This strategy is particularly useful for applications that require a compilation step, as it allows developers to create an intermediate image<\/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 the build tools and libraries, and then copy<\/a><\/span>COPY is a command in computer programming and data management that facilitates the duplication of files or data from one location to another, ensuring data integrity and accessibility. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> only the necessary artifacts into a smaller, cleaner runtime image<\/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

Why Use Multi-Stage Builds?<\/h2>\n

1. Reduction of Image Size<\/h3>\n

One of the primary advantages of using multi-stage builds is the significant reduction in image<\/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> size. In traditional Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> practices, developers would include all dependencies, build tools, and runtime files in a single image<\/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 often leads to bloated images that take longer to download and deploy. By separating the build and runtime environments, you can ensure that only the essential files are included in the final image<\/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>, resulting in a smaller, more efficient container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.<\/p>\n

2. Improved Security<\/h3>\n

A smaller image<\/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> size not only aids in efficiency but also enhances security. By excluding build tools and unnecessary files from the final image<\/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 reduce the attack surface. This minimizes vulnerabilities and potential entry points for malicious activities. In production, the fewer components included in the image<\/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 lower the chance of security breaches.<\/p>\n

3. Simplified Dockerfile Management<\/h3>\n

Multi-stage builds offer a clean way to manage complex Dockerfiles. With the ability to isolate different stages, developers can more easily understand, maintain, and modify their Dockerfiles. Each stage can focus on a specific task<\/a><\/span>A task is a specific piece of work or duty assigned to an individual or system. It encompasses defined objectives, required resources, and expected outcomes, facilitating structured progress in various contexts. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> \u2014 whether it\u2019s building, testing, or deploying \u2014 and can have its own base image<\/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> tailored to that task<\/a><\/span>A task is a specific piece of work or duty assigned to an individual or system. It encompasses defined objectives, required resources, and expected outcomes, facilitating structured progress in various contexts. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.<\/p>\n

How Multi-Stage Builds Work<\/h2>\n

The syntax for creating a multi-stage build<\/a><\/span>A multi-stage build is a Docker optimization technique that enables the separation of build and runtime environments. By using multiple FROM statements in a single Dockerfile, developers can streamline image size and enhance security by excluding unnecessary build dependencies in the final image. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is straightforward. Each stage begins with a FROM<\/code> instruction, and subsequent instructions can build upon the last one. You can refer to any previous build stage by using the AS<\/code> keyword to create a named stage.<\/p>\n

Example of a Simple Multi-Stage Build<\/h3>\n

Let\u2019s consider a basic example of a multi-stage build<\/a><\/span>A multi-stage build is a Docker optimization technique that enables the separation of build and runtime environments. By using multiple FROM statements in a single Dockerfile, developers can streamline image size and enhance security by excluding unnecessary build dependencies in the final image. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> for a 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.<\/p>\n

# Stage 1: Build\nFROM node:14 AS builder\n\n# Set the working directory\nWORKDIR \/app\n\n# Copy package.json and yarn.lock\nCOPY package.json yarn.lock .\/\n\n# Install dependencies\nRUN yarn install\n\n# Copy the rest of the application code\nCOPY . .\n\n# Build the application\nRUN yarn build\n\n# Stage 2: Production\nFROM node:14 AS production\n\n# Set the working directory for the production stage\nWORKDIR \/app\n\n# Copy only the build artifacts from the builder stage\nCOPY --from=builder \/app\/dist .\/dist\nCOPY --from=builder \/app\/package.json .\/package.json\n\n# Install only production dependencies\nRUN yarn install --production\n\n# Command to run the application\nCMD [\"node\", \"dist\/index.js\"]<\/code><\/pre>\n
In this example, the first stage (named builder<\/code>) installs all dependencies and executes the build process. The second stage (named production<\/code>) only copies the compiled artifacts, resulting in a lightweight final image<\/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
Advanced Multi-Stage Build Techniques<\/h2>\n
1. Using Multiple Build Stages<\/h3>\n
Complex applications often require multiple steps in their build process. By leveraging several stages, you can effectively manage these steps. For instance, you might have a testing stage after the build stage to run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> unit tests before copying the artifacts to the final image<\/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
# Stage 1: Build\nFROM node:14 AS builder\nWORKDIR \/app\nCOPY package.json yarn.lock .\/\nRUN yarn install\nCOPY . .\nRUN yarn build\n\n# Stage 2: Test\nFROM node:14 AS tester\nWORKDIR \/app\nCOPY --from=builder \/app .\nRUN yarn test\n\n# Stage 3: Production\nFROM node:14 AS production\nWORKDIR \/app\nCOPY --from=builder \/app\/dist .\/dist\nCOPY --from=builder \/app\/package.json .\/package.json\nRUN yarn install --production\nCMD [\"node\", \"dist\/index.js\"]<\/code><\/pre>\n
In this setup, the build artifacts are first tested before being copied into the production image<\/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>, ensuring that only verified code is included.<\/p>\n
2. Caching Mechanisms<\/h3>\n
Docker uses a cache to speed up the build process. When a line in a Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> hasn\u2019t changed, Docker can reuse the previously built layer. Multi-stage builds can take advantage of this caching mechanism. By structuring your Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> intelligently, placing the least frequently changing commands \u2014 such as dependency installations \u2014 before the commands that change frequently, you can significantly reduce build times.<\/p>\n
For instance, separating dependency installations into their own layer can help speed up subsequent builds:<\/p>\n
# Stage 1: Build\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 AS builder\nWORKDIR<\/a><\/span>The `WORKDIR` instruction in Dockerfile sets the working directory for subsequent instructions. It simplifies path management, as all relative paths will be resolved from this directory, enhancing build clarity. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> \/app\nCOPY<\/a><\/span>COPY is a command in computer programming and data management that facilitates the duplication of files or data from one location to another, ensuring data integrity and accessibility. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> package.json yarn.lock .\/\nRUN<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> yarn install\nCOPY<\/a><\/span>COPY is a command in computer programming and data management that facilitates the duplication of files or data from one location to another, ensuring data integrity and accessibility. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> . .\nRUN<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> yarn build<\/code><\/pre>\n
In this example, as long as package.json<\/code> and yarn.lock<\/code> don’t change, the yarn install<\/code> layer will be cached, speeding up future builds.<\/p>\n
3. Mixing Different Base Images<\/h3>\n
Multi-stage builds allow you to use different base images for different stages. For example, you might use a larger image<\/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 build tools for the build stage and a minimal image<\/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> for the final runtime stage. This is particularly useful when the application is built in one environment but is intended to run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> in another.<\/p>\n
# Stage 1: Build\nFROM golang:1.17 AS builder\nWORKDIR \/app\nCOPY . .\nRUN go build -o myapp\n\n# Stage 2: Production\nFROM alpine:latest\nWORKDIR \/app\nCOPY --from=builder \/app\/myapp .\nCMD [\".\/myapp\"]<\/code><\/pre>\n
In this example, the golang:1.17<\/code> image<\/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 for building a Go application, while alpine:latest<\/code> is utilized for the final lightweight runtime image<\/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
4. Environment Variables and ARG<\/h3>\n
Another powerful feature of multi-stage builds is the ability to pass environment variables and build arguments between stages. This allows you to customize various build settings depending on the environment.<\/p>\n
# Stage 1: Build\nFROM node:14 AS builder\nARG NODE_ENV=production\nENV NODE_ENV ${NODE_ENV}\nWORKDIR \/app\nCOPY package.json yarn.lock .\/\nRUN yarn install\nCOPY . .\nRUN yarn build\n\n# Stage 2: Production\nFROM node:14 AS production\nWORKDIR \/app\nCOPY --from=builder \/app\/dist .\/dist\nCOPY --from=builder \/app\/package.json .\/package.json\nRUN yarn install --production\nCMD [\"node\", \"dist\/index.js\"]<\/code><\/pre>\n
By using ARG<\/a><\/span>ARG is a directive used within Dockerfiles to define build-time variables that allow you to parameterize your builds. These variables can influence how an image is constructed, enabling developers to create more flexible and reusable Docker images. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code> and ENV<\/a><\/span>ENV, or Environmental Variables, are crucial in software development and system configuration. They store dynamic values that affect the execution environment, enabling flexible application behavior across different platforms. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span><\/code>, the NODE_ENV<\/code> variable can be dynamically set during the build process, allowing more flexible configuration.<\/p>\n
Best Practices for Multi-Stage Builds<\/h2>\n
    \n
  1. Keep Stages Focused<\/strong>: Each stage should have a clear responsibility, making it easier to maintain and understand.<\/li>\n
  2. Use Official Images<\/strong>: Whenever possible, use official base images to reduce vulnerabilities and simplify maintenance.<\/li>\n
  3. Run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> Non-Root User<\/strong>: For the final image<\/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>, consider running your application as a non-root user to enhance security.<\/li>\n
  4. Minimize Layers<\/strong>: Combine commands where possible to decrease the number of layers in your final image<\/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>.<\/li>\n
  5. Leverage Caching<\/strong>: Organize your Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to maximize layer caching efficiency.<\/li>\n
  6. Regularly Review Dependencies<\/strong>: Ensure that only necessary dependencies are included in the final image<\/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>.<\/li>\n<\/ol>\n
    Conclusion<\/h2>\n
    Multi-stage builds are a powerful feature in Docker that can greatly enhance the efficiency, security, and maintainability of your container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> images. By strategically separating the build and runtime environments, developers can create smaller images that are faster to deploy and less susceptible to security vulnerabilities. Understanding how to effectively use multi-stage builds will allow you to optimize your Dockerfiles and streamline your development workflows.<\/p>\n
    As you explore the intricacies of multi-stage builds, remember that the ultimate goal is to build images that are not only functional but also efficient and secure. By following best practices and leveraging the advanced capabilities of multi-stage builds, you can take your Docker skills to the next level.<\/p>","protected":false},"excerpt":{"rendered":"
    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> Gli strumenti di compilazione multi-stage ottimizzano 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 by allowing developers to use multiple FROM statements. This technique reduces final 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> size and enhances security by minimizing dependencies.<\/p>","protected":false},"author":1,"featured_media":1963,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1325","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile MULTI-STAGE - 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-multi-stage\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile MULTI-STAGE - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"Dockerfile multi-stage builds optimize image creation by allowing developers to use multiple FROM statements. This technique reduces final image size and enhances security by minimizing dependencies.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-multi-stage\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:23:30+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.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-multi-stage\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/\",\"name\":\"Dockerfile MULTI-STAGE - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.jpg\",\"datePublished\":\"2024-07-23T12:20:47+00:00\",\"dateModified\":\"2024-07-23T12:23:30+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-multi-stage-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#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 MULTI-STAGE\"}]},{\"@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 MULTI-STAGE - Dockerpros","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-multi-stage\/","og_locale":"it_IT","og_type":"article","og_title":"Dockerfile MULTI-STAGE - Dockerpros","og_description":"Dockerfile multi-stage builds optimize image creation by allowing developers to use multiple FROM statements. This technique reduces final image size and enhances security by minimizing dependencies.","og_url":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-multi-stage\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:23:30+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.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-multi-stage\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/","name":"Dockerfile MULTI-STAGE - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.jpg","datePublished":"2024-07-23T12:20:47+00:00","dateModified":"2024-07-23T12:23:30+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-multi-stage_1325.jpg","width":800,"height":600,"caption":"dockerfile-multi-stage-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-multi-stage\/#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 MULTI-STAGE"}]},{"@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\/1325","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\/1325\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media\/1963"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media?parent=1325"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary-cat?post=1325"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}