{"id":1378,"date":"2024-07-23T12:39:20","date_gmt":"2024-07-23T12:39:20","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1378"},"modified":"2024-07-23T12:39:20","modified_gmt":"2024-07-23T12:39:20","slug":"succes-echec-du-cache","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cache-hit-miss\/","title":{"rendered":"Dockerfile \u2013cache-hit-miss"},"content":{"rendered":"

Understanding Docker’s Build Cache: The –cache-hit-miss Flag<\/h2>\n

Docker is an essential tool for modern application development, allowing developers to create, deploy, and 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> applications inside containers. One of the most powerful features of Docker is its ability to cache build layers, which significantly speeds up the build process. The --cache-hit-miss<\/code> flag is a relatively new addition to Docker that provides insights into caching behavior during the build process. This article delves deep into the mechanics of Docker’s build cache, the implications of using the --cache-hit-miss<\/code> flag, and best practices to optimize 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> for efficient builds.<\/p>\n

The Basics of Docker Build<\/h2>\n

Before we explore the --cache-hit-miss<\/code> flag, let’s briefly review how Docker’s build process works. When you execute a docker build<\/code> command, Docker processes each instruction 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><\/code> sequentially, creating intermediate images for each layer. Layers in Docker are immutable, which means that if the content of a layer hasn\u2019t changed, Docker can reuse it during subsequent builds. This caching mechanism drastically reduces build times, especially for large applications with numerous dependencies.<\/p>\n

For example, consider the following simple 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><\/code>:<\/p>\n

FROM ubuntu:latest\n\nRUN apt-get update && apt-get install -y python3\nCOPY . \/app\nWORKDIR \/app\nRUN pip install -r requirements.txt\nCMD [\"python3\", \"app.py\"]<\/code><\/pre>\n
In this case, Docker will cache the results of the apt-get update<\/code> and pip install<\/code> commands. If you modify a file in the \/app<\/code> directory but do not change 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>, the apt-get update<\/code> layer will be reused, significantly speeding up the build process.<\/p>\n
What is the –cache-hit-miss Flag?<\/h2>\n
The --cache-hit-miss<\/code> flag was introduced as part of Docker BuildKit to help developers understand the cache efficiency of their builds. When you use this flag while building your Docker images, Docker will output additional information about each build step, indicating whether the layer was a cache hit (reused from a previous build) or a cache miss (built from scratch).<\/p>\n
For instance, running the following command with the --cache-hit-miss<\/code> flag:<\/p>\n
DOCKER_BUILDKIT=1 docker build --cache-hit-miss -t myapp .<\/code><\/pre>\n
might yield an output like this:<\/p>\n
#1 [internal] load build definition from Dockerfile\n#1 sha256:abcd1234...\n#1 transferring 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>: 32B 0.0s done\n#2 [internal] load .dockerignore\n#2 sha256:abcd1234...\n#2 transferring context: 2B 0.0s done\n#3 [1\/4] FROM ubuntu:latest\n#3 sha256:abcd1234...\n#3 pulling ubuntu:latest...\n#4 [2\/4] 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> apt-get update && apt-get install -y python3\n#4 CACHED\n#5 [3\/4] 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> . \/app\n#5 sha256:abcd1234...\n#6 [4\/4] 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> pip install -r requirements.txt\n#6 MISS<\/code><\/pre>\n
In this output, you can see that the 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> apt-get update<\/code> step was a cache hit, while the 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> pip install -r requirements.txt<\/code> step was a cache miss. This detailed information allows developers to analyze their 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> for inefficiencies, identify which layers are causing delays, and optimize the build process accordingly.<\/p>\n
The Importance of Cache Hits and Misses<\/h2>\n
Understanding cache hits and misses is crucial for several reasons:<\/p>\n
1. Build Performance<\/h3>\n
As mentioned earlier, cache hits can significantly reduce build times. By analyzing which layers are cache misses, developers can adjust their 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><\/code> to maximize cache hits, leading to faster builds and a more efficient CI\/CD pipeline.<\/p>\n
2. Resource Efficiency<\/h3>\n
Cache misses often lead to unnecessary resource consumption. When layers are rebuilt from scratch, they consume CPU, memory, and storage, which can lead to longer build times and increased costs, especially when using cloud-based CI\/CD services. Understanding the cache behavior can help optimize resource usage.<\/p>\n
3. Debugging<\/h3>\n
When a build fails, knowing whether layers were cache hits or misses can aid in debugging. If a cache hit caused a failure in subsequent layers, you might need to investigate the underlying reasons instead of focusing solely on the last command executed.<\/p>\n
4. Best Practices Implementation<\/h3>\n
The --cache-hit-miss<\/code> flag can help reinforce best practices in 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> creation. By providing visibility into the caching behavior, developers can continually refine their Dockerfiles for optimal performance.<\/p>\n
Analyzing Dockerfile Instructions for Cache Efficiency<\/h2>\n
To maximize cache hits and minimize misses, developers should consider how each instruction in their 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><\/code> interacts with the build cache. Here are some guidelines to analyze and optimize 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> instructions:<\/p>\n
1. Ordering Instructions<\/h3>\n
Docker caches layers based on the order of instructions. Instructions that are less likely to change should be placed higher 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>. This means that frequent changes should be minimized in layers that are executed earlier. For example:<\/p>\n
# Good: Less frequently changing instructions at the top\nFROM ubuntu:latest\n\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> apt-get update && apt-get install -y python3\n# More stable dependencies should be higher\n\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> . \/app\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\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> pip install -r requirements.txt<\/code><\/pre>\n
If you frequently modify application code, consider placing 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> . \/app<\/code> instruction below the installation of dependencies.<\/p>\n
2. Grouping Instructions<\/h3>\n
Group related commands into a single 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> instruction. This can reduce the number of layers created, which can help optimize the caching mechanism:<\/p>\n
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> apt-get update && \n    apt-get install -y python3 && \n    apt-get clean && \n    rm -rf \/var\/lib\/apt\/lists\/*<\/code><\/pre>\n
By combining commands, you can reduce the cache footprint and improve build performance.<\/p>\n
3. Utilize .dockerignore<\/h3>\n
The .dockerignore<\/code> file can prevent unnecessary files 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>, which can optimize the build context and, consequently, the cache. Ignoring files and directories that are not relevant to the build process can improve cache effectiveness.<\/p>\n
4. Version Pinning<\/h3>\n
When installing dependencies, consider explicitly pinning versions in your requirements.txt<\/code> or equivalent files. This can help ensure that the same version is installed across builds, thereby increasing the likelihood of cache hits:<\/p>\n
# requirements.txt\nFlask==1.1.2\nrequests==2.24.0<\/code><\/pre>\n
5. Multi-Stage Builds<\/h3>\n
Using multi-stage builds can help separate the build environment from the runtime environment, which can lead to smaller images and more cache hits. Here\u2019s a basic example:<\/p>\n
# First stage: build the application\nFROM python:3.8 AS builder\nWORKDIR \/app\nCOPY requirements.txt requirements.txt\nRUN pip install -r requirements.txt\n\n# Second stage: create the runtime image\nFROM python:3.8-slim\nWORKDIR \/app\nCOPY --from=builder \/app \/app\nCOPY . \/app\nCMD [\"python3\", \"app.py\"]<\/code><\/pre>\n
In this example, the dependencies are cached in the builder stage, and you can further optimize this stage by applying the previously mentioned techniques.<\/p>\n
Monitoring the Cache Effectiveness<\/h2>\n
The --cache-hit-miss<\/code> flag is an excellent first step in understanding cache effectiveness, but continuous monitoring can provide deeper insights. Consider implementing the following strategies:<\/p>\n
1. Logging Build Outputs<\/h3>\n
Capture the output of Docker builds and store it for analysis. By aggregating this data, you can identify trends in cache hits and misses over time.<\/p>\n
2. CI\/CD Integration<\/h3>\n
Integrate cache monitoring into your CI\/CD pipelines. Tools like Jenkins, CircleCI, or GitHub Actions can be configured to capture build logs and generate reports on cache utilization.<\/p>\n
3. Review and Refactor<\/h3>\n
Regularly review your Dockerfiles as the application evolves. Refactoring may be necessary to maintain optimal cache efficiency as dependencies change or new patterns emerge.<\/p>\n
Conclusion<\/h2>\n
The --cache-hit-miss<\/code> flag is a powerful tool for developers looking to optimize their Docker builds. By understanding cache behavior and following best practices, you can reduce build times, improve resource efficiency, and foster a more streamlined development process. As Docker continues to evolve, staying informed about new features and updates will help you leverage the full potential of containerization in your application development journey.<\/p>\n
The ability to analyze build processes and make informed decisions based on cache efficiency will ultimately contribute to a more productive and effective workflow, ensuring that your applications are built swiftly and reliably. Embrace the power of Docker\u2019s caching mechanism, and start optimizing your build pipeline today.<\/p>","protected":false},"excerpt":{"rendered":"
L'option `\u2013cache-hit-miss` 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> La gestion fournit des informations sur l'efficacit\u00e9 de la mise en cache des couches. Elle indique si le cache a \u00e9t\u00e9 utilis\u00e9 pendant le processus de construction, ce qui facilite l'optimisation et le d\u00e9pannage.<\/p>","protected":false},"author":1,"featured_media":2069,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1378","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -cache-hit-miss - 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\/succes-echec-du-cache\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -cache-hit-miss - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--cache-hit-miss` option in Dockerfile management provides insights into layer caching efficiency. It reports whether cache was used during the build process, aiding optimization and troubleshooting.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/succes-echec-du-cache\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.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=\"6 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-hit-miss\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/\",\"name\":\"Dockerfile -cache-hit-miss - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg\",\"datePublished\":\"2024-07-23T12:39:20+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-cache-hit-miss-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#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-hit-miss\"}]},{\"@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-hit-miss - 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\/succes-echec-du-cache\/","og_locale":"fr_FR","og_type":"article","og_title":"Dockerfile -cache-hit-miss - Dockerpros","og_description":"The `--cache-hit-miss` option in Dockerfile management provides insights into layer caching efficiency. It reports whether cache was used during the build process, aiding optimization and troubleshooting.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/succes-echec-du-cache\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/","name":"Dockerfile -cache-hit-miss - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg","datePublished":"2024-07-23T12:39:20+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-hit-miss_1378.jpg","width":800,"height":600,"caption":"dockerfile-cache-hit-miss-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-hit-miss\/#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-hit-miss"}]},{"@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\/1378","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\/1378\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/2069"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1378"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1378"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}