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

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

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

Prérequis

Avant de commencer ce didacticiel, effectuez toutes les étapes de configuration dansCommencer à utiliser le AWS CDK.

À propos de ce didacticiel

Dans ce didacticiel, vous allez créer et déployer une application simple AWS utilisant le AWS CDK. L'application consiste en une AWS Lambda fonction qui renvoie un Hello World! message lorsqu'elle est invoquée. La fonction sera invoquée via une fonction Lambda URL 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 CDK projet à l'aide du CDK CLI cdk initcommande.
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 du CDK CLI cdk bootstrapcommande.
Développez votre application : utilisez les constructions de la bibliothèque AWS Construct pour définir votre fonction Lambda et les ressources de la fonction Lambda. URL
Préparez votre application pour le déploiement : utilisez le CDK CLI pour créer votre application et synthétiser un AWS CloudFormation modèle.
Déployez votre application : utilisez le CDK CLI cdk deploycommande 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 du CDK CLI cdk destroycommande.

Étape 1 : Créez votre CDK projet

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

Pour créer un CDK projet

À partir du répertoire de départ de votre choix, créez et naviguez vers un répertoire nommé hello-cdk :
```
$ mkdir hello-cdk && cd hello-cdk
```
Important
Assurez-vous de nommer le répertoire de votre projethello-cdk, exactement comme indiqué ici. Le CDK CLI utilise ce nom de répertoire pour nommer les éléments de votre CDK code. Si vous utilisez un autre nom de répertoire, vous rencontrerez des problèmes au cours de ce didacticiel.
Dans le hello-cdk répertoire, initialisez un nouveau CDK projet à l'aide du CDK CLI cdk initcommande. Spécifiez le app modèle et votre langage de programmation préféré à l'aide de l'--languageoption suivante :
TypeScript
```
$ cdk init app --language typescript
```
JavaScript
```
$ cdk init app --language javascript
```
Python
```
$ cdk init app --language python
```
Une fois l'application créée, entrez également les deux commandes suivantes. Ils activent les Python environnement virtuel et installe les dépendances de AWS CDK base.
```
$ 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 unIDE, vous pouvez désormais ouvrir ou importer le projet. Entrée Eclipse, 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 pour aider à organiser le code source de votre CDK application. Cette structure de fichiers et de dossiers s'appelle votre CDK projet. Prenez le temps d'explorer votre CDK projet.

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

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

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 CDK pile est créée à l'aide de la Stack construction. Voici une partie de ce code provenant de votre fichier de CDK pile :

TypeScript

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


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

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

  }
}

JavaScript

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


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

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

    // Define your constructs here

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


from aws_cdk import (
  Stack,
)
from constructs import Construct

class HelloCdkStack(Stack):

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

    # Define your constructs here

Java

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


package com.myorg;

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

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

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

    // Define your constructs here
  }
}

C#

Situé dans src/HelloCdk/HelloCdkStack.cs :


using Amazon.CDK;
using Constructs;

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

Go

Situé dans hello-cdk.go :


package main

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

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

  return stack
}

// ...

Étape 2 : Configuration de votre AWS environnement

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

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

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

Pour utiliser le AWS CLI pour obtenir votre Compte AWS identifiant

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

Pour utiliser le AWS CLI pour obtenir votre Région AWS

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

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

Pour configurer l'environnement de votre CDK stack

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

TypeScript

Situé dans bin/hello-cdk.ts :


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

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

JavaScript

Situé dans bin/hello-cdk.js :


#!/usr/bin/env node

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

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

Python

Situé dans app.py :


#!/usr/bin/env python3
import os

import aws_cdk as cdk

from hello_cdk.hello_cdk_stack import HelloCdkStack


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

Java

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


package com.myorg;

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

import java.util.Arrays;

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

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

                .build());

        app.synth();
    }
}

C#

Situé dans src/HelloCdk/Program.cs :


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

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

Go

Situé dans hello-cdk.go :


package main

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

// ...

func main() {
  defer jsii.Close()

  app := awscdk.NewApp(nil)

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

  app.Synth(nil)
}

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

Étape 3 : Bootstrap votre environnement AWS

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

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


$ cdk bootstrap

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

Étape 4 : Créez votre CDK application

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 AWS CDK étant donné que CDK CLI exécutera automatiquement cette étape. Cependant, vous pouvez toujours créer manuellement lorsque vous souhaitez détecter des erreurs de syntaxe et de type. Voici un exemple :

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

À ce stade, vous devriez avoir une CDK application contenant une seule CDK pile. Pour vérifier, utilisez CDK CLI cdk listcommande 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'opération Étape 1 : Créez votre CDK projet 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 CDK pile comme suit :

TypeScript

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


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

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

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

JavaScript

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


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

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

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

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


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

class HelloCdkStack(Stack):

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

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

Java

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


package com.myorg;

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

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

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

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

  }
}

C#

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


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

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

Go

Situé dans hello-cdk.go :


package main

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

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

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

  return stack
}

// ...

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

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

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

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

Étape 7 : Définissez votre fonction Lambda URL

Dans cette étape, vous allez utiliser la méthode addFunctionUrl auxiliaire de la Function construction pour définir une fonction URL Lambda. Pour en afficher la valeur 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 CDK pile :

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, votre fonction Lambda URL 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 aurez terminé ce didacticiel, suivez Étape 12 : Supprimer votre application pour supprimer ces ressources.

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

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

Si votre application contient plusieurs piles, vous devez spécifier les piles à synthétiser. Étant donné que votre application ne contient qu'une seule pile, le CDK CLI détecte automatiquement la pile à synthétiser.

Si vous ne synthétisez pas de modèle, CDK CLI 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 CDK application.

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, le CDK CLI produira un YAML: CloudFormation modèle formaté vers stdout et enregistrement d'un JSON: modèle formaté dans le cdk.out répertoire de votre projet.

Voici un exemple de sortie du CloudFormation modèle :


Resources:
  HelloWorldFunctionServiceRoleunique-identifier:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: sts:AssumeRole
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: "2012-10-17"
      ManagedPolicyArns:
        - Fn::Join:
            - ""
            - - "arn:"
              - Ref: AWS::Partition
              - :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
  HelloWorldFunctionunique-identifier:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        ZipFile: "

          \        exports.handler = async function(event) {

          \          return {

          \            statusCode: 200,

          \            body: JSON.stringify('Hello World!'),

          \          };

          \        };

          \      "
      Handler: index.handler
      Role:
        Fn::GetAtt:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrlunique-identifier:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurlunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      FunctionUrlAuthType: NONE
      Principal: "*"
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  myFunctionUrlOutput:
    Value:
      Fn::GetAtt:
        - HelloWorldFunctionFunctionUrlunique-identifier
        - FunctionUrl
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/unique-identifier/version
    Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
  CheckBootstrapVersion:
    Assertions:
      - Assert:
          Fn::Not:
            - Fn::Contains:
                - - "1"
                  - "2"
                  - "3"
                  - "4"
                  - "5"
                - Ref: BootstrapVersion
        AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.

Note

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

En définissant une seule construction L2, vous AWS CDK créez 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 CDK stack

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

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


$ cdk deploy

✨  Synthesis time: 2.69s

HelloCdkStack:  start: Building unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier:current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:

IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│   │ Resource                              │ Effect │ Action                   │ Principal                    │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn}             │ Allow  │ lambda:InvokeFunctionUrl │ *                            │           │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow  │ sts:AssumeRole           │ Service:lambda.amazonaws.com │           │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│   │ Resource                          │ Managed Policy ARN                                                             │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)

Do you wish to deploy these changes (y/n)? y

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

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

Une fois le déploiement terminé, CDK CLI affichera votre point de terminaisonURL. Copiez-le URL pour l'étape suivante. Voici un exemple :


...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 41.65s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://<api-id>.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 44.34s

Étape 10 : Interagissez avec votre application sur AWS

Au cours de cette étape, vous interagissez avec votre application AWS en invoquant votre fonction Lambda par le biais de cette fonction. URL Lorsque vous accédez auURL, votre fonction Lambda renvoie le Hello World! message.

Pour appeler votre fonction, accédez-y par le URL biais de votre navigateur ou de la ligne de commande. Voici un exemple :


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

Étape 11 : Modifiez votre candidature

Au cours de cette étape, vous modifiez le message renvoyé par la fonction Lambda lorsqu'elle est invoquée. Vous effectuez une différence à l'aide du CDK CLI cdk diffcommande 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 CDK pile comme suit :

TypeScript

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


// ...

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

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

    // ...

JavaScript

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


// ...

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

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

    // ...

  }
}

module.exports = { HelloCdkStack }

Python

Situé dans hello_cdk/hello_cdk_stack.py :


# ...

class HelloCdkStack(Stack):

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

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

    # ...

Java

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


// ...

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

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

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

    // ...
  }
}

C#


// ...

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

      // ...
    }
  }
}

Go


// ...

type HelloCdkStackProps struct {
  awscdk.StackProps
}

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

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

// ...

À l'heure actuelle, vos modifications de code n'ont entraîné aucune mise à jour directe de votre ressource Lambda déployée. Votre code définit l'état souhaité pour votre ressource. Pour modifier votre ressource déployée, vous allez utiliser CDK CLI 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 HelloWorldFunctionunique-identifier
 └─ [~] Code
     └─ [~] .ZipFile:
         ├─ [-] 
                exports.handler = async function(event) {
                    return {
                      statusCode: 200,
                      body: JSON.stringify('Hello World!'),
                    };
                };
                
         └─ [+] 
                exports.handler = async function(event) {
                    return {
                      statusCode: 200,
                      body: JSON.stringify('Hello CDK!'),
                    };
                };
                

✨  Number of stacks with differences: 1

Pour créer cette différence, CDK CLI interroge votre Compte 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'opérationÉtape 10 : Interagissez avec votre application sur AWS. Voici un exemple :


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

Étape 12 : Supprimer votre application

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

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


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

 ✅  HelloCdkStack: destroyed

Étapes suivantes

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

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

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

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

AWS CDK Il s'agit d'un projet open source. Pour contribuer, voir Contribuer au AWS Cloud Development Kit (AWS CDK).

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

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

Conventions de rédaction

Premiers pas

Collaborez avec la CDK bibliothèque

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

Prérequis

À propos de ce didacticiel

Étape 1 : Créez votre CDK projet

Pour créer un CDK projet

Important

Étape 2 : Configuration de votre AWS environnement

Pour utiliser le AWS CLI pour obtenir votre Compte AWS identifiant

Pour utiliser le AWS CLI pour obtenir votre Région AWS

Pour configurer l'environnement de votre CDK stack

Étape 3 : Bootstrap votre environnement AWS

Étape 4 : Créez votre CDK application

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

Étape 6 : Définissez votre fonction Lambda

Étape 7 : Définissez votre fonction Lambda URL

Avertissement

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

Note

Note

Étape 9 : Déployez votre CDK stack

Étape 10 : Interagissez avec votre application sur AWS

Étape 11 : Modifiez votre candidature

Étape 12 : Supprimer votre application

Étapes suivantes