Pesquisa de site

Como usar cotas de recursos do Kubernetes


As cotas de recursos evitam a contenção de recursos e a "apropriação de terras", controlando a quantidade de CPU ou memória que um aplicativo pode consumir.

“Controle” é a palavra que vem à mente quando alguém menciona que precisa gerenciar os recursos de computação do Kubernetes, especialmente CPU e memória. Essas conversas geralmente acontecem depois que a plataforma Kubernetes foi implantada por um tempo e os desenvolvedores estão usando o cluster extensivamente. E na maioria das vezes, o assunto surge depois que um problema acontece.

Problemas de recursos são comuns quando a implementação do Kubernetes é implantada sem considerar o crescimento futuro do cluster. Os problemas também podem estar relacionados ao nível de experiência da equipe que implanta e gerencia o cluster Kubernetes.

Sem controles, um aplicativo ou desenvolvedor não autorizado pode atrapalhar os negócios. Isso acontece inadvertidamente quando vários desenvolvedores compartilham um cluster com um número fixo de nós. Estas restrições de recursos podem dar origem a desentendimentos, acusações e "apropriação de terras" de recursos disponíveis entre os promotores. É uma situação muito ruim para administradores de cluster e desenvolvedores.

Existem várias maneiras de gerenciar como os aplicativos utilizam recursos de computação no ambiente Kubernetes. Na maioria das vezes, as cotas de recursos e os intervalos de limites são suficientes. Observe que no Kubernetes, o gerenciamento de armazenamento adota uma abordagem incomum usando um plug-in de volume persistente onde são definidas propriedades para atender e controlar diferentes requisitos de armazenamento.

As cotas de recursos do Kubernetes são uma forma de controlar como os recursos de computação são usados. Este artigo mostrará como usar esse recurso para gerenciar o comportamento dos desenvolvedores e controlar o consumo de recursos do aplicativo.

O que são cotas de recursos?

Resumindo, as cotas de recursos fornecem restrições que limitam o consumo de recursos por namespace. Eles podem ser aplicados apenas no nível do namespace, o que significa que podem ser aplicados a recursos de computação e limitar o número de objetos dentro do namespace.

Uma cota de recursos do Kubernetes é definida por um objeto ResourceQuota. Quando aplicado a um namespace, pode limitar recursos de computação, como CPU e memória, bem como a criação dos seguintes objetos:

  • Vagens
  • Serviços
  • Segredos
  • Reivindicações de Volume Persistente (PVCs)
  • ConfigMaps

O Kubernetes oferece suporte a dois tipos de cotas de CPU e memória para gerenciar recursos de computação. Eles são controlados por meio de limites e solicitações, conforme explica a documentação do LimitRange.

Resumindo, uma solicitação define os recursos garantidos de CPU ou memória para contêineres, enquanto um limite é a memória ou limite de CPU que um contêiner pode usar, dependendo do que está disponível com base no uso de outros contêineres.

Esta imagem ilustra a diferença entre solicitações e limites nas cotas de recursos do Kubernetes.

(Michael Calizo, CC BY-SA 4.0)

O exercício a seguir demonstra como usar cotas de recursos para criar restrições que limitam um aplicativo a determinados recursos com base em um limite definido. Também mostra a utilidade da implementação de cotas de recursos para obter controle sobre a implementação do Kubernetes.

Pré-requisitos

Antes de começar, certifique-se de ter o Kubernetes implantado em sua máquina local. Aqui está minha configuração:

  • Minikube v1.14.2
  • Sistema operacional Fedora 33
  • Acesso à internet

Se precisar de ajuda para implantar o Minikube em seu laptop Linux, você pode seguir as etapas em Introdução ao Minikube de Bryant Son. Ou, se estiver no Windows ou macOS, você pode seguir estas etapas.

Configurar uma cota de recursos

Este exemplo cria uma cota de CPU, mas o processo é semelhante para uma cota de memória ou uma combinação das duas.

Em um cenário de produção real, os recursos da CPU geralmente estão no topo dos recursos computacionais que você precisa gerenciar para evitar a contenção de recursos. Isso acontece sempre que você tem vários aplicativos em execução no servidor (computação).

Comece criando um novo namespace onde você aplicará sua cota de CPU:

$ kubectl create namespace quota-test
namespace/quota-test created

Crie um arquivo chamado cpu-quota.yaml e coloque nele a seguinte cota (criada para esta demonstração):

apiVersion: v1
kind: ResourceQuota
metadata:
  name: test-cpu-quota
spec:
  hard:
    requests.cpu: "100m"  
    limits.cpu: "200m"

Aplique a cota ao seu cluster Kubernetes com:

$ kubectl apply -f cpu-qouta.yaml 
resourcequota/test-cpu-quota created

Verifique se a cota foi aplicada com o comando kubectl description:

$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name:         test-cpu-quota
Namespace:    quota-test
Resource      Used  Hard
--------      ----  ----
limits.cpu    0     200m
requests.cpu  0     100m

Observe a coluna Recursos usados; esse valor mudará conforme você implanta os pods.

Agora que você definiu sua cota, teste-a. Neste exemplo, implante três pods diferentes no mesmo namespace para ver se é possível controlar o uso dos recursos com base nos limites definidos. Os três pods são:

  • PodA: Este pod, o primeiro a ser instanciado, usará 50% da CPU disponível.
  • PodB: Este pod usará os outros 50% da CPU disponível; será o segundo pod instanciado.
  • PodC: a cota definida deve impedir a implantação deste terceiro pod.

Agora que você conhece o cenário, implante os pods.

Implantar os pods

PodA:

$ kubectl create -n quota-test -f- <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: poda
spec:
  containers:
  - name: quota-test
    image: busybox
    imagePullPolicy: IfNotPresent
    command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
    resources:
      requests:
        cpu: "50m"
      limits:
        cpu: "100m"
  restartPolicy: Never
EOF

Verifique o uso da CPU descrevendo a cota novamente e observando os limites e solicitações de valores de CPU usada:

$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name:         test-cpu-quota
Namespace:    quota-test
Resource      Used  Hard
--------      ----  ----
limits.cpu    100m  200m
requests.cpu  50m   100m

PodB:

$ kubectl create -n quota-test -f- <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: podb
spec:
  containers:
  - name: quota-test
    image: busybox
    imagePullPolicy: IfNotPresent
    command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
    resources:
      requests:
        cpu: "50m"
      limits:
        cpu: "100m"
  restartPolicy: Never
EOF

Verifique novamente o uso de recursos da CPU. Como esperado, o PodB pode ser agendado porque a cota permite:

$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name:         test-cpu-quota
Namespace:    quota-test
Resource      Used  Hard
--------      ----  ----
limits.cpu    200m  200m
requests.cpu  100m  100m

PodC:

Agora, tente instanciar o terceiro pod, mesmo sabendo que o PodA e o Pod B maximizaram o limite de cota de CPU que você definiu:

$ kubectl create -n quota-test -f- <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: podc
spec:
  containers:
  - name: quota-test
    image: busybox
    imagePullPolicy: IfNotPresent
    command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
    resources:
      requests:
        cpu: "5m"
      limits:
        cpu: "10m"
  restartPolicy: Never
EOF

Como esperado, o terceiro pod não será instanciado porque a cota definida impede a criação dos pods:

Error from server (Forbidden): error when creating "STDIN": pods "podc" is forbidden: exceeded quota: test-cpu-quota, requested: limits.cpu=10m,requests.cpu=5m, used: limits.cpu=200m,requests.cpu=100m, limited: limits.cpu=200m,requests.cpu=100m

Como mostra este exemplo, cotas de recursos definidas corretamente são uma ferramenta poderosa que um administrador do Kubernetes pode utilizar para gerenciar o comportamento do desenvolvedor.

Limpar

Exclua o namespace que você criou (neste caso, quota-test):

$ kubectl delete -n quota-test

Planejando suas cotas

Há muitas maneiras de controlar como os usuários podem implantar aplicativos para evitar a "apropriação de terras" em um cluster Kubernetes. Ter uma implementação sólida de cotas, intervalos de limites e outros recursos nativos contribui para a estabilidade de um cluster.

A implementação de cotas de recursos em recursos de computação é uma decisão de design importante sobre a qual você precisa pensar cuidadosamente, especialmente ao implantar o Kubernetes para executar aplicativos corporativos essenciais aos negócios.

Ao definir cotas, é importante incluir os desenvolvedores no seu planejamento. Devido ao seu conhecimento de aplicação, eles são os melhores recursos para estimar o que é necessário.

Artigos relacionados: