Requisitos previos Acerca de este tutorial Paso 1: Crea tu CDK proyecto Paso 2: Configure su AWS entorno Paso 3: Inicie su entorno AWS Paso 4: Crea tu aplicación CDK Paso 5: Haz una lista de las CDK pilas de tu aplicación Paso 6: Defina la función Lambda Paso 7: Defina la función Lambda URL Paso 8: Sintetizar una plantilla CloudFormation Paso 9: Implemente su pila CDK Paso 10: Interactúa con tu aplicación en AWS Paso 11: Modifica tu aplicación Paso 12: Elimina tu aplicación Siguientes pasos

Tutorial: Crea tu primera AWS CDK aplicación

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

Requisitos previos

Antes de comenzar este tutorial, complete todos los pasos de configuración que se indican enCómo empezar con el AWS CDK.

Acerca de este tutorial

En este tutorial, creará e implementará una aplicación sencilla al AWS usar el AWS CDK. La aplicación consta de una AWS Lambda función que devuelve un Hello World! mensaje cuando se invoca. La función se invocará a través de una función Lambda URL que sirve como punto final HTTP (S) dedicado para la función Lambda.

A través de este tutorial, realizará lo siguiente:

Cree su proyecto: cree un CDK proyecto utilizando el CDK CLI cdk initcomando.
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 CDK CLI cdk bootstrapcomando.
Desarrolle su aplicación: utilice componentes de la biblioteca AWS Construct para definir la función Lambda y los recursos de la función Lambda. URL
Prepare la aplicación para la implementación: utilice el CDK CLI para crear su aplicación y sintetizar una AWS CloudFormation plantilla.
Implemente su aplicación: utilice el CDK CLI cdk deploycomando para implementar la aplicación y aprovisionar AWS los recursos.
Interactúe con su aplicación: interactúe con la función Lambda AWS desplegada invocándola y recibiendo una respuesta.
Modifique su aplicación: modifique la función Lambda y despliéguela para implementar los cambios.
Elimine su aplicación: elimine todos los recursos que haya creado mediante el CDK CLI cdk destroycomando.

Paso 1: Crea tu CDK proyecto

En este paso, crearás un nuevo CDK proyecto. Un CDK proyecto debe estar en su propio directorio, con sus propias dependencias de módulos locales.

Para crear un proyecto CDK

Desde el directorio de inicio de su elección, cree y navegue hasta un directorio denominadohello-cdk:
```
$ mkdir hello-cdk && cd hello-cdk
```
importante
Asegúrese de asignar un nombre al directorio hello-cdk del proyecto exactamente como se muestra aquí. El CDK CLI usa este nombre de directorio para nombrar cosas dentro de su CDK código. Si utilizas un nombre de directorio diferente, tendrás problemas durante este tutorial.
Desde el hello-cdk directorio, inicialice un nuevo CDK proyecto mediante el CDK CLI cdk initcomando. Especifique la app plantilla y el lenguaje de programación preferido con la --language opción:
TypeScript
```
$ cdk init app --language typescript
```
JavaScript
```
$ cdk init app --language javascript
```
Python
```
$ cdk init app --language python
```
Una vez creada la aplicación, introduce también los dos comandos siguientes. Estos activan la aplicación Python entorno virtual e instala las dependencias AWS CDK principales.
```
$ 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 está utilizando unIDE, ahora puede abrir o importar el proyecto. En Eclipse, por ejemplo, elija Archivo > Importar > Maven > Proyectos Maven existentes. Asegúrese de que los ajustes del proyecto estén configurados 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 src directorio.
Go
```
$ cdk init app --language go
```
Una vez creada la aplicación, introduzca también el siguiente comando para instalar los módulos de AWS Construct Library que requiere la aplicación.
```
$ go get
```

El cdk init comando crea una estructura de archivos y carpetas dentro del hello-cdk directorio para ayudar a organizar el código fuente de la CDK aplicación. Esta estructura de archivos y carpetas se denomina CDK proyecto. Tómate un momento para explorar tu CDK proyecto.

Si tienes Git instalado, cada proyecto que cree con él también cdk init se inicializa como Git .

Durante la inicialización del proyecto, el CDK CLI crea una CDK aplicación que contiene una sola CDK pila. La instancia de la CDK aplicación se crea mediante la App construcción. La siguiente es una parte de este código del archivo de CDK la aplicación:

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

TypeScript

Ubicado enlib/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

Ubicado enlib/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

Ubicado enhello_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

Ubicado ensrc/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#

Ubicado ensrc/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

Ubicado enhello-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 CDK pila. De este modo, especificas en qué entorno se implementará tu CDK pila.

En primer lugar, determine el AWS entorno que quiere usar. Un AWS entorno se compone de una Cuenta de AWS y Región de AWS.

Si lo usa AWS CLI para configurar las credenciales de seguridad en su máquina local, puede usarlo AWS CLI para obtener información del AWS entorno para un perfil específico.

Para usar el AWS CLI para obtener su Cuenta de AWS ID

Ejecute el siguiente AWS CLI comando para obtener el Cuenta de AWS ID de su default perfil:
```
$ aws sts get-caller-identity --query "Account" --output text
```
Si prefiere usar un perfil con nombre, proporcione el nombre de su perfil mediante la --profile opción:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```

Para usar el AWS CLI para obtener su Región de AWS

Ejecute el siguiente AWS CLI comando para obtener la región que configuró para su default perfil:
```
$ aws configure get region
```
Si prefiere usar un perfil con nombre, proporcione el nombre de su perfil mediante la --profile opción:
```
$ aws configure get region --profile your-profile-name
```

A continuación, configurará el AWS entorno de su CDK pila modificando la HelloCdkStack instancia en el archivo de su aplicación. Para este tutorial, codificará la información de su AWS entorno. Esto se recomienda para entornos de producción. Para obtener información sobre otras formas de configurar entornos, consulteConfigure los entornos para usarlos con el AWS CDK.

Para configurar el entorno de su CDK pila

En el archivo de la aplicación, utilice la env propiedad de la Stack construcción para configurar el entorno. A continuación, se muestra un ejemplo:

TypeScript

Ubicado enbin/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

Ubicado enbin/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

Ubicado enapp.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

Ubicado ensrc/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#

Ubicado ensrc/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

Ubicado enhello-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 CDK implementaciones.

Para arrancar su entorno, ejecute lo siguiente desde la raíz del proyecto: CDK


$ cdk bootstrap

Al arrancar desde la raíz del CDK proyecto, no es necesario que proporciones ninguna información adicional. El CDK CLI obtiene información ambiental de su proyecto. Cuando arranca fuera de un CDK proyecto, debe proporcionar información sobre el entorno con el cdk bootstrap comando. Para obtener más información, consulte Inicie su entorno para usarlo con AWS CDK.

Paso 4: Crea tu aplicación 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 AWS CDK con el CDK CLI realizará este paso automáticamente. Sin embargo, puedes seguir compilando manualmente si quieres atrapar errores de sintaxis y de tipo. A continuación, se muestra un ejemplo:

Paso 5: Haz una lista de las CDK pilas de tu aplicación

En este punto, deberías tener una CDK aplicación que contenga una sola CDK pila. Para verificarlo, usa la CDK CLI cdk listcomando para mostrar las pilas. El resultado debe mostrar una sola pila llamadaHelloCdkStack:


$ cdk list
HelloCdkStack

Si no ve este resultado, compruebe que está en el directorio de trabajo correcto de su proyecto e inténtelo de nuevo. Si sigues sin ver tu pila, repite el proceso Paso 1: Crea tu CDK proyecto e inténtalo de nuevo.

Paso 6: Defina la función Lambda

En este paso, se importa el aws_lambda módulo de la biblioteca de AWS construcciones y se utiliza la construcción Function L2.

Modifique el archivo de CDK pila de la siguiente manera:

TypeScript

Ubicado enlib/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

Ubicado enlib/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

Ubicado enhello_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

Ubicado ensrc/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#

Ubicado ensrc/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

Ubicado enhello-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
}

// ...

Echemos un vistazo más de cerca a la Function construcción. Como todas las construcciones, la Function clase utiliza tres parámetros:

alcance: define la Stack instancia como la matriz de la Function construcción. Todas las construcciones que definen AWS los recursos se crean dentro del ámbito de una pila. Puede definir componentes fijos dentro de otros componentes, creando una jerarquía (árbol). En este caso, y en la mayoría de los casos, el ámbito es this (en self Python).
ID: el ID de construcción Function de la AWS CDK aplicación. 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. 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í, tu ID de construcción esHelloWorldFunction. Las funciones también pueden tener un nombre, especificado con la functionName propiedad. Es diferente del identificador de construcción.
props: conjunto de valores que definen las propiedades de la función. Aquí se definen las code propiedades runtimehandler, y.

Los accesorios se representan de forma diferente en los idiomas compatibles con. AWS CDK
- En TypeScript y JavaScript, props es un argumento único y se pasa un objeto que contiene las propiedades deseadas.
- En Python, los accesorios se pasan como argumentos de palabras clave.
- En Java, se proporciona un constructor para pasar los accesorios. Hay dos: uno para FunctionProps y otro para Function que puedas construir la construcción y su objeto de utilería en un solo paso. Este código usa este último.
- En C#, se crea una instancia de un FunctionProps objeto mediante un inicializador de objetos y se pasa como tercer parámetro.
Si los accesorios de una construcción son opcionales, puedes omitir el parámetro por completo. props

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 construcción para ampliarla según sus necesidades o si desea cambiar sus valores predeterminados.

Paso 7: Defina la función Lambda URL

En este paso, se utiliza el método addFunctionUrl auxiliar de la Function construcción para definir una función URL Lambda. Para generar el valor de este valor URL en el despliegue, creará una AWS CloudFormation salida utilizando la CfnOutput construcción.

Añada lo siguiente a su archivo de CDK pila:

TypeScript

Ubicado enlib/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

Ubicado enlib/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

Ubicado enhello_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

Ubicado ensrc/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#

Ubicado ensrc/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

Ubicado enhello-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 función Lambda URL se define sin autenticación. Cuando se implementa, se crea un punto final de acceso público que se puede utilizar para invocar la función. Cuando termines con este tutorial, sigue estos pasos Paso 12: Elimina tu aplicación para eliminar estos recursos.

Paso 8: Sintetizar una plantilla CloudFormation

En este paso, se prepara para el despliegue sintetizando una plantilla con CloudFormation CDK CLI cdk synthcomando. Este comando realiza una validación básica del CDK código, ejecuta la CDK aplicación y genera una CloudFormation plantilla a partir de la CDK pila.

Si tu aplicación contiene más de una pila, debes especificar qué pilas quieres sintetizar. Como tu aplicación contiene una sola pila, CDK CLI detecta automáticamente la pila que se va a sintetizar.

Si no sintetiza una plantilla, la CDK CLI realizará este paso automáticamente cuando la despliegues. Sin embargo, le 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 tipo. Para obtener instrucciones, consulte Paso 4: Crea tu aplicación CDK.

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


$ cdk synth

nota

Si recibes un error como el siguiente, comprueba que estás en el hello-cdk directorio e inténtalo de nuevo:

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

Si tiene éxito, el CDK CLI generará un YAML CloudFormation —plantilla formateada en stdout y guardada JSON—plantilla formateada en el cdk.out directorio de su proyecto.

El siguiente es un ejemplo de salida de la 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: 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 AWS::CDK::Metadata recurso de forma predeterminada. El AWS CDK equipo utiliza estos metadatos para obtener información sobre el AWS CDK uso y encontrar formas de mejorarlo. Para obtener más información, incluida la forma de excluirse de los informes de versiones, consulteInformes de versiones.

Al definir una única construcción de nivel 2, AWS CDK crea una CloudFormation plantilla extensa 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 CDK

En este paso, utiliza el CDK CLI cdk deploycomando para desplegar tu CDK pila. Este comando recupera la CloudFormation plantilla generada y la despliega mediante ella AWS CloudFormation, lo que aprovisiona los recursos como parte de una CloudFormation pila.

Desde la raíz del proyecto, ejecuta lo siguiente. Confirma los cambios si se te 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 cdk synth modo, no es necesario especificar la AWS CDK pila, ya que la aplicación contiene una sola pila.

Durante la implementación, el CDK CLI muestra la información de progreso a medida que se despliega la pila. Cuando hayas terminado, puedes ir a la AWS CloudFormation consola para ver tu HelloCdkStack pila. También puede ir a la consola de Lambda para ver el recurso. HelloWorldFunction

Cuando se complete la implementación, el CDK CLI generará su punto finalURL. Copia esto 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ú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 función. URL Al acceder aURL, la función Lambda devuelve el Hello World! mensaje.

Para invocar su función, acceda a la función a URL través de su 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: Modifica tu aplicación

En este paso, se modifica el mensaje que devuelve la función Lambda cuando se invoca. Para realizar una diferencia, utilice el CDK CLI cdk diffcomando para obtener una vista previa de los cambios y desplegarlos para actualizar la aplicación. A continuación, interactúa con la aplicación AWS para ver el nuevo mensaje.

Modifica la myFunction instancia en tu archivo de CDK pila de la siguiente manera:

TypeScript

Ubicado enlib/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

Ubicado enlib/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

Ubicado enhello_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

Ubicado ensrc/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 desplegado, utilizará el CDK CLI 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 los cambios necesarios para alcanzar el nuevo estado deseado.

Para obtener una vista previa de los cambios, ejecute el cdk diff comando. 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, el CDK CLI consulta tu Cuenta de AWS cuenta para obtener la AWS CloudFormation plantilla más reciente de la HelloCdkStack pila. A continuación, compara la plantilla más reciente con la plantilla que acaba de sintetizar en tu aplicación.

Para implementar los cambios, ejecuta el cdk deploy comando. 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 interactuar con la aplicación, repita el procedimientoPaso 10: Interactúa con tu aplicación en AWS. A continuación, se muestra un ejemplo:


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello CDK!"%

Paso 12: Elimina tu aplicación

En este paso, utiliza el CDK CLI cdk destroycomando para eliminar la aplicación. Este comando elimina la CloudFormation pila asociada a la suyaCDK, que incluye los recursos que ha creado.

Para eliminar la aplicación, ejecute el cdk destroy comando y confirme la solicitud de eliminación de 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 este tutorial y lo ha utilizado AWS CDK para crear, modificar y eliminar correctamente los recursos del Nube de AWS. Ahora está listo para empezar a utilizar el AWS CDK.

Para obtener más información sobre el uso de AWS CDK en su lenguaje de programación preferido, consulteTrabaja con la AWS CDK biblioteca.

Para obtener recursos adicionales, consulte lo siguiente:

Pruebe el CDKtaller para realizar un recorrido más detallado sobre un proyecto más complejo.
Consulte la APIreferencia para empezar a explorar las CDK estructuras disponibles para sus AWS servicios favoritos.
Visite Construct Hub para descubrir construcciones creadas por AWS y otras personas.
Explore ejemplos de uso del AWS CDK.

AWS CDK Es un proyecto de código abierto. Para contribuir, consulte Contribuir al AWS Cloud Development Kit (AWS CDK).

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Introducción

Trabaja con la CDK biblioteca

Tutorial: Crea tu primera AWS CDK aplicación

Requisitos previos

Acerca de este tutorial

Paso 1: Crea tu CDK proyecto

Para crear un proyecto CDK

importante

Paso 2: Configure su AWS entorno

Para usar el AWS CLI para obtener su Cuenta de AWS ID

Para usar el AWS CLI para obtener su Región de AWS

Para configurar el entorno de su CDK pila

Paso 3: Inicie su entorno AWS

Paso 4: Crea tu aplicación CDK

Paso 5: Haz una lista de las CDK pilas de tu aplicación

Paso 6: Defina la función Lambda

Paso 7: Defina la función Lambda URL

aviso

Paso 8: Sintetizar una plantilla CloudFormation

nota

nota

Paso 9: Implemente su pila CDK

Paso 10: Interactúa con tu aplicación en AWS

Paso 11: Modifica tu aplicación

Paso 12: Elimina tu aplicación

Siguientes pasos