

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Migrazione dell’interfaccia utente da Studio Classic a Studio
<a name="studio-updated-migrate-ui"></a>

La prima fase per la migrazione di un dominio esistente prevede la migrazione dell'interfaccia utente da Amazon SageMaker Studio Classic ad Amazon SageMaker Studio. Questa fase non include la migrazione dei dati. Gli utenti possono continuare a lavorare normalmente con i propri dati, come prima della migrazione. Per informazioni sulla migrazione dei dati, consulta [(Facoltativo) Migrazione dei dati da Studio Classic a Studio](studio-updated-migrate-data.md).

La fase 1 prevede i passaggi seguenti:

1. Aggiornare le autorizzazioni di creazione delle applicazioni per le nuove applicazioni disponibili in Studio.

1. Aggiornare la configurazione VPC per il dominio.

1. Aggiornare il dominio per utilizzare l’interfaccia utente di Studio.

## Prerequisiti
<a name="studio-updated-migrate-ui-prereq"></a>

Prima di eseguire questa procedura, completa i prerequisiti descritti in [Completamento dei prerequisiti per la migrazione dell’esperienza di Studio](studio-updated-migrate-prereq.md).

## Fase 1. Aggiorna le autorizzazioni per la creazione di applicazioni
<a name="studio-updated-migrate-limit-apps"></a>

Prima di eseguire la migrazione del dominio, aggiorna il ruolo di esecuzione del dominio per concedere agli utenti le autorizzazioni per creare le applicazioni.

1. Crea una AWS Identity and Access Management policy con uno dei seguenti contenuti seguendo i passaggi descritti in [Creazione di politiche IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_create.html): 
   + Utilizza la policy seguente per concedere le autorizzazioni per tutti i tipi e gli spazi delle applicazioni.
**Nota**  
Se il dominio utilizza la policy `SageMakerFullAccess`, non è necessario eseguire questa azione. `SageMakerFullAccess` concede le autorizzazioni per creare tutte le applicazioni.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Sid": "SMStudioUserProfileAppPermissionsCreateAndDelete",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateApp",
                     "sagemaker:DeleteApp"
                 ],
                 "Resource": "arn:aws:sagemaker:{{us-east-1}}:{{111122223333}}:app/*",
                 "Condition": {
                     "Null": {
                         "sagemaker:OwnerUserProfileArn": "true"
                     }
                 }
             },
             {
                 "Sid": "SMStudioCreatePresignedDomainUrlForUserProfile",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreatePresignedDomainUrl"
                 ],
                 "Resource": "arn:aws:sagemaker:{{us-east-1}}:{{111122223333}}: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:{{us-east-1}}:{{111122223333}}:*/*",
                 "Condition": {
                     "Null": {
                         "sagemaker:TaggingAction": "false"
                     }
                 }
             },
             {
                 "Sid": "SMStudioRestrictSharedSpacesWithoutOwners",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateSpace",
                     "sagemaker:UpdateSpace",
                     "sagemaker:DeleteSpace"
                 ],
                 "Resource": "arn:aws:sagemaker:{{us-east-1}}:{{111122223333}}:space/${sagemaker:DomainId}/*",
                 "Condition": {
                     "Null": {
                         "sagemaker:OwnerUserProfileArn": "true"
                     }
                 }
             },
             {
                 "Sid": "SMStudioRestrictSpacesToOwnerUserProfile",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateSpace",
                     "sagemaker:UpdateSpace",
                     "sagemaker:DeleteSpace"
                 ],
                 "Resource": "arn:aws:sagemaker:{{us-east-1}}:{{111122223333}}:space/${sagemaker:DomainId}/*",
                 "Condition": {
                     "ArnLike": {
                         "sagemaker:OwnerUserProfileArn": "arn:aws:sagemaker:us-east-1:{{111122223333}}:user-profile/${sagemaker:DomainId}/${sagemaker:UserProfileName}"
                     },
                     "StringEquals": {
                         "sagemaker:SpaceSharingType": [
                             "Private",
                             "Shared"
                         ]
                     }
                 }
             },
             {
                 "Sid": "SMStudioRestrictCreatePrivateSpaceAppsToOwnerUserProfile",
                 "Effect": "Allow",
                 "Action": [
                     "sagemaker:CreateApp",
                     "sagemaker:DeleteApp"
                 ],
                 "Resource": "arn:aws:sagemaker:{{us-east-1}}:{{111122223333}}:app/${sagemaker:DomainId}/*",
                 "Condition": {
                     "ArnLike": {
                         "sagemaker:OwnerUserProfileArn": "arn:aws:sagemaker:us-east-1:{{111122223333}}: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"
                         ]
                     }
                 }
             }
         ]
     }
     ```

------
   + Poiché Studio mostra un set esteso di applicazioni, gli utenti possono accedere ad applicazioni che prima non venivano visualizzate. Gli amministratori possono limitare l'accesso a queste applicazioni predefinite creando una policy AWS Identity and Access Management (IAM) che conceda le autorizzazioni di negazione per alcune applicazioni a utenti specifici.
**Nota**  
I tipi di applicazione possono essere `jupyterlab` o `codeeditor`.

------
#### [ JSON ]

****  

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

------

1. Associa la policy al ruolo di esecuzione del dominio. Per le istruzioni, segui la procedura descritta in [Adding IAM identity permissions (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console).

## Fase 2. Aggiorna la configurazione VPC
<a name="studio-updated-migrate-vpc"></a>

Se utilizzi il dominio in modalità `VPC-Only`, assicurati che la configurazione del VPC soddisfi i requisiti per l’utilizzo di Studio in modalità `VPC-Only`. Per ulteriori informazioni, consulta [Connect Amazon SageMaker Studio in un VPC a risorse esterne](studio-updated-and-internet-access.md).

## Fase 3. Aggiorna l’interfaccia utente di Studio
<a name="studio-updated-migrate-set-studio-updated"></a>

Prima di eseguire la migrazione del dominio esistente da Studio Classic a Studio, consigliamo di creare un dominio di test utilizzando Studio con le stesse configurazioni del dominio esistente.

### (Facoltativo) Creazione di un dominio di test
<a name="studio-updated-migrate-ui-create-test"></a>

Utilizza questo dominio di test per interagire con Studio, testare le configurazioni di rete e avviare le applicazioni, prima di eseguire la migrazione del dominio esistente.

1. Ottieni l’ID dominio del dominio esistente.

   1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

   1. Nel riquadro di navigazione a sinistra, espandi **Configurazioni di amministrazione** e scegli **Domini**. 

   1. Scegli il dominio esistente.

   1. Dalla pagina **Dettagli dominio**, seleziona la scheda **Impostazioni dominio**.

   1. Copia l’**ID dominio**.

1. Aggiungi l’ID dominio al dominio esistente.

   ```
   export REF_DOMAIN_ID="{{domain-id}}"
   export SM_REGION="{{region}}"
   ```

1. Utilizza `describe-domain` per ottenere informazioni importanti sul dominio esistente.

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

1. Convalida i parametri.

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

1. Crea un dominio di test utilizzando le configurazioni del dominio esistente.

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

1. Dopo aver creato il dominio di test `In Service`, utilizza l’ID del dominio di test per creare un profilo utente. Questo profilo utente viene utilizzato per avviare e testare le applicazioni.

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

#### Test della funzionalità di Studio
<a name="studio-updated-migrate-ui-testing"></a>

Avvia il dominio di test utilizzando il profilo utente `test-network-user`. Ti consigliamo di testare accuratamente l’interfaccia utente di Studio e di creare applicazioni per testare la funzionalità di Studio in modalità `VPCOnly`. Testa i flussi di lavoro seguenti:
+ Crea un nuovo JupyterLab spazio, ambiente di test e connettività.
+ Crea un nuovo editor di codice, basato su Code-OSS Visual Studio Code - Open Source Space, ambiente di test e connettività.
+ Avvia una nuova app Studio Classic, un ambiente di test e una connettività.
+ Testa la connettività di Amazon Simple Storage Service con azioni di test di lettura e scrittura.

Se questi test hanno esito positivo, aggiorna il dominio esistente. In caso di errori, consigliamo di risolvere i problemi relativi ad ambiente e connettività prima di aggiornare il dominio esistente.

#### Pulizia delle risorse del dominio di test
<a name="studio-updated-migrate-ui-clean"></a>

Dopo aver eseguito la migrazione del dominio esistente, pulisci le risorse del dominio di test.

1. Aggiungi l’ID del dominio di test.

   ```
   export TEST_DOMAIN="{{test-domain-id}}"
   export SM_REGION="{{region}}"
   ```

1. Elenca tutte le applicazioni del dominio che sono in esecuzione.

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

1. Analizza l’elenco JSON delle applicazioni in esecuzione ed eliminale. Se gli utenti hanno tentato di creare un’applicazione per la quale non dispongono delle autorizzazioni, potrebbero esserci degli spazi che non sono stati acquisiti nello script seguente. Questi spazi dovranno essere eliminati 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
   ```

1. Elimina il profilo utente di test.

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

1. Elimina il dominio di test.

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

Dopo aver testato la funzionalità di Studio con le configurazioni nel dominio di test, esegui la migrazione del dominio esistente. Se Studio è l’esperienza predefinita per un dominio, lo sarà per tutti gli utenti del dominio. Tuttavia, le impostazioni utente sono prioritarie rispetto alle impostazioni del dominio. Di conseguenza, se Studio Classic è l’esperienza predefinita configurata nelle impostazioni di un utente, l’utente avrà Studio Classic come esperienza predefinita. 

Puoi migrare il dominio esistente aggiornandolo dalla console SageMaker AI AWS CLI, o AWS CloudFormation. Scegli una delle schede seguenti per visualizzare le istruzioni pertinenti.

### Imposta Studio come esperienza predefinita per il dominio esistente utilizzando la console SageMaker AI
<a name="studio-updated-migrate-set-studio-updated-console"></a>

Puoi impostare Studio come esperienza predefinita per il dominio esistente utilizzando la console SageMaker AI.

1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

1. Nel riquadro di navigazione a sinistra, espandi **Configurazioni di amministrazione** e scegli **Domini**. 

1. Scegli il dominio esistente per il quale desideri abilitare Studio come esperienza predefinita.

1. Nella pagina **Dettagli del dominio**, espandi **Abilita il nuovo Studio**.

1. (Facoltativo) Per visualizzare i dettagli sulla procedura necessaria per abilitare Studio come esperienza predefinita, scegli **Visualizza dettagli**. La pagina mostra quanto segue.
   + Nella sezione **Panoramica di SageMaker Studio** puoi visualizzare le applicazioni incluse o disponibili nell'interfaccia basata sul web di Studio. 
   + Nella sezione **Processo di abilitazione** puoi vedere le descrizioni delle attività del flusso di lavoro per abilitare Studio.
**Nota**  
Dovrai eseguire la migrazione dei dati manualmente. Per istruzioni sulla migrazione dei dati, consulta [(Facoltativo) Migrazione dei dati da Studio Classic a Studio](studio-updated-migrate-data.md).
   + Nella sezione **Torna all’esperienza Studio Classic** puoi vedere come tornare a Studio Classic dopo aver abilitato Studio come esperienza predefinita.

1. Per iniziare il processo di abilitazione di Studio come esperienza predefinita, scegli **Abilita il nuovo Studio**.

1. Nella sezione **Specifica e configura il ruolo** puoi vedere le applicazioni predefinite che vengono incluse automaticamente in Studio.

   Per impedire agli utenti di eseguire queste applicazioni, scegli il ruolo AWS Identity and Access Management (IAM) con una policy IAM che rifiuta l’accesso. Per informazioni su come creare una policy per limitare l’accesso, consulta [Fase 1. Aggiorna le autorizzazioni per la creazione di applicazioni](#studio-updated-migrate-limit-apps).

1. Nella sezione **Scegli il bucket S3 predefinito per collegare la policy CORS** puoi concedere a Studio l’accesso ai bucket Amazon S3. In questo caso, il bucket Amazon S3 predefinito è quello per Studio Classic. In questa fase puoi procedere come descritto di seguito:
   + Verifica il bucket Amazon S3 predefinito del dominio a cui collegare la policy CORS. Se il tuo dominio non dispone di un bucket Amazon S3 predefinito, SageMaker AI crea un bucket Amazon S3 con la policy CORS corretta allegata.
   + Puoi includere altri dieci bucket Amazon S3 a cui collegare la policy CORS.

     Se intendi includere più di dieci bucket, puoi aggiungerli manualmente. Per ulteriori informazioni su come collegare manualmente la policy CORS al bucket Amazon S3, consulta [(Facoltativo) Aggiornamento della policy CORS per accedere ai bucket Amazon S3](#studio-updated-migrate-cors).

   Per procedere, seleziona la casella di controllo accanto ad **Accetti di sostituire qualsiasi policy CORS esistente sui bucket Amazon S3 scelti?**

1. La sezione **Esegui la migrazione dei dati** contiene informazioni sui diversi volumi di archiviazione di dati per Studio Classic e Studio. Con questo processo, non verrà eseguita automaticamente la migrazione dei dati. Per istruzioni sulla migrazione dei dati, sulle configurazioni del ciclo di vita e sulle estensioni, consulta. JupyterLab [(Facoltativo) Migrazione dei dati da Studio Classic a Studio](studio-updated-migrate-data.md)

1. Dopo aver completato le attività sulla pagina e verificato la configurazione, scegli **Abilita il nuovo Studio**.

### Imposta Studio come esperienza predefinita per il dominio esistente utilizzando il AWS CLI
<a name="studio-updated-migrate-set-studio-updated-cli"></a>

Per impostare Studio come esperienza predefinita per il dominio esistente con la AWS CLI, utilizza la chiamata [update-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker/update-domain.html). Devi impostare `ENABLED` come valore per `StudioWebPortal` e `studio::` come valore per `DefaultLandingUri` all’interno del parametro `default-user-settings`. 

`StudioWebPortal` indica se Studio è l’esperienza predefinita e `DefaultLandingUri` indica l’esperienza predefinita alla quale viene indirizzato l’utente quando accede al dominio. In questo esempio, l’impostazione di questi valori a livello di dominio (in `default-user-settings`) rende Studio l’esperienza predefinita per gli utenti all’interno del dominio.

Se un utente all’interno del dominio ha impostato `StudioWebPortal` su `DISABLED` e `DefaultLandingUri` su `app:JupyterServer:` a livello utente (in `UserSettings`), queste impostazioni hanno la precedenza rispetto a quelle del dominio. In altre parole, l’utente avrà Studio Classic come esperienza predefinita, indipendentemente dalle impostazioni del dominio. 

Nell’esempio di codice seguente viene illustrato come impostare Studio come esperienza predefinita per gli utenti all’interno del dominio:

```
aws sagemaker update-domain \
--domain-id {{existing-domain-id}} \
--region {{Regione AWS}} \
--default-user-settings '
{
    "StudioWebPortal": "ENABLED",
    "DefaultLandingUri": "studio::"
}
'
```
+ Per ottenere `{{existing-domain-id}}`, utilizza le istruzioni seguenti:

**Per ottenere `{{id di dominio esistente}}`**

  1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

  1. Nel riquadro di navigazione a sinistra, espandi **Configurazioni di amministrazione** e scegli **Domini**. 

  1. Scegli il dominio esistente.

  1. Dalla pagina **Dettagli dominio**, seleziona la scheda **Impostazioni dominio**.

  1. Copia l’**ID dominio**.
+ Per assicurarti di utilizzare quello corretto Regione AWS per il tuo dominio, utilizza le seguenti istruzioni: 

**Per ottenere `{{Regione AWS}}`**

  1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

  1. Nel riquadro di navigazione a sinistra, espandi **Configurazioni di amministrazione** e scegli **Domini**. 

  1. Scegli il dominio esistente.

  1. Nella pagina **Dettagli del dominio**, verifica che si tratti del dominio esistente.

  1. Espandi l'elenco a Regione AWS discesa in alto a destra della console SageMaker AI e utilizza l' Regione AWS ID corrispondente a destra del tuo Regione AWS nome. Ad esempio, `us-west-1`.

Dopo aver eseguito la migrazione della tua esperienza predefinita a Studio, puoi concedere a Studio l’accesso ai bucket Amazon S3. Ad esempio, puoi includere l’accesso al tuo bucket Amazon S3 predefinito di Studio Classic e a bucket Amazon S3 aggiuntivi. A tale scopo, è necessario collegare manualmente una configurazione di [Cross-OriginResource Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) (CORS) ai bucket Amazon S3. Per ulteriori informazioni su come collegare manualmente la policy CORS ai bucket Amazon S3, consulta [(Facoltativo) Aggiornamento della policy CORS per accedere ai bucket Amazon S3](#studio-updated-migrate-cors).

[Allo stesso modo, puoi impostare Studio come esperienza predefinita quando crei un dominio AWS CLI utilizzando la chiamata create-domain.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker/create-domain.html) 

### Imposta Studio come esperienza predefinita per il dominio esistente utilizzando il AWS CloudFormation
<a name="studio-updated-migrate-set-studio-updated-cloud-formation"></a>

Puoi impostare l’esperienza predefinita quando crei un dominio con AWS CloudFormation. Per un modello di CloudFormation migrazione, consulta [SageMaker Studio Administrator IaC Templates](https://github.com/aws-samples/sagemaker-studio-admin-iac-templates/tree/main?tab=readme-ov-file#phase-1-migration). Per ulteriori informazioni sulla creazione di un dominio utilizzando CloudFormation, consulta [Creazione di un dominio Amazon SageMaker AI utilizzando CloudFormation](https://github.com/aws-samples/cloudformation-studio-domain?tab=readme-ov-file#creating-sagemaker-studio-domains-using-cloudformation).

Per informazioni sulla risorsa di dominio supportata da AWS CloudFormation, consulta [AWS:: SageMaker AI: :Domain](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-domain.html#cfn-sagemaker-domain-defaultusersettings).

Dopo aver eseguito la migrazione della tua esperienza predefinita a Studio, puoi concedere a Studio l’accesso ai bucket Amazon S3. Ad esempio, puoi includere l’accesso al tuo bucket Amazon S3 predefinito di Studio Classic e a bucket Amazon S3 aggiuntivi. A tale scopo, è necessario collegare manualmente una configurazione di [Cross-OriginResource Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) (CORS) ai bucket Amazon S3. Per informazioni su come collegare manualmente la policy CORS ai bucket Amazon S3, consulta [(Facoltativo) Aggiornamento della policy CORS per accedere ai bucket Amazon S3](#studio-updated-migrate-cors).

### (Facoltativo) Aggiornamento della policy CORS per accedere ai bucket Amazon S3
<a name="studio-updated-migrate-cors"></a>

In Studio Classic, gli utenti possono creare, elencare e caricare file nei bucket Amazon Simple Storage Service (Amazon S3). Per supportare la stessa esperienza in Studio, gli amministratori devono collegare una configurazione di [Cross-Origin Resource Sharing](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) (CORS) ai bucket Amazon S3. Ciò è necessario perché Studio effettua chiamate Amazon S3 dal browser Internet. Il browser invoca CORS per conto degli utenti. Di conseguenza, se la policy CORS non è collegata ai bucket Amazon S3, tutte le richieste ai bucket Amazon S3 hanno esito negativo.

Potrebbe essere necessario collegare manualmente la policy CORS ai bucket Amazon S3 per i seguenti motivi.
+ Se esiste già un bucket Amazon S3 predefinito a cui non è collegata la policy CORS corretta durante la migrazione dell’esperienza predefinita del dominio esistente a Studio.
+ Se utilizzi il AWS CLI per migrare l'esperienza predefinita del dominio esistente a Studio. Per informazioni sull'utilizzo di AWS CLI to migrate, consulta. [Imposta Studio come esperienza predefinita per il dominio esistente utilizzando il AWS CLI](#studio-updated-migrate-set-studio-updated-cli)
+ Se desideri collegare la policy CORS a ulteriori bucket Amazon S3.

**Nota**  
Se prevedi di utilizzare la console SageMaker AI per abilitare Studio come esperienza predefinita, i bucket Amazon S3 a cui colleghi la policy CORS verranno sostituite dalle politiche CORS esistenti durante la migrazione. Per questo motivo, puoi ignorare le istruzioni manuali seguenti.  
Tuttavia, se hai già utilizzato la console SageMaker AI per la migrazione e desideri includere altri bucket Amazon S3 a cui allegare la policy CORS, continua con le seguenti istruzioni manuali.

La procedura seguente mostra come aggiungere manualmente una configurazione CORS a un bucket Amazon S3.

**Per aggiungere una configurazione CORS a un bucket Amazon S3**

1. Verifica che esista un bucket Amazon S3 nello Regione AWS stesso dominio esistente con il nome seguente. Per istruzioni, consulta [Viewing the properties for an Amazon S3 bucket](https://docs.aws.amazon.com//AmazonS3/latest/userguide/view-bucket-properties.html). 

   ```
   sagemaker-{{region}}-{{account-id}}
   ```

1. Aggiungi una configurazione CORS con il contenuto seguente al bucket Amazon S3 predefinito. Per istruzioni, consulta [Configuring cross-origin resource sharing (CORS)](https://docs.aws.amazon.com//AmazonS3/latest/userguide/enabling-cors-examples.html).

   ```
   [
       {
           "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"
           ]
       }
   ]
   ```

### (Facoltativo) Esegui la migrazione da Data Wrangler in Studio Classic a Canvas SageMaker
<a name="studio-updated-migrate-dw"></a>

Amazon SageMaker Data Wrangler esiste come funzionalità propria nell'esperienza Studio Classic. Quando abiliti Studio come esperienza predefinita, utilizza l'applicazione [Amazon SageMaker Canvas](https://docs.aws.amazon.com/sagemaker/latest/dg/canvas.html) per accedere alla funzionalità Data Wrangler. SageMaker Canvas è un'applicazione in cui puoi addestrare e distribuire modelli di apprendimento automatico senza scrivere alcun codice e Canvas offre funzionalità di preparazione dei dati basate su Data Wrangler.

La nuova esperienza di Studio non supporta l’interfaccia utente classica di Data Wrangler, quindi devi creare un’applicazione Canvas per continuare a utilizzare Data Wrangler. Tuttavia, devi disporre delle autorizzazioni necessarie per creare e utilizzare le applicazioni Canvas.

Completa i seguenti passaggi per allegare le politiche di autorizzazione necessarie al ruolo IAM del tuo dominio SageMaker AI o al ruolo IAM dell'utente. AWS 

**Per concedere le autorizzazioni per la funzionalità Data Wrangler all’interno di Canvas**

1. Allega la policy AWS gestita [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonSageMakerFullAccess)al ruolo IAM del tuo utente. Per la procedura su come collegare le policy IAM a un ruolo, consulta [Adding IAM identity permissions (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella *Guida per l’utente di AWS IAM*.

   Se questa policy di autorizzazione è troppo permissiva per il tuo caso d’uso, puoi creare policy limitate che includano almeno le autorizzazioni seguenti:

   ```
   {
       "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"
           }
       }
   }
   ```

1. Allega la policy AWS gestita [AmazonSageMakerCanvasDataPrepFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerCanvasDataPrepFullAccess.html)al ruolo IAM del tuo utente.

Dopo aver assegnato le autorizzazioni necessarie, puoi creare un’applicazione Canvas e accedere. Per ulteriori informazioni, consulta [Guida introduttiva all'utilizzo di Amazon SageMaker Canvas](canvas-getting-started.md).

Dopo aver effettuato l’accesso a Canvas, puoi accedere direttamente a Data Wrangler e iniziare a creare flussi di dati. Per ulteriori informazioni, consulta [Preparazione dei dati](canvas-data-prep.md) nella documentazione di Canvas.

### (Facoltativo) Esegui la migrazione da Autopilot in Studio Classic a Canvas SageMaker
<a name="studio-updated-migrate-autopilot"></a>

[Amazon SageMaker Autopilot](https://docs.aws.amazon.com/sagemaker/AWSIronmanApiDoc/integ/npepin-studio-migration-autopilot-to-canvas/latest/dg/autopilot-automate-model-development.html) esiste come funzionalità propria nell'esperienza Studio Classic. Quando esegui la migrazione all'utilizzo dell'esperienza Studio aggiornata, utilizza l'applicazione [Amazon SageMaker Canvas](https://docs.aws.amazon.com/sagemaker/latest/dg/canvas.html) per continuare a utilizzare le stesse funzionalità di apprendimento automatico (AutoML) tramite un'interfaccia utente (UI). SageMaker Canvas è un'applicazione in cui è possibile addestrare e distribuire modelli di machine learning senza scrivere alcun codice e Canvas fornisce un'interfaccia utente per eseguire le attività di AutoML.

La nuova esperienza di Studio non supporta l’interfaccia utente classica di Autopilot. Se desideri continuare a utilizzare le funzionalità AutoML di Autopilot tramite un’interfaccia utente, devi creare un’applicazione Canvas. 

Tuttavia, devi disporre delle autorizzazioni necessarie per creare e utilizzare le applicazioni Canvas.
+ Se accedi a SageMaker Canvas da Studio, aggiungi tali autorizzazioni al ruolo di esecuzione del tuo dominio o profilo utente SageMaker AI.
+ Se accedi a SageMaker Canvas dalla console, aggiungi tali autorizzazioni al ruolo AWS IAM del tuo utente.
+ Se accedi a SageMaker Canvas tramite un [URL predefinito, aggiungi tali autorizzazioni al ruolo IAM che stai utilizzando per l'accesso SSO a Okta](https://docs.aws.amazon.com/sagemaker/latest/dg/setting-up-canvas-sso.html#canvas-optional-access).

Per abilitare le funzionalità AutoML in Canvas, aggiungi le policy seguenti al ruolo di esecuzione o al ruolo utente IAM.
+ AWS [politica gestita:. `CanvasFullAccess`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-canvas.html#security-iam-awsmanpol-AmazonSageMakerCanvasFullAccess) 
+ Policy inline:

  ```
  {
      "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"
          }
      }
  }
  ```

**Per collegare le policy IAM a un ruolo di esecuzione**

1. 

**Trova il ruolo di esecuzione associato al tuo profilo utente SageMaker AI**

   1. Nella console SageMaker AI[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/), vai su **Domini**, quindi scegli il tuo dominio SageMaker AI.

   1. L’ARN del ruolo di esecuzione è elencato in *Ruolo di esecuzione* nella pagina **Dettagli utente** del profilo utente. Prendi nota del nome del ruolo di esecuzione nell’ARN.

   1. Nella console IAM [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/), scegli **Ruoli**.

   1. Cerca il ruolo in base al nome nel campo di ricerca.

   1. Seleziona il ruolo.

1. Aggiungi le policy al ruolo.

   1. Nella console IAM [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/), scegli **Ruoli**.

   1. Cerca il ruolo in base al nome nel campo di ricerca.

   1. Seleziona il ruolo.

   1. Nella scheda **Autorizzazioni**, vai al menu a discesa **Aggiungi autorizzazioni**.

   1. 
      + Per le policy gestite: seleziona **Collega policy** e cerca il nome della policy gestita da collegare.

        Seleziona la policy, quindi scegli **Aggiungi autorizzazioni**.
      + Per le policy inline: seleziona **Crea policy inline**, incolla la policy nella scheda JSON, scegli Avanti, assegna un nome alla policy e scegli **Crea**.

Per la procedura su come collegare le policy IAM a un ruolo, consulta [Adding IAM identity permissions (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella *Guida per l’utente di AWS IAM*.

Dopo aver assegnato le autorizzazioni necessarie, puoi creare un’applicazione Canvas e accedere. Per ulteriori informazioni, consulta [Guida introduttiva all'utilizzo di Amazon SageMaker Canvas](canvas-getting-started.md).

## Impostazione di Studio Classic come esperienza predefinita
<a name="studio-updated-migrate-revert"></a>

Gli amministratori possono reimpostare Studio Classic come esperienza predefinita per un dominio esistente. Questa operazione può essere eseguita tramite la AWS CLI.

**Nota**  
Quando è impostato come esperienza predefinita a livello di dominio, Studio Classic è l’esperienza predefinita per tutti gli utenti del dominio. Tuttavia, le impostazioni a livello di utente hanno la precedenza sulle impostazioni a livello di dominio. Quindi, se un utente ha impostato l’esperienza predefinita su Studio, avrà Studio come esperienza predefinita. 

Per tornare a Studio Classic come esperienza predefinita per il dominio esistente utilizzando la AWS CLI, usa la chiamata [update-domain](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker/update-domain.html). Nel campo `default-user-settings`, imposta:
+ Il valore `StudioWebPortal` su `DISABLED`.
+ Il valore `DefaultLandingUri` su `app:JupyterServer:`.

`StudioWebPortal` indica se Studio è l’esperienza predefinita e `DefaultLandingUri` indica l’esperienza predefinita alla quale viene indirizzato l’utente quando accede al dominio. In questo esempio, l’impostazione di questi valori a livello di dominio (in `default-user-settings`) rende Studio Classic l’esperienza predefinita per gli utenti all’interno del dominio.

Se un utente all’interno del dominio ha impostato `StudioWebPortal` su `ENABLED` e `DefaultLandingUri` su `studio::` a livello utente (in `UserSettings`), queste impostazioni hanno la precedenza rispetto a quelle a livello di dominio. In altre parole, l’utente avrà Studio come esperienza predefinita, indipendentemente dalle impostazioni a livello di dominio. 

Nell’esempio di codice seguente viene illustrato come impostare Studio Classic come esperienza predefinita per gli utenti all’interno del dominio:

```
aws sagemaker update-domain \
--domain-id {{existing-domain-id}} \
--region {{Regione AWS}} \
--default-user-settings '
{
    "StudioWebPortal": "DISABLED",
    "DefaultLandingUri": "app:JupyterServer:"
}
'
```

Utilizza le istruzioni seguenti per ottenere `{{existing-domain-id}}`.

1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

1. Nel riquadro di navigazione a sinistra, espandi **Configurazioni di amministrazione** e scegli **Domini**. 

1. Scegli il dominio esistente.

1. Dalla pagina **Dettagli dominio**, seleziona la scheda **Impostazioni dominio**.

1. Copia l’**ID dominio**.

Per ottenere il tuo`{{Regione AWS}}`, usa le seguenti istruzioni per assicurarti di utilizzare quello corretto Regione AWS per il tuo dominio.

1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

1. Nel riquadro di navigazione a sinistra, espandi **Configurazioni di amministrazione** e scegli **Domini**. 

1. Scegli il dominio esistente.

1. Nella pagina **Dettagli del dominio**, verifica che si tratti del dominio esistente.

1. Espandi l'elenco a Regione AWS discesa in alto a destra della console SageMaker AI e utilizza l' Regione AWS ID corrispondente a destra del tuo Regione AWS nome. Ad esempio, `us-west-1`.