Prérequis Créer un projet CDK Ajouter un paramètre facultatif Définissez la classe de pile Créez deux instances de pile Synthétiser et déployer la pile Nettoyage

Exemple : créer une application CDK avec plusieurs piles

Vous pouvez créer une AWS Cloud Development Kit (AWS CDK) application contenant plusieurs piles. Lorsque vous déployez l' AWS CDK application, chaque pile devient son propre AWS CloudFormation modèle. Vous pouvez également synthétiser et déployer chaque pile individuellement à l'aide du AWS CDK CLI cdk deploycommande.

Dans cet exemple, nous abordons les points suivants :

Comment étendre la Stack classe pour accepter de nouvelles propriétés ou de nouveaux arguments.
Comment utiliser les propriétés pour déterminer les ressources contenues dans la pile et leur configuration.
Comment instancier plusieurs piles à partir de cette classe.

L'exemple présenté dans cette rubrique utilise une propriété booléenne nommée (encryptBucketPython :encrypt_bucket). Il indique si un compartiment Amazon S3 doit être chiffré. Si tel est le cas, la pile active le chiffrement à l'aide d'une clé gérée par AWS Key Management Service (AWS KMS). L'application crée deux instances de cette pile, l'une avec chiffrement et l'autre sans chiffrement.

Prérequis

Cet exemple suppose que toutes les étapes de démarrage ont été effectuées.

Créer un projet CDK

Tout d'abord, nous créons un projet CDK à l'aide du CDK CLI:

Ajouter un paramètre facultatif

L'propsargument du Stack constructeur remplit l'interface. StackProps Dans cet exemple, nous voulons que la pile accepte une propriété supplémentaire nous indiquant s'il faut chiffrer le compartiment Amazon S3. Pour ce faire, nous créons une interface ou une classe qui inclut la propriété. Cela permet au compilateur de s'assurer que la propriété possède une valeur booléenne et d'activer l'auto-complétion pour celle-ci dans votre IDE.

Nous ouvrons notre fichier de pile dans notre IDE ou notre éditeur et ajoutons la nouvelle interface, la nouvelle classe ou le nouvel argument. Les nouvelles lignes sont surlignées en gras :

TypeScript

Dossier : lib/multistack-stack.ts


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface MultiStackProps extends cdk.StackProps {
  encryptBucket?: boolean;
}

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

    // The code that defines our stack goes here
  }
}

JavaScript

Dossier : lib/multistack-stack.js

JavaScript n'a pas de fonctionnalité d'interface ; nous n'avons pas besoin d'ajouter de code.


const cdk = require('aws-cdk-stack');

class MultistackStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // The code that defines our stack goes here
  }
}

module.exports = { MultistackStack }

Python

Dossier : multistack/multistack_stack.py

Python ne possède pas de fonctionnalité d'interface, nous allons donc étendre notre pile pour accepter la nouvelle propriété en ajoutant un argument de type mot-clé.


import aws_cdk as cdk
from constructs import Construct

class MultistackStack(cdk.Stack):

    # The Stack class doesn't know about our encrypt_bucket parameter,
    # so accept it separately and pass along any other keyword arguments.
    def __init__(self, scope: Construct, id: str, *, encrypt_bucket=False,
                 **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        # The code that defines our stack goes here

Java

Dossier : src/main/java/com/myorg/MultistackStack.java

C'est plus compliqué que ce que nous voulons vraiment aborder d'étendre un type d'accessoire en Java. Écrivez plutôt le constructeur de la pile pour accepter un paramètre booléen facultatif. Comme props il s'agit d'un argument facultatif, nous allons écrire un constructeur supplémentaire qui vous permettra de l'ignorer. Il sera défini par défaut surfalse.


package com.myorg;

import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.constructs.Construct;

import software.amazon.awscdk.services.s3.Bucket;

public class MultistackStack extends Stack {
    // additional constructors to allow props and/or encryptBucket to be omitted
    public MultistackStack(final Construct scope, final String id, boolean encryptBucket) {
        this(scope, id, null, encryptBucket);
    }
    
    public MultistackStack(final Construct scope, final String id) {
        this(scope, id, null, false);
    }

    public MultistackStack(final Construct scope, final String id, final StackProps props,
            final boolean encryptBucket) {
        super(scope, id, props);

        // The code that defines our stack goes here
    }
}

C#

Dossier : src/Multistack/MultistackStack.cs


using Amazon.CDK;
using constructs;

namespace Multistack
{
    

    public class MultiStackProps : StackProps
    {
        public bool? EncryptBucket { get; set; }
    }


    public class MultistackStack : Stack
    {
        public MultistackStack(Construct scope, string id, MultiStackProps props) : base(scope, id, props)
        {
            // The code that defines our stack goes here
        }
    }
}

La nouvelle propriété est facultative. Si encryptBucket (Python :encrypt_bucket) n'est pas présent, sa valeur est undefined ou son équivalent local. Le bucket ne sera pas chiffré par défaut.

Définissez la classe de pile

Ensuite, nous définissons notre classe de pile en utilisant notre nouvelle propriété. Le nouveau code est surligné en gras :

TypeScript

Dossier : lib/multistack-stack.ts


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

interface MultistackProps extends cdk.StackProps {
  encryptBucket?: boolean;
}

export class MultistackStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MultistackProps) {
    super(scope, id, props);
    
    // Add a Boolean property "encryptBucket" to the stack constructor.
    // If true, creates an encrypted bucket. Otherwise, the bucket is unencrypted.
    // Encrypted bucket uses KMS-managed keys (SSE-KMS).
    if (props && props.encryptBucket) {
      new s3.Bucket(this, "MyGroovyBucket", {
        encryption: s3.BucketEncryption.KMS_MANAGED, 
        removalPolicy: cdk.RemovalPolicy.DESTROY
      });
    } else {
      new s3.Bucket(this, "MyGroovyBucket", {
        removalPolicy: cdk.RemovalPolicy.DESTROY});
    }
  }
}

JavaScript

Dossier : lib/multistack-stack.js


const cdk = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');

class MultistackStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);
    
    // Add a Boolean property "encryptBucket" to the stack constructor.
    // If true, creates an encrypted bucket. Otherwise, the bucket is unencrypted.
    // Encrypted bucket uses KMS-managed keys (SSE-KMS).
    if ( props && props.encryptBucket) {
      new s3.Bucket(this, "MyGroovyBucket", {
        encryption: s3.BucketEncryption.KMS_MANAGED, 
        removalPolicy: cdk.RemovalPolicy.DESTROY
      });
    } else {
      new s3.Bucket(this, "MyGroovyBucket", {
        removalPolicy: cdk.RemovalPolicy.DESTROY});
    }
  }
}

module.exports = { MultistackStack }

Python

Dossier : multistack/multistack_stack.py


import aws_cdk as cdk
from constructs import Construct
from aws_cdk import aws_s3 as s3

class MultistackStack(cdk.Stack):

    # The Stack class doesn't know about our encrypt_bucket parameter,
    # so accept it separately and pass along any other keyword arguments.
    def __init__(self, scope: Construct, id: str, *, encrypt_bucket=False,
                 **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        # Add a Boolean property "encryptBucket" to the stack constructor.
        # If true, creates an encrypted bucket. Otherwise, the bucket is unencrypted.
        # Encrypted bucket uses KMS-managed keys (SSE-KMS).
        if encrypt_bucket:
            s3.Bucket(self, "MyGroovyBucket",
                      encryption=s3.BucketEncryption.KMS_MANAGED,
                      removal_policy=cdk.RemovalPolicy.DESTROY)
        else:
            s3.Bucket(self, "MyGroovyBucket",
                     removal_policy=cdk.RemovalPolicy.DESTROY)

Java

Dossier : src/main/java/com/myorg/MultistackStack.java


package com.myorg;

import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.constructs.Construct;
import software.amazon.awscdk.RemovalPolicy;

import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.BucketEncryption;

public class MultistackStack extends Stack {
    // additional constructors to allow props and/or encryptBucket to be omitted
    public MultistackStack(final Construct scope, final String id,
            boolean encryptBucket) {
        this(scope, id, null, encryptBucket);
    }

    public MultistackStack(final Construct scope, final String id) {
        this(scope, id, null, false);
    }

    // main constructor
    public MultistackStack(final Construct scope, final String id,
            final StackProps props, final boolean encryptBucket) {
        super(scope, id, props);

        // Add a Boolean property "encryptBucket" to the stack constructor.
        // If true, creates an encrypted bucket. Otherwise, the bucket is
        // unencrypted. Encrypted bucket uses KMS-managed keys (SSE-KMS).
        if (encryptBucket) {
            Bucket.Builder.create(this, "MyGroovyBucket")
                    .encryption(BucketEncryption.KMS_MANAGED)
                    .removalPolicy(RemovalPolicy.DESTROY).build();
        } else {
            Bucket.Builder.create(this, "MyGroovyBucket")
                    .removalPolicy(RemovalPolicy.DESTROY).build();
        }
    }
}

C#

Dossier : src/Multistack/MultistackStack.cs


using Amazon.CDK;
using Amazon.CDK.AWS.S3;

namespace Multistack
{
    
    public class MultiStackProps : StackProps
    {
        public bool? EncryptBucket { get; set; }
    }

    public class MultistackStack : Stack
    {
        public MultistackStack(Construct scope, string id, IMultiStackProps props = null) : base(scope, id, props)
        {
            // Add a Boolean property "EncryptBucket" to the stack constructor.
            // If true, creates an encrypted bucket. Otherwise, the bucket is unencrypted.
            // Encrypted bucket uses KMS-managed keys (SSE-KMS).
            if (props?.EncryptBucket ?? false)
            {
                new Bucket(this, "MyGroovyBucket", new BucketProps
                {
                    Encryption = BucketEncryption.KMS_MANAGED,
                    RemovalPolicy = RemovalPolicy.DESTROY
                });
            }
            else
            {
                new Bucket(this, "MyGroovyBucket", new BucketProps
                {
                    RemovalPolicy = RemovalPolicy.DESTROY
                });
            }
        }
    }
}

Créez deux instances de pile

Dans notre fichier d'application, nous ajoutons le code pour instancier deux piles distinctes. Nous supprimons la MultistackStack définition existante et définissons nos deux piles. Le nouveau code est surligné en gras :

TypeScript

Dossier : bin/multistack.ts


#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MultistackStack } from '../lib/multistack-stack';

const app = new cdk.App();

new MultistackStack(app, "MyWestCdkStack", {
    env: {region: "us-west-1"},
    encryptBucket: false
});
  
new MultistackStack(app, "MyEastCdkStack", {
    env: {region: "us-east-1"},
    encryptBucket: true
});
          
app.synth();

JavaScript

Dossier : bin/multistack.js


#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { MultistackStack } = require('../lib/multistack-stack');

const app = new cdk.App();

new MultistackStack(app, "MyWestCdkStack", {
    env: {region: "us-west-1"},
    encryptBucket: false
});
  
new MultistackStack(app, "MyEastCdkStack", {
    env: {region: "us-east-1"},
    encryptBucket: true
});
          
app.synth();

Python

Dossier : ./app.py


#!/usr/bin/env python3

import aws_cdk as cdk

from multistack.multistack_stack import MultistackStack

app = cdk.App()
MultistackStack(app, "MyWestCdkStack",
                env=cdk.Environment(region="us-west-1"),
                encrypt_bucket=False)

MultistackStack(app, "MyEastCdkStack",
                env=cdk.Environment(region="us-east-1"),
                encrypt_bucket=True)
            
app.synth()

Java

Dossier : src/main/java/com/myorg/MultistackApp.java


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

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

        new MultistackStack(app, "MyWestCdkStack", StackProps.builder()
                .env(Environment.builder()
                        .region("us-west-1")
                        .build())
                .build(), false);

        new MultistackStack(app, "MyEastCdkStack", StackProps.builder()
                .env(Environment.builder()
                        .region("us-east-1")
                        .build())
                .build(), true);

        app.synth();
    }
}

C#

Fichier : src/Multistack/Program .cs


using Amazon.CDK;

namespace Multistack
{
    class Program
    {
        static void Main(string[] args)
        {
            var app = new App();

            new MultistackStack(app, "MyWestCdkStack", new MultiStackProps
            {
                Env = new Environment { Region = "us-west-1" },
                EncryptBucket = false
            });

            new MultistackStack(app, "MyEastCdkStack", new MultiStackProps
            {
                Env = new Environment { Region = "us-east-1" },
                EncryptBucket = true
            });

            app.Synth();
        }
    }
}

Ce code utilise la nouvelle propriété encryptBucket (Python :encrypt_bucket) de la MultistackStack classe pour instancier ce qui suit :

Une pile avec un compartiment Amazon S3 chiffré dans la us-east-1 AWS région.
Une pile contenant un compartiment Amazon S3 non chiffré dans la us-west-1 AWS région.

Synthétiser et déployer la pile

Ensuite, nous pouvons déployer des stacks depuis l'application. Tout d'abord, nous synthétisons un AWS CloudFormation modèle pourMyEastCdkStack. Il s'agit de la pile us-east-1 intégrée au compartiment Amazon S3 chiffré.


$ cdk synth MyEastCdkStack

Pour déployer cette pile dans notre AWS environnement, nous pouvons exécuter l'une des commandes suivantes. La première commande utilise notre AWS profil par défaut pour obtenir les informations d'identification nécessaires au déploiement de la pile. Le second utilise un profil que nous indiquons. En PROFILE_NAME effet, nous pouvons remplacer le nom d'un AWS CLI profil contenant les informations d'identification appropriées pour le déploiement vers le us-east-1 Région AWS.


$ cdk deploy MyEastCdkStack


$ cdk deploy MyEastCdkStack --profile=PROFILE_NAME

Nettoyage

Pour éviter de facturer les ressources que nous avons déployées, nous détruisons la pile à l'aide de la commande suivante :


cdk destroy MyEastCdkStack

L'opération de destruction échoue si quelque chose est stocké dans le compartiment de la pile. Il ne devrait pas y en avoir, puisque nous avons uniquement créé le bucket. Si nous avons mis quelque chose dans le compartiment, nous devons en supprimer le contenu avant de détruire la pile. Nous pouvons utiliser le AWS Management Console ou AWS CLI pour supprimer le contenu du bucket.

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

Tutoriel : application Hello World sans serveur

Exemple : création d'un service Fargate