{"id":1341,"date":"2024-07-23T12:36:18","date_gmt":"2024-07-23T12:36:18","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1341"},"modified":"2024-07-23T12:36:18","modified_gmt":"2024-07-23T12:36:18","slug":"dockerfile-cpu-quota","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cpu-quota\/","title":{"rendered":"Dockerfile \u2013cpu-quota"},"content":{"rendered":"

Understanding Dockerfile –cpu-quota: An Advanced Guide<\/h1>\n

In the realm of containerization, Docker serves as a powerful platform that allows developers to package applications and their dependencies into standardized units called containers. One crucial feature of Docker is its capability to control resources allocated to these containers, thereby ensuring performance optimization and resource management. The --cpu-quota<\/code> flag is part of Docker’s resource management toolset, enabling users to specify a limit on the amount of CPU time available to 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 article delves into the intricacies of --cpu-quota<\/code>, its application within Docker, and how it can be effectively utilized to enhance 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 efficiency.<\/p>\n

The Basics of CPU Quota<\/h2>\n

Before we dive into the specifics of the --cpu-quota<\/code> option, it\u2019s essential to understand some foundational concepts related to CPU management in Docker:<\/p>\n

    \n
  1. \n

    CPU Shares<\/strong>: This is a relative weight assigned to containers when allocating CPU resources. By default, each 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> receives 1024 CPU shares. If one 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> has 2048 shares and another has 1024, the first 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> can use twice the CPU time of the second 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> when there is contention.<\/p>\n<\/li>\n

  2. \n

    CPUs<\/strong>: Docker allows users to limit the number of CPUs available to containers. This is done using flags like --cpus<\/code> or --cpuset-cpus<\/code>.<\/p>\n<\/li>\n

  3. \n

    CPU Quota<\/strong>: This is the time limit on how long 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> can use the CPU within a given period. It is defined in microseconds.<\/p>\n<\/li>\n<\/ol>\n

    The --cpu-quota<\/code> flag works in conjunction with the --cpu-period<\/code> flag, which defines the time period for the quota. The combination of these flags allows for precise control over CPU resource allocation.<\/p>\n

    How --cpu-quota<\/code> Works<\/h2>\n

    The --cpu-quota<\/code> flag allows you to specify the total amount of time (in microseconds) that 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> 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> during a specified period (set by --cpu-period<\/code>). By default, the --cpu-period<\/code> is 100,000 microseconds (or 100 milliseconds). Therefore, if you set --cpu-quota<\/code> to 50,000, it means 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> 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> for 50 milliseconds within a 100-millisecond window, effectively limiting its CPU usage to 50%.<\/p>\n

    Syntax<\/h3>\n

    The syntax for using --cpu-quota<\/code> is straightforward. When running a 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>, you can specify it like this:<\/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> --cpu-quota= --cpu-period= <\/code><\/pre>\n
    For example:<\/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> --cpu-quota=50000 --cpu-period=100000 my-container<\/code><\/pre>\n
    In this example, my-container<\/code> will be limited to 50% of a single CPU core.<\/p>\n
    Use Cases for --cpu-quota<\/code><\/h2>\n
    Understanding when and why to use --cpu-quota<\/code> can significantly enhance the performance of your applications and overall resource utilization within your environment. Here are several scenarios:<\/p>\n
    1. Multi-Tenant Environments<\/strong><\/h3>\n
    In environments where multiple applications or services 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> concurrently, each consuming CPU resources, --cpu-quota<\/code> helps enforce fair sharing of CPU resources. This ensures that no single application can monopolize CPU time, leading to performance degradation for other applications.<\/p>\n
    2. Burstable Workloads<\/strong><\/h3>\n
    Some applications experience spikes in CPU demand. By setting an appropriate --cpu-quota<\/code>, you can allow those bursts of activity while still maintaining an overall cap on CPU usage. This balance can prevent runaway processes from causing resource starvation.<\/p>\n
    3. Development and Testing<\/strong><\/h3>\n
    During development and testing, developers often require specific resource constraints to simulate production environments. Utilizing --cpu-quota<\/code> allows for accurate testing of how an application behaves under limited resources, helping identify potential performance issues before deployment.<\/p>\n
    4. Cost Management in Cloud Environments<\/strong><\/h3>\n
    In a cloud environment, where resources are billed based on usage, employing --cpu-quota<\/code> can help manage costs effectively. By restricting CPU usage, you can control expenses while still maintaining necessary application performance.<\/p>\n
    Practical Example: CPU Quota in Action<\/h2>\n
    To illustrate how --cpu-quota<\/code> can be applied practically, let\u2019s consider a scenario where you\u2019re deploying 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> that requires guaranteed performance without overwhelming the host system.<\/p>\n
    Step 1: Create a Simple Docker Image<\/h3>\n
    First, you\u2019ll need a Docker image<\/a><\/span>An image is a visual representation of an object or scene, typically composed of pixels in digital formats. It can convey information, evoke emotions, and facilitate communication across various media. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> for your web application. For simplicity, let\u2019s create a basic Python web server using Flask. Here\u2019s a 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> example:<\/p>\n
    # Use the official Python image\nFROM python:3.9-slim\n\n# Set the working directory\nWORKDIR \/app\n\n# Copy the requirements and install them\nCOPY requirements.txt .\nRUN pip install -r requirements.txt\n\n# Copy the application code\nCOPY . .\n\n# Expose the port\nEXPOSE 5000\n\n# Run the application\nCMD [\"python\", \"app.py\"]<\/code><\/pre>\n
    Step 2: Build the Docker Image<\/h3>\n
    Build the 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> using the following command:<\/p>\n
    docker build -t my-flask-app .<\/code><\/pre>\n
    Step 3: Run the Container with CPU Quota<\/h3>\n
    Now, let\u2019s 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 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> with --cpu-quota<\/code> to limit its CPU usage:<\/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> --name my-flask-container --cpu-quota=50000 --cpu-period=100000 -p 5000:5000 my-flask-app<\/code><\/pre>\n
    In this case, the web application can utilize 50% of the CPU resources available in its environment.<\/p>\n
    Step 4: Monitor Performance<\/h3>\n
    You can monitor how the application performs under this constraint using tools like docker stats<\/code>, which provides real-time metrics about 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> resource usage.<\/p>\n
    docker stats my-flask-container<\/code><\/pre>\n
    This command will show you the CPU usage, memory usage, and other important metrics, allowing you to assess if the --cpu-quota<\/code> setting is appropriate for your workload.<\/p>\n
    Advanced Configurations<\/h2>\n
    Combining CPU Quota with Other Resource Constraints<\/h3>\n
    Docker allows you to layer multiple resource constraints for more granularity. Here are a few advanced configurations that can be combined with --cpu-quota<\/code> to yield even greater control:<\/p>\n
      \n
    1. \n
      Memory Limitation<\/strong>: Use the --memory<\/code> flag to cap memory usage along with CPU limits. This is particularly useful for applications with predictable memory usage patterns.<\/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> --cpu-quota=50000 --cpu-period=100000 --memory=512m my-flask-app<\/code><\/pre>\n<\/li>\n
    2. \n
      Block IO Limitation<\/strong>: Use the --blkio-weight<\/code> flag to manage block IO, ensuring that CPU and IO resources are balanced according to your application\u2019s needs.<\/p>\n<\/li>\n
    3. \n
      Network<\/a><\/span>A network, in computing, refers to a collection of interconnected devices that communicate and share resources. It enables data exchange, facilitates collaboration, and enhances operational efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> Bandwidth Limitation<\/strong>: If your application is network-intensive, consider using --network<\/code> options to manage network<\/a><\/span>A network, in computing, refers to a collection of interconnected devices that communicate and share resources. It enables data exchange, facilitates collaboration, and enhances operational efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> bandwidth alongside CPU and memory constraints.<\/p>\n<\/li>\n<\/ol>\n
      Evaluating Performance<\/h3>\n
      To understand how effective your --cpu-quota<\/code> settings are, consider employing profiling tools that can help analyze your application\u2019s performance under load. Tools such as cAdvisor<\/code> or integrated monitoring solutions like Prometheus<\/code> can provide insights into how resource constraints impact application behavior.<\/p>\n
      Potential Pitfalls<\/h2>\n
      While --cpu-quota<\/code> is a powerful tool for resource management, improper use can lead to performance degradation. Here are some common pitfalls to avoid:<\/p>\n
        \n
      1. \n
        Overly Aggressive Quotas<\/strong>: Setting the CPU quota too low can throttle your application, causing slow response times and degraded user experience.<\/p>\n<\/li>\n
      2. \n
        Not Monitoring Impact<\/strong>: Resource constraints should be continually monitored. Adjustments may be necessary based on changing workloads or application performance characteristics.<\/p>\n<\/li>\n
      3. \n
        Ignoring Application Needs<\/strong>: Different applications have different resource needs. A one-size-fits-all approach to CPU quotas may not yield optimal performance.<\/p>\n<\/li>\n<\/ol>\n
        Conclusion<\/h2>\n
        Understanding and effectively utilizing the --cpu-quota<\/code> option in Docker is essential for managing containerized applications in resource-constrained environments. By enabling precise control over CPU resources, developers can ensure fair sharing, manage performance under load, and optimize overall resource utilization.<\/p>\n
        As you integrate --cpu-quota<\/code> into your Docker workflows, remember that resource constraints are not just about limiting performance; they are also about optimizing and ensuring that your applications 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> efficiently within the broader context of system resources. By combining --cpu-quota<\/code> with other Docker resource management features, you can achieve a finely tuned 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> environment that meets both performance and cost-efficiency goals.<\/p>\n
        In an age where applications need to be as lean and efficient as possible, mastering tools like --cpu-quota<\/code> will empower you to build robust, high-performance containerized applications that can scale effectively while maintaining resource discipline. Whether you’re working in a development, staging, or production environment, Docker’s resource management features are indispensable in today’s cloud-native landscape.<\/p>","protected":false},"excerpt":{"rendered":"
        Le param\u00e8tre `\u2013cpu-quota` dans les Dockerfiles permet aux utilisateurs de d\u00e9finir une limite sur l'utilisation du CPU pour les conteneurs. Cette valeur sp\u00e9cifie la quantit\u00e9 totale de temps CPU qui peut \u00eatre allou\u00e9e, am\u00e9liorant ainsi la gestion des ressources.<\/p>","protected":false},"author":1,"featured_media":1995,"parent":0,"template":"","glossary-cat":[],"class_list":["post-1341","glossary","type-glossary","status-publish","has-post-thumbnail","hentry"],"yoast_head":"\nDockerfile -cpu-quota - 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-cpu-quota\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dockerfile -cpu-quota - Dockerpros\" \/>\n<meta property=\"og:description\" content=\"The `--cpu-quota` flag in Dockerfiles allows users to set a limit on CPU usage for containers. This value specifies the total amount of CPU time that can be allocated, enhancing resource management.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cpu-quota\/\" \/>\n<meta property=\"og:site_name\" content=\"Dockerpros\" \/>\n<meta property=\"og:image\" content=\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.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-cpu-quota\/\",\"url\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/\",\"name\":\"Dockerfile -cpu-quota - Dockerpros\",\"isPartOf\":{\"@id\":\"https:\/\/dockerpros.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.jpg\",\"datePublished\":\"2024-07-23T12:36:18+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#primaryimage\",\"url\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.jpg\",\"contentUrl\":\"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.jpg\",\"width\":800,\"height\":600,\"caption\":\"dockerfile-cpu-quota-2\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#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 –cpu-quota\"}]},{\"@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 -cpu-quota - 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-cpu-quota\/","og_locale":"fr_FR","og_type":"article","og_title":"Dockerfile -cpu-quota - Dockerpros","og_description":"The `--cpu-quota` flag in Dockerfiles allows users to set a limit on CPU usage for containers. This value specifies the total amount of CPU time that can be allocated, enhancing resource management.","og_url":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-cpu-quota\/","og_site_name":"Dockerpros","og_image":[{"width":800,"height":600,"url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.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-cpu-quota\/","url":"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/","name":"Dockerfile -cpu-quota - Dockerpros","isPartOf":{"@id":"https:\/\/dockerpros.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#primaryimage"},"image":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#primaryimage"},"thumbnailUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.jpg","datePublished":"2024-07-23T12:36:18+00:00","breadcrumb":{"@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#primaryimage","url":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.jpg","contentUrl":"https:\/\/dockerpros.com\/wp-content\/uploads\/2024\/07\/dockerfile-cpu-quota_1341.jpg","width":800,"height":600,"caption":"dockerfile-cpu-quota-2"},{"@type":"BreadcrumbList","@id":"https:\/\/dockerpros.com\/wiki\/dockerfile-cpu-quota\/#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 –cpu-quota"}]},{"@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\/1341","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\/1341\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media\/1995"}],"wp:attachment":[{"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/media?parent=1341"}],"wp:term":[{"taxonomy":"glossary-cat","embeddable":true,"href":"https:\/\/dockerpros.com\/fr\/wp-json\/wp\/v2\/glossary-cat?post=1341"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}