Container Service for Kubernetes:Enable dynamic resource overcommitment

Fonctionnement

ack-koordinator suit en continu la charge par nœud et publie la capacité récupérable sous forme de ressources étendues sur chaque nœud. Les pods BestEffort déclarent des demandes et des limites explicites pour ces ressources Batch, ce qui permet à l'ordonnanceur ACK de prendre des décisions de placement éclairées et d'appliquer les limites de ressources via la hiérarchie cgroup du nœud.

Le schéma suivant illustre les limites de la surallocation standard des ressources :

Sans surallocation dynamique, l'ordonnanceur ne dispose d'aucune visibilité sur la charge réelle des nœuds et peut donc placer des pods BestEffort sur des nœuds déjà surchargés. Par ailleurs, il est impossible d'exprimer des quantités de ressources différentes par pod, ce qui empêche une distribution équitable des ressources entre les pods BestEffort.

ack-koordinator introduit trois termes pour décrire la capacité de ressources récupérées :

Facturation

L'installation et l'utilisation du composant ack-koordinator sont gratuites. Veuillez noter les points suivants :

• ack-koordinator est un composant non géré. Après l'installation, il consomme des ressources des nœuds de travail. Spécifiez les demandes de ressources par module lors de l'installation.

• ack-koordinator peut exposer des métriques Prometheus pour des fonctionnalités telles que le profilage des ressources et l'ordonnancement fin. Si vous activez les métriques Prometheus pour ack-koordinator et utilisez Managed Service for Prometheus, ces métriques sont comptabilisées comme des custom metrics et facturées en conséquence. Avant l'activation, consultez la rubrique Billing pour Managed Service for Prometheus et lisez la page Query the amount of observable data and bills pour comprendre le calcul des coûts.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Un cluster ACK Pro. Pour plus d'informations, consultez la rubrique Create an ACK Pro cluster.

• Le composant ack-koordinator installé en version 0.8.0 ou ultérieure. Pour plus d'informations, consultez la rubrique ack-koordinator.

Activer la surallocation dynamique des ressources

Activez et configurez la fonctionnalité en créant ou en mettant à jour une ConfigMap dans le namespace kube-system.

apiVersion: v1
kind: ConfigMap
metadata:
  name: ack-slo-config
  namespace: kube-system
data:
  # colocation-config controls dynamic Batch resource calculation and updates.
  # Related features: Dynamic resource overcommitment, load-aware scheduling.
  colocation-config: |
    {
      "enable": true,                        # Required: enables Batch resource updates. Setting to false resets reclaimed resources to 0.
      "metricAggregateDurationSeconds": 60,  # How often (seconds) node metrics are aggregated. Use the default value.
      "cpuReclaimThresholdPercent": 60,      # Reclaim threshold for batch-cpu, as a % of allocatable CPU. Default: 65.
      "memoryReclaimThresholdPercent": 70,   # Reclaim threshold for batch-memory, as a % of allocatable memory. Default: 65.
      "memoryCalculatePolicy": "usage"       # How batch-memory capacity is calculated: "usage" (default) or "request".
    }

nodeBatchAllocatable = nodeAllocatable × thresholdPercent − podUsage(non-BE) − systemUsage

nodeBatchAllocatable = nodeAllocatable × thresholdPercent − podRequest(non-BE) − systemUsage

Demander des ressources Batch

Après avoir activé la surallocation dynamique des ressources, configurez les pods pour qu'ils demandent des ressources Batch.

# Replace $nodeName with the actual node name.
kubectl get node $nodeName -o yaml

status:
  allocatable:
    # Unit: millicore. The following example shows 50 cores available.
    kubernetes.io/batch-cpu: 50000
    # Unit: bytes. The following example shows 50 GB available.
    kubernetes.io/batch-memory: 53687091200

metadata:
  labels:
    # Required: sets the pod's QoS class to BestEffort.
    koordinator.sh/qosClass: "BE"
spec:
  containers:
  - resources:
      requests:
        # Unit: millicore. "1k" = 1000 millicores = 1 core.
        kubernetes.io/batch-cpu: "1k"
        # Unit: bytes.
        kubernetes.io/batch-memory: "1Gi"
      limits:
        kubernetes.io/batch-cpu: "1k"
        kubernetes.io/batch-memory: "1Gi"

Exemple

Cet exemple déploie un pod de test BestEffort qui utilise des ressources Batch et vérifie que les limites de ressources sont appliquées dans le cgroup du nœud.

1. Vérifiez les ressources Batch disponibles sur le nœud :

   kubectl get node $nodeName -o yaml

   Sortie attendue :

   status:
     allocatable:
       kubernetes.io/batch-cpu: 50000
       kubernetes.io/batch-memory: 53687091200

2. Créez un fichier nommé be-pod-demo.yaml :

   apiVersion: v1
   kind: Pod
   metadata:
     labels:
       koordinator.sh/qosClass: "BE"
     name: be-demo
   spec:
     containers:
     - command:
       - "sleep"
       - "100h"
       image: registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4
       imagePullPolicy: Always
       name: be-demo
       resources:
         limits:
           kubernetes.io/batch-cpu: "50k"
           kubernetes.io/batch-memory: "10Gi"
         requests:
           kubernetes.io/batch-cpu: "50k"
           kubernetes.io/batch-memory: "10Gi"
     schedulerName: default-scheduler

3. Déployez le pod :

   kubectl apply -f be-pod-demo.yaml

4. Vérifiez que les limites de ressources sont reflétées dans le cgroup du nœud. Vérifiez la limite de processeur :

   cat /sys/fs/cgroup/cpu,cpuacct/kubepods.slice/kubepods-besteffort.slice/kubepods-besteffort-pod4b6e96c8_042d_471c_b6ef_b7e0686a****.slice/cri-containerd-11111c202adfefdd63d7d002ccde8907d08291e706671438c4ccedfecba5****.scope/cpu.cfs_quota_us

   Sortie attendue (50 cœurs) :

   5000000

   Vérifiez la limite de mémoire :

   cat /sys/fs/cgroup/memory/kubepods.slice/kubepods-besteffort.slice/kubepods-besteffort-pod4b6e96c8_042d_471c_b6ef_b7e0686a****.slice/cri-containerd-11111c202adfefdd63d7d002ccde8907d08291e706671438c4ccedfecba5****.scope/memory.limit_in_bytes

   Sortie attendue (10 Go) :

   10737418240

Surveiller l'utilisation des ressources Batch

Les clusters ACK s'intègrent à Managed Service for Prometheus. Pour afficher l'utilisation des ressources Batch :

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur console ACKClusters.

2. Sur la page Clusters, cliquez sur le nom du cluster cible. Dans le volet de gauche, choisissez Operations > Prometheus Monitoring.

3. Cliquez sur l'onglet Others, puis sur l'onglet k8s-reclaimed-resource. Ce tableau de bord affiche les revenus mixtes du cluster ainsi que la capacité des ressources aux niveaux du cluster, du nœud et du pod. Pour plus d'informations, consultez la rubrique Enable the colocation monitoring feature.

Si vous avez créé un tableau de bord Prometheus personnalisé, utilisez les métriques suivantes pour interroger les données des ressources Batch :

# Allocatable batch-cpu on the node
koordlet_node_resource_allocatable{resource="kubernetes.io/batch-cpu",node="$node"}
# batch-cpu already allocated on the node
koordlet_container_resource_requests{resource="kubernetes.io/batch-cpu",node="$node"}
# Allocatable batch-memory on the node
kube_node_status_allocatable{resource="kubernetes.io/batch-memory",node="$node"}
# batch-memory already allocated on the node
koordlet_container_resource_requests{resource="kubernetes.io/batch-memory",node="$node"}

FAQ

# Unit: bytes
cat /sys/fs/cgroup/memory/memory.limit_in_bytes
# Expected output example
1048576000

Étapes suivantes

ack-koordinator fournit des contrôles supplémentaires pour protéger les charges de travail en ligne contre les interférences causées par les pods BestEffort. Consultez les rubriques suivantes :

• Enable CPU Suppress

• Enable CPU QoS for containers

• Enable container CPU QoS

• Enable resource isolation based on the L3 cache and MBA