Méthode 1 : installer le module complémentaire HyperPod d'inférence via la console SageMaker AI (recommandé)Méthode 2 : Installation de l'opérateur d'inférence à l'aide de la CLI AWS Méthode 3 : installation du tableau de bord Vérification du fonctionnement de l’opérateur d’inférence (Facultatif) Configurer l'accès des utilisateurs via l' JumpStart interface utilisateur dans SageMaker AI Studio Classic

Configuration de vos HyperPod clusters pour le déploiement de modèles

Ce guide explique comment activer les fonctionnalités d'inférence sur les SageMaker HyperPod clusters Amazon. Vous allez configurer l'infrastructure, les autorisations et les opérateurs dont les ingénieurs du machine learning ont besoin pour déployer et gérer les points de terminaison d'inférence.

Note

Pour créer un cluster avec l'opérateur d'inférence préinstallé, voir. Création d'un cluster orchestré par EKS SageMaker HyperPod Pour installer l'opérateur d'inférence sur un cluster existant, suivez les procédures suivantes.

Vous pouvez installer l'opérateur d'inférence à l'aide de la console SageMaker AI pour une expérience rationalisée, ou utiliser la AWS CLI pour un meilleur contrôle. Ce guide couvre les deux méthodes d'installation.

Méthode 1 : installer le module complémentaire HyperPod d'inférence via la console SageMaker AI (recommandé)

La console SageMaker AI fournit l'expérience la plus rationalisée avec deux options d'installation :

Installation rapide : crée automatiquement toutes les ressources requises avec des valeurs par défaut optimisées, notamment les rôles IAM, les compartiments Amazon S3 et les modules complémentaires de dépendance. Un nouveau domaine Studio sera créé avec les autorisations requises pour déployer un JumpStart modèle sur le cluster concerné. Cette option est idéale pour démarrer rapidement avec un minimum de décisions de configuration.
Installation personnalisée : offre la flexibilité de spécifier les ressources existantes ou de personnaliser les configurations tout en conservant une expérience en un clic. Les clients peuvent choisir de réutiliser les rôles IAM existants, les compartiments Amazon S3 ou les modules complémentaires de dépendance en fonction des besoins de leur organisation.

Conditions préalables

Un HyperPod cluster existant avec orchestration Amazon EKS
Autorisations IAM pour l'administration du cluster Amazon EKS
kubectl configuré pour l'accès au cluster

Étapes d'installation

Accédez à la console SageMaker AI et accédez à HyperPod Clusters → Gestion des clusters.
Sélectionnez le cluster dans lequel vous souhaitez installer l'opérateur d'inférence.
Accédez à l'onglet Inférence. Sélectionnez Installation rapide pour une configuration automatisée ou Installation personnalisée pour une configuration flexible.
Si vous choisissez Installation personnalisée, spécifiez les ressources existantes ou personnalisez les paramètres selon vos besoins.
Cliquez sur Installer pour démarrer le processus d'installation automatique.

Vérifiez l'état de l'installation via la console ou en exécutant les commandes suivantes :


kubectl get pods -n hyperpod-inference-system


aws eks describe-addon --cluster-name CLUSTER-NAME --addon-name amazon-sagemaker-hyperpod-inference --region REGION

Une fois le module complémentaire correctement installé, vous pouvez déployer des modèles à l'aide de la documentation de déploiement des modèles ou accéder àVérification du fonctionnement de l’opérateur d’inférence.

Méthode 2 : Installation de l'opérateur d'inférence à l'aide de la CLI AWS

La méthode d'installation AWS CLI permet de mieux contrôler le processus d'installation et convient à l'automatisation et aux configurations avancées.

Conditions préalables

L'opérateur d'inférence permet le déploiement et la gestion des points de terminaison d'inférence d'apprentissage automatique sur votre cluster Amazon EKS. Avant l'installation, assurez-vous que votre cluster dispose des configurations de sécurité et de l'infrastructure de support requises. Procédez comme suit pour configurer les rôles IAM, installer le AWS Load Balancer Controller, configurer les pilotes Amazon S3 et FSx Amazon CSI, et déployer KEDA et cert-manager :

Connectez-vous à votre cluster et configurez des variables d'environnement
Configuration des rôles IAM pour l'opérateur d'inférence
Création du rôle de contrôleur ALB
Création du rôle d’opérateur KEDA
Installez les modules complémentaires EKS de dépendance

Note

Vous pouvez également utiliser des CloudFormation modèles pour automatiser la configuration des prérequis. Pour de plus amples informations, veuillez consulter Utilisation CloudFormation de modèles pour créer la pile de prérequis.

Connectez-vous à votre cluster et configurez des variables d'environnement

Avant de continuer, vérifiez que vos AWS informations d'identification sont correctement configurées et que vous disposez des autorisations nécessaires. Exécutez les étapes suivantes à l'aide d'un IAM principal disposant de privilèges d'administrateur et d'un accès d'administrateur de cluster à un cluster Amazon EKS. Assurez-vous d'avoir créé un HyperPod cluster avecCréation d'un SageMaker HyperPod cluster avec l'orchestration Amazon EKS. Installez les utilitaires de ligne de commande helm, eksctl et kubectl.

Pour un accès administratif Kubernetes au cluster Amazon EKS, ouvrez la console Amazon EKS et sélectionnez votre cluster. Dans l'onglet Accès, sélectionnez Entrées d'accès IAM. S'il n'existe aucune entrée pour votre principal IAM, sélectionnez Créer une entrée d'accès. Sélectionnez le principal IAM souhaité et associez-le AmazonEKSClusterAdminPolicy à celui-ci.

Configurez kubectl pour vous connecter au cluster nouvellement créé et orchestré par le HyperPod cluster Amazon EKS. Spécifiez la région et le nom du HyperPod cluster.


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

Note

Si vous utilisez un nom de bucket personnalisé qui ne commence pas parhyperpod-tls-, associez la politique suivante à votre rôle d'exécution :


{
    "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}"
                }
            }
        }
    ]
}

Définissez les variables d’environnement par défaut.


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

Extrayez le nom du cluster Amazon EKS de l’ARN du cluster, mettez à jour la configuration kubeconfig locale et vérifiez la connectivité en répertoriant tous les pods dans les espaces de noms.
```
kubectl get pods --all-namespaces
```

(Facultatif) Installez le plug-in d’appareil NVIDIA pour activer la prise en charge des GPU sur le 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

Configuration des rôles IAM pour l'opérateur d'inférence

Rassemblez les identifiants de AWS ressources essentiels ARNs nécessaires à la configuration des intégrations de services entre les composants Amazon EKS, SageMaker AI et 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)

Associez un OIDCidentity fournisseur IAM à votre cluster EKS.


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

Créez la politique de confiance requise pour le rôle IAM de l'opérateur d' HyperPod inférence. Ces politiques permettent une communication interservices sécurisée entre Amazon EKS, SageMaker AI et d'autres AWS services.


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

Créez un rôle d’exécution pour l’opérateur d’inférence.


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

Création d'un espace de noms pour les ressources des opérateurs d'inférence
```
kubectl create namespace $HYPERPOD_INFERENCE_NAMESPACE
```

Création du rôle de contrôleur ALB

Créez la politique d’approbation et la politique d’autorisations.


# 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

Appliquez des balises (kubernetes.io.role/elb) à tous les sous-réseaux du cluster Amazon EKS (publics et privés).


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

Créez un point de terminaison de 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' ' ')

Création du rôle d’opérateur KEDA

Créez la politique d’approbation et la politique d’autorisations.


# 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

Si vous utilisez des modèles à accès contrôlé, créez un rôle IAM pour accéder aux modèles à accès contrôlé.

Créez une politique 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

Créez un rôle 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

Installez les modules complémentaires EKS de dépendance

Avant d'installer l'opérateur d'inférence, vous devez installer les modules complémentaires EKS requis suivants sur votre cluster. L'opérateur d'inférence ne pourra pas s'installer si l'une de ces dépendances est manquante. Chaque module complémentaire a une version minimale requise pour être compatible avec le module complémentaire Inference.

Important

Installez tous les modules complémentaires de dépendance avant de tenter d'installer l'opérateur d'inférence. Les dépendances manquantes entraîneront des échecs d'installation avec des messages d'erreur spécifiques.

Modules complémentaires requis

Pilote CSI Amazon S3 Mountpoint (version minimale : v1.14.1-eksbuild.1)

Nécessaire pour monter des compartiments S3 en tant que volumes persistants dans les charges de travail d'inférence.
```
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
```
Pour obtenir des instructions d'installation détaillées, y compris les autorisations IAM requises, consultez le pilote CSI Mountpoint pour Amazon S3.
Pilote Amazon FSx CSI (version minimale : v1.6.0-eksbuild.1)

Nécessaire pour FSx le montage de systèmes de fichiers pour le stockage de modèles à hautes performances.
```
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
```
Pour obtenir des instructions d'installation détaillées, y compris les autorisations IAM requises, consultez le pilote Amazon FSx for Lustre CSI.
Serveur de métriques (version minimale : v0.7.2-eksbuild.4)

Nécessaire pour la fonctionnalité de mise à l'échelle automatique et la collecte de métriques de ressources.
```
aws eks create-addon \
    --cluster-name $EKS_CLUSTER_NAME \
    --addon-name metrics-server \
    --region $REGION
```
Pour obtenir des instructions d'installation détaillées, consultez Metrics Server.
Gestionnaire de certificats (version minimale : v1.18.2-eksbuild.2)

Nécessaire pour la gestion des certificats TLS pour les points de terminaison d'inférence sécurisés.
```
aws eks create-addon \
    --cluster-name $EKS_CLUSTER_NAME \
    --addon-name cert-manager \
    --region $REGION
```
Pour des instructions d'installation détaillées, consultez cert-manager.

Vérifier l'installation du module complémentaire

Après avoir installé les modules complémentaires requis, vérifiez qu'ils fonctionnent correctement :


# 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

Tous les modules complémentaires doivent afficher le statut « ACTIF » et tous les pods doivent être en état « En cours d'exécution » avant de procéder à l'installation de l'opérateur d'inférence.

Note

Si vous avez créé votre HyperPod cluster à l'aide des options de configuration rapide ou de configuration personnalisée, le pilote FSx CSI et le gestionnaire de certificats sont peut-être déjà installés. Vérifiez leur présence à l'aide des commandes ci-dessus.

Installation de l'opérateur d'inférence avec le module complémentaire EKS

La méthode d'installation du module complémentaire EKS fournit une expérience gérée avec des mises à jour automatiques et une validation intégrée des dépendances. Il s'agit de l'approche recommandée pour installer l'opérateur d'inférence.

Installation du module complémentaire d'opérateur d'inférence

Préparez la configuration du module complémentaire en rassemblant toutes les informations requises ARNs et en créant le fichier de configuration :


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

Créez le fichier de configuration du module complémentaire avec tous les paramètres requis :


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

Installez le module complémentaire d'opérateur d'inférence (version minimale : 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

Surveillez la progression de l'installation et vérifiez qu'elle est bien terminée :


# 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

Pour un dépannage détaillé des problèmes d'installation, voirHyperPod résolution des problèmes d'inférence.

Pour vérifier que l'opérateur d'inférence fonctionne correctement, passez àVérification du fonctionnement de l’opérateur d’inférence.

Utilisation CloudFormation de modèles pour créer la pile de prérequis

Au lieu de configurer manuellement les prérequis, vous pouvez utiliser des CloudFormation modèles pour automatiser la création des rôles et politiques IAM requis pour l'opérateur d'inférence.

Configurez les variables d'entrée. Remplacez les valeurs de l'espace réservé par les vôtres :


#!/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"

Obtenez des informations sur le cluster et le réseau :


# ===== 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"

Créez un fichier de paramètres et déployez une pile :


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

Surveillez l'état de création de la pile :


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

Une fois la pile créée avec succès, récupérez les valeurs de sortie à utiliser dans l'installation de l'opérateur d'inférence :
```
aws cloudformation describe-stacks \
    --stack-name $STACK_NAME \
    --region $REGION \
    --query 'Stacks[0].Outputs'
```

Une fois la CloudFormation pile créée, continuez Installation de l'opérateur d'inférence avec le module complémentaire EKS à installer l'opérateur d'inférence.

Méthode 3 : installation du tableau de bord

Utilisez cette méthode si vous avez besoin de mieux contrôler la configuration de l'installation ou si le module complémentaire EKS n'est pas disponible dans votre région.

Conditions préalables

Avant de continuer, vérifiez que vos AWS informations d'identification sont correctement configurées et que vous disposez des autorisations nécessaires. Les étapes suivantes doivent être exécutées par un administrateur principal IAM disposant de privilèges d'administrateur et d'un accès d'administrateur de cluster à un cluster Amazon EKS. Vérifiez que vous avez créé un HyperPod cluster avecCréation d'un SageMaker HyperPod cluster avec l'orchestration Amazon EKS. Vérifiez que vous avez installé les utilitaires de ligne de commande helm, eksctl et kubectl.

Pour un accès administratif Kubernetes au cluster Amazon EKS, accédez à la console Amazon EKS et sélectionnez le cluster que vous utilisez. Dans l’onglet Accès, sélectionnez les entrées d’accès IAM. S’il n’y a pas d’entrée pour votre principal IAM, sélectionnez Créer une entrée d’accès. Sélectionnez ensuite le principal IAM souhaité et associez-lui la politique AmazonEKSClusterAdminPolicy.

Configurez kubectl pour vous connecter au cluster nouvellement créé et orchestré par le HyperPod cluster Amazon EKS. Spécifiez la région et le nom du HyperPod cluster.


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

Définissez les variables d’environnement par défaut.


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"

Extrayez le nom du cluster Amazon EKS de l’ARN du cluster, mettez à jour la configuration kubeconfig locale et vérifiez la connectivité en répertoriant tous les pods dans les espaces de noms.
```
kubectl get pods --all-namespaces
```

(Facultatif) Installez le plug-in d’appareil NVIDIA pour activer la prise en charge des GPU sur le 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

Préparation de votre environnement pour l’installation de l’opérateur d’inférence

Rassemblez les identifiants de AWS ressources essentiels ARNs nécessaires à la configuration des intégrations de services entre les composants Amazon EKS, SageMaker AI et 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)

Associez un OIDCidentity fournisseur IAM à votre cluster EKS.


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

Créez les documents JSON de politique de confiance et de politique d'autorisation requis pour le rôle IAM d'opérateur d' HyperPod inférence. Ces politiques permettent une communication interservices sécurisée entre Amazon EKS, SageMaker AI et d'autres AWS services.


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

Créez un rôle d’exécution pour l’opérateur d’inférence.


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

Téléchargez et créez la politique IAM requise pour que le AWS Load Balancer Controller gère les équilibreurs de charge d'application et les équilibreurs de charge réseau dans votre 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

Créez un compte de service IAM qui lie le compte de service Kubernetes à la politique IAM, permettant au AWS Load Balancer Controller d'obtenir les AWS autorisations nécessaires via 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"

Appliquez des balises (kubernetes.io.role/elb) à tous les sous-réseaux du cluster Amazon EKS (publics et privés).


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

Créez un espace de noms pour KEDA et le gestionnaire de certificats.
```
kubectl create namespace keda
kubectl create namespace cert-manager
```

Créez un point de terminaison de 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' ' ')

Configurez l’accès au stockage S3 :

Créez une politique IAM qui accorde les autorisations S3 nécessaires pour utiliser Mountpoint pour Amazon S3, ce qui permet au système de fichiers d’accéder aux compartiments S3 depuis le 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"

(Facultatif) Créez un compte de service IAM pour le pilote CSI Amazon S3. Le pilote Amazon S3 CSI nécessite un compte de service IAM doté des autorisations appropriées pour monter des compartiments S3 en tant que volumes persistants dans votre cluster Amazon EKS. Cette étape crée le rôle IAM et le compte de service Kubernetes nécessaires avec la stratégie d’accès S3 requise.


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

(Facultatif) Installez le module complémentaire du pilote CSI Amazon S3. Ce pilote permet à vos pods de monter des compartiments S3 sous forme de volumes persistants, fournissant ainsi un accès direct au stockage S3 depuis vos charges de travail 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
```

(Facultatif) Créez une demande de volume persistant (PVC) pour le stockage S3. Ce PVC permet à vos pods de demander et d’utiliser le stockage S3 comme s’il s’agissait d’un système de fichiers traditionnel.


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

(Facultatif) Configurez l'accès au FSx stockage. Créez un compte de service IAM pour le pilote Amazon FSx CSI. Ce compte de service sera utilisé par le pilote FSx CSI pour interagir avec le FSx service Amazon au nom de votre 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

Création du rôle d’opérateur KEDA

Créez la politique d’approbation et la politique d’autorisations.


# 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

Si vous utilisez des modèles à accès contrôlé, créez un rôle IAM pour accéder aux modèles à accès contrôlé.

Créez une politique 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

Créez un rôle 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

Ajoutez la politique SageMakerFullAccess au rôle d’exécution.


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

Installation de l’opérateur d’inférence

Installez l'opérateur HyperPod d'inférence. Cette étape rassemble les identifiants de ressources AWS requis et génère la commande d’installation Helm avec les paramètres de configuration appropriés.

Accédez au graphique de barre depuis 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

Configurez les annotations du compte de service pour l’intégration IAM. Cette annotation permet au compte de service de l’opérateur de disposer des autorisations IAM nécessaires pour gérer les points de terminaison d’inférence et interagir avec les services 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

Vérification du fonctionnement de l’opérateur d’inférence

Suivez ces étapes pour vérifier que l'installation de votre opérateur d'inférence fonctionne correctement en déployant et en testant un modèle simple.

Déployer un modèle de test pour vérifier l'opérateur

Créez un fichier de configuration de déploiement de modèle. Cela crée un fichier manifeste Kubernetes qui définit un déploiement de JumpStart modèle pour l' HyperPodopérateur d'inférence.


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

Déployez le modèle et nettoyez le fichier de configuration.


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

Vérifiez la configuration du compte de service pour vous assurer que l'opérateur peut assumer AWS les autorisations.


# 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

Configurer les paramètres de déploiement (si vous utilisez l'interface utilisateur de Studio)

Passez en revue le type d'instance recommandé sous Paramètres de déploiement.
Si vous modifiez le type d'instance, assurez-vous de la compatibilité avec votre HyperPod cluster. Contactez votre administrateur si des instances compatibles ne sont pas disponibles.
Pour les instances partitionnées par GPU avec MIG activé, sélectionnez une partition GPU appropriée parmi les profils MIG disponibles afin d'optimiser l'utilisation du GPU. Pour de plus amples informations, veuillez consulter Utilisation de partitions GPU dans Amazon SageMaker HyperPod.
Si vous utilisez la gouvernance des tâches, configurez les paramètres de priorité pour les fonctionnalités de préemption du déploiement du modèle.
Entrez l'espace de noms fourni par votre administrateur. Contactez votre administrateur pour obtenir le bon espace de noms si nécessaire.

(Facultatif) Configurer l'accès des utilisateurs via l' JumpStart interface utilisateur dans SageMaker AI Studio Classic

Pour plus d'informations sur la configuration de SageMaker HyperPod l'accès pour les utilisateurs de Studio Classic et sur la configuration d'autorisations Kubernetes RBAC détaillées pour les utilisateurs de data scientists, lisez et. Configuration d’un cluster Amazon EKS dans Studio Configuration du contrôle d’accès basé sur les rôles Kubernetes

Identifiez le rôle IAM que les utilisateurs de Data Scientist utiliseront pour gérer et déployer des modèles SageMaker HyperPod depuis SageMaker AI Studio Classic. Il s’agit généralement du rôle d’exécution du profil utilisateur ou du rôle d’exécution du domaine pour l’utilisateur de 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"

Attachez une politique d’identité permettant l’accès au déploiement du modèle.


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

Créez une entrée d’accès EKS pour l’utilisateur en le mappant à un groupe 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"]'

Créez des politiques RBAC Kubernetes pour l’utilisateur.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déployez des modèles sur HyperPod

Déploiement de modèles de fondation et de modèles personnalisés et peaufinés