Utilisation du gestionnaire de rôles (AWS CDK) - Amazon SageMaker AI

Utilisation du gestionnaire de rôles (AWS CDK)

Utilisez AWS Cloud Development Kit (AWS CDK) avec le gestionnaire de rôles Amazon SageMaker pour créer des rôles et définir des autorisations par programmation. Vous pouvez utiliser AWS CDK pour accomplir toute tâche que vous pourriez effectuer à l'aide de la 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 AWS CDK, consultez Qu’est-ce qu’AWS CDK ?

Important

Vous devez utiliser le persona Rôle de calcul SageMaker AI pour créer un rôle de calcul SageMaker AI. Pour plus d’informations sur le persona de calcul, consultez Persona de calcul SageMaker AI. Pour le code que vous pouvez utiliser pour créer le rôle de calcul dans AWS CDK, consultez Octroi 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.

  • Activer des conditions globales d'Amazon VPC et d'AWS Key Management Service, et définir leurs valeurs.

  • Choisir parmi toutes les versions des activités de ML pour vos utilisateurs sans interrompre leur accès.

Certaines tâches AWS courantes liées au machine learning (ML) avec SageMaker AI nécessitent des autorisations IAM spécifiques. Les autorisations permettant d’effectuer ces tâches sont définies en tant qu’activités de ML dans le Gestionnaire de rôles Amazon SageMaker. 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 pile AWS CDK. 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 bloc-notes SageMaker.

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 ML ne s'appliquent qu'aux configurations d'Amazon VPC et d'AWS 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 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 la forme d'une construction au sein de la pile AWS CDK. 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 compte AWS.


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 d'Amazon VPC et les autorisations de AWS 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 la forme d'une construction au sein de la pile AWS CDK. 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 compte AWS.


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('amzn-s3-demo-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 ML ne s'appliquent qu'aux configurations d'Amazon VPC et d'AWS KMS spécifiées dans la construction du 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 la forme d’une construction au sein de la pile AWS CDK. 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 compte AWS.


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 la forme d'une construction au sein de la pile AWS CDK. 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') 
    }
}