{"id":3334,"date":"2020-10-27T14:19:17","date_gmt":"2020-10-27T14:19:17","guid":{"rendered":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/"},"modified":"2021-11-17T21:23:22","modified_gmt":"2021-11-17T21:23:22","slug":"kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits","status":"publish","type":"post","link":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/","title":{"rendered":"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits"},"content":{"rendered":"\t\t<div data-elementor-type=\"wp-post\" data-elementor-id=\"3334\" class=\"elementor elementor-3334\" data-elementor-post-type=\"post\">\n\t\t\t\t\t\t<section class=\"elementor-section elementor-top-section elementor-element elementor-element-40a4dbed elementor-section-boxed elementor-section-height-default elementor-section-height-default qodef-elementor-content-no\" data-id=\"40a4dbed\" data-element_type=\"section\">\n\t\t\t\t\t\t<div class=\"elementor-container elementor-column-gap-default\">\n\t\t\t\t\t<div class=\"elementor-column elementor-col-100 elementor-top-column elementor-element elementor-element-5296ab91\" data-id=\"5296ab91\" data-element_type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t<div class=\"elementor-element elementor-element-232d537 elementor-widget elementor-widget-text-editor\" data-id=\"232d537\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t<style>\/*! elementor - v3.21.0 - 30-04-2024 *\/\n.elementor-widget-text-editor.elementor-drop-cap-view-stacked .elementor-drop-cap{background-color:#69727d;color:#fff}.elementor-widget-text-editor.elementor-drop-cap-view-framed .elementor-drop-cap{color:#69727d;border:3px solid;background-color:transparent}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap{margin-top:8px}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap-letter{width:1em;height:1em}.elementor-widget-text-editor .elementor-drop-cap{float:left;text-align:center;line-height:1;font-size:50px}.elementor-widget-text-editor .elementor-drop-cap-letter{display:inline-block}<\/style>\t\t\t\t<p><em>This is part one of a five-part series on\u00a0<a href=\"https:\/\/blog.newrelic.com\/tag\/kubernetes-fundamentals\/\" target=\"_blank\" rel=\"noopener noreferrer\">Kubernetes Fundamentals<\/a>. Check back for new parts in the following weeks.<\/em><\/p><p>Kubernetes is a system for automating containerized applications. It manages the nodes in your cluster, and you define the resource requirements for your applications. Understanding how\u00a0<a href=\"https:\/\/blog.newrelic.com\/engineering\/what-is-kubernetes\/\" target=\"_blank\" rel=\"noopener noreferrer\">Kubernetes<\/a>\u00a0manages resources, especially during peak times, is important to keep your containers running smoothly.<\/p><p>In this post, we\u2019ll take a look at how Kubernetes manages CPU and memory using requests and limits.<\/p><h3>How requests and limits work<\/h3><p>Every node in a Kubernetes cluster has an allocated amount of memory (RAM) and computational power (CPU) that can be used to run containers.<\/p><p><a href=\"https:\/\/contentlab.com\/securing-secrets-in-kubernetes\/\">Kubernetes<\/a>\u00a0defines a logical grouping of one or more containers into Pods. Pods, in turn, can be deployed and managed on top of the nodes. When you create a Pod, you normally specify the storage and networking that containers share within that Pod. The Kubernetes scheduler will then look for nodes that have the resources required to run the Pod.<\/p><p>To help the scheduler, we can specify a lower and upper RAM and CPU limits for each container using\u00a0<em>requests<\/em>\u00a0and\u00a0<em>limits<\/em>. These two keywords enable us to specify the following:<\/p><ul style=\"font-size: 16px; background-color: #ffffff;\"><li style=\"font-size: 16px;\">By specifying a request on a container, we are setting the minimum amount of RAM or CPU required for that container. Kubernetes will roll all container requests up into a total Pod request. The scheduler will use this total request to ensure the Pod can be deployed on a node with enough resources.<\/li><li style=\"font-size: 16px;\">By specifying a limit on a container, we are setting the maximum amount of RAM or CPU that the container can consume. Kubernetes translates the limits to the container service (Docker, for instance) that enforces the limit. If a container exceeds its memory limit, it may be terminated and restarted, if possible. CPU limits are less strict and can generally be exceeded for extended periods of time.<br \/><br \/><\/li><\/ul><p>Let\u2019s see how requests and limits are used.<\/p><h3>Setting CPU requests and limits<\/h3><p>Requests and limits on CPU are measured in CPU units. In Kubernetes, a single CPU unit equals a virtual CPU (vCPU) or core for cloud providers, or a single thread on bare metal processors.<\/p><p>Under certain circumstances, one full CPU unit can still be considered a lot of resources for a container, particularly when we talk about microservices. This is why Kubernetes supports CPU fractions. While you can enter fractions of the CPU as decimals \u2014 for example, 0.5 of a CPU \u2014\u00a0<a href=\"https:\/\/contentlab.com\/securing-secrets-in-kubernetes\/\">Kubernetes<\/a>\u00a0uses the \u201cmillicpu\u201d notation, where 1,000 millicpu (or 1,000m) equals 1 CPU unit.<\/p><p>When we submit a request for a CPU unit, or a fraction of it, the Kubernetes scheduler will use this value to find a node within a cluster that the Pod can run on. For instance, if a Pod contains a single container with a CPU request of 1 CPU, the scheduler will ensure the node it places this Pod on has 1 CPU resource free. For a Docker container, Kubernetes uses the\u00a0<a href=\"https:\/\/docs.docker.com\/engine\/reference\/run\/#cpu-share-constraint\" target=\"_blank\" rel=\"noopener noreferrer\">CPU share constraint<\/a>\u00a0to proportion the CPU.<\/p><p>If we specify a limit, Kubernetes will try to set the container\u2019s upper CPU usage limit. As mentioned earlier, this is not a hard limit, and a container may or may not exceed this limit depending on the containerization technology. For a Docker container, Kubernetes uses the\u00a0<a href=\"https:\/\/docs.docker.com\/engine\/reference\/run\/#cpu-period-constraint\" target=\"_blank\" rel=\"noopener noreferrer\">CPU period constraint<\/a>\u00a0to set the upper bounds of CPU usage. This allows Docker to restrict the percentage of runtime over 100 milliseconds the container can use.<\/p><p>Below is a simple example of a Pod configuration YAML file with a CPU request of 0.5 units and a CPU limit of 1.5 units.<\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-dff2d57 elementor-widget elementor-widget-code-highlight\" data-id=\"dff2d57\" data-element_type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<div class=\"prismjs-default copy-to-clipboard \">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-javascript line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-javascript\">\n\t\t\t\t\t<xmp>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: cpu-request-limit-example\r\nspec:\r\n  containers:\r\n  - name: cpu-request-limit-container\r\n    image: images.example\/app-image\r\n    resources:\r\n      requests:\r\n        cpu: \"500m\"\r\n      limits:\r\n        cpu: \"1500m\"<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-f61cc9c elementor-widget elementor-widget-text-editor\" data-id=\"f61cc9c\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<p>This configuration defines a single container called \u201ccpu-request-limit-container\u201d with the image limits specified in the resources section. In that section, we specify our requests and limits. In this case, we are requesting 500 millicpu (0.5 or 50% of a CPU unit) and limiting the container to 1500 millicpu (1.5 or 150% of a CPU unit).<\/p><h3>Setting memory requests and limits<\/h3><p>Memory requests and limits are measured in bytes, with some standard short codes to specify larger amounts, such as Kilobytes (K) or 1,000 bytes, Megabytes (M) or 1,000,000 bytes, and Gigabytes (G) or 1,000,000,000 bytes. There is also power of 2 versions of these shortcuts. For example, Ki (1,024 bytes), Mi, and Gi. Unlike CPU units, there are no fractions for memory as the smallest unit is a byte.<\/p><p>The Kubernetes scheduler uses memory requests to find a node within your cluster that has enough memory for the Pod to run on. Memory limits work in a similar way to CPU limits except they are enforced in a more strict manner. If a container exceeds a memory limit, it might be terminated and potentially restarted with an \u201cout of memory\u201d error.<\/p><p>The simple example of a Pod configuration YAML file below contains a memory request of 256 megabytes and a memory limit of 512 megabytes.<\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-d5dc20f elementor-widget elementor-widget-code-highlight\" data-id=\"d5dc20f\" data-element_type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<div class=\"prismjs-default copy-to-clipboard \">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-javascript line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-javascript\">\n\t\t\t\t\t<xmp>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: memory-request-limit-example\r\nspec:\r\n  containers:\r\n  - name: memory-request-limit-container\r\n    image: images.example\/app-image\r\n    resources:\r\n     requests:\r\n       memory: \"256M\"\r\n     limits:\r\n       memory: \"512M\"<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-6a769f3 elementor-widget elementor-widget-text-editor\" data-id=\"6a769f3\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<p><\/p>\n<pre><span style=\"color: var( --e-global-color-text ); font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-weight: var( --e-global-typography-text-font-weight ); font-size: 1rem;\">This configuration defines a single container called \u201cmemory-request-limit-container\u201d with the image limits specified in the resources section. We have specified the memory request of 256M, and we\u2019ve limited the container to 512M.<\/span><br><\/pre>\n<h3>Setting limits via namespaces<\/h3>\n<p>If you have several developers, or teams of developers, working within the same large Kubernetes cluster, a good practice is to set common resource requirements to ensure resources are not consumed inadvertently. With Kubernetes, you can define the different namespaces for teams and use Resource Quotas to enforce quotas on these namespaces.<\/p>\n<p>For instance, you may have a Kubernetes cluster that has 64 CPU units and 256 Gigabytes of RAM spread over eight nodes. You might create three namespaces \u2014 one for each of your development teams \u2014 with the resource quota of 10 CPU units and 80 Gigabytes of memory. This would allow each development team to create any number of Pods up to that limit, with some CPU and memory left in reserve.<\/p>\n<p>For more information on specifying resource quotas for namespaces, refer to the <a href=\"https:\/\/kubernetes.io\/docs\/concepts\/policy\/resource-quotas\/\" target=\"_blank\" rel=\"noopener noreferrer\">Resource Quotas<\/a> section of the Kubernetes documentation.<\/p>\n<h3>The importance of monitoring Kubernetes<\/h3>\n<p>Setting requests and limits on both containers and namespaces can go a long way to ensure your Kubernetes cluster does not run out of resources. Monitoring, however, still plays an important role in maintaining the health of individual services, as well as the overall health of your cluster.<\/p>\n<p>When you have large clusters with many services running within Kubernetes pods, health and error monitoring can be difficult. The <a href=\"https:\/\/newrelic.com\/platform\" target=\"_blank\" rel=\"noopener noreferrer\">New Relic platform<\/a> offers an easy way to <a href=\"https:\/\/newrelic.com\/platform\/kubernetes\/monitoring-guide\" target=\"_blank\" rel=\"noopener noreferrer\">monitor your Kubernetes cluster<\/a> and the services running within it. It helps you make sure that requests and limits you are setting at the container and across the cluster are appropriate.<\/p>\n<p><img fetchpriority=\"high\" decoding=\"async\" class=\"alignnone size-full wp-image-4331\" src=\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/cluster_capacity-1024x656-1.png\" alt=\"\" width=\"1024\" height=\"656\" srcset=\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/cluster_capacity-1024x656-1.png 1024w, https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/cluster_capacity-1024x656-1-300x192.png 300w, https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/cluster_capacity-1024x656-1-768x492.png 768w\" sizes=\"(max-width: 1024px) 100vw, 1024px\" \/><\/p>\n<p id=\"caption-attachment-52907\" class=\"wp-caption-text\">Kubernetes dashboard provides an overview of your Kubernetes platform health<\/p>\n<p>Having a good understanding of how Kubernetes handles CPU and memory resources, as well as enabling configuration to manage these resources, is critical to ensure your Kubernetes clusters have enough capacity at all times. As we\u2019ve seen, setting CPU and memory requests and limits is easy\u2014and now you know how to do it. By adding a layer of monitoring, you will go a long way to ensuring that Pods are not fighting for resources on your cluster.<\/p>\n<p><em>This article was originally posted on <a href=\"https:\/\/blog.newrelic.com\/engineering\/kubernetes-request-and-limits\/\">New Relic&#8217;s blog<\/a>.<\/em><\/p>\n<p><em><span class=\"TextRun SCXW156001673 BCX2\" lang=\"EN-US\" xml:lang=\"EN-US\" data-contrast=\"none\"><span class=\"NormalTextRun SCXW156001673 BCX2\">If you\u2019re interested in developing expert technical content that performs, <\/span><\/span><a class=\"Hyperlink SCXW156001673 BCX2\" href=\"https:\/\/contentlab.com\/contact\/\" target=\"_blank\" rel=\"noreferrer noopener\"><span class=\"TextRun Underlined SCXW156001673 BCX2\" lang=\"EN-US\" xml:lang=\"EN-US\" data-contrast=\"none\"><span class=\"NormalTextRun SCXW156001673 BCX2\" data-ccp-charstyle=\"Hyperlink\">let\u2019s have a conversation<\/span><\/span><\/a><span class=\"TextRun SCXW156001673 BCX2\" lang=\"EN-US\" xml:lang=\"EN-US\" data-contrast=\"none\"><span class=\"NormalTextRun SCXW156001673 BCX2\"> today.<\/span><\/span><\/em><\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"<p>In this post, we\u2019ll take a look at how Kubernetes manages CPU and memory using requests and limits.<\/p>\n","protected":false},"author":3,"featured_media":4892,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[19,278,18],"tags":[315,299],"hashtags":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v22.6 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits &#183; Technical Content Marketing | ContentLab<\/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:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits &#183; Technical Content Marketing | ContentLab\" \/>\n<meta property=\"og:description\" content=\"In this post, we\u2019ll take a look at how Kubernetes manages CPU and memory using requests and limits.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits\" \/>\n<meta property=\"og:site_name\" content=\"Technical Content Marketing | ContentLab\" \/>\n<meta property=\"article:published_time\" content=\"2020-10-27T14:19:17+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-11-17T21:23:22+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1746\" \/>\n\t<meta property=\"og:image:height\" content=\"530\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"ContentLab\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@ContentLabIO\" \/>\n<meta name=\"twitter:site\" content=\"@ContentLabIO\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"ContentLab\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#article\",\"isPartOf\":{\"@id\":\"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/\"},\"author\":{\"name\":\"ContentLab\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532\"},\"headline\":\"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits\",\"datePublished\":\"2020-10-27T14:19:17+00:00\",\"dateModified\":\"2021-11-17T21:23:22+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/\"},\"wordCount\":1185,\"publisher\":{\"@id\":\"https:\/\/contentlab.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage\"},\"thumbnailUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png\",\"keywords\":[\"CPU\",\"Kubernetes\"],\"articleSection\":[\"Containers\",\"Hands-on Tutorial\",\"Portfolio\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/\",\"url\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits\",\"name\":\"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits &#183; Technical Content Marketing | ContentLab\",\"isPartOf\":{\"@id\":\"https:\/\/contentlab.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage\"},\"image\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage\"},\"thumbnailUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png\",\"datePublished\":\"2020-10-27T14:19:17+00:00\",\"dateModified\":\"2021-11-17T21:23:22+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage\",\"url\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png\",\"contentUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png\",\"width\":1746,\"height\":530},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/contentlab.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/contentlab.com\/#website\",\"url\":\"https:\/\/contentlab.com\/\",\"name\":\"Technical Content Marketing | ContentLab\",\"description\":\"Technical Content Marketing Done Right.\",\"publisher\":{\"@id\":\"https:\/\/contentlab.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/contentlab.com\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/contentlab.com\/#organization\",\"name\":\"ContentLab.io\",\"url\":\"https:\/\/contentlab.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png\",\"contentUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png\",\"width\":768,\"height\":768,\"caption\":\"ContentLab.io\"},\"image\":{\"@id\":\"https:\/\/contentlab.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/x.com\/ContentLabIO\",\"https:\/\/www.linkedin.com\/company\/17893315\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532\",\"name\":\"ContentLab\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g\",\"caption\":\"ContentLab\"},\"description\":\"ContentLab provides high-quality written articles, tutorials, courses, and other technical marketing materials to industry leaders. We create no-nonsense tech content that\u2019s purpose-built to attract, educate, and engage your technical audience.\",\"sameAs\":[\"https:\/\/contentlab.op\"],\"url\":\"https:\/\/contentlab.com\/author\/contentlab\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits &#183; Technical Content Marketing | ContentLab","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:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits","og_locale":"en_US","og_type":"article","og_title":"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits &#183; Technical Content Marketing | ContentLab","og_description":"In this post, we\u2019ll take a look at how Kubernetes manages CPU and memory using requests and limits.","og_url":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits","og_site_name":"Technical Content Marketing | ContentLab","article_published_time":"2020-10-27T14:19:17+00:00","article_modified_time":"2021-11-17T21:23:22+00:00","og_image":[{"width":1746,"height":530,"url":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png","type":"image\/png"}],"author":"ContentLab","twitter_card":"summary_large_image","twitter_creator":"@ContentLabIO","twitter_site":"@ContentLabIO","twitter_misc":{"Written by":"ContentLab","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#article","isPartOf":{"@id":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/"},"author":{"name":"ContentLab","@id":"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532"},"headline":"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits","datePublished":"2020-10-27T14:19:17+00:00","dateModified":"2021-11-17T21:23:22+00:00","mainEntityOfPage":{"@id":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/"},"wordCount":1185,"publisher":{"@id":"https:\/\/contentlab.com\/#organization"},"image":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage"},"thumbnailUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png","keywords":["CPU","Kubernetes"],"articleSection":["Containers","Hands-on Tutorial","Portfolio"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-1-how-to-manage-cluster-capacity-with-requests-and-limits\/","url":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits","name":"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits &#183; Technical Content Marketing | ContentLab","isPartOf":{"@id":"https:\/\/contentlab.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage"},"image":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage"},"thumbnailUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png","datePublished":"2020-10-27T14:19:17+00:00","dateModified":"2021-11-17T21:23:22+00:00","breadcrumb":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#primaryimage","url":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png","contentUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png","width":1746,"height":530},{"@type":"BreadcrumbList","@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-request-and-limits#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/contentlab.com\/"},{"@type":"ListItem","position":2,"name":"Kubernetes Fundamentals, Part 1: How to Manage Cluster Capacity with Requests and Limits"}]},{"@type":"WebSite","@id":"https:\/\/contentlab.com\/#website","url":"https:\/\/contentlab.com\/","name":"Technical Content Marketing | ContentLab","description":"Technical Content Marketing Done Right.","publisher":{"@id":"https:\/\/contentlab.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/contentlab.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/contentlab.com\/#organization","name":"ContentLab.io","url":"https:\/\/contentlab.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/contentlab.com\/#\/schema\/logo\/image\/","url":"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png","contentUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png","width":768,"height":768,"caption":"ContentLab.io"},"image":{"@id":"https:\/\/contentlab.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/ContentLabIO","https:\/\/www.linkedin.com\/company\/17893315\/"]},{"@type":"Person","@id":"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532","name":"ContentLab","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/contentlab.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g","caption":"ContentLab"},"description":"ContentLab provides high-quality written articles, tutorials, courses, and other technical marketing materials to industry leaders. We create no-nonsense tech content that\u2019s purpose-built to attract, educate, and engage your technical audience.","sameAs":["https:\/\/contentlab.op"],"url":"https:\/\/contentlab.com\/author\/contentlab\/"}]}},"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/1.png","_links":{"self":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts\/3334"}],"collection":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/comments?post=3334"}],"version-history":[{"count":6,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts\/3334\/revisions"}],"predecessor-version":[{"id":5459,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts\/3334\/revisions\/5459"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/media\/4892"}],"wp:attachment":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/media?parent=3334"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/categories?post=3334"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/tags?post=3334"},{"taxonomy":"hashtags","embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/hashtags?post=3334"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}