{"id":740,"date":"2024-07-22T20:39:50","date_gmt":"2024-07-22T20:39:50","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=740"},"modified":"2024-07-22T20:55:29","modified_gmt":"2024-07-22T20:55:29","slug":"multi-stage-build","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/de\/wiki\/multi-stage-build\/","title":{"rendered":"Multi-Stage Build"},"content":{"rendered":"

Understanding Multi-Stage Builds in Docker<\/h1>\n

Definition and Overview<\/h2>\n

Multi-stage builds in Docker are a powerful feature that allows developers to create more efficient and optimized Docker images by using 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>. This approach enables the separation of the build environment from the runtime environment, resulting in 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> sizes and improved build times. By leveraging multi-stage builds, developers can streamline the process of packaging applications, while minimizing the dependencies 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>.<\/p>\n

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

Traditionally, Docker images were built in a monolithic manner, where all dependencies, tools, and the application code were included 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> layer. This approach often resulted in large images that contained unnecessary files and tools used only during the build process. Multi-stage builds offer several advantages:<\/p>\n

    \n
  1. \n

    Reduced 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<\/strong>: By only including the necessary artifacts 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>, developers can significantly decrease the size of their Docker images. This reduction not only speeds up 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> transfers but also optimizes storage costs.<\/p>\n<\/li>\n

  2. \n

    Cleaner Dockerfiles<\/strong>: Multi-stage builds allow for cleaner and more organized Dockerfiles. Complex build processes can be broken down into manageable stages, improving readability and maintainability.<\/p>\n<\/li>\n

  3. \n

    Improved Build Performance<\/strong>: By caching intermediate stages, Docker can reuse layers during the build process, leading to faster builds. This caching mechanism is especially beneficial during iterative development.<\/p>\n<\/li>\n

  4. \n

    Enhanced Security<\/strong>: Smaller images with fewer components reduce the attack surface, thereby enhancing the security posture of the application. By excluding build tools and unnecessary libraries, the risk of vulnerabilities is minimized.<\/p>\n<\/li>\n

  5. \n

    Flexible Build Environments<\/strong>: Different stages can use different base images, allowing developers to tailor environments for specific build requirements without affecting the final 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<\/li>\n<\/ol>\n

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

    A multi-stage build consists of multiple build stages, each defined by a FROM<\/code> instruction in the 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>. Each stage can contain its own set of instructions, and 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> is built using only the artifacts produced in the later stages. Here\u2019s an outline of the process:<\/p>\n

      \n
    1. \n

      Define Multiple Stages<\/strong>: Each stage begins with a FROM<\/code> instruction specifying the 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>. You can use the same 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> for multiple stages or choose different ones based on your needs.<\/p>\n<\/li>\n

    2. \n

      Build Artifacts<\/strong>: Within each stage, you can execute commands to build your application, install dependencies, and generate files.<\/p>\n<\/li>\n

    3. \n

      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> Artifacts<\/strong>: When transitioning from one stage to another, you can use the 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><\/code> command with the --from<\/code> flag to 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 files from the previous stage to the current one.<\/p>\n<\/li>\n

    4. \n

      Final Stage<\/strong>: The final FROM<\/code> instruction defines which stage is used to create 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>. This stage will contain only the essential artifacts needed 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> the application.<\/p>\n<\/li>\n<\/ol>\n

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

      To illustrate the concept, consider a simple example of 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. The following 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> demonstrates a basic multi-stage build:<\/p>\n

      # Stage 1: Build\nFROM node:14 AS build\n\n# Set the working directory\nWORKDIR \/app\n\n# Copy package.json and package-lock.json\nCOPY package*.json .\/\n\n# Install dependencies\nRUN npm install\n\n# Copy the application code\nCOPY . .\n\n# Build the application\nRUN npm run build\n\n# Stage 2: Production\nFROM node:14 AS production\n\n# Set the working directory\nWORKDIR \/app\n\n# Copy only the build artifacts from the build stage\nCOPY --from=build \/app\/dist .\/dist\n\n# Install only production dependencies\nCOPY package*.json .\/\nRUN npm install --only=production\n\n# Start the application\nCMD [\"node\", \"dist\/index.js\"]<\/code><\/pre>\n
      In this example, the first stage (build<\/code>) installs dependencies and builds the application. The second stage (production<\/code>) only copies the necessary build artifacts and installs production dependencies, resulting in a smaller 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
      Best Practices for Multi-Stage Builds<\/h2>\n
      While multi-stage builds provide significant benefits, adhering to best practices will maximize their effectiveness:<\/p>\n
      1. Keep Build Stages Isolated<\/h3>\n
      Each stage should have a clear purpose, whether it is to build, test, or prepare 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>. Isolating stages ensures that the application remains modular and that each stage can be independently managed.<\/p>\n
      2. Use Lightweight Base Images<\/h3>\n
      For final stages, consider using minimal base images like alpine<\/code> or distroless<\/code>, which contain only the necessary components 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> your application. This reduces the overall 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 enhances security.<\/p>\n
      3. Leverage Caching<\/h3>\n
      Docker layers are cached, meaning that if a stage hasn\u2019t changed, Docker can skip rebuilding it. 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> so that the most frequently changing instructions are at the bottom, allowing for optimal caching.<\/p>\n
      4. Minimize Dependencies<\/h3>\n
      Only 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> the necessary files and dependencies 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>. For example, in 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, it\u2019s advisable to install only production dependencies in the final stage.<\/p>\n
      5. Use .dockerignore<\/code> Files<\/h3>\n
      To further optimize builds, utilize a .dockerignore<\/code> file to exclude unnecessary files and directories from being sent to the Docker daemon<\/a><\/span>A daemon is a background process in computing that runs autonomously, performing tasks without user intervention. It typically handles system or application-level functions, enhancing efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> during the build. This will speed up the context transfer and reduce 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> size.<\/p>\n
      6. Keep Your Dockerfile Clean<\/h3>\n
      Maintain a clear structure and add<\/a><\/span>The ADD instruction in Docker is a command used in Dockerfiles to copy files and directories from a host machine into a Docker image during the build process. It not only facilitates the transfer of local files but also provides additional functionality, such as automatically extracting compressed files and fetching remote files via HTTP or HTTPS. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> comments to 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>. This practice enhances readability and helps future maintainers understand the build process.<\/p>\n
      Advanced Use Cases and Techniques<\/h2>\n
      Dynamic Build Arguments<\/h3>\n
      Multi-stage builds support build arguments, which allow for dynamic configurations during the build process. You can define arguments in the 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> and pass them at build time using the --build-arg<\/code> flag. Here\u2019s an example:<\/p>\n
      # Define build argument\nARG<\/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> NODE_VERSION=14\n\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>:${NODE_VERSION} AS build\n...<\/code><\/pre>\n
      Using BuildKit for Enhanced Features<\/h3>\n
      Docker BuildKit is a modern build subsystem that enhances multi-stage builds with features such as improved caching, parallel builds, and support for secrets. To enable BuildKit, set the environment variable:<\/p>\n
      export DOCKER_BUILDKIT=1<\/code><\/pre>\n
      Then, you can leverage advanced syntax such as 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> --mount<\/code> to mount secrets or caches during the build process:<\/p>\n
      # Use BuildKit's secret<\/a><\/span>The concept of \"secret\" encompasses information withheld from others, often for reasons of privacy, security, or confidentiality. Understanding its implications is crucial in fields such as data protection and communication theory. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> mount\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> --mount=type=secret<\/a><\/span>The concept of \"secret\" encompasses information withheld from others, often for reasons of privacy, security, or confidentiality. Understanding its implications is crucial in fields such as data protection and communication theory. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>,id=mysecret \n    npm install<\/code><\/pre>\n
      Multi-Platform Builds<\/h3>\n
      With multi-platform builds, you can create images that can 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> on different architectures (e.g., x86, ARM) using Docker’s buildx<\/code> command. By specifying the desired platforms, you can build 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> that works across various environments:<\/p>\n
      docker buildx<\/a><\/span>Docker Buildx allows users to build images using advanced features such as multi-platform support and caching. It enhances the Docker build process, enabling efficient and scalable image creation across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> build --platform linux\/amd64,linux\/arm64 -t myapp:latest .<\/code><\/pre>\n
      Combining Multiple Build Stages for Testing<\/h3>\n
      You can incorporate testing into your multi-stage builds. For instance, you can 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> tests in a dedicated stage before moving to production:<\/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 build\n...\n\n# Stage 2: Test\nFROM build AS test\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> npm test\n\n# Stage 3: Production\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 production\n...<\/code><\/pre>\n
      This structure allows you to ensure that only tested and validated code is 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>.<\/p>\n
      Challenges and Considerations<\/h2>\n
      While multi-stage builds offer numerous advantages, there are some challenges and considerations to keep in mind:<\/p>\n
      1. Build Complexity<\/h3>\n
      As the number of stages increases, the 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> can become complex. It’s essential to strike a balance between optimization and maintainability.<\/p>\n
      2. Debugging Difficulty<\/h3>\n
      Debugging multi-stage builds can be more challenging as you have to track down issues across multiple stages. It may be beneficial to build interim images for troubleshooting.<\/p>\n
      3. Layer Limitations<\/h3>\n
      Docker has a limit on the number of layers in an 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>, which can affect very complex multi-stage builds. Keep an eye on the number of layers generated during the build process.<\/p>\n
      Conclusion<\/h2>\n
      Multi-stage builds in Docker are an essential tool for modern application development, enabling developers to create cleaner, smaller, and more efficient images. By understanding their mechanics and best practices, you can optimize your Docker builds, enhance security, and streamline your workflows. As the landscape of containerization continues to evolve, mastering multi-stage builds will undoubtedly remain a valuable skill for developers looking to leverage the full potential of Docker.<\/p>","protected":false},"excerpt":{"rendered":"
      Ein Multi-Stage-Build ist eine Docker-Optimierungstechnik, die die Trennung von Build- und Laufzeitumgebungen erm\u00f6glicht. Durch die Verwendung mehrerer FROM-Anweisungen in einem einzigen Dockerfile<\/a><\/span>Eine Dockerfile ist ein Skript, das eine Reihe von Anweisungen zur Automatisierung der Erstellung von Docker-Images enth\u00e4lt. Sie gibt das Basis-Image, die Anwendungsabh\u00e4ngigkeiten und die Konfiguration an und erm\u00f6glicht so eine konsistente Bereitstellung \u00fcber verschiedene Umgebungen hinweg. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, entwickler k\u00f6nnen optimieren Bild<\/a><\/span>Ein Bild ist eine visuelle Darstellung eines Objekts oder einer Szene, die typischerweise aus Pixeln in digitalen Formaten besteht. Es kann Informationen vermitteln, Emotionen hervorrufen und die Kommunikation \u00fcber verschiedene Medien hinweg erleichtern. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> size and enhance security by excluding unnecessary build dependencies in the final Bild<\/a><\/span>Ein Bild ist eine visuelle Darstellung eines Objekts oder einer Szene, die typischerweise aus Pixeln in digitalen Formaten besteht. Es kann Informationen vermitteln, Emotionen hervorrufen und die Kommunikation \u00fcber verschiedene Medien hinweg erleichtern. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.<\/p>","protected":false},"author":1,"featured_media":1552,"parent":0,"template":"","glossary-cat":[],"class_list":["post-740","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nMulti-Stage Build - 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\/de\/wiki\/multi-stage-build\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Multi-Stage Build - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"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.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/de\/wiki\/multi-stage-build\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-22T20:55:29+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.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=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data1\" content=\"6\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/\",\"name\":\"Multi-Stage Build - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg\",\"datePublished\":\"2024-07-22T20:39:50+00:00\",\"dateModified\":\"2024-07-22T20:55:29+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg\",\"width\":800,\"height\":600,\"caption\":\"multi-stage-build-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#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\":\"Multi-Stage Build\"}]},{\"@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\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@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":"Multi-Stage Build - 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\/de\/wiki\/multi-stage-build\/","og_locale":"de_DE","og_type":"article","og_title":"Multi-Stage Build - Dockerpros","og_description":"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.","og_url":"https:\/\/dockerpros.com\/de\/wiki\/multi-stage-build\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-22T20:55:29+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Gesch\u00e4tzte Lesezeit":"6\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/","url":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/","name":"Multi-Stage Build - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg","datePublished":"2024-07-22T20:39:50+00:00","dateModified":"2024-07-22T20:55:29+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/multi-stage-build\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/multi-stage-build_740.jpg","width":800,"height":600,"caption":"multi-stage-build-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/multi-stage-build\/#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":"Multi-Stage Build"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Docker-Profis","description":"DockerPros \u2013 Ihr umfassender Docker-Ressourcen-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":"de"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Docker-Profis","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"de","@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\/de\/wp-json\/wp\/v2\/glossary\/740","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary\/740\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/media\/1552"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/media?parent=740"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary-cat?post=740"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}