Migrar 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 (Amazon EFS) 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 do Amazon Elastic Block Store (Amazon EBS). Quando você atualiza a experiência padrão de um domínio existente, a SageMaker IA monta automaticamente uma pasta em um volume do Amazon EFS para cada usuário em um domínio. Como resultado, os usuários podem acessar arquivos do Studio Classic em suas aplicações do Studio. Para obter mais informações, consulte Montagem automática do Amazon EFS no Studio.

Você também pode desativar a montagem automática do Amazon EFS e migrar manualmente os dados para dar aos usuários acesso aos arquivos do Studio Classic nas aplicações do Studio. Para fazer isso, transfira os arquivos dos diretórios pessoais do usuário para os volumes do Amazon EBS associados a esses espaços. A seção a seguir apresenta informações sobre esse fluxo de trabalho. Para obter mais informações a respeito de como optar por não participar da montagem automática do Amazon EFS, consulte Desativar a montagem automática do Amazon EFS.

Migrar 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:

Como usar um volume personalizado do Amazon EFS
Como usar 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 Migrar manualmente todos os seus dados do Studio Classic e conclua a seção Usar o Amazon S3 para migrar dados. Depois, acesse a seção Importe os arquivos de fluxo para o Canvas.
Se quiser migrar apenas seus arquivos de fluxo de dados e nenhum outro dado do seu volume de armazenamento do Studio Classic, acesse a seção Migre fluxos de dados do Data Wrangler.

Pré-requisitos

Para configurar esses pré-requisitos, conclua as etapas em Pré-requisitos completos para migrar a experiência do Studio. Conclua também as etapas emMigrar a interface do usuário do Studio Classic para o Studio.

Como escolher uma abordagem

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

Prós e contras do uso de um volume personalizado do Amazon EFS

Nessa abordagem, você usa uma AWS DataSync tarefa do Amazon EFS-to-Amazon EFS (uma vez ou cadência) para copiar dados e, em seguida, montar o volume de destino do Amazon EFS 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.
A sincronização do volume de origem do Amazon EFS com um volume de destino do Amazon EFS é mais segura do que montar diretamente o volume de origem do Amazon EFS gerenciado pela SageMaker IA 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 nas aplicações do Studio Classic e do Studio, ao mesmo tempo em que têm seus dados disponíveis em ambas as aplicações, se o AWS DataSync estiver configurado regularmente.
Não há necessidade de empurrar e puxar repetidamente com o Amazon S3.

Contras:

Sem acesso de gravação ao volume de destino do Amazon EFS montado nos espaços do usuário. Para ter acesso de gravação ao volume de destino do Amazon EFS, os clientes precisariam montar o volume alvo do Amazon EFS em uma instância do Amazon Elastic Compute Cloud e fornecer as permissões apropriadas para os usuários gravarem no prefixo do Amazon EFS.
Requer modificação nos grupos de segurança gerenciados pela SageMaker IA 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 do uso do 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 EBS de seu espaço privado.

Prós:

Se a LCC estiver anexada ao domínio, os usuários poderão optar por usar a LCC para copiar dados para seu espaço ou executar o espaço sem o script da LCC. 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 o Amazon EBS, os usuários têm permissões de gravação nos arquivos.
O armazenamento do 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 políticas de AWS Identity and Access Management 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 um Amazon EFS-to-Amazon EFS AWS DataSync para copiar o conteúdo de um volume Studio Classic Amazon EFS para um volume de destino do Amazon EFS uma vez ou em um ritmo regular e, em seguida, montar o volume de destino do Amazon EFS 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 volume de destino do Amazon EFS. Você transferirá dados para esse volume do Amazon EFS 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 volume de origem do Amazon EFS 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 o Amazon EFS de destino seja criado 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 montagem do Amazon EFS na mesma Amazon VPC e sub-rede do volume de origem do Amazon EFS, 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 de origem e destino do Amazon EFS 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 (NFS) de origem e de destino. Quando um novo domínio é criado, a SageMaker IA cria dois grupos de segurança.
- Grupo de segurança de entrada NFS com apenas tráfego de entrada.
- Grupo de segurança de saída NFS com somente tráfego de saída.
O NFS de origem e de destino 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 console da Amazon VPC em. https://console.aws.amazon.com/vpc/
  2. Escolha Grupos de segurança.
  3. Pesquise o ID do domínio existente na página de 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. Essa ação 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. Selecione Salvar rules.
  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. Selecione Salvar rules.
- 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: 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 montagem do Amazon EFS de origem e de destino. Isso permite o tráfego entre as duas montagens do Amazon EFS.
    
    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 um ARN de tarefa que pode ser usado 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 origem do Amazon EFS para a montagem do Amazon EFS de destino. Isso não retém as permissões POSIX do arquivo, o que permite que os usuários leiam a partir da montagem de destino do Amazon EFS, mas não gravem nela.
```
aws datasync start-task-execution --task-arn $DATASYNC_TASK_ARN
```

Monte o volume de destino do Amazon EFS 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 prefixo FileSystemPath. O prefixo inclui o UID do usuário, criado pela SageMaker IA. 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 volume de destino do Amazon EFS é montado na aplicação, o prefixo do usuário substitui o prefixo do domínio. Como resultado, a SageMaker IA só monta 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

Em seguida, os usuários podem selecionar o sistema de arquivos personalizado do Amazon EFS ao iniciar uma aplicação. Para ter mais informações, consulte JupyterLab guia do usuário ou Inicie a aplicação 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 volume do Studio Classic Amazon EFS para um bucket do Amazon S3 uma vez ou em um ritmo regular e, em seguida, criar uma configuração de ciclo de vida para copiar os dados do usuário do Amazon S3 para o volume Amazon EBS de seu espaço privado.

nota

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

Defina o ID do volume Amazon EFS 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 informações sobre como criar um bucket do Amazon S3, consulte Criação de um bucket. O bucket usado deve ter uma política de CORS, conforme descrito em (Opcional) Atualizar a política CORS para acessar os buckets do Amazon S3. Os usuários do domínio também devem ter permissões para acessar o bucket do Amazon S3.

Neste exemplo, estamos copiando arquivos para um prefixo chamado studio-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 usando o 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 um perfil do IAM 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 conceder acesso à localização do Amazon EFS.


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 local de origem do Amazon EFS 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 volume de origem do Amazon EFS para o bucket do Amazon S3 de destino. Aguarde a conclusão do trabalho.
```
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 retornado 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 inicial do Amazon EFS do usuário no Amazon S3 para o volume do Amazon EBS 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

Converter seu arquivo 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 volume do Amazon EBS é 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 a 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 script da LCC ao iniciar uma aplicação. Para ter mais informações, consulte JupyterLab guia do usuário ou Inicie a aplicação de Editor de Código no Studio. Isso sincroniza automaticamente os arquivos do Amazon S3 com o armazenamento do Amazon EBS 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 para conceder acesso:

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

Verifique os seguintes pré-requisitos 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 execução do AWS IAM 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 função do IAM 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 apenas 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 suas aplicações do Studio Classic e Canvas compartilhem o mesmo volume de armazenamento do Amazon EFS, você pode migrar do Canvas com um único 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 seguinte procedimento para migrar todos os seus arquivos de fluxo:

Abra sua versão mais recente do Studio.
No Studio, no painel de navegação à esquerda, selecione 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 uma aplicação do Canvas para você. Pode levar alguns minutos para a aplicação do Canvas ficar pronta.
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. Essa importação é necessária apenas uma vez. 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 número X de arquivos de fluxo foi importado e poderá ver seus arquivos de fluxo na página Data Wrangler da aplicação do Canvas. Todos os arquivos de fluxo importados que tenham o mesmo nome dos fluxos de dados existentes em sua aplicação do 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 no (Opcional) Migrar dados do Studio Classic para o Studio, você pode pular esta etapa e ir direto para a seção Importe os arquivos de fluxo para o Canvas na qual você importa seus arquivos de fluxo 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ê tem um grande número de arquivos de fluxo para importar, recomendamos usar o Amazon S3.

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.

Verifique se você tem um bucket do Amazon S3 preparado como o local de armazenamento dos arquivos de fluxo.

Use o seguinte procedimento 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 inicial. Navegue até a pasta que contém todos os arquivos de fluxo que você deseja migrar.
Use o seguinte comando 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 da chave KMS. Verifique se a função de execução do IAM do usuário (que deve ser a mesma função usada na Etapa 1. Migre o domínio e conceda permissões dos pré-requisitos anteriores) recebeu acesso para usar a chave do 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. Verifique seu bucket do Amazon S3 para garantir que os arquivos de fluxo tenham sido 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, descompacte o arquivo zip localmente (se aplicável), faça login no Canvas e importe os arquivos de fluxo fazendo upload deles a partir do seu computador local.

Use o seguinte procedimento para fazer o download de 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 abre em seu diretório inicial. 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 à esquerda 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 em seu computador 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 seguinte procedimento para importar arquivos de fluxo para o Canvas:

Abra sua versão mais recente do Studio.
No Studio, no painel de navegação à esquerda, selecione 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 uma aplicação do Canvas para você. Pode levar alguns minutos para a aplicação do Canvas ficar pronta.
Quando o Canvas estiver pronto, escolha Abrir no Canvas.
O Canvas é aberto na página do Data Wrangler. No painel superior, escolha Importar fluxos de dados.
Para Fonte de dados, escolha Amazon S3 ou carregamento de dados.
Selecione seus arquivos de fluxo do seu bucket do Amazon S3 ou carregue os 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 número X 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