Container Service for Kubernetes:Guide d’exploitation et de maintenance de la suite cloud-native pour l’IA

Déployer la suite

1. Connectez-vous à la console ACK et cliquez sur Clusters dans le volet de navigation de gauche.

2. Cliquez sur le nom du cluster, puis choisissez Applications > Cloud-native AI Suite dans le volet de gauche.

3. Cliquez sur Deploy.

4. Sélectionnez les composants et cliquez sur Deploy Cloud-native AI Suite. Le système vérifie les dépendances avant le déploiement. Après l’installation, la liste Components vous permet de Deploy, Upgrade ou Uninstall des composants individuels.

5. Après avoir installé ack-ai-dashboard et ack-ai-dev-console, des liens vers AI Dashboard et AI Developer Console apparaissent sur la page Cloud-native AI Suite.

   

Configurer le tableau de bord IA

Accorder des autorisations RAM au rôle worker

Avant que le tableau de bord IA puisse accéder aux données du cluster, associez une politique RAM personnalisée au rôle worker du cluster.

1. Créez une politique personnalisée.

   1. Connectez-vous à la console RAM et choisissez Permissions > Policies dans le volet de navigation de gauche.

   2. Cliquez sur Create Policy, sélectionnez l’onglet JSON et ajoutez la politique suivante :

      {
          "Version": "1",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "cs:*",
                      "log:GetProject",
                      "log:GetLogStore",
                      "log:GetConfig",
                      "log:GetMachineGroup",
                      "log:GetAppliedMachineGroups",
                      "log:GetAppliedConfigs",
                      "log:GetIndex",
                      "log:GetSavedSearch",
                      "log:GetDashboard",
                      "log:GetJob",
                      "ecs:DescribeInstances",
                      "ecs:DescribeSpotPriceHistory",
                      "ecs:DescribePrice",
                      "eci:DescribeContainerGroups",
                      "eci:DescribeContainerGroupPrice",
                      "log:GetLogStoreLogs",
                      "ims:CreateApplication",
                      "ims:UpdateApplication",
                      "ims:GetApplication",
                      "ims:ListApplications",
                      "ims:DeleteApplication",
                      "ims:CreateAppSecret",
                      "ims:GetAppSecret",
                      "ims:ListAppSecretIds",
                      "ims:ListUsers"
                  ],
                  "Resource": "*"
              }
          ]
      }

   3. Nommez la politique k8sWorkerRolePolicy-{ClusterID} et cliquez sur OK.

2. Associez la politique au rôle worker du cluster.

   1. Dans la console RAM, choisissez Identities > Roles et recherchez KubernetesWorkerRole-{ClusterID}.

   2. Cliquez sur Grant Permission.

   3. Dans Select Policy, cliquez sur Custom Policy, recherchez k8sWorkerRolePolicy-{ClusterID}, sélectionnez-la et cliquez sur OK.

Finaliser la configuration du tableau de bord IA

1. Sur la page Cloud-native AI Suite, sélectionnez Sample Console pour Interaction Mode. Une boîte de dialogue Note s’affiche.

   • Si Authorized s’affiche, passez à l’étape 3.

   • Si Unauthorized apparaît en rouge, complétez les autorisations RAM ci-dessus et cliquez sur Authorization Check. Après l’autorisation, Authorized s’affiche.

2. Définissez Console Data Storage : Pre-installed MySQL pour les tests ou ApsaraDB RDS pour la production. Consultez la section Installer et configurer le tableau de bord IA et la console de développement IA.

3. Cliquez sur Deploy Cloud-native AI Suite. Le tableau de bord IA est prêt lorsque son statut indique Ready.

(Facultatif) Créer et accélérer un jeu de données

Montez des jeux de données depuis Object Storage Service (OSS) en tant que volumes persistants (PV) et accélérez l’accès dans le tableau de bord IA.

Créer un PV et un PVC

1. Créez un namespace :

   kubectl create ns demo-ns

2. Créez un fichier nommé fashion-mnist.yaml :

   Espace réservé	Description	Exemple
   fashion-mnist	Nom du bucket OSS	my-dataset-bucket
   oss-cn-beijing.aliyuncs.com	Endpoint OSS pour la région du bucket	oss-cn-hangzhou.aliyuncs.com
   AKID	AccessKey ID	LTAI5tXxx
   AKSECRET	Secret AccessKey	xXxXxXx

   apiVersion: v1
   kind: PersistentVolume
   metadata:
     name: fashion-demo-pv
   spec:
     accessModes:
     - ReadWriteMany
     capacity:
       storage: 10Gi
     csi:
       driver: ossplugin.csi.alibabacloud.com
       volumeAttributes:
         bucket: fashion-mnist
         otherOpts: "-o max_stat_cache_size=0 -o allow_other"
         url: oss-cn-beijing.aliyuncs.com
         akId: "AKID"
         akSecret: "AKSECRET"
       volumeHandle: fashion-demo-pv
     persistentVolumeReclaimPolicy: Retain
     storageClassName: oss
     volumeMode: Filesystem
   ---
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: fashion-demo-pvc
     namespace: demo-ns
   spec:
     accessModes:
     - ReadWriteMany
     resources:
       requests:
         storage: 10Gi
     selector:
       matchLabels:
         alicloud-pvname: fashion-demo-pv
     storageClassName: oss
     volumeMode: Filesystem
     volumeName: fashion-demo-pv

   Remplacez ces espaces réservés :

3. Appliquez le manifeste :

   kubectl create -f fashion-mnist.yaml

4. Vérifiez que le PV et le PVC sont liés :

   kubectl get pv fashion-demo-pv
   kubectl get pvc fashion-demo-pvc -n demo-ns

   Sortie attendue pour le PV :

   NAME              CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                        STORAGECLASS   AGE
   fashion-demo-pv   10Gi       RWX            Retain           Bound    demo-ns/fashion-demo-pvc     oss            8h

   Sortie attendue pour le PVC :

   NAME               STATUS   VOLUME            CAPACITY   ACCESS MODES   STORAGECLASS   AGE
   fashion-demo-pvc   Bound    fashion-demo-pv   10Gi       RWX            oss            8h

Accelerate the dataset

1. Connectez-vous au tableau de bord IA en tant qu’administrateur.

2. Choisissez Dataset > Dataset List dans le volet de navigation de gauche.

3. Recherchez le jeu de données (fashion-demo-pvc) et cliquez sur Accelerate dans la colonne Actions.

   

Tableau de bord du cluster

Le tableau de bord IA ouvre par défaut le tableau de bord du cluster, affichant l’état global des GPU et leur allocation dans le cluster.

GPU Utilization indique si le GPU a exécuté une charge de travail pendant la fenêtre d’échantillonnage, et non son efficacité. Un nœud à 100 % peut exécuter des noyaux légers plutôt que des charges de travail parallèles intensives. Combinez cette métrique avec GPU Memory (Used/Total) pour obtenir une image plus complète.

Tableau de bord des nœuds

Cliquez sur Nodes dans le coin supérieur droit de la page Cluster pour afficher les métriques GPU par nœud et par dispositif GPU.

Tableau de bord des jobs d’entraînement

Cliquez sur TrainingJobs dans le coin supérieur droit de la page Nodes pour afficher la consommation de ressources et l’efficacité des GPU par job.

Tableau de bord des quotas de ressources

Cliquez sur Quota dans le coin supérieur droit de la page Training Jobs pour afficher la consommation de quotas par type de ressource (CPU, mémoire, nvidia.com/gpu, aliyun.com/gpu-mem, aliyun.com/gpu).

Configurer une arborescence de quotas

1. Créez des namespaces pour chaque équipe. Les namespaces existants ne doivent contenir aucun pod en cours d’exécution avant d’être associés à un nœud de quota.

   kubectl create ns namespace1
   kubectl create ns namespace2
   kubectl create ns namespace3
   kubectl create ns namespace4

2. Dans le tableau de bord IA, créez des nœuds de quota et associez chaque nœud feuille à un namespace. Définissez Min et Max pour chaque nœud.

Créer des utilisateurs et des groupes d’utilisateurs

Un utilisateur peut appartenir à plusieurs groupes, et un groupe peut contenir plusieurs utilisateurs. Associez les utilisateurs aux groupes pour leur accorder l’accès aux ressources allouées.

1. Créez un utilisateur. Consultez la section Générer le fichier kubeconfig et le jeton de connexion pour un nouvel utilisateur.

2. Créez un groupe d’utilisateurs. Consultez la section Ajouter un groupe d’utilisateurs.

Exemple de planification de capacité

Cet exemple montre comment le planificateur partage et reprend les ressources CPU entre quatre namespaces. L’arborescence de quotas présente la structure suivante :

Configuration des quotas :

Parcours :

Sans quotas élastiques, chaque namespace feuille utilise uniquement son Min (10 cœurs = 2 pods à 5 cœurs/pod). Avec des quotas élastiques et 40 cœurs de cluster disponibles, les namespaces empruntent la capacité inutilisée jusqu’à leur Max.

Étape 1 : Déployez cinq pods dans namespace1, chacun demandant 5 cœurs CPU (25 cœurs au total).

Avec root.a.1 Max défini sur 20 cœurs, 4 pods s’exécutent (20 cœurs). Le cinquième pod reste en état Pending.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx1
  namespace: namespace1
  labels:
    app: nginx1
spec:
  replicas: 5
  selector:
    matchLabels:
      app: nginx1
  template:
    metadata:
      name: nginx1
      labels:
        app: nginx1
    spec:
      containers:
      - name: nginx1
        image: nginx
        resources:
          limits:
            cpu: 5
          requests:
            cpu: 5

Étape 2 : Déployez cinq pods dans namespace2, chacun demandant 5 cœurs CPU.

Avec 20 cœurs restants (40 - 20 de namespace1), 4 pods s’exécutent. Le cinquième reste en état Pending. namespace1 et namespace2 consomment désormais tous les 40 cœurs racine.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  namespace: namespace2
  labels:
    app: nginx2
spec:
  replicas: 5
  selector:
    matchLabels:
      app: nginx2
  template:
    metadata:
      name: nginx2
      labels:
        app: nginx2
    spec:
      containers:
      - name: nginx2
        image: nginx
        resources:
          limits:
            cpu: 5
          requests:
            cpu: 5

Étape 3 : Déployez cinq pods dans namespace3, chacun demandant 5 cœurs CPU.

Aucune capacité inutilisée ne reste. Le planificateur reprend 10 cœurs de root.a pour garantir le minimum de root.b.1. Il reprend 5 cœurs de root.a.1 (réduisant namespace1 de 4 pods en cours d’exécution à 3) et 5 cœurs de root.a.2 (réduisant namespace2 de 4 pods en cours d’exécution à 3). Avec 10 cœurs récupérés, 2 pods s’exécutent dans namespace3.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx3
  namespace: namespace3
  labels:
    app: nginx3
spec:
  replicas: 5
  selector:
    matchLabels:
      app: nginx3
  template:
    metadata:
      name: nginx3
      labels:
        app: nginx3
    spec:
      containers:
      - name: nginx3
        image: nginx
        resources:
          limits:
            cpu: 5
          requests:
            cpu: 5

Étape 4 : Déployez cinq pods dans namespace4, chacun demandant 5 cœurs CPU.

Le planificateur reprend 10 autres cœurs de root.a pour garantir le minimum de root.b.2 : 5 cœurs de root.a.1 et 5 de root.a.2. Après la reprise, namespace1 et namespace2 disposent chacun de 2 pods en cours d’exécution (10 cœurs), et namespace4 obtient 2 pods en cours d’exécution.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx4
  namespace: namespace4
  labels:
    app: nginx4
spec:
  replicas: 5
  selector:
    matchLabels:
      app: nginx4
  template:
    metadata:
      name: nginx4
      labels:
        app: nginx4
    spec:
      containers:
      - name: nginx4
        image: nginx
        resources:
          limits:
            cpu: 5
          requests:
            cpu: 5

Résultat :

La garantie minimale de chaque équipe a été honorée. La capacité empruntée a été reprise lorsque les autres équipes ont eu besoin de récupérer leurs minimums.