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.
# Cómo empezar con el CDK AWS
Comience con el AWS Cloud Development Kit (AWS CDK) instalando y configurando la interfaz de línea de comandos de AWS CDK (AWS CDK CLI). A continuación, utilice la CLI de CDK para crear su primera aplicación de CDK, iniciar el AWS entorno e implementar la aplicación.
## Requisitos previos
Antes de empezar a utilizar la AWS CDK, complete todos los requisitos previos. Estos requisitos previos son obligatorios para los principiantes AWS o principiantes en la programación. Para obtener instrucciones, consulte los [requisitos previos de AWS CDK](prerequisites.md).
Le recomendamos que tenga un conocimiento básico de lo que es el AWS CDK. Para obtener más información, consulte [¿Qué es la AWS CDK?](home.md) y [aprenda los conceptos básicos del AWS CDK](core-concepts.md).
## Instalación de la CLI del AWS CDK
Para instalar la CLI de CDK, utilice el Administrador de paquetes de Node. Le recomendamos que la instale de forma global con el siguiente comando:
```
$ npm install -g aws-cdk
```
Para instalar una versión específica de la CLI de CDK, utilice la siguiente estructura de comandos:
```
$ npm install -g aws-cdk@X.YY.Z
```
Si desea utilizar varias versiones de la AWS CDK, considere la posibilidad de instalar una versión correspondiente de la CLI de la CDK en proyectos individuales de la CDK. Para ello, elimine la opción `-g` del comando `npm install`. A continuación, utilice `npx aws-cdk` para invocar la CLI de CDK. Esto ejecutará una versión local, en caso de que exista. De lo contrario, se utilizará la versión instalada de forma global.
**Solucionar problemas en la instalación de la CLI de CDK**
Si aparece un error de permiso y tiene acceso de administrador en el sistema, ejecute lo siguiente:
```
$ sudo npm install -g aws-cdk
```
Si recibe un mensaje de error, intente desinstalar la CLI de CDK al ejecutar lo siguiente:
```
$ npm uninstall -g aws-cdk
```
A continuación, repita los pasos para volver a instalar la CLI de CDK.
## Compruebe que la instalación de la CLI de CDK se realizó correctamente
Ejecute los siguientes comandos para comprobar que se instaló correctamente. La CLI del AWS CDK debería generar el número de versión:
```
$ cdk --version
```
## Configurar la CLI del AWS CDK
Después de instalar la CLI de CDK, puede empezar a usarla para desarrollar aplicaciones en su máquina local. Para interactuar con AWS, por ejemplo, implementar aplicaciones, debe tener las credenciales de seguridad configuradas en su máquina local con permisos para realizar cualquier acción que inicie.
Para configurar las credenciales de seguridad en su máquina local, utilice la AWS CLI. La forma de configurar las credenciales de seguridad depende de la forma en que administre los usuarios. Para obtener instrucciones, consulte las [credenciales de autenticación y acceso](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) en la *Guía del usuario de la interfaz de línea de AWS comandos*.
La CLI de CDK utilizará automáticamente las credenciales de seguridad que configure con la AWS CLI. Por ejemplo, si es usuario de IAM Identity Center, puede utilizar el comando `aws configure sso` para configurar credenciales de seguridad. Si es usuario de IAM, puede utilizar el comando `aws configure`. La AWS CLI lo guiará a través de la configuración de las credenciales de seguridad en su máquina local y guardará la información necesaria en sus `credentials` archivos `config` and. A continuación, cuando utilice la CLI de CDK, por ejemplo, si implementa una aplicación con `cdk deploy`, la CLI de CDK utilizará las credenciales de seguridad que haya configurado.
Al igual que la AWS CLI, la CLI de CDK utilizará su `default` perfil de forma predeterminada. Puede especificar un perfil mediante la opción [`--profile`](ref-cli-cmd.md#ref-cli-cmd-options-profile) de la CLI de CDK. Para obtener más información sobre el uso de credenciales de seguridad con la CLI de CDK, consulte [Configurar las credenciales de seguridad para la AWS CLI de CDK](configure-access.md).
## (Opcional) Instale herramientas CDK adicionales AWS
El [kit de herramientas de AWS para Visual Studio Code](https://aws.amazon.com/visualstudiocode/) es un complemento de código abierto para Visual Studio Code que lo ayuda a crear, depurar e implementar aplicaciones en AWS. El kit de herramientas proporciona una experiencia integrada para desarrollar aplicaciones de AWS CDK. Incluye la función AWS CDK Explorer para enumerar sus proyectos de AWS CDK y explorar los distintos componentes de la aplicación CDK. Para obtener instrucciones, consulte lo siguiente:
+ [Instalación del AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html).
+ [AWS CDK para VS Code.](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html)
## Creación de su primera aplicación de CDK
Ahora está listo para empezar a usar el AWS CDK creando su primera aplicación de CDK. Para obtener instrucciones, consulte el [tutorial: Cree su primera aplicación de AWS CDK](hello-world.md).
# Tutorial: Crea tu primera aplicación de AWS CDK
Comience a usar el AWS Cloud Development Kit (AWS CDK) mediante la interfaz de línea de comandos de AWS CDK (AWS CDK CLI) para desarrollar su primera aplicación de CDK, arrancar AWS su entorno e implementar su aplicación. AWS
## Requisitos previos
Antes de comenzar este tutorial, complete todos los pasos de configuración que aparecen en [Introducción](getting-started.md) a la CDK. AWS
## Acerca de este tutorial
En este tutorial, creará e implementará una aplicación sencilla sobre el AWS uso del AWS CDK. La aplicación consta de una [función de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) que devuelve un mensaje de `Hello World!` cuando se invoca. La función se invocará a través de la [URL de la función de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) que sirve como punto de conexión HTTP(S) dedicado para la función de Lambda.
A través de este tutorial, hará lo siguiente:
+ **Crear su proyecto**: cree un proyecto de CDK mediante el comando `cdk init` de la CLI de CDK.
+ **Configure su AWS entorno**: configure el AWS entorno en el que implementará la aplicación.
+ **Inicie su AWS entorno**: prepare su AWS entorno para la implementación iniciándolo mediante el comando CDK CLI. `cdk bootstrap`
+ **Desarrolle su aplicación**: utilice construcciones de la biblioteca AWS Construct para definir los recursos de URL de la función Lambda y la función Lambda.
+ **Prepare su aplicación para la implementación**: use la CLI de CDK para crear su aplicación y sintetizar una AWS CloudFormation plantilla.
+ **Implemente su aplicación**: utilice el `cdk deploy` comando CLI de CDK para implementar su aplicación y aprovisionar sus AWS recursos.
+ **Interactúe con su aplicación**: interactúe con la función Lambda AWS desplegada invocándola y recibiendo una respuesta.
+ **Modificar su aplicación**: modifique su función de Lambda e impleméntela para aplicar sus cambios.
+ **Eliminar la aplicación**: elimine todos los recursos creados con el comando `cdk destroy` de la CLI de CDK.
## Paso 1: cree su proyecto de CDK
En este paso va a crear un proyecto nuevo de CDK. Un proyecto de CDK debe estar en su propio directorio, con sus propias dependencias de módulos locales.
**Para crear un proyecto de CDK**
1. Desde el directorio de inicio que elija, cree y navegue hasta un directorio denominado `hello-cdk`:
```
$ mkdir hello-cdk && cd hello-cdk
```
**importante**
Asegúrese de asignar un nombre al directorio del proyecto `hello-cdk`, *exactamente como se muestra aquí*. La CLI de CDK usa este nombre de directorio para nombrar las características del código del CDK. Si utiliza otro nombre de directorio, tendrá problemas durante este tutorial.
1. Desde el directorio `hello-cdk`, inicie un nuevo proyecto de CDK a través del comando `cdk init` de la CLI de CDK. Especifique la plantilla de la `app` y su lenguaje de programación preferido con la opción `--language`:
**Example**
------
#### [ TypeScript ]
```
$ cdk init app --language typescript
```
------
#### [ JavaScript ]
```
$ cdk init app --language javascript
```
------
#### [ Python ]
```
$ cdk init app --language python
```
Una vez que cree la aplicación, ingrese también los siguientes dos comandos. Estos activan el entorno virtual Python de la aplicación e instalan las dependencias principales del AWS CDK.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
$ cdk init app --language java
```
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).
------
#### [ C\$1 ]
```
$ cdk init app --language csharp
```
Si utiliza Visual Studio, abra el archivo de la solución en el directorio `src`.
------
#### [ Go ]
```
$ cdk init app --language go
```
Una vez creada la aplicación, introduce también el siguiente comando para instalar los módulos de AWS Construct Library que requiere la aplicación.
```
$ go get
```
------
El comando `cdk init` crea una estructura de archivos y carpetas dentro del directorio `hello-cdk` para ayudar a organizar el código fuente de la aplicación de CDK. Esta estructura de archivos y carpetas se denomina *proyecto* de CDK. Tómese un momento para explorar su proyecto de CDK.
Si ha instalado Git, cada proyecto que cree utilizando `cdk init` se iniciará como un repositorio de Git.
Durante la inicialización del proyecto, la CLI de CDK crea una aplicación de CDK que contiene una única pila de CDK. La instancia de la aplicación de CDK se crea mediante el constructo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html). La siguiente es una parte de este código del archivo de aplicación de CDK:
**Example**
Se encuentra en `bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Se encuentra en `bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Se encuentra en `app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",)
app.synth()
```
Se encuentra en `src/main/java/…/HelloCdkApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.build());
app.synth();
}
}
```
Se encuentra en `src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{});
app.Synth();
}
}
}
```
Se encuentra en `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// ...
```
La pila de CDK se crea mediante el constructo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html). La siguiente es una parte de este código del archivo de pila de CDK:
**Example**
Se encuentra en `lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define your constructs here
}
}
```
Se encuentra en `lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define your constructs here
}
}
module.exports = { HelloCdkStack }
```
Se encuentra en `hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define your constructs here
```
Se encuentra en `src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define your constructs here
}
}
```
Se encuentra en `src/HelloCdk/HelloCdkStack.cs`:
```
using Amazon.CDK;
using Constructs;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define your constructs here
}
}
}
```
Se encuentra en `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
return stack
}
// ...
```
## Paso 2: Configure su AWS entorno
En este paso, configurará el AWS entorno de su pila de CDK. De este modo, podrá especificar en qué entorno se implementará su pila de CDK.
En primer lugar, determine el AWS entorno que quiere usar. Un AWS entorno consta de una AWS cuenta y una AWS región.
Cuando usa la AWS CLI para configurar las credenciales de seguridad en su máquina local, puede usar la AWS CLI para obtener información del AWS entorno para un perfil específico.
**Para usar la AWS CLI para obtener el ID de su AWS cuenta**
1. Ejecute el siguiente comando AWS CLI para obtener el ID de AWS cuenta `default` de su perfil:
```
$ aws sts get-caller-identity --query "Account" --output text
```
1. Si prefiere utilizar un perfil con nombre, proporcione el nombre de su perfil a través de la opción `--profile`:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```
**Para usar la AWS CLI para obtener su AWS región**
1. Ejecute el siguiente comando AWS CLI para obtener la región que configuró para su `default` perfil:
```
$ aws configure get region
```
1. Si prefiere utilizar un perfil con nombre, proporcione el nombre de su perfil a través de la opción `--profile`:
```
$ aws configure get region --profile your-profile-name
```
A continuación, configurará el AWS entorno de su pila de CDK modificando la `HelloCdkStack` instancia en el *archivo de su aplicación*. Para este tutorial, codificará la información de su AWS entorno. Esto no se recomienda para entornos de producción. Para obtener información sobre otras formas de configurar entornos, consulte [Configurar entornos para usarlos con la AWS CDK](configure-env.md).
**Para configurar el entorno de su pila de CDK**
1. En el *archivo de la aplicación*, utilice la propiedad `env` del constructo `Stack` para configurar el entorno. A continuación, se muestra un ejemplo:
**Example**
------
#### [ TypeScript ]
Se encuentra en `bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ JavaScript ]
Se encuentra en `bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ Python ]
Se encuentra en `app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
env=cdk.Environment(account='123456789012', region='us-east-1'),
)
app.synth()
```
------
#### [ Java ]
Se encuentra en `src/main/java/…/HelloCdkApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.env(Environment.builder()
.account("123456789012")
.region("us-east-1")
.build())
.build());
app.synth();
}
}
```
------
#### [ C\$1 ]
Se encuentra en `src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{
Env = new Amazon.CDK.Environment
{
Account = "123456789012",
Region = "us-east-1",
}
});
app.Synth();
}
}
}
```
------
#### [ Go ]
Se encuentra en `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
func env() *awscdk.Environment {
return &awscdk.Environment{
Account: jsii.String("123456789012"),
Region: jsii.String("us-east-1"),
}
}
```
------
## Paso 3: Inicie su entorno AWS
En este paso, arranca el AWS entorno que configuró en el paso anterior. Esto prepara el entorno para las implementaciones de CDK.
Para arrancar su entorno, ejecute lo siguiente desde la raíz de su proyecto de CDK:
```
$ cdk bootstrap
```
Al arrancar desde la raíz de su proyecto de CDK, no tiene que proporcionar ninguna información adicional. La CLI de CDK obtiene información sobre el entorno de su proyecto. En el caso de que arranque fuera de un proyecto de CDK, debe proporcionar información sobre el entorno con el comando `cdk bootstrap`. Para obtener más información, consulte [Bootstrap de su entorno para usarlo con la AWS CDK](bootstrapping-env.md).
## Paso 4: cree su aplicación de CDK
En la mayoría de los entornos de programación, el código se crea o compila después de realizar cambios. Esto no es necesario con la AWS CDK, ya que la CLI de la CDK realizará este paso automáticamente. Sin embargo, puede seguir compilando de forma manual cuando quiera encontrar errores de sintaxis y de tipeo. A continuación, se muestra un ejemplo:
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
No es necesario ningún paso de compilación.
No es necesario ningún paso de compilación.
```
$ mvn compile -q
```
O bien, pulse `Control-B` Eclipse (otros tipos de Java IDEs pueden variar)
```
$ dotnet build src
```
O presione F6 en Visual Studio
```
$ go build
```
## Paso 5: enumere las pilas de CDK de su aplicación
En este punto, debería tener una aplicación de CDK que contenga una sola pila de CDK. Para verificarlo, use el comando `cdk list` de la CLI de CDK para mostrar sus pilas. El resultado debe mostrar una sola pila denominada `HelloCdkStack`:
```
$ cdk list
HelloCdkStack
```
Si no puede ver este resultado, verifique que se encuentra en el directorio de trabajo correcto de su proyecto e inténtelo nuevamente. Si sigue sin ver su pila, repita el [Paso 1: cree su proyecto de CDK](#hello-world-create) e inténtelo de nuevo.
## Paso 6: defina la función de Lambda
En este paso, importará el [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)módulo de la biblioteca AWS Construct y utilizará la construcción [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)L2.
Modifique el archivo de pila de CDK de la siguiente manera:
**Example**
Se encuentra en `lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
```
Se encuentra en `lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
module.exports = { HelloCdkStack }
```
Se encuentra en `hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"""
),
)
```
Se encuentra en `src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello World!')" +
" };" +
"};"))
.build();
}
}
```
Se encuentra en `src/main/java/…/HelloCdkStack.java`:
```
using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"),
});
}
}
}
```
Se encuentra en `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
// Import the Lambda module
"github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`)),
})
return stack
}
// ...
```
Examinemos en mayor profundidad al constructo `Function`. Como todos los constructos, la clase `Function` utiliza tres parámetros:
+ **alcance**: define la instancia de `Stack` como la matriz del constructo `Function`. Todas las construcciones que definen AWS los recursos se crean dentro del ámbito de una pila. Puede definir constructos dentro de otros constructos, lo cual crea una jerarquía (árbol). Tanto en este como en la mayoría de los casos, el alcance es `this` (`self` en Python).
+ **ID**: el ID de construcción de la `Function` aplicación AWS CDK. Este ID, más un hash basado en la ubicación de la función dentro de la pila, identifica de forma exclusiva a la función durante la implementación. La AWS CDK también hace referencia a este ID cuando actualizas la construcción en tu aplicación y la vuelves a implementar para actualizar el recurso implementado. Aquí, su ID de constructo es `HelloWorldFunction`. Las funciones también pueden tener un nombre, especificado con la propiedad `functionName`. Esta es diferente al ID del constructo.
+ **props**: agrupación de valores que definen las propiedades de la función. Aquí se definen las propiedades `runtime`, `handler` y `code`.
Los accesorios se representan de forma diferente en los idiomas compatibles con la CDK. AWS
+ En TypeScript y JavaScript, `props` es un único argumento y se pasa un objeto que contiene las propiedades deseadas.
+ En Python, las props se pasan como argumentos de palabras clave.
+ En Java, se proporciona un Builder para pasar las props. Existen dos: uno para `FunctionProps` y otro para `Function`, con el fin de que pueda construir el constructo y su objeto de props en un solo paso. Este código usa este último.
+ En C\$1, se crea una instancia de un objeto de `FunctionProps` mediante un inicializador de objetos y se pasa como tercer parámetro.
Si las props de un constructo son opcionales, puede omitir el parámetro `props` por completo.
Todos los constructos utilizan los mismos tres argumentos, por lo que es fácil mantenerse orientado a medida que se aprenden otros nuevos. Y como es de esperar, puede subclasificar cualquier constructo para ampliarlo según sus necesidades o si desea cambiar sus valores predeterminados.
## Paso 7: implemente la URL de función de Lambda
En este paso, se utiliza el método auxiliar `addFunctionUrl` del constructo `Function` para definir la URL de una función de Lambda. Para generar el valor de esta URL en el momento de la implementación, creará una AWS CloudFormation salida utilizando la [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)construcción.
Agregue lo siguiente a su archivo:
**Example**
Se encuentra en `lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new cdk.CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
```
Se encuentra en `lib/hello-cdk-stack.js`:
```
const { Stack, CfnOutput } = require('aws-cdk-lib'); // Import CfnOutput
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
module.exports = { HelloCdkStack }
```
Se encuentra en `hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
# ...
CfnOutput # Import CfnOutput
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
# ...
# Define the Lambda function URL resource
my_function_url = my_function.add_function_url(
auth_type = _lambda.FunctionUrlAuthType.NONE,
)
# Define a CloudFormation output for your URL
CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)
```
Se encuentra en `src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
.authType(FunctionUrlAuthType.NONE)
.build());
// Define a CloudFormation output for your URL
CfnOutput.Builder.create(this, "myFunctionUrlOutput")
.value(myFunctionUrl.getUrl())
.build();
}
}
```
Se encuentra en `src/main/java/…/HelloCdkStack.java`:
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
{
AuthType = FunctionUrlAuthType.NONE
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
{
Value = myFunctionUrl.Url
});
}
}
}
```
Se encuentra en `hello-cdk.go`:
```
// ...
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
AuthType: awslambda.FunctionUrlAuthType_NONE,
})
// Define a CloudFormation output for your URL
awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
Value: myFunctionUrl.Url(),
})
return stack
}
// ...
```
**aviso**
Para simplificar este tutorial, la URL de función de Lambda se define sin autenticación. Cuando se implementa, se crea un punto de conexión de acceso público que se puede utilizar para invocar la función. Cuando termine con este tutorial, siga el [Paso 12: elimine su aplicación](#hello-world-delete) para eliminar estos recursos.
## Paso 8: Sintetizar una plantilla CloudFormation
En este paso, se prepara para la implementación sintetizando una CloudFormation plantilla con el comando CDK CLI`cdk synth`. Este comando realiza una validación básica del código de CDK, ejecuta la aplicación de CDK y genera una CloudFormation plantilla a partir de la pila de CDK.
Si su aplicación contiene más de una pila, debe especificar qué pilas desea sintetizar. Como la aplicación contiene solo una pila, la CLI de CDK detecta automáticamente la pila que se va a sintetizar.
Si no sintetiza una plantilla, la CLI de CDK realizará este paso automáticamente cuando la implemente. Sin embargo, recomendamos que ejecute este paso antes de cada implementación para comprobar si hay errores de síntesis.
Antes de sintetizar una plantilla, si lo desea, puede crear su aplicación para detectar errores de sintaxis y de tipeo. Para obtener instrucciones, consulte el [Paso 4: cree su aplicación de CDK](#hello-world-build).
Para sintetizar una CloudFormation plantilla, ejecuta lo siguiente desde la raíz de tu proyecto:
```
$ cdk synth
```
**nota**
Si recibe un error como el siguiente, verifique que se encuentra en el directorio `hello-cdk` e inténtelo de nuevo:
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
Si se ejecuta correctamente, la CLI de CDK generará `YAML` una CloudFormation plantilla con formato `stdout` y guardará una plantilla `JSON` con formato en el `cdk.out` directorio de su proyecto.
El siguiente es un ejemplo de salida de la plantilla: CloudFormation
### AWS CloudFormation plantilla
```
Resources:
HelloWorldFunctionServiceRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action: sts:AssumeRole
Effect: Allow
Principal:
Service: lambda.amazonaws.com
Version: "2012-10-17"
ManagedPolicyArns:
- Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
HelloWorldFunction:
Type: AWS::Lambda::Function
Properties:
Code:
ZipFile: "
\ exports.handler = async function(event) {
\ return {
\ statusCode: 200,
\ body: JSON.stringify('Hello World!'),
\ };
\ };
\ "
Handler: index.handler
Role:
Fn::GetAtt:
- HelloWorldFunctionServiceRole
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//version
Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
CheckBootstrapVersion:
Assertions:
- Assert:
Fn::Not:
- Fn::Contains:
- - "1"
- "2"
- "3"
- "4"
- "5"
- Ref: BootstrapVersion
AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.
```
**nota**
Cada plantilla generada contiene un recurso ` AWS::CDK::Metadata` de forma predeterminada. El equipo de AWS CDK utiliza estos metadatos para obtener información sobre el uso de las AWS CDK y encontrar formas de mejorarlo. Para obtener más información, incluyendo cómo optar por no informar la versión, consulte [Informe de versiones](cli.md#version-reporting).
Al definir una única construcción de nivel 2, la AWS CDK crea una amplia CloudFormation plantilla que contiene los recursos de Lambda, junto con los permisos y la lógica de unión necesarios para que los recursos interactúen dentro de la aplicación.
## Paso 9: implemente su pila de CDK
En este paso, utilice el comando `cdk deploy` de la CLI de CDK para implementar su pila de CDK. Este comando recupera la CloudFormation plantilla generada y la despliega mediante ella AWS CloudFormation, lo que aprovisiona los recursos como parte de una pila. CloudFormation
Desde la raíz del proyecto, ejecute lo siguiente. Confirme los cambios, si se le solicita:
```
$ cdk deploy
✨ Synthesis time: 2.69s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:
IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn} │ Allow │ lambda:InvokeFunctionUrl │ * │ │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.com │ │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│ │ Resource │ Managed Policy ARN │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)
Do you wish to deploy these changes (y/n)? y
```
Del mismo modo`cdk synth`, no es necesario especificar la pila de AWS CDK, ya que la aplicación contiene una sola pila.
Durante la implementación, la CLI de CDK muestra información sobre el progreso a medida que se implementa la pila. Cuando haya terminado, podrá ir a la [consola de AWS CloudFormation ](https://console.aws.amazon.com/cloudformation/home) para ver su pila de `HelloCdkStack`. También puede ir a la consola de Lambda para ver el recurso `HelloWorldFunction`.
Cuando la implementación esté completa, la CLI de CDK generará la URL de su punto de conexión. Copie esta URL para el siguiente paso. A continuación, se muestra un ejemplo:
```
...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 41.65s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 44.34s
```
## Paso 10: Interactúa con tu aplicación en AWS
En este paso, interactúa con la aplicación AWS invocando la función Lambda a través de la URL de la función. Al acceder a la URL, la función de Lambda devuelve el mensaje de `Hello World!`.
Para invocar la función, acceda a la URL de función a través del navegador o desde la línea de comandos. A continuación, se muestra un ejemplo:
```
$ curl https://.lambda-url..on.aws/
"Hello World!"%
```
## Paso 11: modifique su aplicación
En este paso, modifique el mensaje que la función de Lambda devuelve cuando se invoca. Para realizar una diferencia, utilice el comando `cdk diff` de la CLI de CDK para obtener una vista previa de los cambios y realizar una implementación para actualizar la aplicación. A continuación, interactúa con la aplicación AWS para ver el nuevo mensaje.
Modifique la instancia de `myFunction` en su archivo de pila de CDK de la siguiente manera:
**Example**
Se encuentra en `lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
```
Se encuentra en `lib/hello-cdk-stack.js`:
```
// ...
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
module.exports = { HelloCdkStack }
```
Se encuentra en `hello_cdk/hello_cdk_stack.py`:
```
# ...
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Modify the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"""
),
)
# ...
```
Se encuentra en `src/main/java/…/HelloCdkStack.java`:
```
// ...
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Modify the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello CDK!')" +
" };" +
"};"))
.build();
// ...
}
}
```
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Modify the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"),
});
// ...
}
}
}
```
```
// ...
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Modify the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`)),
})
// ...
}
```
Actualmente, los cambios en el código no han realizado ninguna actualización directa en el recurso de Lambda implementado. El código define el estado deseado del recurso. Para modificar el recurso implementado, utilizará la CLI de CDK para sintetizar el estado deseado en una nueva AWS CloudFormation plantilla. A continuación, implementará la nueva CloudFormation plantilla como un conjunto de cambios. Los conjuntos de cambios solo realizan cambios necesarios para alcanzar el nuevo estado deseado.
Para obtener una vista previa de los cambios, ejecute el comando `cdk diff`. A continuación, se muestra un ejemplo:
```
$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunction
└─ [~] Code
└─ [~] .ZipFile:
├─ [-]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
└─ [+]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
✨ Number of stacks with differences: 1
```
Para crear esta diferencia, la CLI del CDK consulta su AWS cuenta para obtener la AWS CloudFormation plantilla más reciente de la `HelloCdkStack` pila. A continuación, compare la plantilla más reciente con la plantilla que acaba de sintetizar en su aplicación.
Para implementar los cambios, ejecute el comando `cdk deploy`. A continuación, se muestra un ejemplo:
```
$ cdk deploy
✨ Synthesis time: 2.12s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 26.96s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 29.07s
```
Para interactuar con su aplicación, repita el [Paso 10: interactúe con su aplicación en AWS](#hello-world-interact). A continuación, se muestra un ejemplo:
```
$ curl https://.lambda-url..on.aws/
"Hello CDK!"%
```
## Paso 12: elimine la aplicación
En este paso, utilice el comando `cdk destroy` de la CLI de CDK para eliminar su aplicación. Este comando elimina la CloudFormation pila asociada a tu pila de CDK, que incluye los recursos que has creado.
Para eliminar la aplicación, ejecute el comando `cdk destroy` y confirme la solicitud para eliminar la aplicación. A continuación, se muestra un ejemplo:
```
$ cdk destroy
Are you sure you want to delete: HelloCdkStack (y/n)? y
HelloCdkStack: destroying... [1/1]
✅ HelloCdkStack: destroyed
```
## Siguientes pasos
¡Enhorabuena\$1 Ha completado este tutorial y ha utilizado la AWS CDK para crear, modificar y eliminar recursos en la nube correctamente. AWS Ahora está listo para empezar a usar la AWS CDK.
Para obtener más información sobre el uso del AWS CDK en su lenguaje de programación preferido, consulte [Trabajar con la biblioteca del AWS CDK](work-with.md).
Para obtener más ayuda, consulte los siguientes recursos:
+ Para realizar un recorrido más detallado sobre un proyecto más complejo, pruebe [CDK Workshop](https://cdkworkshop.com/).
+ Consulte la [referencia de la API](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) para empezar a explorar las estructuras de CDK disponibles para sus servicios favoritos. AWS
+ Visite [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) para descubrir construcciones creadas por AWS y otras personas.
+ Explore [algunos ejemplos](https://github.com/aws-samples/aws-cdk-examples) de uso del AWS CDK.
El AWS CDK es un proyecto de código abierto. Para contribuir, consulte [Contribución al AWS Cloud Development Kit (AWS CDK).](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md)