{"id":1245,"date":"2024-07-23T12:16:09","date_gmt":"2024-07-23T12:16:09","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1245"},"modified":"2024-07-23T12:21:37","modified_gmt":"2024-07-23T12:21:37","slug":"arguments-de-construction-docker","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/docker-build-args\/","title":{"rendered":"Docker Build Args"},"content":{"rendered":"

Understanding Docker Build Args: An Advanced Guide<\/h1>\n

Docker Build Args, or Build Arguments, are variables that are passed at build-time to 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>, allowing for flexible and dynamic configuration of Docker images. They facilitate the construction of images that can adapt to different environments, systems, and requirements without necessitating a complete rewriting or duplication of 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>. This article delves into the intricacies of Docker Build Args, exploring their purpose, practical applications, limitations, best practices, and some advanced use-cases that can enhance your development workflows.<\/p>\n

Why Use Build Args?<\/h2>\n

In any software development lifecycle, the ability to customize configurations based on the environment\u2014be it development, testing, or production\u2014is crucial. Docker Build Args provide a mechanism to achieve this by enabling developers to specify variable values that can be utilized within 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>.<\/p>\n

Use Cases for Build Args<\/h3>\n
    \n
  1. \n

    Configuration Management<\/strong>: By using Build Args, developers can manage application configurations dynamically. For instance, API<\/a><\/span>An API, or Application Programming Interface, enables software applications to communicate and interact with each other. It defines protocols and tools for building software and facilitating integration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> keys or database connection strings can be passed securely during the build process.<\/p>\n<\/li>\n

  2. \n

    Environment-Specific Settings<\/strong>: If you need to build 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> that behaves differently based on the environment (e.g., staging vs. production), Build Args can handle such variations seamlessly.<\/p>\n<\/li>\n

  3. \n

    Customizable Builds<\/strong>: Advanced use cases, such as multi-architecture builds, can leverage Build Args to specify different base images or dependencies.<\/p>\n<\/li>\n

  4. \n

    Minimizing 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>: You can use Build Args to determine whether to include optional components, thereby streamlining 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.<\/p>\n<\/li>\n<\/ol>\n

    Defining Build Args in Dockerfile<\/h2>\n

    To create Build Args 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>, you use the 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> instruction. This specifies the name of the variable that can be passed during the build process. Here\u2019s an example:<\/p>\n

    # Define the 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# Use the build argument\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}<\/code><\/pre>\n
    In this example, NODE_VERSION<\/code> is defined as a build argument with a default value of 14<\/code>. If a different version is needed, it can be overridden when building 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>.<\/p>\n
    Building the Image with Build Args<\/h2>\n
    When building a Docker 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 pass your build arguments using the --build-arg<\/code> flag. Here\u2019s how to build the above 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> with a different 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 version:<\/p>\n
    docker build --build-arg NODE_VERSION=16 -t my-node-app .<\/code><\/pre>\n
    This command will override the default value of NODE_VERSION<\/code>, pulling from 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 version 16<\/code> instead.<\/p>\n
    Limitations of Build Args<\/h2>\n
    Understanding the limitations of Build Args is just as critical as knowing how to use them properly. Here are some important points to consider:<\/p>\n
      \n
    1. \n
      Scope<\/strong>: Build Args are only available during the build process. Once 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> is built, they are not accessible in the running 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<\/li>\n
    2. \n
      No Default Values until Overridden<\/strong>: If a Build 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> is declared without a default value and not provided at build time, it will be empty.<\/p>\n<\/li>\n
    3. \n
      Sensitive Data<\/strong>: While Build Args can help manage sensitive configurations, they do not inherently support secure storage of secrets. Environment variables or Docker secrets are preferred for sensitive data.<\/p>\n<\/li>\n
    4. \n
      Build-time Only<\/strong>: Any configuration managed through Build Args must be resolved at build time. Changes made at runtime will not affect the underlying 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
      Best Practices for Using Build Args<\/h2>\n
      To utilize Build Args effectively, consider the following best practices:<\/p>\n
      1. Use Default Values Wisely<\/h3>\n
      Always provide sensible default values for your Build Args. This facilitates easier builds without requiring the user to specify every argument.<\/p>\n
      2. Document Your Build Args<\/h3>\n
      Document your Build Args within 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> or in accompanying documentation. This is crucial for team members who may not be familiar with the build process.<\/p>\n
      3. Keep Sensitive Information Out<\/h3>\n
      Avoid passing sensitive data (like passwords or API<\/a><\/span>An API, or Application Programming Interface, enables software applications to communicate and interact with each other. It defines protocols and tools for building software and facilitating integration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> keys) directly through Build Args. Opt for environment variables or Docker secrets instead.<\/p>\n
      4. Limit the Number of Build Args<\/h3>\n
      Having too many Build Args can complicate 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 lead to confusion. Keep them to a minimum and only include those that are absolutely necessary.<\/p>\n
      Advanced Use-Cases of Build Args<\/h2>\n
      Multi-Stage Builds<\/h3>\n
      Multi-stage builds are a powerful feature in Docker that allows for more efficient images by separating build and runtime environments. You can use Build Args to customize each stage. Here’s an example:<\/p>\n
      # Stage 1: Builder\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\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 builder\n\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 .\/\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 install\n\n# Stage 2: Final Image\nFROM nginx:alpine\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> --from=builder \/app \/usr\/share\/nginx\/html<\/code><\/pre>\n
      In this example, the NODE_VERSION<\/code> is used in the builder stage to ensure that the appropriate 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 version is utilized.<\/p>\n
      Conditional Logic with Build Args<\/h3>\n
      You can also create conditional logic in 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> using Build Args. This can be particularly useful for including optional dependencies:<\/p>\n
      ARG INCLUDE_TESTS=false\n\nRUN if [ \"$INCLUDE_TESTS\" = \"true\" ]; then \n      apt-get update && apt-get install -y test-dependencies; \n    fi<\/code><\/pre>\n
      This allows you to conditionally install packages based on the value of the INCLUDE_TESTS<\/code> Build 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>.<\/p>\n
      Building for Multiple Architectures<\/h3>\n
      Docker Build Args can facilitate building images for multiple architectures. For example, you can define different base images for different architectures:<\/p>\n
      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> BASE_IMAGE=alpine\n\nFROM ${BASE_IMAGE}<\/code><\/pre>\n
      You can then pass different values of BASE_IMAGE<\/code> depending on the target architecture, allowing for greater flexibility in your CI\/CD pipelines.<\/p>\n
      Debugging and Testing Build Args<\/h2>\n
      When working with Build Args, debugging can be challenging due to their build-time scope. Here are some techniques for testing and debugging:<\/p>\n
      1. Use Echo Statements<\/h3>\n
      Inserting simple echo statements in 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> can help you verify the values being used:<\/p>\n
      RUN echo \"Node version is: ${NODE_VERSION}\"<\/code><\/pre>\n
      2. Inspect the Image<\/h3>\n
      After building 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>, you can inspect it using the docker inspect<\/code> command. This will help you understand the final configuration, although it won\u2019t show Build Args directly.<\/p>\n
      3. Analyze Build Output<\/h3>\n
      Pay attention to the output of the docker build<\/code> command. It will indicate which Build Args are being utilized and can help identify any potential issues.<\/p>\n
      Conclusion<\/h2>\n
      Docker Build Args are an invaluable feature for developers who require flexibility and customization in their Docker images. They enable dynamic configuration management, environment-specific settings, and can streamline the build process.<\/p>\n
      By understanding how to effectively implement and leverage Build Args, you can enhance your Docker workflows, create more robust CI\/CD pipelines, and ultimately improve your application\u2019s deployment and scalability. Remember to adhere to best practices, be aware of the limitations, and continuously explore advanced use-cases to maximize the potential of Docker in your projects. <\/p>\n
      As Docker continues to evolve, so do the techniques and practices surrounding it. Staying informed and experimenting with new features will keep your Docker skills sharp and your applications performant.<\/p>","protected":false},"excerpt":{"rendered":"
      Les arguments de construction Docker permettent aux utilisateurs de passer des variables au moment de la construction, offrant ainsi une flexibilit\u00e9 dans les Dockerfiles. Cette fonctionnalit\u00e9 permet de personnaliser les images sans coder en dur les valeurs, am\u00e9liorant ainsi la r\u00e9utilisabilit\u00e9 et la maintenabilit\u00e9.<\/p>","protected":false},"author":1,"featured_media":1807,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1245","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDocker Build Args - 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\/fr\/wiki\/arguments-de-construction-docker\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Docker Build Args - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"Docker Build Args allow users to pass variables at build time, providing flexibility in Dockerfiles. This feature enables customization of images without hardcoding values, enhancing reusability and maintainability.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:21:37+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.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=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data1\" content=\"5 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/\",\"url\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/\",\"name\":\"Docker Build Args - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg\",\"datePublished\":\"2024-07-23T12:16:09+00:00\",\"dateModified\":\"2024-07-23T12:21:37+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg\",\"width\":800,\"height\":600,\"caption\":\"docker-build-args-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#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\":\"Docker Build Args\"}]},{\"@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\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@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":"Docker Build Args - 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\/fr\/wiki\/arguments-de-construction-docker\/","og_locale":"fr_FR","og_type":"article","og_title":"Docker Build Args - Dockerpros","og_description":"Docker Build Args allow users to pass variables at build time, providing flexibility in Dockerfiles. This feature enables customization of images without hardcoding values, enhancing reusability and maintainability.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:21:37+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/","url":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/","name":"Docker Build Args - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg","datePublished":"2024-07-23T12:16:09+00:00","dateModified":"2024-07-23T12:21:37+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-build-args_1245.jpg","width":800,"height":600,"caption":"docker-build-args-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/fr\/wiki\/arguments-de-construction-docker\/#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":"Docker Build Args"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Dockerpros","description":"DockerPros \u2013 Votre centre de ressources Docker incontournable","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":"fr-FR"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Dockerpros","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@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\/fr\/wp-json\/wp\/v2\/glossary\/1245","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary\/1245\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/1807"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1245"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1245"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}