Methode 1: Installieren Sie das HyperPod Inference Add-on über die SageMaker AI-Konsole (empfohlen)Methode 2: Installation des Inferenzoperators mit der CLI AWS Methode 3: Installation des Helmdiagramms Stellen Sie sicher, dass der Inferenzoperator funktioniert (Optional) Richten Sie den Benutzerzugriff über die JumpStart Benutzeroberfläche in SageMaker AI Studio Classic ein

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

Navigieren Sie zur SageMaker AI-Konsole und gehen Sie zu HyperPod Clusters → Cluster Management.
Wählen Sie Ihren Cluster aus, in dem Sie den Inference Operator installieren möchten.
Navigieren Sie zur Registerkarte Inferenz. Wählen Sie „Schnellinstallation“ für die automatische Installation oder „Benutzerdefinierte Installation“ für eine flexible Konfiguration.
Wenn Sie sich für benutzerdefinierte Installation entscheiden, geben Sie vorhandene Ressourcen an oder passen Sie die Einstellungen nach Bedarf an.
Klicken Sie auf Installieren, um den automatisierten Installationsvorgang zu starten.

Ü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 navigierenStellen Sie sicher, dass der Inferenzoperator funktioniert.

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:

Connect zu Ihrem Cluster her und richten Sie Umgebungsvariablen ein
Konfigurieren Sie IAM-Rollen für den Inferenzoperator
Erstellen Sie die ALB-Controller-Rolle
Erstellen Sie die KEDA-Operatorrolle
Installieren Sie die EKS Add-Ons für die Abhängigkeit

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.

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

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

Anmerkung

Wenn Sie einen benutzerdefinierten Bucket-Namen verwenden, der nicht mit beginnthyperpod-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}"
                }
            }
        }
    ]
}

Legen Sie die Standard-Umgebungsvariablen fest.


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

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

(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

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)

Ordnen Sie Ihrem EKS-Cluster einen OIDCidentity IAM-Anbieter zu.


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

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

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

Erstellen Sie einen Namespace für Ressourcen von Inferenzoperatoren
```
kubectl create namespace $HYPERPOD_INFERENCE_NAMESPACE
```

Erstellen Sie die ALB-Controller-Rolle

Erstellen der Vertrauens- und Berechtigungsrichtlinie


# 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

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

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

Erstellen der Vertrauens- und Berechtigungsrichtlinie


# 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

Wenn Sie geschützte Modelle verwenden, erstellen Sie eine IAM-Rolle, um auf die geschützten Modelle zuzugreifen.

Erstellen Sie eine IAM-Richtlinie.


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

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 EKS Add-Ons für die Abhängigkeit

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

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

Ü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

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"

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

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

Ü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 unterHyperPod Fehlerbehebung bei Inferenzen.

Um zu überprüfen, ob der Inferenzoperator ordnungsgemäß funktioniert, fahren Sie fort mitStellen Sie sicher, dass der Inferenzoperator funktioniert.

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.

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"

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"

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

Überwachen Sie den Status der Stack-Erstellung:


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

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 der Installation des Inferenzoperators fort.

Methode 3: Installation des Helmdiagramms

Verwenden Sie diese Methode, wenn Sie mehr Kontrolle über die Installationskonfiguration benötigen oder wenn das EKS-Add-on in Ihrer Region nicht verfügbar ist.

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


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

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

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

(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

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)

Ordnen Sie Ihrem EKS-Cluster einen OIDCidentity IAM-Anbieter zu.


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

Erstellen Sie die JSON-Dokumente für Vertrauensrichtlinien und Berechtigungsrichtlinien, die für die IAM-Rolle des HyperPod Inferenzoperators erforderlich sind. Diese Richtlinien ermöglichen eine sichere dienstübergreifende Kommunikation zwischen Amazon EKS, SageMaker KI und anderen AWS Diensten.


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

Erstellen Sie eine Ausführungsrolle für den Inferenzoperator.


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

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

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"

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

Erstellen Sie einen Namespace für KEDA und den Cert Manager.


kubectl create namespace keda
kubectl create namespace cert-manager

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

Konfigurieren des S3-Speicherzugriffs:

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

(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

(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

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

(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

Erstellen der Vertrauens- und Berechtigungsrichtlinie


# 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

Wenn Sie geschützte Modelle verwenden, erstellen Sie eine IAM-Rolle, um auf die geschützten Modelle zuzugreifen.

Erstellen Sie eine IAM-Richtlinie.


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

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

Fügen Sie der Ausführungsrolle eine SageMakerFullAccess-Richtlinie hinzu.


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

Installieren des Inferenzoperators

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

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

Erstellen einer Konfigurationsdatei für Modellbereitstellung Dadurch wird eine Kubernetes-Manifestdatei erstellt, die eine JumpStart Modellbereitstellung für den HyperPod Inferenzoperator definiert.


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

Stellen Sie das Modell bereit und bereinigen Sie die Konfigurationsdatei.


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

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

Überprüfen Sie den empfohlenen Instanztyp unter Bereitstellungseinstellungen.
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.
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.
Wenn Sie Task Governance verwenden, konfigurieren Sie die Prioritätseinstellungen für die Funktion zur Verhinderung der Modellbereitstellung.
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 Einrichten der rollenbasierten Zugriffskontrolle für Kubernetes

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

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

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

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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Stellen Sie Modelle bereit auf HyperPod

Bereitstellen von Grundlagenmodellen und maßgeschneiderten, optimierten Modellen