Ceci est le guide du développeur du AWS CDK v2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commencer à utiliser le AWS CDK
Commencez à utiliser le AWS Cloud Development Kit (AWS CDK) en installant et en configurant l'interface de ligne de commande AWS CDK (AWS CDK CLI). Utilisez ensuite la CLI CDK pour créer votre première application CDK, démarrer votre AWS environnement et déployer votre application.
## Conditions préalables
Avant de commencer à utiliser le AWS CDK, remplissez tous les prérequis. Ces prérequis sont obligatoires pour ceux qui débutent AWS ou débutent dans le domaine de la programmation. Pour obtenir des instructions, consultez la section [Conditions préalables au AWS CDK](prerequisites.md).
Nous vous recommandons d'avoir une compréhension de base de ce qu'est le AWS CDK. Pour plus d'informations, consultez [Qu'est-ce que le AWS CDK ?](home.md) et [apprenez les concepts de base du AWS CDK](core-concepts.md).
## Installation de la AWS CLI CDK
Utilisez le gestionnaire de Node packages pour installer la CLI CDK. Nous vous recommandons de l'installer globalement à l'aide de la commande suivante :
```
$ npm install -g aws-cdk
```
Pour installer une version spécifique de la CLI CDK, utilisez la structure de commande suivante :
```
$ npm install -g aws-cdk@X.YY.Z
```
Si vous souhaitez utiliser plusieurs versions du AWS CDK, pensez à installer une version correspondante de la CLI CDK dans des projets CDK individuels. Pour ce faire, supprimez l'`-g`option de la `npm install` commande. Utilisez-le ensuite `npx aws-cdk` pour invoquer la CLI CDK. Cela exécutera une version locale si elle existe. Dans le cas contraire, c'est la version installée globalement qui sera utilisée.
**Résoudre les problèmes liés à l'installation d'une CLI CDK**
Si une erreur d'autorisation s'affiche et que vous disposez d'un accès administrateur sur votre système, exécutez la commande suivante :
```
$ sudo npm install -g aws-cdk
```
Si vous recevez un message d'erreur, essayez de désinstaller la CLI CDK en exécutant ce qui suit :
```
$ npm uninstall -g aws-cdk
```
Répétez ensuite les étapes pour réinstaller la CLI CDK.
## Vérifier la réussite de l'installation de la CLI CDK
Exécutez la commande suivante pour vérifier la réussite de l'installation. La CLI du AWS CDK doit afficher le numéro de version :
```
$ cdk --version
```
## Configuration de la AWS CLI CDK
Après avoir installé la CLI CDK, vous pouvez commencer à l'utiliser pour développer des applications sur votre machine locale. Pour interagir avec AWS, par exemple, déployer des applications, vous devez disposer d'informations d'identification de sécurité configurées sur votre machine locale avec les autorisations nécessaires pour effectuer toutes les actions que vous initiez.
Pour configurer les informations d'identification de sécurité sur votre machine locale, vous utilisez la AWS CLI. La façon dont vous configurez les informations d'identification de sécurité dépend de la façon dont vous gérez les utilisateurs. Pour obtenir des instructions, reportez-vous à la section [Authentification et identifiants d'accès](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) dans le *Guide de l'utilisateur de l'interface de ligne de AWS commande*.
La CLI CDK utilisera automatiquement les informations d'identification de sécurité que vous configurez avec la AWS CLI. Par exemple, si vous êtes un utilisateur d'IAM Identity Center, vous pouvez utiliser la `aws configure sso` commande pour configurer les informations d'identification de sécurité. Si vous êtes un utilisateur IAM, vous pouvez utiliser la `aws configure` commande. La AWS CLI vous guidera dans la configuration des informations de sécurité sur votre machine locale et enregistrera les informations nécessaires dans vos `credentials` fichiers `config` and. Ensuite, lorsque vous utilisez la CLI CDK, par exemple en déployant une application avec`cdk deploy`, la CLI CDK utilise les informations d'identification de sécurité que vous avez configurées.
Tout comme la AWS CLI, la CLI CDK utilisera votre `default` profil par défaut. Vous pouvez spécifier un profil à l'aide de l'[`--profile`](ref-cli-cmd.md#ref-cli-cmd-options-profile)option CDK CLI. Pour plus d'informations sur l'utilisation des informations d'identification de sécurité avec la CLI CDK, voir [Configurer les informations d'identification de sécurité pour la AWS CLI CDK](configure-access.md).
## (Facultatif) Installez des outils AWS CDK supplémentaires
Le [AWS Toolkit for Visual Studio Code](https://aws.amazon.com/visualstudiocode/) est un plug-in open source Visual Studio Code qui vous permet de créer, de déboguer et de déployer des applications sur AWS. La boîte à outils fournit une expérience intégrée pour le développement d'applications AWS CDK. Il inclut la fonctionnalité AWS CDK Explorer pour répertorier vos projets AWS CDK et parcourir les différents composants de l'application CDK. Pour obtenir des instructions, veuillez consulter les sections suivantes :
+ [Installation du AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html).
+ [AWS CDK pour VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html).
## Créez votre première application CDK
Vous êtes maintenant prêt à commencer à utiliser le AWS CDK en créant votre première application CDK. Pour obtenir des instructions, consultez [Tutoriel : Créez votre première application AWS CDK](hello-world.md).
# 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
## Conditions préalables
Avant de commencer ce didacticiel, suivez toutes les étapes de configuration dans [Getting started with the AWS CDK](getting-started.md).
## À 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](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) qui renvoie un `Hello World!` message lorsqu'elle est invoquée. La fonction sera invoquée via une [URL de fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) 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**
1. À 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 projet`hello-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.
1. 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é à l'aide de l'`--language`option suivante :
**Example**
------
#### [ 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\$1 ]
```
$ 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 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html)construction. Voici une partie de ce code provenant de votre fichier d'application CDK :
**Example**
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', {
});
```
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', {
});
```
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()
```
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();
}
}
```
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();
}
}
}
```
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 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html)construction. Voici une partie de ce code provenant de votre fichier de pile CDK :
**Example**
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
}
}
```
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 }
```
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
```
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
}
}
```
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
}
}
}
```
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**
1. 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
```
1. Si vous préférez utiliser un profil nommé, indiquez le nom de votre profil à l'aide de l'`--profile`option 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**
1. 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
```
1. Si vous préférez utiliser un profil nommé, indiquez le nom de votre profil à l'aide de l'`--profile`option suivante :
```
$ aws configure get region --profile your-profile-name
```
Vous allez ensuite configurer l' AWS environnement de votre pile CDK en modifiant l'`HelloCdkStack`instance dans votre *fichier d'application*. Dans le cadre de 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 [Configurer les environnements à utiliser avec le AWS CDK](configure-env.md).
**Pour configurer l'environnement de votre pile CDK**
1. Dans votre *fichier d'application*, utilisez la `env` propriété de la `Stack` construction pour configurer votre environnement. Voici un exemple :
**Example**
------
#### [ 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\$1 ]
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](bootstrapping-env.md).
## É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 :
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
Aucune étape de construction n'est nécessaire.
Aucune étape de construction n'est nécessaire.
```
$ mvn compile -q
```
Ou appuyez sur `Control-B` Eclipse (les autres versions de Java IDEs peuvent varier)
```
$ dotnet build src
```
Ou appuyez sur F6 dans Visual Studio
```
$ go build
```
## É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](#hello-world-create) et réessayez.
## Étape 6 : Définissez votre fonction Lambda
Au cours de cette étape, vous importez le [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)module depuis la AWS bibliothèque de constructions et vous utilisez la construction [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)L2.
Modifiez votre fichier de pile CDK comme suit :
**Example**
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!'),
};
};
`),
});
}
}
```
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 }
```
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!'),
};
};
"""
),
)
```
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();
}
}
```
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!'),
};
};
"),
});
}
}
}
```
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` (`self`en 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 est`HelloWorldFunction`. 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 `runtime``handler`, 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 pour`FunctionProps`, 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\$1, 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'`addFunctionUrl`assistance 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 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)construction.
Ajoutez ce qui suit à votre fichier de pile CDK :
**Example**
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,
})
}
}
```
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 }
```
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)
```
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();
}
}
```
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
});
}
}
}
```
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](#hello-world-delete) 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](#hello-world-build).
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 :
### AWS CloudFormation modèle
```
Resources:
HelloWorldFunctionServiceRole:
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:
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
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//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](cli.md#version-reporting).
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
Au cours de 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 :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :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ême`cdk 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](https://console.aws.amazon.com/cloudformation/home) 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://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ 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://.lambda-url..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'`myFunction`instance dans votre fichier de pile CDK comme suit :
**Example**
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!'),
};
};
`),
});
// ...
}
}
```
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 }
```
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!'),
};
};
"""
),
)
# ...
```
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();
// ...
}
}
```
```
// ...
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!'),
};
};
"),
});
// ...
}
}
}
```
```
// ...
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
└─ [~] 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 :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 26.96s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 29.07s
```
Pour interagir avec votre application, répétez [l'étape 10 : Interagissez avec votre application activée AWS](#hello-world-interact). Voici un exemple :
```
$ curl https://.lambda-url..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 \$1 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](work-with.md).
Pour des ressources supplémentaires, consultez les rubriques suivantes :
+ Essayez le [CDK Workshop](https://cdkworkshop.com/) pour une visite plus approfondie impliquant un projet plus complexe.
+ Consultez la [référence de l'API](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) pour commencer à explorer les constructions CDK disponibles pour vos services préférés AWS .
+ Visitez [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) pour découvrir les constructions créées par AWS et d'autres.
+ Découvrez [des exemples](https://github.com/aws-samples/aws-cdk-examples) 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).](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md)