Esta es la guía para desarrolladores de AWS CDK v2. La primera versión del CDK pasó a la etapa de mantenimiento el 1.° de junio de 2022 y no cuenta con soporte desde el 1.° de junio de 2023. Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Configurar y realizar la síntesis de pilas de CDK Antes de poder implementar una pila de AWS Cloud Development Kit (AWS CDK), primero se debe sintetizar. La *síntesis de pilas* es el proceso de producir una plantilla de AWS CloudFormation e implementar artefactos a partir de una pila de CDK. La plantilla y los artefactos se conocen como *ensamblaje de nubes*. El ensamblaje de nubes es lo que se implementa para aprovisionar sus recursos en AWS. Para obtener más información sobre cómo funcionan las implementaciones, consulte [Cómo funcionan las implementaciones de AWS CDK](deploy.md#deploy-how). ## Cómo funcionan en conjunto la síntesis y el arranque Para que las aplicaciones del CDK se implementen correctamente, las plantillas de CloudFormation generadas durante la síntesis deben especificar correctamente los recursos creados durante el arranque. Por lo tanto, el arranque y la síntesis se deben complementar entre sí para que una implementación sea exitosa: + El arranque es un proceso único que consiste en configurar un entorno de AWS para las implementaciones de AWS CDK. Esto configura los recursos de AWS específicos de su entorno que utiliza el CDK para las implementaciones. Estos se denominan comúnmente *recursos de arranque*. Para obtener instrucciones sobre el arranque, consulte [Arranque su entorno para utilizarlo con el AWS CDK](bootstrapping-env.md). + Las plantillas de CloudFormation producidas durante la síntesis incluyen información sobre los recursos de arranque que se deben utilizar. Durante la síntesis, la CLI de CDK no sabe específicamente cómo se arrancó el entorno de AWS. En su lugar, la CLI de CDK produce plantillas de CloudFormation basadas en el sintetizador que usted configure en cada pila de CDK. Para que una implementación se realice correctamente, el sintetizador debe producir plantillas de CloudFormation que hagan referencia a los recursos de arranque correctos que se utilizarán. El CDK viene 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 pilas de CDK La síntesis de pilas de CDK se configura mediante la propiedad `synthesizer` de la instancia [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html). Esta propiedad especifica cómo se sintetizarán las pilas de CDK. Usted proporciona una instancia de una clase que implementa [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IStackSynthesizer.html) o [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IReusableStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IReusableStackSynthesizer.html). Sus métodos se invocarán cada vez que se agregue un activo a la pila o cuando se sintetice la pila. El siguiente es un ejemplo básico del uso de esta propiedad en su pila: **Example** ``` new MyStack(this, 'MyStack', { // stack properties synthesizer: new DefaultStackSynthesizer({ // synthesizer properties }), }); ``` ``` new MyStack(this, 'MyStack', { // stack properties synthesizer: new DefaultStackSynthesizer({ // synthesizer properties }), }); ``` ``` MyStack(self, "MyStack", # stack properties synthesizer=DefaultStackSynthesizer( # synthesizer properties )) ``` ``` new MyStack(app, "MyStack", StackProps.builder() // stack properties .synthesizer(DefaultStackSynthesizer.Builder.create() // synthesizer properties .build()) .build(); ) ``` ``` new MyStack(app, "MyStack", new StackProps // stack properties { Synthesizer = new DefaultStackSynthesizer(new DefaultStackSynthesizerProps { // synthesizer properties }) }); ``` ``` func main() { app := awscdk.NewApp(nil) NewMyStack(app, "MyStack", &MyStackProps{ StackProps: awscdk.StackProps{ Synthesizer: awscdk.NewDefaultStackSynthesizer(&awscdk.DefaultStackSynthesizerProps{ // synthesizer properties }), }, }) app.Synth(nil) } ``` También puede configurar un sintetizador para todas las pilas de CDK de su aplicación de CDK mediante la propiedad `defaultStackSynthesizer` de tu instancia `App`: **Example** ``` import { App, Stack, DefaultStackSynthesizer } from 'aws-cdk-lib'; const app = new App({ // Configure for all stacks in this app defaultStackSynthesizer: new DefaultStackSynthesizer({ /* ... */ }), }); ``` ``` const { App, Stack, DefaultStackSynthesizer } = require('aws-cdk-lib'); const app = new App({ // Configure for all stacks in this app defaultStackSynthesizer: new DefaultStackSynthesizer({ /* ... */ }), }); ``` ``` from aws_cdk import App, Stack, DefaultStackSynthesizer app = App( default_stack_synthesizer=DefaultStackSynthesizer( # Configure for all stacks in this app # ... ) ) ``` ``` 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() ); } } ``` ``` 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 { // ... }) }); } } } ``` ``` 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, el AWS CDK utiliza ` [`DefaultStackSynthesizer](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html) `. Si no configura un sintetizador, se utilizará este sintetizador. Si no modifica el arranque (por ejemplo, realizando cambios en la pila o plantilla del arranque), no tendrá que modificar la síntesis de la pila. Ni siquiera tiene que proporcionar un sintetizador. La CDK utilizará la clase `DefaultStackSynthesizer` predeterminada para configurar la síntesis de pilas de CDK para que interactúe correctamente con la pila de arranque. ## Cómo sintetizar una pila de CDK Para sintetizar una pila de la interfaz de la línea de comandos de AWS CDK (CLI de AWS CDK), utilice el comando de la interfaz de línea de comando de `cdk synth`. Para obtener más información sobre este comando, incluidas las opciones que puede utilizar con este comando, consulte [Sintetizar CDK](ref-cli-cmd-synth.md). Si su aplicación de CDK contiene una sola pila o quiere sintetizar todas las pilas, no tiene que proporcionar el nombre de la pila de CDK como argumento. De forma predeterminada, la CLI de CDK sintetizará sus pilas de CDK en plantillas de AWS CloudFormation. En el directorio `cdk.out` se guarda una plantilla formateada `json` para cada pila. Si la aplicación contiene una sola pila, se imprime en `stdout` una plantilla formateada `yaml`. 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 su aplicación de CDK contiene varias pilas, puede proporcionar el identificador lógico de una pila para sintetizar una sola pila. A continuación, se muestra un ejemplo: ``` $ cdk synth MyStackName ``` Si no sintetiza una pila y la ejecuta `cdk deploy`, la CLI de CDK sintetizará automáticamente su pila antes de implementarla. ## Cómo funciona la síntesis de forma predeterminada **Identificadores lógicos generados en la plantilla de AWS CloudFormation** Al sintetizar una pila de CDK para producir una plantilla de CloudFormation, los identificadores lógicos se generan a partir de las siguientes fuentes, con el formato siguiente `construct-pathconstruct-IDunique-hash`: + **Ruta del constructo**: la ruta completa al constructo en su aplicación de CDK. Esta ruta no incluye el identificador del constructo de nivel uno, que siempre es `Resource` o `Default`, ni el identificador de la pila de nivel superior de la que forma parte. + **Identificador del constructo**: el identificador que se proporciona como segundo argumento al crear una instancia del constructo. + **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 identificadores lógicos de la plantilla sean únicos entre sí. El comportamiento determinista de esta generación de hash garantiza que el valor de identificador lógico generado para cada constructo permanezca igual cada vez que se realice la síntesis. El valor hash solo cambiará si se modifican valores de constructo específicos, como el identificador del constructo o su ruta. Los identificadores lógicos tienen una longitud máxima de 255 caracteres. Por lo tanto, AWS CDK truncará la ruta del constructo y el identificador del constructo si es necesario para mantenerse dentro de ese límite. A continuación, se muestra un ejemplo de un constructo que define un bucket de Amazon Simple Storage Service (Amazon S3). Aquí, pasamos `myBucket` como identificador de nuestro constructo: **Example** ------ #### [ 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\$1 ] ``` 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 ejecutamos `cdk synth`, se genera un identificador lógico con el formato de `myBucketunique-hash`. A continuación, se muestra un ejemplo de este recurso en la plantilla de AWS CloudFormation generada: ``` Resources: myBucket5AF9C99B: Type: AWS::S3::Bucket Properties: VersioningConfiguration: Status: Enabled UpdateReplacePolicy: Delete DeletionPolicy: Delete Metadata: aws:cdk:path: S3BucketAppStack/myBucket/Resource ``` A continuación, se muestra un ejemplo de un constructo llamado `Bar` que define un bucket de Amazon S3. El constructo `Bar` incluye el constructo personalizado `Foo` en su ruta: **Example** ------ #### [ 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\$1 ] ``` 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 ejecutamos `cdk synth`, se genera un identificador lógico con el formato de `FooBarBucketunique-hash`. A continuación, se muestra un ejemplo de este recurso en la plantilla de AWS CloudFormation generada: ``` Resources: FooBarBucketBA3ED1FA: Type: AWS::S3::Bucket Properties: VersioningConfiguration: Status: Enabled UpdateReplacePolicy: Delete DeletionPolicy: Delete # ... ``` ## Personalizar la síntesis de pilas de CDK Si el comportamiento predeterminado de la síntesis de CDK no satisface sus necesidades, puede personalizar la síntesis de CDK. Para hacerlo, modifique `DefaultStackSynthesizer`, utilice otros sintetizadores integrados disponibles o cree su propio sintetizador. Para obtener instrucciones, consulte [Personalizar la síntesis de la pila de CDK](customize-synth.md).