Tutorial: cómo crear una aplicación Hello World sin servidor - AWS Kit Cloud Development Kit (AWS CDK) v2
Requisitos previosPaso 1: cómo crear un proyectoPaso 2: cómo crear su función de LambdaPaso 3: cómo definir las construccionesPaso 4: cómo preparar la aplicación para su implementaciónPaso 5: implementar la aplicaciónPaso 6: cómo interactuar con su aplicaciónPaso 7: cómo eliminar la aplicaciónSolución de problemas

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.

Tutorial: cómo crear una aplicación Hello World sin servidor

En este tutorial, utilizarás el AWS Cloud Development Kit (AWS CDK) para crear una Hello World aplicación sencilla sin servidor que implemente un backend de API básico compuesto por lo siguiente:

  • API REST de Amazon API Gateway: proporciona un punto de enlace HTTP que se utiliza para invocar la función mediante una solicitud HTTP GET.

  • AWS Función Lambda: función que devuelve un Hello World! mensaje cuando se invoca con el punto final HTTP.

  • Integraciones y permisos: detalles de configuración y permisos para que tus recursos interactúen entre sí y realicen acciones, como escribir registros en Amazon CloudWatch.

El siguiente diagrama muestra los componentes de esta aplicación:

Diagrama de una función de Lambda que se invoca cuando envía una solicitud GET al punto de conexión de la API Gateway.

Para este tutorial, creará e interactuará con su aplicación en los siguientes pasos:

  1. Cree un proyecto de AWS CDK.

  2. Defina una función Lambda y una API REST de API Gateway mediante construcciones L2 de la biblioteca Construct. AWS

  3. Implemente su aplicación en la nube. AWS

  4. Interactúa con tu aplicación en la AWS nube.

  5. Elimine la aplicación de muestra de la AWS nube.

Requisitos previos

Antes de comenzar este tutorial, debe completar lo siguiente:

  • Cree una AWS cuenta e instale y configure la AWS interfaz de línea de AWS comandos (CLI).

  • Instale Node.js ynpm.

  • Instale el kit de herramientas de CDK a nivel mundial, utilizando npm install -g aws-cdk.

Para obtener más información, consulte Introducción al AWS CDK.

Se recomienda tener conocimientos básicos sobre:

Paso 1: cómo crear un proyecto

En este paso, se crea un nuevo proyecto de CDK mediante el comando AWS cdk init CLI de CDK.

Para crear un proyecto de CDK

  1. Desde un directorio inicial de su elección, cree y navegue a un directorio de proyecto llamado cdk-hello-world en su máquina:

    $ mkdir cdk-hello-world && cd cdk-hello-world

  2. Para crear un nuevo proyecto en su lenguaje de programación preferido, use el comando cdk init:

    TypeScript
    $ cdk init --language typescript

    Instale las bibliotecas de AWS CDK:

    $ npm install aws-cdk-lib constructs
    JavaScript
    $ cdk init --language javascript

    Instale las bibliotecas de AWS CDK:

    $ npm install aws-cdk-lib constructs
    Python
    $ cdk init --language python

    Active el entorno virtual:

    $ source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead

    Instale las bibliotecas de AWS CDK y las dependencias del proyecto:

    (.venv)$ python3 -m pip install -r requirements.txt
    Java
    $ cdk init --language java

    Instale las bibliotecas de AWS CDK y las dependencias del proyecto:

    $ mvn package
    C#
    $ cdk init --language csharp

    Instale las bibliotecas de AWS CDK y las dependencias del proyecto:

    $ dotnet restore src
    Go
    $ cdk init --language go

    Instale las dependencias del proyecto:

    $ go get github.com/aws/aws-cdk-go/awscdk/v2
$ go get github.com/aws/aws-cdk-go/awscdk/v2/awslambda
$ go get github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway
$ go mod tidy

    La CLI de CDK crea un proyecto con la siguiente estructura:

    TypeScript
    cdk-hello-world
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── cdk-hello-world.ts
├── cdk.json
├── jest.config.js
├── lib
│   └── cdk-hello-world-stack.ts
├── node_modules
├── package-lock.json
├── package.json
├── test
│   └── cdk-hello-world.test.ts
└── tsconfig.json
    JavaScript
    cdk-hello-world
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── cdk-hello-world.js
├── cdk.json
├── jest.config.js
├── lib
│   └── cdk-hello-world-stack.js
├── node_modules
├── package-lock.json
├── package.json
└── test
    └── cdk-hello-world.test.js
    Python
    cdk-hello-world
├── .git
├── .gitignore
├── .venv
├── README.md
├── app.py
├── cdk.json
├── cdk_hello_world
│   ├── __init__.py
│   └── cdk_hello_world_stack.py
├── requirements-dev.txt
├── requirements.txt
├── source.bat
└── tests
    Java
    cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── com
│   │           └── myorg
│   │               ├── CdkHelloWorldApp.java
│   │               └── CdkHelloWorldStack.java
└── target
    C#
    cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk.json
└── src
    ├── CdkHelloWorld
    │   ├── CdkHelloWorld.csproj
    │   ├── CdkHelloWorldStack.cs
    │   ├── GlobalSuppressions.cs
    │   └── Program.cs
    └── CdkHelloWorld.sln
    Go
    cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk-hello-world.go
├── cdk-hello-world_test.go
├── cdk.json
├── go.mod
└── go.sum

La CLI de CDK crea automáticamente una aplicación de CDK que contiene una sola pila. La instancia de la aplicación de CDK se crea a partir de la clase App . La siguiente es una parte del archivo de la aplicación de CDK:

TypeScript

Se encuentra en bin/cdk-hello-world.ts:

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

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

Se encuentra en bin/cdk-hello-world.js:

#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { CdkHelloWorldStack } = require('../lib/cdk-hello-world-stack');
const app = new cdk.App();
new CdkHelloWorldStack(app, 'CdkHelloWorldStack', {
});
Python

Se encuentra en app.py:

#!/usr/bin/env python3
import os
import aws_cdk as cdk
from cdk_hello_world.cdk_hello_world_stack import CdkHelloWorldStack

app = cdk.App()
CdkHelloWorldStack(app, "CdkHelloWorldStack",)
app.synth()
Java

Se encuentra en src/main/java/…​/CdkHelloWorldApp.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 JavaApp {
    public static void main(final String[] args) {
        App app = new App();

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

        app.synth();
    }
}
C#

Se encuentra en src/CdkHelloWorld/Program.cs:

using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace CdkHelloWorld
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new CdkHelloWorldStack(app, "CdkHelloWorldStack", new StackProps
            {

            });
            app.Synth();
        }
    }
}
Go

Se encuentra en cdk-hello-world.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)
    NewCdkHelloWorldStack(app, "CdkHelloWorldStack", &CdkHelloWorldStackProps{
        awscdk.StackProps{
            Env: env(),
        },
    })
    app.Synth(nil)
}

func env() *awscdk.Environment {
    return nil
}

Paso 2: cómo crear su función de Lambda

Dentro de su proyecto de CDK, cree un directorio lambda que incluya un archivo nuevo hello.js. A continuación, se muestra un ejemplo:

TypeScript

Desde la raíz del proyecto, ejecute lo siguiente:

$ mkdir lambda && cd lambda
$ touch hello.js

Ahora debería agregarse lo siguiente a su proyecto de CDK:

cdk-hello-world
└── lambda
    └── hello.js
JavaScript

Desde la raíz del proyecto, ejecute lo siguiente:

$ mkdir lambda && cd lambda
$ touch hello.js

Ahora debería agregarse lo siguiente a su proyecto de CDK:

cdk-hello-world
└── lambda
    └── hello.js
Python

Desde la raíz del proyecto, ejecute lo siguiente:

$ mkdir lambda && cd lambda
$ touch hello.js

Ahora debería agregarse lo siguiente a su proyecto de CDK:

cdk-hello-world
└── lambda
    └── hello.js
Java

Desde la raíz del proyecto, ejecute lo siguiente:

$ mkdir -p src/main/resources/lambda
$ cd src/main/resources/lambda
$ touch hello.js

Ahora debería agregarse lo siguiente a su proyecto de CDK:

cdk-hello-world
└── src
    └── main
        └──resources
            └──lambda
                └──hello.js
C#

Desde la raíz del proyecto, ejecute lo siguiente:

$ mkdir lambda && cd lambda
$ touch hello.js

Ahora debería agregarse lo siguiente a su proyecto de CDK:

cdk-hello-world
└── lambda
    └── hello.js
Go

Desde la raíz del proyecto, ejecute lo siguiente:

$ mkdir lambda && cd lambda
$ touch hello.js

Ahora debería agregarse lo siguiente a su proyecto de CDK:

cdk-hello-world
└── lambda
    └── hello.js
nota

Para simplificar este tutorial, utilizamos una función de Lambda JavaScript para todos los lenguajes de programación CDK.

Para definir la función de Lambda, agregue lo siguiente al archivo recién creado:

exports.handler = async (event) => {
    return {
        statusCode: 200,
        headers: { "Content-Type": "text/plain" },
        body: JSON.stringify({ message: "Hello, World!" }),
    };
};

Paso 3: cómo definir las construcciones

En este paso, definirá sus recursos de Lambda y API Gateway mediante construcciones AWS CDK L2.

Abra el archivo del proyecto que define su pila CDK. Modificará este archivo para definir sus constructos fijos. A continuación se muestra un ejemplo del archivo de pila inicial:

TypeScript

Se encuentra en lib/cdk-hello-world-stack.ts:

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

export class CdkHelloWorldStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Your constructs will go here

  }
}
JavaScript

Se encuentra en lib/cdk-hello-world-stack.js:

const { Stack, Duration } = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const apigateway = require('aws-cdk-lib/aws-apigateway');

class CdkHelloWorldStack extends Stack {

  constructor(scope, id, props) {
    super(scope, id, props);

    // Your constructs will go here

  }
}

module.exports = { CdkHelloWorldStack }
Python

Se encuentra en cdk_hello_world/cdk_hello_world_stack.py:

from aws_cdk import Stack
from constructs import Construct

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

          // Your constructs will go here
Java

Se encuentra en src/main/java/…​/CdkHelloWorldStack.java:

package com.myorg;

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

public class CdkHelloWorldStack extends Stack {
    public CdkHelloWorldStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

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

        // Your constructs will go here
    }
}
C#

Se encuentra en src/CdkHelloWorld/CdkHelloWorldStack.cs:

using Amazon.CDK;
using Constructs;

namespace CdkHelloWorld
{
    public class CdkHelloWorldStack : Stack
    {
        internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // Your constructs will go here
        }
    }
}
Go

Ubicado en cdk-hello-world.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 CdkHelloWorldStackProps struct {
    awscdk.StackProps
}

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

    // Your constructs will go here

    return stack
}

func main() {

    // ...

}

func env() *awscdk.Environment {

    return nil

}

En este archivo, la AWS CDK hace lo siguiente:

  • Su instancia de pila CDK se crea a partir de la clase Stack .

  • La clase Constructs base se importa y se proporciona como ámbito o elemento principal de la instancia de la pila.

Defina activos de la función de Lambda

Para definir el recurso de la función Lambda, importe y utilice la construcción aws-lambda L2 de la AWS biblioteca Construct.

Modifique el archivo de pila de la siguiente manera:

TypeScript
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import Lambda L2 construct
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class CdkHelloWorldStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Define the Lambda function resource
    const helloWorldFunction = new lambda.Function(this, 'HelloWorldFunction', {
      runtime: lambda.Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
      code: lambda.Code.fromAsset('lambda'), // Points to the lambda directory
      handler: 'hello.handler', // Points to the 'hello' file in the lambda directory
    });
  }
}
JavaScript
const { Stack, Duration } = require('aws-cdk-lib');
// Import Lambda L2 construct
const lambda = require('aws-cdk-lib/aws-lambda');


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

    // Define the Lambda function resource
    const helloWorldFunction = new lambda.Function(this, 'HelloWorldFunction', {
      runtime: lambda.Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
      code: lambda.Code.fromAsset('lambda'), // Points to the lambda directory
      handler: 'hello.handler', // Points to the 'hello' file in the lambda directory
    });
  }
}

module.exports = { CdkHelloWorldStack }
Python
from aws_cdk import (
    Stack,
    # Import Lambda L2 construct
    aws_lambda as _lambda,
)
# ...

class CdkHelloWorldStack(Stack):

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

        # Define the Lambda function resource
        hello_world_function = _lambda.Function(
            self,
            "HelloWorldFunction",
            runtime = _lambda.Runtime.NODEJS_20_X, # Choose any supported Node.js runtime
            code = _lambda.Code.from_asset("lambda"), # Points to the lambda directory
            handler = "hello.handler", # Points to the 'hello' file in the lambda directory
        )
nota

Importamos el aws_lambda módulo \_lambda porque lambda es un identificador incorporado en Python.

Java
// ...
// Import Lambda L2 construct
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;

public class CdkHelloWorldStack extends Stack {
    public CdkHelloWorldStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

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

        // Define the Lambda function resource
        Function helloWorldFunction = Function.Builder.create(this, "HelloWorldFunction")
                .runtime(Runtime.NODEJS_20_X)  // Choose any supported Node.js runtime
                .code(Code.fromAsset("src/main/resources/lambda")) // Points to the lambda directory
                .handler("hello.handler")  // Points to the 'hello' file in the lambda directory
                .build();
    }
}
C#
// ...
// Import Lambda L2 construct
using Amazon.CDK.AWS.Lambda;

namespace CdkHelloWorld
{
    public class CdkHelloWorldStack : Stack
    {
        internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // Define the Lambda function resource
            var helloWorldFunction = new Function(this, "HelloWorldFunction", new FunctionProps
            {
                Runtime = Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
                Code = Code.FromAsset("lambda"), // Points to the lambda directory
                Handler = "hello.handler" // Points to the 'hello' file in the lambda directory
            });
        }
    }
}
Go
package main

import (
    // ...
    // Import Lambda L2 construct
    "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
    // Import S3 assets construct
    "github.com/aws/aws-cdk-go/awscdk/v2/awss3assets"
    // ...
)

// ...

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

    // Define the Lambda function resource
    helloWorldFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
        Runtime: awslambda.Runtime_NODEJS_20_X(), // Choose any supported Node.js runtime
        Code:    awslambda.Code_FromAsset(jsii.String("lambda"), &awss3assets.AssetOptions{}), // Points to the lambda directory
        Handler: jsii.String("hello.handler"), // Points to the 'hello' file in the lambda directory
    })

    return stack
}

// ...

A continuación, se crea un activo de función de Lambda y se definen las siguientes propiedades:

  • runtime – El entorno en el que se ejecuta la función. En este caso, utilizamos la versión 20.x de Node.js.

  • code – La ruta del código de la función en su máquina local.

  • handler – El nombre del archivo que contiene el código de la función.

Defina su recurso de API REST de API Gateway

Para definir su API Gateway REST API recurso, se importa y se utiliza la construcción aws-apigateway L2 de la biblioteca AWS Construct.

Modifique el archivo de pila de la siguiente manera:

TypeScript
// ...
//Import API Gateway L2 construct
import * as apigateway from 'aws-cdk-lib/aws-apigateway';


export class CdkHelloWorldStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // ...

    // Define the API Gateway resource
    const api = new apigateway.LambdaRestApi(this, 'HelloWorldApi', {
      handler: helloWorldFunction,
      proxy: false,
    });

    // Define the '/hello' resource with a GET method
    const helloResource = api.root.addResource('hello');
    helloResource.addMethod('GET');
  }
}
JavaScript
// ...
// Import API Gateway L2 construct
const apigateway = require('aws-cdk-lib/aws-apigateway');


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

    // ...

    // Define the API Gateway resource
    const api = new apigateway.LambdaRestApi(this, 'HelloWorldApi', {
      handler: helloWorldFunction,
      proxy: false,
    });

    // Define the '/hello' resource with a GET method
    const helloResource = api.root.addResource('hello');
    helloResource.addMethod('GET');
  };
};

// ...
Python
from aws_cdk import (
    # ...
    # Import API Gateway L2 construct
    aws_apigateway as apigateway,
)
from constructs import Construct

class CdkHelloWorldStack(Stack):

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

        # ...

        # Define the API Gateway resource
        api = apigateway.LambdaRestApi(
            self,
            "HelloWorldApi",
            handler = hello_world_function,
            proxy = False,
        )

        # Define the '/hello' resource with a GET method
        hello_resource = api.root.add_resource("hello")
        hello_resource.add_method("GET")
Java
// ...
// Import API Gateway L2 construct
import software.amazon.awscdk.services.apigateway.LambdaRestApi;
import software.amazon.awscdk.services.apigateway.Resource;

public class CdkHelloWorldStack extends Stack {
    public CdkHelloWorldStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

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

        // ...

        // Define the API Gateway resource
        LambdaRestApi api = LambdaRestApi.Builder.create(this, "HelloWorldApi")
                .handler(helloWorldFunction)
                .proxy(false) // Turn off default proxy integration
                .build();

        // Define the '/hello' resource and its GET method
        Resource helloResource = api.getRoot().addResource("hello");
        helloResource.addMethod("GET");
    }
}
C#
// ...
// Import API Gateway L2 construct
using Amazon.CDK.AWS.APIGateway;

namespace CdkHelloWorld
{
    public class CdkHelloWorldStack : Stack
    {
        internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
           // ...

            // Define the API Gateway resource
            var api = new LambdaRestApi(this, "HelloWorldApi", new LambdaRestApiProps
            {
                Handler = helloWorldFunction,
                Proxy = false
            });

            // Add a '/hello' resource with a GET method
            var helloResource = api.Root.AddResource("hello");
            helloResource.AddMethod("GET");
        }
    }
}
Go
// ...

import (
    // ...
    // Import Api Gateway L2 construct
    "github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway"
    // ...
)

// ...

func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) 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 API Gateway resource
    api := awsapigateway.NewLambdaRestApi(stack, jsii.String("HelloWorldApi"), &awsapigateway.LambdaRestApiProps{
        Handler: helloWorldFunction,
        Proxy: jsii.Bool(false),
    })

    // Add a '/hello' resource with a GET method
    helloResource := api.Root().AddResource(jsii.String("hello"), &awsapigateway.ResourceOptions{})
    helloResource.AddMethod(jsii.String("GET"), awsapigateway.NewLambdaIntegration(helloWorldFunction, &awsapigateway.LambdaIntegrationOptions{}), &awsapigateway.MethodOptions{})

    return stack
}

// ...

Aquí, se crea un recurso de API REST de API Gateway, junto con lo siguiente:

  • Una integración entre la API REST y la función Lambda, que permite a la API invocar la función. Esto incluye la creación de un activo de permisos de Lambda.

  • Un nuevo nombre de activo o ruta hello que se agrega a la raíz del punto de conexión de la API. Esto crea un nuevo punto final que se añade /hello a la URL base.

  • Un método GET para el recurso hello. Cuando se envía una solicitud GET al punto de conexión /hello de Lambda, se invoca la función de Lambda y se devuelve su respuesta.

Paso 4: cómo preparar la aplicación para su implementación

En este paso, debe preparar la aplicación para su implementación mediante la creación, si es necesario, y la validación básica con el cdk synth comando AWS CDK CLI.

Si es necesario, cree la aplicación:

TypeScript

Desde la raíz del proyecto, ejecute lo siguiente:

$ npm run build
JavaScript

No es necesario construir.

Python

No es necesario construir.

Java

Desde la raíz del proyecto, ejecute lo siguiente:

$ mvn package
C#

Desde la raíz del proyecto, ejecute lo siguiente:

$ dotnet build src
Go

No es necesario construir.

Ejecute cdk synth para sintetizar una AWS CloudFormation plantilla a partir del código de la CDK. Al utilizar construcciones de capa 2, la CDK le proporciona muchos de los detalles de configuración necesarios AWS CloudFormation para facilitar la interacción entre la función Lambda y la API REST. AWS

Desde la raíz del proyecto, ejecute lo siguiente:

$ cdk synth
nota

Si recibe un error como el siguiente, verifique que se encuentra en el directorio cdk-hello-world e inténtelo de nuevo:

--app is required either in command-line, in cdk.json or in ~/.cdk.json

Si tiene éxito, la CLI de AWS CDK generará la AWS CloudFormation plantilla en YAML formato en la línea de comandos. También se guarda una plantilla JSON formateada en el directorio cdk.out.

El siguiente es un ejemplo de salida de la AWS CloudFormation plantilla:

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: CdkHelloWorldStack/HelloWorldFunction/ServiceRole/Resource
  HelloWorldFunctionunique-identifier:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        S3Bucket:
          Fn::Sub: cdk-unique-identifier-assets-${AWS::AccountId}-${AWS::Region}
        S3Key: unique-identifier.zip
      Handler: hello.handler
      Role:
        Fn::GetAtt:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldFunction/Resource
      aws:asset:path: asset.unique-identifier
      aws:asset:is-bundled: false
      aws:asset:property: Code
  HelloWorldApiunique-identifier:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: HelloWorldApi
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Resource
  HelloWorldApiDeploymentunique-identifier:
    Type: AWS::ApiGateway::Deployment
    Properties:
      Description: Automatically created by the RestApi construct
      RestApiId:
        Ref: HelloWorldApiunique-identifier
    DependsOn:
      - HelloWorldApihelloGETunique-identifier
      - HelloWorldApihellounique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Deployment/Resource
  HelloWorldApiDeploymentStageprod012345ABC:
    Type: AWS::ApiGateway::Stage
    Properties:
      DeploymentId:
        Ref: HelloWorldApiDeploymentunique-identifier
      RestApiId:
        Ref: HelloWorldApiunique-identifier
      StageName: prod
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/DeploymentStage.prod/Resource
  HelloWorldApihellounique-identifier:
    Type: AWS::ApiGateway::Resource
    Properties:
      ParentId:
        Fn::GetAtt:
          - HelloWorldApiunique-identifier
          - RootResourceId
      PathPart: hello
      RestApiId:
        Ref: HelloWorldApiunique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/Resource
  HelloWorldApihelloGETApiPermissionCdkHelloWorldStackHelloWorldApiunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      Principal: apigateway.amazonaws.com
      SourceArn:
        Fn::Join:
          - ""
          - - "arn:"
            - Ref: AWS::Partition
            - ":execute-api:"
            - Ref: AWS::Region
            - ":"
            - Ref: AWS::AccountId
            - ":"
            - Ref: HelloWorldApi9E278160
            - /
            - Ref: HelloWorldApiDeploymentStageprodunique-identifier
            - /GET/hello
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/ApiPermission.CdkHelloWorldStackHelloWorldApiunique-identifier.GET..hello
  HelloWorldApihelloGETApiPermissionTestCdkHelloWorldStackHelloWorldApiunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      Principal: apigateway.amazonaws.com
      SourceArn:
        Fn::Join:
          - ""
          - - "arn:"
            - Ref: AWS::Partition
            - ":execute-api:"
            - Ref: AWS::Region
            - ":"
            - Ref: AWS::AccountId
            - ":"
            - Ref: HelloWorldApiunique-identifier
            - /test-invoke-stage/GET/hello
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/ApiPermission.Test.CdkHelloWorldStackHelloWorldApiunique-identifier.GET..hello
  HelloWorldApihelloGETunique-identifier:
    Type: AWS::ApiGateway::Method
    Properties:
      AuthorizationType: NONE
      HttpMethod: GET
      Integration:
        IntegrationHttpMethod: POST
        Type: AWS_PROXY
        Uri:
          Fn::Join:
            - ""
            - - "arn:"
              - Ref: AWS::Partition
              - ":apigateway:"
              - Ref: AWS::Region
              - :lambda:path/2015-03-31/functions/
              - Fn::GetAtt:
                  - HelloWorldFunctionunique-identifier
                  - Arn
              - /invocations
      ResourceId:
        Ref: HelloWorldApihellounique-identifier
      RestApiId:
        Ref: HelloWorldApiunique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/Resource
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: CdkHelloWorldStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  HelloWorldApiEndpointunique-identifier:
    Value:
      Fn::Join:
        - ""
        - - https://
          - Ref: HelloWorldApiunique-identifier
          - .execute-api.
          - Ref: AWS::Region
          - "."
          - Ref: AWS::URLSuffix
          - /
          - Ref: HelloWorldApiDeploymentStageprodunique-identifier
          - /
Conditions:
  CDKMetadataAvailable:
    Fn::Or:
      - Fn::Or:
          - Fn::Equals:
              - Ref: AWS::Region
              - af-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-east-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-northeast-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-northeast-2
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-southeast-1
          - Fn::Equals:
              - Ref: AWS::Region
              - ap-southeast-2
          - Fn::Equals:
              - Ref: AWS::Region
              - ca-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - cn-north-1
          - Fn::Equals:
              - Ref: AWS::Region
              - cn-northwest-1
      - Fn::Or:
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-north-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-west-1
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-west-2
          - Fn::Equals:
              - Ref: AWS::Region
              - eu-west-3
          - Fn::Equals:
              - Ref: AWS::Region
              - il-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - me-central-1
          - Fn::Equals:
              - Ref: AWS::Region
              - me-south-1
          - Fn::Equals:
              - Ref: AWS::Region
              - sa-east-1
      - Fn::Or:
          - Fn::Equals:
              - Ref: AWS::Region
              - us-east-1
          - Fn::Equals:
              - Ref: AWS::Region
              - us-east-2
          - Fn::Equals:
              - Ref: AWS::Region
              - us-west-1
          - Fn::Equals:
              - Ref: AWS::Region
              - us-west-2
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/hnb659fds/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.

Al utilizar constructos L2, se definen algunas propiedades para configurar los activos y se utilizan métodos auxiliares para integrarlos entre sí. La AWS CDK configura la mayoría de los AWS CloudFormation recursos y propiedades necesarios para aprovisionar la aplicación.

Paso 5: implementar la aplicación

En este paso, utiliza el cdk deploy comando AWS CDK CLI para implementar la aplicación. El AWS CDK trabaja con el AWS CloudFormation servicio para aprovisionar sus recursos.

importante

Debe realizar un arranque único de su AWS entorno antes de la implementación. Para obtener instrucciones, consulte Cómo arrancar su entorno para usarlo con la CDK. AWS

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

$ cdk deploy

✨  Synthesis time: 2.44s

...

Do you wish to deploy these changes (y/n)? <y>

Cuando se complete la implementación, la CLI de AWS CDK generará la URL de su punto final. Copie esta URL para el siguiente paso. A continuación, se muestra un ejemplo:

...
✅  HelloWorldStack

✨  Deployment time: 45.37s

Outputs:
HelloWorldStack.HelloWorldApiEndpointunique-identifier = https://<api-id>.execute-api.<region>.amazonaws.com/prod/
Stack ARN:
arn:aws:cloudformation:region:account-id:stack/HelloWorldStack/unique-identifier
...

Paso 6: cómo interactuar con su aplicación

En este paso, inicie una solicitud GET al punto de conexión de la API y verá el resultado de la función de Lambda.

Localice la URL del punto de conexión del paso anterior y agregue la ruta /hello. Luego, mediante el navegador o la línea de comandos, envíe una solicitud GET al punto de conexión. A continuación, se muestra un ejemplo:

$ curl https://<api-id>.execute-api.<region>.amazonaws.com/prod/hello
{"message":"Hello World!"}%

¡Enhorabuena! ¡Ha creado, implementado e interactuado correctamente con su aplicación mediante el AWS CDK!

Paso 7: cómo eliminar la aplicación

En este paso, utiliza la CLI de AWS CDK para eliminar la aplicación de la AWS nube.

Para eliminar la aplicación, ejecute cdk destroy. Cuando se le indique, confirme su solicitud para eliminar la aplicación:

$ cdk destroy
Are you sure you want to delete: CdkHelloWorldStack (y/n)? y
CdkHelloWorldStack: destroying... [1/1]
...
 ✅  CdkHelloWorldStack: destroyed

Solución de problemas

Error: {"message»: «Error interno del servidor"}%

Al invocar la función de Lambda implementada, recibe este error. Este puede producirse por varios motivos.

Para seguir solucionando problemas

Utilice la AWS CLI para invocar la función Lambda.

  1. Modifique el archivo de pila para capturar el valor de salida del nombre de la función de Lambda implementada. A continuación, se muestra un ejemplo:

    ...

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

    // Define the Lambda function resource
    // ...

    new CfnOutput(this, 'HelloWorldFunctionName', {
      value: helloWorldFunction.functionName,
      description: 'JavaScript Lambda function'
    });

    // Define the API Gateway resource
    // ...
  }
}

  2. Implemente nuevamente la aplicación. La CLI de AWS CDK generará el valor del nombre de la función Lambda implementada:

    $ cdk deploy

✨  Synthesis time: 0.29s
...
 ✅  CdkHelloWorldStack

✨  Deployment time: 20.36s

Outputs:
...
CdkHelloWorldStack.HelloWorldFunctionName = CdkHelloWorldStack-HelloWorldFunctionunique-identifier
...

  3. Utilice la AWS CLI para invocar la función Lambda en AWS la nube y enviar la respuesta a un archivo de texto:

    $ aws lambda invoke --function-name CdkHelloWorldStack-HelloWorldFunctionunique-identifier output.txt

  4. Verifique output.txt para ver los resultados.

    Causa posible: el recurso API Gateway está definido incorrectamente en el archivo de pila

    Si output.txt muestra una respuesta correcta de la función de Lambda, el problema podría estar relacionado con la forma en que definió la API de REST de API Gateway. La AWS CLI invoca su Lambda directamente, no a través de su punto final. Verifique su código para asegurarse de que coincide con este tutorial. A continuación, vuelva a realizar la implementación.

    Causa posible: el recurso Lambda está definido incorrectamente en el archivo de pila

    Si output.txt devuelve un error, el problema podría estar relacionado con la forma en que definió la función de Lambda. Verifique su código para asegurarse de que coincide con este tutorial. A continuación, vuelva a realizar la implementación.