Utilisation du gestionnaire de rôles (AWS CDK)

Utilisez le AWS Cloud Development Kit (AWS CDK) avec Amazon SageMaker Role Manager pour créer des rôles et définir des autorisations par programmation. Vous pouvez utiliser le AWS CDK pour accomplir n'importe quelle tâche que vous pourriez effectuer à l'aide du AWS Management Console. L'accès par programmation de CDK permet de fournir plus facilement des autorisations permettant à vos utilisateurs d'accéder à des ressources spécifiques. Pour plus d'informations sur le AWS CDK, voir Qu'est-ce que c'est AWS CDK ?

Important

Vous devez utiliser le personnage SageMaker Compute Role pour créer un SageMaker Compute Role. Pour plus d'informations sur le persona de calcul, consultez SageMaker persona informatique. Pour le code que vous pouvez utiliser pour créer le rôle de calcul dans le AWS CDK, voirOctroi d'autorisations à un persona de calcul.

Voici des exemples de tâches que vous pouvez effectuer dans AWS CDK :

Créer des rôles IAM avec des autorisations détaillées pour les personas de machine learning (ML), tels que les scientifiques des données et les ingénieurs MLOps.
Accorder des autorisations aux constructions CDK à partir de personas de ML ou d'activités de ML.
Définir des paramètres de condition d'activité de ML.
Activez le VPC et les AWS Key Management Service conditions Amazon globaux et définissez des valeurs pour celles-ci.
Choisir parmi toutes les versions des activités de ML pour vos utilisateurs sans interrompre leur accès.

Certaines AWS tâches courantes liées à l'apprentissage automatique (ML) SageMaker nécessitent des autorisations IAM spécifiques. Les autorisations pour effectuer les tâches sont définies comme des activités de machine learning dans Amazon SageMaker Role Manager. Les activités de ML spécifient un ensemble d'autorisations liées au rôle IAM. Par exemple, l'activité ML pour Amazon SageMaker Studio Classic dispose de toutes les autorisations dont un utilisateur a besoin pour accéder à Studio Classic. Pour plus d'informations sur les activités de ML, consultez Référence d'activité de ML.

Lorsque vous créez des rôles, vous définissez d'abord les constructions pour le persona de ML ou l'activité de ML. Une construction est une ressource au sein de la AWS CDK pile. Par exemple, une construction peut être un compartiment Amazon S3, un sous-réseau Amazon VPC ou un rôle IAM.

Lorsque vous créez le persona ou l'activité, vous pouvez limiter les autorisations associées à ce persona ou à cette activité à des ressources spécifiques. Par exemple, vous pouvez personnaliser l'activité pour fournir des autorisations uniquement pour un sous-réseau spécifique au sein d'un réseau Amazon VPC.

Après avoir défini les autorisations, vous pouvez créer des rôles, puis les transmettre pour créer d'autres ressources, telles que des instances de SageMaker bloc-notes.

Vous trouverez ci-dessous des exemples de code en Typescript pour les tâches que vous pouvez accomplir à l'aide de CDK. Lorsque vous créez une activité, vous spécifiez un identifiant et les options de la construction de l'activité. Les options sont des dictionnaires qui spécifient les paramètres requis pour les activités, tels qu'Amazon S3. Vous transmettez un dictionnaire vide pour les activités qui n'ont pas de paramètres requis.

Le code suivant crée un persona de ML Scientifique des données avec un ensemble d'activités de ML spécifiques à ce persona. Les autorisations issues des activités de machine learning ne s'appliquent qu'au VPC Amazon et aux AWS KMS configurations spécifiées dans la structure persona. Le code suivant crée une classe pour un persona Scientifique des données. Les activités de ML sont définies dans la liste des activités. Les autorisations du VPC et les autorisations KMS sont définies comme des paramètres facultatifs en dehors de la liste des activités.

Après avoir défini la classe, vous pouvez créer un rôle sous forme de construction au sein de la AWS CDK pile. Vous pouvez également créer une instance de bloc-notes. La personne qui utilise le rôle IAM que vous avez créé dans le code suivant peut accéder à l'instance de bloc-notes lorsqu'elle se connecte à son AWS compte.



export class myCDKStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const persona = new Persona(this, 'example-persona-id', {
        activities: [
            Activity.accessAwsServices(this, 'example-id1', {})
        ]
    });

    const role = persona.createRole(this, 'example-IAM-role-id', 'example-IAM-role-name');
    
    }
}

Le code suivant crée un persona de ML Scientifique des données avec un ensemble d'activités de ML spécifiques à ce persona. Les autorisations issues des activités de ML ne s'appliquent qu'aux configurations du VPC et de KMS spécifiées dans la construction du persona. Le code suivant crée une classe pour un persona Scientifique des données. Les activités de ML sont définies dans la liste des activités. Les autorisations Amazon VPC et les AWS KMS autorisations sont définies comme des paramètres facultatifs en dehors de la liste des activités.



export class myCDKStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const persona = new Persona(this, 'example-persona-id', {
        activities: [
            Activity.runStudioAppsV2(this, 'example-id1', {}),
            Activity.manageJobs(this, 'example-id2', {rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.manageModels(this, 'example-id3', {rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.manageExperiments(this, 'example-id4', {}),
            Activity.visualizeExperiments(this, 'example-id5', {}),
            Activity.accessS3Buckets(this, 'example-id6', {s3buckets: [s3.S3Bucket.fromBucketName('DOC-EXAMPLE-BUCKET')]})
        ],
        // optional: to configure VPC permissions
        subnets: [ec2.Subnet.fromSubnetId('example-VPC-subnet-id')],
        securityGroups: [ec2.SecurityGroup.fromSecurityGroupId('example-VPC-security-group-id')],
        // optional: to configure KMS permissions
        dataKeys: [kms.Key.fromKeyArn('example-KMS-key-ARN')],
        volumeKeys: [kms.Key.fromKeyArn('example-KMS-key-ARN')],
    });

    const role = persona.createRole(this, 'example-IAM-role-id', 'example-IAM-role-name');
    
    const notebookInstance = new CfnNotebookInstance(this, 'example-notebook-instance-name', { RoleArn: role.RoleArn, ...});
    }
}

Le code suivant crée un persona ML Ops avec un ensemble d'activités de ML spécifiques à ce persona. Les autorisations issues des activités de machine learning ne s'appliquent qu'au VPC Amazon et aux AWS KMS configurations spécifiées dans la structure persona. Le code suivant crée une classe pour un persona ML Ops. Les activités de ML sont définies dans la liste des activités. Les autorisations du VPC et les autorisations KMS sont définies comme des paramètres facultatifs en dehors de la liste des activités.

Après avoir défini la classe, vous pouvez créer un rôle sous forme de construction au sein de la AWS CDK pile. Vous pouvez également créer un profil utilisateur Amazon SageMaker Studio Classic. La personne qui utilise le rôle IAM que vous avez créé dans le code suivant peut ouvrir SageMaker Studio Classic lorsqu'elle se connecte à son AWS compte.



export class myCDKStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const persona = new Persona(this, 'example-persona-id', {
        activities: [
            Activity.runStudioAppsV2(this, 'example-id1', {}),
            Activity.manageModels(this, 'example-id2', {rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.manageEndpoints(this, 'example-id3',{rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.managePipelines(this, 'example-id4', {rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.visualizeExperiments(this, 'example-id5', {})
        ],
        subnets: [ec2.Subnet.fromSubnetId('example-VPC-subnet-id')],
        securityGroups: [ec2.SecurityGroup.fromSecurityGroupId('example-VPC-security-group-id')],
        dataKeys: [kms.Key.fromKeyArn('example-KMS-key-ARN')],
        volumeKeys: [kms.Key.fromKeyArn('example-KMS-key-ARN')],
    });

    const role = persona.createRole(this, 'example-IAM-role-id', 'example-IAM-role-name');
    
    let userProfile = new CfnNUserProfile(this, 'example-Studio Classic-profile-name', { RoleName: role.RoleName, ... });  
    }
}

Le code suivant crée un persona ML Ops avec un ensemble d'activités de ML spécifiques à ce persona. Le code suivant crée une classe pour un persona ML Ops. Les activités de ML sont définies dans la liste des activités.

Après avoir défini la classe, vous pouvez créer un rôle sous forme de construction au sein de la AWS CDK pile. Vous pouvez également créer une instance de bloc-notes. Le code accorde des autorisations issues des activités de ML au rôle IAM de la fonction Lambda.



export class myCDKStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const persona = new Persona(this, 'example-persona-id', {
        activities: [
            Activity.runStudioAppsV2(this, 'example-id1', {}),
            Activity.manageModels(this, 'example-id2', {rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.manageEndpoints(this, 'example-id3',{rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.managePipelines(this, 'example-id4', {rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')]}),
            Activity.visualizeExperiments(this, 'example-id5', {})
        ],
    });

    const lambdaFn = lambda.Function.fromFunctionName('example-lambda-function-name');
    persona.grantPermissionsTo(lambdaFn);
    }
}

Le code suivant crée une activité de ML et crée un rôle à partir de cette activité. Les autorisations issues de l'activité s'appliquent uniquement à la configuration du VPC et de KMS que vous spécifiez pour l'utilisateur.



export class myCDKStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const activity = Activity.manageJobs(this, 'example-activity-id', {
        rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')],
        subnets: [ec2.Subnet.fromSubnetId('example-VPC-subnet-id')],
        securityGroups: [ec2.SecurityGroup.fromSecurityGroupId('example-VPC-security-group-id')],
        dataKeys: [kms.Key.fromKeyArn('example-KMS-key-ARN')],
        volumeKeys: [kms.Key.fromKeyArn('example-KMS-key-ARN')],
    });

    const role = activity.createRole(this, 'example-IAM-role-id', 'example-IAM-role-name');
    }
}

Le code suivant crée un rôle IAM pour une activité de ML individuelle.



export class myCDKStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const activity = Activity.manageJobs(this, 'example-activity-id', {
        rolesToPass: [iam.Role.fromRoleName('example-IAM-role-name')],
    });
        

    activity.create_role(this, 'example-IAM-role-id', 'example-IAM-role-name') 
    }
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation du gestionnaire de rôles (console)

Référence de persona