Comment la synthèse et le bootstrapping fonctionnent ensemble Configuration de CDK la synthèse Comment synthétiser une pile CDK Comment fonctionne la synthèse par défaut Personnalisez la synthèse des CDK piles

Configuration et exécution de la synthèse des CDK piles

Avant de pouvoir déployer une AWS Cloud Development Kit (AWS CDK) pile, celle-ci doit d'abord être synthétisée. La synthèse de pile est le processus de production d'un AWS CloudFormation modèle et d'artefacts de déploiement à partir d'une CDK pile. Le modèle et les artefacts sont connus sous le nom d'assemblage cloud. L'assemblage du cloud est ce qui est déployé pour provisionner vos ressources AWS. Pour plus d'informations sur le fonctionnement des déploiements, consultezComment fonctionnent les AWS CDK déploiements.

Comment la synthèse et le bootstrapping fonctionnent ensemble

Pour que vos CDK applications soient correctement déployées, les CloudFormation modèles produits lors de la synthèse doivent spécifier correctement les ressources créées lors du démarrage. Par conséquent, le bootstrap et la synthèse doivent se compléter pour qu'un déploiement soit réussi :

Le bootstrapping est un processus ponctuel de configuration d'un AWS environnement pour AWS CDK les déploiements. Il configure les AWS ressources spécifiques de votre environnement qui sont utilisées par le CDK pour les déploiements. Ces ressources sont communément appelées ressources bootstrap. Pour obtenir des instructions sur le bootstrap, voir. Démarrez votre environnement pour l'utiliser avec AWS CDK
CloudFormation les modèles produits lors de la synthèse incluent des informations sur les ressources bootstrap à utiliser. Au cours de la synthèse, le CDK CLI ne sait pas précisément comment votre AWS environnement a été amorcé. Au lieu de cela, le CDK CLI produit des CloudFormation modèles basés sur le synthétiseur que vous configurez pour chaque CDK pile. Pour qu'un déploiement soit réussi, le synthétiseur doit produire des CloudFormation modèles qui font référence aux bonnes ressources bootstrap à utiliser.

Il CDK est livré avec un synthétiseur par défaut et une configuration d'amorçage conçus pour fonctionner ensemble. Si vous personnalisez l'un, vous devez appliquer les personnalisations pertinentes à l'autre.

Comment configurer la synthèse des CDK piles

Vous configurez la synthèse de CDK pile à l'aide de la synthesizer propriété de votre Stack instance. Cette propriété indique comment vos CDK piles seront synthétisées. Vous fournissez une instance d'une classe qui implémente IStackSynthesizer ouIReusableStackSynthesizer. Ses méthodes seront invoquées chaque fois qu'un actif est ajouté à la pile ou lorsque la pile est synthétisée. Voici un exemple de base de l'utilisation de cette propriété dans votre pile :

Vous pouvez également configurer un synthétiseur pour toutes les CDK piles de votre CDK application à l'aide de la defaultStackSynthesizer propriété de votre App instance :

TypeScript


import { App, Stack, DefaultStackSynthesizer } from 'aws-cdk-lib';

const app = new App({
  // Configure for all stacks in this app
  defaultStackSynthesizer: new DefaultStackSynthesizer({
    /* ... */
  }),
});

JavaScript


const { App, Stack, DefaultStackSynthesizer } = require('aws-cdk-lib');

const app = new App({
  // Configure for all stacks in this app
  defaultStackSynthesizer: new DefaultStackSynthesizer({
    /* ... */
  }),
});

Python


from aws_cdk import App, Stack, DefaultStackSynthesizer

app = App(
    default_stack_synthesizer=DefaultStackSynthesizer(
        # Configure for all stacks in this app
        # ...
    )
)

Java


import software.amazon.awscdk.App;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.DefaultStackSynthesizer;

public class Main {
    public static void main(final String[] args) {
        App app = new App(AppProps.builder()
            // Configure for all stacks in this app
            .defaultStackSynthesizer(DefaultStackSynthesizer.Builder.create().build())
            .build()
        );
    }
}

C#


using Amazon.CDK;
using Amazon.CDK.Synthesizers;

namespace MyNamespace
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App(new AppProps
            {
                // Configure for all stacks in this app
                DefaultStackSynthesizer = new DefaultStackSynthesizer(new DefaultStackSynthesizerProps
                {
                    // ...
                })
            });
        }
    }
}

Go


package main

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

func main() {
    defer jsii.Close()
    
    app := awscdk.NewApp(&awscdk.AppProps{
        // Configure for all stacks in this app
        DefaultStackSynthesizer: awscdk.NewDefaultStackSynthesizer(&awscdk.DefaultStackSynthesizerProps{
            // ...
        }),
    })
}

Par défaut, les AWS CDK utilisationsDefaultStackSynthesizer. Si vous ne configurez pas de synthétiseur, celui-ci sera utilisé.

Si vous ne modifiez pas le bootstrap, par exemple en apportant des modifications à la pile ou au modèle de bootstrap, vous n'avez pas à modifier la synthèse de pile. Vous n'avez même pas besoin de fournir un synthétiseur. Ils CDK utiliseront la DefaultStackSynthesizer classe par défaut pour configurer la synthèse de CDK pile afin d'interagir correctement avec votre pile bootstrap.

Comment synthétiser une pile CDK

Pour synthétiser une CDK pile, utilisez l'interface de ligne de AWS CDK commande (AWS CDK CLI) cdk synth commande. Pour plus d'informations sur cette commande, y compris les options que vous pouvez utiliser avec cette commande, consultezcdk synthesize.

Si votre CDK application contient une seule pile, ou si vous souhaitez synthétiser toutes les piles, il n'est pas nécessaire de fournir le nom de la CDK pile en argument. Par défaut, le CDK CLI synthétisera vos CDK piles dans des modèles. AWS CloudFormation Un modèle json formaté pour chaque pile est enregistré cdk.out dans le répertoire. Si votre application contient une seule pile, un modèle yaml formaté est imprimé sur. stdout Voici un exemple :


$ cdk synth
Resources:
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:H4sIAAAAAAAA/unique-identifier
    Metadata:
      aws:cdk:path: CdkAppStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
    ...

Si votre CDK application contient plusieurs piles, vous pouvez fournir l'identifiant logique d'une pile pour synthétiser une seule pile. Voici un exemple :


$ cdk synth MyStackName

Si vous ne synthétisez pas une pile et ne l'exécutez pascdk deploy, CDK CLI synthétisera automatiquement votre stack avant le déploiement.

Comment fonctionne la synthèse par défaut

Logique générée IDs dans votre AWS CloudFormation modèle

Lorsque vous synthétisez une CDK pile pour produire un CloudFormation modèle, des éléments logiques IDs sont générés à partir des sources suivantes, formatés comme suit : <construct-path><construct-ID><unique-hash>:

Chemin de construction : chemin complet menant à la construction dans votre CDK application. Ce chemin exclut l'ID de la construction L1, qui est toujours Resource ouDefault, et l'ID de la pile de niveau supérieur dont elle fait partie.
ID de construction — L'ID que vous fournissez comme deuxième argument lors de l'instanciation de votre construction.
Hachage unique — AWS CDK Génère un hachage unique à 8 caractères à l'aide d'un algorithme de hachage déterministe. Ce hachage unique permet de garantir que les valeurs d'identification logiques de votre modèle sont uniques les unes par rapport aux autres. Le comportement déterministe de cette génération de hachage garantit que la valeur d'identifiant logique générée pour chaque construction reste la même à chaque fois que vous effectuez une synthèse. La valeur de hachage ne changera que si vous modifiez des valeurs de construction spécifiques telles que l'ID de votre construction ou son chemin.

IDsLes logiques ont une longueur maximale de 255 caractères. Par conséquent, le chemin de construction et l'ID de construction AWS CDK seront tronqués si nécessaire pour respecter cette limite.

Voici un exemple de construction qui définit un compartiment Amazon Simple Storage Service (Amazon S3). Ici, nous passons myBucket comme identifiant pour notre construction :

TypeScript


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

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

    // Define the S3 bucket
    new s3.Bucket(this, 'myBucket', {
      versioned: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
  }
}

JavaScript


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

class MyCdkAppStack extends cdk.Stack {

  constructor(scope, id, props) {
    super(scope, id, props);
    
    new s3.Bucket(this, 'myBucket', {
      versioned: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
  }
}

module.exports = { MyCdkAppStack }

Python


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

class MyCdkAppStack(Stack):
  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)
          
    s3.Bucket(self, 'MyBucket',
      versioned=True,
      removal_policy=cdk.RemovalPolicy.DESTROY
    )

Java


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.BucketProps;
import software.amazon.awscdk.RemovalPolicy;

public class MyCdkAppStack extends Stack {
    public MyCdkAppStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public MyCdkAppStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Bucket.Builder.create(this, "myBucket")
            .versioned(true)
            .removalPolicy(RemovalPolicy.DESTROY)
            .build();
    }
}

C#


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

namespace MyCdkApp
{
    public class MyCdkAppStack : Stack
    {
        public MyCdkAppStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            new Bucket(this, "myBucket", new BucketProps
            {
                Versioned = true,
                RemovalPolicy = RemovalPolicy.DESTROY
            });
        }
    }
}

Go


package main
            
import (
    "github.com/aws/aws-cdk-go/awscdk/v2"
    "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
    "github.com/aws/constructs-go/constructs/v10"
    "github.com/aws/jsii-runtime-go"
)

type MyCdkAppStackProps struct {
    awscdk.StackProps
}

func NewMyCdkAppStack(scope constructs.Construct, id string, props *MyCdkAppStackProps) awscdk.Stack {
    var sprops awscdk.StackProps
    if props != nil {
        sprops = props.StackProps
    }
    stack := awscdk.NewStack(scope, &id, &sprops)
    
    awss3.NewBucket(stack, jsii.String("myBucket"), &awss3.BucketProps{
      Versioned: jsii.Bool(true),
      RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
    })
    
    return stack
}

// ...

Lorsque nous exécutonscdk synth, un identifiant logique au format de myBucketunique-hash est généré. Voici un exemple de cette ressource dans le AWS CloudFormation modèle généré :


Resources:
  myBucket5AF9C99B:
    Type: AWS::S3::Bucket
    Properties:
      VersioningConfiguration:
        Status: Enabled
    UpdateReplacePolicy: Delete
    DeletionPolicy: Delete
    Metadata:
      aws:cdk:path: S3BucketAppStack/myBucket/Resource

Voici un exemple de construction personnalisée nommée Bar qui définit un compartiment Amazon S3. La Bar construction inclut la construction personnalisée Foo dans son chemin :

TypeScript


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

// Define the Bar construct
export class Bar extends Construct {
  constructor(scope: Construct, id: string) {
    super(scope, id);

    // Define an S3 bucket inside of Bar
    new s3.Bucket(this, 'Bucket', {
       versioned: true,
       removalPolicy: cdk.RemovalPolicy.DESTROY,
      } );
  }
}

// Define the Foo construct
export class Foo extends Construct {
  constructor(scope: Construct, id: string) {
    super(scope, id);

    // Create an instance of Bar inside Foo
    new Bar(this, 'Bar');
  }
}

// Define the CDK stack
export class MyCustomAppStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Instantiate Foo construct in the stack
    new Foo(this, 'Foo');
  }
}

JavaScript


const cdk = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');
const { Construct } = require('constructs');

// Define the Bar construct
class Bar extends Construct {
  constructor(scope, id) {
    super(scope, id);

    // Define an S3 bucket inside of Bar
    new s3.Bucket(this, 'Bucket', {
      versioned: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
  }
}

// Define the Foo construct
class Foo extends Construct {
  constructor(scope, id) {
    super(scope, id);

    // Create an instance of Bar inside Foo
    new Bar(this, 'Bar');
  }
}

// Define the CDK stack
class MyCustomAppStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Instantiate Foo construct in the stack
    new Foo(this, 'Foo');
  }
}

module.exports = { MyCustomAppStack }

Python


import aws_cdk as cdk
from constructs import Construct
from aws_cdk import (
    Stack,
    aws_s3 as s3,
    RemovalPolicy,
)

# Define the Bar construct
class Bar(Construct):
    def __init__(self, scope: Construct, id: str) -> None:
        super().__init__(scope, id)

        # Define an S3 bucket inside of Bar
        s3.Bucket(self, 'Bucket',
            versioned=True,
            removal_policy=RemovalPolicy.DESTROY
        )

# Define the Foo construct
class Foo(Construct):
    def __init__(self, scope: Construct, id: str) -> None:
        super().__init__(scope, id)

        # Create an instance of Bar inside Foo
        Bar(self, 'Bar')

# Define the CDK stack
class MyCustomAppStack(Stack):
    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        # Instantiate Foo construct in the stack
        Foo(self, 'Foo')

Java

Dans my-custom-app/src/main/java/com/myorg/Bar.java:


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.BucketProps;
import software.amazon.awscdk.RemovalPolicy;

public class Bar extends Construct {
    public Bar(final Construct scope, final String id) {
        super(scope, id);

        // Define an S3 bucket inside Bar
        Bucket.Builder.create(this, "Bucket")
            .versioned(true)
            .removalPolicy(RemovalPolicy.DESTROY)
            .build();
    }
}

Dans my-custom-app/src/main/java/com/myorg/Foo.java:


package com.myorg;
							
import software.constructs.Construct;

public class Foo extends Construct {
    public Foo(final Construct scope, final String id) {
        super(scope, id);

        // Create an instance of Bar inside Foo
        new Bar(this, "Bar");
    }
}

Dans my-custom-app/src/main/java/com/myorg/MyCustomAppStack.java:


package com.myorg;

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

public class MyCustomAppStack extends Stack {
    public MyCustomAppStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        // Instantiate Foo construct in the stack
        new Foo(this, "Foo");
    }

    // Overload constructor in case StackProps is not provided
    public MyCustomAppStack(final Construct scope, final String id) {
        this(scope, id, null);
    }
}

C#


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

namespace MyCustomApp
{
    // Define the Bar construct
    public class Bar : Construct
    {
        public Bar(Construct scope, string id) : base(scope, id)
        {
            // Define an S3 bucket inside Bar
            new Bucket(this, "Bucket", new BucketProps
            {
                Versioned = true,
                RemovalPolicy = RemovalPolicy.DESTROY
            });
        }
    }

    // Define the Foo construct
    public class Foo : Construct
    {
        public Foo(Construct scope, string id) : base(scope, id)
        {
            // Create an instance of Bar inside Foo
            new Bar(this, "Bar");
        }
    }

    // Define the CDK Stack
    public class MyCustomAppStack : Stack
    {
        public MyCustomAppStack(Construct scope, string id, StackProps props = null) : base(scope, id, props)
        {
            // Instantiate Foo construct in the stack
            new Foo(this, "Foo");
        }
    }
}

Go


package main

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

// Define the Bar construct
type Bar struct {
	constructs.Construct
}

func NewBar(scope constructs.Construct, id string) constructs.Construct {
	bar := constructs.NewConstruct(scope, &id)

	// Define an S3 bucket inside Bar
	awss3.NewBucket(bar, jsii.String("Bucket"), &awss3.BucketProps{
		Versioned:     jsii.Bool(true),
		RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
	})

	return bar
}

// Define the Foo construct
type Foo struct {
	constructs.Construct
}

func NewFoo(scope constructs.Construct, id string) constructs.Construct {
	foo := constructs.NewConstruct(scope, &id)

	// Create an instance of Bar inside Foo
	NewBar(foo, "Bar")

	return foo
}

// Define the CDK Stack
type MyCustomAppStackProps struct {
	awscdk.StackProps
}

func NewMyCustomAppStack(scope constructs.Construct, id string, props *MyCustomAppStackProps) awscdk.Stack {
	stack := awscdk.NewStack(scope, &id, &props.StackProps)

	// Instantiate Foo construct in the stack
	NewFoo(stack, "Foo")

	return stack
}

// Define the CDK App
func main() {
	app := awscdk.NewApp(nil)

	NewMyCustomAppStack(app, "MyCustomAppStack", &MyCustomAppStackProps{
		StackProps: awscdk.StackProps{},
	})

	app.Synth(nil)
}

Lorsque nous exécutonscdk synth, un identifiant logique au format de FooBarBucketunique-hash est généré. Voici un exemple de cette ressource dans le AWS CloudFormation modèle généré :


Resources:
  FooBarBucketBA3ED1FA:
    Type: AWS::S3::Bucket
    Properties:
      VersioningConfiguration:
        Status: Enabled
    UpdateReplacePolicy: Delete
    DeletionPolicy: Delete
    # ...

Personnalisez la synthèse des CDK piles

Si le comportement de CDK synthèse par défaut ne répond pas à vos besoins, vous pouvez personnaliser CDK la synthèse. Pour ce faire, vous devez modifierDefaultStackSynthesizer, utiliser d'autres synthétiseurs intégrés disponibles ou créer votre propre synthétiseur. Pour obtenir des instructions, consultez Personnalisez la synthèse des CDK piles.

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

Définir les autorisations pour les constructions L2

Personnaliser CDK la synthèse