Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Einrichtung Ihrer HyperPod Cluster für die Modellbereitstellung
Diese Anleitung zeigt Ihnen, wie Sie Inferenzfunktionen auf SageMaker HyperPod Amazon-Clustern aktivieren. Sie richten die Infrastruktur, die Berechtigungen und die Operatoren ein, die Techniker für maschinelles Lernen benötigen, um Inferenzendpunkte bereitzustellen und zu verwalten.
**Anmerkung**
Informationen zum Erstellen eines Clusters mit vorinstalliertem Inferenzoperator finden Sie unter. [Erstellen Sie einen EKS-orchestrierten Cluster SageMaker HyperPod](sagemaker-hyperpod-quickstart.md#sagemaker-hyperpod-quickstart-eks) Um den Inferenzoperator auf einem vorhandenen Cluster zu installieren, fahren Sie mit den folgenden Verfahren fort.
Sie können den Inferenzoperator mithilfe der SageMaker KI-Konsole installieren, um ein optimiertes Erlebnis zu erzielen, oder die AWS CLI für mehr Kontrolle verwenden. Dieses Handbuch behandelt beide Installationsmethoden.
## Methode 1: Installieren Sie das HyperPod Inference Add-on über die SageMaker AI-Konsole (empfohlen)
Die SageMaker AI-Konsole bietet mit zwei Installationsoptionen die optimierteste Benutzererfahrung:
+ **Schnellinstallation:** Erstellt automatisch alle erforderlichen Ressourcen mit optimierten Standardeinstellungen, einschließlich IAM-Rollen, Amazon S3 S3-Buckets und Abhängigkeits-Add-Ons. Es wird eine neue Studio-Domain mit den erforderlichen Berechtigungen für die Bereitstellung eines JumpStart Modells im entsprechenden Cluster erstellt. Diese Option ist ideal für einen schnellen Einstieg mit minimalen Konfigurationsentscheidungen.
+ **Benutzerdefinierte Installation:** Bietet Flexibilität bei der Angabe vorhandener Ressourcen oder der Anpassung von Konfigurationen bei gleichzeitiger Beibehaltung des Ein-Klick-Erlebnisses. Kunden können je nach ihren organisatorischen Anforderungen wählen, ob sie bestehende IAM-Rollen, Amazon S3 S3-Buckets oder Abhängigkeits-Add-ons wiederverwenden möchten.
### Voraussetzungen
+ Ein vorhandener HyperPod Cluster mit Amazon EKS-Orchestrierung
+ IAM-Berechtigungen für die Amazon EKS-Clusterverwaltung
+ kubectl ist für den Clusterzugriff konfiguriert
### Schritte zur Installation
1. Navigieren Sie zur SageMaker AI-Konsole und gehen Sie zu **HyperPod Clusters** **→ Cluster Management**.
1. Wählen Sie Ihren Cluster aus, in dem Sie den Inference Operator installieren möchten.
1. Navigieren Sie zur Registerkarte **Inferenz.** Wählen Sie „**Schnellinstallation**“ für die automatische Installation oder „**Benutzerdefinierte Installation**“ für eine flexible Konfiguration.
1. Wenn Sie sich für benutzerdefinierte Installation entscheiden, geben Sie vorhandene Ressourcen an oder passen Sie die Einstellungen nach Bedarf an.
1. Klicken Sie auf **Installieren**, um den automatisierten Installationsvorgang zu starten.
1. Überprüfen Sie den Installationsstatus über die Konsole oder indem Sie die folgenden Befehle ausführen:
```
kubectl get pods -n hyperpod-inference-system
```
```
aws eks describe-addon --cluster-name CLUSTER-NAME --addon-name amazon-sagemaker-hyperpod-inference --region REGION
```
Nachdem das Add-on erfolgreich installiert wurde, können Sie Modelle mithilfe der Dokumentation zur Modellbereitstellung bereitstellen oder zu navigieren[Stellen Sie sicher, dass der Inferenzoperator funktioniert](#sagemaker-hyperpod-model-deployment-setup-verify).
## Methode 2: Installation des Inferenzoperators mit der CLI AWS
Die AWS CLI-Installationsmethode bietet mehr Kontrolle über den Installationsprozess und eignet sich für Automatisierung und erweiterte Konfigurationen.
### Voraussetzungen
Der Inferenzoperator ermöglicht die Bereitstellung und Verwaltung von Inferenzendpunkten für maschinelles Lernen auf Ihrem Amazon EKS-Cluster. Stellen Sie vor der Installation sicher, dass Ihr Cluster über die erforderlichen Sicherheitskonfigurationen und die unterstützende Infrastruktur verfügt. Gehen Sie wie folgt vor, um IAM-Rollen zu konfigurieren, den Load AWS Balancer Controller zu installieren, Amazon S3- und Amazon FSx CSI-Treiber einzurichten und KEDA und cert-manager bereitzustellen:
1. [Connect zu Ihrem Cluster her und richten Sie Umgebungsvariablen ein](#sagemaker-hyperpod-model-deployment-setup-connect-addon)
1. [Konfigurieren Sie IAM-Rollen für den Inferenzoperator](#sagemaker-hyperpod-model-deployment-setup-prepare-addon)
1. [Erstellen Sie die ALB-Controller-Rolle](#sagemaker-hyperpod-model-deployment-setup-alb-addon)
1. [Erstellen Sie die KEDA-Operatorrolle](#sagemaker-hyperpod-model-deployment-setup-keda-addon)
1. [Installieren Sie die Abhängigkeiten EKS Add-Ons](#sagemaker-hyperpod-model-deployment-setup-install-dependencies)
**Anmerkung**
Alternativ können Sie CloudFormation Vorlagen verwenden, um die Einrichtung der Voraussetzungen zu automatisieren. Weitere Informationen finden Sie unter [Verwenden von CloudFormation Vorlagen zur Erstellung des Stacks für die erforderlichen Komponenten](#sagemaker-hyperpod-model-deployment-setup-cfn).
### Connect zu Ihrem Cluster her und richten Sie Umgebungsvariablen ein
Bevor Sie fortfahren, stellen Sie sicher, dass Ihre AWS Anmeldeinformationen ordnungsgemäß konfiguriert sind und über die erforderlichen Berechtigungen verfügen. Führen Sie die folgenden Schritte mit einem IAM-Prinzipal mit Administratorrechten und Cluster-Admin-Zugriff auf einen Amazon EKS-Cluster aus. Stellen Sie sicher, dass Sie einen HyperPod Cluster mit [Erstellen eines SageMaker HyperPod Clusters mit Amazon EKS-Orchestrierung](sagemaker-hyperpod-eks-operate-console-ui-create-cluster.md) erstellt haben. Installieren Sie die Befehlszeilenprogramme helm, eksctl und kubectl.
Für Kubernetes-Administratorzugriff auf den Amazon EKS-Cluster öffnen Sie die Amazon EKS-Konsole und wählen Sie Ihren Cluster aus. Wählen Sie auf der Registerkarte **Zugriff** die Option **IAM-Zugriffseinträge** aus. Wenn für Ihren IAM-Prinzipal kein Eintrag vorhanden ist, wählen Sie „**Zugangseintrag erstellen**“ aus. Wählen Sie den gewünschten IAM-Prinzipal aus und ordnen Sie ihn `AmazonEKSClusterAdminPolicy` zu.
1. Konfigurieren Sie kubectl so, dass es eine Verbindung zu dem neu erstellten HyperPod Cluster herstellt, der vom Amazon EKS-Cluster orchestriert wird. Geben Sie die Region und HyperPod den Clusternamen an.
```
export HYPERPOD_CLUSTER_NAME=
export REGION=
# S3 bucket where tls certificates will be uploaded
export BUCKET_NAME="hyperpod-tls-" # Bucket should have prefix: hyperpod-tls-*
export EKS_CLUSTER_NAME=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
--query 'Orchestrator.Eks.ClusterArn' --output text | \
cut -d'/' -f2)
aws eks update-kubeconfig --name $EKS_CLUSTER_NAME --region $REGION
```
**Anmerkung**
Wenn Sie einen benutzerdefinierten Bucket-Namen verwenden, der nicht mit beginnt`hyperpod-tls-`, fügen Sie Ihrer Ausführungsrolle die folgende Richtlinie hinzu:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "TLSBucketDeleteObjectsPermission",
"Effect": "Allow",
"Action": ["s3:DeleteObject"],
"Resource": ["arn:aws:s3:::${BUCKET_NAME}/*"],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
},
{
"Sid": "TLSBucketGetObjectAccess",
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": ["arn:aws:s3:::${BUCKET_NAME}/*"]
},
{
"Sid": "TLSBucketPutObjectAccess",
"Effect": "Allow",
"Action": ["s3:PutObject", "s3:PutObjectTagging"],
"Resource": ["arn:aws:s3:::${BUCKET_NAME}/*"],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
}
]
}
```
1. Legen Sie die Standard-Umgebungsvariablen fest.
```
HYPERPOD_INFERENCE_ROLE_NAME="SageMakerHyperPodInference-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_NAMESPACE="hyperpod-inference-system"
```
1. Extrahieren Sie den Amazon EKS-Clusternamen aus dem Cluster-ARN, aktualisieren Sie die lokale kubeconfig und überprüfen Sie die Konnektivität, indem Sie alle Pods in NameBereiche auflisten.
```
kubectl get pods --all-namespaces
```
1. (Optional) Installieren Sie das NVIDIA-Geräte-Plugin, um die GPU-Unterstützung auf dem Cluster zu aktivieren.
```
# 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
```
### Konfigurieren Sie IAM-Rollen für den Inferenzoperator
1. Sammeln Sie wichtige AWS Ressourcen-Identifikatoren, die für die Konfiguration von Serviceintegrationen zwischen Amazon EKS-, SageMaker KI- und IAM-Komponenten ARNs erforderlich sind.
```
%%bash -x
export ACCOUNT_ID=$(aws --region $REGION sts get-caller-identity --query 'Account' --output text)
export OIDC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
export EKS_CLUSTER_ROLE=$(aws eks --region $REGION describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.roleArn' --output text)
```
1. Ordnen Sie Ihrem EKS-Cluster einen OIDCidentity IAM-Anbieter zu.
```
eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve
```
1. Erstellen Sie die Vertrauensrichtlinie, die für die IAM-Rolle des HyperPod Inferenzoperators erforderlich ist. Diese Richtlinien ermöglichen eine sichere dienstübergreifende Kommunikation zwischen Amazon EKS, SageMaker KI und anderen AWS Diensten.
```
%%bash -x
# Create trust policy JSON
cat << EOF > trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::${ACCOUNT_ID}:oidc-provider/oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:aud": "sts.amazonaws.com",
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:sub": "system:serviceaccount:hyperpod-inference-system:hyperpod-inference-controller-manager"
}
}
}
]
}
EOF
```
1. Erstellen Sie eine Ausführungsrolle für den Inferenzoperator.
```
aws iam create-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --assume-role-policy-document file://trust-policy.json
aws iam attach-role-policy --role-name $HYPERPOD_INFERENCE_ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodInferenceAccess
```
1. Erstellen Sie einen Namespace für Ressourcen von Inferenzoperatoren
```
kubectl create namespace $HYPERPOD_INFERENCE_NAMESPACE
```
### Erstellen Sie die ALB-Controller-Rolle
1. Erstellen der Vertrauens- und Berechtigungsrichtlinie
```
# Create trust policy
cat < /tmp/alb-trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:hyperpod-inference-system:aws-load-balancer-controller",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
}
]
}
EOF
# Create permissions policy
export ALBController_IAM_POLICY_NAME=HyperPodInferenceALBControllerIAMPolicy
curl -o AWSLoadBalancerControllerIAMPolicy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.13.0/docs/install/iam_policy.json
# Create the role
aws iam create-role \
--role-name alb-role \
--assume-role-policy-document file:///tmp/alb-trust-policy.json
# Create the policy
ALB_POLICY_ARN=$(aws iam create-policy \
--policy-name $ALBController_IAM_POLICY_NAME \
--policy-document file://AWSLoadBalancerControllerIAMPolicy.json \
--query 'Policy.Arn' \
--output text)
# Attach the policy to the role
aws iam attach-role-policy \
--role-name alb-role \
--policy-arn $ALB_POLICY_ARN
```
1. Wenden Sie Tags (`kubernetes.io.role/elb`) auf alle Subnetze im Amazon EKS-Cluster (sowohl öffentlich als auch privat) an.
```
export VPC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.resourcesVpcConfig.vpcId' --output text)
# Add Tags
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' | \
xargs -I{} aws ec2 create-tags --resources {} --tags Key=kubernetes.io/role/elb,Value=1
# Verify Tags are added
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' |
xargs -n1 -I{} aws ec2 describe-tags --filters "Name=resource-id,Values={}" "Name=key,Values=kubernetes.io/role/elb" --query "Tags[0].Value" --output text
```
1. Erstellen Sie einen Amazon-S3-VPC-Endpunkt.
```
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' ' ')
```
### Erstellen Sie die KEDA-Operatorrolle
1. Erstellen der Vertrauens- und Berechtigungsrichtlinie
```
# Create trust policy
cat < /tmp/keda-trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:hyperpod-inference-system:keda-operator",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
}
]
}
EOF
# Create permissions policy
cat < /tmp/keda-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"aps:QueryMetrics",
"aps:GetLabels",
"aps:GetSeries",
"aps:GetMetricMetadata"
],
"Resource": "*"
}
]
}
EOF
# Create the role
aws iam create-role \
--role-name keda-operator-role \
--assume-role-policy-document file:///tmp/keda-trust-policy.json
# Create the policy
KEDA_POLICY_ARN=$(aws iam create-policy \
--policy-name KedaOperatorPolicy \
--policy-document file:///tmp/keda-policy.json \
--query 'Policy.Arn' \
--output text)
# Attach the policy to the role
aws iam attach-role-policy \
--role-name keda-operator-role \
--policy-arn $KEDA_POLICY_ARN
```
1. Wenn Sie geschützte Modelle verwenden, erstellen Sie eine IAM-Rolle, um auf die geschützten Modelle zuzugreifen.
1. Erstellen Sie eine IAM-Richtlinie.
```
%%bash -s $REGION
JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-${REGION}-${HYPERPOD_CLUSTER_NAME}"
cat < /tmp/trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:*:hyperpod-inference-service-account*",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
```
1. Erstellen Sie eine IAM-Rolle.
```
# 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
```
### Installieren Sie die Abhängigkeiten EKS Add-Ons
Bevor Sie den Inferenzoperator installieren, müssen Sie die folgenden erforderlichen EKS-Add-Ons auf Ihrem Cluster installieren. Der Inferenzoperator kann nicht installiert werden, wenn eine dieser Abhängigkeiten fehlt. Für jedes Add-on ist eine Mindestversion erforderlich, um die Kompatibilität mit dem Inference-Add-on zu gewährleisten.
**Wichtig**
Installieren Sie alle Add-Ons für Abhängigkeiten, bevor Sie versuchen, den Inferenzoperator zu installieren. Fehlende Abhängigkeiten führen zu Installationsfehlern mit spezifischen Fehlermeldungen.
#### Erforderliche Add-Ons
1. **Amazon S3 Mountpoint CSI-Treiber** (Mindestversion: v1.14.1-eksbuild.1)
Erforderlich für das Mounten von S3-Buckets als persistente Volumes in Inferenz-Workloads.
```
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
```
Detaillierte Installationsanweisungen, einschließlich der erforderlichen IAM-Berechtigungen, finden Sie unter [Mountpoint for Amazon S3](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#mountpoint-for-s3-add-on) CSI-Treiber.
1. **Amazon FSx CSI-Treiber** (Mindestversion: v1.6.0-eksbuild.1)
Erforderlich für das Mounten von Dateisystemen für Hochleistungsmodellspeicher. 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
```
Detaillierte Installationsanweisungen, einschließlich der erforderlichen IAM-Berechtigungen, finden Sie unter [Amazon FSx for Lustre CSI-Treiber.](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#add-ons-aws-fsx-csi-driver)
1. **Metrics Server** (Mindestversion: v0.7.2-eksbuild.4)
Erforderlich für die Autoscaling-Funktionalität und die Erfassung von Ressourcenmetriken.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name metrics-server \
--region $REGION
```
Detaillierte Installationsanweisungen finden Sie unter [Metrics Server](https://docs.aws.amazon.com/eks/latest/userguide/metrics-server.html).
1. **Cert Manager** (Mindestversion: v1.18.2-eksbuild.2)
Erforderlich für die Verwaltung von TLS-Zertifikaten für sichere Inferenzendpunkte.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name cert-manager \
--region $REGION
```
[Detaillierte Installationsanweisungen finden Sie unter cert-manager.](https://docs.aws.amazon.com/eks/latest/userguide/community-addons.html#addon-cert-manager)
#### Überprüfen Sie die Installation des Add-ons
Stellen Sie nach der Installation der erforderlichen Add-Ons sicher, dass sie ordnungsgemäß ausgeführt werden:
```
# 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
```
Alle Add-Ons sollten den Status „AKTIV“ haben und alle Pods sollten sich im Status „Running“ befinden, bevor Sie mit der Installation des Inference Operators fortfahren.
**Anmerkung**
Wenn Sie Ihren HyperPod Cluster mit den Optionen für die Schnellinstallation oder die benutzerdefinierte Einrichtung erstellt haben, sind der FSx CSI-Treiber und der Cert Manager möglicherweise bereits installiert. Überprüfen Sie mithilfe der obigen Befehle, ob sie vorhanden sind.
### Installation des Inference Operators mit dem EKS-Add-on
Die Installationsmethode für das EKS-Add-on bietet eine verwaltete Erfahrung mit automatischen Updates und integrierter Abhängigkeitsprüfung. Dies ist der empfohlene Ansatz für die Installation des Inferenzoperators.
**Installieren Sie das Inferenzoperator-Add-on**
1. Bereiten Sie die Add-On-Konfiguration vor, indem Sie alle erforderlichen Daten ARNs zusammenstellen und die Konfigurationsdatei erstellen:
```
# Gather required ARNs
export EXECUTION_ROLE_ARN=$(aws iam get-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --query "Role.Arn" --output text)
export HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME --region $REGION --query "ClusterArn" --output text)
export KEDA_ROLE_ARN=$(aws iam get-role --role-name keda-operator-role --query 'Role.Arn' --output text)
export ALB_ROLE_ARN=$(aws iam get-role --role-name alb-role --query 'Role.Arn' --output text)
# Verify all ARNs are set correctly
echo "Execution Role ARN: $EXECUTION_ROLE_ARN"
echo "HyperPod Cluster ARN: $HYPERPOD_CLUSTER_ARN"
echo "KEDA Role ARN: $KEDA_ROLE_ARN"
echo "ALB Role ARN: $ALB_ROLE_ARN"
echo "TLS S3 Bucket: $BUCKET_NAME"
```
1. Erstellen Sie die Add-On-Konfigurationsdatei mit allen erforderlichen Einstellungen:
```
cat > addon-config.json << EOF
{
"executionRoleArn": "$EXECUTION_ROLE_ARN",
"tlsCertificateS3Bucket": "$BUCKET_NAME",
"hyperpodClusterArn": "$HYPERPOD_CLUSTER_ARN",
"jumpstartGatedModelDownloadRoleArn": "$JUMPSTART_GATED_ROLE_ARN",
"alb": {
"serviceAccount": {
"create": true,
"roleArn": "$ALB_ROLE_ARN"
}
},
"keda": {
"auth": {
"aws": {
"irsa": {
"roleArn": "$KEDA_ROLE_ARN"
}
}
}
}
}
EOF
# Verify the configuration file
cat addon-config.json
```
1. Installieren Sie das Inferenzoperator-Add-on (Mindestversion: v1.0.0-eksbuild.1):
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name amazon-sagemaker-hyperpod-inference \
--configuration-values file://addon-config.json \
--region $REGION
```
1. Überwachen Sie den Installationsfortschritt und stellen Sie sicher, dass die Installation erfolgreich abgeschlossen wurde:
```
# 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
```
Ausführliche Informationen zur Behebung von Installationsproblemen finden Sie unter[HyperPod Fehlerbehebung bei Inferenzen](sagemaker-hyperpod-model-deployment-ts.md).
Um zu überprüfen, ob der Inferenzoperator ordnungsgemäß funktioniert, fahren Sie fort mit[Stellen Sie sicher, dass der Inferenzoperator funktioniert](#sagemaker-hyperpod-model-deployment-setup-verify).
### Verwenden von CloudFormation Vorlagen zur Erstellung des Stacks für die erforderlichen Komponenten
Als Alternative zur manuellen Konfiguration der Voraussetzungen können Sie CloudFormation Vorlagen verwenden, um die Erstellung der erforderlichen IAM-Rollen und -Richtlinien für den Inferenzoperator zu automatisieren.
1. Richten Sie Eingabevariablen ein. Ersetzen Sie die Platzhalterwerte durch Ihre eigenen:
```
#!/bin/bash
set -e
# ===== INPUT VARIABLES =====
HP_CLUSTER_NAME="my-hyperpod-cluster" # Replace with your HyperPod cluster name
REGION="us-east-1" # Replace with your AWS region
PREFIX="my-prefix" # Replace with your resource prefix
SHORT_PREFIX="12a34d56" # Replace with your short prefix (maximum 8 characters)
CREATE_DOMAIN="true" # Set to "false" if you don't need a SageMaker Studio domain
STACK_NAME="hyperpod-inference-prerequisites" # Replace with your stack name
TEMPLATE_URL="https://aws-sagemaker-hyperpod-cluster-setup-${REGION}-prod.s3.${REGION}.amazonaws.com/templates/main-stack-inference-operator-addon-template.yaml"
```
1. Cluster- und Netzwerkinformationen ableiten:
```
# ===== DERIVE EKS CLUSTER NAME =====
EKS_CLUSTER_NAME=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --region $REGION --query 'Orchestrator.Eks.ClusterArn' --output text | awk -F'/' '{print $NF}')
echo "EKS_CLUSTER_NAME=$EKS_CLUSTER_NAME"
# ===== GET VPC AND OIDC =====
VPC_ID=$(aws eks describe-cluster --name $EKS_CLUSTER_NAME --region $REGION --query 'cluster.resourcesVpcConfig.vpcId' --output text)
echo "VPC_ID=$VPC_ID"
OIDC_PROVIDER=$(aws eks describe-cluster --name $EKS_CLUSTER_NAME --region $REGION --query 'cluster.identity.oidc.issuer' --output text | sed 's|https://||')
echo "OIDC_PROVIDER=$OIDC_PROVIDER"
# ===== GET PRIVATE ROUTE TABLES =====
ALL_ROUTE_TABLES=$(aws ec2 describe-route-tables --region $REGION --filters "Name=vpc-id,Values=$VPC_ID" --query 'RouteTables[].RouteTableId' --output text)
EKS_PRIVATE_ROUTE_TABLES=""
for rtb in $ALL_ROUTE_TABLES; do
HAS_IGW=$(aws ec2 describe-route-tables --region $REGION --route-table-ids $rtb --query 'RouteTables[0].Routes[?GatewayId && starts_with(GatewayId, `igw-`)]' --output text 2>/dev/null)
if [ -z "$HAS_IGW" ]; then
EKS_PRIVATE_ROUTE_TABLES="${EKS_PRIVATE_ROUTE_TABLES:+$EKS_PRIVATE_ROUTE_TABLES,}$rtb"
fi
done
echo "EKS_PRIVATE_ROUTE_TABLES=$EKS_PRIVATE_ROUTE_TABLES"
# ===== CHECK S3 VPC ENDPOINT =====
S3_ENDPOINT_EXISTS=$(aws ec2 describe-vpc-endpoints --region $REGION --filters "Name=vpc-id,Values=$VPC_ID" "Name=service-name,Values=com.amazonaws.$REGION.s3" --query 'VpcEndpoints[0].VpcEndpointId' --output text)
CREATE_S3_ENDPOINT_STACK=$([ "$S3_ENDPOINT_EXISTS" == "None" ] && echo "true" || echo "false")
echo "CREATE_S3_ENDPOINT_STACK=$CREATE_S3_ENDPOINT_STACK"
# ===== GET HYPERPOD DETAILS =====
HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --region $REGION --query 'ClusterArn' --output text)
echo "HYPERPOD_CLUSTER_ARN=$HYPERPOD_CLUSTER_ARN"
# ===== GET DEFAULT VPC FOR DOMAIN =====
DOMAIN_VPC_ID=$(aws ec2 describe-vpcs --region $REGION --filters "Name=isDefault,Values=true" --query 'Vpcs[0].VpcId' --output text)
echo "DOMAIN_VPC_ID=$DOMAIN_VPC_ID"
DOMAIN_SUBNET_IDS=$(aws ec2 describe-subnets --region $REGION --filters "Name=vpc-id,Values=$DOMAIN_VPC_ID" --query 'Subnets[0].SubnetId' --output text)
echo "DOMAIN_SUBNET_IDS=$DOMAIN_SUBNET_IDS"
# ===== GET INSTANCE GROUPS =====
INSTANCE_GROUPS=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --region $REGION --query 'InstanceGroups[].InstanceGroupName' --output json | python3 -c "import sys, json; groups = json.load(sys.stdin); print('[' + ','.join([f'\\\\\\\"' + g + '\\\\\\\"' for g in groups]) + ']')")
echo "INSTANCE_GROUPS=$INSTANCE_GROUPS"
```
1. Parameterdatei erstellen und Stack bereitstellen:
```
# ===== CREATE PARAMETERS JSON =====
cat > /tmp/cfn-params.json << EOF
[
{"ParameterKey":"ResourceNamePrefix","ParameterValue":"$PREFIX"},
{"ParameterKey":"ResourceNameShortPrefix","ParameterValue":"$SHORT_PREFIX"},
{"ParameterKey":"VpcId","ParameterValue":"$VPC_ID"},
{"ParameterKey":"EksPrivateRouteTableIds","ParameterValue":"$EKS_PRIVATE_ROUTE_TABLES"},
{"ParameterKey":"EKSClusterName","ParameterValue":"$EKS_CLUSTER_NAME"},
{"ParameterKey":"OIDCProviderURLWithoutProtocol","ParameterValue":"$OIDC_PROVIDER"},
{"ParameterKey":"HyperPodClusterArn","ParameterValue":"$HYPERPOD_CLUSTER_ARN"},
{"ParameterKey":"HyperPodClusterName","ParameterValue":"$HP_CLUSTER_NAME"},
{"ParameterKey":"CreateDomain","ParameterValue":"$CREATE_DOMAIN"},
{"ParameterKey":"DomainVpcId","ParameterValue":"$DOMAIN_VPC_ID"},
{"ParameterKey":"DomainSubnetIds","ParameterValue":"$DOMAIN_SUBNET_IDS"},
{"ParameterKey":"CreateS3EndpointStack","ParameterValue":"$CREATE_S3_ENDPOINT_STACK"},
{"ParameterKey":"TieredStorageConfig","ParameterValue":"{\"Mode\":\"Enable\",\"InstanceMemoryAllocationPercentage\":20}"},
{"ParameterKey":"TieredKVCacheConfig","ParameterValue":"{\"KVCacheMode\":\"Enable\",\"InstanceGroup\":$INSTANCE_GROUPS,\"NVMeMode\":\"Enable\"}"}
]
EOF
echo -e "\n===== CREATING CLOUDFORMATION STACK ====="
aws cloudformation create-stack \
--region $REGION \
--stack-name $STACK_NAME \
--template-url $TEMPLATE_URL \
--parameters file:///tmp/cfn-params.json \
--capabilities CAPABILITY_NAMED_IAM
```
1. Überwachen Sie den Status der Stack-Erstellung:
```
aws cloudformation describe-stacks \
--stack-name $STACK_NAME \
--region $REGION \
--query 'Stacks[0].StackStatus'
```
1. Sobald der Stack erfolgreich erstellt wurde, rufen Sie die Ausgabewerte zur Verwendung in der Installation des Inferenzoperators ab:
```
aws cloudformation describe-stacks \
--stack-name $STACK_NAME \
--region $REGION \
--query 'Stacks[0].Outputs'
```
Nachdem der CloudFormation Stack erstellt wurde, fahren Sie mit [Installation des Inference Operators mit dem EKS-Add-on](#sagemaker-hyperpod-model-deployment-setup-install-inference-operator-addon) der Installation des Inferenzoperators fort.
## Methode 3: Installation des Helmdiagramms
**Anmerkung**
Für eine möglichst einfache Installation empfehlen wir die Verwendung von [Methode 1: Installieren Sie das HyperPod Inference Add-on über die SageMaker AI-Konsole (empfohlen)](#sagemaker-hyperpod-model-deployment-setup-ui) oder[Methode 2: Installation des Inferenzoperators mit der CLI AWS](#sagemaker-hyperpod-model-deployment-setup-addon). Die Installation von Helm-Charts ist in einer future Version möglicherweise veraltet.
### Voraussetzungen
Bevor Sie fortfahren, stellen Sie sicher, dass Ihre AWS Anmeldeinformationen ordnungsgemäß konfiguriert sind und über die erforderlichen Berechtigungen verfügen. Die folgenden Schritte müssen von einem IAM-Prinzipal mit Administratorrechten und Cluster-Admin-Zugriff auf einen Amazon EKS-Cluster ausgeführt werden. Stellen Sie sicher, dass Sie einen HyperPod Cluster mit [Erstellen eines SageMaker HyperPod Clusters mit Amazon EKS-Orchestrierung](sagemaker-hyperpod-eks-operate-console-ui-create-cluster.md) erstellt haben. Stellen Sie sicher, dass Sie die Befehlszeilenprogramme helm, eksctl und kubectl installiert haben.
Um Kubernetes-Administratorzugriff auf den Amazon EKS-Cluster zu erhalten, gehen Sie zur Amazon EKS-Konsole und wählen Sie den Cluster aus, den Sie verwenden. Suchen Sie **auf der Registerkarte „Zugriff**“ nach und wählen Sie „IAM Access Entries“ aus. Wenn es keinen Eintrag für Ihren IAM-Principal gibt, wählen Sie **Access-Eintrag erstellen** aus. Wählen Sie dann den gewünschten IAM-Prinzipal aus und ordnen Sie ihn `AmazonEKSClusterAdminPolicy` zu.
1. Konfigurieren Sie kubectl so, dass es eine Verbindung zu dem neu erstellten HyperPod Cluster herstellt, der vom Amazon EKS-Cluster orchestriert wird. Geben Sie die Region und HyperPod den Clusternamen an.
```
export HYPERPOD_CLUSTER_NAME=
export REGION=
# S3 bucket where tls certificates will be uploaded
BUCKET_NAME="" # This should be bucket name, not URI
export EKS_CLUSTER_NAME=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
--query 'Orchestrator.Eks.ClusterArn' --output text | \
cut -d'/' -f2)
aws eks update-kubeconfig --name $EKS_CLUSTER_NAME --region $REGION
```
1. Legen Sie die Standard-Umgebungsvariablen fest.
```
LB_CONTROLLER_POLICY_NAME="AWSLoadBalancerControllerIAMPolicy-$HYPERPOD_CLUSTER_NAME"
LB_CONTROLLER_ROLE_NAME="aws-load-balancer-controller-$HYPERPOD_CLUSTER_NAME"
S3_MOUNT_ACCESS_POLICY_NAME="S3MountpointAccessPolicy-$HYPERPOD_CLUSTER_NAME"
S3_CSI_ROLE_NAME="SM_HP_S3_CSI_ROLE-$HYPERPOD_CLUSTER_NAME"
KEDA_OPERATOR_POLICY_NAME="KedaOperatorPolicy-$HYPERPOD_CLUSTER_NAME"
KEDA_OPERATOR_ROLE_NAME="keda-operator-role-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_ROLE_NAME="HyperpodInferenceRole-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_SA_NAME="hyperpod-inference-operator-controller"
HYPERPOD_INFERENCE_SA_NAMESPACE="hyperpod-inference-system"
JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-$HYPERPOD_CLUSTER_NAME"
FSX_CSI_ROLE_NAME="AmazonEKSFSxLustreCSIDriverFullAccess-$HYPERPOD_CLUSTER_NAME"
```
1. Extrahieren Sie den Amazon EKS-Clusternamen aus dem Cluster-ARN, aktualisieren Sie die lokale kubeconfig und überprüfen Sie die Konnektivität, indem Sie alle Pods in NameBereiche auflisten.
```
kubectl get pods --all-namespaces
```
1. (Optional) Installieren Sie das NVIDIA-Geräte-Plugin, um die GPU-Unterstützung auf dem Cluster zu aktivieren.
```
#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
```
### Bereiten Sie Ihre Umgebung auf die Installation des Inference Operators vor
1. Sammeln Sie wichtige AWS Ressourcen-Identifikatoren, die für die Konfiguration von Serviceintegrationen zwischen Amazon EKS-, SageMaker KI- und IAM-Komponenten ARNs erforderlich sind.
```
%%bash -x
export ACCOUNT_ID=$(aws --region $REGION sts get-caller-identity --query 'Account' --output text)
export OIDC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
export EKS_CLUSTER_ROLE=$(aws eks --region $REGION describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.roleArn' --output text)
```
1. Ordnen Sie Ihrem EKS-Cluster einen OIDCidentity IAM-Anbieter zu.
```
eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve
```
1. Erstellen Sie die Vertrauensrichtlinie, die für die IAM-Rolle des HyperPod Inferenzoperators erforderlich ist. Diese Richtlinie ermöglicht eine sichere dienstübergreifende Kommunikation zwischen Amazon EKS, SageMaker AI und anderen AWS Diensten.
```
%%bash -x
# Create trust policy JSON
cat << EOF > trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::${ACCOUNT_ID}:oidc-provider/oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:aud": "sts.amazonaws.com",
"oidc.eks.${REGION}.amazonaws.com/id/${OIDC_ID}:sub": "system:serviceaccount:hyperpod-inference-system:hyperpod-inference-controller-manager"
}
}
}
]
}
EOF
```
1. Erstellen Sie eine Ausführungsrolle für den Inferenzoperator und hängen Sie die verwaltete Richtlinie an.
```
aws iam create-role --role-name $HYPERPOD_INFERENCE_ROLE_NAME --assume-role-policy-document file://trust-policy.json
aws iam attach-role-policy --role-name $HYPERPOD_INFERENCE_ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodInferenceAccess
```
1. Laden Sie die IAM-Richtlinie herunter, die für den Load Balancer Controller zur Verwaltung von Application Load AWS Balancers und Network Load Balancers in Ihrem EKS-Cluster erforderlich ist, und erstellen Sie sie.
```
%%bash -x
export ALBController_IAM_POLICY_NAME=HyperPodInferenceALBControllerIAMPolicy
curl -o AWSLoadBalancerControllerIAMPolicy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.13.0/docs/install/iam_policy.json
aws iam create-policy --policy-name $ALBController_IAM_POLICY_NAME --policy-document file://AWSLoadBalancerControllerIAMPolicy.json
```
1. Erstellen Sie ein IAM-Dienstkonto, das das Kubernetes-Dienstkonto mit der IAM-Richtlinie verknüpft, sodass der Load AWS Balancer Controller die erforderlichen AWS Berechtigungen über IRSA (IAM Roles for Service Accounts) annehmen kann.
```
%%bash -x
export ALB_POLICY_ARN="arn:aws:iam::$ACCOUNT_ID:policy/$ALBController_IAM_POLICY_NAME"
# Create IAM service account with gathered values
eksctl create iamserviceaccount \
--approve \
--override-existing-serviceaccounts \
--name=aws-load-balancer-controller \
--namespace=kube-system \
--cluster=$EKS_CLUSTER_NAME \
--attach-policy-arn=$ALB_POLICY_ARN \
--region=$REGION
# Print the values for verification
echo "Cluster Name: $EKS_CLUSTER_NAME"
echo "Region: $REGION"
echo "Policy ARN: $ALB_POLICY_ARN"
```
1. Wenden Sie Tags (`kubernetes.io.role/elb`) auf alle Subnetze im Amazon EKS-Cluster (sowohl öffentlich als auch privat) an.
```
export VPC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.resourcesVpcConfig.vpcId' --output text)
# Add Tags
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' | \
xargs -I{} aws ec2 create-tags --resources {} --tags Key=kubernetes.io/role/elb,Value=1
# Verify Tags are added
aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=${VPC_ID}" "Name=map-public-ip-on-launch,Values=true" \
--query 'Subnets[*].SubnetId' --output text | \
tr '\t' '\n' |
xargs -n1 -I{} aws ec2 describe-tags --filters "Name=resource-id,Values={}" "Name=key,Values=kubernetes.io/role/elb" --query "Tags[0].Value" --output text
```
1. Erstellen Sie einen Namespace für KEDA und den Cert Manager.
```
kubectl create namespace keda
kubectl create namespace cert-manager
```
1. Erstellen Sie einen Amazon-S3-VPC-Endpunkt.
```
aws ec2 create-vpc-endpoint \
--vpc-id ${VPC_ID} \
--vpc-endpoint-type Gateway \
--service-name "com.amazonaws.${REGION}.s3" \
--route-table-ids $(aws ec2 describe-route-tables --filters "Name=vpc-id,Values=${VPC_ID}" --query 'RouteTables[].Associations[].RouteTableId' --output text | tr ' ' '\n' | sort -u | tr '\n' ' ')
```
1. Konfigurieren des S3-Speicherzugriffs:
1. Erstellen Sie eine IAM-Richtlinie, die die erforderlichen S3-Berechtigungen für die Verwendung von Mountpoint for Amazon S3 gewährt, wodurch der Dateisystemzugriff auf S3-Buckets innerhalb des Clusters ermöglicht wird.
```
%%bash -x
export S3_CSI_BUCKET_NAME=“”
cat < s3accesspolicy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "MountpointAccess",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::${S3_CSI_BUCKET_NAME}",
"arn:aws:s3:::${S3_CSI_BUCKET_NAME}/*"
]
}
]
}
EOF
aws iam create-policy \
--policy-name S3MountpointAccessPolicy \
--policy-document file://s3accesspolicy.json
cat < s3accesstrustpolicy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/${OIDC_ID}"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.$REGION.amazonaws.com/id/${OIDC_ID}:aud": "sts.amazonaws.com",
"oidc.eks.$REGION.amazonaws.com/id/${OIDC_ID}:sub": "system:serviceaccount:kube-system:${s3-csi-driver-sa}"
}
}
}
]
}
EOF
aws iam create-role --role-name $S3_CSI_ROLE_NAME --assume-role-policy-document file://s3accesstrustpolicy.json
aws iam attach-role-policy --role-name $S3_CSI_ROLE_NAME --policy-arn "arn:aws:iam::$ACCOUNT_ID:policy/S3MountpointAccessPolicy"
```
1. (Optional) Erstellen Sie ein IAM-Servicekonto für den CSI-Treiber von Amazon S3. Der Amazon S3 S3-CSI-Treiber benötigt ein IAM-Servicekonto mit entsprechenden Berechtigungen, um S3-Buckets als persistente Volumes in Ihrem Amazon EKS-Cluster bereitzustellen. In diesem Schritt werden die erforderliche IAM-Rolle und das erforderliche Kubernetes-Servicekonto mit der erforderlichen S3-Zugriffsrichtlinie erstellt.
```
%%bash -x
export S3_CSI_ROLE_NAME="SM_HP_S3_CSI_ROLE-$REGION"
export S3_CSI_POLICY_ARN=$(aws iam list-policies --query 'Policies[?PolicyName==`S3MountpointAccessPolicy`]' | jq '.[0].Arn' | tr -d '"')
eksctl create iamserviceaccount \
--name s3-csi-driver-sa \
--namespace kube-system \
--cluster $EKS_CLUSTER_NAME \
--attach-policy-arn $S3_CSI_POLICY_ARN \
--approve \
--role-name $S3_CSI_ROLE_NAME \
--region $REGION
kubectl label serviceaccount s3-csi-driver-sa app.kubernetes.io/component=csi-driver app.kubernetes.io/instance=aws-mountpoint-s3-csi-driver app.kubernetes.io/managed-by=EKS app.kubernetes.io/name=aws-mountpoint-s3-csi-driver -n kube-system --overwrite
```
1. (Optional) Installieren Sie das Amazon-S3-CSI-Add-on. Dieser Treiber ermöglicht es Ihren Pods, S3-Buckets als persistente Volumes bereitzustellen, sodass Sie von Ihren Kubernetes-Workloads aus direkt auf S3-Speicher zugreifen können.
```
%%bash -x
export S3_CSI_ROLE_ARN=$(aws iam get-role --role-name $S3_CSI_ROLE_NAME --query 'Role.Arn' --output text)
eksctl create addon --name aws-mountpoint-s3-csi-driver --cluster $EKS_CLUSTER_NAME --service-account-role-arn $S3_CSI_ROLE_ARN --force
```
1. (Optional) Erstellen Sie einen Persistent Volume Claim (PVC) für S3-Speicher. Mit diesem PVC können Ihre Pods S3-Speicher anfordern und verwenden, als ob es sich um ein herkömmliches Dateisystem handeln würde.
```
%%bash -x
cat < pvc_s3.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: s3-claim
spec:
accessModes:
- ReadWriteMany # supported options: ReadWriteMany / ReadOnlyMany
storageClassName: "" # required for static provisioning
resources:
requests:
storage: 1200Gi # ignored, required
volumeName: s3-pv
EOF
kubectl apply -f pvc_s3.yaml
```
1. (Optional) Konfigurieren Sie den FSx Speicherzugriff. Erstellen Sie ein IAM-Servicekonto für den Amazon FSx CSI-Treiber. Dieses Dienstkonto wird vom FSx CSI-Treiber verwendet, um im Namen Ihres Clusters mit dem FSx Amazon-Service zu interagieren.
```
%%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
```
### Erstellen Sie die KEDA-Operatorrolle
1. Erstellen der Vertrauens- und Berechtigungsrichtlinie
```
# Create trust policy
cat < /tmp/keda-trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:kube-system:keda-operator",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
}
]
}
EOF
# Create permissions policy
cat < /tmp/keda-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetMetricData",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"aps:QueryMetrics",
"aps:GetLabels",
"aps:GetSeries",
"aps:GetMetricMetadata"
],
"Resource": "*"
}
]
}
EOF
# Create the role
aws iam create-role \
--role-name keda-operator-role \
--assume-role-policy-document file:///tmp/keda-trust-policy.json
# Create the policy
KEDA_POLICY_ARN=$(aws iam create-policy \
--policy-name KedaOperatorPolicy \
--policy-document file:///tmp/keda-policy.json \
--query 'Policy.Arn' \
--output text)
# Attach the policy to the role
aws iam attach-role-policy \
--role-name keda-operator-role \
--policy-arn $KEDA_POLICY_ARN
```
1. Wenn Sie geschützte Modelle verwenden, erstellen Sie eine IAM-Rolle, um auf die geschützten Modelle zuzugreifen.
1. Erstellen Sie die Vertrauensrichtlinie und die IAM-Rolle für den geschützten Modellzugriff.
```
%%bash -s $REGION
JUMPSTART_GATED_ROLE_NAME="JumpstartGatedRole-${REGION}-${HYPERPOD_CLUSTER_NAME}"
cat < /tmp/trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:*:hyperpod-inference-service-account*",
"oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
# Create the role and attach the managed policy
aws iam create-role \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--assume-role-policy-document file:///tmp/trust-policy.json
aws iam attach-role-policy \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodGatedModelAccess
```
```
JUMPSTART_GATED_ROLE_ARN_LIST= !aws iam get-role --role-name=$JUMPSTART_GATED_ROLE_NAME --query "Role.Arn" --output text
JUMPSTART_GATED_ROLE_ARN = JUMPSTART_GATED_ROLE_ARN_LIST[0]
!echo $JUMPSTART_GATED_ROLE_ARN
```
### Installieren des Inferenzoperators
1. Installieren Sie den HyperPod Inferenzoperator. In diesem Schritt werden die erforderlichen AWS Ressourcen-IDs gesammelt und der Helm-Installationsbefehl mit den entsprechenden Konfigurationsparametern generiert.
Greifen Sie über [https://github.com/aws/sagemaker-hyperpod-cli/tree/main/helm\$1chart](https://github.com/aws/sagemaker-hyperpod-cli/tree/main/helm_chart) auf das Helmdiagramm zu.
```
git clone https://github.com/aws/sagemaker-hyperpod-cli
cd sagemaker-hyperpod-cli
cd helm_chart/HyperPodHelmChart
helm dependencies update charts/inference-operator
```
```
%%bash -x
HYPERPOD_INFERENCE_ROLE_ARN=$(aws iam get-role --role-name=$HYPERPOD_INFERENCE_ROLE_NAME --query "Role.Arn" --output text)
echo $HYPERPOD_INFERENCE_ROLE_ARN
S3_CSI_ROLE_ARN=$(aws iam get-role --role-name=$S3_CSI_ROLE_NAME --query "Role.Arn" --output text)
echo $S3_CSI_ROLE_ARN
HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME --query "ClusterArn")
# Verify values
echo "Cluster Name: $EKS_CLUSTER_NAME"
echo "Execution Role: $HYPERPOD_INFERENCE_ROLE_ARN"
echo "Hyperpod ARN: $HYPERPOD_CLUSTER_ARN"
# Run the the HyperPod inference operator installation.
helm install hyperpod-inference-operator charts/inference-operator \
-n kube-system \
--set region=$REGION \
--set eksClusterName=$EKS_CLUSTER_NAME \
--set hyperpodClusterArn=$HYPERPOD_CLUSTER_ARN \
--set executionRoleArn=$HYPERPOD_INFERENCE_ROLE_ARN \
--set s3.serviceAccountRoleArn=$S3_CSI_ROLE_ARN \
--set s3.node.serviceAccount.create=false \
--set keda.podIdentity.aws.irsa.roleArn="arn:aws:iam::$ACCOUNT_ID:role/keda-operator-role" \
--set tlsCertificateS3Bucket="s3://$BUCKET_NAME" \
--set alb.region=$REGION \
--set alb.clusterName=$EKS_CLUSTER_NAME \
--set alb.vpcId=$VPC_ID
# For JumpStart Gated Model usage, Add
# --set jumpstartGatedModelDownloadRoleArn=$UMPSTART_GATED_ROLE_ARN
```
1. Konfigurieren Sie die Anmerkungen zum Dienstkonto für die IAM-Integration. Diese Anmerkung ermöglicht es dem Servicekonto des Betreibers, die erforderlichen IAM-Berechtigungen für die Verwaltung von Inferenzendpunkten und die Interaktion mit AWS -Services anzunehmen.
```
%%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
```
## Stellen Sie sicher, dass der Inferenzoperator funktioniert
Gehen Sie wie folgt vor, um zu überprüfen, ob Ihre Inferenzoperator-Installation ordnungsgemäß funktioniert, indem Sie ein einfaches Modell bereitstellen und testen.
**Stellen Sie ein Testmodell bereit, um den Operator zu verifizieren**
1. Erstellen einer Konfigurationsdatei für Modellbereitstellung Dadurch wird eine Kubernetes-Manifestdatei erstellt, die eine JumpStart Modellbereitstellung für den HyperPod Inferenzoperator definiert.
```
cat <> simple_model_install.yaml
---
apiVersion: inference.sagemaker.aws.amazon.com/v1
kind: JumpStartModel
metadata:
name: testing-deployment-bert
namespace: default
spec:
model:
modelId: "huggingface-eqa-bert-base-cased"
sageMakerEndpoint:
name: "hp-inf-ep-for-testing"
server:
instanceType: "ml.c5.2xlarge"
environmentVariables:
- name: SAMPLE_ENV_VAR
value: "sample_value"
maxDeployTimeInSeconds: 1800
EOF
```
1. Stellen Sie das Modell bereit und bereinigen Sie die Konfigurationsdatei.
```
kubectl create -f simple_model_install.yaml
rm -f simple_model_install.yaml
```
1. Überprüfen Sie die Konfiguration des Dienstkontos, um sicherzustellen, dass der Betreiber Berechtigungen annehmen kann. 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
```
**Konfigurieren Sie die Bereitstellungseinstellungen (wenn Sie die Studio-Benutzeroberfläche verwenden)**
1. Überprüfen Sie den empfohlenen Instanztyp unter **Bereitstellungseinstellungen**.
1. Wenn Sie den **Instanztyp** ändern, stellen Sie die Kompatibilität mit Ihrem HyperPod Cluster sicher. Wenden Sie sich an Ihren Administrator, wenn kompatible Instances nicht verfügbar sind.
1. Wählen Sie für GPU-partitionierte Instances mit aktiviertem MIG eine geeignete **GPU-Partition aus den verfügbaren MIG-Profilen aus, um die GPU-Auslastung** zu optimieren. Weitere Informationen finden Sie unter [Verwenden von GPU-Partitionen in Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md).
1. Wenn Sie Task Governance verwenden, konfigurieren Sie die Prioritätseinstellungen für die Funktion zur Verhinderung der Modellbereitstellung.
1. Geben Sie den von Ihrem Administrator bereitgestellten Namespace ein. Wenden Sie sich bei Bedarf an Ihren Administrator, um den richtigen Namespace zu erhalten.
## (Optional) Richten Sie den Benutzerzugriff über die JumpStart Benutzeroberfläche in SageMaker AI Studio Classic ein
Weitere Hintergrundinformationen zur Einrichtung des SageMaker HyperPod Zugriffs für Studio Classic-Benutzer und zur Konfiguration detaillierter Kubernetes-RBAC-Berechtigungen für Data Scientist-Benutzer finden Sie unter und. [Einen Amazon-EKS-Cluster in Studio einrichten](sagemaker-hyperpod-studio-setup-eks.md) [Einrichten der rollenbasierten Zugriffskontrolle für Kubernetes](sagemaker-hyperpod-eks-setup-rbac.md)
1. Identifizieren Sie die IAM-Rolle, die Data Scientist-Benutzer verwenden werden, um Modelle von AI Studio Classic aus zu verwalten und bereitzustellen. SageMaker HyperPod SageMaker Dies ist in der Regel die Benutzerprofil-Ausführungsrolle oder die Domain-Ausführungsrolle für den Studio Classic-Benutzer.
```
%%bash -x
export DATASCIENTIST_ROLE_NAME=""
export DATASCIENTIST_POLICY_NAME="HyperPodUIAccessPolicy"
export EKS_CLUSTER_ARN=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
--query 'Orchestrator.Eks.ClusterArn' --output text)
export DATASCIENTIST_HYPERPOD_NAMESPACE="team-namespace"
```
1. Fügen Sie eine Identitätsrichtlinie an, die den Zugriff auf Model Deployment ermöglicht.
```
%%bash -x
# Create access policy
cat << EOF > hyperpod-deployment-ui-access-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DescribeHyerpodClusterPermissions",
"Effect": "Allow",
"Action": [
"sagemaker:DescribeCluster"
],
"Resource": "$HYPERPOD_CLUSTER_ARN"
},
{
"Sid": "UseEksClusterPermissions",
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:AccessKubernetesApi",
"eks:MutateViaKubernetesApi",
"eks:DescribeAddon"
],
"Resource": "$EKS_CLUSTER_ARN"
},
{
"Sid": "ListPermission",
"Effect": "Allow",
"Action": [
"sagemaker:ListClusters",
"sagemaker:ListEndpoints"
],
"Resource": "*"
},
{
"Sid": "SageMakerEndpointAccess",
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:InvokeEndpoint"
],
"Resource": "arn:aws:sagemaker:$REGION:$ACCOUNT_ID:endpoint/*"
}
]
}
EOF
aws iam put-role-policy --role-name DATASCIENTIST_ROLE_NAME --policy-name HyperPodDeploymentUIAccessInlinePolicy --policy-document file://hyperpod-deployment-ui-access-policy.json
```
1. Erstellen Sie einen EKS-Zugriffseintrag für den Benutzer, der ihn einer Kubernetes-Gruppe zuordnet.
```
%%bash -x
aws eks create-access-entry --cluster-name $EKS_CLUSTER_NAME \
--principal-arn "arn:aws:iam::$ACCOUNT_ID:role/$DATASCIENTIST_ROLE_NAME" \
--kubernetes-groups '["hyperpod-scientist-user-namespace-level","hyperpod-scientist-user-cluster-level"]'
```
1. Erstellen Sie Kubernetes-RBAC-Richtlinien für den Benutzer.
```
%%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
```