Sélectionner vos préférences de cookies

Nous utilisons des cookies essentiels et des outils similaires qui sont nécessaires au fonctionnement de notre site et à la fourniture de nos services. Nous utilisons des cookies de performance pour collecter des statistiques anonymes afin de comprendre comment les clients utilisent notre site et d’apporter des améliorations. Les cookies essentiels ne peuvent pas être désactivés, mais vous pouvez cliquer sur « Personnaliser » ou « Refuser » pour refuser les cookies de performance.

Si vous êtes d’accord, AWS et les tiers approuvés utiliseront également des cookies pour fournir des fonctionnalités utiles au site, mémoriser vos préférences et afficher du contenu pertinent, y compris des publicités pertinentes. Pour accepter ou refuser tous les cookies non essentiels, cliquez sur « Accepter » ou « Refuser ». Pour effectuer des choix plus détaillés, cliquez sur « Personnaliser ».

Les ressources et le AWS CDK

Mode de mise au point
Les ressources et le AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

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.

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.

Les ressources sont celles que vous configurez pour être utilisées Services AWS dans vos applications. Les ressources sont une fonctionnalité de AWS CloudFormation. En configurant les ressources et leurs propriétés dans un AWS CloudFormation modèle, vous pouvez les déployer AWS CloudFormation pour provisionner vos ressources. Avec le AWS Cloud Development Kit (AWS CDK), vous pouvez configurer les ressources par le biais de constructions. Vous déployez ensuite votre application CDK, ce qui implique de synthétiser un AWS CloudFormation modèle et de le déployer pour AWS CloudFormation provisionner vos ressources.

Configuration des ressources à l'aide de constructions

Comme décrit dansAWS CDK Constructions, il AWS CDK fournit une riche bibliothèque de classes de constructions, appelées AWS constructions, qui représentent toutes les AWS ressources.

Pour créer une instance d'une ressource à l'aide de la structure correspondante, transmettez le scope comme premier argument, l'ID logique de la construction et un ensemble de propriétés de configuration (accessoires). Par exemple, voici comment créer une file d'attente Amazon SQS AWS KMS chiffrée à l'aide de la construction SQS.Queue de la bibliothèque Construct. AWS

TypeScript
import * as sqs from '@aws-cdk/aws-sqs'; new sqs.Queue(this, 'MyQueue', { encryption: sqs.QueueEncryption.KMS_MANAGED });
JavaScript
const sqs = require('@aws-cdk/aws-sqs'); new sqs.Queue(this, 'MyQueue', { encryption: sqs.QueueEncryption.KMS_MANAGED });
Python
import aws_cdk.aws_sqs as sqs sqs.Queue(self, "MyQueue", encryption=sqs.QueueEncryption.KMS_MANAGED)
Java
import software.amazon.awscdk.services.sqs.*; Queue.Builder.create(this, "MyQueue").encryption( QueueEncryption.KMS_MANAGED).build();
C#
using Amazon.CDK.AWS.SQS; new Queue(this, "MyQueue", new QueueProps { Encryption = QueueEncryption.KMS_MANAGED });
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs" ) sqs.NewQueue(stack, jsii.String("MyQueue"), &sqs.QueueProps{ Encryption: sqs.QueueEncryption_KMS_MANAGED, })
import * as sqs from '@aws-cdk/aws-sqs'; new sqs.Queue(this, 'MyQueue', { encryption: sqs.QueueEncryption.KMS_MANAGED });

Certains accessoires de configuration sont facultatifs et, dans de nombreux cas, ont des valeurs par défaut. Dans certains cas, tous les accessoires sont facultatifs et le dernier argument peut être totalement omis.

Attributs de ressource

La plupart des ressources de la bibliothèque AWS Construct exposent des attributs, qui sont résolus au moment du déploiement par AWS CloudFormation. Les attributs sont exposés sous forme de propriétés sur les classes de ressources avec le nom du type comme préfixe. L'exemple suivant montre comment obtenir l'URL d'une file d'attente Amazon SQS à l'aide de la propriété (queueUrlPython :queue_url).

TypeScript
import * as sqs from '@aws-cdk/aws-sqs'; const queue = new sqs.Queue(this, 'MyQueue'); const url = queue.queueUrl; // => A string representing a deploy-time value
JavaScript
const sqs = require('@aws-cdk/aws-sqs'); const queue = new sqs.Queue(this, 'MyQueue'); const url = queue.queueUrl; // => A string representing a deploy-time value
Python
import aws_cdk.aws_sqs as sqs queue = sqs.Queue(self, "MyQueue") url = queue.queue_url # => A string representing a deploy-time value
Java
Queue queue = new Queue(this, "MyQueue"); String url = queue.getQueueUrl(); // => A string representing a deploy-time value
C#
var queue = new Queue(this, "MyQueue"); var url = queue.QueueUrl; // => A string representing a deploy-time value
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs" ) queue := sqs.NewQueue(stack, jsii.String("MyQueue"), &sqs.QueueProps{}) url := queue.QueueUrl() // => A string representing a deploy-time value
import * as sqs from '@aws-cdk/aws-sqs'; const queue = new sqs.Queue(this, 'MyQueue'); const url = queue.queueUrl; // => A string representing a deploy-time value

Consultez Les jetons et le AWS CDK pour plus d'informations sur la façon dont les attributs du AWS CDK moment du déploiement sont codés sous forme de chaînes.

Ressources de référencement

Lorsque vous configurez des ressources, vous devez souvent référencer les propriétés d'une autre ressource. Voici quelques exemples :

  • Une ressource Amazon Elastic Container Service (Amazon ECS) nécessite une référence au cluster sur lequel elle s'exécute.

  • Une CloudFront distribution Amazon nécessite une référence au bucket Amazon Simple Storage Service (Amazon S3) contenant le code source.

Vous pouvez référencer les ressources de l'une des manières suivantes :

  • En transmettant une ressource définie dans votre application CDK, soit dans la même pile, soit dans une autre

  • En transmettant un objet proxy faisant référence à une ressource définie dans votre AWS compte, créé à partir d'un identifiant unique de la ressource (tel qu'un ARN)

Si la propriété d'une construction représente une construction pour une autre ressource, son type est celui du type d'interface de la construction. Par exemple, la construction Amazon ECS utilise une propriété cluster de typeecs.ICluster. Un autre exemple est la construction de CloudFront distribution qui prend une propriété sourceBucket (Python :source_bucket) de types3.IBucket.

Vous pouvez transmettre directement n'importe quel objet de ressource du type approprié défini dans la même AWS CDK application. L'exemple suivant définit un cluster Amazon ECS, puis l'utilise pour définir un service Amazon ECS.

TypeScript
const cluster = new ecs.Cluster(this, 'Cluster', { /*...*/ }); const service = new ecs.Ec2Service(this, 'Service', { cluster: cluster });
JavaScript
const cluster = new ecs.Cluster(this, 'Cluster', { /*...*/ }); const service = new ecs.Ec2Service(this, 'Service', { cluster: cluster });
Python
cluster = ecs.Cluster(self, "Cluster") service = ecs.Ec2Service(self, "Service", cluster=cluster)
Java
Cluster cluster = new Cluster(this, "Cluster"); Ec2Service service = new Ec2Service(this, "Service", new Ec2ServiceProps.Builder().cluster(cluster).build());
C#
var cluster = new Cluster(this, "Cluster"); var service = new Ec2Service(this, "Service", new Ec2ServiceProps { Cluster = cluster });
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" ecs "github.com/aws/aws-cdk-go/awscdk/v2/awsecs" ) cluster := ecs.NewCluster(stack, jsii.String("MyCluster"), &ecs.ClusterProps{}) service := ecs.NewEc2Service(stack, jsii.String("MyService"), &ecs.Ec2ServiceProps{ Cluster: cluster, })
const cluster = new ecs.Cluster(this, 'Cluster', { /*...*/ }); const service = new ecs.Ec2Service(this, 'Service', { cluster: cluster });

Référencement de ressources dans une pile différente

Vous pouvez faire référence aux ressources d'une pile différente à condition qu'elles soient définies dans la même application et qu'elles se trouvent dans le même AWS environnement. Le schéma suivant est généralement utilisé :

  • Stockez une référence à la construction en tant qu'attribut de la pile qui produit la ressource. (Pour obtenir une référence à la pile de la construction actuelle, utilisezStack.of(this).)

  • Transmettez cette référence au constructeur de la pile qui consomme la ressource en tant que paramètre ou propriété. La pile consommatrice la transmet ensuite en tant que propriété à toute construction qui en a besoin.

L'exemple suivant définit une pilestack1. Cette pile définit un compartiment Amazon S3 et stocke une référence à la structure du compartiment en tant qu'attribut de la pile. Ensuite, l'application définit une deuxième pilestack2, qui accepte un bucket lors de l'instanciation. stack2peut, par exemple, définir une AWS Glue table qui utilise le bucket pour le stockage des données.

TypeScript
const prod = { account: '123456789012', region: 'us-east-1' }; const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod }); // stack2 will take a property { bucket: IBucket } const stack2 = new StackThatExpectsABucket(app, 'Stack2', { bucket: stack1.bucket, env: prod });
JavaScript
const prod = { account: '123456789012', region: 'us-east-1' }; const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod }); // stack2 will take a property { bucket: IBucket } const stack2 = new StackThatExpectsABucket(app, 'Stack2', { bucket: stack1.bucket, env: prod });
Python
prod = core.Environment(account="123456789012", region="us-east-1") stack1 = StackThatProvidesABucket(app, "Stack1", env=prod) # stack2 will take a property "bucket" stack2 = StackThatExpectsABucket(app, "Stack2", bucket=stack1.bucket, env=prod)
Java
// Helper method to build an environment static Environment makeEnv(String account, String region) { return Environment.builder().account(account).region(region) .build(); } App app = new App(); Environment prod = makeEnv("123456789012", "us-east-1"); StackThatProvidesABucket stack1 = new StackThatProvidesABucket(app, "Stack1", StackProps.builder().env(prod).build()); // stack2 will take an argument "bucket" StackThatExpectsABucket stack2 = new StackThatExpectsABucket(app, "Stack,", StackProps.builder().env(prod).build(), stack1.bucket);
C#
Amazon.CDK.Environment makeEnv(string account, string region) { return new Amazon.CDK.Environment { Account = account, Region = region }; } var prod = makeEnv(account: "123456789012", region: "us-east-1"); var stack1 = new StackThatProvidesABucket(app, "Stack1", new StackProps { Env = prod }); // stack2 will take a property "bucket" var stack2 = new StackThatExpectsABucket(app, "Stack2", new StackProps { Env = prod, bucket = stack1.Bucket});
const prod = { account: '123456789012', region: 'us-east-1' }; const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod }); // stack2 will take a property { bucket: IBucket } const stack2 = new StackThatExpectsABucket(app, 'Stack2', { bucket: stack1.bucket, env: prod });

Si le AWS CDK détermine que la ressource se trouve dans le même environnement, mais dans une pile différente, il synthétise automatiquement les AWS CloudFormation exportations dans la pile productrice et un Fn : : ImportValue dans la pile consommatrice pour transférer ces informations d'une pile à l'autre.

Résoudre les blocages de dépendance

Le fait de référencer une ressource d'une pile dans une pile différente crée une dépendance entre les deux piles. Cela permet de s'assurer qu'ils sont déployés dans le bon ordre. Une fois les piles déployées, cette dépendance est concrète. Ensuite, la suppression de l'utilisation de la ressource partagée de la pile consommatrice peut entraîner un échec de déploiement inattendu. Cela se produit s'il existe une autre dépendance entre les deux piles qui les oblige à être déployées dans le même ordre. Cela peut également se produire sans dépendance si la pile productrice est simplement choisie par le CDK Toolkit pour être déployée en premier. L' AWS CloudFormation exportation est supprimée de la pile productrice car elle n'est plus nécessaire, mais la ressource exportée est toujours utilisée dans la pile consommatrice car sa mise à jour n'est pas encore déployée. Par conséquent, le déploiement de la pile de producteurs échoue.

Pour sortir de cette impasse, supprimez l'utilisation de la ressource partagée de la pile consommatrice. (Cela supprime l'exportation automatique de la pile de production.) Ajoutez ensuite manuellement la même exportation à la pile de production en utilisant exactement le même identifiant logique que l'exportation générée automatiquement. Supprimez l'utilisation de la ressource partagée dans la pile consommatrice et déployez les deux piles. Supprimez ensuite l'exportation manuelle (et la ressource partagée si elle n'est plus nécessaire) et déployez à nouveau les deux piles. La exportValue() méthode de la pile est un moyen pratique de créer l'exportation manuelle à cette fin. (Voir l'exemple dans la référence de méthode liée.)

Référencement des ressources de votre compte AWS

Supposons que vous souhaitiez utiliser une ressource déjà disponible dans votre AWS compte dans votre AWS CDK application. Il peut s'agir d'une ressource définie via la console, un AWS SDK, directement avec AWS CloudFormation ou dans une autre AWS CDK application. Vous pouvez transformer l'ARN de la ressource (ou un autre attribut d'identification, ou groupe d'attributs) en un objet proxy. L'objet proxy sert de référence à la ressource en appelant une méthode d'usine statique sur la classe de la ressource.

Lorsque vous créez un tel proxy, la ressource externe ne fait pas partie de votre AWS CDK application. Par conséquent, les modifications que vous apportez au proxy dans votre AWS CDK application n'affectent pas la ressource déployée. Le proxy peut toutefois être transmis à n'importe quelle AWS CDK méthode nécessitant une ressource de ce type.

L'exemple suivant montre comment référencer un bucket basé sur un bucket existant avec l'ARN arn:aws:s3 : ::amzn-s3-demo-bucket1, et un Amazon Virtual Private Cloud basé sur un VPC existant ayant un ID spécifique.

TypeScript
// Construct a proxy for a bucket by its name (must be same account) s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1'); // Construct a proxy for a bucket by its full ARN (can be another account) s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1'); // Construct a proxy for an existing VPC from its attribute(s) ec2.Vpc.fromVpcAttributes(this, 'MyVpc', { vpcId: 'vpc-1234567890abcde', });
JavaScript
// Construct a proxy for a bucket by its name (must be same account) s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1'); // Construct a proxy for a bucket by its full ARN (can be another account) s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1'); // Construct a proxy for an existing VPC from its attribute(s) ec2.Vpc.fromVpcAttributes(this, 'MyVpc', { vpcId: 'vpc-1234567890abcde' });
Python
# Construct a proxy for a bucket by its name (must be same account) s3.Bucket.from_bucket_name(self, "MyBucket", "amzn-s3-demo-bucket1") # Construct a proxy for a bucket by its full ARN (can be another account) s3.Bucket.from_bucket_arn(self, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1") # Construct a proxy for an existing VPC from its attribute(s) ec2.Vpc.from_vpc_attributes(self, "MyVpc", vpc_id="vpc-1234567890abcdef")
Java
// Construct a proxy for a bucket by its name (must be same account) Bucket.fromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1"); // Construct a proxy for a bucket by its full ARN (can be another account) Bucket.fromBucketArn(this, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1"); // Construct a proxy for an existing VPC from its attribute(s) Vpc.fromVpcAttributes(this, "MyVpc", VpcAttributes.builder() .vpcId("vpc-1234567890abcdef").build());
C#
// Construct a proxy for a bucket by its name (must be same account) Bucket.FromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1"); // Construct a proxy for a bucket by its full ARN (can be another account) Bucket.FromBucketArn(this, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1"); // Construct a proxy for an existing VPC from its attribute(s) Vpc.FromVpcAttributes(this, "MyVpc", new VpcAttributes { VpcId = "vpc-1234567890abcdef" });
Go
// Define a proxy for a bucket by its name (must be same account) s3.Bucket_FromBucketName(stack, jsii.String("MyBucket"), jsii.String("amzn-s3-demo-bucket1")) // Define a proxy for a bucket by its full ARN (can be another account) s3.Bucket_FromBucketArn(stack, jsii.String("MyBucket"), jsii.String("arn:aws:s3:::amzn-s3-demo-bucket1")) // Define a proxy for an existing VPC from its attributes ec2.Vpc_FromVpcAttributes(stack, jsii.String("MyVpc"), &ec2.VpcAttributes{ VpcId: jsii.String("vpc-1234567890abcde"), })
// Construct a proxy for a bucket by its name (must be same account) s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1'); // Construct a proxy for a bucket by its full ARN (can be another account) s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1'); // Construct a proxy for an existing VPC from its attribute(s) ec2.Vpc.fromVpcAttributes(this, 'MyVpc', { vpcId: 'vpc-1234567890abcde', });

Regardons de plus près la Vpc.fromLookup()méthode. La ec2.Vpc construction étant complexe, vous pouvez sélectionner le VPC à utiliser avec votre application CDK de nombreuses manières. Pour résoudre ce problème, la construction VPC utilise une méthode fromLookup statique (Python :from_lookup) qui vous permet de rechercher le VPC Amazon souhaité en interrogeant votre AWS compte au moment de la synthèse.

Pour être utiliséVpc.fromLookup(), le système qui synthétise la pile doit avoir accès au compte propriétaire de l'Amazon VPC. Cela est dû au fait que le CDK Toolkit interroge le compte pour trouver le bon Amazon VPC au moment de la synthèse.

De plus, ne Vpc.fromLookup() fonctionne que dans les piles définies avec un compte et une région explicites (voirEnvironnements pour le AWS CDK). S'il AWS CDK essaie de rechercher un Amazon VPC à partir d'une pile indépendante de l'environnement, le CDK Toolkit ne sait pas quel environnement interroger pour trouver le VPC.

Vous devez fournir des Vpc.fromLookup() attributs suffisants pour identifier de manière unique un VPC dans votre AWS compte. Par exemple, il ne peut y avoir qu'un seul VPC par défaut, il suffit donc de spécifier le VPC comme VPC par défaut.

TypeScript
ec2.Vpc.fromLookup(this, 'DefaultVpc', { isDefault: true });
JavaScript
ec2.Vpc.fromLookup(this, 'DefaultVpc', { isDefault: true });
Python
ec2.Vpc.from_lookup(self, "DefaultVpc", is_default=True)
Java
Vpc.fromLookup(this, "DefaultVpc", VpcLookupOptions.builder() .isDefault(true).build());
C#
Vpc.FromLookup(this, id = "DefaultVpc", new VpcLookupOptions { IsDefault = true });
Go
ec2.Vpc_FromLookup(this, jsii.String("DefaultVpc"), &ec2.VpcLookupOptions{ IsDefault: jsii.Bool(true), })
ec2.Vpc.fromLookup(this, 'DefaultVpc', { isDefault: true });

Vous pouvez également utiliser la tags propriété pour effectuer une recherche VPCs par balise. Vous pouvez ajouter des balises à l'Amazon VPC au moment de sa création en utilisant AWS CloudFormation ou le. AWS CDK Vous pouvez modifier les balises à tout moment après leur création à l'aide du SDK AWS Management Console AWS CLI, du ou d'un AWS SDK. En plus des balises que vous ajoutez vous-même, les balises suivantes AWS CDK sont automatiquement ajoutées à toutes les VPCs balises créées.

  • Nom — Le nom du VPC.

  • aws-cdk:subnet-name — Nom du sous-réseau.

  • aws-cdk:subnet-type — Type du sous-réseau : public, privé ou isolé.

TypeScript
ec2.Vpc.fromLookup(this, 'PublicVpc', {tags: {'aws-cdk:subnet-type': "Public"}});
JavaScript
ec2.Vpc.fromLookup(this, 'PublicVpc', {tags: {'aws-cdk:subnet-type': "Public"}});
Python
ec2.Vpc.from_lookup(self, "PublicVpc", tags={"aws-cdk:subnet-type": "Public"})
Java
Vpc.fromLookup(this, "PublicVpc", VpcLookupOptions.builder() .tags(java.util.Map.of("aws-cdk:subnet-type", "Public")) // Java 9 or later .build());
C#
Vpc.FromLookup(this, id = "PublicVpc", new VpcLookupOptions { Tags = new Dictionary<string, string> { ["aws-cdk:subnet-type"] = "Public" });
Go
ec2.Vpc_FromLookup(this, jsii.String("DefaultVpc"), &ec2.VpcLookupOptions{ Tags: &map[string]*string{"aws-cdk:subnet-type": jsii.String("Public")}, })
ec2.Vpc.fromLookup(this, 'PublicVpc', {tags: {'aws-cdk:subnet-type': "Public"}});

Les résultats de Vpc.fromLookup() sont mis en cache dans le cdk.context.json fichier du projet. (Consultez Les valeurs contextuelles et le AWS CDK.) Passez ce fichier au contrôle de version afin que votre application continue de faire référence au même Amazon VPC. Cela fonctionne même si vous modifiez ultérieurement les attributs de votre VPCs VPC de manière à sélectionner un autre VPC. Cela est particulièrement important si vous déployez la pile dans un environnement qui n'a pas accès au AWS compte qui définit le VPC, tel que CDK Pipelines.

Bien que vous puissiez utiliser une ressource externe partout où vous utiliseriez une ressource similaire définie dans votre AWS CDK application, vous ne pouvez pas la modifier. Par exemple, appeler addToResourcePolicy (Python :add_to_resource_policy) sur un appareil externe s3.Bucket ne fait rien.

Noms physiques des ressources

Les noms logiques des ressources dans AWS CloudFormation sont différents des noms des ressources qui apparaissent AWS Management Console après leur déploiement par AWS CloudFormation. Les AWS CDK appels, ces derniers nomment des noms physiques.

Par exemple, AWS CloudFormation vous pouvez créer le compartiment Amazon S3 avec l'ID logique Stack2MyBucket4DD88B4F et le nom physiquestack2MyBucket4dd88b4f-iuv1rbv9z3to.

Vous pouvez spécifier un nom physique lors de la création de constructions représentant des ressources à l'aide de la propriété <resourceType> Name. L'exemple suivant crée un compartiment Amazon S3 avec le nom physiqueamzn-s3-demo-bucket.

TypeScript
const bucket = new s3.Bucket(this, 'MyBucket', { bucketName: 'amzn-s3-demo-bucket', });
JavaScript
const bucket = new s3.Bucket(this, 'MyBucket', { bucketName: 'amzn-s3-demo-bucket' });
Python
bucket = s3.Bucket(self, "MyBucket", bucket_name="amzn-s3-demo-bucket")
Java
Bucket bucket = Bucket.Builder.create(this, "MyBucket") .bucketName("amzn-s3-demo-bucket").build();
C#
var bucket = new Bucket(this, "MyBucket", new BucketProps { BucketName = "amzn-s3-demo-bucket" });
Go
bucket := s3.NewBucket(this, jsii.String("MyBucket"), &s3.BucketProps{ BucketName: jsii.String("amzn-s3-demo-bucket"), })
const bucket = new s3.Bucket(this, 'MyBucket', { bucketName: 'amzn-s3-demo-bucket', });

L'attribution de noms physiques aux ressources présente certains inconvénients. AWS CloudFormation Plus important encore, toute modification des ressources déployées nécessitant le remplacement d'une ressource, telle que la modification des propriétés d'une ressource qui sont immuables après sa création, échouera si un nom physique est attribué à une ressource. Si vous vous retrouvez dans cet état, la seule solution est de supprimer la AWS CloudFormation pile, puis de déployer à nouveau l' AWS CDK application. Consultez la AWS CloudFormation documentation pour plus de détails.

Dans certains cas, par exemple lors de la création d'une AWS CDK application avec des références interenvironnementales, des noms physiques sont nécessaires pour AWS CDK qu'elle fonctionne correctement. Dans ces cas, si vous ne voulez pas vous embêter à trouver vous-même un nom physique, vous pouvez laisser le AWS CDK nom pour vous. Pour ce faire, utilisez la valeur spécialePhysicalName.GENERATE_IF_NEEDED, comme suit.

TypeScript
const bucket = new s3.Bucket(this, 'MyBucket', { bucketName: core.PhysicalName.GENERATE_IF_NEEDED, });
JavaScript
const bucket = new s3.Bucket(this, 'MyBucket', { bucketName: core.PhysicalName.GENERATE_IF_NEEDED });
Python
bucket = s3.Bucket(self, "MyBucket", bucket_name=core.PhysicalName.GENERATE_IF_NEEDED)
Java
Bucket bucket = Bucket.Builder.create(this, "MyBucket") .bucketName(PhysicalName.GENERATE_IF_NEEDED).build();
C#
var bucket = new Bucket(this, "MyBucket", new BucketProps { BucketName = PhysicalName.GENERATE_IF_NEEDED });
Go
bucket := s3.NewBucket(this, jsii.String("MyBucket"), &s3.BucketProps{ BucketName: awscdk.PhysicalName_GENERATE_IF_NEEDED(), })
const bucket = new s3.Bucket(this, 'MyBucket', { bucketName: core.PhysicalName.GENERATE_IF_NEEDED, });

Transmission d'identifiants de ressources uniques

Dans la mesure du possible, vous devez transmettre les ressources par référence, comme décrit dans la section précédente. Cependant, dans certains cas, vous n'avez pas d'autre choix que de faire référence à une ressource par l'un de ses attributs. Les exemples de cas d'utilisation incluent les suivants :

  • Lorsque vous utilisez des AWS CloudFormation ressources de bas niveau.

  • Lorsque vous devez exposer des ressources aux composants d'exécution d'une AWS CDK application, par exemple lorsque vous faites référence à des fonctions Lambda par le biais de variables d'environnement.

Ces identifiants sont disponibles sous forme d'attributs sur les ressources, tels que les suivants.

TypeScript
bucket.bucketName lambdaFunc.functionArn securityGroup.groupArn
JavaScript
bucket.bucketName lambdaFunc.functionArn securityGroup.groupArn
Python
bucket.bucket_name lambda_func.function_arn security_group_arn
Java

La AWS CDK liaison Java utilise des méthodes getter pour les attributs.

bucket.getBucketName() lambdaFunc.getFunctionArn() securityGroup.getGroupArn()
C#
bucket.BucketName lambdaFunc.FunctionArn securityGroup.GroupArn
Go
bucket.BucketName() fn.FunctionArn()
bucket.bucketName lambdaFunc.functionArn securityGroup.groupArn

L'exemple suivant montre comment transmettre le nom d'un bucket généré à une AWS Lambda fonction.

TypeScript
const bucket = new s3.Bucket(this, 'Bucket'); new lambda.Function(this, 'MyLambda', { // ... environment: { BUCKET_NAME: bucket.bucketName, }, });
JavaScript
const bucket = new s3.Bucket(this, 'Bucket'); new lambda.Function(this, 'MyLambda', { // ... environment: { BUCKET_NAME: bucket.bucketName } });
Python
bucket = s3.Bucket(self, "Bucket") lambda.Function(self, "MyLambda", environment=dict(BUCKET_NAME=bucket.bucket_name))
Java
final Bucket bucket = new Bucket(this, "Bucket"); Function.Builder.create(this, "MyLambda") .environment(java.util.Map.of( // Java 9 or later "BUCKET_NAME", bucket.getBucketName())) .build();
C#
var bucket = new Bucket(this, "Bucket"); new Function(this, "MyLambda", new FunctionProps { Environment = new Dictionary<string, string> { ["BUCKET_NAME"] = bucket.BucketName } });
Go
bucket := s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{}) lambda.NewFunction(this, jsii.String("MyLambda"), &lambda.FunctionProps{ Environment: &map[string]*string{"BUCKET_NAME": bucket.BucketName()}, })
const bucket = new s3.Bucket(this, 'Bucket'); new lambda.Function(this, 'MyLambda', { // ... environment: { BUCKET_NAME: bucket.bucketName, }, });

Octroi d'autorisations entre les ressources

Les constructions de niveau supérieur permettent d'obtenir des autorisations avec le moindre privilège en proposant des exigences d'autorisation simples, basées sur l'intention ou explicites. APIs Par exemple, de nombreuses constructions L2 proposent des méthodes d'octroi que vous pouvez utiliser pour accorder à une entité (telle qu'un rôle ou un utilisateur IAM) l'autorisation d'utiliser la ressource, sans avoir à créer manuellement des déclarations d'autorisation IAM.

L'exemple suivant crée les autorisations permettant au rôle d'exécution d'une fonction Lambda de lire et d'écrire des objets dans un compartiment Amazon S3 particulier. Si le compartiment Amazon S3 est chiffré à l'aide d'une AWS KMS clé, cette méthode autorise également le rôle d'exécution de la fonction Lambda à déchiffrer avec la clé.

TypeScript
if (bucket.grantReadWrite(func).success) { // ... }
JavaScript
if ( bucket.grantReadWrite(func).success) { // ... }
Python
if bucket.grant_read_write(func).success: # ...
Java
if (bucket.grantReadWrite(func).getSuccess()) { // ... }
C#
if (bucket.GrantReadWrite(func).Success) { // ... }
Go
if *bucket.GrantReadWrite(function, nil).Success() { // ... }
if (bucket.grantReadWrite(func).success) { // ... }

Les méthodes de subvention renvoient un iam.Grant objet. Utilisez l'successattribut de l'Grantobjet pour déterminer si la subvention a été appliquée efficacement (par exemple, elle n'a peut-être pas été appliquée à des ressources externes). Vous pouvez également utiliser la méthode assertSuccess (Python :assert_success) de l'Grantobjet pour vérifier que la subvention a été correctement appliquée.

Si aucune méthode d'autorisation spécifique n'est disponible pour le cas d'utilisation en question, vous pouvez utiliser une méthode d'autorisation générique pour définir une nouvelle autorisation avec une liste d'actions spécifiée.

L'exemple suivant montre comment accorder à une fonction Lambda l'accès à l'action Amazon DynamoDB. CreateBackup

TypeScript
table.grant(func, 'dynamodb:CreateBackup');
JavaScript
table.grant(func, 'dynamodb:CreateBackup');
Python
table.grant(func, "dynamodb:CreateBackup")
Java
table.grant(func, "dynamodb:CreateBackup");
C#
table.Grant(func, "dynamodb:CreateBackup");
Go
table := dynamodb.NewTable(this, jsii.String("MyTable"), &dynamodb.TableProps{}) table.Grant(function, jsii.String("dynamodb:CreateBackup"))
table.grant(func, 'dynamodb:CreateBackup');

De nombreuses ressources, telles que les fonctions Lambda, nécessitent qu'un rôle soit assumé lors de l'exécution du code. Une propriété de configuration vous permet de spécifier uniam.IRole. Si aucun rôle n'est spécifié, la fonction crée automatiquement un rôle spécifiquement pour cet usage. Vous pouvez ensuite utiliser des méthodes d'attribution sur les ressources pour ajouter des instructions au rôle.

Les méthodes de subvention sont conçues à l'aide d'un niveau inférieur APIs pour la gestion des politiques IAM. Les politiques sont modélisées sous forme d'PolicyDocumentobjets. Ajoutez des instructions directement aux rôles (ou au rôle attaché à une construction) à l'aide de la addToRolePolicy méthode (Python :add_to_role_policy), ou à la politique d'une ressource (telle qu'une Bucket politique) à l'aide de la méthode addToResourcePolicy (Python :add_to_resource_policy).

Indicateurs de ressources et alarmes

De nombreuses ressources émettent CloudWatch des métriques qui peuvent être utilisées pour configurer des tableaux de bord de surveillance et des alarmes. Les constructions de niveau supérieur utilisent des méthodes métriques qui vous permettent d'accéder aux métriques sans rechercher le nom correct à utiliser.

L'exemple suivant montre comment définir une alarme lorsque le nombre d'une file ApproximateNumberOfMessagesNotVisible d'attente Amazon SQS dépasse 100.

TypeScript
import * as cw from '@aws-cdk/aws-cloudwatch'; import * as sqs from '@aws-cdk/aws-sqs'; import { Duration } from '@aws-cdk/core'; const queue = new sqs.Queue(this, 'MyQueue'); const metric = queue.metricApproximateNumberOfMessagesNotVisible({ label: 'Messages Visible (Approx)', period: Duration.minutes(5), // ... }); metric.createAlarm(this, 'TooManyMessagesAlarm', { comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD, threshold: 100, // ... });
JavaScript
const cw = require('@aws-cdk/aws-cloudwatch'); const sqs = require('@aws-cdk/aws-sqs'); const { Duration } = require('@aws-cdk/core'); const queue = new sqs.Queue(this, 'MyQueue'); const metric = queue.metricApproximateNumberOfMessagesNotVisible({ label: 'Messages Visible (Approx)', period: Duration.minutes(5) // ... }); metric.createAlarm(this, 'TooManyMessagesAlarm', { comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD, threshold: 100 // ... });
Python
import aws_cdk.aws_cloudwatch as cw import aws_cdk.aws_sqs as sqs from aws_cdk.core import Duration queue = sqs.Queue(self, "MyQueue") metric = queue.metric_approximate_number_of_messages_not_visible( label="Messages Visible (Approx)", period=Duration.minutes(5), # ... ) metric.create_alarm(self, "TooManyMessagesAlarm", comparison_operator=cw.ComparisonOperator.GREATER_THAN_THRESHOLD, threshold=100, # ... )
Java
import software.amazon.awscdk.core.Duration; import software.amazon.awscdk.services.sqs.Queue; import software.amazon.awscdk.services.cloudwatch.Metric; import software.amazon.awscdk.services.cloudwatch.MetricOptions; import software.amazon.awscdk.services.cloudwatch.CreateAlarmOptions; import software.amazon.awscdk.services.cloudwatch.ComparisonOperator; Queue queue = new Queue(this, "MyQueue"); Metric metric = queue .metricApproximateNumberOfMessagesNotVisible(MetricOptions.builder() .label("Messages Visible (Approx)") .period(Duration.minutes(5)).build()); metric.createAlarm(this, "TooManyMessagesAlarm", CreateAlarmOptions.builder() .comparisonOperator(ComparisonOperator.GREATER_THAN_THRESHOLD) .threshold(100) // ... .build());
C#
using cdk = Amazon.CDK; using cw = Amazon.CDK.AWS.CloudWatch; using sqs = Amazon.CDK.AWS.SQS; var queue = new sqs.Queue(this, "MyQueue"); var metric = queue.MetricApproximateNumberOfMessagesNotVisible(new cw.MetricOptions { Label = "Messages Visible (Approx)", Period = cdk.Duration.Minutes(5), // ... }); metric.CreateAlarm(this, "TooManyMessagesAlarm", new cw.CreateAlarmOptions { ComparisonOperator = cw.ComparisonOperator.GREATER_THAN_THRESHOLD, Threshold = 100, // .. });
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" cw "github.com/aws/aws-cdk-go/awscdk/v2/awscloudwatch" sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs" ) queue := sqs.NewQueue(this, jsii.String("MyQueue"), &sqs.QueueProps{}) metric := queue.MetricApproximateNumberOfMessagesNotVisible(&cw.MetricOptions{ Label: jsii.String("Messages Visible (Approx)"), Period: awscdk.Duration_Minutes(jsii.Number(5)), }) metric.CreateAlarm(this, jsii.String("TooManyMessagesAlarm"), &cw.CreateAlarmOptions{ ComparisonOperator: cw.ComparisonOperator_GREATER_THAN_THRESHOLD, Threshold: jsii.Number(100), })
import * as cw from '@aws-cdk/aws-cloudwatch'; import * as sqs from '@aws-cdk/aws-sqs'; import { Duration } from '@aws-cdk/core'; const queue = new sqs.Queue(this, 'MyQueue'); const metric = queue.metricApproximateNumberOfMessagesNotVisible({ label: 'Messages Visible (Approx)', period: Duration.minutes(5), // ... }); metric.createAlarm(this, 'TooManyMessagesAlarm', { comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD, threshold: 100, // ... });

S'il n'existe aucune méthode pour une métrique particulière, vous pouvez utiliser la méthode métrique générale pour spécifier le nom de la métrique manuellement.

Les métriques peuvent également être ajoutées aux CloudWatch tableaux de bord. Consultez CloudWatch.

Trafic réseau

Dans de nombreux cas, vous devez activer les autorisations sur un réseau pour qu'une application fonctionne, par exemple lorsque l'infrastructure informatique doit accéder à la couche de persistance. Les ressources qui établissent ou écoutent les connexions exposent les méthodes qui permettent les flux de trafic, notamment la définition de règles de groupe de sécurité ou de réseau ACLs.

IConnectableles ressources ont une connections propriété qui constitue la passerelle vers la configuration des règles de trafic réseau.

Vous permettez aux données de circuler sur un chemin réseau donné à l'aide de allow méthodes. L'exemple suivant active les connexions HTTPS vers le Web et les connexions entrantes du groupe Amazon EC2 Auto Scalingfleet2.

TypeScript
import * as asg from '@aws-cdk/aws-autoscaling'; import * as ec2 from '@aws-cdk/aws-ec2'; const fleet1: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/); // Allow surfing the (secure) web fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 })); const fleet2: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/); fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());
JavaScript
const asg = require('@aws-cdk/aws-autoscaling'); const ec2 = require('@aws-cdk/aws-ec2'); const fleet1 = asg.AutoScalingGroup(); // Allow surfing the (secure) web fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 })); const fleet2 = asg.AutoScalingGroup(); fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());
Python
import aws_cdk.aws_autoscaling as asg import aws_cdk.aws_ec2 as ec2 fleet1 = asg.AutoScalingGroup( ... ) # Allow surfing the (secure) web fleet1.connections.allow_to(ec2.Peer.any_ipv4(), ec2.Port(PortProps(from_port=443, to_port=443))) fleet2 = asg.AutoScalingGroup( ... ) fleet1.connections.allow_from(fleet2, ec2.Port.all_traffic())
Java
import software.amazon.awscdk.services.autoscaling.AutoScalingGroup; import software.amazon.awscdk.services.ec2.Peer; import software.amazon.awscdk.services.ec2.Port; AutoScalingGroup fleet1 = AutoScalingGroup.Builder.create(this, "MyFleet") /* ... */.build(); // Allow surfing the (secure) Web fleet1.getConnections().allowTo(Peer.anyIpv4(), Port.Builder.create().fromPort(443).toPort(443).build()); AutoScalingGroup fleet2 = AutoScalingGroup.Builder.create(this, "MyFleet2") /* ... */.build(); fleet1.getConnections().allowFrom(fleet2, Port.allTraffic());
C#
using cdk = Amazon.CDK; using asg = Amazon.CDK.AWS.AutoScaling; using ec2 = Amazon.CDK.AWS.EC2; // Allow surfing the (secure) Web var fleet1 = new asg.AutoScalingGroup(this, "MyFleet", new asg.AutoScalingGroupProps { /* ... */ }); fleet1.Connections.AllowTo(ec2.Peer.AnyIpv4(), new ec2.Port(new ec2.PortProps { FromPort = 443, ToPort = 443 }); var fleet2 = new asg.AutoScalingGroup(this, "MyFleet2", new asg.AutoScalingGroupProps { /* ... */ }); fleet1.Connections.AllowFrom(fleet2, ec2.Port.AllTraffic());
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" autoscaling "github.com/aws/aws-cdk-go/awscdk/v2/awsautoscaling" ec2 "github.com/aws/aws-cdk-go/awscdk/v2/awsec2" ) fleet1 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet1"), &autoscaling.AutoScalingGroupProps{}) fleet1.Connections().AllowTo(ec2.Peer_AnyIpv4(),ec2.NewPort(&ec2.PortProps{ FromPort: jsii.Number(443), ToPort: jsii.Number(443) }),jsii.String("secure web")) fleet2 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet2"), &autoscaling.AutoScalingGroupProps{}) fleet1.Connections().AllowFrom(fleet2, ec2.Port_AllTraffic(),jsii.String("all traffic"))
import * as asg from '@aws-cdk/aws-autoscaling'; import * as ec2 from '@aws-cdk/aws-ec2'; const fleet1: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/); // Allow surfing the (secure) web fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 })); const fleet2: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/); fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());

Des ports par défaut sont associés à certaines ressources. Les exemples incluent l'écouteur d'un équilibreur de charge sur le port public et les ports sur lesquels le moteur de base de données accepte les connexions pour les instances d'une base de données Amazon RDS. Dans de tels cas, vous pouvez renforcer le contrôle du réseau sans avoir à spécifier manuellement le port. Pour ce faire, utilisez les allowToDefaultPort méthodes allowDefaultPortFrom et (Python :allow_default_port_from,allow_to_default_port).

L'exemple suivant montre comment activer les connexions depuis n'importe quelle IPV4 adresse et une connexion depuis un groupe Auto Scaling pour accéder à une base de données.

TypeScript
listener.connections.allowDefaultPortFromAnyIpv4('Allow public access'); fleet.connections.allowToDefaultPort(rdsDatabase, 'Fleet can access database');
JavaScript
listener.connections.allowDefaultPortFromAnyIpv4('Allow public access'); fleet.connections.allowToDefaultPort(rdsDatabase, 'Fleet can access database');
Python
listener.connections.allow_default_port_from_any_ipv4("Allow public access") fleet.connections.allow_to_default_port(rds_database, "Fleet can access database")
Java
listener.getConnections().allowDefaultPortFromAnyIpv4("Allow public access"); fleet.getConnections().AllowToDefaultPort(rdsDatabase, "Fleet can access database");
C#
listener.Connections.AllowDefaultPortFromAnyIpv4("Allow public access"); fleet.Connections.AllowToDefaultPort(rdsDatabase, "Fleet can access database");
Go
listener.Connections().AllowDefaultPortFromAnyIpv4(jsii.String("Allow public Access")) fleet.Connections().AllowToDefaultPort(rdsDatabase, jsii.String("Fleet can access database"))
listener.connections.allowDefaultPortFromAnyIpv4('Allow public access'); fleet.connections.allowToDefaultPort(rdsDatabase, 'Fleet can access database');

Gestion des événements

Certaines ressources peuvent servir de sources d'événements. Utilisez la addEventNotification méthode (Python :add_event_notification) pour enregistrer une cible d'événement pour un type d'événement particulier émis par la ressource. En outre, les addXxxNotification méthodes offrent un moyen simple d'enregistrer un gestionnaire pour les types d'événements courants.

L'exemple suivant montre comment déclencher une fonction Lambda lorsqu'un objet est ajouté à un compartiment Amazon S3.

TypeScript
import * as s3nots from '@aws-cdk/aws-s3-notifications'; const handler = new lambda.Function(this, 'Handler', { /*…*/ }); const bucket = new s3.Bucket(this, 'Bucket'); bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));
JavaScript
const s3nots = require('@aws-cdk/aws-s3-notifications'); const handler = new lambda.Function(this, 'Handler', { /*…*/ }); const bucket = new s3.Bucket(this, 'Bucket'); bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));
Python
import aws_cdk.aws_s3_notifications as s3_nots handler = lambda_.Function(self, "Handler", ...) bucket = s3.Bucket(self, "Bucket") bucket.add_object_created_notification(s3_nots.LambdaDestination(handler))
Java
import software.amazon.awscdk.services.s3.Bucket; import software.amazon.awscdk.services.lambda.Function; import software.amazon.awscdk.services.s3.notifications.LambdaDestination; Function handler = Function.Builder.create(this, "Handler")/* ... */.build(); Bucket bucket = new Bucket(this, "Bucket"); bucket.addObjectCreatedNotification(new LambdaDestination(handler));
C#
using lambda = Amazon.CDK.AWS.Lambda; using s3 = Amazon.CDK.AWS.S3; using s3Nots = Amazon.CDK.AWS.S3.Notifications; var handler = new lambda.Function(this, "Handler", new lambda.FunctionProps { .. }); var bucket = new s3.Bucket(this, "Bucket"); bucket.AddObjectCreatedNotification(new s3Nots.LambdaDestination(handler));
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" s3nots "github.com/aws/aws-cdk-go/awscdk/v2/awss3notifications" ) handler := lambda.NewFunction(this, jsii.String("MyFunction"), &lambda.FunctionProps{}) bucket := s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{}) bucket.AddObjectCreatedNotification(s3nots.NewLambdaDestination(handler), nil)
import * as s3nots from '@aws-cdk/aws-s3-notifications'; const handler = new lambda.Function(this, 'Handler', { /*…*/ }); const bucket = new s3.Bucket(this, 'Bucket'); bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));

Politiques de suppression

Les ressources qui conservent des données persistantes, telles que les bases de données, les compartiments Amazon S3 et les registres Amazon ECR, sont soumises à une politique de suppression. La politique de suppression indique s'il faut supprimer les objets persistants lorsque la AWS CDK pile qui les contient est détruite. Les valeurs spécifiant la politique de suppression sont disponibles via l'RemovalPolicyénumération du AWS CDK core module.

Note

Les ressources autres que celles qui stockent des données de manière persistante peuvent également removalPolicy avoir une utilisation à des fins différentes. Par exemple, une version de fonction Lambda utilise un removalPolicy attribut pour déterminer si une version donnée est conservée lors du déploiement d'une nouvelle version. Elles ont des significations et des valeurs par défaut différentes de celles de la politique de suppression d'un bucket Amazon S3 ou d'une table DynamoDB.

Valeur Signification

RemovalPolicy.RETAIN

Conservez le contenu de la ressource lors de la destruction de la pile (par défaut). La ressource est devenue orpheline de la pile et doit être supprimée manuellement. Si vous tentez de redéployer la pile alors que la ressource existe toujours, vous recevrez un message d'erreur en raison d'un conflit de nom.

RemovalPolicy.DESTROY

La ressource sera détruite en même temps que la pile.

AWS CloudFormation ne supprime pas les compartiments Amazon S3 contenant des fichiers, même si leur politique de suppression est définie sur. DESTROY Tenter de le faire est une AWS CloudFormation erreur. Pour AWS CDK supprimer tous les fichiers du bucket avant de le détruire, définissez la autoDeleteObjects propriété du bucket surtrue.

Vous trouverez ci-dessous un exemple de création d'un compartiment Amazon S3 avec RemovalPolicy of DESTROY et autoDeleteOjbects défini surtrue.

TypeScript
import * as cdk from '@aws-cdk/core'; import * as s3 from '@aws-cdk/aws-s3'; export class CdkTestStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); const bucket = new s3.Bucket(this, 'Bucket', { removalPolicy: cdk.RemovalPolicy.DESTROY, autoDeleteObjects: true }); } }
JavaScript
const cdk = require('@aws-cdk/core'); const s3 = require('@aws-cdk/aws-s3'); class CdkTestStack extends cdk.Stack { constructor(scope, id, props) { super(scope, id, props); const bucket = new s3.Bucket(this, 'Bucket', { removalPolicy: cdk.RemovalPolicy.DESTROY, autoDeleteObjects: true }); } } module.exports = { CdkTestStack }
Python
import aws_cdk.core as cdk import aws_cdk.aws_s3 as s3 class CdkTestStack(cdk.stack): def __init__(self, scope: cdk.Construct, id: str, **kwargs): super().__init__(scope, id, **kwargs) bucket = s3.Bucket(self, "Bucket", removal_policy=cdk.RemovalPolicy.DESTROY, auto_delete_objects=True)
Java
software.amazon.awscdk.core.*; import software.amazon.awscdk.services.s3.*; public class CdkTestStack extends Stack { public CdkTestStack(final Construct scope, final String id) { this(scope, id, null); } public CdkTestStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); Bucket.Builder.create(this, "Bucket") .removalPolicy(RemovalPolicy.DESTROY) .autoDeleteObjects(true).build(); } }
C#
using Amazon.CDK; using Amazon.CDK.AWS.S3; public CdkTestStack(Construct scope, string id, IStackProps props) : base(scope, id, props) { new Bucket(this, "Bucket", new BucketProps { RemovalPolicy = RemovalPolicy.DESTROY, AutoDeleteObjects = true }); }
Go
import ( "github.com/aws/aws-cdk-go/awscdk/v2" "github.com/aws/jsii-runtime-go" s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" ) s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{ RemovalPolicy: awscdk.RemovalPolicy_DESTROY, AutoDeleteObjects: jsii.Bool(true), })
import * as cdk from '@aws-cdk/core'; import * as s3 from '@aws-cdk/aws-s3'; export class CdkTestStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); const bucket = new s3.Bucket(this, 'Bucket', { removalPolicy: cdk.RemovalPolicy.DESTROY, autoDeleteObjects: true }); } }

Vous pouvez également appliquer une politique de suppression directement à la AWS CloudFormation ressource sous-jacente via la applyRemovalPolicy() méthode. Cette méthode est disponible sur certaines ressources dynamiques qui n'ont pas de removalPolicy propriété dans les accessoires de leur ressource L2. Voici quelques exemples :

  • AWS CloudFormation piles

  • Groupes d’utilisateurs Amazon Cognito

  • Instances de base de données Amazon DocumentDB

  • EC2 Volumes Amazon

  • Domaines Amazon OpenSearch Service

  • Systèmes de FSx fichiers Amazon

  • Files d'attente Amazon SQS

TypeScript
const resource = bucket.node.findChild('Resource') as cdk.CfnResource; resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
JavaScript
const resource = bucket.node.findChild('Resource'); resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
Python
resource = bucket.node.find_child('Resource') resource.apply_removal_policy(cdk.RemovalPolicy.DESTROY);
Java
CfnResource resource = (CfnResource)bucket.node.findChild("Resource"); resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
C#
var resource = (CfnResource)bucket.node.findChild('Resource'); resource.ApplyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
const resource = bucket.node.findChild('Resource') as cdk.CfnResource; resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
Note

Le «  AWS CDK s » RemovalPolicy se AWS CloudFormation traduit par « DeletionPolicy ». Cependant, la valeur par défaut AWS CDK est de conserver les données, ce qui est le contraire de la AWS CloudFormation valeur par défaut.

Rubrique suivante :

Identifiants

Rubrique précédente :

Action d’amorçage
ConfidentialitéConditions d'utilisation du sitePréférences de cookies
© 2025, Amazon Web Services, Inc. ou ses affiliés. Tous droits réservés.