Cómo funcionan juntos la síntesis y el arranque Configurar CDK la síntesis ¿Cómo sintetizar una pila CDK Cómo funciona la síntesis de forma predeterminada Personalice la síntesis de CDK pilas

Configurar y realizar la síntesis de CDK pilas

Antes de poder implementar una AWS Cloud Development Kit (AWS CDK) pila, primero se debe sintetizar. La síntesis de pilas es el proceso de producir una AWS CloudFormation plantilla y desplegar artefactos a partir de una CDK pila. La plantilla y los artefactos se conocen como ensamblaje de nubes. El ensamblaje de nubes es lo que se implementa para aprovisionar sus recursos AWS. Para obtener más información sobre cómo funcionan las implementaciones, consulteCómo funcionan AWS CDK las implementaciones.

Cómo funcionan juntos la síntesis y el arranque

Para que CDK las aplicaciones se desplieguen correctamente, las CloudFormation plantillas generadas durante la síntesis deben especificar correctamente los recursos creados durante el arranque. Por lo tanto, el arranque y la síntesis deben complementarse entre sí para que una implementación sea exitosa:

El arranque es un proceso único que consiste en configurar un entorno para las implementaciones. AWS AWS CDK Configura los AWS recursos específicos de su entorno que utiliza para las implementaciones. CDK Por lo general, se denominan recursos de arranque. Para obtener instrucciones sobre el arranque, consulte. Inicie su entorno para usarlo con AWS CDK
CloudFormation las plantillas producidas durante la síntesis incluyen información sobre qué recursos de bootstrap utilizar. Durante la síntesis, el CDK CLI no sabe específicamente cómo se ha iniciado su AWS entorno. En cambio, el CDK CLI produce CloudFormation plantillas basadas en el sintetizador que configure para cada CDK pila. Para que una implementación se realice correctamente, el sintetizador debe producir CloudFormation plantillas que hagan referencia a los recursos de arranque correctos que se van a utilizar.

CDKViene con un sintetizador predeterminado y una configuración de arranque que están diseñados para funcionar juntos. Si personaliza una, debe aplicar las personalizaciones pertinentes a la otra.

¿Cómo configurar la síntesis de CDK pilas

La síntesis de CDK pilas se configura mediante la synthesizer propiedad de la Stack instancia. Esta propiedad especifica cómo se sintetizarán las CDK pilas. Usted proporciona una instancia de una clase que implementa IStackSynthesizer oIReusableStackSynthesizer. Sus métodos se invocarán cada vez que se añada un activo a la pila o cuando se sintetice la pila. El siguiente es un ejemplo básico del uso de esta propiedad en tu pila:

También puedes configurar un sintetizador para todas las CDK pilas de tu CDK aplicación mediante la defaultStackSynthesizer propiedad de tu instancia: App

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{
            // ...
        }),
    })
}

De forma predeterminada, los usos. AWS CDK DefaultStackSynthesizer Si no configura un sintetizador, se utilizará este sintetizador.

Si no modifica el bootstrapping (por ejemplo, realizando cambios en la pila o plantilla del bootstrap), no tendrá que modificar la síntesis de la pila. Ni siquiera tienes que proporcionar un sintetizador. CDKUsará la DefaultStackSynthesizer clase predeterminada para configurar la síntesis de pilas para que interactúe correctamente con tu CDK pila de bootstrap.

¿Cómo sintetizar una pila CDK

Para sintetizar una CDK pila, utilice la interfaz de línea de AWS CDK comandos (AWS CDK CLIcdk synthcomando). Para obtener más información sobre este comando, incluidas las opciones que puede utilizar con este comando, consultecdk synthesize.

Si tu CDK aplicación contiene una sola pila o quieres sintetizar todas las pilas, no tienes que proporcionar el nombre de la CDK pila como argumento. De forma predeterminada, el CDK CLI sintetizará tus CDK pilas en AWS CloudFormation plantillas. En el directorio se guarda una plantilla json formateada para cada pila. cdk.out Si la aplicación contiene una sola pila, se imprime una plantilla yaml formateada. stdout A continuación, se muestra un ejemplo:


$ 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 tu CDK aplicación contiene varias pilas, puedes proporcionar el ID lógico de una pila para sintetizar una sola pila. A continuación, se muestra un ejemplo:


$ cdk synth MyStackName

Si no sintetizas una pila y la ejecutas, el cdk deploy CDK CLI sintetizará automáticamente su pila antes de la implementación.

Cómo funciona la síntesis de forma predeterminada

Generó lógica IDs en su AWS CloudFormation plantilla

Al sintetizar una CDK pila para producir una CloudFormation plantilla, la lógica IDs se genera a partir de las siguientes fuentes, con el formato <construct-path><construct-ID><unique-hash>:

Ruta de construcción: la ruta completa a la construcción de tu CDK aplicación. Esta ruta excluye el ID de la construcción L1, que siempre es Resource oDefault, y el ID de la pila de nivel superior de la que forma parte.
ID de construcción: el ID que se proporciona como segundo argumento al crear una instancia de la construcción.
Hash único: AWS CDK genera un hash único de 8 caracteres mediante un algoritmo de hash determinista. Este hash único ayuda a garantizar que los valores de ID lógicos de la plantilla sean únicos entre sí. El comportamiento determinista de esta generación de hash garantiza que el valor de ID lógico generado para cada construcción permanezca igual cada vez que se realice la síntesis. El valor hash solo cambiará si se modifican valores de construcción específicos, como el ID de la construcción o su ruta.

IDsLos lógicos tienen una longitud máxima de 255 caracteres. Por lo tanto, AWS CDK truncará la ruta de construcción y el ID de construcción si es necesario para mantenerse dentro de ese límite.

A continuación se muestra un ejemplo de una construcción que define un bucket de Amazon Simple Storage Service (Amazon S3). Aquí, pasamos myBucket como ID de nuestra construcción:

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
}

// ...

Cuando ejecutamoscdk synth, myBucketunique-hash se genera un ID lógico con el formato de. El siguiente es un ejemplo de este recurso en la AWS CloudFormation plantilla generada:


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

El siguiente es un ejemplo de un nombre de construcción personalizado Bar que define un bucket de Amazon S3. La Bar construcción incluye la construcción personalizada Foo en su ruta:

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

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

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

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

Cuando ejecutamoscdk synth, FooBarBucketunique-hash se genera un identificador lógico con el formato de. El siguiente es un ejemplo de este recurso en la AWS CloudFormation plantilla generada:


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

Personalice la síntesis de CDK pilas

Si el comportamiento de CDK síntesis predeterminado no se ajusta a sus necesidades, puede personalizar CDK la síntesis. Para ello, modifiqueDefaultStackSynthesizer, utilice otros sintetizadores integrados disponibles o cree su propio sintetizador. Para obtener instrucciones, consulte Personalice la síntesis de CDK pilas.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Defina los permisos para las construcciones de L2

Personalice CDK la síntesis