{"id":97982,"date":"2020-10-23T14:42:15","date_gmt":"2020-10-23T12:42:15","guid":{"rendered":"https:\/\/prohoster.info\/blog\/administrirovanie\/devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes"},"modified":"2020-11-18T00:58:47","modified_gmt":"2020-11-17T22:58:47","slug":"devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes","status":"publish","type":"post","link":"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes","title":{"rendered":"Nine Tips for Improving Kubernetes Performance","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/92dc510aa9d785a31d310816b18bf854.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>Hello everyone! My name is Oleg Sidorenkov, and I work at DomClick as the head of the infrastructure team. We have been running 'Kubik' in production for over three years now, and during this time, we have experienced many interesting moments with it. Today, I will share how, with the right approach, you can extract even more performance from 'vanilla' Kubernetes for your cluster. Ready steady go! <\/p>\n<p>As you all know, Kubernetes is a scalable open-source system for container orchestration; or rather, 5 binaries that perform magic by managing the lifecycle of your microservices in a server environment. Additionally, it is a quite flexible tool that you can build like a Lego set for maximum customization to fit various tasks.<\/p>\n<p>And everything seems fine: just throw servers into the cluster like logs into a fire, and you won't have a care in the world. But if you are an eco-conscious person, you might think: 'How can I maintain the fire in the stove while preserving the forest?'. In other words, how to find ways to improve the infrastructure and reduce costs.<\/p>\n<h2>1. Monitor resource usage of teams and applications<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/91e2e60b47ee985b024532c8b685230c.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>One of the simplest yet most effective methods is to implement requests\/limits. Divide applications by namespaces, and namespaces by development teams. Set resource use values for CPU, memory, and ephemeral storage for the application before deployment.<\/p>\n<pre><code>resources:\n   requests:\n     memory: 2Gi\n     cpu: 250m\n   limits:\n     memory: 4Gi\n     cpu: 500m<\/code><\/pre>\n<p>Through experience, we concluded: do not inflate requests beyond limits by more than double. The cluster's capacity is calculated based on requests, and if you set applications with a resource difference of, say, 5-10 times, just imagine what will happen to your node as it fills up with pods and suddenly receives a load. Nothing good. At best, throttling; at worst, you will say goodbye to a worker and create cyclical loads on other nodes once the pods start migrating.<\/p>\n<p>In addition, using <code>limitranges<\/code> you can set resource values for a container at the start \u2014 minimum, maximum, and default:<\/p>\n<pre><code>\u279c  ~ kubectl describe limitranges --namespace ops\nName:       limit-range\nNamespace:  ops\nType        Resource           Min   Max   Default Request  Default Limit  Max Limit\/Request Ratio\n----        --------           ---   ---   ---------------  -------------  -----------------------\nContainer   cpu                50m   10    100m             100m           2\nContainer   ephemeral-storage  12Mi  8Gi   128Mi            4Gi            -\nContainer   memory             64Mi  40Gi  128Mi            128Mi          2<\/code><\/pre>\n<p>Don't forget to limit the resources of the namespace so that one team cannot take all the cluster resources:<\/p>\n<pre><code>\u279c  ~ kubectl describe resourcequotas --namespace ops\nName:                   resource-quota\nNamespace:              ops\nResource                Used          Hard\n--------                ----          ----\nlimits.cpu              77250m        80\nlimits.memory           124814367488  150Gi\npods                    31            45\nrequests.cpu            53850m        80\nrequests.memory         75613234944   150Gi\nservices                26            50\nservices.loadbalancers  0             0\nservices.nodeports      0             0<\/code><\/pre>\n<p>As seen from the description <code>resourcequotas<\/code>, if the ops team wants to deploy pods that will consume another 10 cpu, the scheduler will not allow this and will throw an error:<\/p>\n<pre><code>Error creating: pods \"nginx-proxy-9967d8d78-nh4fs\" is forbidden: exceeded quota: resource-quota, requested: limits.cpu=5,requests.cpu=5, used: limits.cpu=77250m,requests.cpu=53850m, limited: limits.cpu=10,requests.cpu=10<\/code><\/pre>\n<p>To solve such a task, you can write a tool, for example, like <noindex><a rel=\"nofollow\" href=\"https:\/\/github.com\/pauljamm\/team-operator\">this<\/a><\/noindex>, capable of storing and committing the state of team resources.<\/p>\n<h2>2. Choose optimal file storage<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/c7f8bdbf5490acc9061695a6d608015e.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>Here, I would like to touch on the topic of persistent volumes and the disk subsystem of Kubernetes worker nodes. I hope no one is using \"Cube\" on HDD in production, but sometimes even a regular SSD is not enough. We have faced the problem of logs overwhelming the disk with I\/O operations, and there are not many options for solving this: <\/p>\n<ul>\n<li>\n<p>Use high-performance SSDs or switch to NVMe (if you manage your own hardware).<\/p>\n<\/li>\n<li>\n<p>Reduce the level of logging.<\/p>\n<\/li>\n<li>\n<p>Implement \"smart\" balancing of pods that are stressing the disk (<code>podAntiAffinity<\/code>).<\/p>\n<\/li>\n<\/ul>\n<p>The screenshot above shows what happens under nginx-ingress-controller with the disk when access_logs logging is enabled (~12k logs\/sec). This state can certainly lead to degradation of all applications on that node.<\/p>\n<p>As for PV, unfortunately, I have not tested all <noindex><a rel=\"nofollow\" href=\"https:\/\/kubernetes.io\/docs\/concepts\/storage\/persistent-volumes\/#types-of-persistent-volumes\">types<\/a><\/noindex> Persistent Volumes. Use the best option that suits you. Historically, we have had a small number of services that require RWX volumes, and long ago we started using NFS storage for this purpose. It's cheap and... sufficient. Of course, we've had our share of issues with it \u2014 you can imagine, but we learned to tune it, and now we don't have headaches anymore. If possible, switch to S3 object storage.<\/p>\n<h2>3. Build Optimized Images<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/c25ce405d1eb4c01f031e18b0bfa4836.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>It's best to use container-optimized images so that Kubernetes can retrieve them faster and execute them more efficiently.&nbsp;<\/p>\n<p>Optimization means that images:<\/p>\n<ul>\n<li>\n<p>contain only one application or perform only one function;<\/p>\n<\/li>\n<li>\n<p>are small in size, because larger images transfer poorly over networks;<\/p>\n<\/li>\n<li>\n<p>include health and readiness checks, which allow Kubernetes to take action in case of downtime;<\/p>\n<\/li>\n<li>\n<p>use container-friendly operating systems (like Alpine or CoreOS) that are more resilient to configuration errors;<\/p>\n<\/li>\n<li>\n<p>employ multi-stage builds so that you can deploy only compiled applications, not their accompanying source code.<\/p>\n<\/li>\n<\/ul>\n<p>There are many tools and services available to check and optimize images on the fly. It is important to always keep them up to date and verified for security. Ultimately, you achieve: <\/p>\n<ol>\n<li>\n<p>Reduced network load on the entire cluster.<\/p>\n<\/li>\n<li>\n<p>Decreased container startup time.<\/p>\n<\/li>\n<li>\n<p>A smaller footprint for your entire Docker registry.<\/p>\n<\/li>\n<\/ol>\n<h2>4. Use DNS Cache<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/9f4384462a77dc528d7911c56f684f2d.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>When it comes to high loads, living without tuning the cluster's DNS system can be quite challenging. Long ago, Kubernetes developers supported their kube-dns solution. It was implemented in our environment, but this software wasn't particularly tuned and didn't deliver the required performance, even though the task seemed simple. Then coredns emerged, which we switched to, and we faced no issues afterward, as it became the default DNS service in K8s. At some point, we reached 40,000 rps to the DNS system, and that solution also became insufficient. Fortunately, Nodelocaldns was released, which is also referred to as node local cache, its also known as <noindex><a rel=\"nofollow\" href=\"https:\/\/kubernetes.io\/docs\/tasks\/administer-cluster\/nodelocaldns\/\">NodeLocal DNSCache<\/a><\/noindex>.<\/p>\n<p>Why do we use this? There is a bug in the Linux kernel that, upon multiple requests through conntrack NAT over UDP, leads to a race condition for writing to the conntrack tables, resulting in loss of some traffic through NAT (every access through Service is NAT). Nodelocaldns solves this problem by eliminating NAT and upgrading the connection to TCP to upstream DNS, as well as local caching of DNS queries to upstreams (including a short 5-second negative cache).<\/p>\n<h2>5. Automatically scale pods horizontally and vertically<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/3804a14685a55160fa7d9f3226eab1fa.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>Can you confidently say that all your microservices are ready for a two- to threefold increase in load? How do you properly allocate resources to your applications? Keeping a couple of pods running above the workload can turn out to be excessive, while keeping them too tight risks outages from a sudden surge in traffic to the service. The golden mean can be achieved with the magic of replication from services like <noindex><a rel=\"nofollow\" href=\"https:\/\/kubernetes.io\/docs\/tasks\/run-application\/horizontal-pod-autoscale\/\">Horizontal Pod Autoscaler<\/a><\/noindex> and <noindex><a rel=\"nofollow\" href=\"https:\/\/github.com\/kubernetes\/autoscaler\/tree\/master\/vertical-pod-autoscaler\">Vertical Pod Autoscaler<\/a><\/noindex>. <\/p>\n<p><strong>VPA<\/strong> automatically adjusts the requests\/limits of your containers in a pod based on actual usage. How can this be helpful? If you have pods that cannot be scaled horizontally for some reason (which is not very reliable), you can try entrusting VPA to adjust its resources. Its feature is a recommendation system based on historical and current data from the metric server, so if you do not want to automatically change requests\/limits, you can simply monitor recommended resources for your containers and optimize settings to save CPU and memory in the cluster. <\/p>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/3965950aa3315faa4bb3e3ff5bd61955.png\" style=\"display:block;margin: 0 auto;\" \/>Image sourced from https:\/\/levelup.gitconnected.com\/kubernetes-autoscaling-101-cluster-autoscaler-horizontal-pod-autoscaler-and-vertical-pod-2a441d9ad231<\/p>\n<p>The scheduler in Kubernetes always relies on requests. Whatever value you set there, the scheduler will look for a suitable node based on it. The limits values are needed by the kubelet to understand when to throttle or kill a pod. And since the only important parameter is the requests value, VPA will work with that. Every time you set vertical scaling for an application, you define what the requests should be. But what about limits? This parameter will also be scaled proportionally.<\/p>\n<p>For example, here are typical pod settings:<\/p>\n<pre><code>resources:\n   requests:\n     memory: 250Mi\n     cpu: 200m\n   limits:\n     memory: 500Mi\n     cpu: 350m<\/code><\/pre>\n<p>The recommendation mechanism determines that your application requires 300m CPU and 500Mi for normal operation. You will receive the following settings:<\/p>\n<pre><code>resources:\n   requests:\n     memory: 500Mi\n     cpu: 300m\n   limits:\n     memory: 1000Mi\n     cpu: 525m<\/code><\/pre>\n<p>As mentioned above, this is proportional scaling based on the ratio of requests\/limits in the manifest:<\/p>\n<ul>\n<li>\n<p>CPU: 200m \u2192 300m: ratio 1:1.75;<\/p>\n<\/li>\n<li>\n<p>Memory: 250Mi \u2192 500Mi: ratio 1:2.<\/p>\n<\/li>\n<\/ul>\n<p>As for <strong>HPA<\/strong>, the mechanism here is more transparent. Threshold values for metrics, such as CPU and memory, are set, and if the average across all replicas exceeds the threshold, the application scales up by +1 pod until the value falls below the threshold or the maximum number of replicas is reached.<\/p>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/f7a3fa28177d66be925867e38f5bbed6.png\" style=\"display:block;margin: 0 auto;\" \/>Image sourced from https:\/\/levelup.gitconnected.com\/kubernetes-autoscaling-101-cluster-autoscaler-horizontal-pod-autoscaler-and-vertical-pod-2a441d9ad231<\/p>\n<p>In addition to standard metrics like CPU and memory, you can set thresholds on your custom metrics from Prometheus and work with them if you believe this is the most accurate way to determine when to scale your application. Once the application stabilizes below the specified metric threshold, HPA will begin to scale down the pods to the minimum number of replicas or until the load meets the specified threshold.<\/p>\n<h2>6. Do not forget about Node Affinity and Pod Affinity<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/e718191d9e8ff25fd3b2d65cba9b3b73.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>Not all nodes run on the same hardware, and not all pods need to run applications that require intensive computing. Kubernetes allows you to specify the specialization of nodes and pods using <strong>Node Affinity<\/strong> and <strong>Pod Affinity<\/strong>.<\/p>\n<p>If you have nodes suited for compute-intensive operations, it is better for maximum efficiency to bind applications to the corresponding nodes. To do this, use <code>nodeSelector<\/code> with a node label.<\/p>\n<p>Suppose you have two nodes: one with <code>CPUType=HIGHFREQ<\/code> and many fast cores, and the other with <code>MemoryType=HIGHMEMORY<\/code> a large amount of memory and higher performance. The simplest way is to assign a pod deployment to the node <code>HIGHFREQ<\/code>, by adding the following selector in the <code>spec<\/code> section:<\/p>\n<pre><code>\u2026\nnodeSelector:\n\tCPUType: HIGHFREQ<\/code><\/pre>\n<p>A more costly and specific way to do this is to use <code>nodeAffinity<\/code> in the field <code>affinity<\/code> section. <code>spec<\/code>There are two options:<\/p>\n<ul>\n<li>\n<p><code>requiredDuringSchedulingIgnoredDuringExecution<\/code>: hard constraint (the scheduler will deploy pods only on specific nodes (and nowhere else));<\/p>\n<\/li>\n<li>\n<p><code>preferredDuringSchedulingIgnoredDuringExecution<\/code>: soft scheduling (the scheduler will attempt to deploy on specific nodes, and if unsuccessful, will try to deploy on the next available node).<\/p>\n<\/li>\n<\/ul>\n<p>You can specify a certain syntax for node label selectors, such as <code>In<\/code>, <code>NotIn<\/code>, <code>Exists<\/code>, <code>DoesNotExist<\/code>, <code>Gt<\/code> or <code>Lt<\/code>. However, keep in mind that complex methods in long lists of labels will slow down decision-making in critical situations. In other words, don't complicate things.<\/p>\n<p>As mentioned above, Kubernetes allows you to define the affinity of current pods. That is, you can ensure that certain pods work alongside other pods in the same availability zone (relevant for clouds) or nodes.<\/p>\n<p>In <code>podAffinity<\/code> fields <code>affinity<\/code> section. <code>spec<\/code> the same fields are available as in the case of <code>nodeAffinity<\/code>: <code>requiredDuringSchedulingIgnoredDuringExecution<\/code><strong> <\/strong>and <code>preferredDuringSchedulingIgnoredDuringExecution<\/code>. The only difference is that <code>matchExpressions<\/code> will bind pods to the node where a pod with such a label is already running.<\/p>\n<p>Additionally, Kubernetes offers a field <code>podAntiAffinity<\/code>, which, on the contrary, does not bind the pod to a node with specific pods.<\/p>\n<p>Regarding expressions <code>nodeAffinity<\/code> the same advice applies: strive to maintain simplicity and logic in rules, and don't try to overload the pod specification with a complex set of rules. It\u2019s very easy to create a rule that does not meet the cluster conditions, adding unnecessary load on the scheduler and reducing overall performance.<\/p>\n<h2>7. Taints &amp; Tolerations<\/h2>\n<p>There is another way to manage the scheduler. If you have a large cluster with hundreds of nodes and thousands of microservices, it can be very difficult to prevent certain pods from being placed on specific nodes.<\/p>\n<p>This is aided by the taints mechanism \u2014 prohibitive rules. For example, in certain scenarios, you can prevent certain nodes from running pods. To apply a taint to a specific node, use the <code>taint<\/code> option in kubectl. Specify the key and value, and then taint as follows <code>NoSchedule<\/code> or <code>NoExecute<\/code>:<\/p>\n<pre><code>$ kubectl taint nodes node10 node-role.kubernetes.io\/ingress=true:NoSchedule<\/code><\/pre>\n<p>It is also worth noting that the taint mechanism supports three main effects: <code>NoSchedule<\/code>, <code>NoExecute<\/code> and <code>PreferNoSchedule<\/code><strong>. <\/strong><\/p>\n<ul>\n<li>\n<p><code>NoSchedule<\/code><strong> <\/strong>means that as long as there is no corresponding entry in the pod specification <code>tolerations<\/code>, it cannot be deployed on the node (in this example <code>node10<\/code>).<\/p>\n<\/li>\n<li>\n<p><code>PreferNoSchedule <\/code>\u2014 a simplified version <code>NoSchedule<\/code>. In this case, the scheduler will try not to schedule pods that do not have a corresponding entry <code>tolerations<\/code> on the node, but this is not a strict limitation. If there are no resources in the cluster, the pods will start deploying on this node.<\/p>\n<\/li>\n<li>\n<p><code>NoExecute<\/code><strong> <\/strong>\u2014 this effect triggers an immediate evacuation of pods that do not have a corresponding record <code>tolerations<\/code>.<\/p>\n<\/li>\n<\/ul>\n<p>Interestingly, this behavior can be overridden using the tolerations mechanism. This is useful when there is a 'prohibited' node and you need to place only infrastructure services on it. How to do this? Allow only those pods for which there is an appropriate toleration.<\/p>\n<p>Here\u2019s how the pod specification will look:<\/p>\n<pre><code>spec:\n   tolerations:\n     - key: \"node-role.kubernetes.io\/ingress\"\n        operator: \"Equal\"\n        value: \"true\"\n        effect: \"NoSchedule\"<\/code><\/pre>\n<p>This does not mean that during the next redeploy the pod will end up on this node, this is not a Node Affinity mechanism and <code>nodeSelector<\/code>. But by combining several features, you can achieve very flexible scheduling configuration.<\/p>\n<h2>8. Configure pod deployment priority<\/h2>\n<p>The fact that you configured pod binding to nodes does not mean that all pods should be processed with the same priority. For example, you may want to deploy certain pods before others.<\/p>\n<p>Kubernetes offers various ways to set pod prioritization (Pod Priority and Preemption). The configuration consists of several parts: the object <code>PriorityClass<\/code><strong> <\/strong>and the field description <code>priorityClassName<\/code><strong> <\/strong>in the pod specification. Let\u2019s look at an example:<\/p>\n<pre><code>apiVersion: scheduling.k8s.io\/v1\nkind: PriorityClass\nmetadata:\n  name: high-priority\nvalue: 99999\nglobalDefault: false\ndescription: \"This priority class should be used for very important pods only\"<\/code><\/pre>\n<p>We create <code>PriorityClass<\/code>, assign it a name, description, and value.<strong> <\/strong>The higher <code>value<\/code>, the higher the priority. The value can be any 32-bit integer less than or equal to 1,000,000,000. Higher values are reserved for critical system pods that typically cannot be preempted.<strong> <\/strong>Preemption will occur only if there is no place for the high-priority pod to deploy; then some pods from a specific node will be evacuated. If this mechanism is too rigid for you, you can add the option <code>preemptionPolicy: Never<\/code>, and then there will be no preemption; the pod will stand first in line and wait for the scheduler to find free resources for it.<\/p>\n<p>Next, we create a pod where we specify the name <code>priorityClassName<\/code>:<\/p>\n<pre><code>apiVersion: v1\nkind: Pod\nmetadata:\n  name: static-web\n  labels:\n    role: myrole\n spec:\n  containers:\n    - name: web\n      image: nginx\n      ports:\n        - name: web\n          containerPort: 80\n          protocol: TCP\n  priorityClassName: high-priority\n          <\/code><\/pre>\n<p>You can create as many priority classes as you want, although it is recommended not to get carried away (for instance, stick to low, medium, and high priority). <\/p>\n<p>This way, if necessary, you will be able to enhance the efficiency of deploying critical services like nginx-ingress-controller, coredns, etc.<\/p>\n<h2>9. Optimize the ETCD cluster<\/h2>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/f5917adfa943c789b6c784f43305851b.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>ETCD can be considered the brain of the entire cluster. It's crucial to maintain this database at a high level of performance, as the speed of operations in the \"Kube\" depends on it. A standard and fairly effective solution would be to keep the ETCD cluster on master nodes to ensure minimal latency to the kube-apiserver. If that is not feasible, place ETCD as close as possible, ensuring good bandwidth between nodes. Pay attention to how many ETCD nodes can fail without harming the cluster.<\/p>\n<p><img decoding=\"async\" alt=\"Nine Tips for Improving Kubernetes Performance\" src=\"\/wp-content\/uploads\/2020\/10\/cdd2c32eefed253c6ff774899c367ccc.png\" style=\"display:block;margin: 0 auto;\" \/><\/p>\n<p>Keep in mind that overly increasing the number of participants in the cluster may enhance fault tolerance at the expense of performance; everything should be done in moderation.<\/p>\n<p>When it comes to service configuration, there are few recommendations:<\/p>\n<ol>\n<li>\n<p>Have good hardware, based on the size of the cluster (you can read more about it) <noindex><a rel=\"nofollow\" href=\"https:\/\/github.com\/etcd-io\/etcd\/blob\/master\/Documentation\/op-guide\/hardware.md\">here<\/a><\/noindex>).<\/p>\n<\/li>\n<li>\n<p>Tweak a few parameters if you have spread the cluster across a couple of data centers or if your network and disks leave much to be desired (you can read more about it) <noindex><a rel=\"nofollow\" href=\"https:\/\/github.com\/etcd-io\/etcd\/blob\/master\/Documentation\/tuning.md\">here<\/a><\/noindex>).<\/p>\n<\/li>\n<\/ol>\n<h2>Conclusion<\/h2>\n<p>This article describes the points that our team strives to adhere to. It is not a step-by-step description of actions, but rather options that may come in handy for optimizing overhead costs in the cluster. Clearly, every cluster is unique in its own way, and configuration solutions can vary significantly, so it would be interesting to get your feedback: how do you monitor your Kubernetes cluster and what do you use to enhance its performance? Share your experience in the comments; we would love to learn from you. <\/p>\n<p>Source: <a content=\"nofollow\" rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/domclick\/blog\/520968\/\">habr.com<\/a> <\/p>","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"excerpt":{"rendered":"<p>\u0412\u0441\u0435\u043c \u043f\u0440\u0438\u0432\u0435\u0442! \u041c\u0435\u043d\u044f \u0437\u043e\u0432\u0443\u0442 \u041e\u043b\u0435\u0433 \u0421\u0438\u0434\u043e\u0440\u0435\u043d\u043a\u043e\u0432, \u044f \u0440\u0430\u0431\u043e\u0442\u0430\u044e \u0432 \u043a\u043e\u043c\u043f\u0430\u043d\u0438\u0438 \u0414\u043e\u043c\u041a\u043b\u0438\u043a \u0440\u0443\u043a\u043e\u0432\u043e\u0434\u0438\u0442\u0435\u043b\u0435\u043c \u043a\u043e\u043c\u0430\u043d\u0434\u044b \u0438\u043d\u0444\u0440\u0430\u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u044b. \u041c\u044b \u044d\u043a\u0441\u043f\u043b\u0443\u0430\u0442\u0438\u0440\u0443\u0435\u043c \u00ab\u041a\u0443\u0431\u0438\u043a\u00bb \u0432 \u043f\u0440\u043e\u0434\u0435 \u0443\u0436\u0435 \u0431\u043e\u043b\u044c\u0448\u0435 \u0442\u0440\u0451\u0445 \u043b\u0435\u0442, \u0438 \u0437\u0430 \u044d\u0442\u043e \u0432\u0440\u0435\u043c\u044f \u043f\u0435\u0440\u0435\u0436\u0438\u043b\u0438 \u0441 \u043d\u0438\u043c \u043c\u043d\u043e\u0433\u043e \u0440\u0430\u0437\u043d\u044b\u0445 \u0438\u043d\u0442\u0435\u0440\u0435\u0441\u043d\u044b\u0445 \u043c\u043e\u043c\u0435\u043d\u0442\u043e\u0432. \u0421\u0435\u0433\u043e\u0434\u043d\u044f \u044f \u043f\u043e\u0432\u0435\u0434\u0430\u044e \u0432\u0430\u043c, \u043a\u0430\u043a \u043f\u0440\u0438 \u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u043e\u043c \u043f\u043e\u0434\u0445\u043e\u0434\u0435 \u043c\u043e\u0436\u043d\u043e \u0432\u044b\u0436\u0430\u0442\u044c \u0438\u0437 \u00ab\u0432\u0430\u043d\u0438\u043b\u044c\u043d\u043e\u0433\u043e\u00bb Kubernetes \u0435\u0449\u0451 \u0431\u043e\u043b\u044c\u0448\u0435 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 \u0434\u043b\u044f \u0432\u0430\u0448\u0435\u0433\u043e \u043a\u043b\u0430\u0441\u0442\u0435\u0440\u0430. Ready steady [&hellip;]<\/p>\n","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"author":1,"featured_media":97983,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[688],"tags":[],"class_list":["post-97982","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administrirovanie"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 5.0.1.1 - aioseo.com -->\n\t<meta name=\"description\" content=\"\u0412\u0441\u0435\u043c \u043f\u0440\u0438\u0432\u0435\u0442!\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<meta name=\"author\" content=\"Yuri Gagarin\"\/>\n\t<link rel=\"canonical\" href=\"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 5.0.1.1\" \/>\n\t\t<meta property=\"og:locale\" content=\"en_US\" \/>\n\t\t<meta property=\"og:site_name\" content=\"ProHoster | \u041a\u0443\u043f\u0438\u0442\u044c \u043d\u0430\u0434\u0435\u0436\u043d\u044b\u0439 \u0445\u043e\u0441\u0442\u0438\u043d\u0433 \u0434\u043b\u044f \u0441\u0430\u0439\u0442\u043e\u0432 \u0441 \u0437\u0430\u0449\u0438\u0442\u043e\u0439 \u043e\u0442 DDoS, VPS VDS \u0441\u0435\u0440\u0432\u0435\u0440\u044b\" \/>\n\t\t<meta property=\"og:type\" content=\"article\" \/>\n\t\t<meta property=\"og:title\" content=\"\ud83e\udd47\u0414\u0435\u0432\u044f\u0442\u044c \u0441\u043e\u0432\u0435\u0442\u043e\u0432 \u043f\u043e \u043f\u043e\u0432\u044b\u0448\u0435\u043d\u0438\u044e \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 Kubernetes | ProHoster\" \/>\n\t\t<meta property=\"og:description\" content=\"\u0412\u0441\u0435\u043c \u043f\u0440\u0438\u0432\u0435\u0442!\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes\" \/>\n\t\t<meta property=\"og:image\" content=\"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg\" \/>\n\t\t<meta property=\"og:image:secure_url\" content=\"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg\" \/>\n\t\t<meta property=\"og:image:width\" content=\"350\" \/>\n\t\t<meta property=\"og:image:height\" content=\"350\" \/>\n\t\t<meta property=\"article:published_time\" content=\"2020-10-23T12:42:15+00:00\" \/>\n\t\t<meta property=\"article:modified_time\" content=\"2020-11-17T22:58:47+00:00\" \/>\n\t\t<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/prohoster\" \/>\n\t\t<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/prohoster\" \/>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"\ud83e\udd47Nine tips for enhancing Kubernetes performance | ProHoster","description":"Hello everyone!","canonical_url":"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","og:site_name":"ProHoster | \u041a\u0443\u043f\u0438\u0442\u044c \u043d\u0430\u0434\u0435\u0436\u043d\u044b\u0439 \u0445\u043e\u0441\u0442\u0438\u043d\u0433 \u0434\u043b\u044f \u0441\u0430\u0439\u0442\u043e\u0432 \u0441 \u0437\u0430\u0449\u0438\u0442\u043e\u0439 \u043e\u0442 DDoS, VPS VDS \u0441\u0435\u0440\u0432\u0435\u0440\u044b","og:type":"article","og:title":"\ud83e\udd47\u0414\u0435\u0432\u044f\u0442\u044c \u0441\u043e\u0432\u0435\u0442\u043e\u0432 \u043f\u043e \u043f\u043e\u0432\u044b\u0448\u0435\u043d\u0438\u044e \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u0438\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 Kubernetes | ProHoster","og:description":"\u0412\u0441\u0435\u043c \u043f\u0440\u0438\u0432\u0435\u0442!","og:url":"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/devyat-sovetov-po-povysheniyu-proizvoditelnosti-kubernetes","og:image":"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg","og:image:secure_url":"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg","og:image:width":350,"og:image:height":350,"article:published_time":"2020-10-23T12:42:15+00:00","article:modified_time":"2020-11-17T22:58:47+00:00","article:publisher":"https:\/\/www.facebook.com\/prohoster","article:author":"https:\/\/www.facebook.com\/prohoster"},"aioseo_meta_data":{"post_id":"97982","title":null,"description":null,"keywords":null,"keyphrases":null,"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":null,"og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"","isEnabled":true},"graphs":[]},"schema_type":null,"schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":null,"robots_max_videopreview":null,"robots_max_imagepreview":"large","priority":null,"frequency":null,"local_seo":null,"seo_analyzer_scan_date":null,"breadcrumb_settings":null,"limit_modified_date":false,"reviewed_by":null,"ai":null,"created":"2021-02-28 10:08:27","updated":"2022-09-30 17:30:03","focus_keyword":null,"additional_keywords":null,"truseo_locale":null},"gt_translate_keys":[{"key":"link","format":"url"}],"_links":{"self":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/posts\/97982","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/comments?post=97982"}],"version-history":[{"count":0,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/posts\/97982\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/media\/97983"}],"wp:attachment":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/media?parent=97982"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/categories?post=97982"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/tags?post=97982"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}