Tutorial: cómo crear su primera aplicación de AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

Esta es la guía para AWS CDK desarrolladores de la versión 2. La CDK versión anterior entró en mantenimiento el 1 de junio de 2022 y finalizó el soporte el 1 de junio de 2023.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Tutorial: cómo crear su primera aplicación de AWS CDK

Comience a utilizar AWS Cloud Development Kit (AWS CDK) al utilizar la interfaz de la línea de comandos AWS CDK (CLI de AWS CDK) para desarrollar su primera aplicación de CDK, arrancar su entorno de AWS e implementar su aplicación en AWS.

Requisitos previos

Antes de iniciar este tutorial, complete los pasos en Introducción al AWS CDK.

Acerca de este tutorial

En este tutorial, creará e implementará una aplicación sencilla en AWS mediante el uso del AWS CDK. La aplicación consta de una función de AWS Lambda 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 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.

  • Configurar su entorno de AWS: configure el entorno de AWS en el que implementará la aplicación.

  • Arrancar su entorno deAWS: prepare su entorno de AWS para la implementación mediante el arranque del comando cdk bootstrap de la CLI de CDK.

  • Desarrollar su aplicación: utilice constructos de la Biblioteca de constructos de AWS para definir la función de Lambda y los recursos de URL de la función de Lambda.

  • Preparar su aplicación para la implementación: use la CLI de CDK para crear su aplicación y sintetizar una plantilla de AWS CloudFormation.

  • Implementar su aplicación: utilice el comando cdk deploy de la CLI de CDK para implementar su aplicación y aprovisionar sus recursos de AWS.

  • Interactuar con su aplicación: interactúe con la función de Lambda implementada en AWS al invocarla y recibir 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.

  2. 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:

    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 de 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#
    $ 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, introduzca también el siguiente comando para instalar los módulos de la Biblioteca de constructos de AWS que requieren 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 App. La siguiente es una parte de este código del archivo de aplicación de CDK:

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', { });
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', { });
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",) 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() .build()); app.synth(); } }
C#

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(); } } }
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) } // ...

La pila de CDK se crea mediante el constructo Stack. La siguiente es una parte de este código del archivo de pila de CDK:

TypeScript

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 } }
JavaScript

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 }
Python

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
Java

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 } }
C#

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

En este paso, configurará el entorno de AWS de la pila de CDK. De este modo, podrá especificar en qué entorno se implementará su pila de CDK.

En primer lugar, determine el entorno de AWS que desea utilizar. Un entorno de AWS consta de una Cuenta de AWS y una Región de AWS.

Si usa la AWS CLI para configurar las credenciales de seguridad en su equipo local, puede usar la AWS CLI para obtener información del entorno de AWS para un perfil específico.

Para usar la AWS CLI para obtener su ID de Cuenta de AWS
  1. Ejecute el siguiente comando de la AWS CLI para obtener el ID de Cuenta de AWS de su perfil default:

    $ aws sts get-caller-identity --query "Account" --output text
  2. 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 Región de AWS
  1. Ejecute el siguiente comando de la AWS CLI para obtener la región que configuró para su perfil default:

    $ aws configure get region
  2. 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 entorno de AWS para su pila de CDK modificando la instancia de HelloCdkStack en el archivo de la aplicación. Para este tutorial, codificará de forma rígida la información de su entorno de AWS. Recomendamos este procedimiento para los entornos de producción. Para obtener información sobre otras formas de configurar entornos, consulte Configuración de los entornos para usarlos con AWS CDK.

Para configurar el entorno de su pila de CDK
  • 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:

    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#

    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: arranque su entorno de AWS

En este paso, arranque el entorno de AWS que ha configurado 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 Inicie su entorno para usarlo con AWS CDK.

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 AWS CDK, ya que la CLI de 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:

TypeScript
$ npm run build > hello-cdk@0.1.0 build > tsc
JavaScript

No es necesario ningún paso de compilación.

Python

No es necesario ningún paso de compilación.

Java
$ mvn compile -q

O presione Control-B en Eclipse (otros IDE de Java pueden variar)

C#
$ dotnet build src

O presione F6 en Visual Studio

Go
$ 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 proceso Paso 1: cree su proyecto de CDK e inténtelo de nuevo.

Paso 6: defina la función de Lambda

En este paso, importe el módulo aws_lambda desde la Biblioteca de constructos de AWS y utilice el constructo Function de nivel 2.

Modifique el archivo de pila de CDK de la siguiente manera:

TypeScript

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!'), }; }; `), }); } }
JavaScript

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 }
Python

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!'), }; }; """ ), )
Java

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(); } }
C#

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!'), }; }; "), }); } } }
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" // 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. Todos los constructos que definen a los recursos de AWS se crean dentro del alcance 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 del constructo de la Function dentro de la aplicación de 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. El AWS CDK también hace referencia a este ID cuando actualiza el constructo en su aplicación y la vuelve 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.

    Las props se representan de forma diferente en los lenguajes compatibles con el AWS CDK.

    • En TypeScript y JavaScript, props es un único argumento al que se le 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#, 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 salida de AWS CloudFormation al utilizar el constructo CfnOutput.

Agregue lo siguiente a su archivo:

TypeScript

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, }) } }
JavaScript

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 }
Python

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)
Java

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(); } }
C#

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

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 Paso 12: elimine la aplicación para eliminar estos recursos.

Paso 8: sintetice una plantilla de CloudFormation

En este paso, se prepara para la implementación sintetizando una plantilla de CloudFormation con el comando cdk synth de la CLI de CDK. Este comando realiza una validación básica del código de CDK, ejecuta la aplicación de CDK y genera una plantilla de CloudFormation 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 Paso 4: cree su aplicación de CDK.

Para sintetizar una plantilla de CloudFormation, ejecute lo siguiente desde la raíz del proyecto:

$ cdk synth
nota

Si recibe un error como el siguiente, verifique que está 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á una plantilla con formato de YAML de CloudFormation para stdout y guardará una plantilla con formato de JSON en el directorio cdk.out de su proyecto.

A continuación, se muestra un ejemplo de resultado de la plantilla de CloudFormation:

Resources: HelloWorldFunctionServiceRoleunique-identifier: 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 HelloWorldFunctionunique-identifier: 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: - HelloWorldFunctionServiceRoleunique-identifier - Arn Runtime: nodejs20.x DependsOn: - HelloWorldFunctionServiceRoleunique-identifier Metadata: aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource HelloWorldFunctionFunctionUrlunique-identifier: Type: AWS::Lambda::Url Properties: AuthType: NONE TargetFunctionArn: Fn::GetAtt: - HelloWorldFunctionunique-identifier - Arn Metadata: aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource HelloWorldFunctioninvokefunctionurlunique-identifier: Type: AWS::Lambda::Permission Properties: Action: lambda:InvokeFunctionUrl FunctionName: Fn::GetAtt: - HelloWorldFunctionunique-identifier - Arn FunctionUrlAuthType: NONE Principal: "*" Metadata: aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url CDKMetadata: Type: AWS::CDK::Metadata Properties: Analytics: v2:deflate64:unique-identifier Metadata: aws:cdk:path: HelloCdkStack/CDKMetadata/Default Condition: CDKMetadataAvailable Outputs: myFunctionUrlOutput: Value: Fn::GetAtt: - HelloWorldFunctionFunctionUrlunique-identifier - FunctionUrl Parameters: BootstrapVersion: Type: AWS::SSM::Parameter::Value<String> Default: /cdk-bootstrap/unique-identifier/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 AWS CDK y encontrar formas de mejorarlo. Para obtener más información, incluyendo cómo optar por no informar la versión, consulte Informes de versiones.

Al definir un único constructo de nivel 2, el AWS CDK crea una amplia plantilla de CloudFormation que contiene los recursos de Lambda, junto con los permisos y la lógica de enlace 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 plantilla de CloudFormation generada y la implementa a través de AWS CloudFormation, lo que aprovisiona los recursos como parte de una pila de CloudFormation.

Desde el directorio raíz del proyecto, ejecute lo siguiente. Confirme los cambios si se le solicita:

$ cdk deploy ✨ Synthesis time: 2.69s HelloCdkStack: start: Building unique-identifier:current_account-current_region HelloCdkStack: success: Built unique-identifier:current_account-current_region HelloCdkStack: start: Publishing unique-identifier:current_account-current_region HelloCdkStack: success: Published unique-identifier: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 que 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 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://<api-id>.lambda-url.<Region>.on.aws/ Stack ARN: arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier ✨ Total time: 44.34s

Paso 10: interactúe con su aplicación en AWS

En este paso, interactúe con la aplicación en AWS a través de la invocación de la función de Lambda mediante la URL de 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://<api-id>.lambda-url.<Region>.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úe con la aplicación en AWS para ver el nuevo mensaje.

Modifique la instancia de myFunction en su archivo de pila de CDK de la siguiente manera:

TypeScript

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!'), }; }; `), }); // ...
JavaScript

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 }
Python

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!'), }; }; """ ), ) # ...
Java

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(); // ... } }
C#

// ... 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!'), }; }; "), }); // ... } } }
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) // 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 plantilla de AWS CloudFormation. A continuación, implementará la nueva plantilla de CloudFormation 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 HelloWorldFunctionunique-identifier └─ [~] 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 de CDK necesita su cuenta de Cuenta de AWS para obtener la plantilla de AWS CloudFormation más reciente de la pila HelloCdkStack. 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 unique-identifier:current_account-current_region HelloCdkStack: success: Built unique-identifier:current_account-current_region HelloCdkStack: start: Publishing unique-identifier:current_account-current_region HelloCdkStack: success: Published unique-identifier:current_account-current_region HelloCdkStack: deploying... [1/1] HelloCdkStack: creating CloudFormation changeset... ✅ HelloCdkStack ✨ Deployment time: 26.96s Outputs: HelloCdkStack.myFunctionUrlOutput = https://unique-identifier.lambda-url.<Region>.on.aws/ Stack ARN: arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier ✨ Total time: 29.07s

Para integrar su aplicación, repita Paso 10: interactúe con su aplicación en AWS. A continuación, se muestra un ejemplo:

$ curl https://<api-id>.lambda-url.<Region>.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 pila de CloudFormation asociada a la pila de CDK, la cual comprende los recursos que ha 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! Ha completado el tutorial y lo ha utilizado el AWS CDK para crear, modificar y eliminar correctamente los recursos de Nube de AWS. Ahora tiene todo listo para empezar a usar el 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 de AWS CDK.

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.

  • Consulte API referenc para empezar a explorar los constructos de CDK disponibles para sus servicios favoritos de AWS.

  • Visite Construct Hub para descubrir constructos creados por AWS y otros.

  • Explore Examples sobre el uso del AWS CDK.

El AWS CDK es un proyecto de código abierto. Para contribuir, consulte Contributing to the AWS Cloud Development Kit (AWS CDK).