Définissez les autorisations pour les constructions L2 à l'aide du AWS CDK

Mode de mise au point

Définissez les autorisations pour les constructions L2 à l'aide du AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

Utiliser des méthodes d'octroi pour définir les autorisations Création et utilisation manuelles de rôles IAM

Ceci est le guide du AWS CDK développeur de la version 2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Ceci est le guide du AWS CDK développeur de la version 2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Définissez des rôles et des politiques AWS Identity and Access Management (IAM) pour les constructions L2 lors de l'utilisation du. AWS Cloud Development Kit (AWS CDK)

Utiliser des méthodes d'octroi pour définir les autorisations

Lorsque vous définissez votre infrastructure à l'aide des constructions L2 de la bibliothèque AWS de constructions, vous pouvez utiliser les méthodes d'octroi fournies pour spécifier les autorisations dont vos ressources auront besoin. Ils AWS CDK créeront automatiquement les rôles IAM nécessaires pour toutes les AWS ressources qui en ont besoin.

L'exemple suivant définit les autorisations entre une AWS Lambda fonction et le bucket Amazon Simple Storage Service (Amazon S3). Ici, la grantRead méthode de la construction Bucket L2 est utilisée pour définir ces autorisations :

TypeScript


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as kms from 'aws-cdk-lib/aws-kms';

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

    const key = new kms.Key(this, 'BucketKey');
    const bucket = new s3.Bucket(this, 'Bucket', {
      encryptionKey: key,
    });
    const handler = new lambda.Function(this, 'Handler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
    });

    // Define permissions between function and S3 bucket using grantRead method
    bucket.grantRead(handler);
    
  }
}

JavaScript


const { Stack, Duration } = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');
const lambda = require('aws-cdk-lib/aws-lambda');
const kms = require('aws-cdk-lib/aws-kms');

class CdkDemoStack extends Stack {

  constructor(scope, id, props) {
    super(scope, id, props);

    const key = new kms.Key(this, 'BucketKey');
    const bucket = new s3.Bucket(this, 'Bucket', {
      encryptionKey: key,
    });
    const handler = new lambda.Function(this, 'Handler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
    });

    // Define permissions between function and S3 bucket using grantRead method
    bucket.grantRead(handler);

  }
}

// ...

Python


from aws_cdk import (
    Stack,
    aws_s3 as s3,
    aws_lambda as _lambda,
    aws_kms as kms,
)
from constructs import Construct

class CdkDemoStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        key = kms.Key(self, 'BucketKey')
        bucket = s3.Bucket(self, 'Bucket')
        handler = _lambda.Function(
            self, 
            'Handler',
            runtime = _lambda.Runtime.NODEJS_20_X,
            handler = 'index.handler',
            code = _lambda.Code.from_asset('lambda'),
        )

        # Define permissions between function and S3 bucket using grantRead method
        bucket.grantRead(handler)

Java


package com.myorg;

import software.amazon.awscdk.core.App;
import software.amazon.awscdk.core.Stack;
import software.amazon.awscdk.core.StackProps;
import software.amazon.awscdk.services.kms.Key;
import software.amazon.awscdk.services.kms.KeyProps;
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.BucketProps;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.FunctionProps;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.lambda.Code;
import software.constructs.Construct;

public class CdkDemoStack extends Stack {
    public CdkDemoStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public CdkDemoStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Key key = new Key(this, "BucketKey", KeyProps.builder().build());

        Bucket bucket = new Bucket(this, "Bucket", BucketProps.builder()
            .encryptionKey(key)
            .build());

        Function handler = new Function(this, "Handler", FunctionProps.builder()
            .runtime(Runtime.NODEJS_20_X)
            .handler("index.handler")
            .code(Code.fromAsset("lambda"))
            .build());

        // Define permissions between function and S3 bucket using grantRead method
        bucket.grantRead(handler);
    }

    public static void main(final String[] args) {
        App app = new App();

        new CdkDemoStack(app, "CdkDemoStack");

        app.synth();
    }
}

C#


using Amazon.CDK;
using Amazon.CDK.AWS.KMS;
using Amazon.CDK.AWS.S3;
using Amazon.CDK.AWS.Lambda;

namespace CdkDemo
{
    public class CdkDemoStack : Stack
    {
        internal CdkDemoStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var key = new Key(this, "BucketKey");

            var bucket = new Bucket(this, "Bucket", new BucketProps
            {
                EncryptionKey = key
            });

            var handler = new Function(this, "Handler", new FunctionProps
            {
                Runtime = Runtime.NODEJS_20_X,
                Handler = "index.handler",
                Code = Code.FromAsset("lambda")
            });

            // Define permissions between function and S3 bucket using grantRead method
            bucket.GrantRead(handler);
        }
    }
}

Go


package main
import (
    "github.com/aws/aws-cdk-go/awscdk/v2"
    "github.com/aws/aws-cdk-go/awscdk/v2/awskms"
    "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
    "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
    "github.com/aws/constructs-go/constructs/v10"
    "github.com/aws/jsii-runtime-go"
)
// ...
func NewCdkDemoStack(scope constructs.Construct, id string, props *CdkDemoStackProps) awscdk.Stack {
    stack := awscdk.NewStack(scope, &id, &props.StackProps)
    key := awskms.NewKey(stack, jsii.String("BucketKey"), nil)
    bucket := awss3.NewBucket(stack, jsii.String("Bucket"), &awss3.BucketProps{
        EncryptionKey: key,
    })
    handler := awslambda.NewFunction(stack, jsii.String("Handler"), &awslambda.FunctionProps{
        Runtime: awslambda.Runtime_NODEJS_20_X(),
        Handler: jsii.String("index.handler"),
        Code:    awslambda.Code_FromAsset(jsii.String("lambda"), &awss3assets.AssetOptions{}),
    })
    bucket.GrantRead(handler)
    return stack
}
// ...

anchor anchor anchor anchor anchor anchor


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as kms from 'aws-cdk-lib/aws-kms';

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

    const key = new kms.Key(this, 'BucketKey');
    const bucket = new s3.Bucket(this, 'Bucket', {
      encryptionKey: key,
    });
    const handler = new lambda.Function(this, 'Handler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
    });

    // Define permissions between function and S3 bucket using grantRead method
    bucket.grantRead(handler);
    
  }
}

Lorsque vous utilisez des méthodes d'octroi de constructions L2 pour définir des autorisations entre des ressources, elles AWS CDK créeront des rôles avec des politiques de moindre privilège en fonction de la méthode que vous spécifiez. Pour des raisons de sécurité, nous vous recommandons d'utiliser la méthode qui applique uniquement les autorisations dont vous avez besoin. Par exemple, si vous devez uniquement accorder des autorisations pour qu'une fonction Lambda puisse lire depuis un compartiment Amazon S3, utilisez la grantRead méthode au lieu de. grantReadWrite

Pour chaque méthode que vous utilisez, le CDK crée un rôle IAM unique pour les ressources spécifiées. Si nécessaire, vous pouvez également modifier directement la politique qui sera attachée au rôle. Voici un exemple :

anchor anchor anchor anchor anchor anchor


import { aws_iam as iam } from 'aws-cdk-lib';

handler.addToRolePolicy(new iam.PolicyStatement({
  actions: ['s3:GetObject', 's3:List*'],
  resources: [
    bucket.bucketArn,
    bucket.arnForObjects('*'),
  ]
}));

Toutefois, nous vous recommandons d'utiliser les grant méthodes lorsqu'elles sont disponibles.

Création et utilisation manuelles de rôles IAM

Si vous préférez ne pas utiliser les grant méthodes CDK pour créer et gérer les autorisations, vous devez les créer et les configurer manuellement. Vous pouvez créer des rôles IAM à l'aide de AWS Management Console AWS CLI, ou AWS SDKs. Ensuite, vous pouvez les transmettre manuellement à votre application CDK ou utiliser la fonctionnalité de personnalisation des rôles.

Référencez et gérez manuellement tous les rôles

Les constructions qui nécessitent un rôle possèdent une role propriété facultative que vous pouvez utiliser pour transmettre un objet de rôle.

Pour référencer un rôle manuellement

Role.fromRoleName()À utiliser pour faire référence à votre rôle préexistant. Voici un exemple :


const existingRole = Role.fromRoleName(stack, 'Role', 'my-pre-existing-role', {
  mutable: false // Prevent CDK from attempting to add policies to this role
}

Transmettez le rôle préexistant lors de la définition de votre ressource. Voici un exemple :


const handler = new lambda.Function(stack, 'Handler', { runtime: lambda.Runtime.NODEJS_20_XZ, handler:
         'index.handler', code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')), // Pass in pre-existing role
         role: existingRole, });

Utiliser la fonctionnalité de personnalisation des rôles

La fonctionnalité de personnalisation des AWS CDK rôles génère un rapport sur les rôles et les politiques de votre application CDK. Vous pouvez utiliser cette fonctionnalité pour générer un rapport. Vous pouvez ensuite leur substituer des rôles précréés.

Pour utiliser la fonctionnalité de personnalisation des rôles

Ajoutez Role.customizeRoles() quelque part en haut de votre application CDK. Voici un exemple :


const stack = new Stack(app, 'LambdaStack');

// Add this to use the role customization feature
iam.Role.customizeRoles(stack);

// Define your resources using L2 constructs
const key = new kms.Key(stack, 'BucketKey');
const bucket = new s3.Bucket(stack, 'Bucket', {
  encryptionKey: key,
});
const handler = new lambda.Function(stack, 'Handler', {
  runtime: lambda.Runtime.NODEJS_16_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
});

// The grantRead() is still important. Even though it actually doesn't mutate
// any policies, it indicates the need for them.
bucket.grantRead(handler);

Lorsque vous synthétisez votre application, le CDK génère une erreur indiquant que vous devez fournir le nom de rôle précréé à. Role.customizeRoles() Voici un exemple du rapport généré :

<missing role> (LambdaStack/Handler/ServiceRole)

AssumeRole Policy:
[
  {
    "Action": "sts:AssumeRole",
    "Effect": "Allow",
    "Principal": {
      "Service": "lambda.amazonaws.com"
    }
  }
]

Managed Policy ARNs:
[
  "arn:(PARTITION):iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
]

Managed Policies Statements:
NONE

Identity Policy Statements:
[
  {
    "Action": [
      "s3:GetObject*",
      "s3:GetBucket*",
      "s3:List*"
    ],
    "Effect": "Allow",
    "Resource": [
      "(LambdaStack/Bucket/Resource.Arn)",
      "(LambdaStack/Bucket/Resource.Arn)/*"
    ]
  }
]

Une fois le rôle créé, vous pouvez le transmettre à votre application pour la ressource à laquelle il s'applique. Par exemple, si le nom du rôle créé pour LambdaStack/Handler/ServiceRole estlambda-service-role, vous devez mettre à jour votre application CDK comme suit :
```
const stack = new Stack(app, 'LambdaStack');

// Add this to pass in the role
iam.Role.customizeRoles(stack, {
  usePrecreatedRoles: {
    'LambdaStack/Handler/ServiceRole': 'lambda-service-role',
  },
});
```
Le CDK utilisera désormais le nom de rôle précréé partout où le rôle est référencé dans l'application CDK. Il continuera également à générer le rapport afin que toute future modification de politique puisse être référencée.

Vous remarquerez que la référence à l'ARN du compartiment Amazon S3 dans le rapport est rendue sous la forme (LambdaStack/Bucket/Resource.Arn) au lieu de l'ARN réel du compartiment. Cela est dû au fait que l'ARN du bucket est une valeur temporelle de déploiement inconnue lors de la synthèse (le bucket n'a pas encore été créé). C'est un autre exemple de la raison pour laquelle nous recommandons d'autoriser CDK à gérer les rôles et les autorisations IAM en utilisant les méthodes fourniesgrant. Afin de créer le rôle avec la politique initiale, l'administrateur devra créer la politique avec des autorisations plus larges (par exemple,arn:aws:s3:::*).

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.