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. # Definieren Sie Berechtigungen für L2-Konstrukte mit dem CDK AWS Definieren Sie Rollen und Richtlinien für AWS Identity and Access Management (IAM) für L2-Konstrukte, wenn Sie das AWS Cloud Development Kit (AWS CDK) verwenden. ## 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. Das AWS CDK erstellt automatisch die IAM-Rollen, die für alle AWS Ressourcen benötigt werden, die sie benötigen. **Tipp** Grant-Methoden funktionieren über Grants-Klassen auch mit L1-Konstrukten. [Weitere Informationen finden Sie unter Fassaden.](facades.md) Im Folgenden finden Sie ein Beispiel, das Berechtigungen zwischen einer AWS Lambda-Funktion und einem Amazon Simple Storage Service (Amazon S3) -Bucket definiert. Hier wird die `grants.read` Methode des Bucket L2-Konstrukts verwendet, um diese Berechtigungen zu definieren: **Example** ``` 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 the read method from BucketGrants bucket.grants.read(handler); } } ``` ``` 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 read method from BucketGrants bucket.grants.read(handler); } } // ... ``` ``` 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 the read method from BucketGrants bucket.grants.read(handler) ``` ``` 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 the read method from BucketGrants bucket.getGrants().read(handler); } public static void main(final String[] args) { App app = new App(); new CdkDemoStack(app, "CdkDemoStack"); app.synth(); } } ``` ``` 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 the Read method from BucketGrants bucket.Grants.Read(handler); } } } ``` ``` 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.Grants().Read(handler) return stack } // ... ``` Wenn Sie Grant-Methoden von L2-Konstrukten verwenden, um Berechtigungen zwischen Ressourcen zu definieren, erstellt das AWS CDK Rollen mit Richtlinien mit den geringsten Rechten auf der Grundlage der von Ihnen angegebenen Methode. Aus Sicherheitsgründen empfehlen wir, dass Sie die Methode 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 `grants.read` Methode. `grants.readWrite` 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: **Example** ``` import { aws_iam as iam } from 'aws-cdk-lib'; handler.addToRolePolicy(new iam.PolicyStatement({ actions: ['s3:GetObject', 's3:List*'], resources: [ bucket.bucketArn, bucket.arnForObjects('*'), ] })); ``` ``` const iam = require('aws-cdk-lib/aws-iam'); handler.addToRolePolicy(new iam.PolicyStatement({ actions: ['s3:GetObject', 's3:List*'], resources: [ bucket.bucketArn, bucket.arnForObjects('*'), ] })); ``` ``` from aws_cdk import aws_iam as iam handler.add_to_role_policy(iam.PolicyStatement( actions=['s3:GetObject', 's3:List*'], resources=[ bucket.bucket_arn, bucket.arn_for_objects('*'), ] )) ``` ``` import software.amazon.awscdk.services.iam.PolicyStatement; import software.amazon.awscdk.services.iam.PolicyStatementProps; handler.addToRolePolicy(PolicyStatement.Builder.create() .actions(Arrays.asList("s3:GetObject", "s3:List*")) .resources(Arrays.asList( bucket.getBucketArn(), bucket.arnForObjects("*") )) .build()); ``` ``` using Amazon.CDK.AWS.IAM; using Amazon.CDK.AWS.S3; using Amazon.CDK.AWS.Lambda; handler.AddToRolePolicy(new PolicyStatement(new PolicyStatementProps { Actions = new[] { "s3:GetObject", "s3:List*" }, Resources = new[] { bucket.BucketArn, bucket.ArnForObjects("*") } })); ``` ``` package main import ( // ... "github.com/aws/aws-cdk-go/awscdk/v2/awsiam" // ... ) // ... func NewCdkDemoStack(scope constructs.Construct, id string, props *CdkDemoStackProps) awscdk.Stack { // ... handler.AddToRolePolicy(awsiam.NewPolicyStatement(&awsiam.PolicyStatementProps{ Actions: jsii.Strings("s3:GetObject", "s3:List*"), Resources: jsii.Strings(bucket.BucketArn(), bucket.ArnForObjects("*")), })) // ... } ``` Wir empfehlen jedoch, die Methoden in der `grants` Eigenschaft zu verwenden, sofern verfügbar. ## 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 der AWS Management Console, AWS CLI oder AWS SDKs erstellen. 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** 1. Verwenden Sie diese `Role.fromRoleName()` Option, 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 }) ``` 1. 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 AWS CDK-Funktion *zur 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** 1. 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 grants.read() is still important. Even though it actually doesn't mutate // any policies, it indicates the need for them. bucket.grants.read(handler); ``` 1. 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: ``` (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)/*" ] } ] ``` 1. 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` lautet`lambda-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:::*`).