2.5. Création d'un ensemble de machines de calcul sur GCP

PDF

Vous pouvez créer un ensemble de machines de calcul différent pour répondre à un besoin spécifique dans votre cluster OpenShift Container Platform sur Google Cloud Platform (GCP). Par exemple, vous pouvez créer des jeux de machines d'infrastructure et des machines connexes afin de pouvoir déplacer des charges de travail de support vers les nouvelles machines.

Important

Vous ne pouvez utiliser les fonctionnalités avancées de gestion et de mise à l'échelle des machines que dans les clusters où l'API Machine est opérationnelle. Les clusters dont l'infrastructure est fournie par l'utilisateur nécessitent une validation et une configuration supplémentaires pour utiliser l'API Machine.

Les clusters avec le type de plateforme d'infrastructure none ne peuvent pas utiliser l'API Machine. Cette limitation s'applique même si les machines de calcul attachées au cluster sont installées sur une plateforme qui prend en charge cette fonctionnalité. Ce paramètre ne peut pas être modifié après l'installation.

Pour afficher le type de plateforme de votre cluster, exécutez la commande suivante :

$ oc get infrastructure cluster -o jsonpath='{.status.platform}'

2.5.1. Exemple de YAML pour une ressource personnalisée d'une machine de calcul sur GCP

Cet exemple YAML définit un ensemble de machines de calcul qui fonctionne dans Google Cloud Platform (GCP) et crée des nœuds étiquetés avec node-role.kubernetes.io/<role>: "".

Dans cet exemple, <infrastructure_id> est l'étiquette d'ID d'infrastructure basée sur l'ID de cluster que vous avez défini lors du provisionnement du cluster, et <role> est l'étiquette de nœud à ajouter.

apiVersion: machine.openshift.io/v1beta1
kind: MachineSet
metadata:
  labels:
    machine.openshift.io/cluster-api-cluster: <infrastructure_id> 1
  name: <infrastructure_id>-w-a
  namespace: openshift-machine-api
spec:
  replicas: 1
  selector:
    matchLabels:
      machine.openshift.io/cluster-api-cluster: <infrastructure_id>
      machine.openshift.io/cluster-api-machineset: <infrastructure_id>-w-a
  template:
    metadata:
      creationTimestamp: null
      labels:
        machine.openshift.io/cluster-api-cluster: <infrastructure_id>
        machine.openshift.io/cluster-api-machine-role: <role> 2
        machine.openshift.io/cluster-api-machine-type: <role>
        machine.openshift.io/cluster-api-machineset: <infrastructure_id>-w-a
    spec:
      metadata:
        labels:
          node-role.kubernetes.io/<role>: ""
      providerSpec:
        value:
          apiVersion: gcpprovider.openshift.io/v1beta1
          canIPForward: false
          credentialsSecret:
            name: gcp-cloud-credentials
          deletionProtection: false
          disks:
          - autoDelete: true
            boot: true
            image: <path_to_image> 3
            labels: null
            sizeGb: 128
            type: pd-ssd
          gcpMetadata: 4
          - key: <custom_metadata_key>
            value: <custom_metadata_value>
          kind: GCPMachineProviderSpec
          machineType: n1-standard-4
          metadata:
            creationTimestamp: null
          networkInterfaces:
          - network: <infrastructure_id>-network
            subnetwork: <infrastructure_id>-worker-subnet
          projectID: <project_name> 5
          region: us-central1
          serviceAccounts:
          - email: <infrastructure_id>-w@<project_name>.iam.gserviceaccount.com
            scopes:
            - https://www.googleapis.com/auth/cloud-platform
          tags:
            - <infrastructure_id>-worker
          userDataSecret:
            name: worker-user-data
          zone: us-central1-a

1

Pour <infrastructure_id>, spécifiez l'ID d'infrastructure qui est basé sur l'ID de cluster que vous avez défini lorsque vous avez provisionné le cluster. Si le CLI OpenShift est installé, vous pouvez obtenir l'ID d'infrastructure en exécutant la commande suivante :

$ oc get -o jsonpath='{.status.infrastructureName}{"\n"}' infrastructure cluster

2

Pour <node>, indiquez l'étiquette de nœud à ajouter.

3

Spécifiez le chemin d'accès à l'image utilisée dans les ensembles de machines de calcul actuels. Si le CLI OpenShift est installé, vous pouvez obtenir le chemin d'accès à l'image en exécutant la commande suivante :

$ oc -n openshift-machine-api \
    -o jsonpath='{.spec.template.spec.providerSpec.value.disks[0].image}{"\n"}' \
    get machineset/<infrastructure_id>-worker-a

To use a GCP Marketplace image, specify the offer to use:

OpenShift Container Platform: https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-ocp-48-x86-64-202210040145
OpenShift Platform Plus: https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-opp-48-x86-64-202206140145
OpenShift Kubernetes Engine: https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-oke-48-x86-64-202206140145

4

Facultatif : Spécifiez des métadonnées personnalisées sous la forme d'une paire key:value. Pour des exemples de cas d'utilisation, voir la documentation GCP pour la définition de métadonnées personnalisées.

5

Pour <project_name>, indiquez le nom du projet GCP que vous utilisez pour votre cluster.

2.5.2. Création d'un ensemble de machines de calcul

En plus des ensembles de machines de calcul créés par le programme d'installation, vous pouvez créer vos propres ensembles pour gérer dynamiquement les ressources de calcul des machines pour les charges de travail spécifiques de votre choix.

Conditions préalables

Déployer un cluster OpenShift Container Platform.
Installez le CLI OpenShift (oc).
Connectez-vous à oc en tant qu'utilisateur disposant de l'autorisation cluster-admin.

Procédure

Créez un nouveau fichier YAML contenant l'échantillon de ressources personnalisées (CR) de l'ensemble de machines de calcul et nommé <file_name>.yaml.
Veillez à définir les valeurs des paramètres <clusterID> et <role>.

Facultatif : si vous n'êtes pas sûr de la valeur à définir pour un champ spécifique, vous pouvez vérifier un ensemble de machines de calcul existant dans votre cluster.

Pour répertorier les ensembles de machines de calcul de votre cluster, exécutez la commande suivante :

$ oc get machinesets -n openshift-machine-api

Exemple de sortie

NAME                                DESIRED   CURRENT   READY   AVAILABLE   AGE
agl030519-vplxk-worker-us-east-1a   1         1         1       1           55m
agl030519-vplxk-worker-us-east-1b   1         1         1       1           55m
agl030519-vplxk-worker-us-east-1c   1         1         1       1           55m
agl030519-vplxk-worker-us-east-1d   0         0                             55m
agl030519-vplxk-worker-us-east-1e   0         0                             55m
agl030519-vplxk-worker-us-east-1f   0         0                             55m

Pour afficher les valeurs d'une ressource personnalisée (CR) d'un ensemble de machines de calcul spécifique, exécutez la commande suivante :

$ oc get machineset <machineset_name> \
  -n openshift-machine-api -o yaml

Exemple de sortie

apiVersion: machine.openshift.io/v1beta1
kind: MachineSet
metadata:
  labels:
    machine.openshift.io/cluster-api-cluster: <infrastructure_id> 1
  name: <infrastructure_id>-<role> 2
  namespace: openshift-machine-api
spec:
  replicas: 1
  selector:
    matchLabels:
      machine.openshift.io/cluster-api-cluster: <infrastructure_id>
      machine.openshift.io/cluster-api-machineset: <infrastructure_id>-<role>
  template:
    metadata:
      labels:
        machine.openshift.io/cluster-api-cluster: <infrastructure_id>
        machine.openshift.io/cluster-api-machine-role: <role>
        machine.openshift.io/cluster-api-machine-type: <role>
        machine.openshift.io/cluster-api-machineset: <infrastructure_id>-<role>
    spec:
      providerSpec: 3
        ...

1: L'ID de l'infrastructure du cluster.
2: Une étiquette de nœud par défaut.
Note
Pour les clusters disposant d'une infrastructure fournie par l'utilisateur, un ensemble de machines de calcul ne peut créer que des machines de type worker et infra.
3: Les valeurs de la section <providerSpec> du CR de l'ensemble de machines de calcul sont spécifiques à la plate-forme. Pour plus d'informations sur les paramètres <providerSpec> dans le CR, consultez l'exemple de configuration du CR de l'ensemble de machines de calcul pour votre fournisseur.

Créez un CR MachineSet en exécutant la commande suivante :
```
oc create -f <nom_du_fichier>.yaml
```

Vérification

Affichez la liste des ensembles de machines de calcul en exécutant la commande suivante :

$ oc get machineset -n openshift-machine-api

Exemple de sortie

NAME                                DESIRED   CURRENT   READY   AVAILABLE   AGE
agl030519-vplxk-infra-us-east-1a    1         1         1       1           11m
agl030519-vplxk-worker-us-east-1a   1         1         1       1           55m
agl030519-vplxk-worker-us-east-1b   1         1         1       1           55m
agl030519-vplxk-worker-us-east-1c   1         1         1       1           55m
agl030519-vplxk-worker-us-east-1d   0         0                             55m
agl030519-vplxk-worker-us-east-1e   0         0                             55m
agl030519-vplxk-worker-us-east-1f   0         0                             55m

Lorsque le nouveau jeu de machines de calcul est disponible, les valeurs DESIRED et CURRENT correspondent. Si le jeu de machines de calcul n'est pas disponible, attendez quelques minutes et exécutez à nouveau la commande.

2.5.3. Configuration des types de disques persistants à l'aide d'ensembles de machines de calcul

Vous pouvez configurer le type de disque persistant sur lequel un ensemble de machines de calcul déploie des machines en modifiant le fichier YAML de l'ensemble de machines de calcul.

Pour plus d'informations sur les types de disques persistants, la compatibilité, la disponibilité régionale et les limitations, voir la documentation GCP Compute Engine sur les disques persistants.

Procédure

Dans un éditeur de texte, ouvrez le fichier YAML d'un ensemble de machines de calcul existant ou créez-en un nouveau.
Modifiez la ligne suivante sous le champ providerSpec:
```
providerSpec:
  value:
    disks:
      type: <pd-disk-type> 1
```
1
Indiquez le type de disque persistant. Les valeurs valides sont pd-ssd, pd-standard, et pd-balanced. La valeur par défaut est pd-standard.

Vérification

Dans la console Google Cloud, examinez les détails d'une machine déployée par l'ensemble de machines de calcul et vérifiez que le champ Type correspond au type de disque configuré.

2.5.4. Jeux de machines qui déploient des machines en tant qu'instances VM préemptibles

Vous pouvez réduire les coûts en créant un ensemble de machines de calcul fonctionnant sur GCP qui déploie des machines en tant qu'instances VM préemptibles non garanties. Les instances VM préemptibles utilisent la capacité excédentaire de Compute Engine et sont moins coûteuses que les instances normales. Vous pouvez utiliser les instances VM préemptibles pour les charges de travail qui peuvent tolérer des interruptions, telles que les charges de travail évolutives horizontalement, par lots ou sans état.

Le moteur de calcul GCP peut mettre fin à une instance de VM préemptible à tout moment. Compute Engine envoie un avis de préemption à l'utilisateur indiquant qu'une interruption se produira dans 30 secondes. OpenShift Container Platform commence à supprimer les charges de travail des instances concernées lorsque Compute Engine émet l'avis de préemption. Un signal ACPI G3 Mechanical Off est envoyé au système d'exploitation après 30 secondes si l'instance n'est pas arrêtée. L'instance VM préemptible est ensuite transférée à l'état TERMINATED par Compute Engine.

Des interruptions peuvent se produire lors de l'utilisation d'instances VM préemptibles pour les raisons suivantes :

Il y a un événement lié au système ou à la maintenance
L'offre d'instances de VM préemptibles diminue
L'instance atteint la fin de la période de 24 heures allouée pour les instances VM préemptibles

Lorsque GCP met fin à une instance, un gestionnaire de fin s'exécutant sur le nœud d'instance VM préemptible supprime la ressource machine. Pour satisfaire la quantité de l'ensemble de machines de calcul replicas, l'ensemble de machines de calcul crée une machine qui demande une instance de VM préemptible.

2.5.4.1. Créer des instances de VM préemptibles en utilisant des ensembles de machines de calcul

Vous pouvez lancer une instance de VM préemptible sur GCP en ajoutant preemptible à votre fichier YAML de configuration de machine de calcul.

Procédure

Ajoutez la ligne suivante sous le champ providerSpec:
```
providerSpec:
  value:
    preemptible: true
```
Si preemptible est défini sur true, la machine est étiquetée comme interruptable-instance après le lancement de l'instance.

2.5.5. Activation des clés de chiffrement gérées par le client pour un ensemble de machines de calcul

Google Cloud Platform (GCP) Compute Engine permet aux utilisateurs de fournir une clé de chiffrement pour chiffrer les données sur les disques au repos. La clé est utilisée pour chiffrer la clé de chiffrement des données, et non pour chiffrer les données du client. Par défaut, Compute Engine chiffre ces données en utilisant les clés Compute Engine.

Vous pouvez activer le cryptage avec une clé gérée par le client en utilisant l'API Machine. Vous devez d'abord créer une clé KMS et attribuer les autorisations correctes à un compte de service. Le nom de la clé KMS, le nom du porte-clés et l'emplacement sont nécessaires pour permettre à un compte de service d'utiliser votre clé.

Note

Si vous ne souhaitez pas utiliser un compte de service dédié pour le chiffrement du KMS, le compte de service par défaut du Compute Engine est utilisé à la place. Vous devez autoriser le compte de service par défaut à accéder aux clés si vous n'utilisez pas de compte de service dédié. Le nom du compte de service par défaut du moteur de calcul suit le modèle service-<project_number>@compute-system.iam.gserviceaccount.com.

Procédure

Exécutez la commande suivante avec le nom de votre clé KMS, le nom de l'anneau de clés et l'emplacement pour permettre à un compte de service spécifique d'utiliser votre clé KMS et pour accorder au compte de service le rôle IAM correct :

gcloud kms keys add-iam-policy-binding <key_name> \
  --keyring <key_ring_name> \
  --location <key_ring_location> \
  --member "serviceAccount:service-<project_number>@compute-system.iam.gserviceaccount.com” \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter

Configurez la clé de chiffrement dans le champ providerSpec du fichier YAML de votre machine de calcul. Par exemple :
```
providerSpec:
  value:
    # ...
    disks:
    - type:
      # ...
      encryptionKey:
        kmsKey:
          name: machine-encryption-key 1
          keyRing: openshift-encrpytion-ring 2
          location: global 3
          projectID: openshift-gcp-project 4
        kmsKeyServiceAccount: openshift-service-account@openshift-gcp-project.iam.gserviceaccount.com 5
```
1
Nom de la clé de chiffrement gérée par le client et utilisée pour le chiffrement du disque.
2
Le nom du porte-clés KMS auquel la clé KMS appartient.
3
Emplacement du GCP dans lequel se trouve le trousseau de clés KMS.
4
Facultatif : L'ID du projet dans lequel le porte-clés KMS existe. Si aucun ID de projet n'est défini, l'ensemble de machines de calcul projectID dans lequel l'ensemble de machines de calcul a été créé est utilisé.
5
Facultatif : Le compte de service utilisé pour la demande de chiffrement de la clé KMS donnée. Si aucun compte de service n'est défini, le compte de service par défaut du Compute Engine est utilisé.
Après la création d'une nouvelle machine à l'aide de la configuration actualisée de l'objet providerSpec, la clé de chiffrement du disque est chiffrée avec la clé KMS.

2.5.6. Activation de la prise en charge du GPU pour un ensemble de machines de calcul

Google Cloud Platform (GCP) Compute Engine permet aux utilisateurs d'ajouter des GPU aux instances de machines virtuelles. Les charges de travail qui bénéficient d'un accès aux ressources GPU peuvent être plus performantes sur les machines de calcul avec cette fonctionnalité activée. OpenShift Container Platform sur GCP prend en charge les modèles de GPU NVIDIA dans les séries de machines A2 et N1.

Tableau 2.1. Configurations GPU prises en charge
Nom du modèle	Type de GPU	Types de machines ^[1]
NVIDIA A100	`nvidia-tesla-a100`	`a2-highgpu-1g` `a2-highgpu-2g` `a2-highgpu-4g` `a2-highgpu-8g` `a2-megagpu-16g`
NVIDIA K80	`nvidia-tesla-k80`	`n1-standard-1` `n1-standard-2` `n1-standard-4` `n1-standard-8` `n1-standard-16` `n1-standard-32` `n1-standard-64` `n1-standard-96` `n1-highmem-2` `n1-highmem-4` `n1-highmem-8` `n1-highmem-16` `n1-highmem-32` `n1-highmem-64` `n1-highmem-96` `n1-highcpu-2` `n1-highcpu-4` `n1-highcpu-8` `n1-highcpu-16` `n1-highcpu-32` `n1-highcpu-64` `n1-highcpu-96`
NVIDIA P100	`nvidia-tesla-p100`
NVIDIA P4	`nvidia-tesla-p4`
NVIDIA T4	`nvidia-tesla-t4`
NVIDIA V100	`nvidia-tesla-v100`

Pour plus d'informations sur les types de machines, y compris les spécifications, la compatibilité, la disponibilité régionale et les limitations, voir la documentation GCP Compute Engine sur la série de machines N1, la série de machines A2 et la disponibilité des régions et zones GPU.

Vous pouvez définir le GPU pris en charge à utiliser pour une instance à l'aide de l'API Machine.

Vous pouvez configurer les machines de la série N1 pour qu'elles soient déployées avec l'un des types de GPU pris en charge. Les machines de la série A2 sont livrées avec des GPU associés et ne peuvent pas utiliser d'accélérateurs invités.

Note

Les GPU pour les charges de travail graphiques ne sont pas pris en charge.

Procédure

Dans un éditeur de texte, ouvrez le fichier YAML d'un ensemble de machines de calcul existant ou créez-en un nouveau.
Spécifiez une configuration GPU dans le champ providerSpec du fichier YAML de votre machine de calcul. Voir les exemples suivants de configurations valides :
Exemple de configuration pour la série de machines A2 :
```
  providerSpec:
    value:
      machineType: a2-highgpu-1g 1
      onHostMaintenance: Terminate 2
      restartPolicy: Always 3
```
1
Spécifiez le type de machine. Assurez-vous que le type de machine est inclus dans la série de machines A2.
2
Lorsque vous utilisez le support GPU, vous devez définir onHostMaintenance sur Terminate.
3
Spécifiez la politique de redémarrage pour les machines déployées par l'ensemble de machines de calcul. Les valeurs autorisées sont Always ou Never.
Exemple de configuration pour la série de machines N1 :
```
providerSpec:
  value:
    gpus:
    - count: 1 1
      type: nvidia-tesla-p100 2
    machineType: n1-standard-1 3
    onHostMaintenance: Terminate 4
    restartPolicy: Always 5
```
1
Spécifiez le nombre de GPU à attacher à la machine.
2
Spécifiez le type de GPU à attacher à la machine. Assurez-vous que le type de machine et le type de GPU sont compatibles.
3
Spécifiez le type de machine. Assurez-vous que le type de machine et le type de GPU sont compatibles.
4
Lorsque vous utilisez le support GPU, vous devez définir onHostMaintenance sur Terminate.
5
Spécifiez la politique de redémarrage pour les machines déployées par l'ensemble de machines de calcul. Les valeurs autorisées sont Always ou Never.

2.5.7. Ajouter un nœud GPU à un cluster OpenShift Container Platform existant

Vous pouvez copier et modifier la configuration d'un ensemble de machines de calcul par défaut pour créer un ensemble de machines et des machines compatibles avec le GPU pour le fournisseur de cloud GCP.

Le tableau suivant énumère les types d'instance validés :

Instance type	Accélérateur GPU NVIDIA	Nombre maximal de GPU	L'architecture
`a2-highgpu-1g`	A100	1	x86
`n1-standard-4`	T4	1	x86

Procédure

Faire une copie d'un site existant MachineSet.
Dans la nouvelle copie, modifiez le jeu de machines name dans metadata.name et dans les deux instances de machine.openshift.io/cluster-api-machineset.

Modifiez le type d'instance pour ajouter les deux lignes suivantes à la nouvelle copie de MachineSet:

machineType: a2-highgpu-1g
onHostMaintenance: Terminate

Exemple de fichier a2-highgpu-1g.json

{
    "apiVersion": "machine.openshift.io/v1beta1",
    "kind": "MachineSet",
    "metadata": {
        "annotations": {
            "machine.openshift.io/GPU": "0",
            "machine.openshift.io/memoryMb": "16384",
            "machine.openshift.io/vCPU": "4"
        },
        "creationTimestamp": "2023-01-13T17:11:02Z",
        "generation": 1,
        "labels": {
            "machine.openshift.io/cluster-api-cluster": "myclustername-2pt9p"
        },
        "name": "myclustername-2pt9p-worker-gpu-a",
        "namespace": "openshift-machine-api",
        "resourceVersion": "20185",
        "uid": "2daf4712-733e-4399-b4b4-d43cb1ed32bd"
    },
    "spec": {
        "replicas": 1,
        "selector": {
            "matchLabels": {
                "machine.openshift.io/cluster-api-cluster": "myclustername-2pt9p",
                "machine.openshift.io/cluster-api-machineset": "myclustername-2pt9p-worker-gpu-a"
            }
        },
        "template": {
            "metadata": {
                "labels": {
                    "machine.openshift.io/cluster-api-cluster": "myclustername-2pt9p",
                    "machine.openshift.io/cluster-api-machine-role": "worker",
                    "machine.openshift.io/cluster-api-machine-type": "worker",
                    "machine.openshift.io/cluster-api-machineset": "myclustername-2pt9p-worker-gpu-a"
                }
            },
            "spec": {
                "lifecycleHooks": {},
                "metadata": {},
                "providerSpec": {
                    "value": {
                        "apiVersion": "machine.openshift.io/v1beta1",
                        "canIPForward": false,
                        "credentialsSecret": {
                            "name": "gcp-cloud-credentials"
                        },
                        "deletionProtection": false,
                        "disks": [
                            {
                                "autoDelete": true,
                                "boot": true,
                                "image": "projects/rhcos-cloud/global/images/rhcos-412-86-202212081411-0-gcp-x86-64",
                                "labels": null,
                                "sizeGb": 128,
                                "type": "pd-ssd"
                            }
                        ],
                        "kind": "GCPMachineProviderSpec",
                        "machineType": "a2-highgpu-1g",
                        "onHostMaintenance": "Terminate",
                        "metadata": {
                            "creationTimestamp": null
                        },
                        "networkInterfaces": [
                            {
                                "network": "myclustername-2pt9p-network",
                                "subnetwork": "myclustername-2pt9p-worker-subnet"
                            }
                        ],
                        "preemptible": true,
                        "projectID": "myteam",
                        "region": "us-central1",
                        "serviceAccounts": [
                            {
                                "email": "myclustername-2pt9p-w@myteam.iam.gserviceaccount.com",
                                "scopes": [
                                    "https://www.googleapis.com/auth/cloud-platform"
                                ]
                            }
                        ],
                        "tags": [
                            "myclustername-2pt9p-worker"
                        ],
                        "userDataSecret": {
                            "name": "worker-user-data"
                        },
                        "zone": "us-central1-a"
                    }
                }
            }
        }
    },
    "status": {
        "availableReplicas": 1,
        "fullyLabeledReplicas": 1,
        "observedGeneration": 1,
        "readyReplicas": 1,
        "replicas": 1
    }
}

Affichez les nœuds, les machines et les ensembles de machines existants en exécutant la commande suivante. Notez que chaque nœud est une instance d'une définition de machine avec une région GCP spécifique et un rôle OpenShift Container Platform.

$ oc get nodes

Exemple de sortie

NAME                                                             STATUS     ROLES                  AGE     VERSION
myclustername-2pt9p-master-0.c.openshift-qe.internal             Ready      control-plane,master   8h      v1.25.4+77bec7a
myclustername-2pt9p-master-1.c.openshift-qe.internal             Ready      control-plane,master   8h      v1.25.4+77bec7a
myclustername-2pt9p-master-2.c.openshift-qe.internal             Ready      control-plane,master   8h      v1.25.4+77bec7a
myclustername-2pt9p-worker-a-mxtnz.c.openshift-qe.internal       Ready      worker                 8h      v1.25.4+77bec7a
myclustername-2pt9p-worker-b-9pzzn.c.openshift-qe.internal       Ready      worker                 8h      v1.25.4+77bec7a
myclustername-2pt9p-worker-c-6pbg6.c.openshift-qe.internal       Ready      worker                 8h      v1.25.4+77bec7a
myclustername-2pt9p-worker-gpu-a-wxcr6.c.openshift-qe.internal   Ready      worker                 4h35m   v1.25.4+77bec7a

Affichez les machines et les ensembles de machines qui existent dans l'espace de noms openshift-machine-api en exécutant la commande suivante. Chaque ensemble de machines de calcul est associé à une zone de disponibilité différente dans la région GCP. Le programme d'installation équilibre automatiquement la charge des machines de calcul entre les zones de disponibilité.

$ oc get machinesets -n openshift-machine-api

Exemple de sortie

NAME                               DESIRED   CURRENT   READY   AVAILABLE   AGE
myclustername-2pt9p-worker-a       1         1         1       1           8h
myclustername-2pt9p-worker-b       1         1         1       1           8h
myclustername-2pt9p-worker-c       1         1                             8h
myclustername-2pt9p-worker-f       0         0                             8h

Affichez les machines qui existent dans l'espace de noms openshift-machine-api en exécutant la commande suivante. Vous ne pouvez configurer qu'une machine de calcul par ensemble, mais vous pouvez faire évoluer un ensemble de machines de calcul pour ajouter un nœud dans une région et une zone particulières.

$ oc get machines -n openshift-machine-api | grep worker

Exemple de sortie

myclustername-2pt9p-worker-a-mxtnz       Running   n2-standard-4   us-central1   us-central1-a   8h
myclustername-2pt9p-worker-b-9pzzn       Running   n2-standard-4   us-central1   us-central1-b   8h
myclustername-2pt9p-worker-c-6pbg6       Running   n2-standard-4   us-central1   us-central1-c   8h

Faites une copie de l'une des définitions de compute MachineSet existantes et générez le résultat dans un fichier JSON en exécutant la commande suivante. Ce fichier servira de base à la définition de l'ensemble de machines de calcul compatibles avec le GPU.
```
$ oc get machineset myclustername-2pt9p-worker-a -n openshift-machine-api -o json  > <output_file.json>
```
Modifiez le fichier JSON pour apporter les changements suivants à la nouvelle définition MachineSet:
- Renommez l'ensemble de machines name en insérant la sous-chaîne gpu dans metadata.name et dans les deux instances de machine.openshift.io/cluster-api-machineset.
- Remplacer machineType de la nouvelle définition de MachineSet par a2-highgpu-1g, qui inclut un GPU NVIDIA A100.
```
jq .spec.template.spec.providerSpec.value.machineType ocp_4.12_machineset-a2-highgpu-1g.json

"a2-highgpu-1g"
```
  Le fichier <output_file.json> est enregistré sous le nom de ocp_4.12_machineset-a2-highgpu-1g.json.
Mettez à jour les champs suivants dans ocp_4.12_machineset-a2-highgpu-1g.json:
- Remplacer .metadata.name par un nom contenant gpu.
- Modifier .spec.selector.matchLabels["machine.openshift.io/cluster-api-machineset"] pour qu'il corresponde au nouveau .metadata.name.
- Modifier .spec.template.metadata.labels["machine.openshift.io/cluster-api-machineset"] pour qu'il corresponde au nouveau .metadata.name.
- Remplacer .spec.template.spec.providerSpec.value.MachineType par a2-highgpu-1g.
- Ajouter la ligne suivante sous machineType: ``OnHostMaintenance'' : "Terminer". Par exemple :
```
"machineType": "a2-highgpu-1g",
"onHostMaintenance": "Terminate",
```

Pour vérifier vos modifications, exécutez la commande suivante : diff de la définition originale du calcul et de la nouvelle définition du nœud compatible avec le GPU :

$ oc get machineset/myclustername-2pt9p-worker-a -n openshift-machine-api -o json | diff ocp_4.12_machineset-a2-highgpu-1g.json -

Exemple de sortie

15c15
<         "name": "myclustername-2pt9p-worker-gpu-a",
---
>         "name": "myclustername-2pt9p-worker-a",
25c25
<                 "machine.openshift.io/cluster-api-machineset": "myclustername-2pt9p-worker-gpu-a"
---
>                 "machine.openshift.io/cluster-api-machineset": "myclustername-2pt9p-worker-a"
34c34
<                     "machine.openshift.io/cluster-api-machineset": "myclustername-2pt9p-worker-gpu-a"
---
>                     "machine.openshift.io/cluster-api-machineset": "myclustername-2pt9p-worker-a"
59,60c59
<                         "machineType": "a2-highgpu-1g",
<                         "onHostMaintenance": "Terminate",
---
>                         "machineType": "n2-standard-4",

Créez l'ensemble de machines de calcul compatibles avec le GPU à partir du fichier de définition en exécutant la commande suivante :
```
$ oc create -f ocp_4.12_machineset-a2-highgpu-1g.json
```
Exemple de sortie
```
machineset.machine.openshift.io/myclustername-2pt9p-worker-gpu-a created
```

Vérification

Affichez le jeu de machines que vous avez créé en exécutant la commande suivante :
```
$ oc -n openshift-machine-api get machinesets | grep gpu
```
Le nombre de répliques de MachineSet étant fixé à 1, un nouvel objet Machine est créé automatiquement.
Exemple de sortie
```
myclustername-2pt9p-worker-gpu-a   1         1         1       1           5h24m
```

Affichez l'objet Machine créé par le jeu de machines en exécutant la commande suivante :

$ oc -n openshift-machine-api get machines | grep gpu

Exemple de sortie

myclustername-2pt9p-worker-gpu-a-wxcr6   Running   a2-highgpu-1g   us-central1   us-central1-a   5h25m

Note

Notez qu'il n'est pas nécessaire de spécifier un espace de noms pour le nœud. La définition du nœud est limitée à la grappe.

2.5.8. Déploiement de l'opérateur de découverte de fonctionnalités des nœuds

Une fois le nœud compatible avec le GPU créé, vous devez le découvrir afin de pouvoir le planifier. Pour ce faire, installez l'opérateur NFD (Node Feature Discovery). L'opérateur NFD identifie les caractéristiques des dispositifs matériels dans les nœuds. Il résout le problème général de l'identification et du catalogage des ressources matérielles dans les nœuds d'infrastructure afin qu'elles puissent être mises à la disposition d'OpenShift Container Platform.

Procédure

Installez l'opérateur de découverte de fonctionnalités Node à partir de OperatorHub dans la console OpenShift Container Platform.
Après avoir installé l'opérateur NFD dans OperatorHub, sélectionnez Node Feature Discovery dans la liste des opérateurs installés et sélectionnez Create instance. Ceci installe les pods nfd-master et nfd-worker, un pod nfd-worker pour chaque nœud de calcul, dans l'espace de noms openshift-nfd.

Vérifiez que l'opérateur est installé et fonctionne en exécutant la commande suivante :

$ oc get pods -n openshift-nfd

Exemple de sortie

NAME                                       READY    STATUS     RESTARTS   AGE

nfd-controller-manager-8646fcbb65-x5qgk    2/2      Running 7  (8h ago)   1d

Recherchez l'Oerator installé dans la console et sélectionnez Create Node Feature Discovery.
Sélectionnez Create pour créer une ressource personnalisée NFD. Cela crée des pods NFD dans l'espace de noms openshift-nfd qui interrogent les nœuds OpenShift Container Platform à la recherche de ressources matérielles et les cataloguent.

Vérification

Après une construction réussie, vérifiez qu'un pod NFD fonctionne sur chaque nœud en exécutant la commande suivante :

$ oc get pods -n openshift-nfd

Exemple de sortie

NAME                                       READY   STATUS      RESTARTS        AGE
nfd-controller-manager-8646fcbb65-x5qgk    2/2     Running     7 (8h ago)      12d
nfd-master-769656c4cb-w9vrv                1/1     Running     0               12d
nfd-worker-qjxb2                           1/1     Running     3 (3d14h ago)   12d
nfd-worker-xtz9b                           1/1     Running     5 (3d14h ago)   12d

L'opérateur NFD utilise les identifiants PCI des fournisseurs pour identifier le matériel dans un nœud. NVIDIA utilise l'ID PCI 10de.

Affichez le GPU NVIDIA découvert par l'opérateur NFD en exécutant la commande suivante :
```
$ oc describe node ip-10-0-132-138.us-east-2.compute.internal | egrep 'Roles|pci'
```
Exemple de sortie
```
Roles: worker

feature.node.kubernetes.io/pci-1013.present=true

feature.node.kubernetes.io/pci-10de.present=true

feature.node.kubernetes.io/pci-1d0f.present=true
```
10de apparaît dans la liste des caractéristiques du nœud compatible avec le GPU. Cela signifie que l'opérateur NFD a correctement identifié le nœud de l'ensemble de machines équipé d'un GPU.

2.5. Création d'un ensemble de machines de calcul sur GCP

2.5.1. Exemple de YAML pour une ressource personnalisée d'une machine de calcul sur GCP

2.5.2. Création d'un ensemble de machines de calcul

2.5.3. Configuration des types de disques persistants à l'aide d'ensembles de machines de calcul

2.5.4. Jeux de machines qui déploient des machines en tant qu'instances VM préemptibles

2.5.4.1. Créer des instances de VM préemptibles en utilisant des ensembles de machines de calcul

2.5.5. Activation des clés de chiffrement gérées par le client pour un ensemble de machines de calcul

2.5.6. Activation de la prise en charge du GPU pour un ensemble de machines de calcul

2.5.7. Ajouter un nœud GPU à un cluster OpenShift Container Platform existant

2.5.8. Déploiement de l'opérateur de découverte de fonctionnalités des nœuds

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Rendre l’open source plus inclusif

À propos de Red Hat

Red Hat legal and privacy links

Red Hat legal and privacy links