Prérequis Étape 1 : Configurer votre projet Étape 2 : définir la pile Étape 3 : créer la fonction Étape 4 : déployer la pile Étape 5 : tester de la fonction Étape 6 : Nettoyer Étapes suivantes

Déploiement de fonctions Lambda avec AWS CDK

L’AWS Cloud Development Kit (AWS CDK) est un cadre d’infrastructure en tant que code (IaC) qui vous permet de définir l’infrastructure du Cloud AWS en utilisant un langage de programmation de votre choix. Pour définir votre propre infrastructure de cloud, écrivez d'abord une application (dans l'un des langages pris en charge par le CDK) contenant une ou plusieurs piles. Ensuite, vous le synthétisez à un modèle CloudFormation et déployez vos ressources dans votre Compte AWS. Suivez les étapes décrites dans cette rubrique pour déployer une fonction Lambda qui renvoie un événement depuis un point de terminaison Amazon API Gateway.

L'AWS Construct Library, incluse avec le CDK, fournit des modules que vous pouvez utiliser pour modéliser les ressources fournies par les Services AWS. Pour les services populaires, la bibliothèque fournit des constructions organisées avec des valeurs par défaut intelligentes et les bonnes pratiques. Vous pouvez utiliser le module aws_lambda pour définir votre fonction et les ressources de support en quelques lignes de code.

Prérequis

Avant de commencer ce tutoriel, installez l’AWS CDK en exécutant la commande suivante.


npm install -g aws-cdk

Étape 1 : Configurer votre projet AWS CDK

Créez un répertoire pour votre nouvelle appli AWS CDK et initialisez le projet.

Note

Le modèle d'application AWS CDK utilise le nom du répertoire du projet pour générer des noms pour les fichiers source et les classes. Dans cet exemple, le répertoire est nommé hello-lambda. Si vous utilisez un nom répertoire différent, votre application ne correspondra pas à ces instructions.

v2 AWS CDK inclut des constructions stables pour tous les Services AWS dans un seul package, appelé aws-cdk-lib. Ce package est installé en tant que dépendance lorsque vous initialisez le projet. Lorsque vous travaillez avec certains langages de programmation, le package est installé lorsque vous créez le projet pour la première fois.

Étape 2 : définir la pile AWS CDK

Une pile CDK est un ensemble d’une ou plusieurs constructions qui définissent les ressources AWS. Chaque pile CDK représente une pile CloudFormation dans votre application CDK.

Pour définir votre pile CDK, suivez les instructions de votre langage de programmation préféré. Cette pile définit les éléments suivants :

Le nom logique de la fonction : MyFunction
L’emplacement du code de fonction, spécifié dans la propriété code. Pour plus d’informations, consultez Handler code dans la Référence de l’API AWS Cloud Development Kit (AWS CDK).
Le nom logique de l’API REST : HelloApi
Le nom logique du point de terminaison d’API Gateway : ApiGwEndpoint

Notez que toutes les piles CDK de ce tutoriel utilisent l’environnement d’exécution Node.js pour la fonction Lambda. Vous pouvez utiliser différents langages de programmation pour la pile CDK et la fonction Lambda afin de tirer parti des points forts de chaque langage. Par exemple, vous pouvez utiliser TypeScript pour la pile CDK afin de tirer parti des avantages du typage statique pour votre code d’infrastructure. Vous pouvez utiliser JavaScript pour la fonction Lambda afin de tirer parti de la flexibilité et du développement rapide d’un langage à typage dynamique.

JavaScript

Ouvrez le fichier lib/hello-lambda-stack.js et remplacez le contenu par ce qui suit.


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

class HelloLambdaStack extends Stack {
  /**
   *
   * @param {Construct} scope
   * @param {string} id
   * @param {StackProps=} props
   */
  constructor(scope, id, props) {
    super(scope, id, props);
    const fn = new lambda.Function(this, 'MyFunction', {
      code: lambda.Code.fromAsset('lib/lambda-handler'),
      runtime: lambda.Runtime.NODEJS_LATEST,
      handler: 'index.handler'
    });

    const endpoint = new apigw.LambdaRestApi(this, 'MyEndpoint', {
      handler: fn,
      restApiName: "HelloApi"
    });

  }
}

module.exports = { HelloLambdaStack }

TypeScript

Ouvrez le fichier lib/hello-lambda-stack.ts et remplacez le contenu par ce qui suit.


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as apigw from "aws-cdk-lib/aws-apigateway";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as path from 'node:path';

export class HelloLambdaStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps){
    super(scope, id, props)
    const fn = new lambda.Function(this, 'MyFunction', {
      runtime: lambda.Runtime.NODEJS_LATEST,
      handler: 'index.handler',
      code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
    });

    const endpoint = new apigw.LambdaRestApi(this, `ApiGwEndpoint`, {
      handler: fn,
      restApiName: `HelloApi`,
    });

  }
}

Python

Ouvrez le fichier /hello-lambda/hello_lambda/hello_lambda_stack.py et remplacez le contenu par ce qui suit.


from aws_cdk import (
    Stack,
    aws_apigateway as apigw,
    aws_lambda as _lambda
)
from constructs import Construct

class HelloLambdaStack(Stack):

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

        fn = _lambda.Function(
            self,
            "MyFunction",
            runtime=_lambda.Runtime.NODEJS_LATEST,
            handler="index.handler",
            code=_lambda.Code.from_asset("lib/lambda-handler")
        )

        endpoint = apigw.LambdaRestApi(
            self,
            "ApiGwEndpoint",
            handler=fn,
            rest_api_name="HelloApi"
        )

Java

Ouvrez le fichier /hello-lambda/src/main/java/com/myorg/HelloLambdaStack.java et remplacez le contenu par ce qui suit.


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.apigateway.LambdaRestApi;
import software.amazon.awscdk.services.lambda.Function;

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

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

        Function hello = Function.Builder.create(this, "MyFunction")
                            .runtime(software.amazon.awscdk.services.lambda.Runtime.NODEJS_LATEST)
                            .code(software.amazon.awscdk.services.lambda.Code.fromAsset("lib/lambda-handler"))
                            .handler("index.handler")
                            .build();

        LambdaRestApi api = LambdaRestApi.Builder.create(this, "ApiGwEndpoint")
                                .restApiName("HelloApi")
                                .handler(hello)
                                .build();

    }
}

C#

Ouvrez le fichier src/HelloLambda/HelloLambdaStack.cs et remplacez le contenu par ce qui suit.


using Amazon.CDK;
using Amazon.CDK.AWS.APIGateway;
using Amazon.CDK.AWS.Lambda;
using Constructs;

namespace HelloLambda
{
    public class HelloLambdaStack : Stack
    {
        internal HelloLambdaStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var fn = new Function(this, "MyFunction", new FunctionProps
            {
                Runtime = Runtime.NODEJS_LATEST,
                Code = Code.FromAsset("lib/lambda-handler"),
                Handler = "index.handler"
            });

            var api = new LambdaRestApi(this, "ApiGwEndpoint", new LambdaRestApiProps
            {
                Handler = fn
            });
        }
    }
}

Étape 3 : créer le code de la fonction Lambda

À partir de la racine de votre projet (hello-lambda), créez le répertoire /lib/lambda-handler pour le code de la fonction Lambda. Ce répertoire est spécifié dans la propriété code de votre pile AWS CDK.

Dans le répertoire /lib/lambda-handler, créez un nouveau fichier appelé index.js. Collez le code suivant dans le fichier. La fonction extrait des propriétés spécifiques de la requête d’API et les renvoie sous forme de réponse JSON.


exports.handler = async (event) => {
  // Extract specific properties from the event object
  const { resource, path, httpMethod, headers, queryStringParameters, body } = event;
  const response = {
    resource,
    path,
    httpMethod,
    headers,
    queryStringParameters,
    body,
  };
  return {
    body: JSON.stringify(response, null, 2),
    statusCode: 200,
  };
};

Étape 4 : déployer la pile AWS CDK

À la racine de votre projet, effectuez la commande cdk synth :


cdk synth

Cette commande synthétise un modèle AWS CloudFormation à partir de votre pile de CDK. Le modèle est un fichier YAML d’environ 400 lignes, semblable à ce qui suit.

Note

Si vous obtenez l’erreur suivante, assurez-vous que vous êtes à la racine du répertoire de votre projet.


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

Exemple CloudFormationModèle


Resources:
  MyFunctionServiceRole3C357FF2:
    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: HelloLambdaStack/MyFunction/ServiceRole/Resource
  MyFunction1BAA52E7:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        S3Bucket:
          Fn::Sub: cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}
        S3Key: ab1111111cd32708dc4b83e81a21c296d607ff2cdef00f1d7f48338782f92l3901.zip
      Handler: index.handler
      Role:
        Fn::GetAtt:
          - MyFunctionServiceRole3C357FF2
          - Arn
      Runtime: nodejs22.x
      ...

Exécutez la commande cdk deploy :
```
cdk deploy
```
Patientez que vos ressources soient créées. Le résultat final inclut l’URL de votre point de terminaison d’API Gateway. Exemple :
```
Outputs:
HelloLambdaStack.ApiGwEndpoint77F417B1 = https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/
```

Étape 5 : tester de la fonction

Pour invoquer la fonction Lambda, copiez le point de terminaison d’API Gateway et collez-le dans un navigateur Web ou exécutez une commande curl :


curl -s https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/

La réponse est une représentation JSON des propriétés sélectionnées à partir de l’objet d’événement d’origine, qui contient des informations sur la requête envoyée au point de terminaison d’API Gateway. Exemple :


{
  "resource": "/",
  "path": "/",
  "httpMethod": "GET",
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
    "Accept-Encoding": "gzip, deflate, br, zstd",
    "Accept-Language": "en-US,en;q=0.9",
    "CloudFront-Forwarded-Proto": "https",
    "CloudFront-Is-Desktop-Viewer": "true",
    "CloudFront-Is-Mobile-Viewer": "false",
    "CloudFront-Is-SmartTV-Viewer": "false",
    "CloudFront-Is-Tablet-Viewer": "false",
    "CloudFront-Viewer-ASN": "16509",
    "CloudFront-Viewer-Country": "US",
    "Host": "abcd1234.execute-api.us-east-1.amazonaws.com",
     ...

Étape 6 : Nettoyer vos ressources

Le point de terminaison d’API Gateway est accessible au public. Pour éviter des frais inattendus, exécutez la commande cdk destroy pour supprimer la pile et toutes les ressources associées.


cdk destroy

Étapes suivantes

Pour plus d'informations sur l'écriture d'applications AWS CDK dans la langue de votre choix, consultez les éléments suivants :

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation d’AWS SAM et d’Infrastructure Composer

Powertools pour AWS Lambda