Phase 3: (Optional) Daten von Studio Classic zu Studio migrieren

Anmerkung

Wenn Sie Amazon SageMaker Data Wrangler-Datenflüsse haben, die Sie aus Studio Classic migrieren möchten, können Sie eine der folgenden Optionen für die Migration Ihrer Dateien wählen:

Überspringen Sie diesen Abschnitt und gehen Sie zu. (Optional) Migrieren Sie Datenflüsse aus Data Wrangler in Studio Classic
Füllen Sie diesen Abschnitt mit der Amazon S3 S3-Option aus und fahren Sie dann mit dem Importieren Sie die Flow-Dateien in Canvas Abschnitt von fort(Optional) Migrieren Sie Datenflüsse aus Data Wrangler in Studio Classic.

Studio Classic und Studio verwenden zwei verschiedene Arten von Speichervolumes. Studio Classic verwendet ein einzelnes Amazon Elastic File System (Amazon EFS) -Volume, um Daten für alle Benutzer und gemeinsam genutzten Bereiche in der Domain zu speichern. In Studio erhält jeder Bereich sein eigenes Amazon Elastic Block Store (Amazon EBS) -Volume. Wenn Sie das Standarderlebnis einer vorhandenen Domain aktualisieren, werden Daten zwischen diesen beiden Volumetypen SageMaker nicht automatisch übertragen. Infolgedessen bleiben Benutzerdaten, die auf einem Amazon EBS- oder Amazon EFS-Volume gespeichert sind, in diesem Volume. Wenn ein Benutzer mit Daten in Studio Classic nach einer Änderung der Standarderfahrung auf Studio zugreift, werden seine Daten nicht automatisch im Code Editor JupyterLab oder im Code-Editor angezeigt, der auf Code-OSS-, Visual Studio Code — Open-Source-Anwendungen basiert.

Wenn Benutzer Zugriff auf Dateien aus Studio Classic in Studio-Anwendungen benötigen, müssen Sie die Dateien aus den Home-Verzeichnissen der Benutzer auf die Amazon EBS-Volumes übertragen, die diesen Bereichen zugeordnet sind.

Bei der Migration der Daten, des Codes und der Artefakte eines Benutzers von Studio Classic nach Studio empfehlen wir einen der folgenden Ansätze:

Verwenden eines benutzerdefinierten Amazon EFS-Volumes
Verwenden von Amazon Simple Storage Service (Amazon S3)

Voraussetzungen

Bevor Sie diese Schritte ausführen, müssen Sie die Voraussetzungen unter erfüllenVollständige Voraussetzungen für die Migration des Studio-Erlebnisses. Sie müssen auch die Schritte unter ausführenPhase 1: Migrieren Sie die Benutzeroberfläche von Studio Classic zu Studio.

Einen Ansatz wählen

Beachten Sie bei der Auswahl eines Ansatzes für die Migration Ihrer Daten Folgendes.

Vor- und Nachteile der Verwendung eines benutzerdefinierten Amazon EFS-Volumes

Bei diesem Ansatz verwenden Sie eine Amazon EFS-zu-Amazon AWS DataSync EFS-Aufgabe (einmalig oder schrittweise), um Daten zu kopieren und anschließend das Amazon EFS-Zielvolume in die Spaces eines Benutzers einzubinden. Dadurch erhalten Benutzer Zugriff auf Daten aus Studio Classic in ihren Studio-Computerumgebungen.

Vorteile:

In den Bereichen des Benutzers sind nur die Home-Verzeichnisdaten des Benutzers sichtbar. Es findet keine gegenseitige Bestäubung der Daten statt.
Die Synchronisierung vom Amazon EFS-Quellvolume mit einem Amazon EFS-Zielvolume ist sicherer als das direkte Mounten des von verwalteten Amazon EFS-Quellvolumes SageMaker in Spaces. Dadurch wird die Gefahr einer Beeinträchtigung der Benutzerdateien im Home-Verzeichnis vermieden.
Benutzer haben die Flexibilität, weiterhin in Studio Classic- und Studio-Anwendungen zu arbeiten und gleichzeitig ihre Daten in beiden Anwendungen verfügbar zu haben, wenn AWS DataSync die Einrichtung in regelmäßigen Abständen erfolgt.
Mit Amazon S3 ist kein wiederholtes Push & Pull erforderlich.

Nachteile:

Kein Schreibzugriff auf das Amazon EFS-Zielvolume, das in die Bereiche des Benutzers eingebunden ist. Um Schreibzugriff auf das Amazon EFS-Zielvolume zu erhalten, müssten Kunden das Amazon EFS-Zielvolume in eine Amazon Elastic Compute Cloud-Instance einbinden und Benutzern die entsprechenden Berechtigungen zum Schreiben in das Amazon EFS-Präfix gewähren.
Erfordert eine Änderung der Sicherheitsgruppen, die von verwaltet werden SageMaker , um eingehenden und ausgehenden Datenfluss über das Netzwerkdateisystem (NFS) zu ermöglichen.
Kostet mehr als die Nutzung von Amazon S3.
Wenn Sie Datenflüsse aus Data Wrangler in Studio Classic migrieren, müssen Sie die Schritte zum manuellen Exportieren von Flow-Dateien befolgen.

Vor- und Nachteile der Verwendung von Amazon S3

Bei diesem Ansatz verwenden Sie eine Amazon EFS-zu-Amazon AWS DataSync S3-Aufgabe (einmalig oder in regelmäßigen Abständen), um Daten zu kopieren, und erstellen dann eine Lebenszykluskonfiguration, um die Daten des Benutzers von Amazon S3 auf das Amazon EBS-Volume seines privaten Bereichs zu kopieren.

Vorteile:

Wenn das LCC an die Domain angehängt ist, können Benutzer wählen, ob sie das LCC verwenden möchten, um Daten in ihren Space zu kopieren oder den Space ohne LCC-Skript auszuführen. Dadurch haben Benutzer die Wahl, ihre Dateien nur in die Bereiche zu kopieren, die sie benötigen.
Wenn eine AWS DataSync Aufgabe in einem bestimmten Rhythmus eingerichtet wird, können Benutzer ihre Studio-Anwendung neu starten, um die neuesten Dateien abzurufen.
Da die Daten nach Amazon EBS kopiert werden, haben Benutzer Schreibberechtigungen für die Dateien.
Amazon S3 S3-Speicher ist günstiger als Amazon EFS.
Wenn Sie Datenflüsse aus Data Wrangler in Studio Classic migrieren, können Sie die manuellen Exportschritte überspringen und die Datenflüsse direkt von Amazon S3 in SageMaker Canvas importieren.

Nachteile:

Wenn Administratoren Fremdbestäubung verhindern möchten, müssen sie AWS Identity and Access Management Richtlinien auf Benutzerebene erstellen, um sicherzustellen, dass Benutzer nur auf das Amazon S3 S3-Präfix zugreifen können, das ihre Dateien enthält.

Bei diesem Ansatz verwenden Sie ein Amazon EFS-to-Amazon EFS, AWS DataSync um den Inhalt eines Studio Classic Amazon EFS-Volumes einmal oder in regelmäßigen Abständen auf ein Amazon EFS-Zielvolume zu kopieren und dann das Amazon EFS-Zielvolume in die Spaces eines Benutzers einzubinden. Dadurch erhalten Benutzer Zugriff auf Daten aus Studio Classic in ihren Studio-Computerumgebungen.

Erstellen Sie ein Amazon EFS-Zielvolume. Sie übertragen Daten auf dieses Amazon EFS-Volume und mounten es mithilfe von Mounten auf Präfixebene im Bereich eines entsprechenden Benutzers.


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"

Fügen Sie Variablen für das Amazon EFS-Quellvolume hinzu, das derzeit an die Domain angehängt und von allen Benutzern verwendet wird. Die Amazon Virtual Private Cloud Cloud-Informationen der Domain sind erforderlich, um sicherzustellen, dass das Amazon EFS-Ziel in derselben Amazon-VPC und demselben Subnetz mit derselben Sicherheitsgruppenkonfiguration erstellt wird.
```
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"
```

Erstellen Sie ein Amazon EFS-Mount-Ziel in derselben Amazon VPC und demselben Subnetz wie das Amazon EFS-Quellvolume mit derselben Sicherheitsgruppenkonfiguration. Es dauert einige Minuten, bis das Mount-Ziel verfügbar ist.


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

Erstellen Sie Amazon EFS-Quell- und Zielorte für die AWS DataSync Aufgabe.


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")

Lassen Sie den Datenverkehr zwischen den Quell- und Ziel-Mounts des Netzwerkdateisystems (NFS) zu. Wenn eine neue Domäne erstellt wird, werden zwei SageMaker Sicherheitsgruppen erstellt.
- NFS-Sicherheitsgruppe für eingehenden Datenverkehr mit nur eingehendem Datenverkehr.
- Ausgehender NFS-Sicherheitsgruppe mit nur ausgehendem Datenverkehr.
Das Quell- und das Ziel-NFS befinden sich in denselben Sicherheitsgruppen. Sie können den Verkehr zwischen diesen Mounts vom oder aus zulassen. AWS Management Console AWS CLI
- Erlaube Verkehr von AWS Management Console
  1. Melden Sie sich bei der Amazon VPC-Konsole an AWS Management Console und öffnen Sie sie unter https://console.aws.amazon.com/vpc/.
  2. Wählen Sie Security Groups.
  3. Suchen Sie auf der Seite Sicherheitsgruppen nach der ID der vorhandenen Domain.
    
    d-xxxxxxx
    
    Die Ergebnisse sollten zwei Sicherheitsgruppen zurückgeben, deren Name die Domain-ID enthält.
    
    security-group-for-inbound-nfs-domain-id
    
    security-group-for-outbound-nfs-domain-id
  4. Wählen Sie die Sicherheitsgruppen-ID für eingehende Nachrichten aus. Dadurch wird eine neue Seite mit Details zur Sicherheitsgruppe geöffnet.
  5. Wählen Sie die Registerkarte Ausgehende Regeln aus.
  6. Wählen Sie Regeln für ausgehenden Datenverkehr bearbeiten aus.
  7. Aktualisieren Sie die vorhandenen Regeln für ausgehenden Datenverkehr oder fügen Sie eine neue Regel für ausgehenden Datenverkehr mit den folgenden Werten hinzu:
    
    Typ: NFS
    
    Protocol (Protokoll): TCP
    
    Portbereich: 2049
    
    Ziel: security-group-for-outbound -nfs- domain-id | security-group-id
  8. Wählen Sie Save rules (Regeln speichern) aus.
  9. Wählen Sie die Registerkarte Regeln für eingehenden Datenverkehr aus.
  10. Wählen Sie Regeln für eingehenden Datenverkehr bearbeiten aus.
  11. Aktualisieren Sie die vorhandenen Regeln für eingehende Nachrichten oder fügen Sie eine neue Regel für ausgehenden Datenverkehr mit den folgenden Werten hinzu:
    
    Typ: NFS
    
    Protocol (Protokoll): TCP
    
    Portbereich: 2049
    
    Ziel: security-group-for-outbound -nfs- domain-id | security-group-id
  12. Wählen Sie Save rules (Regeln speichern) aus.
- Erlaube Verkehr von AWS CLI
  1. Aktualisieren Sie die Regeln für eingehende und ausgehende Nachrichten der Sicherheitsgruppe mit den folgenden Werten:
    
    Protocol (Protokoll): TCP
    
    Portbereich: 2049
    
    Gruppen-ID: Sicherheitsgruppen-ID für eingehenden Datenverkehr oder Sicherheitsgruppen-ID für ausgehenden Datenverkehr
    
    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. Fügen Sie sowohl die Sicherheitsgruppen für eingehenden als auch für ausgehenden Datenverkehr den Quell- und Ziel-Amazon EFS-Mount-Zielen hinzu. Dies ermöglicht den Verkehr zwischen den beiden Amazon EFS-Mounts.
    
    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

Erstellen Sie eine AWS DataSync Aufgabe. Dadurch wird ein Task-ARN zurückgegeben, mit dem die Aufgabe bei Bedarf oder als Teil einer regulären Kadenz ausgeführt werden kann.


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")

Starten Sie eine AWS DataSync Aufgabe, um Daten automatisch vom Amazon EFS-Quell-Mount in den Amazon EFS-Ziel-Mount zu kopieren. Dadurch werden die POSIX-Berechtigungen der Datei nicht beibehalten, sodass Benutzer vom Amazon EFS-Ziel-Mount lesen, aber nicht darauf schreiben können.
```
aws datasync start-task-execution --task-arn $DATASYNC_TASK_ARN
```

Mounten Sie das Amazon EFS-Zielvolume auf der Root-Ebene auf der Domain.


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

Überschreiben Sie jedes Benutzerprofil mit einem FileSystemPath Präfix. Das Präfix beinhaltet die UID des Benutzers, die von erstellt wurde. SageMaker Dadurch wird sichergestellt, dass Benutzer nur Zugriff auf ihre Daten haben, und eine Fremdbestäubung wird verhindert. Wenn in der Domain ein Space erstellt und das Amazon EFS-Zielvolume in die Anwendung eingebunden wird, überschreibt das Präfix des Benutzers das Domain-Präfix. Daher wird SageMaker nur das /user-id Verzeichnis in der Anwendung des Benutzers bereitgestellt.
```
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
```
Benutzer können dann beim Starten einer Anwendung das benutzerdefinierte Amazon EFS-Dateisystem auswählen. Weitere Informationen finden Sie unter JupyterLab benutzerhandbuch oder Starten Sie eine Code-Editor-Anwendung in Studio.

Bei diesem Ansatz verwenden Sie eine Amazon EFS-to-Amazon AWS DataSync S3-Aufgabe, um den Inhalt eines Studio Classic Amazon EFS-Volumes einmal oder in regelmäßigen Abständen in einen Amazon S3-Bucket zu kopieren. Anschließend erstellen Sie eine Lebenszykluskonfiguration, um die Daten des Benutzers von Amazon S3 auf das Amazon EBS-Volume seines privaten Bereichs zu kopieren.

Anmerkung

Dieser Ansatz funktioniert nur für Domains, die über Internetzugang verfügen.

Geben Sie die Amazon EFS-Quellvolume-ID der Domain ein, die die Daten enthält, die Sie migrieren.


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

Legen Sie den Namen des Amazon S3 S3-Ziel-Buckets fest. Informationen zum Erstellen eines Amazon S3 S3-Buckets finden Sie unter Bucket erstellen. Der verwendete Bucket muss über eine CORS-Richtlinie verfügen, wie unter beschrieben(Optional) Aktualisieren Sie Ihre CORS-Richtlinie für den Zugriff auf Amazon S3 S3-Buckets. Benutzer in der Domain müssen auch über Berechtigungen für den Zugriff auf den Amazon S3 S3-Bucket verfügen.

In diesem Beispiel kopieren wir Dateien in ein Präfix mit dem Namenstudio-new. Wenn Sie einen einzelnen Amazon S3 S3-Bucket verwenden, um mehrere Domains zu migrieren, verwenden Sie das studio-new/<domain-id> Präfix, um die Berechtigungen für die Dateien mithilfe von IAM einzuschränken.
```
export BUCKET_NAME=s3-bucket-name
export S3_DESTINATION_PATH=studio-new
```

Erstellen Sie eine Vertrauensrichtlinie, die Ihnen die AWS DataSync Erlaubnis erteilt, die Ausführungsrolle Ihres Kontos zu übernehmen.


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
)

Erstellen Sie eine IAM-Rolle und fügen Sie die Vertrauensrichtlinie hinzu.


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"

Erstellen Sie eine Sicherheitsgruppe, um Zugriff auf den Amazon EFS-Standort zu gewähren.


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"

Erstellen Sie einen Amazon EFS-Quellspeicherort für die AWS DataSync Aufgabe.


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"

Erstellen Sie einen Amazon S3 S3-Zielstandort für die AWS DataSync Aufgabe.


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"

Erstellen Sie eine AWS DataSync Aufgabe.


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"

Starte die AWS DataSync Aufgabe. Diese Aufgabe kopiert automatisch Daten vom Amazon EFS-Quellvolume in den Amazon S3-Ziel-Bucket. Warten Sie, bis die Aufgabe abgeschlossen ist.
```
aws datasync start-task-execution --task-arn $TASK_ARN
```

Überprüfen Sie den Status der AWS DataSync Aufgabe, um sicherzustellen, dass sie abgeschlossen ist. Übergeben Sie den im vorherigen Schritt zurückgegebenen ARN.


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

Nachdem die AWS DataSync Aufgabe abgeschlossen ist, bereinigen Sie die zuvor erstellten Ressourcen.


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"

Erstellen Sie auf Ihrem lokalen Rechner eine Datei namens on-start.sh mit folgendem Inhalt. Dieses Skript kopiert das Amazon EFS-Home-Verzeichnis des Benutzers in Amazon S3 auf das Amazon EBS-Volume des Benutzers in Studio und erstellt ein Präfix für jedes Benutzerprofil.


#!/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

Konvertieren Sie Ihr Skript in das Base64-Format. Diese Anforderung verhindert Fehler, die bei der Kodierung von Leerzeichen und Zeilenumbrüchen auftreten. Der Skripttyp kann entweder JupyterLab oder CodeEditor sein.
```
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}`
```
Überprüfen Sie Folgendes, bevor Sie das Skript verwenden:
- Das Amazon EBS-Volume ist groß genug, um die Objekte zu speichern, die Sie exportieren.
- Sie migrieren keine versteckten Dateien und Ordner, z. B. .bashrc .condarc wenn Sie dies nicht beabsichtigen.
- Für die Ausführungsrolle AWS Identity and Access Management (IAM), die mit Studio-Benutzerprofilen verknüpft ist, sind die Richtlinien so konfiguriert, dass sie nur auf das jeweilige Home-Verzeichnis in Amazon S3 zugreifen.

Erstellen Sie mithilfe Ihres Skripts eine Lebenszykluskonfiguration.


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

Hängen Sie das LCC an Ihre Domain an.


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

Benutzer können dann das LCC-Skript auswählen, wenn sie eine Anwendung starten. Weitere Informationen finden Sie unter JupyterLab benutzerhandbuch oder Starten Sie eine Code-Editor-Anwendung in Studio. Dadurch werden die Dateien von Amazon S3 automatisch mit dem Amazon EBS-Speicher für den Speicherplatz des Benutzers synchronisiert.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Phase 2: (Optional) Migrieren von benutzerdefinierten Images und Lebenszykluskonfigurationen

(Optional) Migrieren Sie Datenflüsse aus Data Wrangler in Studio Classic