Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Défaillances d'installation de l'opérateur d'inférence via AWS la CLI
<a name="sagemaker-hyperpod-model-deployment-ts-cli"></a>

**Présentation :** lors de l'installation de l'opérateur d'inférence via la AWS CLI, l'installation du module complémentaire peut échouer en raison de dépendances manquantes. Cette section couvre les scénarios courants d'échec de l'installation de la CLI et leurs solutions.

## L'installation du module complémentaire d'inférence a échoué en raison de l'absence de pilotes CSI
<a name="sagemaker-hyperpod-model-deployment-ts-missing-csi-drivers"></a>

**Problème :** La création du module complémentaire d'opérateur d'inférence échoue car les dépendances du pilote CSI requises ne sont pas installées sur le cluster EKS.

**Symptômes et diagnostic :**

**Messages d'erreur :**

Les erreurs suivantes apparaissent dans les journaux de création des modules complémentaires ou dans les journaux des opérateurs d'inférence :

```
S3 CSI driver not installed (missing CSIDriver s3.csi.aws.com). 
Please install the required CSI driver and see the troubleshooting guide for more information.

FSx CSI driver not installed (missing CSIDriver fsx.csi.aws.com). 
Please install the required CSI driver and see the troubleshooting guide for more information.
```

**Étapes de diagnostic :**

1. Vérifiez si les pilotes CSI sont installés :

   ```
   # Check for S3 CSI driver
   kubectl get csidriver s3.csi.aws.com
   kubectl get pods -n kube-system | grep mountpoint
   
   # Check for FSx CSI driver  
   kubectl get csidriver fsx.csi.aws.com
   kubectl get pods -n kube-system | grep fsx
   ```

1. Vérifiez l'état du module EKS :

   ```
   # List all add-ons
   aws eks list-addons --cluster-name $EKS_CLUSTER_NAME --region $REGION
   
   # Check specific CSI driver add-ons
   aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name aws-mountpoint-s3-csi-driver --region $REGION 2>/dev/null || echo "S3 CSI driver not installed"
   aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name aws-fsx-csi-driver --region $REGION 2>/dev/null || echo "FSx CSI driver not installed"
   ```

1. Vérifiez l'état du module complémentaire de l'opérateur d'inférence :

   ```
   aws eks describe-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION \
       --query "addon.{Status:status,Health:health,Issues:issues}" \
       --output json
   ```

**Résolution :**

**Étape 1 : Installation du pilote S3 CSI manquant**

1. Créez un rôle IAM pour le pilote S3 CSI (s'il n'est pas déjà créé) :

   ```
   # Set up service account role ARN (from installation steps)
   export S3_CSI_ROLE_ARN=$(aws iam get-role --role-name $S3_CSI_ROLE_NAME --query 'Role.Arn' --output text 2>/dev/null || echo "Role not found")
   echo "S3 CSI Role ARN: $S3_CSI_ROLE_ARN"
   ```

1. Installez le module complémentaire du pilote S3 CSI :

   ```
   aws eks create-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name aws-mountpoint-s3-csi-driver \
       --addon-version v1.14.1-eksbuild.1 \
       --service-account-role-arn $S3_CSI_ROLE_ARN \
       --region $REGION
   ```

1. Vérifiez l'installation du pilote S3 CSI :

   ```
   # Wait for add-on to be active
   aws eks wait addon-active --cluster-name $EKS_CLUSTER_NAME --addon-name aws-mountpoint-s3-csi-driver --region $REGION
   
   # Verify CSI driver is available
   kubectl get csidriver s3.csi.aws.com
   kubectl get pods -n kube-system | grep mountpoint
   ```

**Étape 2 : Installation du pilote FSx CSI manquant**

1. Créez un rôle IAM pour le pilote FSx CSI (s'il n'est pas déjà créé) :

   ```
   # Set up service account role ARN (from installation steps)
   export FSX_CSI_ROLE_ARN=$(aws iam get-role --role-name $FSX_CSI_ROLE_NAME --query 'Role.Arn' --output text 2>/dev/null || echo "Role not found")
   echo "FSx CSI Role ARN: $FSX_CSI_ROLE_ARN"
   ```

1. Installez le module complémentaire du pilote FSx CSI :

   ```
   aws eks create-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name aws-fsx-csi-driver \
       --addon-version v1.6.0-eksbuild.1 \
       --service-account-role-arn $FSX_CSI_ROLE_ARN \
       --region $REGION
   
   # Wait for add-on to be active
   aws eks wait addon-active --cluster-name $EKS_CLUSTER_NAME --addon-name aws-fsx-csi-driver --region $REGION
   
   # Verify FSx CSI driver is running
   kubectl get pods -n kube-system | grep fsx
   ```

**Étape 3 : vérifier toutes les dépendances**

Après avoir installé les dépendances manquantes, vérifiez qu'elles fonctionnent correctement avant de réessayer l'installation de l'opérateur d'inférence :

```
# Check all required add-ons are active
aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name aws-mountpoint-s3-csi-driver --region $REGION
aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name aws-fsx-csi-driver --region $REGION
aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name metrics-server --region $REGION
aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name cert-manager --region $REGION

# Verify all pods are running
kubectl get pods -n kube-system | grep -E "(mountpoint|fsx|metrics-server)"
kubectl get pods -n cert-manager
```

## Inférence : les définitions de ressources personnalisées sont manquantes lors du déploiement du modèle
<a name="sagemaker-hyperpod-model-deployment-ts-crd-not-exist"></a>

**Problème :** les définitions de ressources personnalisées (CRDs) sont manquantes lorsque vous essayez de créer des déploiements de modèles. Ce problème se produit lorsque vous avez précédemment installé et supprimé le module complémentaire d'inférence sans nettoyer les déploiements de modèles dotés de finaliseurs.

**Symptômes et diagnostic :**

**Cause première :**

Si vous supprimez le module complémentaire d'inférence sans supprimer au préalable tous les déploiements de modèles, les ressources personnalisées dotées de finaliseurs restent dans le cluster. Ces finaliseurs doivent être terminés avant que vous puissiez supprimer le. CRDs Le processus de suppression du module complémentaire n'attend pas la fin de la suppression du CRD, ce qui le CRDs maintient dans un état de terminaison et empêche de nouvelles installations.

**Pour diagnostiquer ce problème**

1. Vérifiez s'ils CRDs existent.

   ```
   kubectl get crd | grep inference.sagemaker.aws.amazon.com
   ```

1. Vérifiez les ressources personnalisées bloquées.

   ```
   # Check for JumpStartModel resources
   kubectl get jumpstartmodels -A
   
   # Check for InferenceEndpointConfig resources
   kubectl get inferenceendpointconfigs -A
   ```

1. Inspectez les finaliseurs sur les ressources bloquées.

   ```
   # Example for a specific JumpStartModel
   kubectl get jumpstartmodels <model-name> -n <namespace> -o jsonpath='{.metadata.finalizers}'
   
   # Example for a specific InferenceEndpointConfig
   kubectl get inferenceendpointconfigs <config-name> -n <namespace> -o jsonpath='{.metadata.finalizers}'
   ```

**Résolution :**

Supprimez manuellement les finaliseurs de tous les déploiements de modèles qui n'ont pas été supprimés lorsque vous avez supprimé le module complémentaire d'inférence. Procédez comme suit pour chaque ressource personnalisée bloquée.

**Pour supprimer les finaliseurs des ressources JumpStartModel **

1. Répertoriez toutes les JumpStartModel ressources dans tous les espaces de noms.

   ```
   kubectl get jumpstartmodels -A
   ```

1. Pour chaque JumpStartModel ressource, supprimez les finaliseurs en appliquant un correctif à la ressource pour définir metadata.finalizers sur un tableau vide.

   ```
   kubectl patch jumpstartmodels <model-name> -n <namespace> -p '{"metadata":{"finalizers":[]}}' --type=merge
   ```

   L'exemple suivant montre comment appliquer un correctif à une ressource nommée kv-l1-only.

   ```
   kubectl patch jumpstartmodels kv-l1-only -n default -p '{"metadata":{"finalizers":[]}}' --type=merge
   ```

1. Vérifiez que l'instance du modèle est supprimée.

   ```
   kubectl get jumpstartmodels -A
   ```

   Lorsque toutes les ressources sont nettoyées, vous devriez voir le résultat suivant.

   ```
   Error from server (NotFound): Unable to list "inference.sagemaker.aws.amazon.com/v1, Resource=jumpstartmodels": the server could not find the requested resource (get jumpstartmodels.inference.sagemaker.aws.amazon.com)
   ```

1. Vérifiez que le JumpStartModel CRD est retiré.

   ```
   kubectl get crd | grep jumpstartmodels.inference.sagemaker.aws.amazon.com
   ```

   Si le CRD est correctement supprimé, cette commande ne renvoie aucune sortie.

**Pour supprimer les finaliseurs des ressources InferenceEndpointConfig **

1. Répertoriez toutes les InferenceEndpointConfig ressources dans tous les espaces de noms.

   ```
   kubectl get inferenceendpointconfigs -A
   ```

1. Pour chaque InferenceEndpointConfig ressource, supprimez les finaliseurs.

   ```
   kubectl patch inferenceendpointconfigs <config-name> -n <namespace> -p '{"metadata":{"finalizers":[]}}' --type=merge
   ```

   L'exemple suivant montre comment appliquer un correctif à une ressource nommée my-inference-config.

   ```
   kubectl patch inferenceendpointconfigs my-inference-config -n default -p '{"metadata":{"finalizers":[]}}' --type=merge
   ```

1. Vérifiez que l'instance de configuration est supprimée.

   ```
   kubectl get inferenceendpointconfigs -A
   ```

   Lorsque toutes les ressources sont nettoyées, vous devriez voir le résultat suivant.

   ```
   Error from server (NotFound): Unable to list "inference.sagemaker.aws.amazon.com/v1, Resource=inferenceendpointconfigs": the server could not find the requested resource (get inferenceendpointconfigs.inference.sagemaker.aws.amazon.com)
   ```

1. Vérifiez que le InferenceEndpointConfig CRD est retiré.

   ```
   kubectl get crd | grep inferenceendpointconfigs.inference.sagemaker.aws.amazon.com
   ```

   Si le CRD est correctement supprimé, cette commande ne renvoie aucune sortie.

**Pour réinstaller le module complémentaire d'inférence**

Après avoir nettoyé toutes les ressources bloquées et vérifié qu' CRDs elles sont supprimées, réinstallez le module complémentaire d'inférence. Pour de plus amples informations, veuillez consulter [Installation de l'opérateur d'inférence avec le module complémentaire EKS](sagemaker-hyperpod-model-deployment-setup.md#sagemaker-hyperpod-model-deployment-setup-install-inference-operator-addon).

**Vérification :**

1. Vérifiez que le module complémentaire d'inférence est correctement installé.

   ```
   aws eks describe-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION \
       --query "addon.{Status:status,Health:health}" \
       --output table
   ```

   Le statut doit être ACTIF et la santé doit être SAINE.

1. Vérifiez qu' CRDs ils sont correctement installés.

   ```
   kubectl get crd | grep inference.sagemaker.aws.amazon.com
   ```

   Vous devriez voir les informations relatives à l'inférence CRDs répertoriées dans la sortie.

1. Testez la création d'un nouveau modèle de déploiement pour confirmer que le problème est résolu.

   ```
   # Create a test deployment using your preferred method
   kubectl apply -f <your-model-deployment.yaml>
   ```

**Prévention** :

Pour éviter ce problème, effectuez les étapes suivantes avant de désinstaller le module complémentaire d'inférence.

1. Supprimez tous les déploiements de modèles.

   ```
   # Delete all JumpStartModel resources
   kubectl delete jumpstartmodels --all -A
   
   # Delete all InferenceEndpointConfig resources
   kubectl delete inferenceendpointconfigs --all -A
   
   # Wait for all resources to be fully deleted
   kubectl get jumpstartmodels -A
   kubectl get inferenceendpointconfigs -A
   ```

1. Vérifiez que toutes les ressources personnalisées sont supprimées.

1. Après avoir confirmé que toutes les ressources sont nettoyées, supprimez le module complémentaire d'inférence.

## L'installation du module complémentaire d'inférence a échoué en raison de l'absence du gestionnaire de certificats
<a name="sagemaker-hyperpod-model-deployment-ts-missing-cert-manager"></a>

**Problème :** La création du module complémentaire d'opérateur d'inférence échoue car le module complémentaire EKS de cert-manager n'est pas installé, ce qui entraîne l'absence de définitions de ressources personnalisées (). CRDs

**Symptômes et diagnostic :**

**Messages d'erreur :**

Les erreurs suivantes apparaissent dans les journaux de création des modules complémentaires ou dans les journaux des opérateurs d'inférence :

```
Missing required CRD: certificaterequests.cert-manager.io. 
The cert-manager add-on is not installed. Please install cert-manager and see the troubleshooting guide for more information.
```

**Étapes de diagnostic :**

1. Vérifiez si cert-manager est installé :

   ```
   # Check for cert-manager CRDs
   kubectl get crd | grep cert-manager
   kubectl get pods -n cert-manager
   
   # Check EKS add-on status
   aws eks describe-addon --cluster-name $EKS_CLUSTER_NAME --addon-name cert-manager --region $REGION 2>/dev/null || echo "Cert-manager not installed"
   ```

1. Vérifiez l'état du module complémentaire de l'opérateur d'inférence :

   ```
   aws eks describe-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION \
       --query "addon.{Status:status,Health:health,Issues:issues}" \
       --output json
   ```

**Résolution :**

**Étape 1 : Installation du module complémentaire cert-manager**

1. Installez le module complémentaire EKS cert-manager :

   ```
   aws eks create-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name cert-manager \
       --addon-version v1.18.2-eksbuild.2 \
       --region $REGION
   ```

1. Vérifiez l'installation du gestionnaire de certificats :

   ```
   # Wait for add-on to be active
   aws eks wait addon-active --cluster-name $EKS_CLUSTER_NAME --addon-name cert-manager --region $REGION
   
   # Verify cert-manager pods are running
   kubectl get pods -n cert-manager
   
   # Verify CRDs are installed
   kubectl get crd | grep cert-manager | wc -l
   # Expected: Should show multiple cert-manager CRDs
   ```

**Étape 2 : Réessayer d'installer l'opérateur d'inférence**

1. Une fois le gestionnaire de certificats installé, réessayez d'installer l'opérateur d'inférence :

   ```
   # Delete the failed add-on if it exists
   aws eks delete-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION 2>/dev/null || echo "Add-on not found, proceeding with installation"
   
   # Wait for deletion to complete
   sleep 30
   
   # Reinstall the inference operator add-on
   aws eks create-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --addon-version v1.0.0-eksbuild.1 \
       --configuration-values file://addon-config.json \
       --region $REGION
   ```

1. Surveillez l'installation :

   ```
   # Check installation status
   aws eks describe-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION \
       --query "addon.{Status:status,Health:health}" \
       --output table
   
   # Verify inference operator pods are running
   kubectl get pods -n hyperpod-inference-system
   ```

## L'installation du module complémentaire d'inférence a échoué en raison de l'absence d'un contrôleur ALB
<a name="sagemaker-hyperpod-model-deployment-ts-missing-alb"></a>

**Problème :** La création du module complémentaire d'opérateur d'inférence échoue car le AWS Load Balancer Controller n'est pas installé ou n'est pas correctement configuré pour le module complémentaire d'inférence.

**Symptômes et diagnostic :**

**Messages d'erreur :**

Les erreurs suivantes apparaissent dans les journaux de création des modules complémentaires ou dans les journaux des opérateurs d'inférence :

```
ALB Controller not installed (missing aws-load-balancer-controller pods). 
Please install the Application Load Balancer Controller and see the troubleshooting guide for more information.
```

**Étapes de diagnostic :**

1. Vérifiez si le contrôleur ALB est installé :

   ```
   # Check for ALB Controller pods
   kubectl get pods -n kube-system | grep aws-load-balancer-controller
   kubectl get pods -n hyperpod-inference-system | grep aws-load-balancer-controller
   
   # Check ALB Controller service account
   kubectl get serviceaccount aws-load-balancer-controller -n kube-system 2>/dev/null || echo "ALB Controller service account not found"
   kubectl get serviceaccount aws-load-balancer-controller -n hyperpod-inference-system 2>/dev/null || echo "ALB Controller service account not found in inference namespace"
   ```

1. Vérifiez la configuration du module complémentaire de l'opérateur d'inférence :

   ```
   aws eks describe-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION \
       --query "addon.{Status:status,Health:health,ConfigurationValues:configurationValues}" \
       --output json
   ```

**Résolution :**

Choisissez l'une des options suivantes en fonction de votre configuration :

**Option 1 : laisser le module complémentaire d'inférence installer le contrôleur ALB (recommandé)**
+ Assurez-vous que le rôle ALB est créé et correctement configuré dans la configuration de votre module complémentaire :

  ```
  # Verify ALB role exists
  export ALB_ROLE_ARN=$(aws iam get-role --role-name alb-role --query 'Role.Arn' --output text 2>/dev/null || echo "Role not found")
  echo "ALB Role ARN: $ALB_ROLE_ARN"
  
  # Update your addon-config.json to enable ALB
  cat > addon-config.json << EOF
  {
    "executionRoleArn": "$EXECUTION_ROLE_ARN",
    "tlsCertificateS3Bucket": "$BUCKET_NAME",
    "hyperpodClusterArn": "$HYPERPOD_CLUSTER_ARN",
    "alb": {
      "enabled": true,
      "serviceAccount": {
        "create": true,
        "roleArn": "$ALB_ROLE_ARN"
      }
    },
    "keda": {
      "auth": {
        "aws": {
          "irsa": {
            "roleArn": "$KEDA_ROLE_ARN"
          }
        }
      }
    }
  }
  EOF
  ```

**Option 2 : utiliser l'installation existante du contrôleur ALB**
+ Si ALB Controller est déjà installé, configurez le module complémentaire pour utiliser l'installation existante :

  ```
  # Update your addon-config.json to disable ALB installation
  cat > addon-config.json << EOF
  {
    "executionRoleArn": "$EXECUTION_ROLE_ARN",
    "tlsCertificateS3Bucket": "$BUCKET_NAME",
    "hyperpodClusterArn": "$HYPERPOD_CLUSTER_ARN",
    "alb": {
      "enabled": false
    },
    "keda": {
      "auth": {
        "aws": {
          "irsa": {
            "roleArn": "$KEDA_ROLE_ARN"
          }
        }
      }
    }
  }
  EOF
  ```

**Étape 3 : Réessayer d'installer l'opérateur d'inférence**

1. Réinstallez le module complémentaire d'opérateur d'inférence avec la configuration mise à jour :

   ```
   # Delete the failed add-on if it exists
   aws eks delete-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION 2>/dev/null || echo "Add-on not found, proceeding with installation"
   
   # Wait for deletion to complete
   sleep 30
   
   # Reinstall with updated configuration
   aws eks create-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --addon-version v1.0.0-eksbuild.1 \
       --configuration-values file://addon-config.json \
       --region $REGION
   ```

1. Vérifiez que le contrôleur ALB fonctionne :

   ```
   # Check ALB Controller pods
   kubectl get pods -n hyperpod-inference-system | grep aws-load-balancer-controller
   kubectl get pods -n kube-system | grep aws-load-balancer-controller
   
   # Check service account annotations
   kubectl describe serviceaccount aws-load-balancer-controller -n hyperpod-inference-system 2>/dev/null
   kubectl describe serviceaccount aws-load-balancer-controller -n kube-system 2>/dev/null
   ```

## L'installation du module complémentaire d'inférence a échoué en raison de l'absence d'un opérateur KEDA
<a name="sagemaker-hyperpod-model-deployment-ts-missing-keda"></a>

**Problème :** La création du module complémentaire d'opérateur d'inférence échoue car l'opérateur KEDA (Kubernetes Event Driven Autoscaler) n'est pas installé ou n'est pas correctement configuré pour le module complémentaire d'inférence.

**Symptômes et diagnostic :**

**Messages d'erreur :**

Les erreurs suivantes apparaissent dans les journaux de création des modules complémentaires ou dans les journaux des opérateurs d'inférence :

```
KEDA operator not installed (missing keda-operator pods). 
KEDA can be installed separately in any namespace or via the Inference addon.
```

**Étapes de diagnostic :**

1. Vérifiez si l'opérateur KEDA est installé :

   ```
   # Check for KEDA operator pods in common namespaces
   kubectl get pods -n keda-system | grep keda-operator 2>/dev/null || echo "KEDA not found in keda-system namespace"
   kubectl get pods -n kube-system | grep keda-operator 2>/dev/null || echo "KEDA not found in kube-system namespace"
   kubectl get pods -n hyperpod-inference-system | grep keda-operator 2>/dev/null || echo "KEDA not found in inference namespace"
   
   # Check for KEDA CRDs
   kubectl get crd | grep keda 2>/dev/null || echo "KEDA CRDs not found"
   
   # Check KEDA service account
   kubectl get serviceaccount keda-operator -A 2>/dev/null || echo "KEDA service account not found"
   ```

1. Vérifiez la configuration du module complémentaire de l'opérateur d'inférence :

   ```
   aws eks describe-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION \
       --query "addon.{Status:status,Health:health,ConfigurationValues:configurationValues}" \
       --output json
   ```

**Résolution :**

Choisissez l'une des options suivantes en fonction de votre configuration :

**Option 1 : laisser le module complémentaire d'inférence installer KEDA (recommandé)**
+ Assurez-vous que le rôle KEDA est créé et correctement configuré dans la configuration de votre module complémentaire :

  ```
  # Verify KEDA role exists
  export KEDA_ROLE_ARN=$(aws iam get-role --role-name keda-operator-role --query 'Role.Arn' --output text 2>/dev/null || echo "Role not found")
  echo "KEDA Role ARN: $KEDA_ROLE_ARN"
  
  # Update your addon-config.json to enable KEDA
  cat > addon-config.json << EOF
  {
    "executionRoleArn": "$EXECUTION_ROLE_ARN",
    "tlsCertificateS3Bucket": "$BUCKET_NAME",
    "hyperpodClusterArn": "$HYPERPOD_CLUSTER_ARN",
    "alb": {
      "serviceAccount": {
        "create": true,
        "roleArn": "$ALB_ROLE_ARN"
      }
    },
    "keda": {
      "enabled": true,
      "auth": {
        "aws": {
          "irsa": {
            "roleArn": "$KEDA_ROLE_ARN"
          }
        }
      }
    }
  }
  EOF
  ```

**Option 2 : Utiliser l'installation KEDA existante**
+ Si KEDA est déjà installé, configurez le module complémentaire pour utiliser l'installation existante :

  ```
  # Update your addon-config.json to disable KEDA installation
  cat > addon-config.json << EOF
  {
    "executionRoleArn": "$EXECUTION_ROLE_ARN",
    "tlsCertificateS3Bucket": "$BUCKET_NAME",
    "hyperpodClusterArn": "$HYPERPOD_CLUSTER_ARN",
    "alb": {
      "serviceAccount": {
        "create": true,
        "roleArn": "$ALB_ROLE_ARN"
      }
    },
    "keda": {
      "enabled": false
    }
  }
  EOF
  ```

**Étape 3 : Réessayer d'installer l'opérateur d'inférence**

1. Réinstallez le module complémentaire d'opérateur d'inférence avec la configuration mise à jour :

   ```
   # Delete the failed add-on if it exists
   aws eks delete-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --region $REGION 2>/dev/null || echo "Add-on not found, proceeding with installation"
   
   # Wait for deletion to complete
   sleep 30
   
   # Reinstall with updated configuration
   aws eks create-addon \
       --cluster-name $EKS_CLUSTER_NAME \
       --addon-name amazon-sagemaker-hyperpod-inference \
       --addon-version v1.0.0-eksbuild.1 \
       --configuration-values file://addon-config.json \
       --region $REGION
   ```

1. Vérifiez que KEDA fonctionne :

   ```
   # Check KEDA pods
   kubectl get pods -n hyperpod-inference-system | grep keda
   kubectl get pods -n kube-system | grep keda
   kubectl get pods -n keda-system | grep keda 2>/dev/null
   
   # Check KEDA CRDs
   kubectl get crd | grep scaledobjects
   kubectl get crd | grep scaledjobs
   
   # Check KEDA service account annotations
   kubectl describe serviceaccount keda-operator -n hyperpod-inference-system 2>/dev/null
   kubectl describe serviceaccount keda-operator -n kube-system 2>/dev/null
   kubectl describe serviceaccount keda-operator -n keda-system 2>/dev/null
   ```