{"id":1347,"date":"2024-07-23T12:37:03","date_gmt":"2024-07-23T12:37:03","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1347"},"modified":"2024-07-23T12:37:03","modified_gmt":"2024-07-23T12:37:03","slug":"dockerfile-target-2","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/es\/wiki\/dockerfile-target-2\/","title":{"rendered":"Dockerfile --etapa"},"content":{"rendered":"

Understanding 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> --target<\/code>: An Advanced Guide<\/h2>\n

The --target<\/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 feature that allows developers to specify a particular build stage to target in 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> process. This capability not only enhances the modularity of Docker images but also optimizes the build process by allowing users to selectively build only the components they need. In a world where application complexity is on the rise, effective utilization of the --target<\/code> feature can lead to significant improvements in performance, security, and maintainability.<\/p>\n

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

Before delving into the --target<\/code> feature, it’s essential to grasp the concept of multi-stage builds. Introduced in Docker 17.05, multi-stage builds enable developers to create smaller, more efficient Docker images by using multiple FROM<\/code> statements in 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 have its own 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 environment setup, allowing for a cleaner separation of concerns.<\/p>\n

Why Use Multi-Stage Builds?<\/h3>\n
    \n
  1. Reduced 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<\/strong>: By copying only the necessary artifacts from one stage to another, you can significantly reduce 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> size.<\/li>\n
  2. Improved Build Times<\/strong>: You can cache intermediate stages, which can speed up the build process when changes are made to specific stages.<\/li>\n
  3. Enhanced Security<\/strong>: By limiting the tools and libraries in 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> to only those needed for production, the attack surface is minimized.<\/li>\n
  4. Simplicity<\/strong>: Multi-stage builds can simplify Dockerfiles by avoiding the need for complex scripts to remove development dependencies.<\/li>\n<\/ol>\n

    The Role of the --target<\/code> Option<\/h2>\n

    The --target<\/code> option plays a crucial role within the multi-stage context, as it allows developers to specify which stage of 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> to build. This is particularly useful in development environments where you may want to build and test individual parts of an application without constructing the entire 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

    Syntax<\/h3>\n

    The --target<\/code> option is used in conjunction with the docker build<\/code> command, with the following syntax:<\/p>\n

    docker build --target  -t  .<\/code><\/pre>\n
    Here, corresponds to the name of the stage defined within 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>, and<\/code> is the desired name for the resulting 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
    Example: A Practical Illustration<\/h2>\n
    To better understand how --target<\/code> works, let\u2019s create a simple example using a hypothetical application with multiple build stages.<\/p>\n
    Sample Dockerfile<\/h3>\n
    # Stage 1: Build\nFROM golang:1.17 as builder\n\nWORKDIR \/app\nCOPY . .\n\nRUN go build -o myapp .\n\n# Stage 2: Testing\nFROM golang:1.17 as tester\n\nWORKDIR \/app\nCOPY --from=builder \/app\/myapp . \nCMD [\"go\", \"test\", \".\/...\"]\n\n# Stage 3: Production\nFROM alpine:latest\n\nWORKDIR \/app\nCOPY --from=builder \/app\/myapp .\nCMD [\".\/myapp\"]<\/code><\/pre>\n
    Building Different Stages<\/h3>\n
    You can build each stage of 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> independently using the --target<\/code> option:<\/p>\n
      \n
    1. \n
      To build the builder stage<\/strong>:<\/p>\n
      docker build --target builder -t myapp-builder .<\/code><\/pre>\n<\/li>\n
    2. \n
      To build the tester stage<\/strong>:<\/p>\n
      docker build --target tester -t myapp-tester .<\/code><\/pre>\n<\/li>\n
    3. \n
      To build the production stage<\/strong>:<\/p>\n
      docker build --target production -t myapp .<\/code><\/pre>\n<\/li>\n<\/ol>\n
      By using the --target<\/code> option, you can focus on a specific stage without the overhead of building the entire 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
      Use Cases for --target<\/code><\/h2>\n
      1. Development and Testing<\/h3>\n
      When developing applications, it is often unnecessary to create the entire 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>. You can use the --target<\/code> option to build only the development or testing stages, quickly iterating on your code changes without waiting for the full build. This is particularly effective in CI\/CD environments where build times can critically impact deployment speed.<\/p>\n
      2. Debugging<\/h3>\n
      When debugging, you may want to inspect the state of specific build stages. By targeting a particular stage, you can 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> an interactive session, allowing you to explore and diagnose issues without recreating the entire application environment.<\/p>\n
      docker 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 myapp-tester sh<\/code><\/pre>\n
      3. Conditional Builds<\/h3>\n
      Using build arguments, you can conditionally include or exclude certain stages based on environmental needs. For example, if you have a stage for building documentation, you can easily skip it in production builds.<\/p>\n
      ARG BUILD_DOCS=false\n\nFROM golang:1.17 AS docs\nRUN if [ \"$BUILD_DOCS\" = \"true\" ]; then .\/build_docs.sh; fi<\/code><\/pre>\n
      In this example, you can set the BUILD_DOCS<\/code> argument when building, and --target<\/code> can be used to focus on the docs stage if needed.<\/p>\n
      4. Modular Architecture<\/h3>\n
      When working with microservices, it’s beneficial to define separate 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> stages for each service<\/a><\/span>Service refers to the act of providing assistance or support to fulfill specific needs or requirements. In various domains, it encompasses customer service, technical support, and professional services, emphasizing efficiency and user satisfaction. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. This modular approach facilitates the independent building and deployment of services, making it easier to manage dependencies and update individual components without affecting the entire application.<\/p>\n
      Performance Considerations<\/h2>\n
      Build Context<\/h3>\n
      When using --target<\/code>, it is essential to be mindful of the build context. A large context can significantly slow down build times, especially when utilizing 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. To mitigate this, consider using .dockerignore<\/code> files to exclude unnecessary files from the build context. <\/p>\n
      Caching<\/h3>\n
      Docker’s caching mechanism can dramatically improve build times. When you build a specific stage using --target<\/code>, Docker will cache the layers up to that point. If changes are made to a layer after the targeted stage, only the affected layers will be rebuilt, allowing for faster build times.<\/p>\n
      Resource Management<\/h3>\n
      Building multiple stages can consume considerable system resources, particularly CPU and memory. Monitor the resource usage during the build process and consider scaling<\/a><\/span>Scaling refers to the process of adjusting the capacity of a system to accommodate varying loads. It can be achieved through vertical scaling, which enhances existing resources, or horizontal scaling, which adds additional resources. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> your build infrastructure appropriately to avoid bottlenecks.<\/p>\n
      Best Practices for Using --target<\/code><\/h2>\n
        \n
      1. \n
        Keep Stages Modular<\/strong>: Each stage should serve a specific purpose, whether that be building, testing, or preparing for production. This modularity enhances clarity and maintainability.<\/p>\n<\/li>\n
      2. \n
        Use Clear Naming Conventions<\/strong>: Naming your stages clearly will help team members understand the Dockerfile’s flow and make it easier to target specific stages.<\/p>\n<\/li>\n
      3. \n
        Limit the Use of Global Dependencies<\/strong>: Try to minimize global dependencies in your builds, as they can unnecessarily bloat 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> size. Instead, rely on stage-specific setups.<\/p>\n<\/li>\n
      4. \n
        Document 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><\/strong>: Include 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> to explain each stage’s purpose. This is particularly helpful for onboarding new team members or revisiting 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> after some time.<\/p>\n<\/li>\n
      5. \n
        Use Build Args Wisely<\/strong>: Utilize build arguments to create more dynamic builds. This can facilitate different configurations for different environments without the need for separate Dockerfiles.<\/p>\n<\/li>\n<\/ol>\n
        Conclusion<\/h2>\n
        The --target<\/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 an invaluable feature for modern development workflows. By enabling targeted builds within multi-stage Dockerfiles, developers can streamline their build processes, significantly reduce 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> sizes, and enhance the overall maintainability of Docker images. Understanding how to effectively utilize --target<\/code> will empower teams to build more efficient, secure, and modular applications, ultimately leading to robust deployment pipelines. As application complexity continues to grow, mastering the nuances of Docker features like --target<\/code> will be essential for achieving operational excellence in containerized environments.<\/p>","protected":false},"excerpt":{"rendered":"
        La opci\u00f3n `\u2013target` en un Dockerfile<\/a><\/span>Un Dockerfile es un script que contiene una serie de instrucciones para automatizar la creaci\u00f3n de im\u00e1genes Docker. Especifica la imagen base, las dependencias de la aplicaci\u00f3n y la configuraci\u00f3n, facilitando el despliegue consistente en diferentes entornos. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> enables multi-stage builds by allowing users to specify a particular build stage. This feature optimizes imagen<\/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> sizes and enhances build efficiency by selectively targeting stages for final imagen<\/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> creation.<\/p>","protected":false},"author":1,"featured_media":2007,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1347","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\/es\/wiki\/dockerfile-target-2\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -target - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--target` option in a Dockerfile enables multi-stage builds by allowing users to specify a particular build stage. This feature optimizes image sizes and enhances build efficiency by selectively targeting stages for final image creation.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/es\/wiki\/dockerfile-target-2\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.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=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data1\" content=\"5 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/\",\"name\":\"Dockerfile -target - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg\",\"datePublished\":\"2024-07-23T12:37:03+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-target-3\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#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\":\"es\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@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\/es\/wiki\/dockerfile-target-2\/","og_locale":"es_ES","og_type":"article","og_title":"Dockerfile -target - Dockerpros","og_description":"The `--target` option in a Dockerfile enables multi-stage builds by allowing users to specify a particular build stage. This feature optimizes image sizes and enhances build efficiency by selectively targeting stages for final image creation.","og_url":"https:\/\/dockerpros.com\/es\/wiki\/dockerfile-target-2\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Tiempo de lectura":"5 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/","name":"Dockerfile -target - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg","datePublished":"2024-07-23T12:37:03+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-target-2_1347.jpg","width":800,"height":600,"caption":"dockerfile-target-3"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-target-2\/#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":"Profesionales de Docker","description":"DockerPros \u2013 Tu centro definitivo de recursos 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":"es"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Profesionales de Docker","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"es","@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\/es\/wp-json\/wp\/v2\/glossary\/1347","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary\/1347\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/media\/2007"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/media?parent=1347"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/es\/wp-json\/wp\/v2\/glossary-cat?post=1347"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}