Configuration des ressources à l'aide de constructions Référencement des ressources Noms physiques des ressources Transmettre des identifiants de ressources uniques Octroi d'autorisations entre les ressources Indicateurs et alarmes relatifs aux ressources Trafic réseau Gestion des événements Politiques de suppression

Ressources et AWS CDK

Les ressources sont les éléments que vous configurez pour utiliser AWS les services de vos applications. Les ressources sont une caractéristique 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 via des 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 dans AWS CDK Constructs, le AWS CDK fournit une riche bibliothèque de classes de constructions, appelées constructions, qui représentent toutes les ressources. AWS

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

Exemple

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 complètement 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é queueUrl (Python :queue_url).

Exemple

Reportez-vous à la section Tokens et AWS CDK pour plus d'informations sur la façon dont le AWS CDK code les attributs de déploiement sous forme de chaînes.

Référencement des ressources

Lorsque vous configurez des ressources, vous devrez 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 compartiment Amazon Simple Storage Service (Amazon S3) contenant le code source.

Vous pouvez référencer des 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 référençant 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 CloudFront de 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 application AWS CDK. L'exemple suivant définit un cluster Amazon ECS, puis l'utilise pour définir un service Amazon ECS.

Exemple

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

Vous pouvez faire référence à des ressources d'une autre pile, à condition qu'elles soient définies dans la même application. Les piles peuvent se trouver dans des AWS environnements identiques ou différents (comptes et régions). 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 construction du compartiment en tant qu'attribut de la pile. Ensuite, l'application définit une deuxième pilestack2, qui accepte un compartiment lors de l'instanciation. stack2peut, par exemple, définir une table AWS Glue qui utilise le compartiment pour le stockage des données.

Exemple

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

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 Fn::ImportValue dans la pile consommatrice pour transférer ces informations d'une pile à l'autre. Il s'agit d'une référence solide : le comportement par défaut. Vous pouvez contrôler la force des références croisées pour éviter les blocages de dépendances.

Intensité de référence

Chaque référence croisée a une résistance qui détermine le CloudFormation mécanisme utilisé et le couplage entre les piles :

Fort (par défaut): La pile de production crée une CloudFormation exportation et la pile consommatrice utiliseFn::ImportValue. Cela signifie que la chaîne de production ne peut pas être mise à jour pour supprimer l'exportation tant qu'un consommateur l'importe encore. CloudFormation applique cette contrainte.
Faible: La pile consommatrice sert Fn::GetStackOutput à lire les sorties directement depuis la pile productrice. Aucun couplage d'exportation n'est créé ; chaque pile peut être mise à jour ou supprimée indépendamment.
Les deux: État de transition permettant de passer du statut de pays fort à celui de pays faible. La chaîne de production conserve ses exportations (afin de ne pas ruiner les consommateurs puissants existants), tandis que la chaîne de consommation passe àFn::GetStackOutput.

L'impasse de la dépendance (étreinte mortelle)

Des références fortes peuvent créer un blocage qui empêche les mises à jour de la pile. Cela se produit car il est CloudFormation impossible de supprimer une exportation alors qu'une autre pile l'importe encore, et la pile consommatrice ne peut pas être mise à jour pour arrêter l'importation tant que l'exportation n'existe pas déjà. Il se peut que vous voyiez une erreur telle que :

Export Stack1:ExportsOutputFnGetAtt-****** cannot be deleted as it is in use by Stack2

Cela se produit généralement lorsque vous essayez de supprimer une ressource partagée ou de restructurer vos piles. Les références faibles permettent d'éviter totalement ce problème, car elles ne créent pas d'exportations.

Contrôle de l'intensité de référence

Vous pouvez contrôler l'intensité des références à trois niveaux : à l'échelle de l'application, par ressource ou par utilisation.

App-wide par défaut

Définissez la clé contextuelle suivante cdk.json pour modifier la valeur par défaut pour toutes les références cross-stack de l'application :


{
  "context": {
    "@aws-cdk/core:defaultCrossStackReferences": "weak"
  }
}

Per-resource

Remplacez la force de toutes les références pointant vers une ressource spécifique en utilisant CrossStackReferences.of(resource).produce(strength) :

Exemple

Toutes les références bucket provenant d'autres piles seront désormais utilisées Fn::GetStackOutput indépendamment de la valeur par défaut à l'échelle de l'application.

Per-usage

Remplacez la puissance d'une référence unique au point de consommation en utilisant Stack.consumeReference() :

Exemple

TypeScript


declare const topic: sns.Topic;

const consumer = new Stack(app, 'Consumer', {
  env: { account: '123456789012', region: 'us-east-1' },
});
new sns.Subscription(consumer, 'Subscription', {
  topic: sns.Topic.fromTopicArn(consumer, 'Topic',
    Stack.consumeReference(topic.topicArn, ReferenceStrength.WEAK)),
  endpoint: 'https://example.com/webhook',
  protocol: sns.SubscriptionProtocol.HTTPS,
});

JavaScript


const { Stack, ReferenceStrength } = require('aws-cdk-lib');
const sns = require('aws-cdk-lib/aws-sns');
const subscriptions = require('aws-cdk-lib/aws-sns-subscriptions');

const consumer = new Stack(app, 'Consumer', {
  env: { account: '123456789012', region: 'us-east-1' },
});
new sns.Subscription(consumer, 'Subscription', {
  topic: sns.Topic.fromTopicArn(consumer, 'Topic',
    Stack.consumeReference(topic.topicArn, ReferenceStrength.WEAK)),
  endpoint: 'https://example.com/webhook',
  protocol: sns.SubscriptionProtocol.HTTPS,
});

Python


from aws_cdk import Stack, ReferenceStrength
import aws_cdk.aws_sns as sns

consumer = Stack(app, "Consumer",
    env=core.Environment(account="123456789012", region="us-east-1")
)
sns.Subscription(consumer, "Subscription",
    topic=sns.Topic.from_topic_arn(consumer, "Topic",
        Stack.consume_reference(topic.topic_arn, ReferenceStrength.WEAK)),
    endpoint="https://example.com/webhook",
    protocol=sns.SubscriptionProtocol.HTTPS
)

Java


import software.amazon.awscdk.Stack;
import software.amazon.awscdk.ReferenceStrength;
import software.amazon.awscdk.services.sns.*;

Stack consumer = new Stack(app, "Consumer", StackProps.builder()
        .env(Environment.builder().account("123456789012").region("us-east-1").build())
        .build());
Subscription.Builder.create(consumer, "Subscription")
        .topic(Topic.fromTopicArn(consumer, "Topic",
            Stack.consumeReference(topic.getTopicArn(), ReferenceStrength.WEAK)))
        .endpoint("https://example.com/webhook")
        .protocol(SubscriptionProtocol.HTTPS)
        .build();

C#


using Amazon.CDK;
using Amazon.CDK.AWS.SNS;

var consumer = new Stack(app, "Consumer", new StackProps
{
    Env = new Amazon.CDK.Environment { Account = "123456789012", Region = "us-east-1" }
});
new Subscription(consumer, "Subscription", new SubscriptionProps
{
    Topic = Topic.FromTopicArn(consumer, "Topic",
        Stack.ConsumeReference(topic.TopicArn, ReferenceStrength.WEAK)),
    Endpoint = "https://example.com/webhook",
    Protocol = SubscriptionProtocol.HTTPS
});

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awssns"
  "github.com/aws/jsii-runtime-go"
)

consumer := awscdk.NewStack(app, jsii.String("Consumer"), &awscdk.StackProps{
  Env: &awscdk.Environment{Account: jsii.String("123456789012"), Region: jsii.String("us-east-1")},
})
awssns.NewSubscription(consumer, jsii.String("Subscription"), &awssns.SubscriptionProps{
  Topic: awssns.Topic_FromTopicArn(consumer, jsii.String("Topic"),
    awscdk.Stack_ConsumeReference(topic.TopicArn(), awscdk.ReferenceStrength_WEAK)),
  Endpoint: jsii.String("https://example.com/webhook"),
  Protocol: awssns.SubscriptionProtocol_HTTPS,
})

À utiliser Stack.consumeListReference() pour les références à des listes de chaînes.

DéroGATION étendue

Vous pouvez également définir l'intensité de référence pour un sous-arbre de constructions à l'aide de. CrossStackReferences.of(scope).consume(strength) Toutes les références cross-stack consommées dans cette étendue utiliseront l'intensité spécifiée.

Migration de références fortes vers des références faibles

Si vous avez déjà déployé des piles avec des références fortes, vous ne pouvez pas passer directement à la version faible. Cela CloudFormation échouerait car l'exportation est toujours en cours d'utilisation. Utilisez plutôt une migration en deux phases via l'état de BOTH transition.

L'API à utiliser dépend de votre objectif :

Supprimer une seule référence (tout en conservant les piles et la ressource en place) : utilisez Stack.consumeReference() pour affaiblir uniquement cette utilisation spécifique.
Supprimer ou restructurer la ressource productrice : utilisez cette option CrossStackReferences.of(producer).produce() pour affaiblir toutes les références pointant vers cette ressource à la fois.

Les deux approches suivent le même schéma en deux phases décrit ci-dessous. Les exemples montrent l'approche par ressource. Pour une utilisation par utilisation, insérez la référence Stack.consumeReference(ref, ReferenceStrength.BOTH) dans la phase 1 et Stack.consumeReference(ref, ReferenceStrength.WEAK) dans la phase 2.

Phase 1 : Déploiement avec `les DEUX`

Réglez l'intensité de référence surBOTH. Cela permet à la pile consommatrice de commencer à utiliserFn::GetStackOutput, mais conserve l'exportation dans la pile de production afin que la transition soit sûre :

Exemple

Déployez les deux piles.

Phase 2 : Déploiement avec `WEAK`

Maintenant qu'aucun consommateur ne l'utiliseFn::ImportValue, l'exportation peut être supprimée en toute sécurité. Passez à WEAK :

Exemple

Déployez les deux piles. L'exportation est supprimée et la référence est désormais totalement faible.

Après cette migration, vous pouvez librement supprimer, déplacer ou restructurer la ressource sans vous ruiner.

Solution de contournement manuelle (ancienne)

Si vous n'utilisez pas encore les commandes d'intensité de référence, vous pouvez contourner le blocage manuellement. Supprimez l'utilisation de la ressource partagée de la pile consommatrice. 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. Déployez les deux piles pour supprimer leFn::ImportValue. 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.

Référencement de ressources dans votre AWS compte

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

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

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

Exemple

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

Regardons la Vpc.fromLookup() méthode de plus près. La ec2.Vpc structure étant complexe, il existe de nombreuses manières de sélectionner le VPC à utiliser avec votre application CDK. 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 l'utiliserVpc.fromLookup(), le système qui synthétise la pile doit avoir accès au compte propriétaire de l'Amazon VPC. En effet, 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 (voir Environnements pour le AWS CDK). Si le 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.

Exemple

Vous pouvez également utiliser cette tags propriété pour rechercher des VPC par tag. Vous pouvez ajouter des balises à Amazon VPC au moment de sa création à l'aide du CDK AWS CloudFormation ou du AWS CDK. Vous pouvez modifier les balises à tout moment après leur création à l'aide de la console AWS de gestion, de l' AWS interface de ligne de commande ou d'un AWS SDK. Outre les balises que vous ajoutez vous-même, le AWS CDK ajoute automatiquement les balises suivantes à tous les VPC qu'il crée.

Nom : 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é.

Exemple

Les résultats de Vpc.fromLookup() sont mis en cache dans le cdk.context.json fichier du projet. (Voir Valeurs contextuelles et AWS CDK.) Confiez ce fichier au contrôle de version afin que votre application continue à faire référence au même Amazon VPC. Cela fonctionne même si vous modifiez ultérieurement les attributs de vos VPC de telle sorte qu'un autre VPC soit sélectionné. 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 application AWS CDK, vous ne pouvez pas la modifier. Par exemple, appeler addToResourcePolicy (Python :add_to_resource_policy) sur un périphérique 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 dans la console de AWS gestion après leur déploiement par AWS CloudFormation. Le AWS CDK appelle ces derniers noms 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 qui représentent 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.

Exemple

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 un remplacement de 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'application AWS CDK. Consultez la AWS CloudFormation documentation pour plus de détails.

Dans certains cas, par exemple lors de la création d'une application AWS CDK avec des références inter-environnements, des noms physiques sont requis pour que le AWS CDK fonctionne correctement. Dans ces cas, si vous ne voulez pas vous donner la peine de trouver vous-même un nom physique, vous pouvez laisser le AWS CDK le nommer pour vous. Pour ce faire, utilisez la valeur spécialePhysicalName.GENERATE_IF_NEEDED, comme suit.

Exemple

Transmettre des 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 sont les suivants :

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

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

Exemple

L'exemple suivant montre comment transmettre un nom de compartiment généré à une fonction AWS Lambda.

Exemple

Octroi d'autorisations entre les ressources

Higher-level les constructions permettent d'obtenir les autorisations de moindre privilège en proposant des API simples et basées sur l'intention pour exprimer les exigences d'autorisation. Par exemple, de nombreuses structures proposent des méthodes d'autorisation que vous pouvez utiliser pour autoriser une entité (telle qu'un rôle IAM ou un utilisateur) à utiliser la ressource, sans avoir à créer manuellement des déclarations d'autorisation IAM.

Les méthodes d'octroi sont disponibles via les classes Grants (par exemple BucketGrants pour les compartiments Amazon S3). Ces classes fonctionnent à la fois avec les constructions L1 et L2. Les constructions L2 exposent une grants propriété pour plus de commodité, mais vous pouvez également créer une classe Grants directement à partir d'une construction L1. Vous pouvez combiner des classes Grants avec des Mixins pour L2-like faciliter les constructions L1.

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 clé AWS KMS, cette méthode autorise également le rôle d'exécution de la fonction Lambda à déchiffrer avec cette clé.

Exemple

Les méthodes d'octroi 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 l'autorisation a été correctement appliquée.

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

L'exemple suivant montre comment autoriser une fonction Lambda à accéder à l'action Amazon DynamoDBCreateBackup.

Exemple

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écifique à cet usage. Vous pouvez ensuite utiliser des méthodes d'octroi sur les ressources pour ajouter des déclarations au rôle.

Les méthodes d'octroi sont créées à l'aide d'API de niveau inférieur 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 et alarmes relatifs aux ressources

De nombreuses ressources émettent CloudWatch des métriques qui peuvent être utilisées pour configurer des tableaux de bord de surveillance et des alarmes. Higher-level les constructions ont 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 la valeur d'une file ApproximateNumberOfMessagesNotVisible d'attente Amazon SQS dépasse 100.

Exemple

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

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.

Des mesures peuvent également être ajoutées aux CloudWatch tableaux de bord. Consultez CloudWatch.

Trafic réseau

Dans de nombreux cas, vous devez activer des 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 des connexions exposent des méthodes qui activent les flux de trafic, notamment la définition de règles de groupe de sécurité ou d'ACL réseau.

Les ressources IConnectable possèdent 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 au Web et les connexions entrantes du groupe fleet2 Amazon EC2 Auto Scaling.

Exemple

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

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 appliquer un contrôle strict du réseau sans avoir à spécifier manuellement le port. Pour ce faire, utilisez les allowToDefaultPort méthodes allowDefaultPortFrom and (Python :allow_default_port_from,allow_to_default_port).

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

Exemple

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.

Exemple

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)

Politiques de suppression

Les ressources qui gèrent 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 pile AWS CDK qui les contient est détruite. Les valeurs spécifiant la politique de suppression sont disponibles via l'RemovalPolicyénumération du module AWS CDK. core

Note

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

Value	Signification
`RemovalPolicy.RETAIN`	Conservez le contenu de la ressource lors de la destruction de la pile (par défaut). La ressource est 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 noms.
`RemovalPolicy.DESTROY`	La ressource sera détruite en même temps que la pile.

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

Voici un exemple de création d'un compartiment Amazon S3 avec RemovalPolicy of DESTROY et autoDeleteOjbects défini surtrue.

Exemple

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

Vous pouvez également appliquer une politique de suppression directement à la AWS CloudFormation ressource sous-jacente via applyRemovalPolicy() cette méthode. Cette méthode est disponible pour certaines ressources avec état 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
Volumes Amazon EC2
Domaines Amazon OpenSearch Service
Systèmes de fichiers Amazon FSx
Files d'attente Amazon SQS

Exemple

Note

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

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.

Conventions de rédaction

Action d’amorçage

Identifiants

Ressources et AWS CDK

Configuration des ressources à l'aide de constructions

Exemple

Attributs de ressource

Exemple

Référencement des ressources

Exemple

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

Exemple

Intensité de référence

L'impasse de la dépendance (étreinte mortelle)

Contrôle de l'intensité de référence

App-wide par défaut

Per-resource

Exemple

Per-usage

Exemple

DéroGATION étendue

Migration de références fortes vers des références faibles

Phase 1 : Déploiement avec les DEUX

Exemple

Phase 2 : Déploiement avec WEAK

Exemple

Solution de contournement manuelle (ancienne)

Référencement de ressources dans votre AWS compte

Exemple

Exemple

Exemple

Noms physiques des ressources

Exemple

Exemple

Transmettre des identifiants de ressources uniques

Exemple

Exemple

Octroi d'autorisations entre les ressources

Exemple

Exemple

Indicateurs et alarmes relatifs aux ressources

Exemple

Trafic réseau

Exemple

Exemple

Gestion des événements

Exemple

Politiques de suppression

Note

Exemple

Exemple

Note

Phase 1 : Déploiement avec `les DEUX`

Phase 2 : Déploiement avec `WEAK`