AWS CDK pilas - AWS Cloud Development Kit (AWS CDK) v2
¿Cómo definir una pilaTrabajo con pilas de

Esta es la guía para AWS CDK desarrolladores de la versión 2. La CDK versión anterior entró en mantenimiento el 1 de junio de 2022 y finalizó el soporte 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.

AWS CDK pilas

Una AWS Cloud Development Kit (AWS CDK) pila es una colección de una o más construcciones que definen AWS los recursos. Cada CDK pila representa una AWS CloudFormation pila de tu CDK aplicación. En el momento de la implementación, las construcciones de una pila se aprovisionan como una sola unidad, denominada pila. AWS CloudFormation Para obtener más información sobre las AWS CloudFormation pilas, consulte Cómo trabajar con pilas en la Guía del usuario.AWS CloudFormation

Como las CDK pilas se implementan a través de AWS CloudFormation pilas, se aplican AWS CloudFormation cuotas y limitaciones. Para obtener más información, consulta AWS CloudFormation las cuotas.

¿Cómo definir una pila

Las pilas se definen en el contexto de una aplicación. Para definir una pila, utilice la Stack construcción de la biblioteca de AWS construcciones. Las pilas se pueden definir de cualquiera de las siguientes maneras:

  • Directamente dentro del ámbito de la aplicación.

  • Indirectamente por cualquier construcción del árbol.

El siguiente ejemplo define una CDK aplicación 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();

El siguiente ejemplo es un patrón común para definir una pila en un archivo independiente. Aquí, ampliamos o heredamos la Stack clase y definimos un constructor que acepta scopeid, yprops. Luego, invocamos el constructor de la Stack clase base usando super los valores recibidos scopeid, y. props

TypeScript
class HelloCdkStack extends Stack {
  constructor(scope: App, id: string, props?: StackProps) {
    super(scope, id, props);

    //...
  }
}
JavaScript
class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    //...
  }
}
Python
class HelloCdkStack(Stack):

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

        # ...
Java
public class HelloCdkStack extends Stack {
    public HelloCdkStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

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

        // ...
    }
}
C#
public class HelloCdkStack : Stack
{
    public HelloCdkStack(Construct scope, string id, IStackProps props=null) : base(scope, id, props)
    {
        //...
    }
}
Go
func HelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
 var sprops awscdk.StackProps
 if props != nil {
  sprops = props.StackProps
 }
 stack := awscdk.NewStack(scope, &id, &sprops)

  return stack
}

En el siguiente ejemplo, se declara una clase de pila denominada MyFirstStack que incluye un único bucket de Amazon S3.

TypeScript
class MyFirstStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket');
  }
}
JavaScript
class MyFirstStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket');
  }
}
Python
class MyFirstStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        s3.Bucket(self, "MyFirstBucket")
Java
public class MyFirstStack extends Stack {
    public MyFirstStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public MyFirstStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);
        
        new Bucket(this, "MyFirstBucket");
    }
}
C#
public class MyFirstStack : Stack
{
    public MyFirstStack(Stack scope, string id, StackProps props = null) : base(scope, id, props)
    {
        new Bucket(this, "MyFirstBucket");
    }
}
Go
func MyFirstStack(scope constructs.Construct, id string, props *MyFirstStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)
	
  s3.NewBucket(stack, jsii.String("MyFirstBucket"), &s3.BucketProps{})
  return stack
}

Sin embargo, este código solo ha declarado una pila. Para que la pila se sintetice realmente en una AWS CloudFormation plantilla y se despliegue, debe crearse una instancia de la misma. Y, como todas las CDK construcciones, debe instanciarse en algún contexto. Ese App es ese contexto.

Si utilizas la plantilla de AWS CDK desarrollo estándar, tus pilas se instanciarán en el mismo archivo en el que instanciaste el objeto. App

TypeScript

El archivo que lleva el nombre de tu proyecto (por ejemplo,hello-cdk.ts) en la carpeta de tu proyecto. bin

JavaScript

El archivo que lleva el nombre del proyecto (por ejemplo,hello-cdk.js) en la bin carpeta del proyecto.

Python

El archivo app.py del directorio principal del proyecto.

Java

El archivo denominadoProjectNameApp.java, por ejemploHelloCdkApp.java, está ubicado en lo profundo del src/main directorio.

C#

El archivo nombrado Program.cs debajosrc\ProjectName, por ejemplosrc\HelloCdk\Program.cs.

La pila API

El objeto Stack proporciona una riquezaAPI, que incluye lo siguiente:

  • Stack.of(construct)— Un método estático que devuelve la pila en la que se define una construcción. Esto resulta útil si necesitas interactuar con una pila desde una construcción reutilizable. La llamada falla si no se encuentra una pila en el alcance.

  • 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 una de las siguientes opciones:

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

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

    Para obtener información sobre cómo se determinan los entornos de las pilas, consulte. Entornos para AWS CDK

  • stack.addDependency(stack)(Python: stack.add_dependency(stack) — Se puede usar para definir explícitamente el orden de dependencia entre dos pilas. El cdk deploy comando respeta este orden cuando despliega varias pilas a la vez.

  • stack.tags— Devuelve una 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, esto 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 JSON cadena que se puede incrustar en una AWS CloudFormation plantilla. El objeto puede incluir símbolos, atributos y referencias, que solo se resuelven durante el despliegue.

  • stack.templateOptions(Python:template_options): se usa para especificar opciones de AWS CloudFormation plantilla, como transformación, descripción y metadatos, para la pila.

Trabajo con pilas de

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

Cuando ejecutas el cdk synth comando para una aplicación con varias pilas, el ensamblaje en 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 especificando el nombre de la pila en el comando. cdk synth En el siguiente ejemplo, se sintetiza la plantilla de stack1.

$ cdk synth stack1

Este enfoque es conceptualmente diferente de la forma en que se usan normalmente las AWS CloudFormation plantillas, donde una plantilla se puede implementar varias veces y parametrizar a través de 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 puede determinar su valor en el código.

Por ejemplo, para incluir condicionalmente un recurso en tu aplicación en función del valor de un parámetro, debes configurar una AWS CloudFormation condición 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 sentencia if para comprobar 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 el uso idiomático y natural del lenguaje de programación.

Como cualquier otra construcción, las pilas se pueden componer juntas en grupos. El código siguiente muestra un ejemplo de un servicio que consta de tres pilas: un plano de control, un plano de datos y pilas de supervisión. La construcción del 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();
    }
}

En última instancia, 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 forma predeterminada, el nombre de una pila se deriva del ID de construcción del Stack objeto. Sin embargo, puede especificar un nombre explícito mediante el stackName accesorio (en Python,stack_name), de la siguiente manera.

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

Pilas anidadas

La NestedStackconstrucción ofrece una forma de sortear el límite de AWS CloudFormation 500 recursos para las pilas. Una pila anidada cuenta como un único recurso de 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 construcción O. NestedStack La pila anidada no necesita declararse léxicamente dentro de su pila principal. Solo es necesario pasar la pila principal como primer parámetro (scope) al crear una instancia de la pila anidada. Aparte de esta restricción, la definición de construcciones 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 AWS CDK despliegue. Las pilas anidadas están vinculadas a su pila principal y no se tratan como artefactos de despliegue independientes. No aparecen en la lista por cdk list ni se pueden implementar por. 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 postura de seguridad no se muestran antes del despliegue. Esta información solo se muestra en las pilas de nivel superior.