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

Dockerfile –cache-backup: A Comprehensive Guide<\/h1>\n

The --cache-backup<\/code> feature 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> represents an advanced caching mechanism that allows developers to optimize the build process by storing intermediate build states. This capability not only accelerates the build times for Docker images but also enhances the efficiency of CI\/CD pipelines. In this article, we will delve into the intricacies of the --cache-backup<\/code> feature, how it integrates into Docker’s build process, best practices for effective use, and potential challenges and solutions when leveraging this caching strategy.<\/p>\n

Understanding Caching in Docker<\/h2>\n

Before diving into the specifics of --cache-backup<\/code>, it’s essential to understand how caching works in Docker. Docker utilizes a layered filesystem, where each instruction 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 new layer. If the content of a layer does not change between builds, Docker can reuse the previous layer from the cache, significantly speeding up the building process.<\/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>:<\/p>\n

FROM python:3.8\n\nCOPY requirements.txt \/app\/\nRUN pip install -r \/app\/requirements.txt\n\nCOPY . \/app\/\nCMD [\"python\", \"\/app\/app.py\"]<\/code><\/pre>\n
In this 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>, if the requirements.txt<\/code> file remains unchanged, Docker will use the cached layer 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> pip install<\/code> command, skipping the installation process during subsequent builds. This caching mechanism is a fundamental aspect of Docker’s efficiency, but it can become complex when dealing with large projects or when dependencies frequently change.<\/p>\n
What is --cache-backup<\/code>?<\/h2>\n
The --cache-backup<\/code> option is a command-line flag that enhances the caching ability of Docker builds. It allows developers to create a backup of the cache layers used during the build process, enabling them to restore these layers later. This is particularly useful in scenarios where builds are interrupted or where a cache needs to be preserved across different environments.<\/p>\n
Benefits of Using --cache-backup<\/code><\/h3>\n
    \n
  1. \n
    Improved Build Times<\/strong>: By backing up cache layers, subsequent builds can restore these layers instead of rebuilding them from scratch. This can lead to significant time savings, especially in large projects.<\/p>\n<\/li>\n
  2. \n
    Consistency Across Environments<\/strong>: The ability to back up and restore cache layers ensures that builds are consistent across development, testing, and production environments.<\/p>\n<\/li>\n
  3. \n
    Reduced Resource Consumption<\/strong>: Reusing cache layers minimizes the need for repeated installations of dependencies and other time-consuming operations, leading to lower resource usage.<\/p>\n<\/li>\n
  4. \n
    Fault Tolerance<\/strong>: In case of build failures or interruptions, the cache can be restored to a previous state, allowing developers to avoid starting from scratch.<\/p>\n<\/li>\n<\/ol>\n
    How to Use the --cache-backup<\/code> Option<\/h2>\n
    Utilizing the --cache-backup<\/code> feature involves a few straightforward steps. Below is a guide on how to implement it effectively.<\/p>\n
    Step 1: Set Up Your Dockerfile<\/h3>\n
    Start with your existing 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>. Ensure that it is optimized for caching by organizing the commands logically and minimizing changes to earlier layers. Here\u2019s an example 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 node:14\n\nWORKDIR \/app\n\nCOPY package.json package-lock.json .\/\nRUN npm install\n\nCOPY . .\n\nCMD [\"node\", \"index.js\"]<\/code><\/pre>\n
    Step 2: Backing Up Cache During Build<\/h3>\n
    When you execute a Docker build command, you can use the --cache-backup<\/code> option to create a backup of the cache. For example:<\/p>\n
    docker build --cache-backup -t my-app:latest .<\/code><\/pre>\n
    This command will build your 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> and create a backup of the cache layers used during the process.<\/p>\n
    Step 3: Restoring Cache<\/h3>\n
    In case you need to restore the cache from a backup, you can use the following command:<\/p>\n
    docker build --cache-from my-app:latest -t my-app:latest .<\/code><\/pre>\n
    The --cache-from<\/code> option allows Docker to reference the 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> and use its cache layers, speeding up the build process.<\/p>\n
    Best Practices for Efficient Caching<\/h2>\n
    To maximize the benefits of --cache-backup<\/code>, consider the following best practices:<\/p>\n
    1. Order Your Layers Wisely<\/h3>\n
    The order of 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> can significantly impact caching effectiveness. Place commands that are less likely to change at the top. For instance, installation commands for dependencies should precede the copying of application code.<\/p>\n
    2. Use Multi-Stage Builds<\/h3>\n
    Multi-stage builds allow you to separate the build environment from the production environment. This can help minimize the size of 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> and optimize the caching of build stages.<\/p>\n
    Example:<\/p>\n
    # Builder Stage\nFROM node:14 AS builder\nWORKDIR \/app\nCOPY package.json package-lock.json .\/\nRUN npm install\nCOPY . .\n\n# Production Stage\nFROM node:14\nWORKDIR \/app\nCOPY --from=builder \/app .\nCMD [\"node\", \"index.js\"]<\/code><\/pre>\n
    3. Keep Dependencies Updated<\/h3>\n
    Regularly update your dependencies to avoid caching outdated packages. However, be mindful of how these updates might affect caching.<\/p>\n
    4. Clear Unused Cache<\/h3>\n
    Periodically clear out unused Docker cache<\/a><\/span>Docker Cache optimizes image building by storing intermediate layers, allowing for faster builds by reusing unchanged layers. This reduces redundancy and improves efficiency in development workflows. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to save disk space. You can use the command:<\/p>\n
    docker builder prune<\/code><\/pre>\n
    5. Utilize Docker BuildKit<\/h3>\n
    Docker BuildKit is an advanced feature that enhances the build process, including better cache management and parallel builds. Enabling BuildKit can improve the performance of your builds significantly.<\/p>\n
    To enable BuildKit, set the environment variable before running your build command:<\/p>\n
    export DOCKER_BUILDKIT=1\ndocker build --cache-backup -t my-app:latest .<\/code><\/pre>\n
    Challenges and Solutions<\/h2>\n
    While --cache-backup<\/code> is a powerful feature, it is not without its challenges. Below are some common issues you may encounter and their solutions.<\/p>\n
    1. Cache Inconsistency<\/h3>\n
    As dependencies change, you may 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> into situations where cached layers become inconsistent with the current state of your application.<\/p>\n
    Solution<\/strong>: Regularly review and refresh your cache, particularly after major dependency updates. Utilize versioning for dependencies where possible.<\/p>\n
    2. Disk Space Management<\/h3>\n
    Backing up caches can consume significant disk space over time.<\/p>\n
    Solution<\/strong>: Implement a scheduled task<\/a><\/span>A task is a specific piece of work or duty assigned to an individual or system. It encompasses defined objectives, required resources, and expected outcomes, facilitating structured progress in various contexts. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to prune old, unused cache backups periodically. Use Docker’s built-in cache management commands to help with this.<\/p>\n
    3. Compatibility Issues<\/h3>\n
    If you’re working across multiple environments (development, testing, production), you may experience compatibility issues with cache layers.<\/p>\n
    Solution<\/strong>: Maintain a consistent environment and Docker version across all stages of your development lifecycle. Use tools like Docker Compose<\/a><\/span>Docker Compose is a tool for defining and running multi-container Docker applications using a YAML file. It simplifies deployment, configuration, and orchestration of services, enhancing development efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> to manage multi-container applications easily.<\/p>\n
    Conclusion<\/h2>\n
    The --cache-backup<\/code> option 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> is a powerful tool for enhancing the efficiency of your Docker builds. By optimizing your caching strategy through proper usage of this feature, developers can achieve significant improvements in build times, resource utilization, and consistency across environments. However, it is critical to maintain best practices and remain aware of potential challenges to reap the full benefits of this advanced capability.<\/p>\n
    By following the guidelines and insights provided in this article, developers can effectively utilize --cache-backup<\/code> to streamline their Docker workflows, ultimately leading to more efficient development processes and improved application delivery. As Docker continues to evolve, staying informed about advanced features like --cache-backup<\/code> will be essential for any developer looking to leverage containerization effectively.<\/p>","protected":false},"excerpt":{"rendered":"
    Die Dockerfile<\/a><\/span>Eine Dockerfile ist ein Skript, das eine Reihe von Anweisungen zur Automatisierung der Erstellung von Docker-Images enth\u00e4lt. Sie gibt das Basis-Image, die Anwendungsabh\u00e4ngigkeiten und die Konfiguration an und erm\u00f6glicht so eine konsistente Bereitstellung \u00fcber verschiedene Umgebungen hinweg. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> Die Option `\u2013cache-backup` erm\u00f6glicht es Benutzern, den Build-Cache zwischen Sitzungen beizubehalten, was die Effizienz steigert. Dieses Feature minimiert die Neuerstellungszeiten, indem es Zwischenschichten erh\u00e4lt und den Entwicklungsprozess strafft.<\/p>","protected":false},"author":1,"featured_media":2139,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1413","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -cache-backup - Dockerpros<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-cache-sicherung\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -cache-backup - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The Dockerfile `--cache-backup` option enables users to retain build cache between sessions, enhancing efficiency. This feature minimizes rebuild times by preserving intermediate layers, streamlining the development process.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-cache-sicherung\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"800\" \/>\n\t<meta property=\"og:image:height\" content=\"600\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data1\" content=\"5\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/\",\"name\":\"Dockerfile -cache-backup - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg\",\"datePublished\":\"2024-07-23T12:39:39+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-cache-backup-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#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-backup\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/dockerpros.com\/#website\",\"url\":\"https:\/\/dockerpros.com\/\",\"name\":\"Dockerpros\",\"description\":\"DockerPros \u2013 Your Ultimate Docker Resource Hub\",\"publisher\":{\"@id\":\"https:\/\/dockerpros.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/dockerpros.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png\",\"width\":532,\"height\":114,\"caption\":\"Dockerpros\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Dockerfile -cache-backup - Dockerpros","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-cache-sicherung\/","og_locale":"de_DE","og_type":"article","og_title":"Dockerfile -cache-backup - Dockerpros","og_description":"The Dockerfile `--cache-backup` option enables users to retain build cache between sessions, enhancing efficiency. This feature minimizes rebuild times by preserving intermediate layers, streamlining the development process.","og_url":"https:\/\/dockerpros.com\/de\/wiki\/dockerfile-cache-sicherung\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Gesch\u00e4tzte Lesezeit":"5\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/","name":"Dockerfile -cache-backup - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg","datePublished":"2024-07-23T12:39:39+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cache-backup_1413.jpg","width":800,"height":600,"caption":"dockerfile-cache-backup-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cache-backup\/#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-backup"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Docker-Profis","description":"DockerPros \u2013 Ihr umfassender Docker-Ressourcen-Hub","publisher":{"@id":"https:\/\/dockerpros.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/dockerpros.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Docker-Profis","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/Dockerpros_logo_blanco.png","width":532,"height":114,"caption":"Dockerpros"},"image":{"@id":"https:\/\/dockerpros.com\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary\/1413","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary\/1413\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/media\/2139"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/media?parent=1413"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/de\/wp-json\/wp\/v2\/glossary-cat?post=1413"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}