Red Hat Summit Red Hat SummitSupportConsoleDéveloppeursCommencer un essaiContact

7.2. Estimation du nombre de pods que peuvent contenir les nœuds d'OpenShift Container Platform

En tant qu'administrateur de cluster, vous pouvez utiliser l'outil de capacité de cluster pour visualiser le nombre de pods qui peuvent être planifiés pour augmenter les ressources actuelles avant qu'elles ne soient épuisées, et pour garantir que tous les pods futurs pourront être planifiés. Cette capacité provient d'un hôte de nœud individuel dans une grappe et comprend le CPU, la mémoire, l'espace disque et d'autres éléments.

L'outil de capacité de la grappe simule une séquence de décisions d'ordonnancement afin de déterminer le nombre d'instances d'un pod d'entrée qui peuvent être ordonnancées sur la grappe avant qu'elle n'épuise ses ressources, ce qui permet d'obtenir une estimation plus précise.

Note

La capacité allouable restante est une estimation approximative, car elle ne tient pas compte de toutes les ressources distribuées entre les nœuds. Elle analyse uniquement les ressources restantes et estime la capacité disponible qui est encore consommable en termes de nombre d'instances d'un pod avec des exigences données qui peuvent être planifiées dans un cluster.

En outre, les modules ne peuvent être programmés que sur des ensembles particuliers de nœuds en fonction de leurs critères de sélection et d'affinité. Par conséquent, il peut être difficile d'estimer quels pods restants une grappe peut programmer.

Vous pouvez exécuter l'outil d'analyse de la capacité des clusters en tant qu'utilitaire autonome à partir de la ligne de commande ou en tant que tâche dans un pod au sein d'un cluster OpenShift Container Platform. L'exécution en tant que tâche à l'intérieur d'un pod vous permet de l'exécuter plusieurs fois sans intervention.

Vous pouvez exécuter l'outil OpenShift Container Platform cluster capacity à partir de la ligne de commande pour estimer le nombre de pods qui peuvent être planifiés sur votre cluster.

Conditions préalables

  • Exécutez l'outil OpenShift Cluster Capacity Tool, qui est disponible sous forme d'image de conteneur à partir du catalogue de l'écosystème Red Hat.

  • Créez un exemple de fichier spec Pod, que l'outil utilise pour estimer l'utilisation des ressources. Le fichier podspec spécifie ses besoins en ressources sous la forme limits ou requests. L'outil de calcul de la capacité des clusters prend en compte les besoins en ressources du pod dans son analyse d'estimation.

    Voici un exemple de l'entrée Pod spec : 

    apiVersion: v1
kind: Pod
metadata:
  name: small-pod
  labels:
    app: guestbook
    tier: frontend
spec:
  containers:
  - name: php-redis
    image: gcr.io/google-samples/gb-frontend:v4
    imagePullPolicy: Always
    resources:
      limits:
        cpu: 150m
        memory: 100Mi
      requests:
        cpu: 150m
        memory: 100Mi
    Copy to Clipboard Toggle word wrap

Procédure

Pour utiliser l'outil de capacité de cluster sur la ligne de commande :

  1. À partir du terminal, connectez-vous au Red Hat Registry : 

    $ podman login registry.redhat.io
    Copy to Clipboard Toggle word wrap

  2. Tirez l'image de l'outil de capacité de la grappe : 

    $ podman pull registry.redhat.io/openshift4/ose-cluster-capacity
    Copy to Clipboard Toggle word wrap

  3. Exécutez l'outil de calcul de la capacité des clusters : 

    $ podman run -v $HOME/.kube:/kube:Z -v $(pwd):/cc:Z  ose-cluster-capacity \
/bin/cluster-capacity --kubeconfig /kube/config --podspec /cc/pod-spec.yaml \
--verbose
    1
    Copy to Clipboard Toggle word wrap
    1
    Vous pouvez également ajouter l'option --verbose pour obtenir une description détaillée du nombre de pods pouvant être planifiés sur chaque nœud du cluster.

    Exemple de sortie

    small-pod pod requirements:
	- CPU: 150m
	- Memory: 100Mi

The cluster can schedule 88 instance(s) of the pod small-pod.

Termination reason: Unschedulable: 0/5 nodes are available: 2 Insufficient cpu,
3 node(s) had taint {node-role.kubernetes.io/master: }, that the pod didn't
tolerate.

Pod distribution among nodes:
small-pod
	- 192.168.124.214: 45 instance(s)
	- 192.168.124.120: 43 instance(s)
    Copy to Clipboard Toggle word wrap

    Dans l'exemple ci-dessus, le nombre de pods estimés qui peuvent être programmés sur le cluster est de 88.

L'exécution de l'outil de capacité de cluster en tant que tâche à l'intérieur d'un pod présente l'avantage de pouvoir être exécutée plusieurs fois sans nécessiter d'intervention de la part de l'utilisateur. L'exécution de l'outil de capacité de cluster en tant que tâche implique l'utilisation d'un objet ConfigMap.

Conditions préalables

Téléchargez et installez l'outil de calcul de la capacité des clusters.

Procédure

Pour exécuter l'outil de capacité de cluster :

  1. Créer le rôle de cluster : 

    $ cat << EOF| oc create -f -
    Copy to Clipboard Toggle word wrap

    Exemple de sortie

    kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: cluster-capacity-role
rules:
- apiGroups: [""]
  resources: ["pods", "nodes", "persistentvolumeclaims", "persistentvolumes", "services", "replicationcontrollers"]
  verbs: ["get", "watch", "list"]
- apiGroups: ["apps"]
  resources: ["replicasets", "statefulsets"]
  verbs: ["get", "watch", "list"]
- apiGroups: ["policy"]
  resources: ["poddisruptionbudgets"]
  verbs: ["get", "watch", "list"]
- apiGroups: ["storage.k8s.io"]
  resources: ["storageclasses"]
  verbs: ["get", "watch", "list"]
EOF
    Copy to Clipboard Toggle word wrap

  2. Créer le compte de service : 

    $ oc create sa cluster-capacity-sa
    Copy to Clipboard Toggle word wrap

  3. Ajouter le rôle au compte de service : 

    $ oc adm policy add-cluster-role-to-user cluster-capacity-role \
    system:serviceaccount:default:cluster-capacity-sa
    Copy to Clipboard Toggle word wrap

  4. Définir et créer la spécification Pod: 

    apiVersion: v1
kind: Pod
metadata:
  name: small-pod
  labels:
    app: guestbook
    tier: frontend
spec:
  containers:
  - name: php-redis
    image: gcr.io/google-samples/gb-frontend:v4
    imagePullPolicy: Always
    resources:
      limits:
        cpu: 150m
        memory: 100Mi
      requests:
        cpu: 150m
        memory: 100Mi
    Copy to Clipboard Toggle word wrap

  5. L'analyse de la capacité du cluster est montée dans un volume à l'aide d'un objet ConfigMap nommé cluster-capacity-configmap pour monter le fichier d'entrée pod spec pod.yaml dans un volume test-volume au chemin /test-pod.

    Si vous n'avez pas créé d'objet ConfigMap, créez-en un avant de créer le travail : 

    $ oc create configmap cluster-capacity-configmap \
    --from-file=pod.yaml=pod.yaml
    Copy to Clipboard Toggle word wrap

  6. Créez le travail en utilisant l'exemple ci-dessous de fichier de spécification de travail : 

    apiVersion: batch/v1
kind: Job
metadata:
  name: cluster-capacity-job
spec:
  parallelism: 1
  completions: 1
  template:
    metadata:
      name: cluster-capacity-pod
    spec:
        containers:
        - name: cluster-capacity
          image: openshift/origin-cluster-capacity
          imagePullPolicy: "Always"
          volumeMounts:
          - mountPath: /test-pod
            name: test-volume
          env:
          - name: CC_INCLUSTER
    1 
    
            value: "true"
          command:
          - "/bin/sh"
          - "-ec"
          - |
            /bin/cluster-capacity --podspec=/test-pod/pod.yaml --verbose
        restartPolicy: "Never"
        serviceAccountName: cluster-capacity-sa
        volumes:
        - name: test-volume
          configMap:
            name: cluster-capacity-configmap
    Copy to Clipboard Toggle word wrap
    1
    Variable d'environnement obligatoire permettant à l'outil de capacité de cluster de savoir qu'il s'exécute dans un cluster en tant que pod.
    La clé pod.yaml de l'objet ConfigMap est la même que le nom du fichier de spécification Pod, bien qu'elle ne soit pas obligatoire. Ainsi, le fichier spec du pod d'entrée est accessible à l'intérieur du pod en tant que /test-pod/pod.yaml.

  7. Exécutez l'image de capacité de cluster en tant que tâche dans un module : 

    $ oc create -f cluster-capacity-job.yaml
    Copy to Clipboard Toggle word wrap

  8. Consultez les journaux de travail pour connaître le nombre de pods pouvant être planifiés dans le cluster : 

    $ oc logs jobs/cluster-capacity-job
    Copy to Clipboard Toggle word wrap

    Exemple de sortie

    small-pod pod requirements:
        - CPU: 150m
        - Memory: 100Mi

The cluster can schedule 52 instance(s) of the pod small-pod.

Termination reason: Unschedulable: No nodes are available that match all of the
following predicates:: Insufficient cpu (2).

Pod distribution among nodes:
small-pod
        - 192.168.124.214: 26 instance(s)
        - 192.168.124.120: 26 instance(s)
    Copy to Clipboard Toggle word wrap

Retour au début
Red Hat logoGithubredditYoutubeTwitter

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Nous aidons les utilisateurs de Red Hat à innover et à atteindre leurs objectifs grâce à nos produits et services avec un contenu auquel ils peuvent faire confiance. Découvrez nos récentes mises à jour.

Rendre l’open source plus inclusif

Red Hat s'engage à remplacer le langage problématique dans notre code, notre documentation et nos propriétés Web. Pour plus de détails, consultez le Blog Red Hat.

À propos de Red Hat

Nous proposons des solutions renforcées qui facilitent le travail des entreprises sur plusieurs plates-formes et environnements, du centre de données central à la périphérie du réseau.

Theme

© 2025 Red Hat