Conditions préalables À propos de ce didacticiel Étape 1 : Créez votre projet CDK Étape 2 : Configurez votre AWS environment Étape 3 : Bootstrap votre AWS environment É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 CDK Étape 10 : Interagissez avec votre application sur AWS Étape 11 : Modifier votre candidature Étape 12 : Supprimez votre candidature Étapes suivantes

Tutoriel : Créez votre premier AWS Appli 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 votre AWS environnement et déployer votre application sur. AWS

Conditions préalables

Avant de commencer ce didacticiel, suivez toutes les étapes de configuration décrites dans la section Premiers pas avec le AWS CDK.

À propos de ce didacticiel

Dans ce didacticiel, vous allez créer et déployer une application simple sur AWS l'utilisation du AWS CDK. L'application se compose d'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é pour 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 CLIcdk init.
Configurez 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 l'interface de ligne de commande 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 modules locaux.

Pour créer un projet CDK

À partir du répertoire de départ de votre choix, créez et naviguez jusqu'à 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 nom de répertoire différent, 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 CLI. cdk init Spécifiez le app modèle et votre langage de programmation préféré avec l'--languageoption :
Exemple
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. DansEclipse, par exemple, 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 afin de faciliter l'organisation du 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 de cdk init celui-ci 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 App construction. Voici une partie de ce code provenant de votre fichier d'application CDK :

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', {
});

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 Stack construction. Voici une partie de ce code provenant de votre fichier de pile CDK :

Exemple

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 : Configurez votre AWS environment

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.

Tout d'abord, déterminez 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 la AWS CLI pour obtenir des informations d' AWS environnement pour un profil spécifique.

Pour utiliser l' AWS interface de ligne de commande afin d'obtenir votre identifiant de AWS compte

Exécutez la commande AWS CLI suivante pour obtenir l'identifiant de AWS compte associé à 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 :
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```

Pour utiliser la AWS CLI afin d'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 :
```
$ 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. Pour ce didacticiel, vous allez coder en dur les informations relatives à votre AWS environnement. Cela n'est pas recommandé pour les environnements de production. Pour plus d'informations sur les autres méthodes de configuration des environnements, voir Configuration des 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 :

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 AWS environment

Au cours de cette étape, vous initialisez 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 la commande suivante 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 de votre projet. Lorsque vous démarrez en dehors d'un projet CDK, vous devez fournir des informations sur l'environnement avec la cdk bootstrap commande. Pour plus d'informations, consultez Bootstrap votre environnement à 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 l'interface de ligne de commande du CDK effectuera automatiquement cette étape. Cependant, vous pouvez toujours générer manuellement si vous souhaitez détecter les erreurs de syntaxe et de saisie. Voici un exemple :

Exemple

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

À ce stade, vous devriez disposer d'une application CDK contenant une seule pile 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 vous ne voyez pas ce résultat, 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_lambda module depuis la AWS bibliothèque de constructions et vous utilisez la construction Function L2.

Modifiez votre fichier de pile CDK comme suit :

Exemple

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, la portée est this (selfen Python).
Id — L'identifiant de construction de Function votre application AWS CDK. Cet identifiant, associé à un hachage basé sur l'emplacement de la fonction dans la pile, permet d'identifier la fonction de manière unique lors du déploiement. Le AWS CDK fait également référence à cet ID lorsque vous mettez à jour la construction dans votre application et que vous 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 se trouve un argument unique et vous transmettez un objet contenant les propriétés souhaitées.
- En Python, les accessoires sont transmis en tant qu'arguments de mots clés.
- En Java, un Builder est fourni pour transmettre les accessoires. Il y en a deux : l'un pour FunctionProps et l'autre Function pour vous permettre de construire la construction et ses accessoires en une seule étape. Ce code utilise cette dernière option.
- 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 vous en doutez, vous pouvez sous-classer n'importe quelle construction pour l'étendre à 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 utilisez la méthode d'addFunctionUrlassistance de la Function construction pour définir l'URL d'une fonction Lambda. Pour générer la valeur de cette URL lors du déploiement, vous allez créer une AWS CloudFormation sortie à l'aide de la CfnOutput construction.

Ajoutez ce qui suit à votre fichier de pile CDK :

Exemple

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 invoquer votre fonction. Lorsque vous aurez terminé ce didacticiel, suivez l'étape 12 : Supprimez 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 CLIcdk synth. 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. Étant donné que 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, l'interface de ligne de commande CDK effectuera automatiquement cette étape lors du déploiement. Nous vous recommandons toutefois d'exécuter cette étape avant chaque déploiement pour vérifier l'absence d'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 saisie. Pour obtenir des instructions, consultez Étape 4 : Création de votre application CDK.

Pour synthétiser un CloudFormation modèle, exécutez la commande suivante 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 affichera un modèle au YAML format —formaté stdout et enregistrera un CloudFormation modèle au 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 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 pour savoir comment désactiver les rapports de version, consultez la section Rapports de version.

En définissant une construction L2 unique, 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 CDK

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

À partir de la racine de votre projet, exécutez les opérations suivantes. 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, vous n'êtes pas obligé de spécifier la pile AWS CDK puisque l'application ne contient qu'une seule pile.

Pendant le déploiement, la CLI CDK affiche les informations de progression au fur et à mesure du déploiement de votre pile. 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 afficher votre HelloWorldFunction ressource.

Une fois le déploiement terminé, la CLI CDK affichera l'URL de votre point de terminaison. Copiez cette URL pour passer à 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 invoquant votre fonction Lambda via l'URL de la fonction. Lorsque vous accédez à l'URL, votre fonction Lambda renvoie le Hello World! message.

Pour invoquer 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 : Modifier votre candidature

Au cours de cette étape, vous modifiez le message que la fonction Lambda renvoie 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 :

Exemple

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é de 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 en tant qu'ensemble de modifications. Les ensembles de modifications n'apportent que 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 --method=template 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, l'interface de ligne de commande CDK interroge le compte de votre AWS 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 sur AWS. Voici un exemple :


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

Étape 12 : Supprimez votre candidature

Dans cette étape, vous utilisez 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 avez utilisé le AWS CDK pour créer, modifier et supprimer des ressources dans le AWS Cloud avec succès. 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é, voir Utilisation de la bibliothèque AWS CDK.

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

Essayez l'atelier CDK 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 des 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 la section Contribution au kit de développement AWS cloud (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

Prise en main

Travaillez avec la bibliothèque CDK

Tutoriel : Créez votre premier AWS Appli CDK

Conditions préalables

À propos de ce didacticiel

Étape 1 : Créez votre projet CDK

Important

Exemple

Exemple

Exemple

Étape 2 : Configurez votre AWS environment

Exemple

Étape 3 : Bootstrap votre AWS environment

Étape 4 : Créez votre application CDK

Exemple

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

Étape 6 : Définissez votre fonction Lambda

Exemple

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

Exemple

Avertissement

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

Note

Note

Étape 9 : Déployez votre pile CDK

Étape 10 : Interagissez avec votre application sur AWS

Étape 11 : Modifier votre candidature

Exemple

Étape 12 : Supprimez votre candidature

Étapes suivantes