Fase 1: migración de la interfaz de usuario de Studio Classic a Studio

1. Cree un dominio de prueba para verificar las configuraciones antes de migrar el dominio existente.

2. Migre el dominio existente.

3. Limpie el dominio de prueba.

1. Obtén el ID de dominio de tu dominio actual.

   1. Abre la SageMaker consola de Amazon en https://console.aws.amazon.com/sagemaker/.

   2. En el panel de navegación izquierdo, expande las configuraciones de administración y selecciona Dominios.

   3. Elige el dominio existente.

   4. En la página Detalles del dominio, elija la pestaña Configuración del dominio.

   5. Copia el ID de dominio.

2. Agrega el ID de dominio de tu dominio existente.

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

3. Se usa describe-domain para obtener información importante sobre el dominio 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 los parámetros.

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

5. Cree un dominio de prueba con las configuraciones del dominio 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. Una vez creado el dominio de pruebaIn Service, utilice el ID del dominio de prueba para crear un perfil de usuario. Este perfil de usuario se utiliza para lanzar y probar aplicaciones.

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

1. Cree una AWS Identity and Access Management política con uno de los siguientes contenidos siguiendo los pasos que se indican en Creación de políticas de IAM:

   • Utilice la siguiente política para conceder permisos a todos los tipos y espacios de aplicaciones.

     nota

     Si el dominio de prueba usa la SageMakerFullAccess política, no es necesario que realice esta acción. SageMakerFullAccessconcede permisos para crear todas las aplicaciones.

     {
         "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 Studio muestra un conjunto ampliado de aplicaciones, los usuarios pueden tener acceso a aplicaciones que no se mostraban antes. Los administradores pueden limitar el acceso a estas aplicaciones predeterminadas mediante la creación de una política AWS Identity and Access Management (IAM) que deniegue los permisos de algunas aplicaciones a usuarios específicos.

     nota

     El tipo de aplicación puede ser jupyterlab ocodeeditor.

     {  
       "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. Adjunte la política a la función de ejecución del dominio de prueba. Para obtener instrucciones, sigue los pasos que se indican en Añadir permisos de identidad de IAM (consola).

Para añadir una configuración CORS a un bucket de Amazon S3

1. Compruebe que haya un bucket de Amazon S3 en el Región de AWS mismo dominio existente con el siguiente nombre. Para obtener instrucciones, consulte Visualización de las propiedades de un bucket de Amazon S3.

   sagemaker-region-account-id

2. Añada una configuración CORS con el siguiente contenido al bucket predeterminado de Amazon S3. Para obtener instrucciones, consulte Configurar el uso compartido de recursos entre orígenes (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 permisos para la funcionalidad de Data Wrangler dentro de Canvas

1. Adjunte la política AWS administrada AmazonSageMakerFullAccessa la función de IAM de su usuario. Para ver un procedimiento que muestra cómo asociar políticas de IAM a un rol, consulte Añadir permisos de identidad de IAM (consola) en la Guía del usuario de AWS IAM.

   Si esta política de permisos es demasiado permisiva para su caso de uso, puede crear políticas específicas que incluyan al menos los siguientes permisos:

   {
       "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. Adjunta la política AWS gestionada a la función de IAM AmazonSageMakerCanvasDataPrepFullAccessde tu usuario.

Para asociar las políticas de IAM a una función de ejecución

1. Busque el rol de ejecución adjunto a su perfil SageMaker de usuario

   1. En la SageMaker consolahttps://console.aws.amazon.com/sagemaker/, dirígete a Dominios y, a continuación, selecciona tu SageMaker dominio.

   2. El ARN de la función de ejecución aparece en la sección Función de ejecución de la página de detalles del usuario de su perfil de usuario. Anote el nombre de la función de ejecución en el ARN.

   3. En la consola de IAM https://console.aws.amazon.com/iam/, elija Roles.

   4. Busque su función por su nombre en el campo de búsqueda.

   5. Seleccione el rol.

2. Añada políticas al rol

   1. En la consola de IAM https://console.aws.amazon.com/iam/, elija Roles.

   2. Busque su función por su nombre en el campo de búsqueda.

   3. Seleccione el rol.

   4. En la pestaña Permisos, navega hasta el menú desplegable Añadir permisos.

   5. • Para políticas administradas: selecciona Adjuntar políticas y busca el nombre de la política de administración que deseas adjuntar.

        Selecciona la política y, a continuación, selecciona Añadir permisos.

      • Para las políticas en línea: selecciona Crear política en línea, pega la política en la pestaña JSON, selecciona Siguiente, asigna un nombre a la política y selecciona Crear.

1. Agrega el ID del dominio de prueba.

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

2. Enumera todas las aplicaciones del dominio que se encuentran en estado de ejecución.

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

3. Analice la lista JSON de aplicaciones en ejecución y elimínelas. Si los usuarios intentaron crear una aplicación para la que no tienen permisos, es posible que haya espacios que no estén capturados en el siguiente script. Debe eliminar estos espacios manualmente.

   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. Elimine el perfil de usuario de prueba.

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

5. Elimine el dominio de prueba.

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