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.
# Trabajar con la biblioteca de AWS CDK
Importe y utilice la biblioteca de AWS Cloud Development Kit (AWS CDK) para definir su infraestructura en la nube de AWS con un [lenguaje de programación compatible](languages.md).
## Importar la Biblioteca de AWS CDK
A menudo se hace referencia a la [Biblioteca de AWS CDK](libraries.md) por su nombre de paquete de TypeScript de `aws-cdk-lib`. El nombre real del paquete varía según el idioma. El siguiente es un ejemplo de cómo instalar e importar la biblioteca de CDK:
**Example**
| | |
| --- |--- |
| **Instalación** | `npm install aws-cdk-lib` |
| **Importe** | `import * as cdk from 'aws-cdk-lib';` |
| | |
| --- |--- |
| **Instalación** | `npm install aws-cdk-lib` |
| **Importe** | `const cdk = require('aws-cdk-lib');` |
| | |
| --- |--- |
| **Instalación** | `python -m pip install aws-cdk-lib` |
| **Importe** | `import aws_cdk as cdk` |
| | |
| --- |--- |
| **En `pom.xml`, agregue** | `Group software.amazon.awscdk; artifact aws-cdk-lib` |
| **Importe** | `import software.amazon.awscdk.App;` |
| | |
| --- |--- |
| **Instalación** | `dotnet add package Amazon.CDK.Lib` |
| **Importe** | `using Amazon.CDK;` |
| | |
| --- |--- |
| **Instalación** | `go get github.com/aws/aws-cdk-go/awscdk/v2` |
| **Importe** |
import ( "github.com/aws/aws-cdk-go/awscdk/v2" )
|
La clase base `construct` y el código de soporte están en la biblioteca `constructs`. Los constructos experimentales, en los que la API aún se encuentra en proceso de perfeccionamiento, se distribuyen como módulos separados.
## Uso de la referencia de la API de AWS CDK
Utilice la [referencia de la API de AWS CDK](libraries.md#libraries-reference) a medida que desarrolla con AWS CDK.
El material de referencia de cada módulo se divide en las siguientes secciones.
+ *Descripción general*: material introductorio que necesitará conocer para trabajar con el servicio en AWS CDK, que incluye conceptos y ejemplos.
+ *Constructos*: clases de biblioteca que representan uno o más recursos concretos de AWS. Se trata de los recursos “seleccionados” (L2) o patrones (recursos L3) que proporcionan una interfaz de alto nivel con valores predeterminados en buen estado.
+ *Clases*: clases que no son de constructos y que proporcionan la funcionalidad utilizada por los constructos del módulo.
+ *Estructuras*: estructuras de datos (grupos de atributos) que definen la estructura de los valores compuestos, como las propiedades (el argumento `props` de los constructos) y las opciones.
+ *Interfaces*: las interfaces, cuyos nombres comienzan todos por “I”, definen la funcionalidad mínima absoluta para el constructo correspondiente u otra clase. El CDK usa interfaces de constructos para representar los recursos de AWS que están definidos fuera de la aplicación de AWS CDK y a los que se hace referencia mediante métodos como `Bucket.fromBucketArn()`.
+ *Enumeraciones*: colecciones de valores con nombre que se utilizan para especificar determinados parámetros de constructos. El uso de un valor enumerado permite al CDK comprobar la validez de estos valores durante la síntesis.
+ *Recursos de CloudFormation*: estos constructos L1, cuyos nombres comienzan por “Cfn”, representan exactamente los recursos definidos en la especificación de CloudFormation. Se generan de forma automática a partir de esa especificación con cada versión del CDK. Cada constructo L2 o L3 encapsula uno o más recursos de CloudFormation.
+ *Tipos de propiedades de CloudFormation*: conjunto de valores con nombre que definen las propiedades de cada recurso de CloudFormation.
## Comparación de las interfaces con las clases de constructo
El AWS CDK utiliza las interfaces de una manera específica que puede no resultar obvia incluso si está familiarizado con las interfaces como concepto de programación.
El AWS CDK admite el uso de recursos definidos fuera de las aplicaciones CDK mediante métodos como `Bucket.fromBucketArn()`. Los recursos externos no se pueden modificar y es posible que no tengan todas las funciones disponibles con los recursos definidos en su aplicación CDK que utiliza, por ejemplo, la clase `Bucket`. Por lo tanto, las interfaces representan la funcionalidad mínima disponible en el CDK para un tipo de recurso de AWS determinado, *incluidos los recursos externos*.
Por lo tanto, al crear instancias de recursos en la aplicación CDK, siempre debe utilizar clases concretas, como `Bucket`. Cuando especifique el tipo de argumento que va a aceptar en uno de sus propios constructos, utilice un tipo de interfaz como `IBucket` si está preparado para trabajar con recursos externos (es decir, no necesitará cambiarlos). Si necesita un constructo definido por CDK, especifique el tipo más general que pueda utilizar.
Algunas interfaces son versiones mínimas de propiedades o grupos de opciones asociados a clases específicas, en lugar de constructos. Estas interfaces pueden resultar útiles a la hora de subclasificar para aceptar argumentos que pasará a su clase principal. Si necesita una o más propiedades adicionales, querrá implementarla o derivarla de esta interfaz o de un tipo más específico.
**nota**
Algunos lenguajes de programación compatibles con AWS CDK no tienen ninguna característica de interfaz. En estos lenguajes, las interfaces son simplemente clases normales. Puede identificarlos por sus nombres, que siguen el patrón de una “I” inicial seguida del nombre de algún otro constructo (por ejemplo, `IBucket`). Se aplican las mismas reglas.
## Administración de las dependencias
Las dependencias de la aplicación o biblioteca de AWS CDK se administran mediante herramientas de administración de paquetes. A menudo, estas herramientas se utilizan con los lenguajes de programación.
Por lo general, AWS CDK es compatible con la herramienta de administración de paquetes estándar u oficial del lenguaje, si existe. De lo contrario, AWS CDK será compatible con la herramienta más popular o más compatible del lenguaje. Es posible que también pueda usar otras herramientas, especialmente si funcionan con las herramientas compatibles. Sin embargo, el soporte oficial para otras herramientas es limitado.
AWS CDK admite los siguientes administradores de paquetes:
| Idioma | Herramienta de administración de paquetes compatible |
| --- | --- |
| TypeScript/JavaScript | NPM (Node Package Manager) o Yarn |
| Python | PIP (instalador de paquetes para Python) |
| Java | Maven |
| C\$1 | NuGet |
| Go | Módulos Go |
Al crear un nuevo proyecto mediante el comando `cdk init` de la CLI de AWS CDK, las dependencias de las bibliotecas principales y los constructos estables del CDK se especifican de forma automática.
Para obtener más información acerca de cómo administrar las dependencias de los lenguajes de programación compatibles, consulte lo siguiente:
+ [Administración de dependencias en TypeScript](work-with-cdk-typescript.md#work-with-cdk-typescript-dependencies).
+ [Administración de dependencias en JavaScript](work-with-cdk-javascript.md#work-with-cdk-javascript-dependencies).
+ [Administración de dependencias en Python](work-with-cdk-python.md#work-with-cdk-python-dependencies).
+ [Administración de dependencias en Java](work-with-cdk-java.md#work-with-cdk-java-dependencies).
+ [Administración de dependencias en C\$1](work-with-cdk-csharp.md#work-with-cdk-csharp-dependencies).
+ [Administración de dependencias en Go](work-with-cdk-go.md#work-with-cdk-go-dependencies).
## Comparar AWS CDK en TypeScript con otros lenguajes
TypeScript fue el primer lenguaje compatible para el desarrollo de aplicaciones de AWS CDK. Por lo tanto, una cantidad sustancial de código de CDK de ejemplo está escrita en TypeScript. Si desarrolla en otro lenguaje, puede ser útil comparar la forma en que se implementa el código de AWS CDK en TypeScript en comparación con el lenguaje que elija. Esto puede ayudarlo a usar los ejemplos de toda la documentación.
## Importación de un módulo
**Example**
TypeScript admite la importación de un espacio de nombres completo o de objetos individuales desde un espacio de nombres. Cada espacio de nombres incluye constructos y otras clases para su uso con un servicio de AWS determinado.
```
// Import main CDK library as cdk
import * as cdk from 'aws-cdk-lib'; // ES6 import preferred in TS
const cdk = require('aws-cdk-lib'); // Node.js require() preferred in JS
// Import specific core CDK classes
import { Stack, App } from 'aws-cdk-lib';
const { Stack, App } = require('aws-cdk-lib');
// Import AWS S3 namespace as s3 into current namespace
import { aws_s3 as s3 } from 'aws-cdk-lib'; // TypeScript
const s3 = require('aws-cdk-lib/aws-s3'); // JavaScript
// Having imported cdk already as above, this is also valid
const s3 = cdk.aws_s3;
// Now use s3 to access the S3 types
const bucket = s3.Bucket(...);
// Selective import of s3.Bucket
import { Bucket } from 'aws-cdk-lib/aws-s3'; // TypeScript
const { Bucket } = require('aws-cdk-lib/aws-s3'); // JavaScript
// Now use Bucket to instantiate an S3 bucket
const bucket = Bucket(...);
```
Al igual que TypeScript, Python admite la importación de módulos con espacios de nombres y la importación selectiva. Los espacios de nombres en Python se parecen a **aws\$1cdk.** *xxx*, donde *xxx* representa el nombre de un servicio de AWS, como **s3** para Amazon S3. (Amazon S3 se utiliza en estos ejemplos).
```
# Import main CDK library as cdk
import aws_cdk as cdk
# Selective import of specific core classes
from aws_cdk import Stack, App
# Import entire module as s3 into current namespace
import aws_cdk.aws_s3 as s3
# s3 can now be used to access classes it contains
bucket = s3.Bucket(...)
# Selective import of s3.Bucket into current namespace
from aws_cdk.s3 import Bucket
# Bucket can now be used to instantiate a bucket
bucket = Bucket(...)
```
Las importaciones de Java funcionan de forma diferente a las de TypeScript. Cada instrucción de importación importa un único nombre de clase desde un paquete determinado o todas las clases definidas en ese paquete (mediante `\*`). Se puede acceder a las clases con el nombre de la clase en sí mismo si se importó o con el nombre de la clase *cualificada*, incluido su paquete.
Las bibliotecas reciben un nombre como `software.amazon.awscdk.services.xxx` para la Biblioteca de constructos de AWS (la biblioteca principal es `software.amazon.awscdk`). El identificador de grupo de Maven para los paquetes de AWS CDK es `software.amazon.awscdk`.
```
// Make certain core classes available
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.App;
// Make all Amazon S3 construct library classes available
import software.amazon.awscdk.services.s3.*;
// Make only Bucket and EventType classes available
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.EventType;
// An imported class may now be accessed using the simple class name (assuming that name
// does not conflict with another class)
Bucket bucket = Bucket.Builder.create(...).build();
// We can always use the qualified name of a class (including its package) even without an
// import directive
software.amazon.awscdk.services.s3.Bucket bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
// Java 10 or later can use var keyword to avoid typing the type twice
var bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
```
En C\$1, los tipos se importan con la directiva `using`. Existen dos estilos. El primero otorga acceso a todos los tipos en el espacio de nombres especificado mediante sus nombres simples. El segundo puede hacer referencia al propio espacio de nombres mediante un alias.
Los paquetes reciben un nombre como `Amazon.CDK.AWS.xxx` para los paquetes de la Biblioteca de constructos de AWS. (El módulo principal es `Amazon.CDK`.)
```
// Make CDK base classes available under cdk
using cdk = Amazon.CDK;
// Make all Amazon S3 construct library classes available
using Amazon.CDK.AWS.S3;
// Now we can access any S3 type using its name
var bucket = new Bucket(...);
// Import the S3 namespace under an alias
using s3 = Amazon.CDK.AWS.S3;
// Now we can access an S3 type through the namespace alias
var bucket = new s3.Bucket(...);
// We can always use the qualified name of a type (including its namespace) even without a
// using directive
var bucket = new Amazon.CDK.AWS.S3.Bucket(...);
```
Cada módulo de la Biblioteca de constructos de AWSse proporciona como un paquete Go.
```
import (
"github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
"github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
// now instantiate a bucket
bucket := awss3.NewBucket(...)
// use aliases for brevity/clarity
import (
cdk "github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
bucket := s3.NewBucket(...)
```
## Crear una instancia de constructo
Las clases de constructos de AWS CDK tienen el mismo nombre en todos los lenguajes admitidos. La mayoría de los lenguajes usan la palabra clave `new` para crear instancias de una clase (Python y Go no lo hacen). Además, en la mayoría de los lenguajes, la palabra clave `this` se refiere a la instancia actual. (Python utiliza `self` por convención). Debería pasar una referencia a la instancia actual como el parámetro `scope` a cada constructo que cree.
El tercer argumento de un constructo de AWS CDK es `props` un objeto que contiene los atributos necesarios para crear el constructo. Este argumento puede ser opcional, pero cuando es necesario, los lenguajes compatibles lo manejan de formas idiomáticas. Los nombres de los atributos también se adaptan a los patrones de nomenclatura estándar del lenguaje.
**Example**
```
// Instantiate default Bucket
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket');
// Instantiate Bucket with bucketName and versioned properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
bucketName: 'amzn-s3-demo-bucket',
versioned: true,
});
// Instantiate Bucket with websiteRedirect, which has its own sub-properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
websiteRedirect: {host: 'aws.amazon.com'}});
```
Python no usa una palabra clave `new` al crear instancias de una clase. El argumento de propiedades se representa mediante argumentos de palabras clave y los argumentos se nombran mediante `snake_case`.
Si un valor de props es en sí mismo un grupo de atributos, se representa mediante una clase con el nombre de la propiedad que acepta argumentos de palabras clave para las subpropiedades.
En Python, la instancia actual se pasa a los métodos como el primer argumento, que se denomina `self` por convención.
```
# Instantiate default Bucket
bucket = s3.Bucket(self, "amzn-s3-demo-bucket")
# Instantiate Bucket with bucket_name and versioned properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket", versioned=true)
# Instantiate Bucket with website_redirect, which has its own sub-properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", website_redirect=s3.WebsiteRedirect(
host_name="aws.amazon.com"))
```
En Java, el argumento props se representa mediante una clase denominada `XxxxProps` (por ejemplo, `BucketProps` para los props del constructo `Bucket`). El argumento props se construye mediante un patrón de construcción.
Cada clase `XxxxProps` tiene un constructor. También hay un práctico constructor para cada constructo que construye los props y el constructo en un solo paso, como se muestra en el siguiente ejemplo.
Los accesorios tienen el mismo nombre que en TypeScript, con `camelCase`.
```
// Instantiate default Bucket
Bucket bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with bucketName and versioned properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.bucketName("amzn-s3-demo-bucket").versioned(true)
.build();
# Instantiate Bucket with websiteRedirect, which has its own sub-properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.websiteRedirect(new websiteRedirect.Builder()
.hostName("aws.amazon.com").build())
.build();
```
En C\$1, los props se especifican mediante un inicializador de objetos para una clase llamada `XxxxProps` (por ejemplo, `BucketProps` para los props del constructo `Bucket`).
Los props se nombran de manera similar a TypeScript, excepto que usan `PascalCase`.
Es conveniente usar la palabra clave `var` al crear una instancia de un constructo, por lo que no es necesario escribir el nombre de la clase dos veces. Sin embargo, la guía de estilo del código local puede variar.
```
// Instantiate default Bucket
var bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with BucketName and Versioned properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
BucketName = "amzn-s3-demo-bucket",
Versioned = true});
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
WebsiteRedirect = new WebsiteRedirect {
HostName = "aws.amazon.com"
}});
```
Para crear un constructo en Go, llama a la función `NewXxxxxx` donde `Xxxxxxx` es el nombre del constructo. Las propiedades de los constructos se definen como una estructura.
En Go, todos los parámetros de los constructos son punteros, incluidos valores como números, valores booleanos y cadenas. Utilice funciones prácticas como `jsii.String` para crear estos punteros.
```
// Instantiate default Bucket
bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), nil)
// Instantiate Bucket with BucketName and Versioned properties
bucket1 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
BucketName: jsii.String("amzn-s3-demo-bucket"),
Versioned: jsii.Bool(true),
})
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
bucket2 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
WebsiteRedirect: &awss3.RedirectTarget{
HostName: jsii.String("aws.amazon.com"),
}})
```
## Acceso a los miembros
Es habitual hacer referencia a los atributos o propiedades de los constructos y otras clases de AWS CDK y utilizar estos valores como, por ejemplo, entradas para crear otros constructos. Las diferencias de nomenclatura descritas anteriormente para los métodos también se aplican aquí. Además, en Java, no es posible acceder a los miembros de forma directa. En su lugar, se proporciona un método getter.
**Example**
Los nombres son `camelCase`.
```
bucket.bucketArn
```
Los nombres son `snake_case`.
```
bucket.bucket_arn
```
Se proporciona un método getter para cada propiedad; estos nombres son `camelCase`.
```
bucket.getBucketArn()
```
Los nombres son `PascalCase`.
```
bucket.BucketArn
```
Los nombres son `PascalCase`.
```
bucket.BucketArn
```
## Constantes de enumeración
Las constantes de enumeración se asignan a una clase y tienen nombres en mayúscula con guiones bajos en todos los lenguajes (a veces denominadas `SCREAMING_SNAKE_CASE`). Como los nombres de clase también utilizan las mismas mayúsculas y minúsculas en todos los lenguajes compatibles, excepto Go, los nombres de enumeración válidos también son los mismos en estos lenguajes.
```
s3.BucketEncryption.KMS_MANAGED
```
En Go, las constantes de enumeración son atributos del espacio de nombres del módulo y se escriben de la siguiente manera.
```
awss3.BucketEncryption_KMS_MANAGED
```
## Interfaces de objetos
El AWS CDK utiliza interfaces de objetos de TypeScript para indicar que una clase implementa un conjunto esperado de métodos y propiedades. Puede reconocer una interfaz de objetos porque su nombre comienza con `I`. Una clase concreta indica las interfaces que implementa mediante la palabra clave `implements`.
**Example**
JavaScript no tiene una característica de interfaz. Puede ignorar la palabra clave `implements` y los nombres de clase que la siguen.
```
import { IAspect, IConstruct } from 'aws-cdk-lib';
class MyAspect implements IAspect {
public visit(node: IConstruct) {
console.log('Visited', node.node.path);
}
}
```
Python no tiene una característica de interfaz. Sin embargo, para AWS CDK puede indicar la implementación de la interfaz al decorar la clase con `@jsii.implements(interface)`.
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
```
import software.amazon.awscdk.IAspect;
import software.amazon.awscdk.IConstruct;
public class MyAspect implements IAspect {
public void visit(IConstruct node) {
System.out.format("Visited %s", node.getNode().getPath());
}
}
```
```
using Amazon.CDK;
public class MyAspect : IAspect
{
public void Visit(IConstruct node)
{
System.Console.WriteLine($"Visited ${node.Node.Path}");
}
}
```
Las estructuras de Go no necesitan declarar de forma explícita qué interfaces implementan. El compilador Go determina la implementación en función de los métodos y propiedades disponibles en la estructura. Por ejemplo, en el código siguiente, `MyAspect` implementa la interfaz `IAspect` porque proporciona un método `Visit` que toma un constructo.
```
type MyAspect struct {
}
func (a MyAspect) Visit(node constructs.IConstruct) {
fmt.Println("Visited", *node.Node().Path())
}
```
# Utilización del AWS CDK en TypeScript
TypeScript es un lenguaje de cliente totalmente compatible con AWS Cloud Development Kit (AWS CDK) y se lo considera estable. Para trabajar con AWS CDK en TypeScript se utilizan herramientas conocidas, como el compilador TypeScript de Microsoft (`tsc`), [Node.js](https://nodejs.org/) y el administrador de paquetes de nodos (`npm`). También puede usar [Yarn](https://yarnpkg.com/) si lo prefiere, aunque en los ejemplos de esta guía se usa NPM. Los módulos que componen la Biblioteca de constructos de AWS se distribuyen a través del repositorio NPM, [nuget.org.](https://www.npmjs.com/)
Puede usar cualquier editor o IDE. Muchos desarrolladores de AWS CDK usan [Visual Studio Code](https://code.visualstudio.com/) (o su equivalente de código abierto [VSCodium](https://vscodium.com/)), que tiene un excelente compatibilidad con TypeScript.
## Introducción al TypeScript
Para trabajar con el AWS CDK, debe tener una cuenta de AWS y credenciales, y haber instalado Node.js y el kit de herramientas de AWS CDK. Consulte [Introducción al AWS CDK](getting-started.md).
También necesita el propio TypeScript (versión 3.8 o posterior). Si no lo tiene, puede instalarlo mediante `npm`.
```
$ npm install -g typescript
```
**nota**
Si aparece un error de permiso y tiene acceso de administrador al sistema, intente con `sudo npm install -g typescript`.
Mantenga TypeScript actualizado con un `npm update -g typescript` periódico.
**nota**
Obsolescencia del lenguaje de terceros: la versión en otros idiomas solo se admite hasta que el proveedor o la comunidad compartan su fecha de caducidad (EOL) y está sujeta a cambios con previo aviso.
## Creación de un proyecto
Cree un nuevo proyecto AWS CDK, mediante la invocación de `cdk init` en un directorio vacío. Utilice la opción `--language` y especifique `typescript`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language typescript
```
Al crear un proyecto, también se instala el módulo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html) y sus dependencias.
`cdk init` utiliza el nombre de la carpeta del proyecto para asignar un nombre a varios elementos del proyecto, incluidas las clases, las subcarpetas y los archivos. Los guiones del nombre de la carpeta se convierten en guiones bajos. Aunque, de lo contrario, el nombre debe seguir la forma de un identificador de TypeScript; por ejemplo, no debe comenzar por un número ni contener espacios.
## Uso local `tsc` y `cdk`
En su mayor parte, esta guía supone que instala TypeScript y el kit de herramientas de CDK de forma global (`npm install -g typescript aws-cdk`) y los ejemplos de comandos proporcionados (como `cdk synth`) siguen esta suposición. Este enfoque facilita mantener ambos componentes actualizados y, dado que ambos adoptan un enfoque estricto en cuanto a la compatibilidad con versiones anteriores, por lo general, se corre poco riesgo si se utilizan siempre las versiones más recientes.
Algunos equipos prefieren especificar todas las dependencias dentro de cada proyecto, incluidas herramientas como el compilador TypeScript y el kit de herramientas de CDK. Esta práctica permite vincular estos componentes a versiones específicas y asegurarse de que todos los desarrolladores de su equipo (y de su entorno de CI/CD) utilicen exactamente esas versiones. Esto elimina una posible fuente de cambio, lo que ayuda a que las compilaciones y las implementaciones sean más consistentes y repetibles.
El CDK incluye dependencias tanto para TypeScript como para el kit de herramientas de CDK en las plantillas del proyecto de TypeScript `package.json`, por lo que si quiere utilizar este enfoque, no necesita hacer modificaciones en su proyecto. Todo lo que necesita hacer es usar comandos ligeramente diferentes para crear su aplicación y para emitir comandos `cdk`.
| Operación | Uso de herramientas globales | Uso de herramientas locales |
| --- | --- | --- |
| **Iniciar el proyecto** | `cdk init --language typescript` | `npx aws-cdk init --language typescript` |
| **Compilación** | `tsc` | `npm run build` |
| **Ejecutar el comando del kit de herramientas de CDK** | `cdk …` | `npm run cdk …` or `npx aws-cdk …` |
`npx aws-cdk` ejecuta la versión del kit de herramientas instalada localmente en el proyecto actual, si está disponible; de lo contrario, utiliza la instalación global, si la hay. Si no existe una instalación global, `npx` descarga una copia temporal del kit de herramientas de CDK y la ejecuta. Puede especificar una versión arbitraria del kit de herramientas de CDK mediante la sintaxis `@`: `npx aws-cdk@2.0 --version` imprime `2.0.0`.
**sugerencia**
Configure un alias para poder usar el comando `cdk` con la instalación local del kit de herramientas de CDK.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## Administración de los módulos de la Biblioteca de constructos de AWS
Use el administrador de paquetes de nodo (`npm`) para instalar y actualizar los módulos de la Biblioteca de constructos de AWS para que sus aplicaciones los usen, así como otros paquetes que necesite. (Puede usar `yarn` en lugar de `npm` si lo prefiere). `npm` también instala las dependencias de esos módulos automáticamente.
La mayoría de los constructos de AWS CDK se encuentran en el paquete CDK principal, llamado `aws-cdk-lib`, que es una dependencia predeterminada en los nuevos proyectos creados por `cdk init`. Los módulos “experimentales” de la Biblioteca de constructos de AWS, en los que aún se están desarrollando los constructos de nivel superior, reciben el nombre `@aws-cdk/-alpha`. El nombre del servicio tiene el prefijo *aws-*. Si no está seguro del nombre de un módulo, [búsquelo en el NPM](https://www.npmjs.com/search?q=%40aws-cdk).
**nota**
La [referencia de la API de CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) también muestra los nombres de los paquetes.
Por ejemplo, el siguiente comando instala el módulo experimental de AWS CodeStar.
```
$ npm install @aws-cdk/aws-codestar-alpha
```
El soporte de la Biblioteca de constructos de algunos servicios se encuentra en más de un espacio de nombres. Por ejemplo, además de `aws-route53`, hay tres espacios de nombres adicionales de Amazon Route 53: `aws-route53-targets`, `aws-route53-patterns`, y `aws-route53resolver`.
Las dependencias de su proyecto se mantienen en `package.json`. Puede editar este archivo para bloquear algunas o todas sus dependencias en una versión específica, o para permitir que se actualicen a versiones más recientes según determinados criterios. Esto es para actualizar las dependencias de NPM de su proyecto a la última versión permitida, de acuerdo con las reglas que especificó en `package.json`:
```
$ npm update
```
En TypeScript, importe módulos a su código con el mismo nombre que utilizó para instalarlos mediante NPM. Recomendamos las siguientes prácticas al importar clases de AWS CDK y módulos de la Biblioteca de constructos de AWS a sus aplicaciones. Seguir estas directrices ayudará a que su código sea coherente con el de otras aplicaciones de AWS CDK y a que sea más fácil de entender.
+ Utilice directivas `import` al estilo de ES6, no `require()`.
+ Por lo general, se importan clases individuales desde `aws-cdk-lib`.
```
import { App, Stack } from 'aws-cdk-lib';
```
+ Si necesita muchas clases de `aws-cdk-lib`, puede utilizar un alias de espacio de nombres de `cdk` en lugar de importar clases individuales. Evite hacer ambas cosas.
```
import * as cdk from 'aws-cdk-lib';
```
+ Por lo general, se importan las Bibliotecas de constructos de AWS utilizando alias de espacio de nombres cortos.
```
import { aws_s3 as s3 } from 'aws-cdk-lib';
```
## Administrar dependencias en TypeScript
En los proyectos CDK en TypeScript, las dependencias se especifican en el archivo `package.json` del directorio principal del proyecto. Los módulos principales de AWS CDK se encuentran en un único paquete `NPM` llamado `aws-cdk-lib`.
Cuando instala un paquete utilizando `npm install`, el NPM graba el paquete `package.json` por usted.
Si lo prefiere, puede usar Yarn en lugar de NPM. Sin embargo, el CDK no es compatible con el modo listo para usar de Yarn, que es el modo predeterminado en Yarn 2. Agregue lo siguiente al archivo `.yarnrc.yml` de su proyecto para desactivar esta característica.
```
nodeLinker: node-modules
```
### Aplicaciones de CDK
A continuación, se muestra un ejemplo de un archivo `package.json` generado a través del comando `cdk init --language typescript`:
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
En el caso de las aplicaciones de CDK implementables, debe especificarse `aws-cdk-lib` en la sección `dependencies` de `package.json`. Puede utilizar un carácter (^) como especificador del número de versión para indicar que aceptará versiones posteriores a la especificada, siempre que estén dentro de la misma versión principal.
Para los constructos experimentales, especifique las versiones exactas de los módulos de la Biblioteca de constructos alfa, ya que sus API pueden cambiar. No utilice ^ ni \$1, ya que las versiones posteriores de estos módulos pueden incluir cambios en la API que pueden dañar su aplicación.
Especifique las versiones de las bibliotecas y herramientas necesarias para probar su aplicación (por ejemplo, el marco de pruebas `jest`) en la sección `devDependencies` de `package.json`. Si lo desea, utilice ^ para especificar si se aceptan versiones posteriores compatibles.
### Bibliotecas de constructos de terceros
Si está desarrollando una Biblioteca de constructos, especifique sus dependencias mediante una combinación de las secciones `peerDependencies` y `devDependencies`, como se muestra en el siguiente archivo `package.json` de ejemplo.
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
En `peerDependencies`, utilice un carácter (^) para especificar la versión más baja de `aws-cdk-lib` con la que funciona la biblioteca. Esto maximiza la compatibilidad de la biblioteca con una variedad de versiones de CDK. Especifique las versiones exactas de los módulos de la Biblioteca de constructos alfa, que tienen las API que pueden cambiar. El uso de `peerDependencies` garantiza que solo haya una copia de todas las bibliotecas de CDK en el árbol de `node_modules`.
En `devDependencies`, especifique las herramientas y bibliotecas que necesita para realizar las pruebas; si lo desea, use ^ para indicar que se aceptan versiones posteriores compatibles. Especifique de forma exacta (sin ^ o \$1) las versiones más bajas de `aws-cdk-lib` y otros paquetes CDK con los que anuncia que su biblioteca es compatible. Esta práctica garantiza que las pruebas se ejecuten con esas versiones. De esta forma, si utiliza inadvertidamente una característica que solo se encuentra en las versiones más recientes, sus pruebas pueden detectarla.
**aviso**
Las `peerDependencies` se instalan automáticamente solo en NPM 7 y versiones posteriores. Si usa NPM 6 o una versión anterior, o si usa Yarn, debe incluir las dependencias de sus dependencias en `devDependencies`. De lo contrario, no se instalarán y recibirá una advertencia sobre las dependencias entre pares no resueltas.
### Instalación y actualización de las dependencias
Ejecute el siguiente comando para instalar las dependencias de su proyecto.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
$ yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
$ yarn install --frozen-lockfile
```
Para actualizar los módulos instalados, se pueden utilizar los comandos anteriores `npm install` y `yarn upgrade`. Cualquiera de los dos comandos actualiza los paquetes en `node_modules` a las versiones más recientes que cumplen las reglas de `package.json`. Sin embargo, no actualizan el propio `package.json`, por lo que puede que desee establecer una nueva versión mínima. Si aloja su paquete en GitHub, puede configurar las [actualizaciones de las versiones del Dependabot](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) para que actualice automáticamente `package.json`. Como alternativa, use [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**importante**
Por diseño, al instalar o actualizar las dependencias, NPM y Yarn eligen la última versión de cada paquete que cumpla con los requisitos especificados en `package.json`. Siempre existe el riesgo de que estas versiones se rompan (ya sea accidental o deliberadamente). Realice pruebas exhaustivas después de actualizar las dependencias de su proyecto.
## Expresiones idiomáticas de AWS CDK en TypeScript
### Props
Todas las clases de Bibliotecas de constructos de AWS se instancian con tres argumentos: el *ámbito* en el que se define el constructo (su elemento principal en el árbol de constructos), un *identificador* y *props*. Los argumentos de *props* son un conjunto de pares clave/valor que el constructo utiliza para configurar los recursos de AWS que crea. Otras clases y métodos también utilizan el patrón de “conjunto de atributos” como argumento.
En TypeScript, la forma de `props` se define mediante una interfaz que indica los argumentos obligatorios y opcionales y sus tipos. Esta interfaz se define para cada tipo de argumento `props` y, por lo general, es específica de un solo constructo o método. Por ejemplo, el constructo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html) (en el módulo `aws-cdk-lib/aws-s3`) especifica un argumento de `props` que se ajusta a la interfaz [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html).
Si una propiedad es en sí misma un objeto, por ejemplo, la propiedad [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect) de `BucketProps`, dicho objeto tendrá su propia interfaz a la que deberá ajustarse su forma, en este caso [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html).
Si subclasifica una clase de Biblioteca de constructos de AWS (o anula un método que utiliza un argumento similar a las props), puede heredarla de la interfaz existente para crear una nueva que especifique los accesorios nuevos que necesite el código. Cuando llama a la clase principal o al método base, normalmente puede pasar todo el argumento de props que haya recibido, ya que se ignorarán todos los atributos proporcionados en el objeto, pero no especificados en la interfaz.
Una futura versión del AWS CDK podría agregar casualmente una nueva propiedad con el nombre que utilizó para su propiedad. Transferir el valor que recibe a la cadena de herencia puede provocar un comportamiento inesperado. Es más seguro transferir una copia superficial de los props recibidos con su propiedad eliminada o establecida como `undefined`. Por ejemplo:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
Como alternativa, nombre sus propiedades para que quede claro que pertenecen a su constructo. De esta forma, es poco probable que colisionen con propiedades en futuras versiones de AWS CDK. Si hay muchas, utilice un único objeto con el nombre apropiado para almacenarlas.
### Valores faltantes
Los valores que faltan en un objeto (como las props) tienen el valor `undefined` en TypeScript. La versión 3.7 del lenguaje introdujo operadores que simplifican el trabajo con estos valores, lo que facilita la especificación de los valores predeterminados y el encadenamiento de “cortocircuitos” cuando se alcanza un valor indefinido. Para obtener más información sobre estas características, consulte las [notas de la versión de TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html), específicamente las dos primeras características, el encadenamiento opcional y la fusión nula.
## Crear y ejecutar aplicaciones de CDK
Por lo general, debe estar en el directorio raíz del proyecto cuando compila y ejecuta la aplicación.
Node.js no puede ejecutar TypeScript directamente; en su lugar, la aplicación se convierte a JavaScript mediante el compilador de TypeScript, `tsc`. A continuación, se ejecuta el código JavaScript resultante.
El AWS CDK hace esto automáticamente siempre que necesite ejecutar la aplicación. Sin embargo, la compilación manual puede resultar útil para comprobar si hay errores y ejecutar pruebas. Para compilar la aplicación TypeScript manualmente, emita `npm run build`. También puede optar por emitir `npm run watch` para entrar en el modo de visualización, en el que el compilador de TypeScript reconstruye automáticamente la aplicación cada vez que guarda los cambios en un archivo fuente.
# Trabajando con el AWS CDK en JavaScript
JavaScript es un lenguaje de cliente totalmente compatible con el AWS CDK y se considera estable. Al trabajar con el AWS Cloud Development Kit (AWS CDK) se JavaScript utilizan herramientas conocidas, como [Node.js](https://nodejs.org/) y Node Package Manager (`npm`). También puede usar [Yarn](https://yarnpkg.com/) si lo prefiere, aunque en los ejemplos de esta guía se usa NPM. [Los módulos que componen la biblioteca AWS Construct se distribuyen a través del repositorio NPM, npmjs.org.](https://www.npmjs.com/)
Puede usar cualquier editor o IDE. Muchos desarrolladores de AWS CDK utilizan [Visual Studio Code (o su equivalente de código](https://code.visualstudio.com/) abierto [VSCodium](https://vscodium.com/)), que cuenta con un buen soporte para. JavaScript
## Comience con JavaScript
Para trabajar con el AWS CDK, debe tener una AWS cuenta y credenciales y tener instalados Node.js y el kit de herramientas del AWS CDK. Consulte [Primeros pasos con](getting-started.md) el CDK. AWS
JavaScript AWS Las solicitudes de CDK no requieren requisitos previos adicionales más allá de estos.
**nota**
Obsolescencia del lenguaje de terceros: la versión en otros idiomas solo se admite hasta que el proveedor o la comunidad compartan su fecha de caducidad (EOL) y está sujeta a cambios con previo aviso.
## Creación de un proyecto
Para crear un nuevo proyecto de AWS CDK, debe invocarlo `cdk init` en un directorio vacío. Utilice la opción `--language` y especifique `javascript`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language javascript
```
Al crear un proyecto, también se instala el módulo [aws-cdk-lib](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html) y sus dependencias.
`cdk init` utiliza el nombre de la carpeta del proyecto para asignar un nombre a varios elementos del proyecto, incluidas las clases, las subcarpetas y los archivos. Los guiones del nombre de la carpeta se convierten en guiones bajos. Sin embargo, de lo contrario, el nombre debe tener la forma de un JavaScript identificador; por ejemplo, no debe empezar por un número ni contener espacios.
## Uso de `cdk` local
En su mayor parte, en esta guía se da por sentado que se instala el kit de herramientas de CDK de forma global (`npm install -g aws-cdk`), y los ejemplos de comandos proporcionados (por ejemplo, `cdk synth`) siguen esta suposición. Este enfoque facilita mantener el kit de herramientas de CDK actualizado y, dado que el CDK sigue una política estricta de compatibilidad con versiones anteriores, generalmente implica poco riesgo utilizar siempre la última versión.
Algunos equipos prefieren especificar todas las dependencias de cada proyecto, incluidas las herramientas como el kit de herramientas de CDK. Esta práctica le permite fijar dichos componentes a versiones específicas y garantizar que todos los desarrolladores de su equipo (y de su CI/CD entorno) utilicen exactamente esas versiones. Esto elimina una posible fuente de cambio, lo que ayuda a que las compilaciones y las implementaciones sean más consistentes y repetibles.
El CDK incluye una dependencia para el kit de herramientas del CDK en las plantillas del JavaScript proyecto`package.json`, por lo que si quieres utilizar este enfoque, no necesitas realizar ningún cambio en el proyecto. Todo lo que necesita hacer es usar comandos ligeramente diferentes para crear su aplicación y para emitir comandos `cdk`.
| Operación | Uso de herramientas globales | Uso de herramientas locales |
| --- | --- | --- |
| **Inicializa el proyecto** | `cdk init --language javascript` | `npx aws-cdk init --language javascript` |
| **Ejecute el comando CDK Toolkit** | `cdk …` | `npm run cdk …` o `npx aws-cdk …` |
`npx aws-cdk` ejecuta la versión del kit de herramientas instalada localmente en el proyecto actual, si está disponible; de lo contrario, utiliza la instalación global, si la hay. Si no existe una instalación global, `npx` descarga una copia temporal del kit de herramientas de CDK y la ejecuta. Puede especificar una versión arbitraria del kit de herramientas de CDK mediante la sintaxis `@`: `npx aws-cdk@1.120 --version` imprime `1.120.0`.
**sugerencia**
Configure un alias para poder usar el comando `cdk` con la instalación local del kit de herramientas de CDK.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## Gestión de los módulos de AWS Construct Library
Use el Node Package Manager (`npm`) para instalar y actualizar los módulos de AWS Construct Library para que los usen sus aplicaciones, así como otros paquetes que necesite. (Puede usar `yarn` en lugar de `npm` si lo prefiere). `npm` también instala las dependencias de esos módulos automáticamente.
La mayoría de las construcciones de AWS CDK se encuentran en el paquete CDK principal, denominado`aws-cdk-lib`, que es una dependencia predeterminada en los nuevos proyectos creados por. `cdk init` Los módulos de la biblioteca de AWS construcciones «experimentales», en los que aún se están desarrollando construcciones de nivel superior, reciben el mismo nombre. `aws-cdk-lib/-alpha` El nombre del servicio tiene el prefijo *aws-*. Si no está seguro del nombre de un módulo, [búsquelo en el NPM](https://www.npmjs.com/search?q=%40aws-cdk).
**nota**
La [referencia de la API de CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) también muestra los nombres de los paquetes.
Por ejemplo, el siguiente comando instala el módulo experimental para. AWS CodeStar
```
npm install @aws-cdk/aws-codestar-alpha
```
El soporte de la Biblioteca de constructos de algunos servicios se encuentra en más de un espacio de nombres. Por ejemplo, además de `aws-route53`, hay tres espacios de nombres adicionales de Amazon Route 53: `aws-route53-targets`, `aws-route53-patterns`, y `aws-route53resolver`.
Las dependencias de su proyecto se mantienen en `package.json`. Puede editar este archivo para bloquear algunas o todas sus dependencias en una versión específica, o para permitir que se actualicen a versiones más recientes según determinados criterios. Esto es para actualizar las dependencias de NPM de su proyecto a la última versión permitida, de acuerdo con las reglas que especificó en `package.json`:
```
npm update
```
En JavaScript, importas módulos a tu código con el mismo nombre que utilizaste para instalarlos mediante NPM. Recomendamos las siguientes prácticas al importar clases de AWS CDK y módulos de AWS Construct Library a sus aplicaciones. Seguir estas pautas ayudará a que su código sea coherente con el de otras aplicaciones de AWS CDK y a que sea más fácil de entender.
+ Utilice `import` directivas`require()`, no ES6 estilícelas. Las versiones anteriores de Node.js no admiten la ES6 importación, por lo que el uso de la sintaxis anterior es más compatible. (Si realmente desea utilizar ES6 las importaciones, utilice [esm](https://www.npmjs.com/package/esm) para asegurarse de que su proyecto es compatible con todas las versiones compatibles de Node.js).
+ Por lo general, se importan clases individuales desde `aws-cdk-lib`.
```
const { App, Stack } = require('aws-cdk-lib');
```
+ Si necesita muchas clases de `aws-cdk-lib`, puede utilizar un alias de espacio de nombres de `cdk` en lugar de importar clases individuales. Evite hacer ambas cosas.
```
const cdk = require('aws-cdk-lib');
```
+ Por lo general, importe las bibliotecas de AWS Construct utilizando alias de espacios de nombres cortos.
```
const { s3 } = require('aws-cdk-lib/aws-s3');
```
## Administrar las dependencias en JavaScript
En los proyectos de JavaScript CDK, las dependencias se especifican en el `package.json` archivo del directorio principal del proyecto. Los módulos AWS CDK principales se encuentran en un único `NPM` paquete denominado. `aws-cdk-lib`
Cuando instala un paquete utilizando `npm install`, el NPM graba el paquete `package.json` por usted.
Si lo prefiere, puede usar Yarn en lugar de NPM. Sin embargo, el CDK no es compatible con el plug-and-play modo de Yarn, que es el modo predeterminado en Yarn 2. Agregue lo siguiente al archivo `.yarnrc.yml` de su proyecto para desactivar esta característica.
```
nodeLinker: node-modules
```
### Aplicaciones de CDK
A continuación, se muestra un ejemplo de un archivo `package.json` generado por el comando `cdk init --language typescript`. El archivo generado para JavaScript es similar, solo que sin las entradas TypeScript relacionadas.
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
En el caso de las aplicaciones de CDK implementables, debe especificarse `aws-cdk-lib` en la sección `dependencies` de `package.json`. Puede utilizar un carácter (^) como especificador del número de versión para indicar que aceptará versiones posteriores a la especificada, siempre que estén dentro de la misma versión principal.
En el caso de las construcciones experimentales, especifique las versiones exactas de los módulos de la biblioteca de construcciones alfa, APIs que pueden cambiar. No utilice ^ ni \$1, ya que las versiones posteriores de estos módulos pueden incluir cambios en la API que pueden dañar su aplicación.
Especifique las versiones de las bibliotecas y herramientas necesarias para probar su aplicación (por ejemplo, el marco de pruebas `jest`) en la sección `devDependencies` de `package.json`. Si lo desea, utilice ^ para especificar si se aceptan versiones posteriores compatibles.
### Bibliotecas de constructos de terceros
Si está desarrollando una Biblioteca de constructos, especifique sus dependencias mediante una combinación de las secciones `peerDependencies` y `devDependencies`, como se muestra en el siguiente archivo `package.json` de ejemplo.
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
En `peerDependencies`, utilice un carácter (^) para especificar la versión más baja de `aws-cdk-lib` con la que funciona la biblioteca. Esto maximiza la compatibilidad de la biblioteca con una variedad de versiones de CDK. Especifique las versiones exactas de los módulos de la biblioteca de construcciones alfa, APIs que pueden cambiar. El uso de `peerDependencies` garantiza que solo haya una copia de todas las bibliotecas de CDK en el árbol de `node_modules`.
En `devDependencies`, especifique las herramientas y bibliotecas que necesita para realizar las pruebas; si lo desea, use ^ para indicar que se aceptan versiones posteriores compatibles. Especifique de forma exacta (sin ^ o \$1) las versiones más bajas de `aws-cdk-lib` y otros paquetes CDK con los que anuncia que su biblioteca es compatible. Esta práctica garantiza que las pruebas se ejecuten con esas versiones. De esta forma, si utiliza inadvertidamente una característica que solo se encuentra en las versiones más recientes, sus pruebas pueden detectarla.
**aviso**
Las `peerDependencies` se instalan automáticamente solo en NPM 7 y versiones posteriores. Si usa NPM 6 o una versión anterior, o si usa Yarn, debe incluir las dependencias de sus dependencias en `devDependencies`. De lo contrario, no se instalarán y recibirá una advertencia sobre las dependencias entre pares no resueltas.
### Instalación y actualización de las dependencias
Ejecute el siguiente comando para instalar las dependencias de su proyecto.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
yarn install --frozen-lockfile
```
Para actualizar los módulos instalados, se pueden utilizar los comandos anteriores `npm install` y `yarn upgrade`. Cualquiera de los dos comandos actualiza los paquetes en `node_modules` a las versiones más recientes que cumplen las reglas de `package.json`. Sin embargo, no actualizan el propio `package.json`, por lo que puede que desee establecer una nueva versión mínima. Si alojas tu paquete en GitHub, puedes configurar las [actualizaciones de las versiones del Dependabot para que](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) se actualicen automáticamente. `package.json` Para otras opciones, consulte [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**importante**
Por diseño, al instalar o actualizar las dependencias, NPM y Yarn eligen la última versión de cada paquete que cumpla con los requisitos especificados en `package.json`. Siempre existe el riesgo de que estas versiones se rompan (ya sea accidental o deliberadamente). Realice pruebas exhaustivas después de actualizar las dependencias de su proyecto.
## AWS Los modismos de CDK están en JavaScript
### Props
Todas las clases de AWS Construct Library se instancian con tres argumentos: el *ámbito* en el que se define la construcción (su elemento principal en el árbol de construcciones), un *identificador* y *props*, un conjunto de key/value pares que la construcción utiliza para configurar los recursos que crea. AWS Otras clases y métodos también utilizan el patrón de “conjunto de atributos” como argumento.
El uso de un IDE o un editor que tenga una buena JavaScript función de autocompletar ayudará a evitar errores ortográficos en los nombres de las propiedades. Si un constructo está esperando una propiedad `encryptionKeys` y la escribe como `encryptionkeys`, al instanciar el constructo, no ha transferido el valor que pretendía. Esto puede provocar un error en el momento de la síntesis si la propiedad es obligatoria, o hacer que la propiedad se ignore silenciosamente si es opcional. En este último caso, es posible que obtenga un comportamiento predeterminado que pretendía anular. Tenga mucho cuidado aquí.
Cuando subclasifique una clase de AWS Construct Library (o sustituya un método que utilice un argumento similar a un objeto), puede que desee aceptar propiedades adicionales para su propio uso. La clase principal o el método anulado ignorarán estos valores, ya que en ese código nunca se accede a ellos, por lo que, en general, puede transferir todas las props que haya recibido.
Una futura versión del AWS CDK podría añadir casualmente una nueva propiedad con el nombre que utilizó para su propia propiedad. Transferir el valor que recibe a la cadena de herencia puede provocar un comportamiento inesperado. Es más seguro transferir una copia superficial de los props recibidos con su propiedad eliminada o establecida como `undefined`. Por ejemplo:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
Como alternativa, nombre sus propiedades para que quede claro que pertenecen a su constructo. De esta forma, es poco probable que choquen con propiedades en futuras versiones de AWS CDK. Si hay muchas, utilice un único objeto con el nombre apropiado para almacenarlas.
### Valores faltantes
Los valores que faltan en un objeto (por ejemplo`props`) tienen el valor `undefined` en. JavaScript Para ello, se aplican las técnicas habituales. Por ejemplo, una expresión idiomática común para acceder a una propiedad de un valor que puede no estar definido es la siguiente:
```
// a may be undefined, but if it is not, it may have an attribute b
// c is undefined if a is undefined, OR if a doesn't have an attribute b
let c = a && a.b;
```
Sin embargo, si `a` pudiera tener algún otro valor “falso” además de `undefined`, es mejor hacer la prueba más explícita. Aquí, aprovecharemos el hecho de que `null` y `undefined` son iguales para probarlos al mismo tiempo:
```
let c = a == null ? a : a.b;
```
**sugerencia**
Node.js 14.0 y las versiones posteriores admiten nuevos operadores que pueden simplificar el manejo de valores indefinidos. Para obtener más información, consulte las propuestas de [encadenamiento opcional](https://github.com/tc39/proposal-optional-chaining/blob/master/README.md) y [fusión de NULL](https://github.com/tc39/proposal-nullish-coalescing/blob/master/README.md).
## Uso de TypeScript ejemplos con JavaScript
[TypeScript](https://www.typescriptlang.org/)es el lenguaje que utilizamos para desarrollar el AWS CDK y fue el primer lenguaje compatible para el desarrollo de aplicaciones, por lo que muchos ejemplos de códigos de AWS CDK disponibles están escritos en él. TypeScript Estos ejemplos de código pueden ser un buen recurso para JavaScript los desarrolladores; basta con eliminar las partes TypeScript específicas del código.
TypeScript Los fragmentos suelen utilizar las palabras clave más recientes ECMAScript `import` y las `export` palabras clave para importar objetos de otros módulos y declarar que los objetos estarán disponibles fuera del módulo actual. Node.js acaba de empezar a admitir estas palabras clave en sus últimas versiones. En función de la versión de Node.js que utilice (o que desee admitir), puede reescribir las importaciones y exportaciones para utilizar la sintaxis anterior.
Las importaciones se pueden sustituir por llamadas a la función `require()`.
**Example**
```
import * as cdk from 'aws-cdk-lib';
import { Bucket, BucketPolicy } from 'aws-cdk-lib/aws-s3';
```
```
const cdk = require('aws-cdk-lib');
const { Bucket, BucketPolicy } = require('aws-cdk-lib/aws-s3');
```
Las exportaciones se pueden asignar al objeto `module.exports`.
**Example**
```
export class Stack1 extends cdk.Stack {
// ...
}
export class Stack2 extends cdk.Stack {
// ...
}
```
```
class Stack1 extends cdk.Stack {
// ...
}
class Stack2 extends cdk.Stack {
// ...
}
module.exports = { Stack1, Stack2 }
```
**nota**
Una alternativa para el uso de las importaciones y exportaciones al estilo antiguo es utilizar el módulo [esm](https://www.npmjs.com/package/esm).
Una vez que haya ordenado las importaciones y exportaciones, puede profundizar en el código real. Es posible que te encuentres con estas funciones de uso común TypeScript :
+ Anotaciones de tipo
+ Definiciones de interfaz
+ Conversiones/casteos de tipos
+ Modificadores de acceso
Se pueden proporcionar anotaciones de tipo para las variables, los miembros de la clase, los parámetros de las funciones y los tipos de retorno de funciones. En el caso de las variables, los parámetros y los miembros, los tipos se especifican siguiendo el identificador con dos puntos y el tipo. Los valores de retorno de las funciones siguen la firma de la función y constan de dos puntos y el tipo.
Para convertir el código anotado en texto JavaScript, elimine los dos puntos y el tipo. Los miembros de la clase deben tener algún valor JavaScript; configúrelo en `undefined` si solo tienen una anotación de texto. TypeScript
**Example**
```
var encrypted: boolean = true;
class myStack extends cdk.Stack {
bucket: s3.Bucket;
// ...
}
function makeEnv(account: string, region: string) : object {
// ...
}
```
```
var encrypted = true;
class myStack extends cdk.Stack {
bucket = undefined;
// ...
}
function makeEnv(account, region) {
// ...
}
```
En TypeScript, las interfaces se utilizan para asignar un nombre a los paquetes de propiedades obligatorias y opcionales y a sus tipos. A continuación, puede utilizar el nombre de la interfaz como anotación de tipo. TypeScript se asegurará de que el objeto que utilice como argumento para una función, por ejemplo, tenga las propiedades requeridas de los tipos correctos.
```
interface myFuncProps {
code: lambda.Code,
handler?: string
}
```
JavaScript no tiene una función de interfaz, por lo que una vez que haya eliminado las anotaciones de tipo, elimine por completo las declaraciones de la interfaz.
*Cuando una función o un método devuelve un tipo de uso general (por ejemplo`object`), pero desea tratar ese valor como un tipo secundario más específico para acceder a propiedades o métodos que no forman parte de la interfaz del tipo más general, TypeScript le permite convertir el valor `as` seguido de un nombre de tipo o interfaz.* JavaScript no lo admite (o no lo necesita), así que basta con quitar `as` y el siguiente identificador. Una sintaxis de conversión menos común es usar el nombre de un tipo entre paréntesis, ``. Estas conversiones también deben eliminarse.
Por último, TypeScript es compatible con los modificadores `public` de acceso y `private` para los miembros de las clases. `protected` Todos los miembros de la clase JavaScript son públicos. Tan solo elimine estos modificadores dondequiera que los vea.
Saber cómo identificar y eliminar estas TypeScript funciones contribuye en gran medida a adaptar los TypeScript fragmentos cortos a ellas. JavaScript Sin embargo, puede resultar poco práctico convertir los TypeScript ejemplos más largos de esta manera, ya que es más probable que utilicen otras funciones. TypeScript Para estas situaciones, recomendamos [Sucrase](https://github.com/alangpierce/sucrase). Sucrase no mostrará un reclamo si el código utiliza una variable indefinida, por ejemplo, como lo haría `tsc`. Si es sintácticamente válido, con pocas excepciones, Sucrase puede traducirlo a. JavaScript Esto lo hace particularmente valioso para convertir fragmentos que tal vez no se puedan ejecutar por sí solos.
## ¿Migrando a TypeScript
Muchos JavaScript desarrolladores se mudan a ella a [TypeScript](https://www.typescriptlang.org/)medida que sus proyectos se hacen más grandes y complejos. TypeScript es un superconjunto de JavaScript (todo el JavaScript código es TypeScript código válido, por lo que no es necesario realizar cambios en el código) y también es un lenguaje CDK compatible. AWS Las anotaciones tipográficas y otras TypeScript funciones son opcionales y se pueden añadir a tu aplicación de AWS CDK a medida que encuentres valor en ellas. TypeScript también te da acceso anticipado a nuevas JavaScript funciones, como el encadenamiento opcional y la fusión de valores nulos, antes de que estén listas y sin necesidad de actualizar Node.js.
TypeScriptSus interfaces «basadas en formas», que definen paquetes de propiedades obligatorias y opcionales (y sus tipos) dentro de un objeto, permiten detectar los errores más comunes al escribir el código y facilitan que el IDE pueda proporcionar consejos sólidos de autocompletado y otros consejos de codificación en tiempo real.
La codificación TypeScript implica un paso adicional: compilar la aplicación con el compilador,. TypeScript `tsc` Para las aplicaciones AWS CDK típicas, la compilación requiere unos segundos como máximo.
La forma más sencilla de migrar una aplicación de JavaScript AWS CDK existente TypeScript es crear un nuevo TypeScript proyecto con `cdk init app --language typescript` los archivos fuente (y cualquier otro archivo necesario, como activos como el código fuente de la función AWS Lambda) y copiarlos al nuevo proyecto. Cambie el nombre de JavaScript los archivos para que terminen en `.ts` y comiencen a desarrollar en. TypeScript
# Trabajando con el AWS CDK en Python
Python es un lenguaje de cliente totalmente compatible con el AWS Cloud Development Kit (AWS CDK) y se considera estable. Para trabajar con la AWS CDK en Python se utilizan herramientas conocidas, como la implementación estándar de Python (CPython), los entornos virtuales con `virtualenv` y el instalador `pip` de paquetes de Python. Los módulos que componen la biblioteca AWS Construct se distribuyen a través de [pypi.org](https://pypi.org/search/?q=aws-cdk). La versión Python del AWS CDK incluso usa identificadores de estilo Python (por ejemplo, nombres de métodos). `snake_case`
Puede usar cualquier editor o IDE. Muchos desarrolladores de AWS CDK usan [Visual Studio Code (o su equivalente de código](https://code.visualstudio.com/) abierto [VSCodium](https://vscodium.com/)), que tiene un buen soporte para Python a través de una extensión [oficial](https://marketplace.visualstudio.com/items?itemName=ms-python.python). El editor IDLE incluido con Python será suficiente para empezar. Los módulos de Python para la AWS CDK tienen sugerencias de tipo, que son útiles para una herramienta de linting o un IDE que admita la validación de tipos.
## Introducción a Python
Para trabajar con el AWS CDK, debe tener una AWS cuenta y credenciales y tener instalados Node.js y el kit de herramientas del AWS CDK. Consulte [Primeros pasos con](getting-started.md) el CDK. AWS
Las aplicaciones de Python AWS CDK requieren Python 3.9 o una versión posterior. Si aún no lo tiene instalado, [descargue una versión compatible](https://www.python.org/downloads/) para su sistema operativo en [python.org](https://www.python.org/). Si utiliza Linux, es posible que su sistema tenga una versión compatible, o puede instalarlo mediante el administrador de paquetes de distribución (`yum`, `apt`, etc.). Los usuarios de Mac pueden estar interesados en [Homebrew](https://brew.sh/), un administrador de paquetes estilo Linux para macOS.
**nota**
Obsolescencia del lenguaje de terceros: la versión en otros idiomas solo se admite hasta que el proveedor o la comunidad compartan su fecha de caducidad (EOL) y está sujeta a cambios con previo aviso.
También se requieren el instalador del paquete Python, `pip`, y el administrador del entorno virtual, `virtualenv`. Las instalaciones de Windows de las versiones de Python compatibles incluyen estas herramientas. En Linux, `pip` y `virtualenv` se pueden proporcionar como paquetes separados en el administrador de paquetes. Como alternativa, también puede instalarlos con los siguientes comandos:
```
python -m ensurepip --upgrade
python -m pip install --upgrade pip
python -m pip install --upgrade virtualenv
```
Si se produce un error de permisos, ejecute los comandos anteriores con la marca `--user` para que los módulos se instalen en su directorio de usuarios o utilice `sudo` para obtener los permisos necesarios para instalar los módulos en todo el sistema.
**nota**
Es común que las distribuciones de Linux usen el nombre ejecutable `python3` para Python 3.x y hagan referencia `python` a una instalación de Python 2.x. Algunas distribuciones tienen un paquete opcional que puede instalar y que hace que el comando `python` haga referencia a Python 3. Si esto no funciona, puede ajustar el comando utilizado para ejecutar la aplicación editando `cdk.json` en el directorio principal del proyecto.
**nota**
En Windows, es posible que desee invocar Python (y `pip`) mediante el ejecutable `py`, el [lanzador >Python para Windows](https://docs.python.org/3/using/windows.html#launcher). Entre otras cosas, el lanzador permite especificar fácilmente qué versión instalada de Python desea usar.
Si cuando escribe `python` en la línea de comandos aparece un mensaje sobre la instalación de Python desde la Tienda Windows, incluso después de instalar una versión de Python para Windows, abra el panel de configuración Administrar alias de ejecución de aplicaciones de Windows y desactive las dos entradas del instalador de aplicaciones para Python.
## Creación de un proyecto
Para crear un nuevo proyecto de AWS CDK, debe invocarlo `cdk init` en un directorio vacío. Utilice la opción `--language` y especifique `python`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language python
```
`cdk init` utiliza el nombre de la carpeta del proyecto para asignar un nombre a varios elementos del proyecto, incluidas las clases, las subcarpetas y los archivos. Los guiones del nombre de la carpeta se convierten en guiones bajos. Aunque, de lo contrario, el nombre debe seguir la forma de un identificador de Python; por ejemplo, no debe comenzar por un número ni contener espacios.
Para trabajar con el nuevo proyecto, active su entorno virtual. Esto permite que las dependencias del proyecto se instalen localmente en la carpeta del proyecto, en lugar de hacerlo globalmente.
```
$ source .venv/bin/activate
```
**nota**
Puede que lo reconozca como el Mac/Linux comando para activar un entorno virtual. Las plantillas de Python incluyen un archivo por lotes, `source.bat`, que permite utilizar el mismo comando en Windows. El comando tradicional de Windows `.\venv\Scripts\activate` también funciona.
Si inicializó su proyecto de CDK con AWS CDK Toolkit v1.70.0 o una versión anterior, su entorno virtual está en el directorio en lugar de hacerlo. `.env` `.venv`
**importante**
Active el entorno virtual del proyecto cada vez que empiece a trabajar en él. De lo contrario, no tendrá acceso a los módulos instalados allí y los módulos que instale irán al directorio global de módulos de Python (o generarán un error de permiso).
Tras activar su entorno virtual por primera vez, instale las dependencias estándar de la aplicación:
```
$ python -m pip install -r requirements.txt
```
## AWS Administrar los módulos de Construct Library
Usa el instalador de paquetes de Python para instalar y actualizar los módulos de AWS Construct Library para que los usen tus aplicaciones, así como otros paquetes que necesites. `pip` `pip`también instala las dependencias de esos módulos automáticamente. Si su sistema no reconoce `pip` como un comando independiente, invoque `pip` como un módulo de Python, de la siguiente manera:
```
$ python -m pip
```
La mayoría de las construcciones de AWS CDK están incluidas. `aws-cdk-lib` Los módulos experimentales están en módulos separados denominados `aws-cdk..alpha`. El nombre del servicio incluye un prefijo *aws*. Si no está seguro del nombre de un módulo, [búsquelo en PyPI](https://pypi.org/search/?q=aws-cdk). Por ejemplo, el siguiente comando instala la biblioteca. AWS CodeStar
```
$ python -m pip install aws-cdk.aws-codestar-alpha
```
Los constructos de algunos servicios están en más de un espacio de nombres. Por ejemplo, además de `aws-cdk.aws-route53`, hay tres espacios de nombres adicionales de Amazon Route 53: denominados `aws-route53-targets`, `aws-route53-patterns` y `aws-route53resolver`.
**nota**
La [edición de Python de la referencia de la API de CDK](https://docs.aws.amazon.com/cdk/api/v2/python/index.html) también muestra los nombres de los paquetes.
Los nombres utilizados para importar los módulos de AWS Construct Library al código de Python son los siguientes.
```
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_lambda as lambda_
```
Recomendamos las siguientes prácticas al importar clases de AWS CDK y módulos de AWS Construct Library a sus aplicaciones. Seguir estas pautas ayudará a que su código sea coherente con el de otras aplicaciones de AWS CDK y a que sea más fácil de entender.
+ En general, importe clases individuales del nivel superior de `aws_cdk`.
```
from aws_cdk import App, Construct
```
+ Si necesita muchas clases de `aws_cdk`, puede utilizar un alias de espacio de nombres de `cdk` en lugar de importar clases individuales. Evite hacer ambas cosas.
```
import aws_cdk as cdk
```
+ Por lo general, importe las bibliotecas de AWS Construct utilizando alias de espacios de nombres cortos.
```
import aws_cdk.aws_s3 as s3
```
Después de instalar un módulo, actualice el archivo `requirements.txt` del proyecto, que contiene una lista de las dependencias del proyecto. Es mejor hacerlo manualmente en lugar de usar `pip freeze`. `pip freeze` captura las versiones actuales de todos los módulos instalados en el entorno virtual de Python, lo que puede resultar útil cuando se agrupa un proyecto para ejecutarlo en otro lugar.
Sin embargo, normalmente el `requirements.txt` debe enumerar solo las dependencias de nivel superior (los módulos de los que depende directamente la aplicación) y no las dependencias de esas bibliotecas. Esta estrategia simplifica la actualización de las dependencias.
Puede editar `requirements.txt` para permitir las actualizaciones; basta con sustituir `==` a un número de versión anterior con `~=` para que permita actualizar a una versión compatible superior o eliminar por completo el requisito de versión para especificar la última versión disponible del módulo.
Si `requirements.txt` se editó adecuadamente para permitir las actualizaciones, ejecute este comando para actualizar los módulos instalados del proyecto en cualquier momento:
```
$ pip install --upgrade -r requirements.txt
```
## Administración de dependencias en Python
En Python, las dependencias se especifican colocándolas en `requirements.txt` para aplicaciones o `setup.py` para bibliotecas de constructos. Luego, las dependencias se administran con la herramienta PIP. El PIP se invoca de una de las siguientes formas:
```
pip
python -m pip
```
La invocación `python -m pip` funciona en la mayoría de los sistemas; `pip` requiere que el ejecutable de PIP esté en la ruta del sistema. Si `pip` no funciona, intente sustituirlo por `python -m pip`.
El comando `cdk init --language python` crea un entorno virtual para su nuevo proyecto. Esto permite que cada proyecto tenga sus propias versiones de las dependencias y también un archivo `requirements.txt` básico. Debe activar este entorno virtual. Para ello, ejecute `source .venv/bin/activate` cada vez que comience a trabajar en el proyecto. En Windows, ejecute `.\venv\Scripts\activate` en su lugar.
### Aplicaciones CDK
A continuación se muestra un ejemplo de un archivo `requirements.txt`. Como PIP no tiene una característica de bloqueo de dependencias, recomendamos que utilice el operador == para especificar las versiones exactas de todas las dependencias, como se muestra aquí.
```
aws-cdk-lib==2.14.0
aws-cdk.aws-appsync-alpha==2.10.0a0
```
Cuando instala un módulo mediante `pip install`, este no se agrega automáticamente a `requirements.txt`. Debe hacerlo usted mismo. Si desea actualizar a una versión posterior de una dependencia, edite su número de versión en `requirements.txt`.
Para instalar o actualizar las dependencias del proyecto después de crear o editar `requirements.txt`, ejecute lo siguiente:
```
python -m pip install -r requirements.txt
```
**sugerencia**
El comando `pip freeze` muestra las versiones de todas las dependencias instaladas en un formato que se puede escribir en un archivo de texto. Se puede utilizar como un archivo de requisitos con `pip install -r`. Este archivo es práctico para fijar todas las dependencias (incluidas las transitivas) a las versiones exactas con las que llevó a cabo las pruebas. Para evitar problemas cuando actualice los paquetes más adelante, utilice un archivo independiente para ello, como `freeze.txt` (no `requirements.txt`). A continuación, regenérelo cuando actualice las dependencias del proyecto.
### Bibliotecas de constructos de terceros
En las bibliotecas, las dependencias se especifican en `setup.py`, de modo que las dependencias transitivas se descargan automáticamente cuando una aplicación utiliza el paquete. De lo contrario, todas las aplicaciones que quieran usar su paquete deberán copiar sus dependencias en su `requirements.txt` A continuación, se muestra un ejemplo de `setup.py`.
```
from setuptools import setup
setup(
name='my-package',
version='0.0.1',
install_requires=[
'aws-cdk-lib==2.14.0',
],
...
)
```
Para trabajar en el paquete de desarrollo, cree o active un entorno virtual y, a continuación, ejecute el siguiente comando.
```
python -m pip install -e .
```
Aunque PIP instala automáticamente las dependencias transitivas, solo puede haber una copia instalada de cada paquete. Se selecciona la versión que se especifique más arriba en el árbol de dependencias; las aplicaciones siempre tienen la última palabra sobre qué versión de los paquetes se instalan.
## AWS Modismos de CDK en Python
### Conflictos entre lenguajes
En Python, `lambda` es una palabra clave del lenguaje, por lo que no se puede utilizar como nombre para el módulo de biblioteca de construcciones de AWS Lambda ni para las funciones de Lambda. La convención de Python para este tipo de conflictos es usar un guion bajo al final, como en el nombre de la variable `lambda_`.
Por convención, se denomina al segundo argumento de las construcciones de AWS CDK. `id` Cuando escribe sus propias pilas y constructos, llamar a un parámetro `id` “sombras” la función integrada de Python `id()`, que devuelve el identificador único de un objeto. Esta función no se usa con mucha frecuencia, pero si la necesita en el constructo, cambie el nombre del argumento, por ejemplo `construct_id`.
### Argumentos y propiedades
Todas las clases de AWS Construct Library se instancian con tres argumentos: el *ámbito* en el que se define la construcción (su elemento principal en el árbol de construcciones), un *identificador* y *props*, un conjunto de key/value pares que la construcción utiliza para configurar los recursos que crea. Otras clases y métodos también utilizan el patrón de “agrupación de atributos” como argumento.
*scope* e *id* siempre deben pasarse como argumentos posicionales, no como argumentos de palabras clave, ya que sus nombres cambian si el constructo acepta una propiedad denominada *scope* o *id*.
En Python, los props se expresan como argumentos de palabras clave. Si un argumento contiene estructuras de datos anidadas, estas se expresan mediante una clase que toma sus propios argumentos de palabras clave en la instanciación. El mismo patrón se aplica a otras llamadas de métodos que utilizan un argumento estructurado.
Por ejemplo, en el método `add_lifecycle_rule` de un bucket de Amazon S3, la propiedad `transitions` es una lista de instancias `Transition`.
```
bucket.add_lifecycle_rule(
transitions=[
Transition(
storage_class=StorageClass.GLACIER,
transition_after=Duration.days(10)
)
]
)
```
Cuando amplíe una clase o anule un método, es posible que desee aceptar argumentos adicionales para sus propios fines que la clase principal no comprenda. En este caso, debe aceptar los argumentos que no tenga problema en usar en la expresión idiomática \$1\$1kwargs y usar argumentos que solo contengan palabras clave para aceptar los argumentos que sean de su interés. Cuando llame al constructo del método principal o al anulado, pase solo los argumentos que espera (normalmente solo \$1\$1kwargs). Si se pasan argumentos que la clase o el método principal no esperan, se produce un error.
```
class MyConstruct(Construct):
def __init__(self, id, *, MyProperty=42, **kwargs):
super().__init__(self, id, **kwargs)
# ...
```
Una futura versión del AWS CDK podría añadir casualmente una nueva propiedad con el nombre que utilizó para su propia propiedad. Esto no provocará ningún problema técnico a los usuarios de su constructo o método (dado que su propiedad no pasa a un nivel superior de la cadena, la clase principal o el método anulado simplemente utilizarán un valor predeterminado), pero puede provocar confusión. Puede evitar este posible problema asignando un nombre a sus propiedades de forma que pertenezcan claramente a su constructo. Si hay muchas propiedades nuevas, agrúpelas en una clase con el nombre adecuado y pásela como un único argumento de palabra clave.
### Valores faltantes
El AWS CDK se utiliza `None` para representar valores faltantes o indefinidos. Cuando trabaje con \$1\$1kwargs, utilice el método `get()` del diccionario para proporcionar un valor predeterminado si no se proporciona una propiedad. Evite usar `kwargs[…]`, ya que esto aumenta los `KeyError` para los valores faltantes.
```
encrypted = kwargs.get("encrypted") # None if no property "encrypted" exists
encrypted = kwargs.get("encrypted", False) # specify default of False if property is missing
```
Es posible que algunos métodos de AWS CDK (por ejemplo, `tryGetContext()` para obtener un valor de contexto en tiempo de ejecución) devuelvan`None`, lo que tendrá que comprobar de forma explícita.
### Uso de una interfaz
Python no tiene una característica de interfaz como la tienen otros lenguajes, aunque sí tiene [clases base abstractas](https://docs.python.org/3/library/abc.html), que son similares. (Si no estás familiarizado con las interfaces, Wikipedia tiene [una buena introducción](https://en.wikipedia.org/wiki/Interface_(computing)#In_object-oriented_languages)). TypeScript, el lenguaje en el que se implementa la AWS CDK, proporciona interfaces, y las construcciones y otros objetos de la AWS CDK suelen requerir un objeto que se adhiera a una interfaz determinada, en lugar de heredarlo de una clase determinada. [Por lo tanto, la AWS CDK proporciona su propia función de interfaz como parte de la capa JSII.](https://github.com/aws/jsii)
Para indicar que una clase implementa una interfaz en particular, puede usar el decorador `@jsii.implements`:
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
### Dificultades de escritura
Python usa la escritura dinámica, en la que todas las variables pueden hacer referencia a un valor de cualquier tipo. Los parámetros y los valores devueltos se pueden anotar mediante escritura, pero se trata de “sugerencias” y no se aplican. Esto significa que en Python, es fácil pasar el tipo de valor incorrecto a una construcción AWS CDK. En lugar de recibir un error de tipo durante la compilación, como ocurriría con un lenguaje de tipado estático, es posible que se produzca un error de tiempo de ejecución cuando la capa JSII (que traduce entre Python y el TypeScript núcleo del AWS CDK) no pueda procesar el tipo inesperado.
Según nuestra experiencia, los errores de tipo que cometen los programadores de Python suelen clasificarse en estas categorías.
+ Pasar un único valor donde un constructo espera un contenedor (lista o diccionario de Python) o viceversa.
+ Pasar un valor de un tipo asociado a una construcción de capa 1 (`CfnXxxxxx`) a un constructo de L2 o L3, o viceversa.
## Evitar errores tipográficos
Los módulos Python de AWS CDK incluyen anotaciones de tipo, por lo que puede utilizar las herramientas que los admiten para detectar los errores de tipo antes de la implementación.
### Integración con IDE (recomendada)
Visual Studio Code con Pylance proporciona una comprobación de tipos en tiempo real a medida que se escribe código:
1. [Instale la extensión Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
1. Configure la verificación estricta de tipos en: `.vscode/settings.json`
```
{
"python.languageServer": "Pylance",
"python.analysis.typeCheckingMode": "strict"
}
```
1. Los errores tipográficos ahora aparecen inmediatamente con garabatos rojos y mensajes de error detallados
[PyCharm](https://www.jetbrains.com/pycharm/)también proporciona una comprobación tipográfica integrada con funciones similares.
### Comprobación de tipos desde la línea de comandos
Para CI/CD las validaciones en canalización o previas a la confirmación, usa uno de estos verificadores de tipos:
**MyPy (Basado en Python):**
```
pip install mypy
mypy app.py
```
**Derechos de autor (más rápido, JavaScript basado en el mismo motor que Pylance):**
```
npm install -g pyright
pyright app.py
```
### Flujo de trabajo recomendado
1. Durante el desarrollo: usa Pyright o Pylance para obtener comentarios instantáneos
1. Antes de confirmar: Ejecuta o `mypy app.py` `pyright app.py`
1. En CI/CD: haga que la verificación de tipos sea un paso obligatorio antes de la implementación
# Trabajar con el AWS CDK en Java
Java es un lenguaje de cliente totalmente compatible con el AWS CDK y se considera estable. Puede desarrollar aplicaciones de AWS CDK en Java con herramientas conocidas, como el JDK (de Oracle o una distribución de OpenJDK como Amazon Corretto) y Apache Maven.
El AWS CDK es compatible con Java 8 y versiones posteriores. Sin embargo, le recomendamos que utilice la versión más reciente posible, ya que las versiones posteriores del lenguaje incluyen mejoras que son especialmente prácticas para desarrollar aplicaciones de AWS CDK. Por ejemplo, Java 9 introduce el `Map.of()` método (una forma práctica de declarar mapas hash que se escribirían como objetos literales). TypeScript Java 10 introduce la inferencia de tipos locales mediante la palabra clave `var`.
**nota**
La mayoría de los ejemplos de código de esta Guía para desarrolladores funcionan con Java 8. Algunos ejemplos utilizan `Map.of()`; estos ejemplos incluyen comentarios en los que se indica que requieren Java 9.
Puedes usar cualquier editor de texto o un IDE de Java que pueda leer proyectos de Maven para trabajar en tus AWS aplicaciones de CDK. En esta guía proporcionamos sugerencias sobre [Eclipse](https://www.eclipse.org/downloads/), pero IntelliJ NetBeans, IDEA y IDEs otros pueden importar proyectos de Maven y pueden usarse para AWS desarrollar aplicaciones de CDK en Java.
Es posible escribir aplicaciones de AWS CDK en lenguajes alojados en JVM distintos de Java (por ejemplo, Kotlin, Groovy, Clojure o Scala), pero es posible que la experiencia no sea especialmente idiomática y no podamos ofrecer soporte para estos lenguajes.
## Introducción a Java
Para trabajar con el AWS CDK, debe tener una cuenta y credenciales, y tener instalados Node.js y el kit de herramientas del CDK. AWS AWS Consulte [Introducción al CDK](getting-started.md). AWS
Las aplicaciones del AWS CDK de Java requieren Java 8 (v1.8) o una versión posterior. Recomendamos [Amazon Corretto](https://aws.amazon.com/corretto/), pero puede usar cualquier distribución de OpenJDK o [JDK de Oracle](https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html). También necesitará [Apache Maven](https://maven.apache.org/download.cgi) 3.5 o una versión posterior. También puedes usar herramientas como Gradle, pero los esqueletos de aplicaciones generados por el kit de herramientas del AWS CDK son proyectos de Maven.
**nota**
Obsolescencia del lenguaje de terceros: la versión en otros idiomas solo se admite hasta que el proveedor o la comunidad compartan su fecha de caducidad (EOL) y está sujeta a cambios con previo aviso.
## Creación de un proyecto
Para crear un nuevo proyecto de AWS CDK, debe invocarlo en un directorio vacío. `cdk init` Utilice la opción `--language` y especifique `java`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language java
```
`cdk init` utiliza el nombre de la carpeta del proyecto para asignar un nombre a varios elementos del proyecto, incluidas las clases, las subcarpetas y los archivos. Los guiones del nombre de la carpeta se convierten en guiones bajos. Sin embargo, de lo contrario, el nombre debe seguir la forma de un identificador Java; por ejemplo, no debe comenzar por un número ni contener espacios.
El proyecto resultante incluye una referencia al paquete Maven de `software.amazon.awscdk`. Maven lo instala automáticamente, así como a sus dependencias.
Si utiliza un IDE, ahora puede abrir o importar el proyecto. Por ejemplo, en Eclipse, elija **Archivo** > **Importar** > **Maven** > **Proyectos de Maven existentes**. Asegúrese de que la configuración del proyecto esté configurada para utilizar Java 8 (1.8).
## Gestión de los módulos de AWS Construct Library
Use Maven para instalar los paquetes de AWS Construct Library, que están en el grupo`software.amazon.awscdk`. La mayoría de los constructos se encuentran en el artefacto `aws-cdk-lib`, que se agrega a los nuevos proyectos de Java de forma predeterminada. Los módulos para los servicios cuyo soporte de CDK de nivel superior aún se está desarrollando se encuentran en paquetes «experimentales» separados, denominados con una versión corta (no o con el prefijo de AWS Amazon) del nombre de su servicio. [Busque en el repositorio central de Maven](https://search.maven.org/search?q=software.amazon.awscdk) los nombres de todas las bibliotecas de AWS CDK y Construct Module. AWS
**nota**
La [edición Java de la referencia de la API del CDK](https://docs.aws.amazon.com/cdk/api/v2/java/index.html) también muestra los nombres de los paquetes.
El soporte de AWS Construct Library de algunos servicios está en más de un espacio de nombres. Por ejemplo, Amazon Route 53 tiene su funcionalidad dividida en `software.amazon.awscdk.route53`, `route53-patterns`, `route53resolver` y`route53-targets`.
El paquete AWS CDK principal se importa en código Java como. `software.amazon.awscdk` Los módulos de los distintos servicios de la biblioteca AWS Construct se encuentran bajo el nombre de su paquete Maven `software.amazon.awscdk.services` y reciben un nombre similar al de su paquete. Por ejemplo, el espacio de nombres del módulo Amazon S3 es `software.amazon.awscdk.services.s3`.
Recomendamos escribir una `import` sentencia Java independiente para cada clase de AWS Construct Library que utilice en cada uno de sus archivos fuente de Java y evitar las importaciones de caracteres comodín. Siempre puede utilizar el nombre completo de un tipo (incluido su espacio de nombres) sin una instrucción `import`.
Si la aplicación depende de un paquete experimental, edite el `pom.xml` del proyecto y agregue un nuevo elemento `` al contenedor ``. Por ejemplo, el siguiente `` elemento especifica el módulo de biblioteca de construcciones CodeStar experimental:
```
software.amazon.awscdkcodestar-alpha2.0.0-alpha.10
```
**sugerencia**
Si usa un IDE de Java, probablemente tenga características para administrar las dependencias de Maven. Sin embargo, recomendamos editar el `pom.xml` de forma directa, a menos que esté absolutamente seguro de que la funcionalidad del IDE coincide con lo que haría a mano.
## Administración de dependencias en Java
En Java, las dependencias se especifican en `pom.xml` y se instalan mediante Maven. El contenedor `` incluye un elemento `` para cada paquete. La siguiente es una sección de `pom.xml` de una aplicación Java de CDK típica.
```
software.amazon.awscdkaws-cdk-lib2.14.0software.amazon.awscdkappsync-alpha2.10.0-alpha.0
```
**sugerencia**
Muchos Java IDEs tienen el soporte de Maven integrado y `pom.xml` editores visuales, lo que puede resultarle práctico para gestionar las dependencias.
Maven no admite el bloqueo de dependencias. Aunque es posible especificar rangos de versiones en `pom.xml`, recomendamos que utilice siempre versiones exactas para que las compilaciones se puedan repetir.
Maven instala de forma automática las dependencias transitivas, pero solo puede haber una copia instalada de cada paquete. Se selecciona la versión que se especifique más arriba en el árbol POM; las aplicaciones siempre tienen la última palabra en cuanto a la versión de los paquetes que se instalan.
Maven instala o actualiza de forma automática las dependencias cada vez que compila (`mvn compile`) o empaquetas (`mvn package`) su proyecto. El kit de herramientas de CDK lo hace de forma automática cada vez que lo ejecuta, por lo que, por lo general, no es necesario invocar Maven de forma manual.
## AWS Modismos de CDK en Java
### Props
Todas las clases de AWS Construct Library se instancian con tres argumentos: el *ámbito* en el que se define la construcción (su elemento principal en el árbol de construcciones), un *identificador* y *props*, un conjunto de key/value pares que la construcción utiliza para configurar los recursos que crea. Otras clases y métodos también utilizan el patrón de "agrupación de atributos" como argumento.
En Java, los props se expresan mediante el [patrón Constructor](https://en.wikipedia.org/wiki/Builder_pattern). Cada tipo de constructo tiene un tipo de props correspondiente; por ejemplo, el constructo `Bucket` (que representa un bucket de Amazon S3) toma como props una instancia de `BucketProps`.
La `BucketProps` clase (como todas las clases de props de AWS Construct Library) tiene una clase interna llamada. `Builder` El tipo `BucketProps.Builder` ofrece métodos para configurar las distintas propiedades de una instancia `BucketProps`. Cada método devuelve la instancia `Builder`, por lo que las llamadas a los métodos se pueden encadenar para establecer varias propiedades. Al final de la cadena, se llama a `build()` para producir de forma efectiva el objeto `BucketProps`.
```
Bucket bucket = new Bucket(this, "amzn-s3-demo-bucket", new BucketProps.Builder()
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build());
```
Los constructos y otras clases que utilizan como argumento final un objeto similar a un props ofrecen un atajo. La clase tiene un `Builder` propio que crea una instancia de ella y de su objeto props en un solo paso. De esta forma, no necesita crear instancias explícitas (por ejemplo) tanto `BucketProps` como `Bucket`, y no necesita importar el tipo props.
```
Bucket bucket = Bucket.Builder.create(this, "amzn-s3-demo-bucket")
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build();
```
Al derivar su propio constructo a partir de uno existente, es posible que desee aceptar las propiedades adicionales. Le recomendamos que siga estos patrones de construcción. Sin embargo, esto no es tan simple como subclasificar una clase de constructo. Debe proporcionar usted mismo las partes móviles de las dos nuevas clases de `Builder`. Es posible que prefiera que su constructo solo acepte uno o más argumentos adicionales. Debe proporcionar constructores adicionales cuando un argumento sea opcional.
### Estructuras genéricas
En algunas APIs, el AWS CDK usa JavaScript matrices u objetos sin tipo como entrada a un método. (Consulte, por ejemplo, el método de.) AWS CodeBuild [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue) En Java, estos objetos se representan como `java.util.Map`. En los casos en que todos los valores son cadenas, puede utilizar `Map`.
Java no proporciona una forma de escribir literales para dichos contenedores como lo hacen otros lenguajes. En Java 9 y versiones posteriores, se pueden utilizar [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-) para definir cómodamente mapas de hasta diez entradas en línea con una de estas llamadas.
```
java.util.Map.of(
"base-directory", "dist",
"files", "LambdaStack.template.json"
)
```
Para crear mapas con más de diez entradas, utilice [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-).
Si utiliza Java 8, puede proporcionar sus propios métodos similares a estos.
JavaScript las matrices se representan como `List