{"id":1333,"date":"2024-07-23T12:21:35","date_gmt":"2024-07-23T12:21:35","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1333"},"modified":"2024-07-23T12:23:47","modified_gmt":"2024-07-23T12:23:47","slug":"dockerfile-cache-from","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cache-from\/","title":{"rendered":"Dockerfile --cache-from"},"content":{"rendered":"

Understanding --cache-from<\/code> in Dockerfile: An Advanced Guide<\/h1>\n

Docker is a powerful tool for containerization, allowing developers to package applications with all their dependencies into standardized units, known as containers. One of the key features of Docker that enhances build efficiency is the --cache-from<\/code> option, which leverages previously built images to speed up the build process. In this article, we will delve into the intricacies of --cache-from<\/code>, exploring its use cases, the benefits it provides, its limitations, and best practices for effectively integrating it into your Docker workflow.<\/p>\n

What is --cache-from<\/code>?<\/h2>\n

The --cache-from<\/code> flag is used with the docker build<\/code> command to specify 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> to be used as a cache source for 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>. When you use --cache-from<\/code>, Docker will check the specified 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 cached layers before attempting to build new layers. This can significantly reduce build times, especially when working with large images or when the same base images are reused across different builds. By utilizing cached layers, --cache-from<\/code> helps in optimizing the build process, leading to faster iterations and reduced resource consumption.<\/p>\n

The Docker Build Process<\/h2>\n

To fully appreciate the advantages of --cache-from<\/code>, it’s essential to understand how Docker handles the build process. When you 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> a docker build<\/code> command, Docker constructs a new 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 by layer, based on the directives specified 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>.<\/p>\n

    \n
  1. \n

    Layering<\/strong>: Each command 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> generates a new layer 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>. For example, 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><\/code>, 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>, 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><\/code> commands create layers that can be cached and reused in subsequent builds.<\/p>\n<\/li>\n

  2. \n

    Caching Mechanism<\/strong>: Docker uses a cache to store these layers. When you rebuild 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>, Docker checks the cache to see if it can reuse an existing layer that matches the current build context. If it finds a match, it avoids re-executing the command, thus speeding up the build process.<\/p>\n<\/li>\n

  3. \n

    Layer Identification<\/strong>: Layers are identified by a combination of the command, the context (files and directories in the build context), and their associated metadata (such as environment variables). If any of these components change, Docker will invalidate the cache for that layer and rebuild it.<\/p>\n<\/li>\n<\/ol>\n

    Use Cases for --cache-from<\/code><\/h2>\n

    1. Multi-Stage Builds<\/h3>\n

    Multi-stage builds are a powerful feature in Docker that allows developers to use 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 can be particularly useful for optimizing 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 separating build environments from final runtime environments. --cache-from<\/code> can be used in multi-stage builds to pull cached layers from previous builds.<\/p>\n

    For example, you might have a multi-stage 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> that builds an application in one stage and then copies the output to a lighter 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> in the final stage. By using --cache-from<\/code> with the 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>, you can speed up the build process significantly.<\/p>\n

    # Dockerfile\nFROM golang:1.16 AS builder\nWORKDIR \/app\nCOPY . .\nRUN go build -o myapp\n\nFROM alpine:latest\nWORKDIR \/app\nCOPY --from=builder \/app\/myapp .\nCMD [\".\/myapp\"]<\/code><\/pre>\n
    You can build this 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> while leveraging a cached version of the builder<\/code> stage:<\/p>\n
    docker build --cache-from myapp:builder -t myapp:latest .<\/code><\/pre>\n
    2. CI\/CD Pipelines<\/h3>\n
    In Continuous Integration and Continuous Deployment (CI\/CD) environments, build times can become a bottleneck. Using --cache-from<\/code> can help to alleviate this issue by allowing the build process to take advantage of previously built layers.<\/p>\n
    By caching images in a remote registry<\/a><\/span>A registry is a centralized database that stores information about various entities, such as software installations, system configurations, or user data. It serves as a crucial component for system management and configuration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, CI\/CD tools can pull these images as cache sources, reducing the time it takes to build new images. For instance, if your CI\/CD pipeline regularly builds Docker images, you can tag the built images with a specific version and use those tags in subsequent builds.<\/p>\n
    docker build --cache-from myregistry\/myapp:latest -t myapp:latest .<\/code><\/pre>\n
    3. Frequent Development Iterations<\/h3>\n
    During active development, developers often rebuild images several times a day. In such cases, using --cache-from<\/code> can drastically reduce build times by using a previously built 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> as a cache source. This is particularly useful when 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> or application dependencies have not changed significantly.<\/p>\n
    For example, if you are working on a microservice that relies on a shared 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 that 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> as a cache source:<\/p>\n
    docker build --cache-from myregistry\/mybaseimage:latest -t myservice:latest .<\/code><\/pre>\n
    Benefits of Using --cache-from<\/code><\/h2>\n
    1. Reduced Build Times<\/h3>\n
    The primary advantage of using --cache-from<\/code> is the significant reduction in build times. By reusing cached layers from previous builds, Docker can skip execution of commands that have not changed, leading to faster builds.<\/p>\n
    2. Efficient Resource Utilization<\/h3>\n
    By tapping into cached layers, --cache-from<\/code> minimizes the resources required for the build process. This is particularly important in environments with limited resources or where multiple builds are being executed concurrently.<\/p>\n
    3. Improved Development Workflow<\/h3>\n
    For developers, reduced build times translate to quicker feedback loops, allowing for more efficient iterations during the development process. This can enhance overall productivity and improve the quality of the software being developed.<\/p>\n
    4. Consistency Across Builds<\/h3>\n
    Using --cache-from<\/code> can help ensure consistency across builds, especially in CI\/CD environments. By utilizing a common cache source, teams can achieve reproducible builds, making it easier to diagnose issues and maintain application stability.<\/p>\n
    Limitations of --cache-from<\/code><\/h2>\n
    While --cache-from<\/code> provides several advantages, it also has limitations that developers should be aware of:<\/p>\n
    1. Cache Invalidation<\/h3>\n
    Docker’s caching mechanism relies on a combination of commands, file changes, and metadata. Any change in these aspects can lead to cache invalidation, resulting in a layer being rebuilt even if it was previously cached. This could lead to longer build times if not managed properly.<\/p>\n
    2. Cache Size Limitations<\/h3>\n
    When using --cache-from<\/code>, the size of the cache can impact performance. If the cached 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 too large, it may take longer to pull 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> from a remote registry<\/a><\/span>A registry is a centralized database that stores information about various entities, such as software installations, system configurations, or user data. It serves as a crucial component for system management and configuration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, negating some of the benefits of caching. Keeping images lean and manageable can help mitigate this issue.<\/p>\n
    3. Network Dependency<\/h3>\n
    Using remote images as cache sources introduces a dependency on network<\/a><\/span>A network, in computing, refers to a collection of interconnected devices that communicate and share resources. It enables data exchange, facilitates collaboration, and enhances operational efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> availability. If the cache 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 not available due to network<\/a><\/span>A network, in computing, refers to a collection of interconnected devices that communicate and share resources. It enables data exchange, facilitates collaboration, and enhances operational efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> issues or if it has been removed from the registry<\/a><\/span>A registry is a centralized database that stores information about various entities, such as software installations, system configurations, or user data. It serves as a crucial component for system management and configuration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, the build process may fail or take longer than expected.<\/p>\n
    Best Practices for Using --cache-from<\/code><\/h2>\n
    To make the most out of --cache-from<\/code>, consider the following best practices:<\/p>\n
    1. Tagging and Versioning Images<\/h3>\n
    Use meaningful tags and version numbers for your images in the registry<\/a><\/span>A registry is a centralized database that stores information about various entities, such as software installations, system configurations, or user data. It serves as a crucial component for system management and configuration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This practice not only helps in identifying cached layers but also ensures that the correct versions are being used in your build process.<\/p>\n
    2. Regularly Clean Up Unused Images<\/h3>\n
    Regularly clean up unused images and layers from your Docker host and your registry<\/a><\/span>A registry is a centralized database that stores information about various entities, such as software installations, system configurations, or user data. It serves as a crucial component for system management and configuration. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This helps to maintain a clean environment and ensures that you’re not using stale or outdated cache layers in your builds.<\/p>\n
    3. Monitor Build Performance<\/h3>\n
    Keep an eye on build performance and cache usage. Tools like Docker’s buildkit can provide insights into layer caching and help identify bottlenecks in your build process. This information can guide you in optimizing your Dockerfiles for better cache utilization.<\/p>\n
    4. Leverage Multi-Stage Builds<\/h3>\n
    Whenever possible, utilize multi-stage builds to keep your final images small and focused. This not only improves build performance when using --cache-from<\/code> but also enhances security by reducing the attack surface of your images.<\/p>\n
    5. Use BuildKit<\/h3>\n
    Docker BuildKit is an advanced build subsystem that improves build performance and efficiency. Enabling BuildKit can provide better caching capabilities and support for the --cache-from<\/code> option. To enable BuildKit, you can set the environment variable DOCKER_BUILDKIT=1<\/code> before your build command.<\/p>\n
    Conclusion<\/h2>\n
    The --cache-from<\/code> feature in Docker is an invaluable tool for optimizing 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> builds, especially in development and CI\/CD environments. By effectively leveraging cached layers from previously built images, developers can significantly reduce build times, improve resource utilization, and enhance overall workflow efficiency. However, it’s essential to be aware of the limitations and to follow best practices to ensure effective use of --cache-from<\/code>.<\/p>\n
    As containerization continues to gain traction, understanding and utilizing advanced features like --cache-from<\/code> will be crucial for developers aiming to streamline their workflows and enhance productivity. By incorporating this feature into your Docker build strategy, you can forge a more efficient and robust development process that keeps pace with the rapid evolution of software development.<\/p>","protected":false},"excerpt":{"rendered":"
    L'option `\u2013cache-from` dans 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> builds allows users to leverage cached layers from existing images. This can significantly speed up the build process by reusing previously built layers, reducing redundancy and improving efficiency.<\/p>","protected":false},"author":1,"featured_media":1979,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1333","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -cache-from - 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\/dockerfile-cache-from\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -cache-from - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--cache-from` option in Dockerfile builds allows users to leverage cached layers from existing images. This can significantly speed up the build process by reusing previously built layers, reducing redundancy and improving efficiency.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cache-from\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:23:47+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.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=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/\",\"name\":\"Dockerfile -cache-from - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg\",\"datePublished\":\"2024-07-23T12:21:35+00:00\",\"dateModified\":\"2024-07-23T12:23:47+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-cache-from-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#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 –cache-from\"}]},{\"@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":"Dockerfile -cache-from - 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\/dockerfile-cache-from\/","og_locale":"fr_FR","og_type":"article","og_title":"Dockerfile -cache-from - Dockerpros","og_description":"The `--cache-from` option in Dockerfile builds allows users to leverage cached layers from existing images. This can significantly speed up the build process by reusing previously built layers, reducing redundancy and improving efficiency.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cache-from\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:23:47+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/","name":"Dockerfile -cache-from - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg","datePublished":"2024-07-23T12:21:35+00:00","dateModified":"2024-07-23T12:23:47+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-from_1333.jpg","width":800,"height":600,"caption":"dockerfile-cache-from-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-from\/#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 –cache-from"}]},{"@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\/1333","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\/1333\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/1979"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1333"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1333"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}