Seleccione sus preferencias de cookies

Usamos cookies esenciales y herramientas similares que son necesarias para proporcionar nuestro sitio y nuestros servicios. Usamos cookies de rendimiento para recopilar estadísticas anónimas para que podamos entender cómo los clientes usan nuestro sitio y hacer mejoras. Las cookies esenciales no se pueden desactivar, pero puede hacer clic en “Personalizar” o “Rechazar” para rechazar las cookies de rendimiento.

Si está de acuerdo, AWS y los terceros aprobados también utilizarán cookies para proporcionar características útiles del sitio, recordar sus preferencias y mostrar contenido relevante, incluida publicidad relevante. Para aceptar o rechazar todas las cookies no esenciales, haga clic en “Aceptar” o “Rechazar”. Para elegir opciones más detalladas, haga clic en “Personalizar”.

Preferencias
Contacte con nosotros
Comentarios
AWS Documentation
Cree una cuenta AWS

Introducción a las AWS CDK pilas

RSS
Modo de enfoque
Introducción a las AWS CDK pilas - AWS Cloud Development Kit (AWS CDK) v2
Acerca de la pila de APITrabajo con pilas

Esta es la guía para AWS CDK desarrolladores de la versión 2. 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.

Esta es la guía para AWS CDK desarrolladores de la versión 2. 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.

Una AWS CDK pila es la unidad de despliegue más pequeña. Representa un conjunto de AWS recursos que se definen mediante estructuras de CDK. Al implementar aplicaciones de CDK, los recursos de una pila de CDK se implementan juntos como una pila. AWS CloudFormation Para obtener más información sobre las AWS CloudFormation pilas, consulte Administrar los recursos de AWS como una sola unidad con AWS CloudFormation pilas en la Guía del AWS CloudFormation usuario.

Una pila se define mediante la extensión o la herencia del constructo Stack. El siguiente ejemplo es un patrón común para definir una pila de CDK en un archivo independiente, conocido como archivo de pila. Aquí, extendemos o heredamos la clase Stack y definimos un constructor que acepte scope, id y props. Luego, invocamos el constructor de clase Stack de base mediante super con el scope, el id y los props recibidos:

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

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}
JavaScript
const { Stack } = require('aws-cdk-lib');

class MyCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define your constructs here

  }
}

module.exports = { MyCdkStack }
Python
from aws_cdk import (
  Stack,
)
from constructs import Construct

class MyCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Define your constructs here
Java
package com.myorg;

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

public class MyCdkStack extends Stack {
  public MyCdkStack(final Construct scope, final String id) {  
    this(scope, id, null);
  }
  
  public MyCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define your constructs here
  }
}
C#
using Amazon.CDK; 
using Constructs;

namespace MyCdk
{
  public class MyCdkStack : Stack
  {
    internal MyCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}
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"
)

type CdkDemoAppStackProps struct {
	awscdk.StackProps
}

func NewCdkDemoAppStack(scope constructs.Construct, id string, props *CdkDemoAppStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return stack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewCdkDemoAppStack(app, "CdkDemoAppStack", &CdkDemoAppStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
} 

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

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}

En el ejemplo anterior solo se definió una pila. Para crear la pila, se debe crear una instancia de ella en el contexto de la aplicación de CDK. Un patrón común consiste en definir la aplicación de CDK e iniciar la pila en un archivo independiente, conocido como archivo de aplicación.

A continuación, se muestra un ejemplo donde se crea una pila de CDK llamada MyCdkStack. Aquí, se crea la aplicación de CDK y se crea una instancia de MyCdkStack en el contexto de la aplicación:

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

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});
JavaScript
#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { MyCdkStack } = require('../lib/my-cdk-stack');

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});
Python

Se encuentra en app.py:

#!/usr/bin/env python3
import os

import aws_cdk as cdk

from my_cdk.my_cdk_stack import MyCdkStack


app = cdk.App()
MyCdkStack(app, "MyCdkStack",)

app.synth()
Java
package com.myorg;

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

import java.util.Arrays;

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

    new MyCdkStack(app, "MyCdkStack", StackProps.builder()
      .build());

    app.synth();
  }
}
C#
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCdk
{
  sealed class Program
  {
    public static void Main(string[] args)
    {
      var app = new App();
      new MyCdkStack(app, "MyCdkStack", new StackProps
      {});
      app.Synth();
    }
  }
}
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(nil)

  NewMyCdkStack(app, "MyCdkStack", &MyCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

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

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});

En el siguiente ejemplo, se crea una aplicación de CDK que contiene dos pilas:

TypeScript
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();
JavaScript
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();
Python
app = App()

MyFirstStack(app, 'stack1')
MySecondStack(app, 'stack2')

app.synth()
Java
App app = new App();

new MyFirstStack(app, "stack1");
new MySecondStack(app, "stack2");

app.synth();
C#
var app = new App();

new MyFirstStack(app, "stack1");
new MySecondStack(app, "stack2");

app.Synth();
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"
)

type MyFirstStackProps struct {
	awscdk.StackProps
}

func NewMyFirstStack(scope constructs.Construct, id string, props *MyFirstStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	myFirstStack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return myFirstStack
}

type MySecondStackProps struct {
	awscdk.StackProps
}

func NewMySecondStack(scope constructs.Construct, id string, props *MySecondStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	mySecondStack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return mySecondStack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewMyFirstStack(app, "MyFirstStack", &MyFirstStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	NewMySecondStack(app, "MySecondStack", &MySecondStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
}

// ...
anchoranchoranchoranchoranchoranchor
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();

Acerca de la pila de API

El objeto Stack proporciona una API completa que incluye lo siguiente:

  • Stack.of(construct): un método estático que devuelve la pila en la que se define un constructo. Es útil si necesita interactuar con una pila desde un constructo reutilizable. La llamada falla si no se encuentra una pila en el ámbito.

  • stack.stackName (Python: stack_name): devuelve el nombre físico de la pila. Como se mencionó anteriormente, todas las AWS CDK pilas tienen un nombre físico que AWS CDK pueden resolver durante la síntesis.

  • stack.regiony stack.account — Devuelve la AWS región y la cuenta, respectivamente, en las que se desplegará esta pila. Estas propiedades devuelven uno de los siguientes valores:

    • La cuenta o la región que se especificó de forma explícita cuando se definió la pila

    • Un token codificado en cadenas que se resuelve con los AWS CloudFormation pseudoparámetros de la cuenta y la región para indicar que esta pila es independiente del entorno

    Para obtener más información acerca de cómo se determinan los entornos para pilas, consulte Entornos para AWS CDK.

  • stack.addDependency(stack) (Python: stack.add_dependency(stack)): se puede utilizar para definir de manera explícita el orden de dependencia entre dos pilas. El comando cdk deploy respeta este orden cuando se implementan varias pilas a la vez.

  • stack.tags— Devuelve un TagManagerque puedes usar para añadir o eliminar etiquetas a nivel de pila. Este administrador de etiquetas etiqueta todos los recursos de la pila y también etiqueta la propia pila cuando se crea mediante ella. AWS CloudFormation

  • stack.partition, stack.urlSuffix (Python:url_suffix), stack.stackId (Python:stack_id) y stack.notificationArn (Python:notification_arn): devuelven los tokens que se resuelven en los AWS CloudFormation pseudoparámetros respectivos, como{ "Ref": "AWS::Partition" }. Estos tokens están asociados al objeto de pila específico para que el AWS CDK marco pueda identificar las referencias entre pilas.

  • stack.availabilityZones (Python: availability_zones): devuelve el conjunto de zonas de disponibilidad disponibles en el entorno en el que se implementa esta pila. En el caso de las pilas independientes del entorno, este siempre devuelve una matriz con dos zonas de disponibilidad. En el caso de las pilas específicas del entorno, AWS CDK consulta el entorno y devuelve el conjunto exacto de zonas de disponibilidad disponibles en la región que especificó.

  • stack.parseArn(arn)and stack.formatArn(comps) (Python:parse_arn,format_arn): se puede usar para trabajar con Amazon Resource Names (ARNs).

  • stack.toJsonString(obj)(Python:to_json_string): se puede usar para formatear un objeto arbitrario como una cadena JSON que se puede incrustar en una AWS CloudFormation plantilla. El objeto puede incluir tókenes, atributos y referencias, que solo se resuelven durante la implementación.

  • stack.templateOptions (Python: template_options): se utiliza para especificar las opciones de plantilla de AWS CloudFormation , como Transform, Description y Metadata, para la pila.

Trabajo con pilas

Las pilas se despliegan como una AWS CloudFormation pila en un AWS entorno. El entorno cubre una Cuenta de AWS y específica. Región de AWS

Cuando se ejecuta el comando cdk synth para una aplicación con varias pilas, el ensamblaje de la nube incluye una plantilla independiente para cada instancia de pila. Incluso si las dos pilas son instancias de la misma clase, las AWS CDK emite como dos plantillas individuales.

Puede sintetizar cada plantilla si especifica el nombre de la pila en el comando cdk synth. El siguiente ejemplo sintetiza la plantilla para stack1:

$ cdk synth stack1

Este enfoque es conceptualmente diferente de la forma en que se utilizan normalmente las AWS CloudFormation plantillas, donde una plantilla se puede implementar varias veces y parametrizar mediante parámetros.AWS CloudFormation Si bien AWS CloudFormation los parámetros se pueden definir en el AWS CDK, por lo general no se recomienda utilizarlos porque los AWS CloudFormation parámetros solo se resuelven durante el despliegue. Esto significa que no se puede determinar su valor en el código.

Por ejemplo, para incluir de manera condicional un recurso en su aplicación en función del valor de un parámetro, debe configurar una condición de AWS CloudFormation y etiquetar el recurso con ella. AWS CDK Adopta un enfoque en el que las plantillas concretas se resuelven en el momento de la síntesis. Por lo tanto, puede utilizar una instrucción if para verificar el valor y determinar si se debe definir un recurso o si se debe aplicar algún comportamiento.

nota

AWS CDK Proporciona la mayor resolución posible durante el tiempo de síntesis para permitir un uso idiomático y natural del lenguaje de programación.

Como cualquier otro constructo, las pilas pueden componerse en grupos. El siguiente código muestra un ejemplo de un servicio que consta de tres pilas: un plano de control, un plano de datos y pilas de supervisión. El constructo de servicio se define dos veces: una para el entorno beta y otra para el entorno de producción.

TypeScript
import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();
JavaScript
const { App, Stack } = require('aws-cdk-lib');
const { Construct } = require('constructs');

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope, id, props) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");
  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();
Python
from aws_cdk import App, Stack
from constructs import Construct

# imagine these stacks declare a bunch of related resources
class ControlPlane(Stack): pass
class DataPlane(Stack): pass
class Monitoring(Stack): pass

class MyService(Construct):

  def __init__(self, scope: Construct, id: str, *, prod=False):
  
    super().__init__(scope, id)
  
    # we might use the prod argument to change how the service is configured
    ControlPlane(self, "cp")
    DataPlane(self, "data")
    Monitoring(self, "mon")
    
app = App();
MyService(app, "beta")
MyService(app, "prod", prod=True)

app.synth()
Java
package com.myorg;

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

public class MyApp {

    // imagine these stacks declare a bunch of related resources
    static class ControlPlane extends Stack {
        ControlPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class DataPlane extends Stack {
        DataPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class Monitoring extends Stack {
        Monitoring(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class MyService extends Construct {
        MyService(Construct scope, String id) {
            this(scope, id, false);
        }
        
        MyService(Construct scope, String id, boolean prod) {
            super(scope, id);
            
            // we might use the prod argument to change how the service is configured
            new ControlPlane(this, "cp");
            new DataPlane(this, "data");
            new Monitoring(this, "mon");         
        }
    }
    
    public static void main(final String argv[]) {
        App app = new App();

        new MyService(app, "beta");
        new MyService(app, "prod", true);
        
        app.synth();
    }
}
C#
using Amazon.CDK;
using Constructs;

// imagine these stacks declare a bunch of related resources
public class ControlPlane : Stack {
    public ControlPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class DataPlane : Stack {
    public DataPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class Monitoring : Stack
{
    public Monitoring(Construct scope, string id=null) : base(scope, id) { }
}

public class MyService : Construct
{
    public MyService(Construct scope, string id, Boolean prod=false) : base(scope, id)
    {
        // we might use the prod argument to change how the service is configured
        new ControlPlane(this, "cp");
        new DataPlane(this, "data");
        new Monitoring(this, "mon");
    }
}

class Program
{
    static void Main(string[] args)
    {

        var app = new App();
        new MyService(app, "beta");
        new MyService(app, "prod", prod: true);
        app.Synth();
    }
}
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"
)

type ControlPlaneStackProps struct {
	awscdk.StackProps
}

func NewControlPlaneStack(scope constructs.Construct, id string, props *ControlPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	ControlPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return ControlPlaneStack
}

type DataPlaneStackProps struct {
	awscdk.StackProps
}

func NewDataPlaneStack(scope constructs.Construct, id string, props *DataPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	DataPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return DataPlaneStack
}

type MonitoringStackProps struct {
	awscdk.StackProps
}

func NewMonitoringStack(scope constructs.Construct, id string, props *MonitoringStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MonitoringStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return MonitoringStack
}

type MyServiceStackProps struct {
	awscdk.StackProps
	Prod bool
}

func NewMyServiceStack(scope constructs.Construct, id string, props *MyServiceStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MyServiceStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	NewControlPlaneStack(MyServiceStack, "cp", &ControlPlaneStackProps{
		StackProps: sprops,
	})
	NewDataPlaneStack(MyServiceStack, "data", &DataPlaneStackProps{
		StackProps: sprops,
	})
	NewMonitoringStack(MyServiceStack, "mon", &MonitoringStackProps{
		StackProps: sprops,
	})

	return MyServiceStack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	betaProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: false,
	}

	NewMyServiceStack(app, "beta", &betaProps)

	prodProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: true,
	}

	NewMyServiceStack(app, "prod", &prodProps)

	app.Synth(nil)
}

// ...
anchoranchoranchoranchoranchoranchor
import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

Finalmente, esta AWS CDK aplicación consta de seis pilas, tres para cada entorno:

$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

Los nombres físicos de las AWS CloudFormation pilas se determinan automáticamente en AWS CDK función de la ruta de construcción de la pila en el árbol. De manera predeterminada, el nombre de una pila deriva del ID de constructo del objeto Stack. Sin embargo, se puede especificar un nombre explícito mediante el uso de la propiedad stackName (en Python, stack_name), como se indica a continuación.

TypeScript
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
JavaScript
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
Python
MyStack(self, "not:a:stack:name", stack_name="this-is-stack-name")
Java
new MyStack(this, "not:a:stack:name", StackProps.builder()
    .StackName("this-is-stack-name").build());
C#
new MyStack(this, "not:a:stack:name", new StackProps
{
    StackName = "this-is-stack-name"
});
anchoranchoranchoranchoranchor
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });

Uso de pilas anidadas

Una pila anidada es una pila de CDK que se crea dentro de otra pila, conocida como pila principal. Las pilas anidadas se crean mediante el constructo NestedStack.

Cuando se utilizan pilas anidadas, se pueden organizar los recursos en varias pilas. Las pilas anidadas también ofrecen una forma de evitar el límite de AWS CloudFormation 500 recursos de las pilas. Una pila anidada cuenta solo como un recurso en la pila que la contiene. Sin embargo, puede contener hasta 500 recursos, incluidas pilas anidadas adicionales.

El ámbito de una pila anidada debe ser una Stack o un constructo NestedStack. La pila anidada no necesita declararse léxicamente dentro de la pila principal. Solo es necesario pasar la pila principal como el primer parámetro (scope) cuando se crea una instancia de la pila anidada. Además de esta restricción, la definición de constructos en una pila anidada funciona exactamente igual que en una pila normal.

En el momento de la síntesis, la pila anidada se sintetiza en su propia AWS CloudFormation plantilla, que se carga en el depósito provisional durante el despliegue. AWS CDK Las pilas anidadas están vinculadas a su pila principal y no se tratan como artefactos de implementación independientes. No aparecen en la lista cdk list ni pueden implementarse mediante cdk deploy.

Las referencias entre las pilas principales y las pilas anidadas se traducen automáticamente en parámetros y resultados de la pila en las AWS CloudFormation plantillas generadas, como ocurre con cualquier referencia entre pilas.

aviso

En el caso de las pilas anidadas, los cambios en la posición de seguridad no se muestran antes de la implementación. Esta información solo se muestra en el caso de las pilas de nivel superior.

En esta página

PrivacidadTérminos del sitioPreferencias de cookies
© 2025, Amazon Web Services, Inc o sus afiliados. Todos los derechos reservados.