Work with capacity scheduling - Container Compute Service: Central de Documentação do Alibaba Cloud

O Container Compute Service (ACS) oferece suporte ao mecanismo ResourceQuota do Kubernetes open source. Um ResourceQuota estabelece limites rígidos para o total de recursos que um namespace pode consumir, incluindo CPU, memória, recursos estendidos, entre outros. Quando um namespace possui um ResourceQuota, o Kubernetes monitora o uso e rejeita qualquer solicitação que ultrapasse o limite definido.

Como funciona

Os ResourceQuotas funcionam da seguinte maneira:

Cada equipe ou aplicação executa em um namespace separado.
Um administrador de cluster cria um ou mais ResourceQuotas para cada namespace.
Ao criar recursos (pods, Services, etc.), o sistema de cotas rastreia a utilização e garante que ela permaneça dentro dos limites rígidos definidos no ResourceQuota.
Se a criação ou atualização de um recurso exceder a cota, o Kubernetes rejeita a solicitação com o código de status HTTP 403 Forbidden. A mensagem de erro identifica o nome da cota, a quantidade solicitada, o uso atual e o limite rígido.

Requisitos

Caso um ResourceQuota defina limites de CPU ou memória para um namespace, todo pod criado nesse namespace deve especificar solicitações e limites de recursos. Pods sem essas configurações são rejeitados. Para evitar isso, utilize o controlador de admissão LimitRanger para definir limites padrão de recursos automaticamente.
Após modificar um ResourceQuota, a alteração se aplica apenas a novas solicitações de criação de recursos. Os recursos existentes não são afetados.
O nome de um ResourceQuota deve ser um subdomínio DNS válido.

Ativar o recurso ResourceQuota

Por padrão, o recurso ResourceQuota está ativado para clusters do Container Service for Kubernetes (ACK) criados no console do ACS. Basta criar um ResourceQuota no namespace para habilitar esse recurso no respectivo namespace.

Tipos de recursos suportados

O ACS é totalmente compatível com o mecanismo ResourceQuota do Kubernetes. Tanto recursos padrão quanto recursos estendidos são suportados.

Recursos padrão

Recurso	Restrição
`limits.cpu`	A soma dos limites de CPU em todos os pods em estado não finalizado não pode exceder este valor.
`limits.memory`	A soma dos limites de memória em todos os pods em estado não finalizado não pode exceder este valor.
`requests.cpu`	A soma das solicitações de CPU em todos os pods em estado não finalizado não pode exceder este valor.
`requests.memory`	A soma das solicitações de memória em todos os pods em estado não finalizado não pode exceder este valor.
`hugepages-<size>`	A soma das solicitações de HugePage do tamanho especificado em todos os pods em estado não finalizado não pode exceder este valor.
`cpu`	Equivalente a `requests.cpu`.
`memory`	Equivalente a `requests.memory`.

Recursos estendidos

O Kubernetes não suporta overcommit de recursos estendidos (limite > solicitação). Para recursos estendidos, configure apenas cotas que começam com requests.. Para mais detalhes, consulte Cotas de recursos.

Pré-requisitos

Antes de começar, certifique-se de ter:

Um cluster ACS
kubectl configurado para se conectar ao seu cluster
Permissões de administrador de cluster para criar ResourceQuotas

Criar e verificar um ResourceQuota

Este exemplo demonstra a criação de um ResourceQuota que limita o uso de CPU em um namespace e mostra o que acontece quando os pods atingem esse limite.

Etapa 1: Criar um namespace

kubectl create namespace test

Etapa 2: Criar um ResourceQuota

Crie um ResourceQuota chamado test-quota no namespace test com um limite rígido de CPU de 4000 milicores (4 núcleos) tanto para solicitações quanto para limites:

cat << EOF | kubectl apply -f -
apiVersion: v1
kind: ResourceQuota
metadata:
  name: test-quota
  namespace: test
spec:
  hard:
    requests.cpu: "4000m"
    limits.cpu: "4000m"
EOF

Essa cota impõe as seguintes restrições ao namespace test:

A soma das solicitações de CPU em todos os pods não deve exceder 4000m.
A soma dos limites de CPU em todos os pods não deve exceder 4000m.

Etapa 3: Verificar o ResourceQuota

kubectl -n test describe resourcequota test-quota

Saída esperada:

Namespace:    test
Resource      Used  Hard
--------      ----  ----
limits.cpu    0     4
requests.cpu  0     4

A coluna Used exibe 0, confirmando que nenhum pod consumiu a cota até o momento.

Etapa 4: Implantar pods que consomem a cota

Crie um Deployment com 5 réplicas, cada uma solicitando 1 núcleo de CPU (1000m). Como a cota é de 4000m, apenas 4 pods podem ser agendados:

cat << EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: test-app
  name: test-app
  namespace: test
spec:
  replicas: 5
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs/busybox:v1.29.2
        imagePullPolicy: IfNotPresent
        name: test
        command:
        - sleep
        - "360000000"
        resources:
          limits:
            cpu: "1"
EOF

Etapa 5: Verificar o status dos pods

kubectl -n test get pod

Saída esperada:

NAME                        READY   STATUS    RESTARTS   AGE
test-app-5ddxxxxx94-jdv4m   1/1     Running   0          35s
test-app-5ddxxxxx94-jhmtb   1/1     Running   0          35s
test-app-5ddxxxxx94-mr8vq   1/1     Running   0          35s
test-app-5ddxxxxx94-pjdfn   1/1     Running   0          35s

Quatro pods estão em execução. O quinto pod não consegue iniciar porque o namespace não tem cota de CPU restante.

Etapa 6: Verificar o uso da cota

kubectl -n test describe resourcequota

Saída esperada:

Name:         test-quota
Namespace:    test
Resource      Used  Hard
--------      ----  ----
limits.cpu    4     4
requests.cpu  4     4

As colunas Used e Hard coincidem, indicando que a cota foi totalmente consumida.

Etapa 7: Confirmar que a cota bloqueia novos pods

Escale o Deployment para 5 réplicas e observe a aplicação da cota:

Escale o Deployment:

kubectl -n test scale deploy test-app --replicas 5

Verifique o ReplicaSet. A coluna DESIRED mostra 5, mas CURRENT exibe 4, o que significa que um pod falhou ao ser criado:
```
kubectl -n test get rs
```
Saída esperada:
```
NAME                  DESIRED   CURRENT   READY   AGE
test-app-5ddxxxxx94   5         4         4       3m10s
```

Inspecione os eventos do ReplicaSet para visualizar o erro de cota:

kubectl -n test describe rs test-app-5ddxxxxx94

A seção Events mostra um aviso FailedCreate semelhante a:

Warning  FailedCreate  replicaset-controller  Error creating: pods "test-app-5ddc68c994-5s4ph" is forbidden: exceeded quota: test-quota, requested: limits.cpu=1,requests.cpu=1, used: limits.cpu=4,requests.cpu=4, limited: limits.cpu=4,requests.cpu=4

O erro identifica o nome da cota (test-quota), a quantidade solicitada, o uso atual e o limite rígido, facilitando o diagnóstico e a resolução.

Próximos passos

Cotas de recursos — Referência oficial do Kubernetes
LimitRange — Define automaticamente solicitações e limites padrão de recursos para pods