Metodo 1: installa il componente aggiuntivo HyperPod Inference tramite la console SageMaker AI (consigliato)Metodo 2: installazione dell'operatore di inferenza utilizzando la CLI AWS Metodo 3: installazione di Helm chart Verifica del funzionamento dell’operatore di inferenza (Facoltativo) Configura l'accesso degli utenti tramite l' JumpStart interfaccia utente in SageMaker AI Studio Classic

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

Vai alla console SageMaker AI e vai a HyperPod Clusters → Cluster Management.
Seleziona il cluster in cui desideri installare Inference Operator.
Vai alla scheda Inferenza. Seleziona Installazione rapida per la configurazione automatica o Installazione personalizzata per la flessibilità di configurazione.
Se scegli Installazione personalizzata, specifica le risorse esistenti o personalizza le impostazioni secondo necessità.
Fate clic su Installa per avviare il processo di installazione automatizzato.

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

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:

Connect al cluster e configura le variabili di ambiente
Configura i ruoli IAM per l'operatore di inferenza
Crea il ruolo ALB Controller
Creazione del ruolo di operatore KEDA
Installa i componenti aggiuntivi EKS di dipendenza

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.

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 conCreazione di un SageMaker HyperPod cluster con l'orchestrazione di Amazon EKS. 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

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=<hyperpod-cluster-name>
export REGION=<region>

# S3 bucket where tls certificates will be uploaded
export BUCKET_NAME="hyperpod-tls-<your-bucket-suffix>" # 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 conhyperpod-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}"
                }
            }
        }
    ]
}

Imposta le variabili env predefinite.


HYPERPOD_INFERENCE_ROLE_NAME="SageMakerHyperPodInference-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_NAMESPACE="hyperpod-inference-system"

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

(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

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)

Associa un OIDCidentity provider IAM al tuo cluster EKS.


eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve

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

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

Crea uno spazio dei nomi per le risorse degli operatori di inferenza
```
kubectl create namespace $HYPERPOD_INFERENCE_NAMESPACE
```

Crea il ruolo ALB Controller

Crea la policy di attendibilità e la policy di autorizzazione.


# Create trust policy
cat <<EOF > /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

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

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

Crea la policy di attendibilità e la policy di autorizzazione.


# Create trust policy
cat <<EOF > /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 <<EOF > /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

Se utilizzi modelli gated, crea un ruolo IAM per accedervi.

Creare una policy IAM


%%bash -s $REGION

JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-${REGION}-${HYPERPOD_CLUSTER_NAME}"

cat <<EOF > /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

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

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

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

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"

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

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

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, vedereHyperPod risoluzione dei problemi di inferenza.

Per verificare che l'operatore di inferenza funzioni correttamente, continuate conVerifica del funzionamento dell’operatore di inferenza.

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.

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"

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"

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

Monitora lo stato di creazione dello stack:


aws cloudformation describe-stacks \
    --stack-name $STACK_NAME \
    --region $REGION \
    --query 'Stacks[0].StackStatus'

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 di inferenza.

Metodo 3: installazione di Helm chart

Utilizzate questo metodo se avete bisogno di un maggiore controllo sulla configurazione di installazione o se il componente aggiuntivo EKS non è disponibile nella vostra regione.

Prerequisiti

Prima di procedere, verificate che AWS le vostre 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 conCreazione di un SageMaker HyperPod cluster con l'orchestrazione di Amazon EKS. 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.

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=<hyperpod-cluster-name>
export REGION=<region>

# S3 bucket where tls certificates will be uploaded
BUCKET_NAME="<Enter name of your s3 bucket>" # 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

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"
PRESIGNED_URL_ACCESS_POLICY_NAME="PresignedUrlAccessPolicy-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_ACCESS_POLICY_NAME="HyperpodInferenceAccessPolicy-$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"

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

(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

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)

Associa un OIDCidentity provider IAM al tuo cluster EKS.


eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve

Crea i documenti JSON della politica di fiducia e della politica di autorizzazione necessari 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
# 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

# Create permission policy JSON
cat << EOF > permission-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "S3Access",
"Effect": "Allow",
"Action": [
    "s3:Get*",
    "s3:List*",
    "s3:Describe*",
    "s3:PutObject"
],
"Resource": [
    "*"
]
},
{
"Sid": "ECRAccess",
"Effect": "Allow",
"Action": [
    "ecr:GetAuthorizationToken",
    "ecr:BatchCheckLayerAvailability",
    "ecr:GetDownloadUrlForLayer",
    "ecr:GetRepositoryPolicy",
    "ecr:DescribeRepositories",
    "ecr:ListImages",
    "ecr:DescribeImages",
    "ecr:BatchGetImage",
    "ecr:GetLifecyclePolicy",
    "ecr:GetLifecyclePolicyPreview",
    "ecr:ListTagsForResource",
    "ecr:DescribeImageScanFindings"
],
"Resource": [
    "*"
]
},
{
"Sid": "EC2Access",
"Effect": "Allow",
"Action": [
    "ec2:AssignPrivateIpAddresses",
    "ec2:AttachNetworkInterface",
    "ec2:CreateNetworkInterface",
    "ec2:DeleteNetworkInterface",
    "ec2:DescribeInstances",
    "ec2:DescribeTags",
    "ec2:DescribeNetworkInterfaces",
    "ec2:DescribeInstanceTypes",
    "ec2:DescribeSubnets",
    "ec2:DetachNetworkInterface",
    "ec2:ModifyNetworkInterfaceAttribute",
    "ec2:UnassignPrivateIpAddresses",
    "ec2:CreateTags",
    "ec2:DescribeInstances",
    "ec2:DescribeInstanceTypes",
    "ec2:DescribeRouteTables",
    "ec2:DescribeSecurityGroups",
    "ec2:DescribeSubnets",
    "ec2:DescribeVolumes",
    "ec2:DescribeVolumesModifications",
    "ec2:DescribeVpcs",
    "ec2:CreateVpcEndpointServiceConfiguration",
    "ec2:DeleteVpcEndpointServiceConfigurations",
    "ec2:DescribeVpcEndpointServiceConfigurations",
    "ec2:ModifyVpcEndpointServicePermissions"
],
"Resource": [
    "*"
]
},
{
"Sid": "EKSAuthAccess",
"Effect": "Allow",
"Action": [
    "eks-auth:AssumeRoleForPodIdentity"
],
"Resource": [
    "*"
]
},
{
"Sid": "EKSAccess",
"Effect": "Allow",
"Action": [
    "eks:AssociateAccessPolicy",
    "eks:Describe*",
    "eks:List*",
    "eks:AccessKubernetesApi"
],
"Resource": [
    "*"
]
},
{
"Sid": "ApiGatewayAccess",
"Effect": "Allow",
"Action": [
    "apigateway:POST",
    "apigateway:GET",
    "apigateway:PUT",
    "apigateway:PATCH",
    "apigateway:DELETE",
    "apigateway:UpdateRestApiPolicy"
],
"Resource": [
    "arn:aws:apigateway:*::/vpclinks",
    "arn:aws:apigateway:*::/vpclinks/*",
    "arn:aws:apigateway:*::/restapis",
    "arn:aws:apigateway:*::/restapis/*"
]
},
{
"Sid": "ElasticLoadBalancingAccess",
"Effect": "Allow",
"Action": [
    "elasticloadbalancing:CreateLoadBalancer",
    "elasticloadbalancing:DescribeLoadBalancers",
    "elasticloadbalancing:DescribeLoadBalancerAttributes",
    "elasticloadbalancing:DescribeListeners",
    "elasticloadbalancing:DescribeListenerCertificates",
    "elasticloadbalancing:DescribeSSLPolicies",
    "elasticloadbalancing:DescribeRules",
    "elasticloadbalancing:DescribeTargetGroups",
    "elasticloadbalancing:DescribeTargetGroupAttributes",
    "elasticloadbalancing:DescribeTargetHealth",
    "elasticloadbalancing:DescribeTags",
    "elasticloadbalancing:DescribeTrustStores",
    "elasticloadbalancing:DescribeListenerAttributes"
],
"Resource": [
    "*"
]
},
{
"Sid": "SageMakerAccess",
"Effect": "Allow",
"Action": [
    "sagemaker:*"
],
"Resource": [
    "*"
]
},
{
"Sid": "AllowPassRoleToSageMaker",
"Effect": "Allow",
"Action": [
    "iam:PassRole"
],
"Resource": "arn:aws:iam::*:role/*",
"Condition": {
    "StringEquals": {
    "iam:PassedToService": "sagemaker.amazonaws.com"
    }
}
},
{
"Sid": "AcmAccess",
"Effect": "Allow",
"Action": [
    "acm:ImportCertificate",
    "acm:DeleteCertificate"
],
"Resource": [
    "*"
]
}
]
}
EOF

Crea il ruolo di esecuzione per l’operatore di inferenza.


aws iam create-policy --policy-name $HYPERPOD_INFERENCE_ACCESS_POLICY_NAME --policy-document file://permission-policy.json
export policy_arn="arn:aws:iam::${ACCOUNT_ID}:policy/$HYPERPOD_INFERENCE_ACCESS_POLICY_NAME"


aws iam create-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --assume-role-policy-document file://trust-policy.json

aws iam put-role-policy --role-name $HYPERPOD_INFERENCE_ROLE_NAME --policy-name InferenceOperatorInlinePolicy --policy-document file://permission-policy.json

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

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"

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

Crea un namespace per KEDA e Gestione certificati.


kubectl create namespace keda
kubectl create namespace cert-manager

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' ' ')

Configura l’accesso all’archiviazione S3:

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=“<bucketname_for_mounting_through_filesystem>”

cat <<EOF> 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 <<EOF> 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"

(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

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

(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 <<EOF> 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

(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

Crea la policy di attendibilità e la policy di autorizzazione.


# Create trust policy
cat <<EOF > /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 <<EOF > /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

Se utilizzi modelli gated, crea un ruolo IAM per accedervi.

Creare una policy IAM


%%bash -s $REGION

cat <<EOF> /tmp/presignedurl-policy.json
{
"Version": "2012-10-17",
"Statement": [
    {
        "Sid": "CreatePresignedUrlAccess",
        "Effect": "Allow",
        "Action": [
            "sagemaker:CreateHubContentPresignedUrls"
        ],
        "Resource": [
            "arn:aws:sagemaker:$1:aws:hub/SageMakerPublicHub", 
            "arn:aws:sagemaker:$1:aws:hub-content/SageMakerPublicHub/*/*" 
        ]
    }
]
}
EOF

aws iam create-policy --policy-name PresignedUrlAccessPolicy --policy-document file:///tmp/presignedurl-policy.json

JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-${REGION}-${HYPERPOD_CLUSTER_NAME}"

cat <<EOF > /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-controller-manager",
                "oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
            }
        }
    },
        {
        "Effect": "Allow",
        "Principal": {
            "Service": "sagemaker.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
    }
]
}
EOF

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
# Attach the existing PresignedUrlAccessPolicy to the role
aws iam attach-role-policy \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--policy-arn arn:aws:iam::${ACCOUNT_ID}:policy/PresignedUrlAccessPolicy


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

Aggiungi la policy SageMakerFullAccess al ruolo di esecuzione.


aws iam attach-role-policy --role-name=$HYPERPOD_INFERENCE_ROLE_NAME --policy-arn=arn:aws:iam::aws:policy/AmazonSageMakerFullAccess

Installazione dell’operatore di inferenza

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


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

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

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

Implementa il modello e pulisci il file di configurazione.


kubectl create -f simple_model_install.yaml
rm -f simple_model_install.yaml

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)

Controlla il tipo di istanza consigliato in Impostazioni di distribuzione.
Se modifichi il tipo di istanza, verifica la compatibilità con il HyperPod cluster. Contatta l'amministratore se le istanze compatibili non sono disponibili.
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.
Se utilizzi la governance delle attività, configura le impostazioni di priorità per le funzionalità di priorità della distribuzione dei modelli.
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 Configurazione del controllo degli accessi basato su ruoli Kubernetes

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="<Execution Role Name used in SageMaker Studio Classic>"

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"

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

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"]'

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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Distribuisci modelli su HyperPod

Implementazione di modelli di fondazione e di modelli ottimizzati con fine-tuning personalizzati