Definieren Sie Berechtigungen für L2-Konstrukte mit dem AWS CDK

Fokusmodus

Definieren Sie Berechtigungen für L2-Konstrukte mit dem AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

Verwenden Sie Grant-Methoden, um Berechtigungen zu definieren Manuelles Erstellen und Verwenden von IAM-Rollen

Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 in die Wartung aufgenommen und der Support wurde am 1. Juni 2023 eingestellt.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 in die Wartung aufgenommen und der Support wurde am 1. Juni 2023 eingestellt.

Definieren Sie AWS Identity and Access Management (IAM-) Rollen und Richtlinien für L2-Konstrukte, wenn Sie die verwenden. AWS Cloud Development Kit (AWS CDK)

Verwenden Sie Grant-Methoden, um Berechtigungen zu definieren

Wenn Sie Ihre Infrastruktur mithilfe von L2-Konstrukten aus der AWS Construct-Bibliothek definieren, können Sie die bereitgestellten Grant-Methoden verwenden, um die Berechtigungen anzugeben, die Ihre Ressourcen benötigen. Dadurch AWS CDK werden automatisch die IAM-Rollen erstellt, die für alle AWS Ressourcen benötigt werden, für die sie erforderlich sind.

Im Folgenden finden Sie ein Beispiel, das Berechtigungen zwischen einer AWS Lambda Funktion und einem Amazon Simple Storage Service (Amazon S3) -Bucket definiert. Hier grantRead wird die Methode des Bucket L2-Konstrukts verwendet, um diese Berechtigungen zu definieren:

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);
    
  }
}

Wenn Sie Grant-Methoden von L2-Konstrukten verwenden, um Berechtigungen zwischen Ressourcen zu definieren, AWS CDK werden Rollen mit Richtlinien mit den geringsten Rechten basierend auf der von Ihnen angegebenen Methode erstellt. Aus Sicherheitsgründen empfehlen wir, die Methode zu verwenden, die nur die Berechtigungen anwendet, die Sie benötigen. Wenn Sie beispielsweise einer Lambda-Funktion nur Berechtigungen zum Lesen aus einem Amazon S3 S3-Bucket erteilen müssen, verwenden Sie stattdessen die grantRead Methode. grantReadWrite

Für jede Methode, die Sie verwenden, erstellt das CDK eine eindeutige IAM-Rolle für die angegebenen Ressourcen. Bei Bedarf können Sie die Richtlinie, die der Rolle zugewiesen wird, auch direkt ändern. Im Folgenden wird ein Beispiel gezeigt:

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('*'),
  ]
}));

Wir empfehlen jedoch, die grant Methoden zu verwenden, sofern sie verfügbar sind.

Manuelles Erstellen und Verwenden von IAM-Rollen

Wenn Sie die grant CDK-Methoden nicht zum Erstellen und Verwalten von Berechtigungen verwenden möchten, müssen Sie sie manuell erstellen und konfigurieren. Sie können IAM-Rollen mithilfe von AWS Management Console AWS CLI, oder erstellen. AWS SDKs Anschließend können Sie sie manuell an Ihre CDK-Anwendung übergeben oder die Funktion zur Rollenanpassung verwenden.

Alle Rollen manuell referenzieren und verwalten

Konstrukte, die eine Rolle erfordern, verfügen über eine optionale role Eigenschaft, mit der Sie ein Rollenobjekt übergeben können.

Um manuell auf eine Rolle zu verweisen

Wird verwendetRole.fromRoleName(), um auf Ihre bereits bestehende Rolle zu verweisen. Im Folgenden wird ein Beispiel gezeigt:


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

Geben Sie bei der Definition Ihrer Ressource die bereits bestehende Rolle weiter. Im Folgenden wird ein Beispiel gezeigt:


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, });

Verwenden Sie die Funktion zur Rollenanpassung

Die Funktion zur AWS CDK Rollenanpassung generiert einen Bericht über Rollen und Richtlinien in Ihrer CDK-App. Sie können diese Funktion verwenden, um einen Bericht zu erstellen. Anschließend können Sie sie durch vorab erstellte Rollen ersetzen.

Um die Funktion zur Rollenanpassung zu verwenden

Fügen Sie es Role.customizeRoles() irgendwo oben in Ihrer CDK-Anwendung hinzu. Im Folgenden wird ein Beispiel gezeigt:


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

Wenn Sie Ihre Anwendung synthetisieren, gibt das CDK einen Fehler aus, der darauf hinweist, dass Sie den vorab erstellten Rollennamen angeben müssen. Role.customizeRoles() Im Folgenden finden Sie ein Beispiel für den generierten Bericht:

<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)/*"
    ]
  }
]

Sobald die Rolle erstellt wurde, können Sie sie an Ihre Anwendung für die Ressource übergeben, für die sie gilt. Wenn der Name der Rolle, für die erstellt wurde, beispielsweise LambdaStack/Handler/ServiceRole lautetlambda-service-role, würden Sie Ihre CDK-App wie folgt aktualisieren:
```
const stack = new Stack(app, 'LambdaStack');

// Add this to pass in the role
iam.Role.customizeRoles(stack, {
  usePrecreatedRoles: {
    'LambdaStack/Handler/ServiceRole': 'lambda-service-role',
  },
});
```
Das CDK verwendet nun den vorab erstellten Rollennamen überall dort, wo in der CDK-Anwendung auf die Rolle verwiesen wird. Es wird den Bericht auch weiterhin erstellen, sodass auf future politische Änderungen verwiesen werden kann.

Sie werden feststellen, dass der Verweis auf den Amazon S3 S3-Bucket-ARN im Bericht als (LambdaStack/Bucket/Resource.Arn) gerendert wird und nicht als der tatsächliche ARN des Buckets. Dies liegt daran, dass der Bucket-ARN ein Bereitstellungszeitwert ist, der bei der Synthese nicht bekannt ist (der Bucket wurde noch nicht erstellt). Dies ist ein weiteres Beispiel dafür, warum wir empfehlen, CDK die Verwaltung von IAM-Rollen und -Berechtigungen mithilfe der bereitgestellten grant Methoden zu gestatten. Um die Rolle mit der ursprünglichen Richtlinie zu erstellen, muss der Administrator die Richtlinie mit umfassenderen Berechtigungen erstellen (z. B.arn:aws:s3:::*).