{"id":1327,"date":"2024-07-23T12:20:58","date_gmt":"2024-07-23T12:20:58","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1327"},"modified":"2024-07-23T12:23:33","modified_gmt":"2024-07-23T12:23:33","slug":"dockerfile-target","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-target\/","title":{"rendered":"Dockerfile CIBLE"},"content":{"rendered":"

Understanding Dockerfile TARGET: Advanced Insights<\/h2>\n

In the realm of containerization, 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><\/code> serves as the blueprint for building Docker images. Among the myriad features offered by Dockerfiles, the TARGET<\/code> mechanism stands out as a powerful tool for advanced users, allowing for multi-stage builds. This feature enables developers to optimize their Docker images by specifying different build targets within a single Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, making it possible to streamline the image-building process, reduce size, and enhance security. This article will delve deep into the TARGET<\/code> feature in Dockerfiles, exploring its syntax, practical applications, and best practices, while providing an overview of why it is an essential component of modern DevOps practices.<\/p>\n

The Basics of Multi-Stage Builds<\/h2>\n

Before we explore the TARGET<\/code> feature specifically, it’s important to understand the concept of multi-stage builds in Docker. Introduced in Docker 17.05, multi-stage builds allow developers to use multiple FROM<\/code> statements within a single Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. Each stage can be built independently, pulling in different base images and configurations, which can significantly enhance the efficiency of the image-building process.<\/p>\n

Multi-stage builds help in reducing 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> by allowing developers to include only the necessary artifacts. For example, you can compile your application in one stage using a full-fledged development environment and then 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> only the compiled binary to a minimal 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> in another stage. This practice minimizes the attack surface and reduces resource consumption when deploying containers.<\/p>\n

Syntax of the TARGET Instruction<\/h2>\n

The TARGET<\/code> feature is utilized when invoking the docker build<\/code> command. The primary syntax is as follows:<\/p>\n

docker build --target  -t : .<\/code><\/pre>\n
The “ refers to the name of the stage defined 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>. By specifying this target, the Docker engine<\/a><\/span>Docker Engine is an open-source containerization technology that enables developers to build, deploy, and manage applications within lightweight, isolated environments called containers. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> will only build up to that specific stage, allowing you to skip subsequent stages that may not be necessary for your current requirements.<\/p>\n
Example of a Multi-Stage Dockerfile<\/h3>\n
To illustrate the power of the TARGET<\/code> feature, consider the following example of a multi-stage Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>:<\/p>\n
# Stage 1: Build Stage\nFROM golang:1.18 AS builder\nWORKDIR \/app\nCOPY . .\nRUN go build -o myapp\n\n# Stage 2: Production Stage\nFROM alpine:3.15\nWORKDIR \/app\nCOPY --from=builder \/app\/myapp .\nCMD [\".\/myapp\"]<\/code><\/pre>\n
In this example, we have two stages: the first stage (builder<\/code>) compiles a Go application, while the second stage creates a minimal production 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> based on Alpine Linux. <\/p>\n
Building to a Specific Target<\/h3>\n
When you want to build only the builder<\/code> stage and perhaps debug or test the application, you can use the TARGET<\/code> feature as follows:<\/p>\n
docker build --target builder -t myapp:builder .<\/code><\/pre>\n
This command builds the image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> up to the builder<\/code> stage only, allowing you 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> the Go application in the development environment without shipping the complete production 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
Advantages of Using TARGET<\/h2>\n
1. Streamlined Development Process<\/h3>\n
By utilizing the TARGET<\/code> feature, developers can quickly iterate on specific stages of their application without the need to rebuild the entire 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>. This can significantly speed up the development workflow, especially in environments where build time is critical.<\/p>\n
2. Enhanced Security<\/h3>\n
Reducing the number of layers and minimizing the contents of your 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> contributes to improved security. By using TARGET<\/code>, you can ensure that only the necessary components are included in the production image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, while development and testing tools remain in a separate stage that is not deployed.<\/p>\n
3. Space Efficiency<\/h3>\n
Docker images can grow large over time, particularly with dependencies and build tools. By segmenting the build process into stages and using TARGET<\/code>, you can create smaller images by only including the essential artifacts needed 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> your application.<\/p>\n
4. Customization for Different Environments<\/h3>\n
Different environments (development, staging, production) often require different configurations. The TARGET<\/code> feature allows for seamless building of images tailored for each environment by creating dedicated stages for each environment’s needs.<\/p>\n
Best Practices for Using TARGET<\/h2>\n
1. Naming Stages Clearly<\/h3>\n
When leveraging multi-stage builds and the TARGET<\/code> feature, it’s crucial to provide meaningful names to each stage. Clear and descriptive names make it easier for developers to understand the purpose of each stage and which target they should use during the build process.<\/p>\n
For example:<\/p>\n
FROM 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>:14 AS development\n# Development stage instructions\n\nFROM 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>:14 AS testing\n# Testing stage instructions\n\nFROM 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>:14 AS production\n# Production stage instructions<\/code><\/pre>\n
2. Keep Stages Lean<\/h3>\n
Each stage should have a well-defined purpose and should include only what is necessary for that stage. This approach not only minimizes image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> size but also enhances performance and security.<\/p>\n
3. Use Caching Wisely<\/h3>\n
Docker uses a layer caching mechanism that can speed up builds if the layers have not changed. When making modifications, try to structure 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 maximize the efficiency of the cache. Changes in later stages should ideally not invalidate the cache in earlier stages.<\/p>\n
4. Document Your Dockerfile<\/h3>\n
Including comments 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 provide context and clarify the reasoning behind specific stages and commands. This documentation is invaluable for team members who may work on the project in the future.<\/p>\n
5. Test Each Stage Independently<\/h3>\n
When working with multi-stage builds, it may be beneficial to build and test each stage independently to ensure they function as intended. This practice helps to catch issues early in the development process.<\/p>\n
Practical Use Cases for TARGET<\/h2>\n
1. Development vs. Production Builds<\/h3>\n
A frequent use case for the TARGET<\/code> feature is the differentiation between development and production builds. By defining separate stages for development (with testing tools and dependencies) and production (with just the necessary runtime), teams can easily switch between environments.<\/p>\n
2. Building Libraries or Dependencies<\/h3>\n
In scenarios where libraries are built as separate artifacts, developers can create 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> that first compiles the library and then builds the application that depends on it. Using TARGET<\/code>, they can build and test the library independently.<\/p>\n
3. CI\/CD Pipeline Optimization<\/h3>\n
In continuous integration and deployment pipelines, utilizing the TARGET<\/code> feature allows for optimized builds. Specific stages can be built and tested based on the context of the pipeline, reducing build times and resource consumption.<\/p>\n
Conclusion<\/h2>\n
The TARGET<\/code> feature in Dockerfiles is a powerful tool that enables developers to optimize their containerized applications through multi-stage builds. By allowing for targeted builds, this feature enhances the development workflow, improves security, reduces image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> size, and accommodates diverse environment configurations. By adhering to best practices and leveraging practical use cases, developers can fully exploit the capabilities of Docker, driving efficiency and effectiveness in their containerization efforts.<\/p>\n
As the ecosystem around Docker continues to evolve, the importance of mastering advanced features like TARGET<\/code> cannot be overstated. As applications become more complex and the demand for agile development practices grows, understanding and implementing multi-stage builds will be essential for delivering modern applications in a reliable and efficient manner. Whether you are a seasoned Docker user or just beginning your journey, embracing the TARGET<\/code> feature will undoubtedly enhance your containerization strategy.<\/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> L'instruction TARGET permet des builds multi-\u00e9tapes, permettant aux d\u00e9veloppeurs de d\u00e9finir des \u00e9tapes de build sp\u00e9cifiques. Cette fonctionnalit\u00e9 optimise image<\/a><\/span>Une image est une repr\u00e9sentation visuelle d'un objet ou d'une sc\u00e8ne, g\u00e9n\u00e9ralement compos\u00e9e de pixels dans les formats num\u00e9riques. Elle peut transmettre des informations, susciter des \u00e9motions et faciliter la communication \u00e0 travers diff\u00e9rents m\u00e9dias. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> size by copying only necessary artifacts, enhancing efficiency.<\/p>","protected":false},"author":1,"featured_media":1967,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1327","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile TARGET - 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-target\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile TARGET - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The Dockerfile TARGET instruction enables multi-stage builds, allowing developers to define specific build stages. This feature optimizes image size by copying only necessary artifacts, enhancing efficiency.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-target\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:23:33+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.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-target\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/\",\"name\":\"Dockerfile TARGET - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.jpg\",\"datePublished\":\"2024-07-23T12:20:58+00:00\",\"dateModified\":\"2024-07-23T12:23:33+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-target-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#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 TARGET\"}]},{\"@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 TARGET - 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-target\/","og_locale":"fr_FR","og_type":"article","og_title":"Dockerfile TARGET - Dockerpros","og_description":"The Dockerfile TARGET instruction enables multi-stage builds, allowing developers to define specific build stages. This feature optimizes image size by copying only necessary artifacts, enhancing efficiency.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-target\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:23:33+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.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-target\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/","name":"Dockerfile TARGET - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.jpg","datePublished":"2024-07-23T12:20:58+00:00","dateModified":"2024-07-23T12:23:33+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-target\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target_1327.jpg","width":800,"height":600,"caption":"dockerfile-target-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target\/#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 TARGET"}]},{"@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\/1327","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\/1327\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/1967"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1327"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1327"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}