사전 조건 추론 운영자 설치를 위한 환경 준비 KEDA 운영자 역할 생성 추론 운영자 설치 추론 운영자가 작동하는지 확인 (선택 사항) SageMaker AI Studio Classic에서 JumpStart UI를 통한 사용자 액세스 설정

모델 배포를 위한 HyperPod 클러스터 설정

이 안내서는 Amazon SageMaker HyperPod 클러스터에서 추론 기능을 활성화하기 위한 포괄적인 설정 가이드를 제공합니다. 다음 단계는 추론 엔드포인트를 배포하고 관리하는 기계 학습 엔지니어를 지원하는 데 필요한 인프라, 권한 및 운영자를 설정하는 데 도움이 됩니다.

참고

추론 연산자가 사전 설치된 클러스터를 생성하려면 섹션을 참조하세요EKS에 의해 오케스트레이션된 SageMaker HyperPod 클러스터 생성. 기존 클러스터에 추론 연산자를 설치하려면 다음 절차를 계속 진행합니다.

사전 조건

계속하기 전에 자격 AWS증명이 올바르게 구성되어 있고 필요한 권한이 있는지 확인합니다. 다음 단계는 관리자 권한과 클러스터 관리자가 Amazon EKS 클러스터에 액세스할 수 있는 IAM 보안 주체가 실행해야 합니다. Amazon EKS 오케스트레이션을 사용하여 SageMaker HyperPod 클러스터 생성 방법으로 HyperPod 클러스터를 생성했는지 확인합니다. helm, eksctl 및 kubectl 명령줄 유틸리티를 설치했는지 확인합니다.

Amazon EKS 클러스터에 대한 Kubernetes 관리 액세스의 경우 Amazon EKS 콘솔로 이동하여 사용 중인 클러스터를 선택합니다. 액세스 탭에서 IAM 액세스 항목을 선택합니다. IAM 위탁자에 대한 항목이 없는 경우 액세스 항목 생성을 선택합니다. 그런 다음 원하는 IAM 위탁자를 선택하고 AmazonEKSClusterAdminPolicy를 해당 위탁자와 연결합니다.

Amazon EKS 클러스터에 의해 오케스트레이션되어 새로 생성된 HyperPod 클러스터에 연결하도록 kubectl을 구성합니다. 리전 및 HyperPod 클러스터 이름을 지정합니다.


export HYPERPOD_CLUSTER_NAME=<hyperpod-cluster-name>
export REGION=<region>

# S3 bucket where tls certificates will be uploaded
BUCKET_NAME="<Enter name of your s3 bucket>" # This should be bucket name, not URI

export EKS_CLUSTER_NAME=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
  --query 'Orchestrator.Eks.ClusterArn' --output text | \
  cut -d'/' -f2)
aws eks update-kubeconfig --name $EKS_CLUSTER_NAME --region $REGION

기본 환경 변수를 설정합니다.


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"

클러스터 ARN에서 Amazon EKS 클러스터 이름을 추출하고, 로컬 kubeconfig를 업데이트하고, 네임스페이스 전반의 모든 포드를 나열하여 연결을 확인합니다.
```
kubectl get pods --all-namespaces
```

(선택 사항) NVIDIA 디바이스 플러그인을 설치하여 클러스터에서 GPU 지원을 활성화합니다.


#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

추론 운영자 설치를 위한 환경 준비

이제 HyperPod 클러스터가 구성되었으므로 다음 단계는 추론 운영자를 설치하는 것입니다. 추론 운영자는 Amazon EKS 클러스터에서 기계 학습 추론 엔드포인트를 배포하고 관리할 수 있도록 하는 Kubernetes 운영자입니다.

Amazon EKS 클러스터에 적절한 보안 구성과 지원 인프라 구성 요소가 있도록 하려면 중요한 다음 준비 단계를 완료하세요. 여기에는 교차 서비스 인증을 위한 IAM 역할 및 보안 정책 구성, 수신 관리를 위한 AWSLoad Balancer 컨트롤러 설치, 영구 스토리지 액세스를 위한 Amazon S3 및 Amazon FSx CSI 드라이버 설정, 오토 스케일링 및 인증서 관리 기능을 위한 KEDA 및 cert-manager 배포가 포함됩니다.

Amazon EKS, SageMaker AI 및 IAM 구성 요소 간의 서비스 통합을 구성하는 데 필요한 필수 AWS리소스 식별자 및 ARNs을 수집합니다.


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

IAM OIDCidentity 제공업체를 EKS 클러스터와 연결합니다.


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

HyperPod 추론 운영자 IAM 역할에 필요한 신뢰 정책 및 권한 정책 JSON 문서를 생성합니다. 이러한 정책은 Amazon EKS, SageMaker AI 및 기타AWS 서비스 간의 안전한 서비스 간 통신을 가능하게 합니다.


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:*:*"
                }
            }
        }
    ]
}
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

추론 운영자에 대한 실행 역할을 생성합니다.


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

AWSLoad Balancer 컨트롤러가 EKS 클러스터에서 Application Load Balancer 및 Network Load Balancer를 관리하는 데 필요한 IAM 정책을 다운로드하고 생성합니다.


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

Kubernetes 서비스 계정을 IAM 정책과 연결하는 IAM 서비스 계정을 생성하여 AWSLoad Balancer 컨트롤러가 IRSA(서비스 계정에 대한 IAM 역할)를 통해 필요한 AWS권한을 수임할 수 있도록 합니다.


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

Amazon EKS 클러스터(퍼블릭 및 프라이빗 모두kubernetes.io.role/elb)의 모든 서브넷에 태그()를 적용합니다.


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

KEDA 및 Cert Manager용 네임스페이스를 생성합니다.


kubectl create namespace keda
kubectl create namespace cert-manager

Amazon S3 VPC 엔드포인트 생성


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

S3 스토리지 액세스를 구성합니다.

클러스터 내에서 파일 시스템이 S3 버킷에 액세스할 수 있도록 Mountpoint for Amazon S3를 사용하는 데 필요한 S3 권한을 부여하는 IAM 정책을 생성합니다.


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

(선택 사항) Amazon S3 CSI 드라이버에 대한 IAM 서비스 계정을 생성합니다. Amazon S3 CSI 드라이버에는 S3 버킷을 Amazon EKS 클러스터에 영구 볼륨으로 탑재할 수 있는 적절한 권한이 있는 IAM 서비스 계정이 필요합니다. 이 단계에서는 필수 S3 액세스 정책을 사용하여 필요한 IAM 역할과 Kubernetes 서비스 계정을 생성합니다.


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

(선택 사항) Amazon S3 CSI 드라이버 추가 기능을 설치합니다. 이 드라이버를 사용하면 포드가 S3 버킷을 영구 볼륨으로 탑재하여 Kubernetes 워크로드 내에서 S3 스토리지에 직접 액세스할 수 있도록 합니다.
```
%%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
```

(선택 사항) S3 스토리지에 대한 영구 볼륨 클레임(PVC)을 생성합니다. 이 PVC를 사용하면 포드가 기존 파일 시스템인 것처럼 S3 스토리지를 요청하고 사용할 수 있습니다.


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

(선택 사항) FSx 스토리지 액세스를 구성합니다. Amazon FSx CSI 드라이버에 대한 IAM 서비스 계정을 생성합니다. 이 서비스 계정은 FSx CSI 드라이버가 클러스터를 대신하여 Amazon FSx 서비스와 상호 작용하는 데 사용됩니다.


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

KEDA 운영자 역할 생성

신뢰 정책 및 권한 정책을 생성합니다.


# 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

게이트 모델을 사용하는 경우 IAM 역할을 생성하여 게이트 모델에 액세스합니다.

IAM 정책을 생성합니다.


%%bash -s $REGION

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

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

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

cat <<EOF > /tmp/trust-policy.json
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Federated": "arn:aws:iam::$ACCOUNT_ID:oidc-provider/oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID"
            },
            "Action": "sts:AssumeRoleWithWebIdentity",
            "Condition": {
                "StringLike": {
                    "oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:sub": "system:serviceaccount:*:$HYPERPOD_INFERENCE_SA_NAME",
                    "oidc.eks.$REGION.amazonaws.com/id/$OIDC_ID:aud": "sts.amazonaws.com"
                }
            }
        },
         {
            "Effect": "Allow",
            "Principal": {
                "Service": "sagemaker.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
EOF

IAM 역할을 생성합니다.


# Create the role using existing trust policy
aws iam create-role \
    --role-name $JUMPSTART_GATED_ROLE_NAME \
    --assume-role-policy-document file:///tmp/trust-policy.json
# Attach the existing PresignedUrlAccessPolicy to the role
aws iam attach-role-policy \
    --role-name $JUMPSTART_GATED_ROLE_NAME \
    --policy-arn arn:aws:iam::${ACCOUNT_ID}:policy/PresignedUrlAccessPolicy


JUMPSTART_GATED_ROLE_ARN_LIST= !aws iam get-role --role-name=$JUMPSTART_GATED_ROLE_NAME --query "Role.Arn" --output text
JUMPSTART_GATED_ROLE_ARN = JUMPSTART_GATED_ROLE_ARN_LIST[0]
!echo $JUMPSTART_GATED_ROLE_ARN

실행 역할에 SageMakerFullAccess 정책을 추가합니다.


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

추론 운영자 설치

HyperPod 추론 운영자를 설치합니다. 이 단계에서는 필요한 AWS 리소스 식별자를 수집하고 적절한 구성 파라미터를 사용하여 헬름 설치 명령을 생성합니다.

https://github.com/aws/sagemaker-hyperpod-cli/tree/main/helm_chart에서 헬름 차트에 액세스합니다.


git clone https://github.com/aws/sagemaker-hyperpod-cli
cd sagemaker-hyperpod-cli
cd helm_chart/HyperPodHelmChart
helm dependencies update charts/inference-operator


%%bash -x

HYPERPOD_INFERENCE_ROLE_ARN=$(aws iam get-role --role-name=$HYPERPOD_INFERENCE_ROLE_NAME --query "Role.Arn" --output text)
echo $HYPERPOD_INFERENCE_ROLE_ARN
 
S3_CSI_ROLE_ARN=$(aws iam get-role --role-name=$S3_CSI_ROLE_NAME --query "Role.Arn" --output text)
echo $S3_CSI_ROLE_ARN

HYPERPOD_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME --query "ClusterArn")

# Verify values
echo "Cluster Name: $EKS_CLUSTER_NAME"
echo "Execution Role: $HYPERPOD_INFERENCE_ROLE_ARN"
echo "Hyperpod ARN: $HYPERPOD_CLUSTER_ARN"
# Run the the HyperPod inference operator installation. 

helm install hyperpod-inference-operator charts/inference-operator \
-n kube-system \
--set region=$REGION \
 --set eksClusterName=$EKS_CLUSTER_NAME \
--set hyperpodClusterArn=$HYPERPOD_CLUSTER_ARN \
--set executionRoleArn=$HYPERPOD_INFERENCE_ROLE_ARN \
--set s3.serviceAccountRoleArn=$S3_CSI_ROLE_ARN \
--set s3.node.serviceAccount.create=false \
--set keda.podIdentity.aws.irsa.roleArn="arn:aws:iam::$ACCOUNT_ID:role/keda-operator-role" \
--set tlsCertificateS3Bucket="s3://$BUCKET_NAME" \
--set alb.region=$REGION \
--set alb.clusterName=$EKS_CLUSTER_NAME \
--set alb.vpcId=$VPC_ID
 
# For JumpStart Gated Model usage, Add
# --set jumpstartGatedModelDownloadRoleArn=$UMPSTART_GATED_ROLE_ARN

IAM 통합을 위한 서비스 계정 주석을 구성합니다. 이 주석을 사용하면 운영자의 서비스 계정이 추론 엔드포인트를 관리하고 AWS 서비스와 상호 작용하는 데 필요한 IAM 권한을 수임할 수 있습니다.


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

추론 운영자가 작동하는지 확인

모델 배포 구성 파일을 만듭니다. 그러면 HyperPod 추론 운영자에 대한 JumpStart 모델 배포를 정의하는 Kubernetes 매니페스트 파일이 생성됩니다. 구성은 Amazon SageMaker JumpStart에서 사전 훈련된 모델을 Amazon EKS 클러스터의 추론 엔드포인트로 배포하는 방법을 지정합니다.


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

모델을 배포하고 구성 파일을 정리합니다. 이 단계에서는 JumpStart 모델 리소스를 생성하고 임시 구성 파일을 제거하여 작업 영역을 깔끔하게 유지합니다.
```
%%bash -x 

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

모델이 설치되어 실행 중인지 확인합니다. 이 확인은 운영자가 추론 엔드포인트를 관리하기 위한 AWS권한을 성공적으로 수임할 수 있도록 합니다.


%%bash

# Get the service account details
kubectl get serviceaccount -n hyperpod-inference-system

# Check if the service account has theAWSannotations
kubectl describe serviceaccount hyperpod-inference-operator-controller-manager -n hyperpod-inference-system

배포 설정에서 JumpStart는 배포를 위한 인스턴스를 추천합니다. 필요한 경우 이 설정을 수정할 수 있습니다.
1. 인스턴스 유형을 수정하는 경우 선택한 HyperPod 클러스터와 호환되는지 확인합니다. 호환되는 인스턴스가 없는 경우 새 HyperPod 클러스터를 선택하거나 관리자에게 문의하여 클러스터에 호환되는 인스턴스를 추가해야 합니다.
2. 선택한 인스턴스 유형이 GPU 파티셔닝을 지원하고 클러스터가 MIG로 구성된 경우 사용 가능한 MIG 프로파일에서 특정 GPU 파티션을 선택할 수 있습니다. 이를 통해 모델에 필요한 GPU 리소스만 할당하여 GPU 사용률을 최적화할 수 있습니다. 자세한 내용은 Amazon SageMaker HyperPod에서 GPU 파티션 사용 단원을 참조하십시오.
3. 모델 배포의 우선순위를 지정하려면 태스크 거버넌스 추가 기능을 설치하고, 컴퓨팅 할당을 생성하고, 클러스터 정책에 대한 작업 순위를 설정합니다. 이 작업이 완료되면 모델 배포의 우선순위를 선택하는 옵션이 표시됩니다. 이 우선순위를 사용해 클러스터에서 다른 배포 및 작업을 선점할 수 있습니다.
4. 관리자가 액세스 권한을 제공한 네임스페이스를 입력합니다. 정확한 네임스페이스를 가져오려면 관리자에게 직접 문의해야 할 수 있습니다. 유효한 네임스페이스가 제공되면 모델을 배포하기 위한 배포 버튼이 활성화됩니다.

(선택 사항) SageMaker AI Studio Classic에서 JumpStart UI를 통한 사용자 액세스 설정

Studio Classic 사용자에 대한 SageMaker HyperPod 액세스를 설정하고 데이터 과학자 사용자에 대한 세분화된 Kubernetes RBAC 권한을 구성하는 방법에 대한 자세한 내용은 Studio에서 Amazon EKS 클러스터 설정 및 Kubernetes 역할 기반 액세스 제어 설정 섹션을 참조하세요.

데이터 과학자 사용자가 SageMaker AI Studio Classic에서 모델을 관리하고 SageMaker HyperPod에 배포하는 데 사용할 IAM 역할을 식별합니다. 일반적으로 Studio Classic 사용자의 사용자 프로필 실행 역할 또는 도메인 실행 역할입니다.


%%bash -x

export DATASCIENTIST_ROLE_NAME="<Execution Role Name used in SageMaker Studio Classic>"

export DATASCIENTIST_POLICY_NAME="HyperPodUIAccessPolicy"
export EKS_CLUSTER_ARN=$(aws --region $REGION sagemaker describe-cluster --cluster-name $HYPERPOD_CLUSTER_NAME \
  --query 'Orchestrator.Eks.ClusterArn' --output text)

export DATASCIENTIST_HYPERPOD_NAMESPACE="team-namespace"

모델 배포 액세스를 활성화하는 ID 정책을 연결합니다.


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

kubernetes 그룹에 매핑하는 사용자를 위해 EKS 액세스 항목을 생성합니다.


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

사용자를 위한 Kubernetes RBAC 정책을 생성합니다.


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

javascript가 브라우저에서 비활성화되거나 사용이 불가합니다.

AWS 설명서를 사용하려면 Javascript가 활성화되어야 합니다. 지침을 보려면 브라우저의 도움말 페이지를 참조하십시오.

문서 규칙

HyperPod에 모델 배포

파운데이션 모델 및 사용자 지정 미세 조정 모델 배포