Prérequis À propos de ce didacticiel Étape 1 : Créez votre projet CDK Étape 2 : Configuration de votre AWS environnement Étape 3 : Bootstrap votre environnement AWS Étape 4 : Créez votre application CDK Étape 5 : Répertoriez les piles de CDK dans votre application Étape 6 : Définissez votre fonction Lambda Étape 7 : Définissez l'URL de votre fonction Lambda Étape 8 : Synthétiser un modèle CloudFormation Étape 9 : Déployez votre pile de CDK Étape 10 : Interagissez avec votre application sur AWS Étape 11 : Modifiez votre candidature Étape 12 : Supprimer votre application Étapes suivantes

Tutoriel : Créez votre première AWS application CDK

Commencez à utiliser le AWS Cloud Development Kit (AWS CDK) en utilisant l'interface de ligne de commande AWS CDK (AWS CDK CLI) pour développer votre première application CDK, démarrer AWS votre environnement et y déployer votre application. AWS

Prérequis

Avant de commencer ce didacticiel, suivez toutes les étapes de configuration dans Getting started with the AWS CDK.

À propos de ce didacticiel

Dans ce didacticiel, vous allez créer et déployer une application simple AWS utilisant le AWS CDK. L'application consiste en une fonction AWS Lambda qui renvoie un Hello World! message lorsqu'elle est invoquée. La fonction sera invoquée via une URL de fonction Lambda qui sert de point de terminaison HTTP (S) dédié à votre fonction Lambda.

Dans le cadre de ce didacticiel, vous allez effectuer les opérations suivantes :

Créez votre projet : créez un projet CDK à l'aide de la commande CDK cdk init CLI.
Configuration de votre AWS environnement : configurez l' AWS environnement dans lequel vous allez déployer votre application.
Démarrez votre AWS environnement : préparez votre AWS environnement pour le déploiement en le démarrant à l'aide de la commande CDK CLI. cdk bootstrap
Développez votre application : utilisez les constructions de la bibliothèque AWS Construct pour définir votre fonction Lambda et les ressources URL de votre fonction Lambda.
Préparez votre application pour le déploiement : utilisez la CLI CDK pour créer votre application et synthétiser un AWS CloudFormation modèle.
Déployez votre application : utilisez la cdk deploy commande CDK CLI pour déployer votre application et provisionner vos AWS ressources.
Interagissez avec votre application : interagissez avec votre fonction Lambda déployée AWS en l'invoquant et en recevant une réponse.
Modifiez votre application : modifiez votre fonction Lambda et déployez-la pour implémenter vos modifications.
Supprimer votre application : supprimez toutes les ressources que vous avez créées à l'aide de la cdk destroy commande CDK CLI.

Étape 1 : Créez votre projet CDK

Au cours de cette étape, vous allez créer un nouveau projet CDK. Un projet CDK doit se trouver dans son propre répertoire, avec ses propres dépendances de module locales.

Pour créer un projet CDK

À partir du répertoire de départ de votre choix, créez et naviguez vers un répertoire nommé hello-cdk :
```
$ mkdir hello-cdk && cd hello-cdk
```
Important
Assurez-vous de nommer le répertoire de votre projethello-cdk, exactement comme indiqué ici. La CLI CDK utilise ce nom de répertoire pour nommer les éléments de votre code CDK. Si vous utilisez un autre nom de répertoire, vous rencontrerez des problèmes au cours de ce didacticiel.
Dans le hello-cdk répertoire, initialisez un nouveau projet CDK à l'aide de la commande CDK CLIcdk init. Spécifiez le app modèle et votre langage de programmation préféré avec l'--languageoption suivante :
TypeScript

$ cdk init app --language typescript

JavaScript

$ cdk init app --language javascript

Python

$ cdk init app --language python

Une fois l'application créée, entrez également les deux commandes suivantes. Ils activent l'environnement virtuel Python de l'application et installent les dépendances principales du AWS CDK.

$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead $ python -m pip install -r requirements.txt

Java

$ cdk init app --language java

Si vous utilisez un IDE, vous pouvez désormais ouvrir ou importer le projet. Par exempleEclipse, choisissez Fichier > Importer > Maven > Projets Maven existants. Assurez-vous que les paramètres du projet sont définis pour utiliser Java 8 (1.8).

C#

$ cdk init app --language csharp

Si vous utilisez Visual Studio, ouvrez le fichier de solution dans le src répertoire.

Go

$ cdk init app --language go

Une fois l'application créée, entrez également la commande suivante pour installer les modules AWS Construct Library dont l'application a besoin.

$ go get

La cdk init commande crée une structure de fichiers et de dossiers dans le hello-cdk répertoire pour aider à organiser le code source de votre application CDK. Cette structure de fichiers et de dossiers s'appelle votre projet CDK. Prenez un moment pour explorer votre projet CDK.

Si vous l'avez Git installé, chaque projet que vous créez à l'aide cdk init est également initialisé en tant que Git référentiel.

Lors de l'initialisation du projet, la CLI CDK crée une application CDK contenant une seule pile CDK. L'instance de l'application CDK est créée à l'aide de la Appconstruction. Voici une partie de ce code provenant de votre fichier d'application CDK :

TypeScript

Situé dans bin/hello-cdk.ts :


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

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

JavaScript

Situé dans bin/hello-cdk.js :


#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');

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

Python

Situé dans app.py :


#!/usr/bin/env python3
import os

import aws_cdk as cdk

from hello_cdk.hello_cdk_stack import HelloCdkStack

app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",)

app.synth()

Java

Situé dans src/main/java/…/HelloCdkApp.java :


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class HelloCdkApp {
  public static void main(final String[] args) {
    App app = new App();

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

    app.synth();
  }
}

C#

Situé dans src/HelloCdk/Program.cs :


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

namespace HelloCdk
{
  sealed class Program
  {
    public static void Main(string[] args)
    {
      var app = new App();
      new HelloCdkStack(app, "HelloCdkStack", new StackProps
      {});
      app.Synth();
    }
  }
}

Go

Situé dans hello-cdk.go :


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

// ...

func main() {
  defer jsii.Close()

  app := awscdk.NewApp(nil)

  NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

// ...

La pile CDK est créée à l'aide de la Stackconstruction. Voici une partie de ce code provenant de votre fichier de pile CDK :

TypeScript

Situé dans lib/hello-cdk-stack.ts :


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

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

    // Define your constructs here

  }
}

JavaScript

Situé dans lib/hello-cdk-stack.js :


const { Stack } = require('aws-cdk-lib');

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

    // Define your constructs here

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


from aws_cdk import (
  Stack,
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define your constructs here

Java

Situé dans src/main/java/…/HelloCdkStack.java :


package com.myorg;

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

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

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

    // Define your constructs here
  }
}

C#

Situé dans src/HelloCdk/HelloCdkStack.cs :


using Amazon.CDK;
using Constructs;

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}

Go

Situé dans hello-cdk.go :


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  return stack
}

// ...

Étape 2 : Configuration de votre AWS environnement

Au cours de cette étape, vous configurez l' AWS environnement de votre pile CDK. Ce faisant, vous spécifiez l'environnement dans lequel votre pile CDK sera déployée.

Déterminez d'abord l' AWS environnement que vous souhaitez utiliser. Un AWS environnement se compose d'un AWS compte et d'une AWS région.

Lorsque vous utilisez la AWS CLI pour configurer les informations d'identification de sécurité sur votre machine locale, vous pouvez ensuite utiliser l' AWS interface de ligne de commande pour obtenir des informations d' AWS environnement pour un profil spécifique.

Pour utiliser la AWS CLI pour obtenir votre identifiant de AWS compte

Exécutez la commande AWS CLI suivante pour obtenir l'identifiant de AWS compte de votre default profil :
```
$ aws sts get-caller-identity --query "Account" --output text
```
Si vous préférez utiliser un profil nommé, indiquez le nom de votre profil à l'aide de l'--profileoption suivante :
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```

Pour utiliser la AWS CLI pour obtenir votre AWS région

Exécutez la commande AWS CLI suivante pour obtenir la région que vous avez configurée pour votre default profil :
```
$ aws configure get region
```
Si vous préférez utiliser un profil nommé, indiquez le nom de votre profil à l'aide de l'--profileoption suivante :
```
$ aws configure get region --profile your-profile-name
```

Vous allez ensuite configurer l' AWS environnement de votre pile CDK en modifiant l'HelloCdkStackinstance dans votre fichier d'application. Dans le cadre de ce didacticiel, vous allez coder en dur les informations relatives à votre AWS environnement. Cela est recommandé pour les environnements de production. Pour plus d'informations sur les autres méthodes de configuration des environnements, voir Configurer les environnements à utiliser avec le AWS CDK.

Pour configurer l'environnement de votre pile CDK

Dans votre fichier d'application, utilisez la env propriété de la Stack construction pour configurer votre environnement. Voici un exemple :

TypeScript

Situé dans bin/hello-cdk.ts :


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

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

JavaScript

Situé dans bin/hello-cdk.js :


#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');

const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

Python

Situé dans app.py :


#!/usr/bin/env python3
import os

import aws_cdk as cdk

from hello_cdk.hello_cdk_stack import HelloCdkStack

app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
  env=cdk.Environment(account='123456789012', region='us-east-1'),
  )

app.synth()

Java

Situé dans src/main/java/…/HelloCdkApp.java :


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class HelloCdkApp {
    public static void main(final String[] args) {
        App app = new App();

        new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
                .env(Environment.builder()
                        .account("123456789012")
                        .region("us-east-1")
                        .build())

                .build());

        app.synth();
    }
}

C#

Situé dans src/HelloCdk/Program.cs :


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

namespace HelloCdk
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new HelloCdkStack(app, "HelloCdkStack", new StackProps
            {
                Env = new Amazon.CDK.Environment
                {
                    Account = "123456789012",
                    Region = "us-east-1",
                }
            });
            app.Synth();
        }
    }
}

Go

Situé dans hello-cdk.go :


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

// ...

func main() {
  defer jsii.Close()

  app := awscdk.NewApp(nil)

  NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

func env() *awscdk.Environment {
	return &awscdk.Environment{
		Account: jsii.String("123456789012"),
		Region:  jsii.String("us-east-1"),
	}
}

Étape 3 : Bootstrap votre environnement AWS

Au cours de cette étape, vous allez démarrer l' AWS environnement que vous avez configuré à l'étape précédente. Cela prépare votre environnement pour les déploiements de CDK.

Pour démarrer votre environnement, exécutez ce qui suit depuis la racine de votre projet CDK :


$ cdk bootstrap

En démarrant depuis la racine de votre projet CDK, vous n'avez pas à fournir d'informations supplémentaires. La CLI CDK obtient des informations sur l'environnement à partir de votre projet. Lorsque vous démarrez en dehors d'un projet CDK, vous devez fournir des informations d'environnement avec la cdk bootstrap commande. Pour plus d'informations, consultez Bootstrap votre environnement pour l'utiliser avec le AWS CDK.

Étape 4 : Créez votre application CDK

Dans la plupart des environnements de programmation, vous créez ou compilez du code après avoir apporté des modifications. Cela n'est pas nécessaire avec le AWS CDK puisque la CLI du CDK exécutera automatiquement cette étape. Cependant, vous pouvez toujours créer manuellement lorsque vous souhaitez détecter des erreurs de syntaxe et de type. Voici un exemple :

Étape 5 : Répertoriez les piles de CDK dans votre application

À ce stade, vous devriez avoir une application CDK contenant une seule pile de CDK. Pour vérifier, utilisez la cdk list commande CDK CLI pour afficher vos piles. La sortie doit afficher une seule pile nommée HelloCdkStack :


$ cdk list
HelloCdkStack

Si ce résultat ne s'affiche pas, vérifiez que vous vous trouvez dans le bon répertoire de travail de votre projet et réessayez. Si vous ne voyez toujours pas votre pile, répétez l'étape 1 : Créez votre projet CDK et réessayez.

Étape 6 : Définissez votre fonction Lambda

Au cours de cette étape, vous importez le aws_lambdamodule depuis la AWS bibliothèque de constructions et vous utilisez la construction FunctionL2.

Modifiez votre fichier de pile CDK comme suit :

TypeScript

Situé dans lib/hello-cdk-stack.ts :


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';

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

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });
  }
}

JavaScript

Situé dans lib/hello-cdk-stack.js :


const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');

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

    // Define the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
      `),
    });

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


from aws_cdk import (
  Stack,
  aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define the Lambda function resource
    my_function = _lambda.Function(
      self, "HelloWorldFunction",
      runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
      handler = "index.handler",
      code = _lambda.Code.from_inline(
        """
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };
        """
      ),
    )

Java

Situé dans src/main/java/…/HelloCdkStack.java :


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;

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

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

    // Define the Lambda function resource
    Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
      .runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
      .handler("index.handler")
      .code(Code.fromInline(
        "exports.handler = async function(event) {" +
        " return {" +
        " statusCode: 200," +
        " body: JSON.stringify('Hello World!')" +
        " };" +
        "};"))
      .build();

  }
}

C#

Situé dans src/main/java/…/HelloCdkStack.java :


using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define the Lambda function resource
      var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
      {
        Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
        Handler = "index.handler",
        Code = Code.FromInline(@"
          exports.handler = async function(event) {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello World!'),
            };
          };
        "),
      });
    }
  }
}

Go

Situé dans hello-cdk.go :


package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
  // Import the Lambda module
  "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  // Define the Lambda function resource
  myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
    Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
    Handler: jsii.String("index.handler"),
    Code: awslambda.Code_FromInline(jsii.String(`
      exports.handler = async function(event) {
        return {
          statusCode: 200,
          body: JSON.stringify('Hello World!'),
        };
      };
    `)),
  })

  return stack
}

// ...

Regardons la Function construction de plus près. Comme toutes les constructions, la Function classe prend trois paramètres :

scope — Définit votre Stack instance en tant que parent de la Function construction. Toutes les constructions qui définissent les AWS ressources sont créées dans le cadre d'une pile. Vous pouvez définir des constructions à l'intérieur des constructions, en créant une hiérarchie (arbre). Ici, et dans la plupart des cas, le champ d'application est this (selfen Python).
Id — L'ID de construction de Function l'application AWS CDK. Cet identifiant, associé à un hachage basé sur l'emplacement de la fonction dans la pile, identifie de manière unique la fonction lors du déploiement. Le AWS CDK fait également référence à cet ID lorsque vous mettez à jour la structure dans votre application et que vous la redéployez pour mettre à jour la ressource déployée. Ici, votre identifiant de construction estHelloWorldFunction. Les fonctions peuvent également avoir un nom, spécifié avec la functionName propriété. Ceci est différent de l'ID de construction.
props — Ensemble de valeurs qui définissent les propriétés de la fonction. Vous définissez ici les code propriétés runtimehandler, et.

Les accessoires sont représentés différemment dans les langues prises en charge par le AWS CDK.
- Dans TypeScript et JavaScript, props est un argument unique et vous transmettez un objet contenant les propriétés souhaitées.
- En Python, les accessoires sont transmis sous forme d'arguments de mots clés.
- En Java, un Builder est fourni pour transmettre les accessoires. Il y en a deux : une pourFunctionProps, et une seconde Function pour vous permettre de construire la construction et ses accessoires en une seule étape. Ce code utilise ce dernier.
- En C#, vous instanciez un FunctionProps objet à l'aide d'un initialiseur d'objet et vous le transmettez comme troisième paramètre.
  
  Si les accessoires d'une construction sont facultatifs, vous pouvez omettre complètement le props paramètre.

Toutes les constructions utilisent ces trois mêmes arguments, il est donc facile de rester orienté lorsque vous en découvrez de nouveaux. Et comme vous pouvez vous y attendre, vous pouvez sous-classer n'importe quelle construction pour l'étendre en fonction de vos besoins, ou si vous souhaitez modifier ses valeurs par défaut.

Étape 7 : Définissez l'URL de votre fonction Lambda

Dans cette étape, vous allez utiliser la méthode d'addFunctionUrlassistance de la Function construction pour définir une URL de fonction Lambda. Pour afficher la valeur de cette URL lors du déploiement, vous allez créer une AWS CloudFormation sortie à l'aide de la CfnOutputconstruction.

Ajoutez ce qui suit à votre fichier de pile CDK :

TypeScript

Situé dans lib/hello-cdk-stack.ts :


// ...

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

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

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new cdk.CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

JavaScript

Situé dans lib/hello-cdk-stack.js :


const { Stack, CfnOutput } = require('aws-cdk-lib');  // Import CfnOutput

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

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

    // Define the Lambda function URL resource
    const myFunctionUrl = myFunction.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });

    // Define a CloudFormation output for your URL
    new CfnOutput(this, "myFunctionUrlOutput", {
      value: myFunctionUrl.url,
    })

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


from aws_cdk import (
  # ...
  CfnOutput # Import CfnOutput
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define the Lambda function resource
    # ...

    # Define the Lambda function URL resource
    my_function_url = my_function.add_function_url(
      auth_type = _lambda.FunctionUrlAuthType.NONE,
    )

    # Define a CloudFormation output for your URL
    CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)

Java

Situé dans src/main/java/…/HelloCdkStack.java :


package com.myorg;

// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;

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

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

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

    // Define the Lambda function URL resource
    FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
      .authType(FunctionUrlAuthType.NONE)
      .build());

    // Define a CloudFormation output for your URL
    CfnOutput.Builder.create(this, "myFunctionUrlOutput")
      .value(myFunctionUrl.getUrl())
      .build();
  }
}

C#

Situé dans src/main/java/…/HelloCdkStack.java :


// ...

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define the Lambda function resource
      // ...

      // Define the Lambda function URL resource
      var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
      {
        AuthType = FunctionUrlAuthType.NONE
      });

      // Define a CloudFormation output for your URL
      new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
      {
        Value = myFunctionUrl.Url
      });
    }
  }
}

Go

Situé dans hello-cdk.go :


// ...

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

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

  // Define the Lambda function URL resource
  myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
    AuthType: awslambda.FunctionUrlAuthType_NONE,
  })

  // Define a CloudFormation output for your URL
  awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
    Value: myFunctionUrl.Url(),
  })

  return stack
}

// ...

Avertissement

Pour simplifier ce didacticiel, l'URL de votre fonction Lambda est définie sans authentification. Une fois déployé, cela crée un point de terminaison accessible au public qui peut être utilisé pour appeler votre fonction. Lorsque vous avez terminé ce didacticiel, suivez l'étape 12 : Supprimer votre application pour supprimer ces ressources.

Étape 8 : Synthétiser un modèle CloudFormation

Au cours de cette étape, vous préparez le déploiement en synthétisant un CloudFormation modèle à l'aide de la commande CDK cdk synth CLI. Cette commande effectue une validation de base de votre code CDK, exécute votre application CDK et génère un CloudFormation modèle à partir de votre pile CDK.

Si votre application contient plusieurs piles, vous devez spécifier les piles à synthétiser. Comme votre application contient une seule pile, la CLI CDK détecte automatiquement la pile à synthétiser.

Si vous ne synthétisez pas de modèle, la CLI CDK exécutera automatiquement cette étape lors du déploiement. Toutefois, nous vous recommandons d'exécuter cette étape avant chaque déploiement afin de vérifier les erreurs de synthèse.

Avant de synthétiser un modèle, vous pouvez éventuellement créer votre application pour détecter les erreurs de syntaxe et de type. Pour obtenir des instructions, consultez Étape 4 : Créez votre application CDK.

Pour synthétiser un CloudFormation modèle, exécutez ce qui suit depuis la racine de votre projet :


$ cdk synth

Note

Si le message d'erreur suivant s'affiche, vérifiez que vous êtes bien dans le hello-cdk répertoire et réessayez :

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

En cas de succès, la CLI CDK produira un YAML modèle formaté stdout et enregistrera un CloudFormation modèle JSON formaté dans le cdk.out répertoire de votre projet.

Voici un exemple de sortie du CloudFormation modèle :


Resources:
  HelloWorldFunctionServiceRole<unique-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
  HelloWorldFunction<unique-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:
          - HelloWorldFunctionServiceRole<unique-identifier>
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRole<unique-identifier>
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrl<unique-identifier>:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunction<unique-identifier>
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurl<unique-identifier>:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunction<unique-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:
        - HelloWorldFunctionFunctionUrl<unique-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.

Note

Chaque modèle généré contient une AWS::CDK::Metadata ressource par défaut. L'équipe du AWS CDK utilise ces métadonnées pour mieux comprendre l'utilisation du AWS CDK et trouver des moyens de l'améliorer. Pour plus de détails, notamment sur la manière de désactiver les rapports de version, consultez la section Rapports de version.

En définissant une seule construction L2, le AWS CDK crée un CloudFormation modèle complet contenant vos ressources Lambda, ainsi que les autorisations et la logique de collage requises pour que vos ressources interagissent au sein de votre application.

Étape 9 : Déployez votre pile de CDK

Dans cette étape, vous utilisez la cdk deploy commande CDK CLI pour déployer votre pile CDK. Cette commande récupère le CloudFormation modèle que vous avez généré et le déploie AWS CloudFormation, ce qui permet de provisionner vos ressources dans le cadre d'une CloudFormation pile.

À partir de la racine de votre projet, exécutez ce qui suit. Confirmez les modifications si vous y êtes invité :


$ 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

De mêmecdk synth, il n'est pas nécessaire de spécifier la pile AWS CDK puisque l'application contient une seule pile.

Pendant le déploiement, la CLI CDK affiche les informations de progression au fur et à mesure du déploiement de votre stack. Lorsque vous avez terminé, vous pouvez accéder à la AWS CloudFormation console pour voir votre HelloCdkStack pile. Vous pouvez également accéder à la console Lambda pour consulter votre HelloWorldFunction ressource.

Une fois le déploiement terminé, la CLI CDK affiche l'URL de votre point de terminaison. Copiez cette URL pour l'étape suivante. Voici un exemple :


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

Étape 10 : Interagissez avec votre application sur AWS

Au cours de cette étape, vous interagissez avec votre application AWS en appelant votre fonction Lambda via l'URL de la fonction. Lorsque vous accédez à l'URL, votre fonction Lambda renvoie le Hello World! message.

Pour appeler votre fonction, accédez à l'URL de la fonction via votre navigateur ou depuis la ligne de commande. Voici un exemple :


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

Étape 11 : Modifiez votre candidature

Au cours de cette étape, vous modifiez le message renvoyé par la fonction Lambda lorsqu'elle est invoquée. Vous effectuez une différence à l'aide de la cdk diff commande CDK CLI pour prévisualiser vos modifications et déployer pour mettre à jour votre application. Vous interagissez ensuite avec votre application AWS pour voir votre nouveau message.

Modifiez l'myFunctioninstance dans votre fichier de pile CDK comme suit :

TypeScript

Situé dans lib/hello-cdk-stack.ts :


// ...

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

    // Modify the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
      `),
    });

    // ...
  }
}

JavaScript

Situé dans lib/hello-cdk-stack.js :


// ...

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

    // Modify the Lambda function resource
    const myFunction = new lambda.Function(this, "HelloWorldFunction", {
      runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
      handler: "index.handler",
      code: lambda.Code.fromInline(`
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
      `),
    });

    // ...

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


# ...

class HelloCdkStack(Stack):

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

    # Modify the Lambda function resource
    my_function = _lambda.Function(
      self, "HelloWorldFunction",
      runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
      handler = "index.handler",
      code = _lambda.Code.from_inline(
        """
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello CDK!'),
          };
        };
        """
      ),
    )

    # ...

Java

Situé dans src/main/java/…/HelloCdkStack.java :


// ...

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

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

    // Modify the Lambda function resource
    Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
      .runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
      .handler("index.handler")
      .code(Code.fromInline(
        "exports.handler = async function(event) {" +
        " return {" +
        " statusCode: 200," +
        " body: JSON.stringify('Hello CDK!')" +
        " };" +
        "};"))
      .build();

    // ...
  }
}

C#


// ...

namespace HelloCdk
{
  public class HelloCdkStack : Stack
  {
    internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Modify the Lambda function resource
      var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
      {
        Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
        Handler = "index.handler",
        Code = Code.FromInline(@"
          exports.handler = async function(event) {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello CDK!'),
            };
          };
        "),
      });

      // ...
    }
  }
}

Go


// ...

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  // Modify the Lambda function resource
  myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
    Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
    Handler: jsii.String("index.handler"),
    Code: awslambda.Code_FromInline(jsii.String(`
      exports.handler = async function(event) {
        return {
          statusCode: 200,
          body: JSON.stringify('Hello CDK!'),
        };
      };
    `)),
  })

// ...

}

À l'heure actuelle, vos modifications de code n'ont entraîné aucune mise à jour directe de votre ressource Lambda déployée. Votre code définit l'état souhaité pour votre ressource. Pour modifier votre ressource déployée, vous allez utiliser la CLI CDK pour synthétiser l'état souhaité dans un nouveau AWS CloudFormation modèle. Vous déploierez ensuite votre nouveau CloudFormation modèle sous forme d'ensemble de modifications. Les ensembles de modifications apportent uniquement les modifications nécessaires pour atteindre le nouvel état souhaité.

Pour prévisualiser vos modifications, exécutez la cdk diff commande. Voici un exemple :


$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunction<unique-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

Pour créer cette différence, la CLI CDK interroge votre AWS compte de compte pour obtenir le dernier AWS CloudFormation modèle de la HelloCdkStack pile. Ensuite, il compare le dernier modèle avec le modèle qu'il vient de synthétiser à partir de votre application.

Pour implémenter vos modifications, exécutez la cdk deploy commande. Voici un exemple :


$ 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

Pour interagir avec votre application, répétez l'étape 10 : Interagissez avec votre application activée AWS. Voici un exemple :


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

Étape 12 : Supprimer votre application

Au cours de cette étape, vous devez utiliser la cdk destroy commande CDK CLI pour supprimer votre application. Cette commande supprime la CloudFormation pile associée à votre pile CDK, qui inclut les ressources que vous avez créées.

Pour supprimer votre application, exécutez la cdk destroy commande et confirmez votre demande de suppression de l'application. Voici un exemple :


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

 ✅  HelloCdkStack: destroyed

Étapes suivantes

Félicitations ! Vous avez terminé ce didacticiel et vous avez utilisé le AWS CDK pour créer, modifier et supprimer avec succès des ressources dans le AWS cloud. Vous êtes maintenant prêt à commencer à utiliser le AWS CDK.

Pour en savoir plus sur l'utilisation du AWS CDK dans votre langage de programmation préféré, consultez la section Utilisation de la bibliothèque AWS CDK.

Pour des ressources supplémentaires, consultez les rubriques suivantes :

Essayez le CDK Workshop pour une visite plus approfondie impliquant un projet plus complexe.
Consultez la référence de l'API pour commencer à explorer les constructions CDK disponibles pour vos services préférés AWS .
Visitez Construct Hub pour découvrir les constructions créées par AWS et d'autres.
Découvrez des exemples d'utilisation du AWS CDK.

Le AWS CDK est un projet open source. Pour contribuer, consultez Contributing to the AWS Cloud Development Kit (AWS CDK).

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

Premiers pas

Travaillez avec la bibliothèque CDK

Tutoriel : Créez votre première AWS application CDK

Prérequis

À propos de ce didacticiel

Étape 1 : Créez votre projet CDK

Important

Étape 2 : Configuration de votre AWS environnement

Étape 3 : Bootstrap votre environnement AWS

Étape 4 : Créez votre application CDK

Étape 5 : Répertoriez les piles de CDK dans votre application

Étape 6 : Définissez votre fonction Lambda

Étape 7 : Définissez l'URL de votre fonction Lambda

Avertissement

Étape 8 : Synthétiser un modèle CloudFormation

Note

Note

Étape 9 : Déployez votre pile de CDK

Étape 10 : Interagissez avec votre application sur AWS

Étape 11 : Modifiez votre candidature

Étape 12 : Supprimer votre application

Étapes suivantes