{"id":1334,"date":"2024-07-23T12:21:41","date_gmt":"2024-07-23T12:21:41","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1334"},"modified":"2024-07-23T12:23:50","modified_gmt":"2024-07-23T12:23:50","slug":"dockerfile-rm","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-rm\/","title":{"rendered":"Dockerfile \u2013rm"},"content":{"rendered":"

Understanding Docker’s --rm<\/code> Flag: An In-Depth Exploration<\/h1>\n

In the Docker ecosystem, the --rm<\/code> flag plays a critical role in managing container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> lifecycles, specifically concerning automatic cleanup of containers that are no longer needed. When utilized during the execution of a container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, this flag ensures that the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is automatically removed once it exits, preventing the accumulation of stopped containers that can clutter the Docker environment. This article delves deep into the functionality, usage scenarios, advantages, and potential drawbacks of the --rm<\/code> flag, providing a comprehensive understanding for advanced users of Docker.<\/p>\n

The Container Lifecycle and Cleanup Requirements<\/h2>\n

Containers are lightweight, portable, and encapsulated environments for running applications or services. However, one of the common challenges in Docker management is dealing with the containers that have completed their execution. By default, stopped containers are retained in 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>, which can lead to a buildup of exited containers over time. These containers can consume system resources and make it difficult to manage active workloads.<\/p>\n

The --rm<\/code> flag offers a solution by providing a mechanism for automatic cleanup. When a container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> started with this flag exits, Docker automatically removes it, thus keeping the environment tidy. This is particularly useful in development and testing environments where containers may be spun up for short-lived tasks, reducing manual cleanup tasks and the potential for human error.<\/p>\n

How to Use --rm<\/code><\/h2>\n

The --rm<\/code> flag can be used in conjunction with the 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><\/code> command. Its syntax is straightforward:<\/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> --rm [OPTIONS] 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> [COMMAND] [ARG<\/a><\/span>ARG is a directive used within Dockerfiles to define build-time variables that allow you to parameterize your builds. These variables can influence how an image is constructed, enabling developers to create more flexible and reusable Docker images. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>...]<\/code><\/pre>\n
Here is a simple example of using this flag:<\/p>\n
docker run --rm ubuntu echo \"Hello, World!\"<\/code><\/pre>\n
In this command, the Ubuntu 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> is pulled (if not already available locally), a container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is created, the command echo \"Hello, World!\"<\/code> is executed, and upon completion, the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is automatically removed.<\/p>\n
Example Scenarios<\/h3>\n
To illustrate the utility of the --rm<\/code> flag, let’s explore a few scenarios:<\/p>\n
    \n
  1. \n
    Testing Scripts<\/strong>: Developers often write scripts or small applications that need to be tested quickly. Using --rm<\/code>, they 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> their script in an isolated environment without worrying about leaving behind unnecessary containers. <\/p>\n
    docker run --rm python:3.9 python -c \"print('Testing Docker with Python')\"<\/code><\/pre>\n<\/li>\n
  2. \n
    Temporary Services<\/strong>: When running services that are not meant to persist (like a single execution of a web server), the --rm<\/code> flag can keep the environment clean. For instance, testing a web 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>:<\/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> --rm -p 8080:80 nginx<\/code><\/pre>\n<\/li>\n
  3. \n
    Data Processing Jobs<\/strong>: For one-off data processing tasks, where results are not needed after completion, --rm<\/code> can be quite handy:<\/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> --rm -v \/data:\/data my-data-processor<\/code><\/pre>\n<\/li>\n<\/ol>\n
    Important Considerations<\/h3>\n
    While the --rm<\/code> flag provides significant advantages, there are some considerations to keep in mind:<\/p>\n
      \n
    1. \n
      Loss of Logs<\/strong>: When a container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is removed immediately after exiting, any logs generated during its execution are also lost. If you need to debug or analyze the output, consider running the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> without the --rm<\/code> flag or redirecting the output to a file.<\/p>\n<\/li>\n
    2. \n
      Container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> Restart<\/strong>: If the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is designed to restart (e.g., due to a failure), using --rm<\/code> could lead to unexpected behavior, as the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> would be removed every time it exits. In such cases, using a restart policy without --rm<\/code> would be more appropriate.<\/p>\n<\/li>\n
    3. \n
      Batch Processing Limitations<\/strong>: For batch processing jobs that may require examining intermediate states or logs from multiple runs, the --rm<\/code> flag can hinder this process, necessitating a more deliberate approach to managing container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> lifecycles.<\/p>\n<\/li>\n<\/ol>\n
      Advanced Usage: Customizing with Docker Compose<\/h2>\n
      The --rm<\/code> flag can also be integrated into 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> setups, enabling similar container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> management benefits in multi-container applications. By setting the restart<\/code> policy to no<\/code>, you can simulate the behavior of --rm<\/code> for containers defined in a docker-compose.yml<\/code> file.<\/p>\n
      Example Compose File<\/h3>\n
      version: '3'\nservices:\n  web:\n    image: nginx\n    ports:\n      - \"8080:80\"\n    deploy:\n      restart_policy:\n        condition: none<\/code><\/pre>\n
      In this example, once the web<\/code> 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> exits, the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> will be removed, similar to using the --rm<\/code> flag in a 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><\/code> command.<\/p>\n
      Performance Implications<\/h2>\n
      Using --rm<\/code> can also have performance implications. Since removed containers do not persist, they reduce the overhead of Docker managing numerous stopped containers. This leads to better performance when listing containers and can minimize resource consumption in environments where many containers are created and destroyed frequently.<\/p>\n
      However, the trade-off lies in the inability to inspect stopped containers for troubleshooting or auditing purposes. Carefully consider your workflow and whether the benefits of automatic cleanup outweigh the potential drawbacks associated with lost logs and debugging information.<\/p>\n
      Docker Cleanup Commands<\/h2>\n
      While the --rm<\/code> flag facilitates automatic cleanup for individual containers, managing stopped containers en masse can still be necessary in production environments. In such cases, Docker provides commands to remove all stopped containers:<\/p>\n
      docker container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> prune<\/code><\/pre>\n
      This command removes all containers that are not currently running, helping to keep the Docker environment tidy.<\/p>\n
      Real-World Use Cases<\/h2>\n
      Several real-world scenarios exemplify the practical application of the --rm<\/code> flag:<\/p>\n
        \n
      1. \n
        Continuous Integration\/Continuous Deployment (CI\/CD)<\/strong>: In CI\/CD pipelines, where containers are spun up 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> tests or build applications, using --rm<\/code> ensures that once the tasks are completed, the environment is cleaned up automatically, keeping the build agents free from clutter.<\/p>\n<\/li>\n
      2. \n
        Microservices Testing<\/strong>: When developing microservices, developers can use --rm<\/code> to spin up services temporarily for testing purposes without worrying about leftover containers from previous tests.<\/p>\n<\/li>\n
      3. \n
        Data Pipelines<\/strong>: In data processing pipelines, containers might be launched to perform transformations or analyses on data. The --rm<\/code> flag can be employed to ensure that temporary processing containers are cleaned up after completion.<\/p>\n<\/li>\n<\/ol>\n
        Conclusion<\/h2>\n
        The --rm<\/code> flag in Docker is an invaluable tool for managing container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> lifecycles, particularly for short-lived or temporary tasks. It automates cleanup processes, helping users maintain a tidy Docker environment and streamline workflows. However, the flag’s utility must be weighed against considerations regarding logging, debugging, and the need for persistent container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> states. <\/p>\n
        Understanding the appropriate context for using --rm<\/code>, along with integrating it into advanced Docker setups such as 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>, can greatly enhance your Docker experience, making your development and deployment processes more efficient and manageable. As you continue to explore the capabilities of Docker, the --rm<\/code> flag will undoubtedly be a powerful ally in your container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> management strategy.<\/p>","protected":false},"excerpt":{"rendered":"
        The `\u2013rm` flag 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> La commande `docker run --rm` est utilis\u00e9e pour supprimer automatiquement les conteneurs apr\u00e8s leur arr\u00eat. Cela permet de maintenir un environnement plus propre en \u00e9vitant l'accumulation de conteneurs arr\u00eat\u00e9s.<\/p>","protected":false},"author":1,"featured_media":1981,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1334","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -rm - 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-rm\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -rm - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--rm` flag in Dockerfile commands is used to automatically remove containers after they exit. This helps maintain a cleaner environment by preventing the accumulation of stopped containers.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-rm\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-07-23T12:23:50+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.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=\"5 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/\",\"name\":\"Dockerfile -rm - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg\",\"datePublished\":\"2024-07-23T12:21:41+00:00\",\"dateModified\":\"2024-07-23T12:23:50+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-rm-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#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 –rm\"}]},{\"@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 -rm - 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-rm\/","og_locale":"fr_FR","og_type":"article","og_title":"Dockerfile -rm - Dockerpros","og_description":"The `--rm` flag in Dockerfile commands is used to automatically remove containers after they exit. This helps maintain a cleaner environment by preventing the accumulation of stopped containers.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-rm\/","og_site_name":"Dockerpros","article_modified_time":"2024-07-23T12:23:50+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/","name":"Dockerfile -rm - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg","datePublished":"2024-07-23T12:21:41+00:00","dateModified":"2024-07-23T12:23:50+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-rm_1334.jpg","width":800,"height":600,"caption":"dockerfile-rm-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-rm\/#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 –rm"}]},{"@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\/1334","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\/1334\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/1981"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1334"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1334"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}