Fase 1: Migrar a interface do usuário do Studio Classic para o Studio

1. Crie um domínio de teste para verificar as configurações antes de migrar o domínio existente.

2. Migre o domínio existente.

3. Limpe o domínio de teste.

1. Obtenha o ID de domínio do seu domínio existente.

   1. Abra o SageMaker console da Amazon em https://console.aws.amazon.com/sagemaker/.

   2. No painel de navegação esquerdo, expanda Configurações administrativas e escolha Domínios.

   3. Escolha o domínio existente.

   4. Na página Detalhes do Domínio, escolha a guia Configurações do Domínio.

   5. Copie o ID do domínio.

2. Adicione o ID de domínio do seu domínio existente.

   export REF_DOMAIN_ID="domain-id"
   export SM_REGION="region"

3. Use describe-domain para obter informações importantes sobre o domínio existente.

   export REF_EXECROLE=$(aws sagemaker describe-domain --region=$SM_REGION --domain-id=$REF_DOMAIN_ID | jq -r '.DefaultUserSettings.ExecutionRole')
   export REF_VPC=$(aws sagemaker describe-domain --region=$SM_REGION --domain-id=$REF_DOMAIN_ID | jq -r '.VpcId')
   export REF_SIDS=$(aws sagemaker describe-domain --region=$SM_REGION --domain-id=$REF_DOMAIN_ID | jq -r '.SubnetIds | join(",")')
   export REF_SGS=$(aws sagemaker describe-domain --region=$SM_REGION --domain-id=$REF_DOMAIN_ID | jq -r '.DefaultUserSettings.SecurityGroups | join(",")')
   export AUTHMODE=$(aws sagemaker describe-domain --region=$SM_REGION --domain-id=$REF_DOMAIN_ID | jq -r '.AuthMode')

4. Valide os parâmetros.

   echo "Execution Role: $REF_EXECROLE || VPCID: $REF_VPC || SubnetIDs: $REF_SIDS || Security GroupIDs: $REF_SGS || AuthMode: $AUTHMODE"

5. Crie um domínio de teste usando as configurações do domínio existente.

   IFS=',' read -r -a subnet_ids <<< "$REF_SIDS"
   IFS=',' read -r -a security_groups <<< "$REF_SGS"
   security_groups_json=$(printf '%s\n' "${security_groups[@]}" | jq -R . | jq -s .)
   
   aws sagemaker create-domain \
   --domain-name "TestV2Config" \
   --vpc-id $REF_VPC \
   --auth-mode $AUTHMODE \
   --subnet-ids "${subnet_ids[@]}" \
   --app-network-access-type VpcOnly \
   --default-user-settings "
   {
       \"ExecutionRole\": \"$REF_EXECROLE\",
       \"StudioWebPortal\": \"ENABLED\",
       \"DefaultLandingUri\": \"studio::\",
       \"SecurityGroups\": $security_groups_json
   }
   "

6. Depois que o domínio de teste estiver In Service pronto, use o ID do domínio de teste para criar um perfil de usuário. Esse perfil de usuário é usado para iniciar e testar aplicativos.

   aws sagemaker create-user-profile \
   --region="$SM_REGION" --domain-id=test-domain-id \
   --user-profile-name test-network-user

1. Crie uma AWS Identity and Access Management política com um dos conteúdos a seguir seguindo as etapas em Criação de políticas do IAM:

   • Use a política a seguir para conceder permissões para todos os tipos e espaços de aplicativos.

     nota

     Se o domínio de teste usar a SageMakerFullAccess política, você não precisará executar essa ação. SageMakerFullAccessconcede permissões para criar todos os aplicativos.

     {
         "Version": "2012-10-17",
         "Statement": [
             {
                 "Sid": "SMStudioUserProfileAppPermissionsCreateAndDelete",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateApp",
                     "sagemaker:DeleteApp"
                 ],
                 "Resource": "arn:aws:sagemaker:region:account-id:app/*",
                 "Condition": {
                     "Null": {
                         "sagemaker:OwnerUserProfileArn": "true"
                     }
                 }
             },
             {
                 "Sid": "SMStudioCreatePresignedDomainUrlForUserProfile",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreatePresignedDomainUrl"
                 ],
                 "Resource": "arn:aws:sagemaker:region:account-id:user-profile/${sagemaker:DomainId}/${sagemaker:UserProfileName}"
             },
             {
                 "Sid": "SMStudioAppPermissionsListAndDescribe",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:ListApps",
                     "sagemaker:ListDomains",
                     "sagemaker:ListUserProfiles",
                     "sagemaker:ListSpaces",
                     "sagemaker:DescribeApp",
                     "sagemaker:DescribeDomain",
                     "sagemaker:DescribeUserProfile",
                     "sagemaker:DescribeSpace"
                 ],
                 "Resource": "*"
             },
             {
                 "Sid": "SMStudioAppPermissionsTagOnCreate",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:AddTags"
                 ],
                 "Resource": "arn:aws:sagemaker:region:account-id:*/*",
                 "Condition": {
                     "Null": {
                         "sagemaker:TaggingAction": "false"
                     }
                 }
             },
             {
                 "Sid": "SMStudioRestrictSharedSpacesWithoutOwners",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateSpace",
                     "sagemaker:UpdateSpace",
                     "sagemaker:DeleteSpace"
                 ],
                 "Resource": "arn:aws:sagemaker:region:account-id:space/${sagemaker:DomainId}/*",
                 "Condition": {
                     "Null": {
                         "sagemaker:OwnerUserProfileArn": "true"
                     }
                 }
             },
             {
                 "Sid": "SMStudioRestrictSpacesToOwnerUserProfile",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateSpace",
                     "sagemaker:UpdateSpace",
                     "sagemaker:DeleteSpace"
                 ],
                 "Resource": "arn:aws:sagemaker:region:account-id:space/${sagemaker:DomainId}/*",
                 "Condition": {
                     "ArnLike": {
                         "sagemaker:OwnerUserProfileArn": "arn:aws:sagemaker:us-east-1:account-id:user-profile/${sagemaker:DomainId}/${sagemaker:UserProfileName}"
                     },
                     "StringEquals": {
                         "sagemaker:SpaceSharingType": [
                             "Private",
                             "Shared"
                         ]
                     }
                 }
             },
             {
                 "Sid": "SMStudioRestrictCreatePrivateSpaceAppsToOwnerUserProfile",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateApp",
                     "sagemaker:DeleteApp"
                 ],
                 "Resource": "arn:aws:sagemaker:region:account-id:app/${sagemaker:DomainId}/*",
                 "Condition": {
                     "ArnLike": {
                         "sagemaker:OwnerUserProfileArn": "arn:aws:sagemaker:us-east-1:account-id:user-profile/${sagemaker:DomainId}/${sagemaker:UserProfileName}"
                     },
                     "StringEquals": {
                         "sagemaker:SpaceSharingType": [
                             "Private"
                         ]
                     }
                 }
             },
             {
                 "Sid": "AllowAppActionsForSharedSpaces",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateApp",
                     "sagemaker:DeleteApp"
                 ],
                 "Resource": "arn:aws:sagemaker:*:*:app/${sagemaker:DomainId}/*/*/*",
                 "Condition": {
                     "StringEquals": {
                         "sagemaker:SpaceSharingType": [
                             "Shared"
                         ]
                     }
                 }
             }
         ]
     }

   • Como o Studio mostra um conjunto expandido de aplicativos, os usuários podem ter acesso a aplicativos que não foram exibidos antes. Os administradores podem limitar o acesso a esses aplicativos padrão criando uma política AWS Identity and Access Management (IAM) que concede permissões negadas para alguns aplicativos a usuários específicos.

     nota

     O tipo de aplicativo pode ser jupyterlab oucodeeditor.

     {  
       "Version": "2012-10-17",
       "Statement": [
         {
           "Sid": "DenySageMakerCreateAppForSpecificAppTypes",
           "Effect": "Deny",
           "Action": "sagemaker:CreateApp",
           "Resource": "arn:aws:sagemaker:region:account-id:app/domain-id/*/app-type/*"
         }
       ]
     }

2. Anexe a política à função de execução do domínio de teste. Para obter instruções, siga as etapas em Adicionar permissões de identidade do IAM (console).

Para adicionar uma configuração CORS a um bucket do Amazon S3

1. Verifique se há um bucket do Amazon S3 no mesmo domínio existente com o Região da AWS seguinte nome. Para obter instruções, consulte Visualização das propriedades de um bucket do Amazon S3.

   sagemaker-region-account-id

2. Adicione uma configuração CORS com o conteúdo a seguir ao bucket padrão do Amazon S3. Para obter instruções, consulte Como configurar o compartilhamento de recursos de origem cruzada (CORS).

   [
       {
           "AllowedHeaders": [
               "*"
           ],
           "AllowedMethods": [
               "POST",
               "PUT",
               "GET",
               "HEAD",
               "DELETE"
           ],
           "AllowedOrigins": [
               "https://*.sagemaker.aws"
           ],
           "ExposeHeaders": [
               "ETag",
               "x-amz-delete-marker",
               "x-amz-id-2",
               "x-amz-request-id",
               "x-amz-server-side-encryption",
               "x-amz-version-id"
           ]
       }
   ]

Para conceder permissões para a funcionalidade do Data Wrangler dentro do Canvas

1. Anexe a política AWS gerenciada AmazonSageMakerFullAccessà função do IAM do seu usuário. Para ver um procedimento que mostra como anexar políticas do IAM a uma função, consulte Adicionar permissões de identidade do IAM (console) no Guia AWS do usuário do IAM.

   Se essa política de permissões for muito permissiva para seu caso de uso, você poderá criar políticas com escopo reduzido que incluam pelo menos as seguintes permissões:

   {
       "Sid": "AllowStudioActions",
       "Effect": "Allow",
       "Action": [
           "sagemaker:CreatePresignedDomainUrl",
           "sagemaker:DescribeDomain",
           "sagemaker:ListDomains",
           "sagemaker:DescribeUserProfile",
           "sagemaker:ListUserProfiles",
           "sagemaker:DescribeSpace",
           "sagemaker:ListSpaces",
           "sagemaker:DescribeApp",
           "sagemaker:ListApps"
       ],
       "Resource": "*"
   },
   {
       "Sid": "AllowAppActionsForUserProfile",
       "Effect": "Allow",
       "Action": [
           "sagemaker:CreateApp",
           "sagemaker:DeleteApp"
       ],
       "Resource": "arn:aws:sagemaker:region:account-id:app/domain-id/user-profile-name/canvas/*",
       "Condition": {
           "Null": {
               "sagemaker:OwnerUserProfileArn": "true"
           }
       }
   }

2. Anexe a política AWS gerenciada AmazonSageMakerCanvasDataPrepFullAccessà função do IAM do seu usuário.

Para anexar políticas do IAM a uma função de execução

1. Encontre a função de execução anexada ao seu perfil de SageMaker usuário

   1. No SageMaker consolehttps://console.aws.amazon.com/sagemaker/, navegue até Domínios e escolha seu SageMaker domínio.

   2. O ARN da função de execução está listado em Função de execução na página Detalhes do usuário do seu perfil de usuário. Anote o nome da função de execução no ARN.

   3. No console do IAM https://console.aws.amazon.com/iam/, escolha Roles.

   4. Pesquise sua função pelo nome no campo de pesquisa.

   5. Selecione a função.

2. Adicionar políticas à função

   1. No console do IAM https://console.aws.amazon.com/iam/, escolha Roles.

   2. Pesquise sua função pelo nome no campo de pesquisa.

   3. Selecione a função.

   4. Na guia Permissões, navegue até o menu suspenso Adicionar permissões.

   5. • Para políticas gerenciadas: selecione Anexar políticas, pesquise o nome da política de gerenciamento que você deseja anexar.

        Selecione a política e escolha Adicionar permissões.

      • Para políticas em linha: selecione Criar política em linha, cole sua política na guia JSON, escolha Avançar, nomeie sua política e escolha Criar.

1. Adicione o ID do domínio de teste.

   export TEST_DOMAIN="test-domain-id"
   export SM_REGION="region"

2. Liste todos os aplicativos no domínio que estão em execução.

   active_apps_json=$(aws sagemaker list-apps --region=$SM_REGION --domain-id=$TEST_DOMAIN)
   echo $active_apps_json

3. Analise a lista JSON de aplicativos em execução e exclua-os. Se os usuários tentarem criar um aplicativo para o qual não têm permissões, pode haver espaços que não foram capturados no script a seguir. Você deve excluir manualmente esses espaços.

   echo "$active_apps_json" | jq -c '.Apps[]' | while read -r app;
   do
       if echo "$app" | jq -e '. | has("SpaceName")' > /dev/null;
       then
           app_type=$(echo "$app" | jq -r '.AppType')
           app_name=$(echo "$app" | jq -r '.AppName')
           domain_id=$(echo "$app" | jq -r '.DomainId')
           space_name=$(echo "$app" | jq -r '.SpaceName')
   
           echo "Deleting App - AppType: $app_type || AppName: $app_name || DomainId: $domain_id || SpaceName: $space_name"
           aws sagemaker delete-app --region=$SM_REGION --domain-id=$domain_id \
           --app-type $app_type --app-name $app_name --space-name $space_name
   
           echo "Deleting Space - AppType: $app_type || AppName: $app_name || DomainId: $domain_id || SpaceName: $space_name"
           aws sagemaker delete-space --region=$SM_REGION --domain-id=$domain_id \
           --space-name $space_name
       else
   
           app_type=$(echo "$app" | jq -r '.AppType')
           app_name=$(echo "$app" | jq -r '.AppName')
           domain_id=$(echo "$app" | jq -r '.DomainId')
           user_profile_name=$(echo "$app" | jq -r '.UserProfileName')
   
           echo "Deleting Studio Classic - AppType: $app_type || AppName: $app_name || DomainId: $domain_id || UserProfileName: $user_profile_name"
           aws sagemaker delete-app --region=$SM_REGION --domain-id=$domain_id \
           --app-type $app_type --app-name $app_name --user-profile-name $user_profile_name
   
       fi
   
   done

4. Exclua o perfil do usuário de teste.

   aws sagemaker delete-user-profile \
   --region=$SM_REGION --domain-id=$TEST_DOMAIN \
   --user-profile-name "test-network-user"

5. Exclua o domínio de teste.

   aws sagemaker delete-domain \
   --region=$SM_REGION --domain-id=$TEST_DOMAIN