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à.
# Configurazione dei HyperPod cluster per l'implementazione dei modelli
Questa guida mostra come abilitare le funzionalità di inferenza sui SageMaker HyperPod cluster Amazon. Configurerai l'infrastruttura, le autorizzazioni e gli operatori di cui gli ingegneri di machine learning hanno bisogno per implementare e gestire gli endpoint di inferenza.
**Nota**
Per creare un cluster con l'operatore di inferenza preinstallato, consulta. [Crea un cluster orchestrato da EKS SageMaker HyperPod](sagemaker-hyperpod-quickstart.md#sagemaker-hyperpod-quickstart-eks) Per installare l'operatore di inferenza su un cluster esistente, continuate con le seguenti procedure.
Puoi installare l'operatore di inferenza utilizzando la console SageMaker AI per un'esperienza semplificata o utilizzare la AWS CLI per un maggiore controllo. Questa guida copre entrambi i metodi di installazione.
## Metodo 1: installa il componente aggiuntivo HyperPod Inference tramite la console SageMaker AI (consigliato)
La console SageMaker AI offre l'esperienza più semplificata con due opzioni di installazione:
+ **Installazione rapida:** crea automaticamente tutte le risorse necessarie con impostazioni predefinite ottimizzate, inclusi ruoli IAM, bucket Amazon S3 e componenti aggiuntivi per le dipendenze. Verrà creato un nuovo dominio Studio con le autorizzazioni necessarie per distribuire un modello nel cluster pertinente. JumpStart Questa opzione è ideale per iniziare rapidamente con decisioni di configurazione minime.
+ **Installazione personalizzata:** offre la flessibilità necessaria per specificare le risorse esistenti o personalizzare le configurazioni mantenendo l'esperienza con un solo clic. I clienti possono scegliere di riutilizzare i ruoli IAM esistenti, i bucket Amazon S3 o i componenti aggiuntivi di dipendenza in base ai requisiti organizzativi.
### Prerequisiti
+ Un HyperPod cluster esistente con orchestrazione Amazon EKS
+ Autorizzazioni IAM per l'amministrazione di cluster Amazon EKS
+ kubectl configurato per l'accesso al cluster
### Fasi di installazione
1. Vai alla console SageMaker AI e vai a **HyperPod Clusters** → **Cluster Management**.
1. Seleziona il cluster in cui desideri installare Inference Operator.
1. Vai alla scheda **Inferenza.** Seleziona **Installazione rapida** per la configurazione automatica o Installazione **personalizzata** per la flessibilità di configurazione.
1. Se scegli Installazione personalizzata, specifica le risorse esistenti o personalizza le impostazioni secondo necessità.
1. Fate clic su **Installa** per iniziare il processo di installazione automatica.
1. Verifica lo stato dell'installazione tramite la console o eseguendo i seguenti comandi:
```
kubectl get pods -n hyperpod-inference-system
```
```
aws eks describe-addon --cluster-name CLUSTER-NAME --addon-name amazon-sagemaker-hyperpod-inference --region REGION
```
Dopo aver installato correttamente il componente aggiuntivo, puoi distribuire i modelli utilizzando la documentazione sulla distribuzione del modello o accedere a. [Verifica del funzionamento dell’operatore di inferenza](#sagemaker-hyperpod-model-deployment-setup-verify)
## Metodo 2: installazione dell'operatore di inferenza utilizzando la CLI AWS
Il metodo di installazione AWS CLI offre un maggiore controllo sul processo di installazione ed è adatto per l'automazione e le configurazioni avanzate.
### Prerequisiti
L'operatore di inferenza consente l'implementazione e la gestione di endpoint di inferenza di machine learning sul tuo cluster Amazon EKS. Prima dell'installazione, assicurati che il cluster disponga delle configurazioni di sicurezza e dell'infrastruttura di supporto richieste. Completa questi passaggi per configurare i ruoli IAM, installare il AWS Load Balancer Controller, configurare i driver Amazon S3 e FSx Amazon CSI e distribuire KEDA e cert-manager:
1. [Connect al cluster e configura le variabili di ambiente](#sagemaker-hyperpod-model-deployment-setup-connect-addon)
1. [Configura i ruoli IAM per l'operatore di inferenza](#sagemaker-hyperpod-model-deployment-setup-prepare-addon)
1. [Crea il ruolo ALB Controller](#sagemaker-hyperpod-model-deployment-setup-alb-addon)
1. [Creazione del ruolo di operatore KEDA](#sagemaker-hyperpod-model-deployment-setup-keda-addon)
1. [Installa i componenti aggiuntivi EKS di dipendenza](#sagemaker-hyperpod-model-deployment-setup-install-dependencies)
**Nota**
In alternativa, puoi utilizzare CloudFormation modelli per automatizzare la configurazione dei prerequisiti. Per ulteriori informazioni, consulta [Utilizzo dei CloudFormation modelli per creare lo stack dei prerequisiti](#sagemaker-hyperpod-model-deployment-setup-cfn).
### Connect al cluster e configura le variabili di ambiente
Prima di procedere, verifica che AWS le tue credenziali siano configurate correttamente e dispongano delle autorizzazioni necessarie. Esegui i seguenti passaggi utilizzando un principale IAM con privilegi di amministratore e accesso da amministratore del cluster a un cluster Amazon EKS. Assicurati di aver creato un HyperPod cluster con[Creazione di un SageMaker HyperPod cluster con l'orchestrazione di Amazon EKS](sagemaker-hyperpod-eks-operate-console-ui-create-cluster.md). Installa le utilità da riga di comando helm, eksctl e kubectl.
Per l'accesso amministrativo di Kubernetes al cluster Amazon EKS, apri la console Amazon EKS e seleziona il tuo cluster. Nella scheda **Accesso**, seleziona **IAM** Access Entries. Se non esiste alcuna voce per il tuo principale IAM, seleziona **Create Access Entry**. Seleziona il principale IAM desiderato e associalo ad esso. `AmazonEKSClusterAdminPolicy`
1. Configura kubectl per connetterti al cluster appena creato orchestrato dal HyperPod cluster Amazon EKS. Specificare la regione e il nome del cluster. HyperPod
```
export HYPERPOD_CLUSTER_NAME=
export REGION=
# S3 bucket where tls certificates will be uploaded
export BUCKET_NAME="hyperpod-tls-" # Bucket should have prefix: hyperpod-tls-*
export EKS_CLUSTER_NAME=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
--query 'Orchestrator.Eks.ClusterArn' --output text | \
cut -d'/' -f2)
aws eks update-kubeconfig --name $EKS_CLUSTER_NAME --region $REGION
```
**Nota**
Se utilizzi un nome di bucket personalizzato che non inizia con`hyperpod-tls-`, allega la seguente policy al tuo ruolo di esecuzione:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "TLSBucketDeleteObjectsPermission",
"Effect": "Allow",
"Action": ["s3:DeleteObject"],
"Resource": ["arn:aws:s3:::${BUCKET_NAME}/*"],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
},
{
"Sid": "TLSBucketGetObjectAccess",
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": ["arn:aws:s3:::${BUCKET_NAME}/*"]
},
{
"Sid": "TLSBucketPutObjectAccess",
"Effect": "Allow",
"Action": ["s3:PutObject", "s3:PutObjectTagging"],
"Resource": ["arn:aws:s3:::${BUCKET_NAME}/*"],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
}
]
}
```
1. Imposta le variabili env predefinite.
```
HYPERPOD_INFERENCE_ROLE_NAME="SageMakerHyperPodInference-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_NAMESPACE="hyperpod-inference-system"
```
1. Estrai il nome del cluster Amazon EKS dall’ARN del cluster, aggiorna il file kubeconfig locale e verifica la connettività elencando tutti i pod nei namespace.
```
kubectl get pods --all-namespaces
```
1. (Facoltativo) Installa il plugin del dispositivo NVIDIA per abilitare il supporto della GPU sul cluster.
```
# Install nvidia device plugin
kubectl create -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.14.5/nvidia-device-plugin.yml
# Verify that GPUs are visible to k8s
kubectl get nodes -o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia.com/gpu
```
### Configura i ruoli IAM per l'operatore di inferenza
1. Raccogli gli identificatori AWS delle risorse essenziali e ARNs necessari per configurare le integrazioni di servizi tra i componenti Amazon EKS, SageMaker AI e IAM.
```
%%bash -x
export ACCOUNT_ID=$(aws --region $REGION sts get-caller-identity --query 'Account' --output text)
export OIDC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
export EKS_CLUSTER_ROLE=$(aws eks --region $REGION describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.roleArn' --output text)
```
1. Associa un OIDCidentity provider IAM al tuo cluster EKS.
```
eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve
```
1. Crea la policy di fiducia richiesta per il ruolo IAM dell'operatore di HyperPod inferenza. Queste policy consentono una comunicazione sicura tra diversi servizi tra Amazon EKS, SageMaker AI e altri AWS servizi.
```
%%bash -x
# Create trust policy JSON
cat << EOF > trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::${ACCOUNT_ID}:oidc-provider/oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:aud": "sts.amazonaws.com",
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:sub": "system:serviceaccount:hyperpod-inference-system:hyperpod-inference-controller-manager"
}
}
}
]
}
EOF
```
1. Crea il ruolo di esecuzione per l’operatore di inferenza.
```
aws iam create-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --assume-role-policy-document file://trust-policy.json
aws iam attach-role-policy --role-name $HYPERPOD_INFERENCE_ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodInferenceAccess
```
1. Crea uno spazio dei nomi per le risorse degli operatori di inferenza
```
kubectl create namespace $HYPERPOD_INFERENCE_NAMESPACE
```
### Crea il ruolo ALB Controller
1. Crea la policy di attendibilità e la policy di autorizzazione.
```
# Create trust policy
cat < /tmp/alb-trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:hyperpod-inference-system:aws-load-balancer-controller",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
}
]
}
EOF
# Create permissions policy
export ALBController_IAM_POLICY_NAME=HyperPodInferenceALBControllerIAMPolicy
curl -o AWSLoadBalancerControllerIAMPolicy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.13.0/docs/install/iam_policy.json
# Create the role
aws iam create-role \
--role-name alb-role \
--assume-role-policy-document file:///tmp/alb-trust-policy.json
# Create the policy
ALB_POLICY_ARN=$(aws iam create-policy \
--policy-name $ALBController_IAM_POLICY_NAME \
--policy-document file://AWSLoadBalancerControllerIAMPolicy.json \
--query 'Policy.Arn' \
--output text)
# Attach the policy to the role
aws iam attach-role-policy \
--role-name alb-role \
--policy-arn $ALB_POLICY_ARN
```
1. Applica i tag (`kubernetes.io.role/elb`) a tutte le sottoreti del cluster Amazon EKS (sia pubbliche che private).
```
export VPC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.resourcesVpcConfig.vpcId' --output text)
# Add Tags
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' | \
xargs -I{} aws ec2 create-tags --resources {} --tags Key=kubernetes.io/role/elb,Value=1
# Verify Tags are added
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' |
xargs -n1 -I{} aws ec2 describe-tags --filters "Name=resource-id,Values={}" "Name=key,Values=kubernetes.io/role/elb" --query "Tags[0].Value" --output text
```
1. Creare un endpoint VPC Amazon S3.
```
aws ec2 create-vpc-endpoint \
--region ${REGION} \
--vpc-id ${VPC_ID} \
--vpc-endpoint-type Gateway \
--service-name "com.amazonaws.${REGION}.s3" \
--route-table-ids $(aws ec2 describe-route-tables --region $REGION --filters "Name=vpc-id,Values=${VPC_ID}" --query 'RouteTables[].Associations[].RouteTableId' --output text | tr ' ' '\n' | sort -u | tr '\n' ' ')
```
### Creazione del ruolo di operatore KEDA
1. Crea la policy di attendibilità e la policy di autorizzazione.
```
# Create trust policy
cat < /tmp/keda-trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:hyperpod-inference-system:keda-operator",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
}
]
}
EOF
# Create permissions policy
cat < /tmp/keda-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"aps:QueryMetrics",
"aps:GetLabels",
"aps:GetSeries",
"aps:GetMetricMetadata"
],
"Resource": "*"
}
]
}
EOF
# Create the role
aws iam create-role \
--role-name keda-operator-role \
--assume-role-policy-document file:///tmp/keda-trust-policy.json
# Create the policy
KEDA_POLICY_ARN=$(aws iam create-policy \
--policy-name KedaOperatorPolicy \
--policy-document file:///tmp/keda-policy.json \
--query 'Policy.Arn' \
--output text)
# Attach the policy to the role
aws iam attach-role-policy \
--role-name keda-operator-role \
--policy-arn $KEDA_POLICY_ARN
```
1. Se utilizzi modelli gated, crea un ruolo IAM per accedervi.
1. Creare una policy IAM
```
%%bash -s $REGION
JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-${REGION}-${HYPERPOD_CLUSTER_NAME}"
cat < /tmp/trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:*:hyperpod-inference-service-account*",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
```
1. Crea un ruolo IAM.
```
# Create the role using existing trust policy
aws iam create-role \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--assume-role-policy-document file:///tmp/trust-policy.json
aws iam attach-role-policy \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodGatedModelAccess
```
```
JUMPSTART_GATED_ROLE_ARN_LIST= !aws iam get-role --role-name=$JUMPSTART_GATED_ROLE_NAME --query "Role.Arn" --output text
JUMPSTART_GATED_ROLE_ARN = JUMPSTART_GATED_ROLE_ARN_LIST[0]
!echo $JUMPSTART_GATED_ROLE_ARN
```
### Installa i componenti aggiuntivi EKS di dipendenza
Prima di installare l'operatore di inferenza, è necessario installare i seguenti componenti aggiuntivi EKS richiesti sul cluster. L'operatore di inferenza non verrà installato se manca una di queste dipendenze. Ogni componente aggiuntivo ha un requisito minimo di versione per la compatibilità con il componente aggiuntivo Inference.
**Importante**
Installa tutti i componenti aggiuntivi di dipendenza prima di tentare di installare l'operatore di inferenza. Le dipendenze mancanti causeranno errori di installazione con messaggi di errore specifici.
#### Componenti aggiuntivi richiesti
1. **Driver CSI Amazon S3 Mountpoint** (versione minima: v1.14.1-eksbuild.1)
Necessario per montare i bucket S3 come volumi persistenti nei carichi di lavoro di inferenza.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name aws-mountpoint-s3-csi-driver \
--region $REGION \
--service-account-role-arn $S3_CSI_ROLE_ARN
```
Per istruzioni di installazione dettagliate, incluse le autorizzazioni IAM richieste, consulta il driver CSI [Mountpoint for Amazon S3](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#mountpoint-for-s3-add-on).
1. **Amazon FSx CSI Driver** (versione minima: v1.6.0-eksbuild.1)
Necessario per il montaggio di file system per lo storage di modelli ad alte prestazioni. FSx
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name aws-fsx-csi-driver \
--region $REGION \
--service-account-role-arn $FSX_CSI_ROLE_ARN
```
Per istruzioni di installazione dettagliate, incluse le autorizzazioni IAM richieste, consulta il driver [CSI di Amazon FSx for Lustre](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#add-ons-aws-fsx-csi-driver).
1. **Metrics Server** (versione minima: v0.7.2-eksbuild.4)
Necessario per la funzionalità di scalabilità automatica e la raccolta delle metriche delle risorse.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name metrics-server \
--region $REGION
```
[Per istruzioni dettagliate sull'installazione, consulta Metrics Server.](https://docs.aws.amazon.com/eks/latest/userguide/metrics-server.html)
1. **Cert Manager** (versione minima: v1.18.2-eksbuild.2)
Necessario per la gestione dei certificati TLS per endpoint di inferenza sicuri.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name cert-manager \
--region $REGION
```
[Per istruzioni dettagliate sull'installazione, consulta cert-manager.](https://docs.aws.amazon.com/eks/latest/userguide/community-addons.html#addon-cert-manager)
#### Verifica l'installazione del componente aggiuntivo
Dopo aver installato i componenti aggiuntivi richiesti, verifica che funzionino correttamente:
```
# Check add-on status
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 pods are running
kubectl get pods -n kube-system | grep -E "(mountpoint|fsx|metrics-server)"
kubectl get pods -n cert-manager
```
Tutti i componenti aggiuntivi devono mostrare lo stato «ATTIVO» e tutti i pod devono essere in stato «In esecuzione» prima di procedere con l'installazione dell'operatore di inferenza.
**Nota**
Se hai creato il HyperPod cluster utilizzando le opzioni di configurazione rapida o di configurazione personalizzata, è possibile che FSx CSI Driver e Cert Manager siano già installati. Verifica la loro presenza utilizzando i comandi precedenti.
### Installazione del componente aggiuntivo Inference Operator with EKS
Il metodo di installazione del componente aggiuntivo EKS offre un'esperienza gestita con aggiornamenti automatici e convalida delle dipendenze integrata. Questo è l'approccio consigliato per l'installazione dell'operatore di inferenza.
**Installa il componente aggiuntivo Inference Operator**
1. Prepara la configurazione del componente aggiuntivo raccogliendo tutto il necessario ARNs e creando il file di configurazione:
```
# Gather required ARNs
export EXECUTION_ROLE_ARN=$(aws iam get-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --query "Role.Arn" --output text)
export HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME --region $REGION --query "ClusterArn" --output text)
export KEDA_ROLE_ARN=$(aws iam get-role --role-name keda-operator-role --query 'Role.Arn' --output text)
export ALB_ROLE_ARN=$(aws iam get-role --role-name alb-role --query 'Role.Arn' --output text)
# Verify all ARNs are set correctly
echo "Execution Role ARN: $EXECUTION_ROLE_ARN"
echo "HyperPod Cluster ARN: $HYPERPOD_CLUSTER_ARN"
echo "KEDA Role ARN: $KEDA_ROLE_ARN"
echo "ALB Role ARN: $ALB_ROLE_ARN"
echo "TLS S3 Bucket: $BUCKET_NAME"
```
1. Crea il file di configurazione del componente aggiuntivo con tutte le impostazioni richieste:
```
cat > addon-config.json << EOF
{
"executionRoleArn": "$EXECUTION_ROLE_ARN",
"tlsCertificateS3Bucket": "$BUCKET_NAME",
"hyperpodClusterArn": "$HYPERPOD_CLUSTER_ARN",
"jumpstartGatedModelDownloadRoleArn": "$JUMPSTART_GATED_ROLE_ARN",
"alb": {
"serviceAccount": {
"create": true,
"roleArn": "$ALB_ROLE_ARN"
}
},
"keda": {
"auth": {
"aws": {
"irsa": {
"roleArn": "$KEDA_ROLE_ARN"
}
}
}
}
}
EOF
# Verify the configuration file
cat addon-config.json
```
1. Installa il componente aggiuntivo dell'operatore di inferenza (versione minima: v1.0.0-eksbuild.1):
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name amazon-sagemaker-hyperpod-inference \
--configuration-values file://addon-config.json \
--region $REGION
```
1. Monitora lo stato di avanzamento dell'installazione e verifica il corretto completamento:
```
# Check installation status (repeat until status shows "ACTIVE")
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 pods are running
kubectl get pods -n hyperpod-inference-system
# Check operator logs for any issues
kubectl logs -n hyperpod-inference-system deployment/hyperpod-inference-controller-manager --tail=50
```
Per la risoluzione dettagliata dei problemi di installazione, vedere[HyperPod risoluzione dei problemi di inferenza](sagemaker-hyperpod-model-deployment-ts.md).
Per verificare che l'operatore di inferenza funzioni correttamente, continuate con[Verifica del funzionamento dell’operatore di inferenza](#sagemaker-hyperpod-model-deployment-setup-verify).
### Utilizzo dei CloudFormation modelli per creare lo stack dei prerequisiti
In alternativa alla configurazione manuale dei prerequisiti, puoi utilizzare i CloudFormation modelli per automatizzare la creazione dei ruoli e delle policy IAM richiesti per l'operatore di inferenza.
1. Imposta le variabili di input. Sostituisci i valori segnaposto con i tuoi:
```
#!/bin/bash
set -e
# ===== INPUT VARIABLES =====
HP_CLUSTER_NAME="my-hyperpod-cluster" # Replace with your HyperPod cluster name
REGION="us-east-1" # Replace with your AWS region
PREFIX="my-prefix" # Replace with your resource prefix
SHORT_PREFIX="12a34d56" # Replace with your short prefix (maximum 8 characters)
CREATE_DOMAIN="true" # Set to "false" if you don't need a SageMaker Studio domain
STACK_NAME="hyperpod-inference-prerequisites" # Replace with your stack name
TEMPLATE_URL="https://aws-sagemaker-hyperpod-cluster-setup-${REGION}-prod.s3.${REGION}.amazonaws.com/templates/main-stack-inference-operator-addon-template.yaml"
```
1. Ricava informazioni su cluster e rete:
```
# ===== DERIVE EKS CLUSTER NAME =====
EKS_CLUSTER_NAME=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --region $REGION --query 'Orchestrator.Eks.ClusterArn' --output text | awk -F'/' '{print $NF}')
echo "EKS_CLUSTER_NAME=$EKS_CLUSTER_NAME"
# ===== GET VPC AND OIDC =====
VPC_ID=$(aws eks describe-cluster --name $EKS_CLUSTER_NAME --region $REGION --query 'cluster.resourcesVpcConfig.vpcId' --output text)
echo "VPC_ID=$VPC_ID"
OIDC_PROVIDER=$(aws eks describe-cluster --name $EKS_CLUSTER_NAME --region $REGION --query 'cluster.identity.oidc.issuer' --output text | sed 's|https://||')
echo "OIDC_PROVIDER=$OIDC_PROVIDER"
# ===== GET PRIVATE ROUTE TABLES =====
ALL_ROUTE_TABLES=$(aws ec2 describe-route-tables --region $REGION --filters "Name=vpc-id,Values=$VPC_ID" --query 'RouteTables[].RouteTableId' --output text)
EKS_PRIVATE_ROUTE_TABLES=""
for rtb in $ALL_ROUTE_TABLES; do
HAS_IGW=$(aws ec2 describe-route-tables --region $REGION --route-table-ids $rtb --query 'RouteTables[0].Routes[?GatewayId && starts_with(GatewayId, `igw-`)]' --output text 2>/dev/null)
if [ -z "$HAS_IGW" ]; then
EKS_PRIVATE_ROUTE_TABLES="${EKS_PRIVATE_ROUTE_TABLES:+$EKS_PRIVATE_ROUTE_TABLES,}$rtb"
fi
done
echo "EKS_PRIVATE_ROUTE_TABLES=$EKS_PRIVATE_ROUTE_TABLES"
# ===== CHECK S3 VPC ENDPOINT =====
S3_ENDPOINT_EXISTS=$(aws ec2 describe-vpc-endpoints --region $REGION --filters "Name=vpc-id,Values=$VPC_ID" "Name=service-name,Values=com.amazonaws.$REGION.s3" --query 'VpcEndpoints[0].VpcEndpointId' --output text)
CREATE_S3_ENDPOINT_STACK=$([ "$S3_ENDPOINT_EXISTS" == "None" ] && echo "true" || echo "false")
echo "CREATE_S3_ENDPOINT_STACK=$CREATE_S3_ENDPOINT_STACK"
# ===== GET HYPERPOD DETAILS =====
HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --region $REGION --query 'ClusterArn' --output text)
echo "HYPERPOD_CLUSTER_ARN=$HYPERPOD_CLUSTER_ARN"
# ===== GET DEFAULT VPC FOR DOMAIN =====
DOMAIN_VPC_ID=$(aws ec2 describe-vpcs --region $REGION --filters "Name=isDefault,Values=true" --query 'Vpcs[0].VpcId' --output text)
echo "DOMAIN_VPC_ID=$DOMAIN_VPC_ID"
DOMAIN_SUBNET_IDS=$(aws ec2 describe-subnets --region $REGION --filters "Name=vpc-id,Values=$DOMAIN_VPC_ID" --query 'Subnets[0].SubnetId' --output text)
echo "DOMAIN_SUBNET_IDS=$DOMAIN_SUBNET_IDS"
# ===== GET INSTANCE GROUPS =====
INSTANCE_GROUPS=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --region $REGION --query 'InstanceGroups[].InstanceGroupName' --output json | python3 -c "import sys, json; groups = json.load(sys.stdin); print('[' + ','.join([f'\\\\\\\"' + g + '\\\\\\\"' for g in groups]) + ']')")
echo "INSTANCE_GROUPS=$INSTANCE_GROUPS"
```
1. Crea un file di parametri e distribuisci lo stack:
```
# ===== CREATE PARAMETERS JSON =====
cat > /tmp/cfn-params.json << EOF
[
{"ParameterKey":"ResourceNamePrefix","ParameterValue":"$PREFIX"},
{"ParameterKey":"ResourceNameShortPrefix","ParameterValue":"$SHORT_PREFIX"},
{"ParameterKey":"VpcId","ParameterValue":"$VPC_ID"},
{"ParameterKey":"EksPrivateRouteTableIds","ParameterValue":"$EKS_PRIVATE_ROUTE_TABLES"},
{"ParameterKey":"EKSClusterName","ParameterValue":"$EKS_CLUSTER_NAME"},
{"ParameterKey":"OIDCProviderURLWithoutProtocol","ParameterValue":"$OIDC_PROVIDER"},
{"ParameterKey":"HyperPodClusterArn","ParameterValue":"$HYPERPOD_CLUSTER_ARN"},
{"ParameterKey":"HyperPodClusterName","ParameterValue":"$HP_CLUSTER_NAME"},
{"ParameterKey":"CreateDomain","ParameterValue":"$CREATE_DOMAIN"},
{"ParameterKey":"DomainVpcId","ParameterValue":"$DOMAIN_VPC_ID"},
{"ParameterKey":"DomainSubnetIds","ParameterValue":"$DOMAIN_SUBNET_IDS"},
{"ParameterKey":"CreateS3EndpointStack","ParameterValue":"$CREATE_S3_ENDPOINT_STACK"},
{"ParameterKey":"TieredStorageConfig","ParameterValue":"{\"Mode\":\"Enable\",\"InstanceMemoryAllocationPercentage\":20}"},
{"ParameterKey":"TieredKVCacheConfig","ParameterValue":"{\"KVCacheMode\":\"Enable\",\"InstanceGroup\":$INSTANCE_GROUPS,\"NVMeMode\":\"Enable\"}"}
]
EOF
echo -e "\n===== CREATING CLOUDFORMATION STACK ====="
aws cloudformation create-stack \
--region $REGION \
--stack-name $STACK_NAME \
--template-url $TEMPLATE_URL \
--parameters file:///tmp/cfn-params.json \
--capabilities CAPABILITY_NAMED_IAM
```
1. Monitora lo stato di creazione dello stack:
```
aws cloudformation describe-stacks \
--stack-name $STACK_NAME \
--region $REGION \
--query 'Stacks[0].StackStatus'
```
1. Una volta creato correttamente lo stack, recupera i valori di output da utilizzare nell'installazione dell'operatore di inferenza:
```
aws cloudformation describe-stacks \
--stack-name $STACK_NAME \
--region $REGION \
--query 'Stacks[0].Outputs'
```
Dopo aver creato lo CloudFormation stack, continuate con l'installazione dell'operatore [Installazione del componente aggiuntivo Inference Operator with EKS](#sagemaker-hyperpod-model-deployment-setup-install-inference-operator-addon) di inferenza.
## Metodo 3: installazione di Helm chart
**Nota**
Per un'esperienza di installazione più semplice, si consiglia di utilizzare [Metodo 1: installa il componente aggiuntivo HyperPod Inference tramite la console SageMaker AI (consigliato)](#sagemaker-hyperpod-model-deployment-setup-ui) o[Metodo 2: installazione dell'operatore di inferenza utilizzando la CLI AWS](#sagemaker-hyperpod-model-deployment-setup-addon). L'installazione di Helm chart potrebbe essere obsoleta in una versione futura.
### Prerequisiti
Prima di procedere, verifica che AWS le tue credenziali siano configurate correttamente e dispongano delle autorizzazioni necessarie. I seguenti passaggi devono essere eseguiti da un responsabile IAM con privilegi di amministratore e accesso di amministratore del cluster a un cluster Amazon EKS. Verifica di aver creato un HyperPod cluster con[Creazione di un SageMaker HyperPod cluster con l'orchestrazione di Amazon EKS](sagemaker-hyperpod-eks-operate-console-ui-create-cluster.md). Verifica di aver installato le utilità a riga di comando helm, eksctl e kubectl.
Per l'accesso amministrativo di Kubernetes al cluster Amazon EKS, vai alla console Amazon EKS e seleziona il cluster che stai utilizzando. Seleziona Voci di accesso IAM nella scheda **Accesso**. Se la voce per il tuo principale IAM non è presente, seleziona **Crea voce di accesso**. Quindi seleziona il principale IAM desiderato e associalo a `AmazonEKSClusterAdminPolicy`.
1. Configura kubectl per connetterti al cluster appena creato orchestrato dal HyperPod cluster Amazon EKS. Specificare la regione e il nome del cluster. HyperPod
```
export HYPERPOD_CLUSTER_NAME=
export REGION=
# S3 bucket where tls certificates will be uploaded
BUCKET_NAME="" # This should be bucket name, not URI
export EKS_CLUSTER_NAME=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
--query 'Orchestrator.Eks.ClusterArn' --output text | \
cut -d'/' -f2)
aws eks update-kubeconfig --name $EKS_CLUSTER_NAME --region $REGION
```
1. Imposta le variabili env predefinite.
```
LB_CONTROLLER_POLICY_NAME="AWSLoadBalancerControllerIAMPolicy-$HYPERPOD_CLUSTER_NAME"
LB_CONTROLLER_ROLE_NAME="aws-load-balancer-controller-$HYPERPOD_CLUSTER_NAME"
S3_MOUNT_ACCESS_POLICY_NAME="S3MountpointAccessPolicy-$HYPERPOD_CLUSTER_NAME"
S3_CSI_ROLE_NAME="SM_HP_S3_CSI_ROLE-$HYPERPOD_CLUSTER_NAME"
KEDA_OPERATOR_POLICY_NAME="KedaOperatorPolicy-$HYPERPOD_CLUSTER_NAME"
KEDA_OPERATOR_ROLE_NAME="keda-operator-role-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_ROLE_NAME="HyperpodInferenceRole-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_SA_NAME="hyperpod-inference-operator-controller"
HYPERPOD_INFERENCE_SA_NAMESPACE="hyperpod-inference-system"
JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-$HYPERPOD_CLUSTER_NAME"
FSX_CSI_ROLE_NAME="AmazonEKSFSxLustreCSIDriverFullAccess-$HYPERPOD_CLUSTER_NAME"
```
1. Estrai il nome del cluster Amazon EKS dall’ARN del cluster, aggiorna il file kubeconfig locale e verifica la connettività elencando tutti i pod nei namespace.
```
kubectl get pods --all-namespaces
```
1. (Facoltativo) Installa il plugin del dispositivo NVIDIA per abilitare il supporto della GPU sul cluster.
```
#Install nvidia device plugin
kubectl create -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.14.5/nvidia-device-plugin.yml
# Verify that GPUs are visible to k8s
kubectl get nodes -o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia.com/gpu
```
### Preparazione dell’ambiente per l’installazione dell’operatore di inferenza
1. Raccogli gli identificatori AWS delle risorse essenziali e ARNs necessari per configurare le integrazioni di servizi tra i componenti Amazon EKS, SageMaker AI e IAM.
```
%%bash -x
export ACCOUNT_ID=$(aws --region $REGION sts get-caller-identity --query 'Account' --output text)
export OIDC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
export EKS_CLUSTER_ROLE=$(aws eks --region $REGION describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.roleArn' --output text)
```
1. Associa un OIDCidentity provider IAM al tuo cluster EKS.
```
eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve
```
1. Crea la policy di fiducia richiesta per il ruolo IAM dell'operatore di HyperPod inferenza. Questa policy consente una comunicazione sicura tra diversi servizi tra Amazon EKS, SageMaker AI e altri AWS servizi.
```
%%bash -x
# Create trust policy JSON
cat << EOF > trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::${ACCOUNT_ID}:oidc-provider/oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:aud": "sts.amazonaws.com",
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:sub": "system:serviceaccount:hyperpod-inference-system:hyperpod-inference-controller-manager"
}
}
}
]
}
EOF
```
1. Crea il ruolo di esecuzione per l'operatore di inferenza e allega la policy gestita.
```
aws iam create-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --assume-role-policy-document file://trust-policy.json
aws iam attach-role-policy --role-name $HYPERPOD_INFERENCE_ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodInferenceAccess
```
1. Scarica e crea la policy IAM richiesta al AWS Load Balancer Controller per gestire Application Load Balancer e Network Load Balancer nel tuo cluster EKS.
```
%%bash -x
export ALBController_IAM_POLICY_NAME=HyperPodInferenceALBControllerIAMPolicy
curl -o AWSLoadBalancerControllerIAMPolicy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.13.0/docs/install/iam_policy.json
aws iam create-policy --policy-name $ALBController_IAM_POLICY_NAME --policy-document file://AWSLoadBalancerControllerIAMPolicy.json
```
1. Crea un account di servizio IAM che colleghi l'account del servizio Kubernetes alla policy IAM, permettendo al Load AWS Balancer Controller di assumere le AWS autorizzazioni necessarie tramite IRSA (IAM Roles for Service Accounts).
```
%%bash -x
export ALB_POLICY_ARN="arn:aws:iam::$ACCOUNT_ID:policy/$ALBController_IAM_POLICY_NAME"
# Create IAM service account with gathered values
eksctl create iamserviceaccount \
--approve \
--override-existing-serviceaccounts \
--name=aws-load-balancer-controller \
--namespace=kube-system \
--cluster=$EKS_CLUSTER_NAME \
--attach-policy-arn=$ALB_POLICY_ARN \
--region=$REGION
# Print the values for verification
echo "Cluster Name: $EKS_CLUSTER_NAME"
echo "Region: $REGION"
echo "Policy ARN: $ALB_POLICY_ARN"
```
1. Applica i tag (`kubernetes.io.role/elb`) a tutte le sottoreti del cluster Amazon EKS (sia pubbliche che private).
```
export VPC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.resourcesVpcConfig.vpcId' --output text)
# Add Tags
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' | \
xargs -I{} aws ec2 create-tags --resources {} --tags Key=kubernetes.io/role/elb,Value=1
# Verify Tags are added
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' |
xargs -n1 -I{} aws ec2 describe-tags --filters "Name=resource-id,Values={}" "Name=key,Values=kubernetes.io/role/elb" --query "Tags[0].Value" --output text
```
1. Crea un namespace per KEDA e Gestione certificati.
```
kubectl create namespace keda
kubectl create namespace cert-manager
```
1. Creare un endpoint VPC Amazon S3.
```
aws ec2 create-vpc-endpoint \
--vpc-id ${VPC_ID} \
--vpc-endpoint-type Gateway \
--service-name "com.amazonaws.${REGION}.s3" \
--route-table-ids $(aws ec2 describe-route-tables --filters "Name=vpc-id,Values=${VPC_ID}" --query 'RouteTables[].Associations[].RouteTableId' --output text | tr ' ' '\n' | sort -u | tr '\n' ' ')
```
1. Configura l’accesso all’archiviazione S3:
1. Crea una policy IAM che conceda le autorizzazioni S3 necessarie per l’utilizzo di Mountpoint per Amazon S3 e che consenta l’accesso del file system ai bucket S3 dall’interno del cluster.
```
%%bash -x
export S3_CSI_BUCKET_NAME=“”
cat < s3accesspolicy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "MountpointAccess",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::${S3_CSI_BUCKET_NAME}",
"arn:aws:s3:::${S3_CSI_BUCKET_NAME}/*"
]
}
]
}
EOF
aws iam create-policy \
--policy-name S3MountpointAccessPolicy \
--policy-document file://s3accesspolicy.json
cat < s3accesstrustpolicy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/${OIDC_ID}"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.$REGION.amazonaws.com/id/${OIDC_ID}:aud": "sts.amazonaws.com",
"oidc.eks.$REGION.amazonaws.com/id/${OIDC_ID}:sub": "system:serviceaccount:kube-system:${s3-csi-driver-sa}"
}
}
}
]
}
EOF
aws iam create-role --role-name $S3_CSI_ROLE_NAME --assume-role-policy-document file://s3accesstrustpolicy.json
aws iam attach-role-policy --role-name $S3_CSI_ROLE_NAME --policy-arn "arn:aws:iam::$ACCOUNT_ID:policy/S3MountpointAccessPolicy"
```
1. (Facoltativo) Crea un account di servizio IAM per il driver CSI di Amazon S3. Il driver Amazon S3 CSI richiede un account di servizio IAM con le autorizzazioni appropriate per montare i bucket S3 come volumi persistenti nel cluster Amazon EKS. Questa fase crea il ruolo IAM e l’account di servizio Kubernetes necessari con la policy di accesso S3 richiesta.
```
%%bash -x
export S3_CSI_ROLE_NAME="SM_HP_S3_CSI_ROLE-$REGION"
export S3_CSI_POLICY_ARN=$(aws iam list-policies --query 'Policies[?PolicyName==`S3MountpointAccessPolicy`]' | jq '.[0].Arn' | tr -d '"')
eksctl create iamserviceaccount \
--name s3-csi-driver-sa \
--namespace kube-system \
--cluster $EKS_CLUSTER_NAME \
--attach-policy-arn $S3_CSI_POLICY_ARN \
--approve \
--role-name $S3_CSI_ROLE_NAME \
--region $REGION
kubectl label serviceaccount s3-csi-driver-sa app.kubernetes.io/component=csi-driver app.kubernetes.io/instance=aws-mountpoint-s3-csi-driver app.kubernetes.io/managed-by=EKS app.kubernetes.io/name=aws-mountpoint-s3-csi-driver -n kube-system --overwrite
```
1. (Facoltativo) Installa il componente aggiuntivo del driver CSI di Amazon S3. Questo driver consente ai pod di montare i bucket S3 come volumi persistenti, fornendo un accesso diretto all’archiviazione S3 dall’interno dei carichi di lavoro Kubernetes.
```
%%bash -x
export S3_CSI_ROLE_ARN=$(aws iam get-role --role-name $S3_CSI_ROLE_NAME --query 'Role.Arn' --output text)
eksctl create addon --name aws-mountpoint-s3-csi-driver --cluster $EKS_CLUSTER_NAME --service-account-role-arn $S3_CSI_ROLE_ARN --force
```
1. (Facoltativo) Crea una richiesta di volumi persistenti (PVC) per l’archiviazione S3. Questo PVC consente ai pod di richiedere e utilizzare l’archiviazione S3 con le stesse modalità di un file system tradizionale.
```
%%bash -x
cat < pvc_s3.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: s3-claim
spec:
accessModes:
- ReadWriteMany # supported options: ReadWriteMany / ReadOnlyMany
storageClassName: "" # required for static provisioning
resources:
requests:
storage: 1200Gi # ignored, required
volumeName: s3-pv
EOF
kubectl apply -f pvc_s3.yaml
```
1. (Facoltativo) Configura l'accesso allo storage. FSx Crea un account di servizio IAM per il driver Amazon FSx CSI. Questo account di servizio verrà utilizzato dal driver FSx CSI per interagire con il FSx servizio Amazon per conto del tuo cluster.
```
%%bash -x
eksctl create iamserviceaccount \
--name fsx-csi-controller-sa \
--namespace kube-system \
--cluster $EKS_CLUSTER_NAME \
--attach-policy-arn arn:aws:iam::aws:policy/AmazonFSxFullAccess \
--approve \
--role-name FSXLCSI-${EKS_CLUSTER_NAME}-${REGION} \
--region $REGION
```
### Creazione del ruolo di operatore KEDA
1. Crea la policy di attendibilità e la policy di autorizzazione.
```
# Create trust policy
cat < /tmp/keda-trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:kube-system:keda-operator",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
}
]
}
EOF
# Create permissions policy
cat < /tmp/keda-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"aps:QueryMetrics",
"aps:GetLabels",
"aps:GetSeries",
"aps:GetMetricMetadata"
],
"Resource": "*"
}
]
}
EOF
# Create the role
aws iam create-role \
--role-name keda-operator-role \
--assume-role-policy-document file:///tmp/keda-trust-policy.json
# Create the policy
KEDA_POLICY_ARN=$(aws iam create-policy \
--policy-name KedaOperatorPolicy \
--policy-document file:///tmp/keda-policy.json \
--query 'Policy.Arn' \
--output text)
# Attach the policy to the role
aws iam attach-role-policy \
--role-name keda-operator-role \
--policy-arn $KEDA_POLICY_ARN
```
1. Se utilizzi modelli gated, crea un ruolo IAM per accedervi.
1. Crea la policy di fiducia e il ruolo IAM per l'accesso controllato ai modelli.
```
%%bash -s $REGION
JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-${REGION}-${HYPERPOD_CLUSTER_NAME}"
cat < /tmp/trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:*:hyperpod-inference-service-account*",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
# Create the role and attach the managed policy
aws iam create-role \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--assume-role-policy-document file:///tmp/trust-policy.json
aws iam attach-role-policy \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodGatedModelAccess
```
```
JUMPSTART_GATED_ROLE_ARN_LIST= !aws iam get-role --role-name=$JUMPSTART_GATED_ROLE_NAME --query "Role.Arn" --output text
JUMPSTART_GATED_ROLE_ARN = JUMPSTART_GATED_ROLE_ARN_LIST[0]
!echo $JUMPSTART_GATED_ROLE_ARN
```
### Installazione dell’operatore di inferenza
1. Installa l'operatore di HyperPod inferenza. Questa fase raccoglie gli identificatori delle risorse AWS richiesti e genera il comando di installazione Helm con i parametri di configurazione appropriati.
Accedi al grafico di timone da [https://github.com/aws/sagemaker-hyperpod-cli/tree/main/helm](https://github.com/aws/sagemaker-hyperpod-cli/tree/main/helm_chart)\$1chart.
```
git clone https://github.com/aws/sagemaker-hyperpod-cli
cd sagemaker-hyperpod-cli
cd helm_chart/HyperPodHelmChart
helm dependencies update charts/inference-operator
```
```
%%bash -x
HYPERPOD_INFERENCE_ROLE_ARN=$(aws iam get-role --role-name=$HYPERPOD_INFERENCE_ROLE_NAME --query "Role.Arn" --output text)
echo $HYPERPOD_INFERENCE_ROLE_ARN
S3_CSI_ROLE_ARN=$(aws iam get-role --role-name=$S3_CSI_ROLE_NAME --query "Role.Arn" --output text)
echo $S3_CSI_ROLE_ARN
HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME --query "ClusterArn")
# Verify values
echo "Cluster Name: $EKS_CLUSTER_NAME"
echo "Execution Role: $HYPERPOD_INFERENCE_ROLE_ARN"
echo "Hyperpod ARN: $HYPERPOD_CLUSTER_ARN"
# Run the the HyperPod inference operator installation.
helm install hyperpod-inference-operator charts/inference-operator \
-n kube-system \
--set region=$REGION \
--set eksClusterName=$EKS_CLUSTER_NAME \
--set hyperpodClusterArn=$HYPERPOD_CLUSTER_ARN \
--set executionRoleArn=$HYPERPOD_INFERENCE_ROLE_ARN \
--set s3.serviceAccountRoleArn=$S3_CSI_ROLE_ARN \
--set s3.node.serviceAccount.create=false \
--set keda.podIdentity.aws.irsa.roleArn="arn:aws:iam::$ACCOUNT_ID:role/keda-operator-role" \
--set tlsCertificateS3Bucket="s3://$BUCKET_NAME" \
--set alb.region=$REGION \
--set alb.clusterName=$EKS_CLUSTER_NAME \
--set alb.vpcId=$VPC_ID
# For JumpStart Gated Model usage, Add
# --set jumpstartGatedModelDownloadRoleArn=$UMPSTART_GATED_ROLE_ARN
```
1. Configura le annotazioni degli account di servizio per l’integrazione con IAM. Questa annotazione consente all’account di servizio dell’operatore di assumere le autorizzazioni IAM necessarie per gestire gli endpoint di inferenza e interagire con i servizi AWS .
```
%%bash -x
EKS_CLUSTER_ROLE_NAME=$(echo $EKS_CLUSTER_ROLE | sed 's/.*\///')
# Annotate service account
kubectl annotate serviceaccount hyperpod-inference-operator-controller-manager \
-n hyperpod-inference-system \
eks.amazonaws.com/role-arn=arn:aws:iam::${ACCOUNT_ID}:role/${EKS_CLUSTER_ROLE_NAME} \
--overwrite
```
## Verifica del funzionamento dell’operatore di inferenza
Segui questi passaggi per verificare che l'installazione dell'operatore di inferenza funzioni correttamente implementando e testando un modello semplice.
**Implementa un modello di test per verificare l'operatore**
1. Crea un file di configurazione dell’implementazione del modello. Questo crea un file manifest Kubernetes che definisce una distribuzione del JumpStart modello per l'operatore di inferenza. HyperPod
```
cat <> simple_model_install.yaml
---
apiVersion: inference.sagemaker.aws.amazon.com/v1
kind: JumpStartModel
metadata:
name: testing-deployment-bert
namespace: default
spec:
model:
modelId: "huggingface-eqa-bert-base-cased"
sageMakerEndpoint:
name: "hp-inf-ep-for-testing"
server:
instanceType: "ml.c5.2xlarge"
environmentVariables:
- name: SAMPLE_ENV_VAR
value: "sample_value"
maxDeployTimeInSeconds: 1800
EOF
```
1. Implementa il modello e pulisci il file di configurazione.
```
kubectl create -f simple_model_install.yaml
rm -f simple_model_install.yaml
```
1. Verifica la configurazione dell'account di servizio per assicurarti che l'operatore possa assumere le autorizzazioni. AWS
```
# Get the service account details
kubectl get serviceaccount -n hyperpod-inference-system
# Check if the service account has the AWS annotations
kubectl describe serviceaccount hyperpod-inference-operator-controller-manager -n hyperpod-inference-system
```
**Configura le impostazioni di distribuzione (se utilizzi l'interfaccia utente di Studio)**
1. Controlla il tipo di istanza consigliato in **Impostazioni di distribuzione**.
1. Se modifichi il **tipo di istanza**, verifica la compatibilità con il HyperPod cluster. Contatta l'amministratore se le istanze compatibili non sono disponibili.
1. Per le istanze partizionate da GPU con MIG abilitato, seleziona una **partizione GPU appropriata dai profili MIG disponibili per ottimizzare l'utilizzo della GPU**. Per ulteriori informazioni, consulta [Utilizzo delle partizioni GPU in Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md).
1. Se utilizzi la governance delle attività, configura le impostazioni di priorità per le funzionalità di priorità della distribuzione dei modelli.
1. Inserisci lo spazio dei nomi fornito dal tuo amministratore. Se necessario, contatta l'amministratore per il namespace corretto.
## (Facoltativo) Configura l'accesso degli utenti tramite l' JumpStart interfaccia utente in SageMaker AI Studio Classic
Per ulteriori informazioni sulla configurazione dell' SageMaker HyperPod accesso per gli utenti di Studio Classic e sulla configurazione delle autorizzazioni RBAC di Kubernetes dettagliate per gli utenti di data scientist, leggi e. [Configurazione di un cluster Amazon EKS in Studio](sagemaker-hyperpod-studio-setup-eks.md) [Configurazione del controllo degli accessi basato su ruoli Kubernetes](sagemaker-hyperpod-eks-setup-rbac.md)
1. Identifica il ruolo IAM che gli utenti di Data Scientist utilizzeranno per gestire e implementare modelli da AI Studio Classic. SageMaker HyperPod SageMaker Di solito, si tratta del ruolo di esecuzione del profilo utente o del ruolo di esecuzione del dominio per l’utente di Studio Classic.
```
%%bash -x
export DATASCIENTIST_ROLE_NAME=""
export DATASCIENTIST_POLICY_NAME="HyperPodUIAccessPolicy"
export EKS_CLUSTER_ARN=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
--query 'Orchestrator.Eks.ClusterArn' --output text)
export DATASCIENTIST_HYPERPOD_NAMESPACE="team-namespace"
```
1. Collega una policy di identità che abiliti l’accesso all’implementazione del modello.
```
%%bash -x
# Create access policy
cat << EOF > hyperpod-deployment-ui-access-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DescribeHyerpodClusterPermissions",
"Effect": "Allow",
"Action": [
"sagemaker:DescribeCluster"
],
"Resource": "$HYPERPOD_CLUSTER_ARN"
},
{
"Sid": "UseEksClusterPermissions",
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:AccessKubernetesApi",
"eks:MutateViaKubernetesApi",
"eks:DescribeAddon"
],
"Resource": "$EKS_CLUSTER_ARN"
},
{
"Sid": "ListPermission",
"Effect": "Allow",
"Action": [
"sagemaker:ListClusters",
"sagemaker:ListEndpoints"
],
"Resource": "*"
},
{
"Sid": "SageMakerEndpointAccess",
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:InvokeEndpoint"
],
"Resource": "arn:aws:sagemaker:$REGION:$ACCOUNT_ID:endpoint/*"
}
]
}
EOF
aws iam put-role-policy --role-name DATASCIENTIST_ROLE_NAME --policy-name HyperPodDeploymentUIAccessInlinePolicy --policy-document file://hyperpod-deployment-ui-access-policy.json
```
1. Crea una voce di accesso EKS per l’utente che lo mappa a un gruppo Kubernetes.
```
%%bash -x
aws eks create-access-entry --cluster-name $EKS_CLUSTER_NAME \
--principal-arn "arn:aws:iam::$ACCOUNT_ID:role/$DATASCIENTIST_ROLE_NAME" \
--kubernetes-groups '["hyperpod-scientist-user-namespace-level","hyperpod-scientist-user-cluster-level"]'
```
1. Crea policy RBAC Kubernetes per l’utente.
```
%%bash -x
cat << EOF > cluster_level_config.yaml
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: hyperpod-scientist-user-cluster-role
rules:
- apiGroups: [""]
resources: ["pods"]
verbs: ["list"]
- apiGroups: [""]
resources: ["nodes"]
verbs: ["list"]
- apiGroups: [""]
resources: ["namespaces"]
verbs: ["list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: hyperpod-scientist-user-cluster-role-binding
subjects:
- kind: Group
name: hyperpod-scientist-user-cluster-level
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: hyperpod-scientist-user-cluster-role
apiGroup: rbac.authorization.k8s.io
EOF
kubectl apply -f cluster_level_config.yaml
cat << EOF > namespace_level_role.yaml
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
namespace: $DATASCIENTIST_HYPERPOD_NAMESPACE
name: hyperpod-scientist-user-namespace-level-role
rules:
- apiGroups: [""]
resources: ["pods"]
verbs: ["create", "get"]
- apiGroups: [""]
resources: ["nodes"]
verbs: ["get", "list"]
- apiGroups: [""]
resources: ["pods/log"]
verbs: ["get", "list"]
- apiGroups: [""]
resources: ["pods/exec"]
verbs: ["get", "create"]
- apiGroups: ["kubeflow.org"]
resources: ["pytorchjobs", "pytorchjobs/status"]
verbs: ["get", "list", "create", "delete", "update", "describe"]
- apiGroups: [""]
resources: ["configmaps"]
verbs: ["create", "update", "get", "list", "delete"]
- apiGroups: [""]
resources: ["secrets"]
verbs: ["create", "get", "list", "delete"]
- apiGroups: [ "inference.sagemaker.aws.amazon.com" ]
resources: [ "inferenceendpointconfig", "inferenceendpoint", "jumpstartmodel" ]
verbs: [ "get", "list", "create", "delete", "update", "describe" ]
- apiGroups: [ "autoscaling" ]
resources: [ "horizontalpodautoscalers" ]
verbs: [ "get", "list", "watch", "create", "update", "patch", "delete" ]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
namespace: $DATASCIENTIST_HYPERPOD_NAMESPACE
name: hyperpod-scientist-user-namespace-level-role-binding
subjects:
- kind: Group
name: hyperpod-scientist-user-namespace-level
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: Role
name: hyperpod-scientist-user-namespace-level-role
apiGroup: rbac.authorization.k8s.io
EOF
kubectl apply -f namespace_level_role.yaml
```