Migre manualmente todos os seus dados do Studio Classic Migre fluxos de dados do Data Wrangler

(Opcional) Migrar dados do Studio Classic para o Studio

O Studio Classic e o Studio usam dois tipos diferentes de volumes de armazenamento. O Studio Classic usa um único volume do Amazon Elastic File System (AmazonEFS) para armazenar dados de todos os usuários e espaços compartilhados no domínio. No Studio, cada espaço tem seu próprio volume da Amazon Elastic Block Store (AmazonEBS). Quando você atualiza a experiência padrão de um domínio existente, monta SageMaker automaticamente uma pasta em um EFS volume da Amazon para cada usuário em um domínio. Como resultado, os usuários podem acessar arquivos do Studio Classic em seus aplicativos do Studio. Para obter mais informações, consulte EFSMontagem automática da Amazon no Studio.

Você também pode desativar a EFS montagem automática da Amazon e migrar manualmente os dados para dar aos usuários acesso aos arquivos do Studio Classic nos aplicativos do Studio. Para fazer isso, você deve transferir os arquivos dos diretórios pessoais do usuário para os EBS volumes da Amazon associados a esses espaços. A seção a seguir fornece informações sobre esse fluxo de trabalho. Para obter mais informações sobre como desativar a EFS montagem automática da Amazon, consulte. Desative a montagem EFS automática da Amazon

Migre manualmente todos os seus dados do Studio Classic

A seção a seguir descreve como migrar todos os dados do volume de armazenamento do Studio Classic para a nova experiência do Studio.

Ao migrar manualmente os dados, o código e os artefatos de um usuário do Studio Classic para o Studio, recomendamos uma das seguintes abordagens:

Usando um EFS volume personalizado da Amazon
Usando o Amazon Simple Storage Service (Amazon S3)

Se você usou o Amazon SageMaker Data Wrangler no Studio Classic e quiser migrar seus arquivos de fluxo de dados, escolha uma das seguintes opções para migração:

Se você quiser migrar todos os dados do seu volume de armazenamento do Studio Classic, incluindo seus arquivos de fluxo de dados, acesse Migre manualmente todos os seus dados do Studio Classic e conclua a seção Use o Amazon S3 para migrar dados. Em seguida, vá para a Importe os arquivos de fluxo para o Canvas seção.
Se você quiser migrar apenas seus arquivos de fluxo de dados e nenhum outro dado do seu volume de armazenamento do Studio Classic, vá para a Migre fluxos de dados do Data Wrangler seção.

Pré-requisitos

Antes de executar essas etapas, preencha os pré-requisitos em. Pré-requisitos completos para migrar a experiência do Studio Você também deve concluir as etapas emMigrar a interface do usuário do Studio Classic para o Studio.

Escolhendo uma abordagem

Considere o seguinte ao escolher uma abordagem para migrar seus dados do Studio Classic.

Prós e contras de usar um EFS volume personalizado da Amazon

Nessa abordagem, você usa uma EFS-to-Amazon EFS AWS DataSync tarefa da Amazon (uma vez ou cadência) para copiar dados e, em seguida, montar o EFS volume de destino da Amazon nos espaços de um usuário. Isso dá aos usuários acesso aos dados do Studio Classic em seus ambientes de computação do Studio.

Prós:

Somente os dados do diretório inicial do usuário são visíveis nos espaços do usuário. Não há polinização cruzada de dados.
Sincronizar do volume de origem da Amazon com um EFS volume alvo da Amazon EFS é mais seguro do que montar diretamente o EFS volume de origem da Amazon gerenciado por SageMaker em espaços. Isso evita o potencial de impactar os arquivos do usuário do diretório inicial.
Os usuários têm a flexibilidade de continuar trabalhando nos aplicativos Studio Classic e Studio, ao mesmo tempo em que têm seus dados disponíveis em ambos os aplicativos, AWS DataSync se estiverem configurados em um ritmo regular.
Não há necessidade de empurrar e puxar repetidamente com o Amazon S3.

Contras:

Sem acesso de gravação ao EFS volume de destino da Amazon montado nos espaços do usuário. Para obter acesso de gravação ao EFS volume de destino da Amazon, os clientes precisariam montar o EFS volume alvo da Amazon em uma instância do Amazon Elastic Compute Cloud e fornecer as permissões apropriadas para que os usuários gravem no EFS prefixo da Amazon.
Requer modificação nos grupos de segurança gerenciados pelo SageMaker para permitir o fluxo de entrada e saída do sistema de arquivos de rede (NFS).
Custa mais do que usar o Amazon S3.
Ao migrar fluxos de dados do Data Wrangler no Studio Classic, você deve seguir as etapas para exportar manualmente os arquivos de fluxo.

Prós e contras de usar o Amazon S3

Nessa abordagem, você usa uma AWS DataSync tarefa do Amazon EFS-to-Amazon S3 (uma vez ou cadência) para copiar dados e, em seguida, cria uma configuração de ciclo de vida para copiar os dados do usuário do Amazon S3 para o volume Amazon de seu espaço privado. EBS

Prós:

Se o LCC estiver anexado ao domínio, os usuários poderão optar por usar o LCC para copiar dados para seu espaço ou executar o espaço sem LCC script. Isso dá aos usuários a opção de copiar seus arquivos somente nos espaços de que precisam.
Se uma AWS DataSync tarefa for configurada em uma cadência, os usuários poderão reiniciar o aplicativo Studio para obter os arquivos mais recentes.
Como os dados são copiados para a AmazonEBS, os usuários têm permissões de gravação nos arquivos.
O armazenamento Amazon S3 é mais barato que o Amazon. EFS
Se estiver migrando fluxos de dados do Data Wrangler no Studio Classic, você pode pular as etapas de exportação manual e importar diretamente os fluxos de dados do SageMaker Amazon S3 para o Canvas.

Contras:

Se os administradores precisarem evitar a polinização cruzada, eles devem criar AWS Identity and Access Management políticas no nível do usuário para garantir que os usuários só possam acessar o prefixo do Amazon S3 que contém seus arquivos.

Nessa abordagem, você usa uma Amazon EFS-to-Amazon EFS AWS DataSync para copiar o conteúdo de um volume Studio Classic da Amazon para um EFS volume alvo da Amazon EFS uma vez ou em uma cadência regular e, em seguida, monta o EFS volume da Amazon de destino nos espaços de um usuário. Isso dá aos usuários acesso aos dados do Studio Classic em seus ambientes de computação do Studio.

Crie um EFS volume alvo da Amazon. Você transferirá dados para esse EFS volume da Amazon e o montará no espaço de um usuário correspondente usando a montagem em nível de prefixo.


export SOURCE_DOMAIN_ID="domain-id"
export REGION="region"

export TARGET_EFS=$(aws efs create-file-system --performance-mode generalPurpose --throughput-mode bursting --encrypted --region $REGION | jq -r '.FileSystemId')

echo "Target EFS volume Created: $TARGET_EFS"

Adicione variáveis para o EFS volume de origem da Amazon atualmente anexado ao domínio e usado por todos os usuários. As informações da Amazon Virtual Private Cloud do domínio são necessárias para garantir que a Amazon de destino EFS seja criada na mesma Amazon VPC e sub-rede, com a mesma configuração de grupo de segurança.
```
export SOURCE_EFS=$(aws sagemaker describe-domain --domain-id $SOURCE_DOMAIN_ID | jq -r '.HomeEfsFileSystemId')
export VPC_ID=$(aws sagemaker describe-domain --domain-id $SOURCE_DOMAIN_ID | jq -r '.VpcId')

echo "EFS managed by SageMaker: $SOURCE_EFS | VPC: $VPC_ID"
```

Crie um destino de EFS montagem da Amazon na mesma Amazon VPC e sub-rede do EFS volume de origem da Amazon, com a mesma configuração de grupo de segurança. O alvo de montagem leva alguns minutos para ficar disponível.


export EFS_VPC_ID=$(aws efs describe-mount-targets --file-system-id $SOURCE_EFS | jq -r ".MountTargets[0].VpcId")
export EFS_AZ_NAME=$(aws efs describe-mount-targets --file-system-id $SOURCE_EFS | jq -r ".MountTargets[0].AvailabilityZoneName")
export EFS_AZ_ID=$(aws efs describe-mount-targets --file-system-id $SOURCE_EFS | jq -r ".MountTargets[0].AvailabilityZoneId")
export EFS_SUBNET_ID=$(aws efs describe-mount-targets --file-system-id $SOURCE_EFS | jq -r ".MountTargets[0].SubnetId")
export EFS_MOUNT_TARG_ID=$(aws efs describe-mount-targets --file-system-id $SOURCE_EFS | jq -r ".MountTargets[0].MountTargetId")
export EFS_SG_IDS=$(aws efs describe-mount-target-security-groups --mount-target-id $EFS_MOUNT_TARG_ID | jq -r '.SecurityGroups[]')

aws efs create-mount-target \
--file-system-id $TARGET_EFS \
--subnet-id $EFS_SUBNET_ID \
--security-groups $EFS_SG_IDS

Crie locais EFS de origem e destino da Amazon para a AWS DataSync tarefa.


export SOURCE_EFS_ARN=$(aws efs describe-file-systems --file-system-id $SOURCE_EFS | jq -r ".FileSystems[0].FileSystemArn")
export TARGET_EFS_ARN=$(aws efs describe-file-systems --file-system-id $TARGET_EFS | jq -r ".FileSystems[0].FileSystemArn")
export EFS_SUBNET_ID_ARN=$(aws ec2 describe-subnets --subnet-ids $EFS_SUBNET_ID | jq -r ".Subnets[0].SubnetArn")
export ACCOUNT_ID=$(aws ec2 describe-security-groups --group-id $EFS_SG_IDS | jq -r ".SecurityGroups[0].OwnerId")
export EFS_SG_ID_ARN=arn:aws:ec2:$REGION:$ACCOUNT_ID:security-group/$EFS_SG_IDS

export SOURCE_LOCATION_ARN=$(aws datasync create-location-efs --subdirectory "/" --efs-filesystem-arn $SOURCE_EFS_ARN --ec2-config SubnetArn=$EFS_SUBNET_ID_ARN,SecurityGroupArns=$EFS_SG_ID_ARN --region $REGION | jq -r ".LocationArn")
export DESTINATION_LOCATION_ARN=$(aws datasync create-location-efs --subdirectory "/" --efs-filesystem-arn $TARGET_EFS_ARN --ec2-config SubnetArn=$EFS_SUBNET_ID_ARN,SecurityGroupArns=$EFS_SG_ID_ARN --region $REGION | jq -r ".LocationArn")

Permita o tráfego entre as montagens do sistema de arquivos de rede de origem e de destino (NFS). Quando um novo domínio é criado, SageMaker cria dois grupos de segurança.
- NFSgrupo de segurança de entrada com somente tráfego de entrada.
- NFSgrupo de segurança de saída com somente tráfego de saída.
A origem e o destino NFS são colocados dentro dos mesmos grupos de segurança. Você pode permitir o tráfego entre esses suportes a partir do AWS Management Console ou AWS CLI.
- Permitir tráfego a partir do AWS Management Console
  1. Faça login no AWS Management Console e abra o VPC console da Amazon em https://console.aws.amazon.com/vpc/.
  2. Escolha Grupos de segurança.
  3. Pesquise o ID do domínio existente na página Grupos de Segurança.
    
    d-xxxxxxx
    
    Os resultados devem retornar dois grupos de segurança que incluam o ID do domínio no nome.
    
    security-group-for-inbound-nfs-domain-id
    
    security-group-for-outbound-nfs-domain-id
  4. Selecione a ID do grupo de segurança de entrada. Isso abre uma nova página com detalhes sobre o grupo de segurança.
  5. Selecione a guia Regras de saída.
  6. Selecione Editar regras de saída.
  7. Atualize as regras de saída existentes ou adicione uma nova regra de saída com os seguintes valores:
    
    Tipo: NFS
    
    Protocolo: TCP
    
    Intervalo de portas: 2049
    
    Destino: security-group-for-outbound -nfs-domain-id | security-group-id
  8. Escolha Salvar regras.
  9. Selecione a guia Regras de entrada.
  10. Selecione Editar regras de entrada.
  11. Atualize as regras de entrada existentes ou adicione uma nova regra de saída com os seguintes valores:
    
    Tipo: NFS
    
    Protocolo: TCP
    
    Intervalo de portas: 2049
    
    Destino: security-group-for-outbound -nfs-domain-id | security-group-id
  12. Escolha Salvar regras.
- Permitir tráfego a partir do AWS CLI
  1. Atualize as regras de entrada e saída do grupo de segurança com os seguintes valores:
    
    Protocolo: TCP
    
    Intervalo de portas: 2049
    
    ID do grupo: ID do grupo de segurança de entrada ou ID do grupo de segurança de saída
    
    export INBOUND_SG_ID=$(aws ec2 describe-security-groups --filters "Name=group-name,Values=security-group-for-inbound-nfs-$SOURCE_DOMAIN_ID" | jq -r ".SecurityGroups[0].GroupId") export OUTBOUND_SG_ID=$(aws ec2 describe-security-groups --filters "Name=group-name,Values=security-group-for-outbound-nfs-$SOURCE_DOMAIN_ID" | jq -r ".SecurityGroups[0].GroupId") echo "Outbound SG ID: $OUTBOUND_SG_ID | Inbound SG ID: $INBOUND_SG_ID" aws ec2 authorize-security-group-egress \ --group-id $INBOUND_SG_ID \ --protocol tcp --port 2049 \ --source-group $OUTBOUND_SG_ID aws ec2 authorize-security-group-ingress \ --group-id $OUTBOUND_SG_ID \ --protocol tcp --port 2049 \ --source-group $INBOUND_SG_ID
  2. Adicione os grupos de segurança de entrada e saída aos alvos de EFS montagem de origem e de destino da Amazon. Isso permite o tráfego entre as duas EFS montagens da Amazon.
    
    export SOURCE_EFS_MOUNT_TARGET=$(aws efs describe-mount-targets --file-system-id $SOURCE_EFS | jq -r ".MountTargets[0].MountTargetId") export TARGET_EFS_MOUNT_TARGET=$(aws efs describe-mount-targets --file-system-id $TARGET_EFS | jq -r ".MountTargets[0].MountTargetId") aws efs modify-mount-target-security-groups \ --mount-target-id $SOURCE_EFS_MOUNT_TARGET \ --security-groups $INBOUND_SG_ID $OUTBOUND_SG_ID aws efs modify-mount-target-security-groups \ --mount-target-id $TARGET_EFS_MOUNT_TARGET \ --security-groups $INBOUND_SG_ID $OUTBOUND_SG_ID

Crie uma AWS DataSync tarefa. Isso retorna uma tarefa ARN que pode ser usada para executar a tarefa sob demanda ou como parte de uma cadência regular.


export EXTRA_XFER_OPTIONS='VerifyMode=ONLY_FILES_TRANSFERRED,OverwriteMode=ALWAYS,Atime=NONE,Mtime=NONE,Uid=NONE,Gid=NONE,PreserveDeletedFiles=REMOVE,PreserveDevices=NONE,PosixPermissions=NONE,TaskQueueing=ENABLED,TransferMode=CHANGED,SecurityDescriptorCopyFlags=NONE,ObjectTags=NONE'
export DATASYNC_TASK_ARN=$(aws datasync create-task --source-location-arn $SOURCE_LOCATION_ARN --destination-location-arn $DESTINATION_LOCATION_ARN --name "SMEFS_to_CustomEFS_Sync" --region $REGION --options $EXTRA_XFER_OPTIONS | jq -r ".TaskArn")

Inicie uma AWS DataSync tarefa para copiar automaticamente os dados da Amazon de origem EFS para a EFS montagem da Amazon de destino. Isso não retém as POSIX permissões do arquivo, o que permite que os usuários leiam do EFS suporte de destino da Amazon, mas não gravem nele.
```
aws datasync start-task-execution --task-arn $DATASYNC_TASK_ARN
```

Monte o EFS volume de destino da Amazon no domínio no nível raiz.


aws sagemaker update-domain --domain-id $SOURCE_DOMAIN_ID \
--default-user-settings '{"CustomFileSystemConfigs": [{"EFSFileSystemConfig": {"FileSystemId": "'"$TARGET_EFS"'", "FileSystemPath": "/"}}]}'

Substitua cada perfil de usuário por um FileSystemPath prefixo. O prefixo inclui o do usuárioUID, que é criado por SageMaker. Isso garante que os usuários tenham acesso apenas aos seus dados e evita a polinização cruzada. Quando um espaço é criado no domínio e o EFS volume de destino da Amazon é montado no aplicativo, o prefixo do usuário substitui o prefixo do domínio. Como resultado, monta SageMaker somente o /user-id diretório no aplicativo do usuário.


aws sagemaker list-user-profiles --domain-id $SOURCE_DOMAIN_ID | jq -r '.UserProfiles[] | "\(.UserProfileName)"' | while read user; do
export uid=$(aws sagemaker describe-user-profile --domain-id $SOURCE_DOMAIN_ID --user-profile-name $user | jq -r ".HomeEfsFileSystemUid")
echo "$user $uid"
aws sagemaker update-user-profile --domain-id $SOURCE_DOMAIN_ID --user-profile-name $user --user-settings '{"CustomFileSystemConfigs": [{"EFSFileSystemConfig":{"FileSystemId": "'"$TARGET_EFS"'", "FileSystemPath": "'"/$uid/"'"}}]}'
done

Os usuários podem então selecionar o EFS sistema de arquivos personalizado da Amazon ao iniciar um aplicativo. Para obter mais informações, consulte JupyterLab guia do usuário ou Inicie um aplicativo de editor de código no Studio.

Nessa abordagem, você usa uma AWS DataSync tarefa do Amazon EFS-to-Amazon S3 para copiar o conteúdo de um EFS volume do Studio Classic Amazon para um bucket do Amazon S3 uma vez ou em um ritmo regular e, em seguida, cria uma configuração de ciclo de vida para copiar os dados do usuário do Amazon S3 para o volume Amazon do seu espaço privado. EBS

nota

Essa abordagem só funciona para domínios que têm acesso à Internet.

Defina o ID de EFS volume da Amazon de origem do domínio que contém os dados que você está migrando.


timestamp=$(date +%Y%m%d%H%M%S)
export SOURCE_DOMAIN_ID="domain-id"
export REGION="region"
export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export EFS_ID=$(aws sagemaker describe-domain --domain-id $SOURCE_DOMAIN_ID | jq -r '.HomeEfsFileSystemId')

Defina o nome do bucket do Amazon S3 de destino. Para obter informações sobre a criação de um bucket do Amazon S3, consulte Criação de um bucket. O bucket usado deve ter uma CORS política conforme descrito em(Opcional) Atualize sua CORS política para acessar os buckets do Amazon S3. Os usuários no domínio também devem ter permissões para acessar o bucket do Amazon S3.

Neste exemplo, estamos copiando arquivos para um prefixo chamadostudio-new. Se você estiver usando um único bucket do Amazon S3 para migrar vários domínios, use o studio-new/<domain-id> prefixo para restringir as permissões aos arquivos que estão usando. IAM
```
export BUCKET_NAME=s3-bucket-name
export S3_DESTINATION_PATH=studio-new
```

Crie uma política de confiança que dê AWS DataSync permissões para assumir a função de execução da sua conta.


export TRUST_POLICY=$(cat <<EOF
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "datasync.amazonaws.com"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "$ACCOUNT_ID"
                },
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:datasync:$REGION:$ACCOUNT_ID:*"
                }
            }
        }
    ]
}
EOF
)

Crie uma IAM função e anexe a política de confiança.


export timestamp=$(date +%Y%m%d%H%M%S)
export ROLE_NAME="DataSyncS3Role-$timestamp"

aws iam create-role --role-name $ROLE_NAME --assume-role-policy-document "$TRUST_POLICY"
aws iam attach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
echo "Attached IAM Policy AmazonS3FullAccess"
aws iam attach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
echo "Attached IAM Policy AmazonSageMakerFullAccess"
export ROLE_ARN=$(aws iam get-role --role-name $ROLE_NAME --query 'Role.Arn' --output text)
echo "Created IAM Role $ROLE_ARN"

Crie um grupo de segurança para dar acesso à EFS localização da Amazon.


export EFS_ARN=$(aws efs describe-file-systems --file-system-id $EFS_ID | jq -r '.FileSystems[0].FileSystemArn' )
export EFS_SUBNET_ID=$(aws efs describe-mount-targets --file-system-id $EFS_ID | jq -r '.MountTargets[0].SubnetId')
export EFS_VPC_ID=$(aws efs describe-mount-targets --file-system-id $EFS_ID | jq -r '.MountTargets[0].VpcId')
export MOUNT_TARGET_ID=$(aws efs describe-mount-targets --file-system-id $EFS_ID | jq -r '.MountTargets[0].MountTargetId ')
export EFS_SECURITY_GROUP_ID=$(aws efs describe-mount-target-security-groups --mount-target-id $MOUNT_TARGET_ID | jq -r '.SecurityGroups[0]')
export EFS_SUBNET_ARN=$(aws ec2 describe-subnets --subnet-ids $EFS_SUBNET_ID | jq -r '.Subnets[0].SubnetArn')
echo "Subnet ID: $EFS_SUBNET_ID"
echo "Security Group ID: $EFS_SECURITY_GROUP_ID"
echo "Subnet ARN: $EFS_SUBNET_ARN"

timestamp=$(date +%Y%m%d%H%M%S)
sg_name="datasync-sg-$timestamp"
export DATASYNC_SG_ID=$(aws ec2 create-security-group --vpc-id $EFS_VPC_ID --group-name $sg_name --description "DataSync SG" --output text --query 'GroupId')
aws ec2 authorize-security-group-egress --group-id $DATASYNC_SG_ID --protocol tcp --port 2049 --source-group $EFS_SECURITY_GROUP_ID
aws ec2 authorize-security-group-ingress --group-id $EFS_SECURITY_GROUP_ID --protocol tcp --port 2049 --source-group $DATASYNC_SG_ID
export DATASYNC_SG_ARN="arn:aws:ec2:$REGION:$ACCOUNT_ID:security-group/$DATASYNC_SG_ID"
echo "Security Group ARN: $DATASYNC_SG_ARN"

Crie um EFS local de origem na Amazon para a AWS DataSync tarefa.


export SOURCE_ARN=$(aws datasync create-location-efs --efs-filesystem-arn $EFS_ARN --ec2-config "{\"SubnetArn\": \"$EFS_SUBNET_ARN\", \"SecurityGroupArns\": [\"$DATASYNC_SG_ARN\"]}" | jq -r '.LocationArn')
echo "Source Location ARN: $SOURCE_ARN"

Crie um local de destino do Amazon S3 para a AWS DataSync tarefa.


export BUCKET_ARN="arn:aws:s3:::$BUCKET_NAME"
export DESTINATION_ARN=$(aws datasync create-location-s3 --s3-bucket-arn $BUCKET_ARN --s3-config "{\"BucketAccessRoleArn\": \"$ROLE_ARN\"}" --subdirectory $S3_DESTINATION_PATH | jq -r '.LocationArn')
echo "Destination Location ARN: $DESTINATION_ARN"

Crie uma AWS DataSync tarefa.


export TASK_ARN=$(aws datasync create-task --source-location-arn $SOURCE_ARN --destination-location-arn $DESTINATION_ARN | jq -r '.TaskArn')
echo "DataSync Task: $TASK_ARN"

Inicie a AWS DataSync tarefa. Essa tarefa copia automaticamente os dados do EFS volume de origem da Amazon para o bucket Amazon S3 de destino. Aguarde até que a tarefa seja concluída.
```
aws datasync start-task-execution --task-arn $TASK_ARN
```

Verifique o status da AWS DataSync tarefa para verificar se ela foi concluída. Passe o ARN devolvido na etapa anterior.


export TASK_EXEC_ARN=datasync-task-arn
echo "Task execution ARN: $TASK_EXEC_ARN"
export STATUS=$(aws datasync describe-task-execution --task-execution-arn $TASK_EXEC_ARN | jq -r '.Status')
echo "Execution status: $STATUS"
while [ "$STATUS" = "QUEUED" ] || [ "$STATUS" = "LAUNCHING" ] || [ "$STATUS" = "PREPARING" ] || [ "$STATUS" = "TRANSFERRING" ] || [ "$STATUS" = "VERIFYING" ]; do
    STATUS=$(aws datasync describe-task-execution --task-execution-arn $TASK_EXEC_ARN | jq -r '.Status')
    if [ $? -ne 0 ]; then
        echo "Error Running DataSync Task"
        exit 1
    fi
    echo "Execution status: $STATUS"
    sleep 30
done

Depois que a AWS DataSync tarefa for concluída, limpe os recursos criados anteriormente.


aws datasync delete-task --task-arn $TASK_ARN
echo "Deleted task $TASK_ARN"
aws datasync delete-location --location-arn $SOURCE_ARN
echo "Deleted location source $SOURCE_ARN"
aws datasync delete-location --location-arn $DESTINATION_ARN
echo "Deleted location source $DESTINATION_ARN"
aws iam detach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
aws iam detach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
aws iam delete-role --role-name $ROLE_NAME
echo "Deleted IAM Role $ROLE_NAME"
echo "Wait 5 minutes for the elastic network interface to detach..."
start_time=$(date +%s)
while [[ $(($(date +%s) - start_time)) -lt 300 ]]; do
    sleep 1
done
aws ec2 revoke-security-group-ingress --group-id $EFS_SECURITY_GROUP_ID --protocol tcp --port 2049 --source-group $DATASYNC_SG_ID
echo "Revoked Ingress from $EFS_SECURITY_GROUP_ID"
aws ec2 revoke-security-group-egress --group-id $DATASYNC_SG_ID --protocol tcp --port 2049 --source-group $EFS_SECURITY_GROUP_ID
echo "Revoked Egress from $DATASYNC_SG_ID"
aws ec2 delete-security-group --group-id $DATASYNC_SG_ID
echo "Deleted DataSync SG $DATASYNC_SG_ID"

De sua máquina local, crie um arquivo denominado on-start.sh com o conteúdo a seguir. Esse script copia o diretório EFS inicial da Amazon do usuário no Amazon S3 para o EBS volume Amazon do usuário no Studio e cria um prefixo para cada perfil de usuário.


#!/bin/bash
set -eo pipefail

sudo apt-get install -y jq

# Studio Variables
DOMAIN_ID=$(cat /opt/ml/metadata/resource-metadata.json | jq -r '.DomainId')
SPACE_NAME=$(cat /opt/ml/metadata/resource-metadata.json | jq -r '.SpaceName')
USER_PROFILE_NAME=$(aws sagemaker describe-space --domain-id=$DOMAIN_ID --space-name=$SPACE_NAME | jq -r '.OwnershipSettings.OwnerUserProfileName')

# S3 bucket to copy from
BUCKET=s3-bucket-name
# Subfolder in bucket to copy
PREFIX=studio-new

# Getting HomeEfsFileSystemUid for the current user-profile
EFS_FOLDER_ID=$(aws sagemaker describe-user-profile --domain-id $DOMAIN_ID --user-profile-name $USER_PROFILE_NAME | jq -r '.HomeEfsFileSystemUid')

# Local destination directory
DEST=./studio-classic-efs-backup
mkdir -p $DEST

echo "Bucket: s3://$BUCKET/$PREFIX/$EFS_FOLDER_ID/"
echo "Destination $DEST/"
echo "Excluding .*"
echo "Excluding .*/*"

aws s3 cp s3://$BUCKET/$PREFIX/$EFS_FOLDER_ID/ $DEST/ \
    --exclude ".*" \
    --exclude "**/.*" \
    --recursive

Converta seu script no formato base64. Esse requisito evita erros que ocorram devido à codificação de espaçamento e quebra de linha. O tipo de script pode ser JupyterLab ouCodeEditor.
```
export LCC_SCRIPT_NAME='studio-classic-sync'
export SCRIPT_FILE_NAME='on-start.sh'
export SCRIPT_TYPE='JupyterLab-or-CodeEditor'
LCC_CONTENT=`openssl base64 -A -in ${SCRIPT_FILE_NAME}`
```
Verifique o seguinte antes de usar o script:
- O EBS volume da Amazon é grande o suficiente para armazenar os objetos que você está exportando.
- Você não está migrando arquivos e pastas ocultos, como .bashrc e .condarc se não tiver a intenção de fazer isso.
- A função de execução AWS Identity and Access Management (IAM) associada aos perfis de usuário do Studio tem as políticas configuradas para acessar somente o respectivo diretório inicial no Amazon S3.

Crie uma configuração de ciclo de vida usando seu script.


aws sagemaker create-studio-lifecycle-config \
    --studio-lifecycle-config-name $LCC_SCRIPT_NAME \
    --studio-lifecycle-config-content $LCC_CONTENT \
    --studio-lifecycle-config-app-type $SCRIPT_TYPE

Anexe o LCC ao seu domínio.


aws sagemaker update-domain \
    --domain-id $SOURCE_DOMAIN_ID \
    --default-user-settings '
        {"JupyterLabAppSettings":
            {"LifecycleConfigArns":
                [
                    "lifecycle-config-arn"
                ]
            }
        }'

Em seguida, os usuários podem selecionar o LCC script ao iniciar um aplicativo. Para obter mais informações, consulte JupyterLab guia do usuário ou Inicie um aplicativo de editor de código no Studio. Isso sincroniza automaticamente os arquivos do Amazon S3 com o armazenamento da EBS Amazon para o espaço do usuário.

Migre fluxos de dados do Data Wrangler

Se você já usou o Amazon SageMaker Data Wrangler no Amazon SageMaker Studio Classic para tarefas de preparação de dados, você pode migrar para o novo Amazon SageMaker Studio e acessar a versão mais recente do Data Wrangler no Amazon Canvas. SageMaker O Data Wrangler in SageMaker Canvas oferece uma experiência de usuário aprimorada e acesso aos recursos mais recentes, como uma interface de linguagem natural e desempenho mais rápido.

Você pode se conectar ao SageMaker Canvas a qualquer momento para começar a usar a nova experiência do Data Wrangler. Para obter mais informações, consulte Começando a usar o Amazon SageMaker Canvas.

Se você tiver arquivos de fluxo de dados salvos no Studio Classic nos quais estava trabalhando anteriormente, você pode integrá-los ao Studio e depois importar os arquivos de fluxo para o Canvas. Você tem as seguintes opções de migração:

Migração com um clique: Ao entrar no Canvas, você pode usar uma opção de importação única que migra todos os seus arquivos de fluxo em seu nome.
Migração manual: Você pode importar manualmente seus arquivos de fluxo para o Canvas. No Studio Classic, exporte os arquivos para o Amazon S3 ou baixe-os para sua máquina local. Em seguida, você entra no aplicativo SageMaker Canvas, importa os arquivos de fluxo e continua suas tarefas de preparação de dados.

O guia a seguir descreve os pré-requisitos para a migração e como migrar seus arquivos de fluxo de dados usando a opção de um clique ou manual.

Pré-requisitos

Analise os pré-requisitos a seguir antes de começar a migrar seus arquivos de fluxo.

Etapa 1. Migre o domínio e conceda permissões

Antes de migrar arquivos de fluxo de dados, você precisa seguir etapas específicas do Migração do Amazon SageMaker Studio Classic guia para garantir que a função de AWS IAM execução do seu perfil de usuário tenha as permissões necessárias. Siga os pré-requisitos e, Migrar a interface do usuário do Studio Classic para o Studio antes de continuar, que descrevem como conceder as permissões necessárias, configure o Studio como a nova experiência e migre seu domínio existente.

Especificamente, você deve ter permissões para criar um aplicativo SageMaker Canvas e usar os recursos de preparação de dados do SageMaker Canvas. Para obter essas permissões, você pode:

Adicione a AmazonSageMakerCanvasDataPrepFullAccesspolítica à sua IAM função ou
Anexe uma política de permissões mínimas, conforme mostrado na seção (opcional) Migrar do Data Wrangler no Studio Classic para SageMaker o Canvas da página. Migrar a interface do usuário do Studio Classic para o Studio

Certifique-se de usar o mesmo perfil de usuário para o Studio e o SageMaker Canvas.

Depois de concluir os pré-requisitos descritos no guia de migração, você deve ter um novo domínio com as permissões necessárias para acessar SageMaker o Canvas por meio do Studio.

Etapa 2. (Opcional) Prepare um local do Amazon S3

Se você estiver fazendo uma migração manual e planeja usar o Amazon S3 para transferir seus arquivos de fluxo em vez de usar a opção de download local, você deve ter um bucket do Amazon S3 em sua conta que gostaria de usar para armazenar os arquivos de fluxo.

Método de migração com um clique

SageMaker O Canvas oferece uma opção de importação única para migrar seus fluxos de dados do Data Wrangler no Studio Classic para o Data Wrangler no Canvas. SageMaker Desde que seus aplicativos Studio Classic e Canvas compartilhem o mesmo volume EFS de armazenamento da Amazon, você pode migrar do Canvas com um clique. Esse processo simplificado elimina a necessidade de etapas manuais de exportação e importação, e você pode importar todos os seus fluxos de uma só vez.

Use o procedimento a seguir para migrar todos os seus arquivos de fluxo:

Abra sua versão mais recente do Studio.
No Studio, no painel de navegação esquerdo, escolha o menu suspenso Dados.
Nas opções de navegação, escolha Data Wrangler.
Na página Data Wrangler, escolha Executar no Canvas. Se você configurou com sucesso as permissões, isso cria um aplicativo Canvas para você. O aplicativo Canvas pode levar alguns minutos até ficar pronto.
Quando o Canvas estiver pronto, escolha Abrir no Canvas.
O Canvas abre a página do Data Wrangler e aparece um banner na parte superior da página que diz Importar seus fluxos de dados do Data Wrangler no Studio Classic para o Canvas. É uma importação única. Saiba mais. No banner, escolha Importar tudo.

Atenção
Se você fechar a notificação do banner, não poderá mais reabri-la nem usar o método de migração com um clique.

Uma notificação pop-up aparece, indicando que o Canvas está importando seus arquivos de fluxo do Studio Classic. Se a importação for totalmente bem-sucedida, você receberá outra notificação de que o X número de arquivos de fluxo foi importado e poderá ver seus arquivos de fluxo na página Data Wrangler do aplicativo Canvas. Todos os arquivos de fluxo importados que tenham o mesmo nome dos fluxos de dados existentes em seu aplicativo Canvas são renomeados com um postfix. Você pode abrir um fluxo de dados para verificar se ele tem a aparência esperada.

Caso algum dos seus arquivos de fluxo não seja importado com êxito, você receberá uma notificação de que a importação foi parcialmente bem-sucedida ou falhou. Escolha Exibir erros na mensagem de notificação para verificar as mensagens de erro individuais e obter orientação sobre como reformatar qualquer arquivo de fluxo formatado incorretamente.

Depois de importar seus arquivos de fluxo, agora você deve ser capaz de continuar usando o Data Wrangler para preparar dados no Canvas. SageMaker

Método de migração manual

As seções a seguir descrevem como importar manualmente seus arquivos de fluxo para o Canvas, caso o método de migração com um clique não funcione.

Exporte os arquivos de fluxo do Studio Classic

nota

Se você já migrou seus dados do Studio Classic para o Amazon S3 seguindo as instruções (Opcional) Migrar dados do Studio Classic para o Studio em, você pode pular esta etapa e ir direto para a seção na qual você importa seus arquivos de fluxo Importe os arquivos de fluxo para o Canvas do local do Amazon S3 onde seus dados do Studio Classic estão armazenados.

Você pode exportar seus arquivos de fluxo salvando-os no Amazon S3 ou baixando-os para sua máquina local. Ao importar seus arquivos de fluxo para o SageMaker Canvas na próxima etapa, se você escolher a opção de upload local, poderá carregar apenas 20 arquivos de fluxo por vez. Se você tiver um grande número de arquivos de fluxo para importar, recomendamos que você use o Amazon S3 em vez disso.

Siga as instruções em Método 1: usar o Amazon S3 para transferir arquivos de fluxo ou Método 2: usar sua máquina local para transferir arquivos de fluxo para continuar.

Método 1: usar o Amazon S3 para transferir arquivos de fluxo

Com esse método, você usa o Amazon S3 como intermediário entre o Data Wrangler no Studio Classic e o Data Wrangler no SageMaker Canvas (acessado por meio da versão mais recente do Studio). Você exporta os arquivos de fluxo do Studio Classic para o Amazon S3 e, na próxima etapa, acessa o Canvas por meio do Studio e importa os arquivos de fluxo do Amazon S3.

Certifique-se de ter um bucket do Amazon S3 preparado como local de armazenamento para os arquivos de fluxo.

Use o procedimento a seguir para exportar seus arquivos de fluxo do Studio Classic para o Amazon S3:

Abra o Studio Classic.
Abra um novo terminal fazendo o seguinte:
1. Na barra de navegação superior, escolha Arquivo.
2. No menu de contexto, passe o mouse sobre Novo e selecione Terminal.
Por padrão, o terminal deve abrir em seu diretório pessoal. Navegue até a pasta que contém todos os arquivos de fluxo que você deseja migrar.
Use o comando a seguir para sincronizar todos os arquivos de fluxo com a localização especificada do Amazon S3. Substitua {bucket-name} e {folder} pelo caminho para a localização desejada do Amazon S3. Para obter mais informações sobre o comando e os parâmetros, consulte o comando sync na Referência de AWS AWS CLI comandos.
```
aws s3 sync . s3://{bucket-name}/{folder}/ --exclude "*.*" --include "*.flow"
```
Se você estiver usando o seu próprio AWS KMS key, use o comando a seguir para sincronizar os arquivos e especificar sua ID de KMS chave. Certifique-se de que a função de IAM execução do usuário (que deve ser a mesma usada na Etapa 1). Migrar o domínio e conceder permissões (dos pré-requisitos anteriores) recebeu acesso para usar a chave. KMS
```
aws s3 sync . s3://{bucket-name}/{folder}/ --exclude "*.*" --include "*.flow" --sse-kms-key-id {your-key-id}
```

Seus arquivos de fluxo agora devem ser exportados. Você pode verificar seu bucket do Amazon S3 para se certificar de que os arquivos de fluxo foram sincronizados com sucesso.

Para importar esses arquivos na versão mais recente do Data Wrangler, siga as etapas em. Importe os arquivos de fluxo para o Canvas

Método 2: usar sua máquina local para transferir arquivos de fluxo

Com esse método, você baixa os arquivos de fluxo do Studio Classic para sua máquina local. Você pode baixar os arquivos diretamente ou compactá-los como um arquivo zip. Em seguida, você descompacta o arquivo zip localmente (se aplicável), entra no Canvas e importa os arquivos de fluxo fazendo o upload deles da sua máquina local.

Use o procedimento a seguir para baixar seus arquivos de fluxo do Studio Classic:

Abra o Studio Classic.
(Opcional) Se você quiser compactar vários arquivos de fluxo em um arquivo zip e baixá-los todos de uma vez, faça o seguinte:
1. Na barra de navegação superior do Studio Classic, escolha Arquivo.
2. No menu de contexto, passe o mouse sobre Novo e selecione Terminal.
3. Por padrão, o terminal é aberto no seu diretório pessoal. Navegue até a pasta que contém todos os arquivos de fluxo que você deseja migrar.
4. Use o comando a seguir para compactar os arquivos de fluxo no diretório atual como um zip. O comando exclui todos os arquivos ocultos:
```
find . -not -path "*/.*" -name "*.flow" -print0 | xargs -0 zip my_archive.zip
```
Faça o download do arquivo zip ou dos arquivos de fluxo individuais para sua máquina local fazendo o seguinte:
1. No painel de navegação esquerdo do Studio Classic, escolha Navegador de arquivos.
2. Encontre o arquivo que você deseja baixar no navegador de arquivos.
3. Clique com o botão direito do mouse no arquivo e, no menu de contexto, selecione Baixar.

O arquivo deve ser baixado para sua máquina local. Se você os empacotou como um arquivo zip, extraia os arquivos localmente. Depois que os arquivos forem extraídos, para importá-los na versão mais recente do Data Wrangler, siga as etapas em. Importe os arquivos de fluxo para o Canvas

Importe os arquivos de fluxo para o Canvas

Depois de exportar seus arquivos de fluxo, acesse o Canvas pelo Studio e importe os arquivos.

Use o procedimento a seguir para importar arquivos de fluxo para o Canvas:

Abra sua versão mais recente do Studio.
No Studio, no painel de navegação esquerdo, escolha o menu suspenso Dados.
Nas opções de navegação, escolha Data Wrangler.
Na página Data Wrangler, escolha Executar no Canvas. Se você configurou com sucesso as permissões, isso cria um aplicativo Canvas para você. O aplicativo Canvas pode levar alguns minutos até ficar pronto.
Quando o Canvas estiver pronto, escolha Abrir no Canvas.
O Canvas é aberto na página Data Wrangler. No painel superior, escolha Importar fluxos de dados.
Em Fonte de dados, escolha Amazon S3 ou upload local.
Selecione seus arquivos de fluxo do bucket do Amazon S3 ou faça o upload dos arquivos da sua máquina local.

nota
Para upload local, você pode carregar no máximo 20 arquivos de fluxo por vez. Para importações maiores, use o Amazon S3. Se você selecionar uma pasta para importar, todos os arquivos de fluxo em subpastas também serão importados.
Escolha Importar dados.

Se a importação for bem-sucedida, você receberá uma notificação de que o X número de arquivos de fluxo foi importado com êxito.

Caso seus arquivos de fluxo não sejam importados com sucesso, você receberá uma notificação no aplicativo SageMaker Canvas. Escolha Exibir erros na mensagem de notificação para verificar as mensagens de erro individuais e obter orientação sobre como reformatar qualquer arquivo de fluxo formatado incorretamente.

Depois que a importação dos arquivos de fluxo for concluída, acesse a página Data Wrangler do aplicativo SageMaker Canvas para visualizar seus fluxos de dados. Você pode tentar abrir um fluxo de dados para verificar se ele tem a aparência esperada.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

(Opcional) Migre imagens personalizadas e configurações de ciclo de vida

Inicie o Amazon SageMaker Studio