{"id":1365,"date":"2024-07-23T12:38:59","date_gmt":"2024-07-23T12:38:59","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1365"},"modified":"2024-07-23T12:38:59","modified_gmt":"2024-07-23T12:38:59","slug":"dockerfile-output","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-output\/","title":{"rendered":"Dockerfile \u2013output"},"content":{"rendered":"

Understanding Dockerfile –output: A Deep Dive into Advanced Docker Build Techniques<\/h1>\n

Docker has revolutionized how we develop, ship, 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 by providing a consistent environment through containerization. At the heart of Docker’s operational efficiency lies 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>, a script containing instructions 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>. One of the advanced features of 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 enhances the build process is the --output<\/code> option. This feature allows developers to specify where the build artifacts should be stored, providing improved flexibility and efficiency. In this article, we will explore the intricacies of the --output<\/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>, its uses, benefits, and practical examples to make the most of this powerful feature.<\/p>\n

Overview of Docker Build<\/h2>\n

Before delving into the details of the --output<\/code> option, it is essential to understand the basic structure of the Docker 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 command, Docker processes 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> line by line, executing each instruction to create 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. The resulting layers are cached, which optimizes subsequent builds by reusing unchanged layers. This caching mechanism is vital for speeding up the build process.<\/p>\n

However, traditional Docker builds output the 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> directly into the local 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>. While this works well for many use cases, it can create challenges when trying to manage artifacts, especially in complex deployments or CI\/CD pipelines. The --output<\/code> option was introduced to address these challenges by allowing developers to specify a direct output path for the build artifacts.<\/p>\n

The --output<\/code> Option<\/h2>\n

The --output<\/code> option, introduced in Docker BuildKit, allows you to specify a directory where build artifacts can be stored. This means you can extract built files directly without the need to create 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> or push it to a 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> first. This functionality is particularly useful when working with multi-stage builds, as it allows for a more streamlined process in producing and managing build artifacts.<\/p>\n

Syntax of the --output<\/code> Option<\/h3>\n

The basic syntax of the --output<\/code> option is as follows:<\/p>\n

docker build --output  .<\/code><\/pre>\n
In this command, ` specifies the directory where you want to store the build output. The dot (<\/code>.`) at the end denotes the current directory as the context for the build.<\/p>\n
Example of Using --output<\/code><\/h3>\n
Let\u2019s consider a simple example where we want to build a Go application. Below is a basic 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 compiles a Go application:<\/p>\n
# syntax=docker\/dockerfile:1\nFROM golang:1.17 AS builder\n\nWORKDIR \/app\nCOPY . .\n\nRUN go build -o myapp\n\nFROM alpine:3.14\nWORKDIR \/app\nCOPY --from=builder \/app\/myapp .\n\nCMD [\".\/myapp\"]<\/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>, we have defined a multi-stage build<\/a><\/span>A multi-stage build is a Docker optimization technique that enables the separation of build and runtime environments. By using multiple FROM statements in a single Dockerfile, developers can streamline image size and enhance security by excluding unnecessary build dependencies in the final image. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>: the first stage compiles the Go application, and the second stage creates a minimal 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 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> it. If you want to extract the compiled binary directly without creating a Docker image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, you can use the --output<\/code> option:<\/p>\n
docker build --output .\/output_dir .<\/code><\/pre>\n
After executing this command, the compiled binary myapp<\/code> will be available in the .\/output_dir<\/code> directory on your host machine.<\/p>\n
Benefits of Using --output<\/code><\/h2>\n
1. Simplified Artifact Management<\/h3>\n
By using the --output<\/code> option, developers can manage build artifacts more efficiently. Instead of having to build an image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> and then extract files, the --output<\/code> option allows direct access to outputs, simplifying the workflow.<\/p>\n
2. Reduced Build Time<\/h3>\n
Since the artifacts are directly stored on the host, it can reduce the time taken to extract files from 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>, especially in CI\/CD environments. This can lead to faster deployment cycles.<\/p>\n
3. Enhanced CI\/CD Integration<\/h3>\n
In Continuous Integration and Continuous Deployment (CI\/CD) pipelines, managing build artifacts is crucial. The --output<\/code> option allows for a smoother integration of Docker builds with CI\/CD tools by providing easy access to build outputs for testing, packaging, or deployment.<\/p>\n
4. Clear Separation of Concerns<\/h3>\n
By allowing separate output paths for different types of builds, it becomes easier to manage and identify artifacts related to specific builds or components, enhancing the overall organization of project files.<\/p>\n
Use Cases for --output<\/code><\/h2>\n
1. Building Static Binaries<\/h3>\n
When building applications that only need static binaries, such as Go or Rust applications, the --output<\/code> option allows developers to extract these binaries and use them directly in other environments without the overhead of Docker images.<\/p>\n
2. Generating Documentation<\/h3>\n
Another use case is generating documentation as part of the build process. You can configure 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> to generate documentation files and specify an output directory to store them, making them readily available for deployment or distribution.<\/p>\n
3. Packaging Resources<\/h3>\n
For applications that require additional resources or assets, such as configuration files, templates, or static pages, the --output<\/code> option can help package these resources in a clean manner, ready for deployment.<\/p>\n
4. Dynamic Builds<\/h3>\n
In scenarios where builds may change frequently or need to be downloaded dynamically by other applications or services, the --output<\/code> option enables developers to structure their builds flexibly, making them more adaptable to changing requirements.<\/p>\n
Advanced Techniques with --output<\/code><\/h2>\n
Multi-Stage Builds<\/h3>\n
The --output<\/code> option shines in multi-stage builds, where different artifacts may be required at various phases of the build process. By utilizing this feature, developers can streamline the build process by focusing on specific outputs from different stages. <\/p>\n
For instance, consider a project with multiple compiled outputs, such as binaries for different architectures. You can leverage the --output<\/code> option to direct each output to a dedicated directory for easy access.<\/p>\n
Build Caching<\/h3>\n
Using BuildKit\u2019s advanced caching mechanisms, developers can optimize their builds further. By retaining outputs in designated directories while caching intermediate stages, you can vastly improve build performance, especially in scenarios requiring frequent rebuilds.<\/p>\n
Custom Build Contexts<\/h3>\n
Docker allows you to specify custom build contexts, which can include files and directories outside the current working directory. This capability can be enhanced with the --output<\/code> option, allowing you to extract and manage artifacts from complex build setups more efficiently.<\/p>\n
Challenges and Considerations<\/h2>\n
1. Compatibility<\/h3>\n
While the --output<\/code> option brings many benefits, it is essential to note that it requires Docker BuildKit, which may not be enabled by default in all installations. You can enable BuildKit by setting the environment variable DOCKER_BUILDKIT=1<\/code> before executing your build commands.<\/p>\n
2. Limited Outputs<\/h3>\n
Currently, the --output<\/code> option primarily focuses on file outputs. While this is suitable for many use cases, there may be scenarios where you want to output Docker images or other artifacts directly. Developers should be aware of these limitations and plan their workflows accordingly.<\/p>\n
3. Security Considerations<\/h3>\n
When using the --output<\/code> option, be mindful of the security implications of exposing build artifacts. Ensure that sensitive files or configurations are not inadvertently exposed during the build process. Always validate and sanitize the output paths to mitigate potential risks.<\/p>\n
Conclusion<\/h2>\n
The --output<\/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> represents a significant advancement in how developers can handle Docker builds. By allowing the direct extraction of build artifacts, it simplifies artifact management, enhances CI\/CD integration, and reduces build times. While there are some challenges to consider, the benefits far outweigh the drawbacks for most advanced use cases.<\/p>\n
As Docker continues to evolve, features like the --output<\/code> option will only become more integral to the workflows of modern software development. By mastering this feature and incorporating it into your build processes, you can enhance efficiency, maintainability, and overall productivity in your containerized applications.<\/p>\n
In summary, understanding and leveraging the --output<\/code> option will empower developers to optimize their Docker workflows, seamlessly integrate with CI\/CD pipelines, and ultimately deliver high-quality applications with reduced friction. As with any tool, the real power lies in how effectively it is utilized to solve real-world challenges in software development.<\/p>","protected":false},"excerpt":{"rendered":"
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> `\u2013output` option allows users to specify an output location for build artifacts. This enhances build efficiency by enabling direct storage of images or files, streamlining workflows.<\/p>","protected":false},"author":1,"featured_media":2043,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1365","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -output - 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-output\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -output - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The Dockerfile `--output` option allows users to specify an output location for build artifacts. This enhances build efficiency by enabling direct storage of images or files, streamlining workflows.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-output\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.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-output\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/\",\"name\":\"Dockerfile -output - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.jpg\",\"datePublished\":\"2024-07-23T12:38:59+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-output-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#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 –output\"}]},{\"@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 -output - 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-output\/","og_locale":"fr_FR","og_type":"article","og_title":"Dockerfile -output - Dockerpros","og_description":"The Dockerfile `--output` option allows users to specify an output location for build artifacts. This enhances build efficiency by enabling direct storage of images or files, streamlining workflows.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-output\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.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-output\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/","name":"Dockerfile -output - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.jpg","datePublished":"2024-07-23T12:38:59+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-output\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-output_1365.jpg","width":800,"height":600,"caption":"dockerfile-output-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-output\/#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 –output"}]},{"@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\/1365","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\/1365\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/2043"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1365"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1365"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}