{"id":1409,"date":"2024-07-23T12:39:34","date_gmt":"2024-07-23T12:39:34","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1409"},"modified":"2024-07-23T12:39:34","modified_gmt":"2024-07-23T12:39:34","slug":"aggiornamento-cache-dockerfile","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/it\/wiki\/dockerfile-cache-update\/","title":{"rendered":"Dockerfile \u2013cache-update"},"content":{"rendered":"

Advanced Dockerfile Caching: Understanding –cache-update<\/h1>\n

When building Docker images, the process of caching is crucial for optimizing build times and managing dependencies efficiently. The --cache-update<\/code> flag is a relatively new addition to the Docker command-line interface, introduced to enhance the caching behavior during 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. Understanding how --cache-update<\/code> works and how it can be integrated into 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 significantly improve your development workflow. This article dives deep into the mechanics of the --cache-update<\/code> flag, its practical implications, and advanced strategies to leverage it effectively.<\/p>\n

What is Docker Caching?<\/h2>\n

Docker caching is a mechanism that allows Docker to reuse previously built layers of images instead of rebuilding them from scratch. Each command 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> generates a layer, and Docker checks if it can reuse an existing layer based on the command and its context. This caching mechanism drastically speeds up the build process, especially when dealing with large applications or numerous dependencies.<\/p>\n

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

FROM python:3.9-slim\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\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> requirements.txt .\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> pip install -r requirements.txt\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> . .<\/code><\/pre>\n
In this case, Docker caches each layer. If you only change your application code but not the requirements.txt<\/code> file, Docker can reuse the cached layer for the pip install<\/code> command, significantly speeding up builds.<\/p>\n
The Problem with Outdated Caches<\/h2>\n
While caching improves build performance, it can cause issues if your dependencies are outdated. This problem is particularly prevalent when working in environments where dependencies change frequently or when pulling from external repositories. If the cached layer is not updated, you may encounter build failures or 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 risk of deploying outdated code.<\/p>\n
To address this, Docker introduced the --cache-update<\/code> flag, which allows developers to ensure that 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> and its dependencies are up-to-date when building 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>.<\/p>\n
What is –cache-update?<\/h2>\n
The --cache-update<\/code> option can be applied to the docker build<\/code> command. When used, Docker will update the cache for 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><\/code> instructions 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> that rely on external sources\u2014like package managers or repositories\u2014ensuring that the most recent versions are fetched. This is especially useful for languages and frameworks with regularly updated dependencies (e.g., 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, Python, Ruby).<\/p>\n
Syntax and Usage<\/h3>\n
The syntax for using --cache-update<\/code> is straightforward:<\/p>\n
docker build --cache-update -t your-image-name .<\/code><\/pre>\n
This command will evaluate 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>, updating any cached layers associated with commands that fetch external resources.<\/p>\n
Example Usage<\/h3>\n
Here\u2019s an illustrative example using 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> for a Node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.js application:<\/p>\n
FROM node:16\n\nWORKDIR \/app\n\nCOPY package.json package-lock.json .\/\n\nRUN npm install\n\nCOPY . .\n\nCMD [\"node\", \"server.js\"]<\/code><\/pre>\n
To 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> ensuring that the npm install<\/code> command fetches the latest packages, you would 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>:<\/p>\n
docker build --cache-update -t node-app .<\/code><\/pre>\n
In this context, if any dependencies in your package.json<\/code> have changed, they will be updated during the build process.<\/p>\n
Benefits of Using –cache-update<\/h2>\n
The introduction of --cache-update<\/code> brings several advantages:<\/p>\n
1. Up-to-Date Dependencies<\/h3>\n
The primary benefit is that it ensures you are working with the latest versions of your dependencies. This is crucial in production environments where security vulnerabilities can arise from outdated packages.<\/p>\n
2. Faster Debugging<\/h3>\n
When you use the --cache-update<\/code> flag, you can quickly rebuild your 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> and verify if recent changes to dependencies resolve any issues. This reduces the time spent debugging outdated dependencies.<\/p>\n
3. Enhanced Development Workflow<\/h3>\n
By incorporating --cache-update<\/code>, developers can make changes and rebuild images without worrying about stale caches. This leads to a more seamless development experience.<\/p>\n
4. Reduced Risk of Build Failures<\/h3>\n
Using --cache-update<\/code> minimizes the risk of encountering errors due to outdated packages, as you are assured of using the latest versions during the build.<\/p>\n
Understanding –cache-update in Detail<\/h2>\n
How the Caching Mechanism Works<\/h3>\n
To comprehend --cache-update<\/code>, one must first understand how Docker\u2019s caching mechanism operates. When a Docker build command runs, Docker evaluates each instruction in the Dockerfile from<\/a><\/span>The \"FROM\" instruction in a Dockerfile specifies the base image for the container. It sets the initial environment and determines layers for subsequent commands, crucial for efficient image builds. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> top to bottom, checking if a cached version of the layer already exists.<\/p>\n
    \n
  1. \n
    Checksum Comparison<\/strong>: Docker computes a checksum for each instruction and its context (including the files it references). If it finds a matching cached layer, it reuses it.<\/p>\n<\/li>\n
  2. \n
    Layer Invalidation<\/strong>: If any part of the context changes (e.g., a modification in a file referenced in 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), Docker invalidates the cache for that layer and all subsequent layers.<\/p>\n<\/li>\n
  3. \n
    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> Calls<\/strong>: When a 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 makes a 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> call (e.g., fetching package updates), Docker checks if the cache is stale. This is where --cache-update<\/code> shines.<\/p>\n<\/li>\n<\/ol>\n
    Impact on Layer Caching<\/h4>\n
    When --cache-update<\/code> is used, Docker adds an additional layer of caching for 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> calls made during the build. This means that any external resources fetched during 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><\/code> instruction are always considered for updates, ensuring that you have the latest dependencies.<\/p>\n
    Limitations of –cache-update<\/h3>\n
    While --cache-update<\/code> provides significant benefits, there are a few limitations and considerations to keep in mind:<\/p>\n
      \n
    1. \n
      Increased Build Time<\/strong>: Using the --cache-update<\/code> flag may lead to longer build times in scenarios where your dependencies rarely change, as it forces Docker to fetch the latest versions every time.<\/p>\n<\/li>\n
    2. \n
      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> Dependency<\/strong>: The flag relies 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> access to fetch updates. If there are connectivity issues, builds may fail.<\/p>\n<\/li>\n
    3. \n
      No Control Over Versioning<\/strong>: By fetching the latest versions of dependencies, you lose control over specific versions that your application may require. This can lead to instability if newer versions introduce breaking changes.<\/p>\n<\/li>\n<\/ol>\n
      Best Practices for Using –cache-update<\/h2>\n
      To maximize the benefits of --cache-update<\/code>, consider these best practices:<\/p>\n
      1. Conditional Use<\/h3>\n
      Only use --cache-update<\/code> when necessary. For example, in production builds, where stability is paramount, you might want to rely on pinned versions in your dependency files.<\/p>\n
      2. Combine with Versioning<\/h3>\n
      To mitigate the risk of breaking changes, consider using version ranges in your dependency files. This allows you to fetch updates while maintaining some level of control over which versions are installed.<\/p>\n
      3. Use Build Arguments<\/h3>\n
      Use Docker build arguments to toggle the use of --cache-update<\/code> dynamically. This allows you to switch between development (where you want the latest dependencies) and production modes (where you prefer stability).<\/p>\n
      ARG USE_CACHE_UPDATE=false\n\nRUN if [ \"$USE_CACHE_UPDATE\" = true ]; then \n        npm install --cache-update; \n    else \n        npm install; \n    fi<\/code><\/pre>\n
      4. Testing and CI\/CD Pipelines<\/h3>\n
      Integrate --cache-update<\/code> into your CI\/CD pipelines to ensure that every build fetches the latest dependencies during your testing phase. This helps catch potential issues early before deploying to production.<\/p>\n
      5. Embrace Layering<\/h3>\n
      Utilize multi-stage builds to separate the fetching of dependencies from your application code. This way, you can control what gets updated without affecting your application layers unnecessarily.<\/p>\n
      FROM node:16 AS builder\n\nWORKDIR \/app\n\nCOPY package.json package-lock.json .\/\nRUN npm install --cache-update\n\nCOPY . .\n\nFROM node:16\n\nWORKDIR \/app\nCOPY --from=builder \/app .\n\nCMD [\"node\", \"server.js\"]<\/code><\/pre>\n
      Conclusion<\/h2>\n
      The --cache-update<\/code> option is a powerful addition to Docker\u2019s toolset for managing dependencies and optimizing build processes. By allowing developers to fetch the latest versions of dependencies during 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, it enhances stability, performance, and productivity. However, with great power comes great responsibility; understanding when and how to use this feature is crucial for maintaining robust and efficient Docker workflows.<\/p>\n
      As you embark on your journey with Docker, consider integrating --cache-update<\/code> into your builds when appropriate. By doing so, you’ll not only improve your development experience but also ensure that your applications are built on the most current and secure stack<\/a><\/span>A stack is a data structure that operates on a Last In, First Out (LIFO) principle, where the most recently added element is the first to be removed. It supports two primary operations: push and pop. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> of dependencies. Embrace this tool, and take your Docker capabilities to the next level!<\/p>","protected":false},"excerpt":{"rendered":"
      L'opzione `\u2013cache-update` in Dockerfile<\/a><\/span>Un Dockerfile \u00e8 uno script contenente una serie di istruzioni per automatizzare la creazione di immagini Docker. Specifica l'immagine di base, le dipendenze dell'applicazione e la configurazione, facilitando la distribuzione coerente in diversi ambienti. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> allows users to refresh the build cache for specific layers. This ensures that dependencies and base images are updated without rebuilding the entire immagine<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, ottimizzando l'efficienza costruttiva.<\/p>","protected":false},"author":1,"featured_media":2131,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1409","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -cache-update - Dockerpros<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/dockerpros.com\/it\/wiki\/aggiornamento-cache-dockerfile\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -cache-update - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--cache-update` option in Dockerfile allows users to refresh the build cache for specific layers. This ensures that dependencies and base images are updated without rebuilding the entire image, optimizing build efficiency.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/it\/wiki\/aggiornamento-cache-dockerfile\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"800\" \/>\n\t<meta property=\"og:image:height\" content=\"600\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/\",\"name\":\"Dockerfile -cache-update - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg\",\"datePublished\":\"2024-07-23T12:39:34+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-cache-update-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#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-update\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/dockerpros.com\/#website\",\"url\":\"https:\/\/dockerpros.com\/\",\"name\":\"Dockerpros\",\"description\":\"DockerPros \u2013 Your Ultimate Docker Resource Hub\",\"publisher\":{\"@id\":\"https:\/\/dockerpros.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/dockerpros.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"width\":532,\"height\":114,\"caption\":\"Dockerpros\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Dockerfile -cache-update - Dockerpros","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/dockerpros.com\/it\/wiki\/aggiornamento-cache-dockerfile\/","og_locale":"it_IT","og_type":"article","og_title":"Dockerfile -cache-update - Dockerpros","og_description":"The `--cache-update` option in Dockerfile allows users to refresh the build cache for specific layers. This ensures that dependencies and base images are updated without rebuilding the entire image, optimizing build efficiency.","og_url":"https:\/\/dockerpros.com\/it\/wiki\/aggiornamento-cache-dockerfile\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Tempo di lettura stimato":"6 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/","name":"Dockerfile -cache-update - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg","datePublished":"2024-07-23T12:39:34+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-update_1409.jpg","width":800,"height":600,"caption":"dockerfile-cache-update-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-update\/#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-update"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Esperti Docker","description":"DockerPros \u2013 Il tuo punto di riferimento definitivo per Docker","publisher":{"@id":"https:\/\/dockerpros.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/dockerpros.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Esperti Docker","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","width":532,"height":114,"caption":"Dockerpros"},"image":{"@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary\/1409","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary\/1409\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media\/2131"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media?parent=1409"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary-cat?post=1409"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}