Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Inferenza degli errori di installazione da parte dell'operatore tramite AWS CLI
<a name="sagemaker-hyperpod-model-deployment-ts-cli"></a>

**Panoramica: ** quando si installa l'operatore di inferenza tramite la AWS CLI, l'installazione del componente aggiuntivo potrebbe non riuscire a causa della mancanza di dipendenze. Questa sezione illustra gli scenari più comuni di errore di installazione della CLI e le relative risoluzioni.

## L'installazione del componente aggiuntivo Inference non è riuscita a causa della mancanza di driver CSI
<a name="sagemaker-hyperpod-model-deployment-ts-missing-csi-drivers"></a>

**Problema: ** la creazione del componente aggiuntivo per operatori di inferenza non riesce perché le dipendenze dei driver CSI richieste non sono installate nel cluster EKS.

**Sintomi e diagnosi: **

**Messaggi di errore: **

I seguenti errori vengono visualizzati nei registri di creazione del componente aggiuntivo o nei registri degli operatori di inferenza:

```
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.
```

**Fasi diagnostiche: **

1. Controlla se i driver CSI sono installati:

   ```
   # 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. Controlla lo stato del componente aggiuntivo 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. Controlla lo stato del componente aggiuntivo dell'operatore di inferenza:

   ```
   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
   ```

**Risoluzione:**

**Passaggio 1: installa il driver S3 CSI mancante **

1. Crea il ruolo IAM per il driver S3 CSI (se non è già stato creato):

   ```
   # 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. Installa il componente aggiuntivo del driver 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. Verifica l'installazione del driver 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
   ```

**Passaggio 2: installare il driver FSx CSI mancante **

1. Crea il ruolo IAM per il driver FSx CSI (se non è già stato creato):

   ```
   # 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. Installa il componente aggiuntivo del driver 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
   ```

**Fase 3: Verifica tutte le dipendenze **

Dopo aver installato le dipendenze mancanti, verifica che funzionino correttamente prima di riprovare l'installazione dell'operatore di inferenza:

```
# 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
```

## Le definizioni delle risorse personalizzate di inferenza non sono presenti durante la distribuzione del modello
<a name="sagemaker-hyperpod-model-deployment-ts-crd-not-exist"></a>

**Problema: le definizioni di risorse ** personalizzate (CRD) mancano quando si tenta di creare distribuzioni di modelli. Questo problema si verifica quando in precedenza è stato installato ed eliminato il componente aggiuntivo di inferenza senza ripulire le distribuzioni dei modelli con finalizzatori.

**Sintomi e diagnosi: **

**Causa principale: **

Se si elimina il componente aggiuntivo di inferenza senza prima rimuovere tutte le distribuzioni del modello, le risorse personalizzate con finalizzatori rimangono nel cluster. Questi finalizzatori devono essere completati prima di poter eliminare i CRD. Il processo di eliminazione del componente aggiuntivo non attende il completamento dell'eliminazione dei CRD, il che fa sì che i CRD rimangano in uno stato di terminazione e impediscano nuove installazioni.

**Per diagnosticare questo problema **

1. Verifica se esistono CRD.

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

1. Verifica la presenza di risorse personalizzate bloccate.

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

1. Ispeziona i finalizzatori sulle risorse bloccate.

   ```
   # 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}'
   ```

**Risoluzione:**

Rimuovi manualmente i finalizzatori da tutte le distribuzioni del modello che non sono state eliminate quando hai rimosso il componente aggiuntivo di inferenza. Completa i passaggi seguenti per ogni risorsa personalizzata bloccata.

**Per rimuovere i finalizzatori dalle risorse JumpStartModel **

1. Elenca tutte le JumpStartModel risorse in tutti i namespace.

   ```
   kubectl get jumpstartmodels -A
   ```

1. Per ogni JumpStartModel risorsa, rimuovi i finalizzatori applicando una patch alla risorsa per impostare metadata.finalizers su un array vuoto.

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

   L'esempio seguente mostra come applicare una patch a una risorsa denominata kv-l1-only.

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

1. Verificate che l'istanza del modello sia eliminata.

   ```
   kubectl get jumpstartmodels -A
   ```

   Quando tutte le risorse sono state pulite, dovreste vedere il seguente risultato.

   ```
   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. Verifica che il JumpStartModel CRD sia stato rimosso.

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

   Se il CRD viene rimosso con successo, questo comando non restituisce alcun output.

**Per rimuovere i finalizzatori dalle risorse InferenceEndpointConfig **

1. Elenca tutte le InferenceEndpointConfig risorse in tutti i namespace.

   ```
   kubectl get inferenceendpointconfigs -A
   ```

1. Per ogni InferenceEndpointConfig risorsa, rimuovi i finalizzatori.

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

   L'esempio seguente mostra come applicare una patch a una risorsa denominata my-inference-config.

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

1. Verificate che l'istanza di configurazione sia eliminata.

   ```
   kubectl get inferenceendpointconfigs -A
   ```

   Quando tutte le risorse sono state pulite, dovresti vedere il seguente risultato.

   ```
   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. Verifica che il InferenceEndpointConfig CRD sia stato rimosso.

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

   Se il CRD viene rimosso con successo, questo comando non restituisce alcun output.

**Per reinstallare il componente aggiuntivo di inferenza **

Dopo aver ripulito tutte le risorse bloccate e verificato che i CRD siano stati rimossi, reinstallate il componente aggiuntivo di inferenza. Per ulteriori informazioni, consulta [Installazione dell'Inference Operator with EKS add-on](sagemaker-hyperpod-model-deployment-setup.md#sagemaker-hyperpod-model-deployment-setup-install-inference-operator-addon).

**Verifica: **

1. Verifica che il componente aggiuntivo di inferenza sia stato installato correttamente.

   ```
   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
   ```

   Lo stato deve essere ATTIVO e lo stato deve essere SANO.

1. Verificare che i CRD siano installati correttamente.

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

   Dovresti vedere i CRD relativi all'inferenza elencati nell'output.

1. Prova a creare un nuovo modello di distribuzione per confermare che il problema è stato risolto.

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

**Prevenzione:**

Per evitare questo problema, completa i passaggi seguenti prima di disinstallare il componente aggiuntivo di inferenza.

1. Elimina tutte le distribuzioni dei modelli.

   ```
   # 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. Verifica che tutte le risorse personalizzate vengano eliminate.

1. Dopo aver confermato che tutte le risorse sono state pulite, elimina il componente aggiuntivo di inferenza.

## L'installazione del componente aggiuntivo Inference non è riuscita a causa della mancanza di cert-manager
<a name="sagemaker-hyperpod-model-deployment-ts-missing-cert-manager"></a>

**Problema: ** la creazione del componente aggiuntivo per operatori di inferenza non riesce perché cert-manager EKS non Add-On è installato, con conseguente mancanza di Custom Resource Definitions (CRD).

**Sintomi e diagnosi: **

**Messaggi di errore: **

I seguenti errori vengono visualizzati nei registri di creazione del componente aggiuntivo o nei registri degli operatori di inferenza:

```
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.
```

**Fasi diagnostiche: **

1. Controlla se cert-manager è installato:

   ```
   # 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. Controlla lo stato del componente aggiuntivo dell'operatore di inferenza:

   ```
   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
   ```

**Risoluzione:**

**Passaggio 1: installa il componente aggiuntivo cert-manager **

1. Installa il componente aggiuntivo cert-manager EKS:

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

1. Verifica l'installazione di cert-manager:

   ```
   # 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
   ```

**Fase 2: Riprovare l'installazione dell'operatore di inferenza **

1. Dopo aver installato cert-manager, riprova l'installazione dell'operatore di inferenza:

   ```
   # 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. Monitora l'installazione:

   ```
   # 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'installazione del componente aggiuntivo Inference non è riuscita a causa della mancanza del controller ALB
<a name="sagemaker-hyperpod-model-deployment-ts-missing-alb"></a>

**Problema: ** la creazione del componente aggiuntivo per l'operatore di inferenza non riesce perché il AWS Load Balancer Controller non è installato o non è configurato correttamente per il componente aggiuntivo di inferenza.

**Sintomi e diagnosi: **

**Messaggi di errore: **

I seguenti errori vengono visualizzati nei registri di creazione del componente aggiuntivo o nei registri degli operatori di inferenza:

```
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.
```

**Fasi diagnostiche: **

1. Controlla se il controller ALB è installato:

   ```
   # 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. Controlla la configurazione del componente aggiuntivo dell'operatore di inferenza:

   ```
   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
   ```

**Risoluzione:**

Scegli una delle seguenti opzioni in base alla tua configurazione:

**Opzione 1: lascia che il componente aggiuntivo per l'inferenza installi ALB Controller (consigliato) **
+ Assicurati che il ruolo ALB sia stato creato e configurato correttamente nella configurazione del componente aggiuntivo:

  ```
  # 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
  ```

**Opzione 2: utilizzare l'installazione esistente del controller ALB **
+ Se hai già installato ALB Controller, configura il componente aggiuntivo per utilizzare l'installazione esistente:

  ```
  # 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
  ```

**Fase 3: Riprovare l'installazione dell'operatore di inferenza **

1. Reinstalla il componente aggiuntivo dell'operatore di inferenza con la configurazione aggiornata:

   ```
   # 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. Verifica che il controller ALB funzioni:

   ```
   # 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'installazione del componente aggiuntivo Inference non è riuscita a causa della mancanza dell'operatore KEDA
<a name="sagemaker-hyperpod-model-deployment-ts-missing-keda"></a>

**Problema: ** la creazione del componente aggiuntivo per l'operatore di inferenza non riesce perché l'operatore KEDA (Kubernetes Event Driven Autoscaler) non è installato o non è configurato correttamente per il componente aggiuntivo di inferenza.

**Sintomi e diagnosi: **

**Messaggi di errore: **

I seguenti errori vengono visualizzati nei registri di creazione del componente aggiuntivo o nei registri degli operatori di inferenza:

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

**Fasi diagnostiche: **

1. Verificare se l'operatore KEDA è installato:

   ```
   # 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. Verifica la configurazione del componente aggiuntivo dell'operatore di inferenza:

   ```
   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
   ```

**Risoluzione:**

Scegli una delle seguenti opzioni in base alla tua configurazione:

**Opzione 1: lascia che il componente aggiuntivo per l'inferenza installi KEDA (consigliato) **
+ Assicuratevi che il ruolo KEDA sia stato creato e configurato correttamente nella configurazione del componente aggiuntivo:

  ```
  # 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
  ```

**Opzione 2: utilizzare l'installazione KEDA esistente **
+ Se avete già installato KEDA, configurate il componente aggiuntivo per utilizzare l'installazione esistente:

  ```
  # 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
  ```

**Fase 3: Riprovare l'installazione dell'operatore di inferenza **

1. Reinstalla il componente aggiuntivo dell'operatore di inferenza con la configurazione aggiornata:

   ```
   # 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. Verifica che KEDA funzioni:

   ```
   # 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
   ```