As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Configurando seus HyperPod clusters para implantação de modelos
Este guia mostra como habilitar recursos de inferência em SageMaker HyperPod clusters da Amazon. Você configurará a infraestrutura, as permissões e os operadores de que os engenheiros de aprendizado de máquina precisam para implantar e gerenciar endpoints de inferência.
**nota**
Para criar um cluster com o operador de inferência pré-instalado, consulte. [Crie um cluster orquestrado pelo EKS SageMaker HyperPod](sagemaker-hyperpod-quickstart.md#sagemaker-hyperpod-quickstart-eks) Para instalar o operador de inferência em um cluster existente, continue com os procedimentos a seguir.
Você pode instalar o operador de inferência usando o console de SageMaker IA para uma experiência simplificada ou usar a AWS CLI para obter mais controle. Este guia aborda os dois métodos de instalação.
## Método 1: instalar o complemento de HyperPod inferência por meio do console de SageMaker IA (recomendado)
O console de SageMaker IA oferece a experiência mais simplificada com duas opções de instalação:
+ **Instalação rápida:** cria automaticamente todos os recursos necessários com padrões otimizados, incluindo funções do IAM, buckets do Amazon S3 e complementos de dependência. Um novo domínio do Studio será criado com as permissões necessárias para implantar um JumpStart modelo no cluster relevante. Essa opção é ideal para começar rapidamente com o mínimo de decisões de configuração.
+ **Instalação personalizada:** oferece flexibilidade para especificar recursos existentes ou personalizar configurações enquanto mantém a experiência de um clique. Os clientes podem optar por reutilizar funções do IAM, buckets do Amazon S3 ou complementos de dependência existentes com base em seus requisitos organizacionais.
### Pré-requisitos
+ Um HyperPod cluster existente com orquestração do Amazon EKS
+ Permissões do IAM para administração de clusters do Amazon EKS
+ kubectl configurado para acesso ao cluster
### Etapas de instalação
1. Navegue até o console de SageMaker IA e acesse **HyperPod Clusters → **Gerenciamento de clusters****.
1. Selecione seu cluster no qual você deseja instalar o Operador de Inferência.
1. Navegue até a guia **Inferência**. Selecione **Instalação rápida** para configuração automatizada ou **Instalação personalizada** para flexibilidade de configuração.
1. Se escolher Instalação personalizada, especifique os recursos existentes ou personalize as configurações conforme necessário.
1. Clique em **Instalar** para iniciar o processo de instalação automatizada.
1. Verifique o status da instalação por meio do console ou executando os seguintes comandos:
```
kubectl get pods -n hyperpod-inference-system
```
```
aws eks describe-addon --cluster-name CLUSTER-NAME --addon-name amazon-sagemaker-hyperpod-inference --region REGION
```
Depois que o complemento for instalado com sucesso, você poderá implantar modelos usando a documentação de implantação do modelo ou navegar até[Verificar se o operador de inferência está funcionando](#sagemaker-hyperpod-model-deployment-setup-verify).
## Método 2: Instalando o operador de inferência usando a CLI AWS
O método de instalação AWS CLI fornece mais controle sobre o processo de instalação e é adequado para automação e configurações avançadas.
### Pré-requisitos
O operador de inferência permite a implantação e o gerenciamento de endpoints de inferência de aprendizado de máquina em seu cluster Amazon EKS. Antes da instalação, certifique-se de que seu cluster tenha as configurações de segurança e a infraestrutura de suporte necessárias. Conclua estas etapas para configurar as funções do IAM, instalar o AWS Load Balancer Controller, configurar os drivers Amazon S3 e FSx Amazon CSI e implantar o KEDA e o cert-manager:
1. [Conecte-se ao seu cluster e configure variáveis de ambiente](#sagemaker-hyperpod-model-deployment-setup-connect-addon)
1. [Configurar funções do IAM para o operador de inferência](#sagemaker-hyperpod-model-deployment-setup-prepare-addon)
1. [Crie a função de controlador ALB](#sagemaker-hyperpod-model-deployment-setup-alb-addon)
1. [Criar um perfil de operador do KEDA](#sagemaker-hyperpod-model-deployment-setup-keda-addon)
1. [Instale a dependência EKS Add-Ons](#sagemaker-hyperpod-model-deployment-setup-install-dependencies)
**nota**
Como alternativa, você pode usar CloudFormation modelos para automatizar a configuração de pré-requisitos. Para obter mais informações, consulte [Usando CloudFormation modelos para criar a pilha de pré-requisitos](#sagemaker-hyperpod-model-deployment-setup-cfn).
### Conecte-se ao seu cluster e configure variáveis de ambiente
Antes de continuar, verifique se suas AWS credenciais estão configuradas corretamente e se têm as permissões necessárias. Execute as etapas a seguir usando um administrador do IAM com privilégios de administrador e acesso de administrador de cluster a um cluster Amazon EKS. Certifique-se de ter criado um HyperPod cluster com[Criação de um SageMaker HyperPod cluster com a orquestração do Amazon EKS](sagemaker-hyperpod-eks-operate-console-ui-create-cluster.md). Instale os utilitários de linha de comando helm, eksctl e kubectl.
Para acesso administrativo do Kubernetes ao cluster do Amazon EKS, abra o console do Amazon EKS e selecione seu cluster. Na guia **Acesso**, selecione **Entradas de acesso do IAM**. Se não existir nenhuma entrada para seu diretor do IAM, selecione **Criar entrada de acesso**. Selecione o principal do IAM desejado e `AmazonEKSClusterAdminPolicy` associe-o a ele.
1. Configure o kubectl para se conectar ao cluster recém-criado orquestrado pelo HyperPod cluster Amazon EKS. Especifique a região e o nome do HyperPod cluster.
```
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
```
**nota**
Se estiver usando um nome de bucket personalizado que não comece com`hyperpod-tls-`, anexe a seguinte política à sua função de execução:
```
{
"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. Defina as variáveis de ambiente padrão.
```
HYPERPOD_INFERENCE_ROLE_NAME="SageMakerHyperPodInference-$HYPERPOD_CLUSTER_NAME"
HYPERPOD_INFERENCE_NAMESPACE="hyperpod-inference-system"
```
1. Extraia o nome do cluster do Amazon EKS do ARN do cluster, atualize o kubeconfig local e verifique a conectividade listando todos os pods nos namespaces.
```
kubectl get pods --all-namespaces
```
1. (Opcional) Instale o plug-in do dispositivo NVIDIA para habilitar o suporte à GPU no cluster.
```
# Install nvidia device plugin
kubectl create -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.14.5/nvidia-device-plugin.yml
# Verify that GPUs are visible to k8s
kubectl get nodes -o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia.com/gpu
```
### Configurar funções do IAM para o operador de inferência
1. Reúna os identificadores de AWS recursos essenciais e ARNs necessários para configurar as integrações de serviços entre os componentes do Amazon EKS, SageMaker AI e IAM.
```
%%bash -x
export ACCOUNT_ID=$(aws --region $REGION sts get-caller-identity --query 'Account' --output text)
export OIDC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
export EKS_CLUSTER_ROLE=$(aws eks --region $REGION describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.roleArn' --output text)
```
1. Associe um OIDCidentity provedor do IAM ao seu cluster EKS.
```
eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve
```
1. Crie a política de confiança necessária para a função IAM do operador de HyperPod inferência. Essas políticas permitem a comunicação segura entre serviços entre o Amazon EKS, a SageMaker IA e outros AWS serviços.
```
%%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. Crie um perfil de execução para o operador de inferência.
```
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. Crie um namespace para recursos do operador de inferência
```
kubectl create namespace $HYPERPOD_INFERENCE_NAMESPACE
```
### Crie a função de controlador ALB
1. Crie a política de confiança e a política de permissões.
```
# 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. Aplique Tags (`kubernetes.io.role/elb`) a todas as sub-redes no cluster Amazon EKS (públicas e privadas).
```
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. Crie um endpoint da VPC do Amazon S3.
```
aws ec2 create-vpc-endpoint \
--region ${REGION} \
--vpc-id ${VPC_ID} \
--vpc-endpoint-type Gateway \
--service-name "com.amazonaws.${REGION}.s3" \
--route-table-ids $(aws ec2 describe-route-tables --region $REGION --filters "Name=vpc-id,Values=${VPC_ID}" --query 'RouteTables[].Associations[].RouteTableId' --output text | tr ' ' '\n' | sort -u | tr '\n' ' ')
```
### Criar um perfil de operador do KEDA
1. Crie a política de confiança e a política de permissões.
```
# 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. Se você estiver usando modelos fechados, crie um perfil do IAM para acessar acessá-los.
1. Crie uma política do IAM.
```
%%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. Criar um perfil do IAM.
```
# Create the role using existing trust policy
aws iam create-role \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--assume-role-policy-document file:///tmp/trust-policy.json
aws iam attach-role-policy \
--role-name $JUMPSTART_GATED_ROLE_NAME \
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerHyperPodGatedModelAccess
```
```
JUMPSTART_GATED_ROLE_ARN_LIST= !aws iam get-role --role-name=$JUMPSTART_GATED_ROLE_NAME --query "Role.Arn" --output text
JUMPSTART_GATED_ROLE_ARN = JUMPSTART_GATED_ROLE_ARN_LIST[0]
!echo $JUMPSTART_GATED_ROLE_ARN
```
### Instale a dependência EKS Add-Ons
Antes de instalar o operador de inferência, você deve instalar os seguintes complementos EKS necessários em seu cluster. O operador de inferência falhará na instalação se alguma dessas dependências estiver ausente. Cada complemento tem um requisito mínimo de versão para compatibilidade com o complemento Inference.
**Importante**
Instale todos os complementos de dependência antes de tentar instalar o operador de inferência. Dependências ausentes causarão falhas na instalação com mensagens de erro específicas.
#### Complementos necessários
1. **Driver CSI do Amazon S3 Mountpoint** (versão mínima: v1.14.1-eksbuild.1)
Necessário para montar buckets S3 como volumes persistentes em cargas de trabalho de inferência.
```
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
```
Para obter instruções detalhadas de instalação, incluindo as permissões necessárias do IAM, consulte [Mountpoint for Amazon S3 CSI driver](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#mountpoint-for-s3-add-on).
1. **Amazon FSx CSI Driver** (versão mínima: v1.6.0-eksbuild.1)
Necessário para montar sistemas de FSx arquivos para armazenamento de modelos de alto desempenho.
```
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
```
Para obter instruções detalhadas de instalação, incluindo as permissões necessárias do IAM, consulte o driver [CSI Amazon FSx for Lustre](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#add-ons-aws-fsx-csi-driver).
1. **Metrics Server** (versão mínima: v0.7.2-eksbuild.4)
Necessário para funcionalidade de escalonamento automático e coleta de métricas de recursos.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name metrics-server \
--region $REGION
```
Para obter instruções detalhadas de instalação, consulte [Metrics Server](https://docs.aws.amazon.com/eks/latest/userguide/metrics-server.html).
1. **Cert Manager** (versão mínima: v1.18.2-eksbuild.2)
Necessário para o gerenciamento de certificados TLS para endpoints de inferência seguros.
```
aws eks create-addon \
--cluster-name $EKS_CLUSTER_NAME \
--addon-name cert-manager \
--region $REGION
```
Para obter instruções detalhadas de instalação, consulte [cert-manager](https://docs.aws.amazon.com/eks/latest/userguide/community-addons.html#addon-cert-manager).
#### Verifique a instalação do complemento
Depois de instalar os complementos necessários, verifique se eles estão funcionando corretamente:
```
# 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
```
Todos os complementos devem mostrar o status “ATIVO” e todos os pods devem estar no estado “Em execução” antes de prosseguir com a instalação do operador de inferência.
**nota**
Se você criou seu HyperPod cluster usando as opções de configuração rápida ou personalizada, o driver FSx CSI e o Cert Manager já podem estar instalados. Verifique a presença deles usando os comandos acima.
### Instalando o operador de inferência com o complemento EKS
O método de instalação do complemento EKS fornece uma experiência gerenciada com atualizações automáticas e validação de dependências integrada. Essa é a abordagem recomendada para instalar o operador de inferência.
**Instale o complemento do operador de inferência**
1. Prepare a configuração do complemento reunindo tudo o que é necessário ARNs e criando o arquivo de configuração:
```
# 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. Crie o arquivo de configuração do complemento com todas as configurações necessárias:
```
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. Instale o complemento do operador de inferência (versão mínima: 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. Monitore o progresso da instalação e verifique a conclusão bem-sucedida:
```
# 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
```
Para obter uma solução detalhada de problemas de instalação, consulte[HyperPod solução de problemas de inferência](sagemaker-hyperpod-model-deployment-ts.md).
Para verificar se o operador de inferência está funcionando corretamente, continue[Verificar se o operador de inferência está funcionando](#sagemaker-hyperpod-model-deployment-setup-verify).
### Usando CloudFormation modelos para criar a pilha de pré-requisitos
Como alternativa à configuração manual dos pré-requisitos, você pode usar CloudFormation modelos para automatizar a criação das funções e políticas necessárias do IAM para o operador de inferência.
1. Configure as variáveis de entrada. Substitua os valores do espaço reservado pelos seus próprios:
```
#!/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. Obtenha informações de cluster e rede:
```
# ===== 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. Crie o arquivo de parâmetros e implante a pilha:
```
# ===== 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. Monitore o status de criação da pilha:
```
aws cloudformation describe-stacks \
--stack-name $STACK_NAME \
--region $REGION \
--query 'Stacks[0].StackStatus'
```
1. Depois que a pilha for criada com sucesso, recupere os valores de saída para uso na instalação do operador de inferência:
```
aws cloudformation describe-stacks \
--stack-name $STACK_NAME \
--region $REGION \
--query 'Stacks[0].Outputs'
```
Depois que a CloudFormation pilha for criada, continue com [Instalando o operador de inferência com o complemento EKS](#sagemaker-hyperpod-model-deployment-setup-install-inference-operator-addon) a instalação do operador de inferência.
## Método 3: instalação do Helm Chart
**nota**
Para uma experiência de instalação mais simples, recomendamos usar [Método 1: instalar o complemento de HyperPod inferência por meio do console de SageMaker IA (recomendado)](#sagemaker-hyperpod-model-deployment-setup-ui) ou[Método 2: Instalando o operador de inferência usando a CLI AWS](#sagemaker-hyperpod-model-deployment-setup-addon). A instalação do Helm Chart pode ser descontinuada em uma versão futura.
### Pré-requisitos
Antes de continuar, verifique se suas AWS credenciais estão configuradas corretamente e se têm as permissões necessárias. As etapas a seguir precisam ser executadas por um diretor do IAM com privilégios de administrador e acesso de administrador de cluster a um cluster Amazon EKS. Verifique se você criou um HyperPod cluster com[Criação de um SageMaker HyperPod cluster com a orquestração do Amazon EKS](sagemaker-hyperpod-eks-operate-console-ui-create-cluster.md). Verifique se você instalou os utilitários de linha de comando helm, eksctl e kubectl.
Para acesso administrativo do Kubernetes ao cluster Amazon EKS, acesse o console do Amazon EKS e selecione o cluster que você está usando. Examine a guia **Acesso** e selecione “Entradas de acesso do IAM”. Se não houver uma entrada para sua entidade principal do IAM, selecione **Criar entrada de acesso**. Em seguida, selecione a entidade principal desejada do IAM e associe a `AmazonEKSClusterAdminPolicy` a ela.
1. Configure o kubectl para se conectar ao cluster recém-criado orquestrado pelo HyperPod cluster Amazon EKS. Especifique a região e o nome do HyperPod cluster.
```
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. Defina as variáveis de ambiente padrão.
```
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. Extraia o nome do cluster do Amazon EKS do ARN do cluster, atualize o kubeconfig local e verifique a conectividade listando todos os pods nos namespaces.
```
kubectl get pods --all-namespaces
```
1. (Opcional) Instale o plug-in do dispositivo NVIDIA para habilitar o suporte à GPU no cluster.
```
#Install nvidia device plugin
kubectl create -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.14.5/nvidia-device-plugin.yml
# Verify that GPUs are visible to k8s
kubectl get nodes -o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia.com/gpu
```
### Preparar seu ambiente para a instalação do operador de inferência
1. Reúna os identificadores de AWS recursos essenciais e ARNs necessários para configurar as integrações de serviços entre os componentes do Amazon EKS, SageMaker AI e IAM.
```
%%bash -x
export ACCOUNT_ID=$(aws --region $REGION sts get-caller-identity --query 'Account' --output text)
export OIDC_ID=$(aws --region $REGION eks describe-cluster --name $EKS_CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
export EKS_CLUSTER_ROLE=$(aws eks --region $REGION describe-cluster --name $EKS_CLUSTER_NAME --query 'cluster.roleArn' --output text)
```
1. Associe um OIDCidentity provedor do IAM ao seu cluster EKS.
```
eksctl utils associate-iam-oidc-provider --region=$REGION --cluster=$EKS_CLUSTER_NAME --approve
```
1. Crie a política de confiança necessária para a função IAM do operador de HyperPod inferência. Essa política permite a comunicação segura entre serviços entre o Amazon EKS, a SageMaker IA e outros AWS serviços.
```
%%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. Crie uma função de execução para o operador de inferência e anexe a política gerenciada.
```
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. Baixe e crie a política do IAM necessária para que o AWS Load Balancer Controller gerencie Application Load Balancers e Network Load Balancers em seu cluster EKS.
```
%%bash -x
export ALBController_IAM_POLICY_NAME=HyperPodInferenceALBControllerIAMPolicy
curl -o AWSLoadBalancerControllerIAMPolicy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.13.0/docs/install/iam_policy.json
aws iam create-policy --policy-name $ALBController_IAM_POLICY_NAME --policy-document file://AWSLoadBalancerControllerIAMPolicy.json
```
1. Crie uma conta de serviço do IAM que vincule a conta de serviço do Kubernetes à política do IAM, permitindo que o AWS Load Balancer Controller assuma AWS as permissões necessárias por meio do IRSA (IAM Roles for Service Accounts).
```
%%bash -x
export ALB_POLICY_ARN="arn:aws:iam::$ACCOUNT_ID:policy/$ALBController_IAM_POLICY_NAME"
# Create IAM service account with gathered values
eksctl create iamserviceaccount \
--approve \
--override-existing-serviceaccounts \
--name=aws-load-balancer-controller \
--namespace=kube-system \
--cluster=$EKS_CLUSTER_NAME \
--attach-policy-arn=$ALB_POLICY_ARN \
--region=$REGION
# Print the values for verification
echo "Cluster Name: $EKS_CLUSTER_NAME"
echo "Region: $REGION"
echo "Policy ARN: $ALB_POLICY_ARN"
```
1. Aplique Tags (`kubernetes.io.role/elb`) a todas as sub-redes no cluster Amazon EKS (públicas e privadas).
```
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. Crie um namespace para o KEDA e o Cert Manager.
```
kubectl create namespace keda
kubectl create namespace cert-manager
```
1. Crie um endpoint da VPC do Amazon S3.
```
aws ec2 create-vpc-endpoint \
--vpc-id ${VPC_ID} \
--vpc-endpoint-type Gateway \
--service-name "com.amazonaws.${REGION}.s3" \
--route-table-ids $(aws ec2 describe-route-tables --filters "Name=vpc-id,Values=${VPC_ID}" --query 'RouteTables[].Associations[].RouteTableId' --output text | tr ' ' '\n' | sort -u | tr '\n' ' ')
```
1. Configure o acesso ao armazenamento do S3:
1. Crie uma política do IAM que conceda as permissões necessárias do S3 para usar o Mountpoint para Amazon S3, o que permite o acesso do sistema de arquivos aos buckets do S3 por meio do cluster.
```
%%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. (Opcional) Crie uma conta de serviço do IAM para o driver da CSI do Amazon S3. O driver CSI do Amazon S3 exige uma conta de serviço do IAM com permissões apropriadas para montar buckets do S3 como volumes persistentes em seu cluster Amazon EKS. Essa etapa cria um perfil do IAM e a conta de serviço do Kubernetes necessários com a política de acesso do S3 necessária.
```
%%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. (Opcional) Instale o complemento do driver da CSI do Amazon S3. Esse driver permite que os pods montem buckets do S3 como volumes persistentes, fornecendo acesso direto ao armazenamento do S3 por meio de workloads do Kubernetes.
```
%%bash -x
export S3_CSI_ROLE_ARN=$(aws iam get-role --role-name $S3_CSI_ROLE_NAME --query 'Role.Arn' --output text)
eksctl create addon --name aws-mountpoint-s3-csi-driver --cluster $EKS_CLUSTER_NAME --service-account-role-arn $S3_CSI_ROLE_ARN --force
```
1. (Opcional) Crie uma solicitação de volume persistente (PVC) para armazenamento do S3. Essa PVC permite que os pods solicitem e usem o armazenamento do S3 como se fosse um sistema de arquivos tradicional.
```
%%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. (Opcional) Configure o acesso ao FSx armazenamento. Crie uma conta de serviço do IAM para o driver Amazon FSx CSI. Essa conta de serviço será usada pelo driver FSx CSI para interagir com o FSx serviço da Amazon em nome do seu cluster.
```
%%bash -x
eksctl create iamserviceaccount \
--name fsx-csi-controller-sa \
--namespace kube-system \
--cluster $EKS_CLUSTER_NAME \
--attach-policy-arn arn:aws:iam::aws:policy/AmazonFSxFullAccess \
--approve \
--role-name FSXLCSI-${EKS_CLUSTER_NAME}-${REGION} \
--region $REGION
```
### Criar um perfil de operador do KEDA
1. Crie a política de confiança e a política de permissões.
```
# 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. Se você estiver usando modelos fechados, crie um perfil do IAM para acessar acessá-los.
1. Crie a política de confiança e a função do IAM para acesso fechado ao modelo.
```
%%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
```
### Instalar o operador de inferência
1. Instale o operador de HyperPod inferência. Essa etapa reúne os identificadores de recursos necessários da AWS e gera o comando de instalação do Helm com os parâmetros de configuração apropriados.
Acesse o gráfico do leme em [https://github.com/aws/sagemaker-hyperpod-cli/tree/main/helm\_chart](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
```
1. Configure as anotações da conta de serviço para integração com o IAM. Essa anotação permite que a conta de serviço do operador assuma as permissões necessárias do IAM para gerenciar endpoints de inferência e interagir com os serviços da AWS .
```
%%bash -x
EKS_CLUSTER_ROLE_NAME=$(echo $EKS_CLUSTER_ROLE | sed 's/.*\///')
# Annotate service account
kubectl annotate serviceaccount hyperpod-inference-operator-controller-manager \
-n hyperpod-inference-system \
eks.amazonaws.com/role-arn=arn:aws:iam::${ACCOUNT_ID}:role/${EKS_CLUSTER_ROLE_NAME} \
--overwrite
```
## Verificar se o operador de inferência está funcionando
Siga estas etapas para verificar se a instalação do operador de inferência está funcionando corretamente implantando e testando um modelo simples.
**Implante um modelo de teste para verificar o operador**
1. Crie um arquivo de configuração de implantação do modelo. Isso cria um arquivo de manifesto do Kubernetes que define uma implantação de JumpStart modelo para o HyperPod operador de inferência.
```
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. Implante o modelo e limpe o arquivo de configuração.
```
kubectl create -f simple_model_install.yaml
rm -f simple_model_install.yaml
```
1. Verifique a configuração da conta de serviço para garantir que o operador possa assumir AWS as permissões.
```
# 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
```
**Defina as configurações de implantação (se estiver usando a interface do usuário do Studio)**
1. Analise o tipo de instância recomendado em **Configurações de implantação**.
1. Se estiver modificando o **tipo de instância**, garanta a compatibilidade com seu HyperPod cluster. Entre em contato com seu administrador se as instâncias compatíveis não estiverem disponíveis.
1. Para instâncias particionadas por GPU com MIG ativado, selecione uma **partição de GPU apropriada nos perfis MIG disponíveis para otimizar a utilização da GPU**. Para obter mais informações, consulte [Usando partições de GPU na Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md).
1. Se estiver usando a governança de tarefas, defina as configurações de prioridade para os recursos de preempção de implantação do modelo.
1. Insira o namespace fornecido pelo seu administrador. Entre em contato com seu administrador para obter o namespace correto, se necessário.
## (Opcional) Configurar o acesso do usuário por meio da JumpStart interface do usuário no SageMaker AI Studio Classic
Para obter mais informações sobre como configurar o SageMaker HyperPod acesso para usuários do Studio Classic e configurar permissões refinadas do Kubernetes RBAC para usuários de cientistas de dados, leia e. [Configurar um cluster do Amazon EKS no Studio](sagemaker-hyperpod-studio-setup-eks.md) [Como configurar controle de acesso ao Kubernetes baseado em perfil](sagemaker-hyperpod-eks-setup-rbac.md)
1. Identifique a função do IAM que os usuários do Data Scientist usarão para gerenciar e implantar modelos a SageMaker HyperPod partir do SageMaker AI Studio Classic. Normalmente, esse é o perfil de execução do perfil do usuário ou o perfil de execução do domínio para o usuário do Studio Classic.
```
%%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. Anexe uma política de identidade que permita o acesso à implantação do modelo.
```
%%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. Crie uma entrada de acesso do EKS para o usuário associá-la a um grupo do Kubernetes.
```
%%bash -x
aws eks create-access-entry --cluster-name $EKS_CLUSTER_NAME \
--principal-arn "arn:aws:iam::$ACCOUNT_ID:role/$DATASCIENTIST_ROLE_NAME" \
--kubernetes-groups '["hyperpod-scientist-user-namespace-level","hyperpod-scientist-user-cluster-level"]'
```
1. Crie políticas RBAC do Kubernetes para o usuário.
```
%%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
```