Limites de Recursos no Kubernetes

Se o nó tiver recursos suficientes disponíveis, é possível que um contêiner use mais recursos. Podemos especificar quanto de cada recurso um Container precisa. Os recursos comuns a serem especificados são CPU e memória. Quando especificamos a solicitação de recursos para Contêineres em um Pod, o agendador decide em qual nó colocar o Pod. Quando especificamos um limite de recurso para um Contêiner, o kubelet cuida dos limites para que o contêiner em execução não possa usar mais do que o limite que definimos.

Por exemplo, se definirmos uma solicitação de memória de 100 MiB para um contêiner, então o contêiner pode tentar usar mais RAM. Mas se definirmos um limite de memória de 4GiB para esse Contêiner, o tempo de execução impede que o contêiner use mais do que o limite de recurso configurado.

CPU e memória são referidos como recursos de computação.

Cada Contêiner de um Pod pode especificar um ou mais dos seguintes:

• limites de cpu
• limites de memória
• limites de hugepages-
• solicitações de cpu
• solicitações de memória
• solicitações de hugepages-

Para saber mais sobre recursos no Kubernetes, clique aqui para visitar a documentação oficial do Kubernetes.

Neste artigo, veremos um exemplo de um limite de recurso e solicitação para CPU e Memória. Também usaremos o Metric Server. O Metrics Server é um agregador de dados de uso de recursos no cluster e não é implantado por padrão no cluster. Usaremos este Metric Server para ver o consumo de recursos pelos pods.

Pré-requisitos

1. Cluster Kubernetes com pelo menos 1 nó trabalhador.
   Se você quiser aprender a criar um Cluster Kubernetes, clique aqui. Este guia o ajudará a criar um cluster Kubernetes com 1 Master e 2 Nós em Instâncias EC2 Ubuntu 18.04 na AWS.

O que faremos?

1. Limites de recursos

Limites de Recursos

Antes de prosseguirmos e criarmos pods com requisitos de recursos especificados, vamos instalar o Metric Server.

Clone o repositório do Metric Server no Github usando o seguinte comando e instale-o.

git clone https://github.com/kodekloudhub/kubernetes-metrics-server.git

cd kubernetes-metrics-server/

Crie o Metric Server usando os arquivos de objeto.

kubectl create -f .

Aguarde um tempo para que o Metric Server seja iniciado. Após algum tempo, você pode executar o seguinte comando para monitorar os nós do cluster.

kubectl top node

Agora, crie um arquivo de definição de pod com o seguinte conteúdo que contém solicitação e limite de memória.

vim my-pod-with-memory.yml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-memory-demo
spec:
  containers:
  - name: my-container-memory-demo
    image: polinux/stress
    resources:
      limits:
        memory: "50Mi"
      requests:
        memory: "20Mi"
    command: ["stress"]
    args: ["--vm", "1", "--vm-bytes", "30M", "--vm-hang", "1"]

Você pode encontrar a propriedade “resources” na qual especificamos o limite de memória como 50Mi e a solicitação de memória como 20Mi.

Verifique os pods existentes com o namespace padrão no cluster.

kubectl get pods #Obter pods do namespace padrão

Crie um pod usando a definição de pod criada na etapa acima.

kubectl create -f my-pod-with-memory.yml #Criar um pod

kubectl get pods

Agora, se você obtiver os detalhes do Pod, poderá ver que o Pod está solicitando 20Mi de memória e tem um limite de 50Mi de memória.

kubectl get pods

kubectl describe pod my-pod-memory-demo #Descrever o pod

O uso do Pod pode ser verificado usando o seguinte comando.

kubectl  top pods #Verificar consumo de recursos pelo pod

Agora, crie uma definição de pod com solicitação e limite de CPU.

vim my-pod-with-cpu.yml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-cpu-demo
spec:
  containers:
  - name: my-container-cpu-demo    image: vish/stress
    resources:
      limits:        cpu: "1"
      requests:
        cpu: "0.5"
    args:
    - -cpus
    - "2"

No arquivo acima, você pode ver que a definição tem uma propriedade “resource” com solicitação de CPU como 0.5 e limite como 1. Também note que estamos passando 2 CPUs como nosso requisito, que é mais do que o limite.

Agora, vamos criar um pod com solicitação e limite de CPU usando o seguinte comando.

kubectl apply -f my-pod-with-cpu.yml #Criar um pod

kubectl get pods

Obtenha os detalhes do pod que criamos.

kubectl get pods

kubectl describe pod my-pod-cpu-demo

Você pode ver que o Pod solicitou 0.5 ou 500m de CPU com um limite de 1 CPU.

Para verificar o uso da CPU, use o seguinte comando.

kubectl top pod #Verificar consumo de recursos pelo pod

Na captura de tela acima, você pode ver que mesmo após passar 2 CPUs na definição do pod como um argumento, ele não pode consumir mais do que o limite, ou seja, 1 CPU. Aqui, o pod “my-pod-cpu-demo” poderia consumir 999m de CPU, que é equivalente a 1 CPU, e não poderia aumentar seu consumo.

Conclusão

Neste artigo, vimos os passos para habilitar o monitoramento no cluster usando o Metric Server. Vimos como um pod pode solicitar CPU e memória e consumir recursos não além do limite especificado.