{"id":1293,"date":"2024-07-23T12:19:23","date_gmt":"2024-07-23T12:19:23","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1293"},"modified":"2024-11-07T22:52:07","modified_gmt":"2024-11-07T22:52:07","slug":"docker-compose-down-rimuovi-orfani","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/it\/wiki\/docker-compose-down-remove-orphans\/","title":{"rendered":"Docker Compose Down \u2013remove-orphans"},"content":{"rendered":"

Understanding Docker Compose Down –remove-orphans<\/h2>\n

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> is a robust tool used to define and orchestrate multi-container Docker applications, allowing teams to manage complex containerized environments through a simple configuration file. When running the docker-compose down<\/code> command, users can stop and remove all containers, networks, and resources defined in their docker-compose.yml<\/code> file. However, the --remove-orphans<\/code> flag extends this functionality, removing containers that, while not defined in the current configuration file, were once associated with a previous configuration. This article provides a deep dive into the docker-compose down --remove-orphans<\/code> command, examining its functionality, implications, and best practices to maintain clean, efficient Docker environments.<\/p>\n

The Role of Docker Compose<\/h2>\n

To fully appreciate the docker-compose down --remove-orphans<\/code> command, it is critical to understand Docker Compose\u2019s role in managing containerized applications. 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> streamlines the orchestration<\/a><\/span>Orchestration refers to the automated management and coordination of complex systems and services. It optimizes processes by integrating various components, ensuring efficient operation and resource utilization. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> of multi-container applications by enabling users to define services, networks, and volumes in a declarative YAML<\/a><\/span>YAML (YAML Ain't Markup Language) is a human-readable data serialization format commonly used for configuration files. It emphasizes simplicity and clarity, making it suitable for both developers and non-developers. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> format. This setup simplifies complex application environments with interdependent services, making it an invaluable tool in development, testing, and staging environments where multiple services must work in concert.<\/p>\n

The Command Structure<\/h2>\n

The docker-compose down<\/code> command is a part of the 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> CLI, which allows users to manage multi-container Docker applications. The basic syntax of the command is as follows:<\/p>\n

docker-compose down [OPTIONS]<\/code><\/pre>\n
The --remove-orphans<\/code> flag is an optional parameter that can be used with this command:<\/p>\n
docker-compose down --remove-orphans<\/code><\/pre>\n
When executed, this command performs the following actions:<\/p>\n
    \n
  1. Stops all running containers defined in the docker-compose.yml<\/code> file.<\/li>\n
  2. Removes all stopped containers.<\/li>\n
  3. Removes any networks that were created with the docker-compose up<\/code> command.<\/li>\n
  4. By using the --remove-orphans<\/code> flag, it also cleans up containers that are not defined in the current docker-compose.yml<\/code> file but are associated with the project.<\/li>\n<\/ol>\n
    Why Use –remove-orphans?<\/h3>\n
    The --remove-orphans<\/code> flag serves a crucial purpose in maintaining a clean and organized Docker environment. Here are some reasons why this option is particularly useful:<\/p>\n
      \n
    1. Preventing Resource Waste<\/strong>: Orphaned containers can consume system resources unnecessarily. By removing them, you ensure that your environment remains efficient and responsive.<\/li>\n
    2. Eliminating Confusion<\/strong>: In complex projects, it is not uncommon for containers to accumulate over time from various iterations of the application. This can lead to confusion when trying to troubleshoot issues. Removing orphans helps streamline 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> landscape, making it easier to identify which containers are relevant to the current application state.<\/li>\n
    3. Improving Build Times<\/strong>: When running docker-compose up<\/code>, Docker must check the existing containers, networks, and volumes to determine what needs to be rebuilt or brought up. Removing orphans can speed up this process by allowing Docker to focus only on the relevant resources.<\/li>\n
    4. Facilitating Collaboration<\/strong>: In team environments, multiple developers may work on the same project. Orphan containers can arise from previous configurations or changes made by team members. By cleaning these up regularly, you ensure that everyone is working with the same baseline setup.<\/li>\n<\/ol>\n
      While the --remove-orphans<\/code> flag offers substantial advantages for cleaning up Docker environments, it should be used thoughtfully to avoid unintended disruptions. Here are key best practices to follow when using this command:<\/p>\n
      1. Fully Understand Your Environment<\/h3>\n
      Before executing docker-compose down --remove-orphans<\/code>, it\u2019s crucial to understand the current state of your Docker environment. Review all active containers, networks, and volumes to ensure that any removed resources won\u2019t impact dependent services or workflows. Documenting your setup and dependencies can help make informed choices about what can safely be removed, especially in larger, multi-service environments.<\/p>\n
      2. Regular Cleanup in Development Environments<\/h3>\n
      In development environments, where 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> configurations change frequently, regular use of docker-compose down --remove-orphans<\/code> can prevent unnecessary clutter and resource consumption. Routine cleanups also help streamline operations and avoid resource conflicts, especially as projects scale or change. However, exercise caution in production settings to avoid inadvertently removing containers that may be critical for application continuity.<\/p>\n
      3. Backup Critical Data in Volumes<\/h3>\n
      The docker-compose down<\/code> command removes volumes by default unless otherwise specified, which can result in permanent data loss if not managed carefully. Prior to running this command, ensure that any valuable data stored in volumes is safely backed up. Employ automated backups or set specific policies to protect sensitive data and avoid accidental data removal, especially for persistent storage in production environments.<\/p>\n
      4. Implement Version Control for Docker Compose Files<\/h3>\n
      To reduce the risk of accidental removal of important services, maintain version control for your docker-compose.yml<\/code> files. Versioning your configuration allows you to track changes over time and quickly revert to a previous state if needed. This is particularly useful when modifying 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> definitions or removing orphan containers, as you can reference prior configurations and ensure a smooth rollback if issues arise.<\/p>\n
      5. Test in a Staging Environment<\/h3>\n
      Before deploying significant configuration changes or cleaning up orphan containers in production, test the docker-compose down --remove-orphans<\/code> command in a staging environment. This approach enables you to verify that the command performs as expected without risking live services or impacting end-users. A staging test can also reveal any unanticipated interactions or dependencies that might otherwise be disrupted in production.<\/p>\n
      6. Leverage Logging and Monitoring for Enhanced Visibility<\/h3>\n
      Monitoring and logging can provide insights into the impact of docker-compose down --remove-orphans<\/code> on your Docker environment. By setting up appropriate logging, you can track 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> activity, volume<\/a><\/span>Volume is a quantitative measure of three-dimensional space occupied by an object or substance, typically expressed in cubic units. It is fundamental in fields such as physics, chemistry, and engineering. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> usage, and the effects of cleanup operations, enabling you to quickly detect and resolve any unintended issues. Tools like Prometheus, Grafana, and Elasticsearch provide monitoring capabilities that can help track 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> performance and state, ensuring a more stable environment.<\/p>\n
      7. Establish Clear Policies for Production Environments<\/h3>\n
      In production environments, set clear policies around when and how the --remove-orphans<\/code> flag should be used, and document the protocol for cleanup. Restrict its usage to scheduled maintenance windows or after-hours to minimize disruption. Ensure that anyone performing this operation understands which containers are considered safe to remove and has a rollback plan in place for unexpected outcomes.<\/p>\n
      By following these best practices, you can maximize the benefits of docker-compose down --remove-orphans<\/code> while minimizing risks to stability and data integrity. This approach will help keep your Docker environments efficient, clean, and well-managed.<\/p>\n
      Common Scenarios<\/h2>\n
      Scenario 1: Development Iteration<\/h3>\n
      During the development of a microservices application, a developer may frequently modify the docker-compose.yml<\/code> file to add<\/a><\/span>The ADD instruction in Docker is a command used in Dockerfiles to copy files and directories from a host machine into a Docker image during the build process. It not only facilitates the transfer of local files but also provides additional functionality, such as automatically extracting compressed files and fetching remote files via HTTP or HTTPS. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> or remove services. Over time, this can lead to orphaned containers from previous configurations. By running docker-compose down --remove-orphans<\/code>, the developer can clean up these outdated containers, allowing them to focus on the current state of the application.<\/p>\n
      Scenario 2: CI\/CD Pipeline<\/h3>\n
      In continuous integration\/continuous deployment (CI\/CD) pipelines, automated scripts frequently build and tear down Docker environments. Using docker-compose down --remove-orphans<\/code> ensures that each build starts with a clean slate, free from any orphaned containers introduced by previous builds. This practice can reduce build failures caused by lingering services.<\/p>\n
      Scenario 3: Team Collaboration<\/h3>\n
      In a team setting, multiple developers may work on the same application, each modifying the docker-compose.yml<\/code> file. To maintain a consistent and clean development environment, it is a good practice 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> docker-compose down --remove-orphans<\/code> regularly. This ensures that everyone on the team is working with the same set of containers and services, minimizing conflicts and confusion.<\/p>\n
      Troubleshooting Common Issues<\/h2>\n
      While using the docker-compose down --remove-orphans<\/code> command is generally straightforward, users may encounter some issues. Here are a few common problems and their solutions:<\/p>\n
      Issue 1: Command Fails Due to Running Containers<\/h3>\n
      If you try 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> docker-compose down --remove-orphans<\/code> while there are running containers that were started outside of 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>, you may receive an error. Ensure all relevant containers are stopped before executing the command.<\/p>\n
      Issue 2: Unintentional Data Loss<\/h3>\n
      As noted earlier, the docker-compose down<\/code> command will remove volumes by default. If important data is stored in these volumes, you may inadvertently lose it. To prevent this, always back up your data and specify the --volumes<\/code> option if you want to retain them.<\/p>\n
      Issue 3: Missing Orphan Containers<\/h3>\n
      If you find that some expected orphan containers were not removed, check if they are still referenced in any other 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> files or if they were inadvertently recreated by another process or configuration.<\/p>\n
      Conclusion<\/h2>\n
      The docker-compose down --remove-orphans<\/code> command is a powerful tool for maintaining a clean and efficient Docker environment. By removing orphaned containers, users can reduce resource waste, eliminate confusion, and streamline their development processes. However, it is crucial to understand the implications of using this command, especially regarding data loss and environment stability. By following best practices and being aware of common issues, developers can leverage this command effectively in their Docker workflows.<\/p>\n
      In summary, while 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> is intended to simplify the management of multi-container applications, the --remove-orphans<\/code> flag adds an essential layer of cleanliness and organization that is invaluable in both development and production environments. Embrace this command as part of your Docker toolkit, and ensure your containerized applications are running smoothly and efficiently.<\/p>","protected":false},"excerpt":{"rendered":"
      The `docker-compose down \u2013remove-orphans` command is utilized to stop and remove containers defined in a Compose file, along with any orphaned containers not specified in the current configuration. This ensures a clean environment, helping to avoid conflicts and free up resources.<\/p>","protected":false},"author":1,"featured_media":1903,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1293","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDocker Compose Down -remove-orphans - 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\/it\/wiki\/docker-compose-down-rimuovi-orfani\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Docker Compose Down -remove-orphans - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `docker-compose down --remove-orphans` command is utilized to stop and remove containers defined in a Compose file, along with any orphaned containers not specified in the current configuration. This ensures a clean environment, helping to avoid conflicts and free up resources.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/it\/wiki\/docker-compose-down-rimuovi-orfani\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"article:modified_time\" content=\"2024-11-07T22:52:07+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.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=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/\",\"name\":\"Docker Compose Down -remove-orphans - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg\",\"datePublished\":\"2024-07-23T12:19:23+00:00\",\"dateModified\":\"2024-11-07T22:52:07+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg\",\"width\":800,\"height\":600,\"caption\":\"docker-compose-down-remove-orphans-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#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\":\"Docker Compose Down –remove-orphans\"}]},{\"@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\":\"it-IT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/dockerpros.com\/#organization\",\"name\":\"Dockerpros\",\"url\":\"https:\/\/dockerpros.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@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":"Docker Compose Down -remove-orphans - 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\/it\/wiki\/docker-compose-down-rimuovi-orfani\/","og_locale":"it_IT","og_type":"article","og_title":"Docker Compose Down -remove-orphans - Dockerpros","og_description":"The `docker-compose down --remove-orphans` command is utilized to stop and remove containers defined in a Compose file, along with any orphaned containers not specified in the current configuration. This ensures a clean environment, helping to avoid conflicts and free up resources.","og_url":"https:\/\/dockerpros.com\/it\/wiki\/docker-compose-down-rimuovi-orfani\/","og_site_name":"Dockerpros","article_modified_time":"2024-11-07T22:52:07+00:00","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Tempo di lettura stimato":"7 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/","url":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/","name":"Docker Compose Down -remove-orphans - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg","datePublished":"2024-07-23T12:19:23+00:00","dateModified":"2024-11-07T22:52:07+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/docker-compose-down-remove-orphans_1293.jpg","width":800,"height":600,"caption":"docker-compose-down-remove-orphans-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/docker-compose-down-remove-orphans\/#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":"Docker Compose Down –remove-orphans"}]},{"@type":"WebSite","@id":"https:\/\/dockerpros.com\/#website","url":"https:\/\/dockerpros.com\/","name":"Esperti Docker","description":"DockerPros \u2013 Il tuo punto di riferimento definitivo per 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":"it-IT"},{"@type":"Organization","@id":"https:\/\/dockerpros.com\/#organization","name":"Esperti Docker","url":"https:\/\/dockerpros.com\/","logo":{"@type":"ImageObject","inLanguage":"it-IT","@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\/it\/wp-json\/wp\/v2\/glossary\/1293","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary"}],"about":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/types\/glossary"}],"author":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary\/1293\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media\/1903"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/media?parent=1293"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/it\/wp-json\/wp\/v2\/glossary-cat?post=1293"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}