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. # Utilisation de Lambda avec infrastructure en tant que code (IaC) Les fonctions Lambda s’exécutent rarement de manière isolée. Elles font souvent partie d’une application sans serveur avec d’autres ressources telles que les bases de données, les files d’attente et le stockage. Avec l’[infrastructure en tant que code (IaC)](https://aws.amazon.com/what-is/iac/), vous pouvez automatiser vos processus de déploiement pour déployer et mettre à jour rapidement et de manière répétée des applications sans serveur complètes impliquant de nombreuses ressources AWS distinctes. Cette approche accélère votre cycle de développement, facilite la gestion des configurations et garantit que vos ressources sont déployées de la même manière à chaque fois. ## Outils de l’IaC pour Lambda **CloudFormation** CloudFormation est le service IaC de base d’AWS. Vous pouvez utiliser des [modèles YAML ou JSON](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) pour modéliser et allouer l’ensemble de votre infrastructure AWS, y compris les fonctions Lambda. CloudFormation gère les complexités liées à la création, à la mise à jour et à la suppression de vos ressources AWS. **AWS Serverless Application Model (AWS SAM)** AWS SAM est une infrastructure open source qui repose sur CloudFormation. Il fournit une syntaxe simplifiée pour définir les applications sans serveur. Utilisez des [modèles AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html) pour configurer rapidement des fonctions Lambda, des API, des bases de données et des sources d’événements avec seulement quelques lignes de code YAML. **AWS Cloud Development Kit (AWS CDK)** Le CDK est une approche d’IaC axée sur le code. Vous pouvez définir votre architecture basée sur Lambda à l’aide de Typescript, JavaScript, Python, Java, C\$1/.Net ou Go. Choisissez votre langage préféré et utilisez des éléments de programmation tels que les paramètres, les conditions, les boucles, la composition et l’héritage pour définir le résultat souhaité pour votre infrastructure. Le CDK génère ensuite les modèles CloudFormation sous-jacents pour le déploiement. Pour obtenir un exemple d’utilisation de Lambda avec CDK, consultez [Déploiement de fonctions Lambda avec AWS CDK](lambda-cdk-tutorial.md). ![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/IaC_tools.png) AWS fournit également un service appelé AWS Infrastructure Composer pour développer des modèles IaC à l’aide d’une interface graphique simple. Avec Infrastructure Composer, vous concevez une architecture d’application en faisant glisser, en regroupant et en connectant les Services AWS dans un canevas visuel. Infrastructure Composer crée ensuite un modèle AWS SAM ou un modèle CloudFormation à partir de votre conception que vous pouvez utiliser pour déployer votre application. Dans la section [Utilisation des fonctions Lambda dans AWS SAM et Infrastructure Composer](foundation-iac-getting-started.md) ci-dessous, Infrastructure Composer vous permet de développer un modèle pour une application sans serveur basée sur une fonction Lambda existante. # Utilisation des fonctions Lambda dans AWS SAM et Infrastructure Composer Dans ce tutoriel, vous pouvez commencer à utiliser l’IaC avec Lambda en créant un modèle AWS SAM à partir d’une fonction Lambda existante, puis en développant une application sans serveur dans Infrastructure Composer en ajoutant d’autres ressources AWS. Au cours de ce didacticiel, vous apprendrez certains concepts fondamentaux, tels que la manière dont les ressources AWS sont spécifiées dans AWS SAM. Vous découvrirez également comment utiliser Infrastructure Composer pour créer une application sans serveur que vous pouvez déployer à l’aide d’AWS SAM ou d’CloudFormation. Pour compléter ce didacticiel, effectuez les tâches suivantes : + Créer un exemple de fonction Lambda + Utiliser la console Lambda pour afficher le modèle AWS SAM de la fonction + Exportez la configuration de votre fonction vers une application sans serveur simple AWS Infrastructure Composer et concevez une application sans serveur basée sur la configuration de votre fonction + Enregistrez un modèle AWS SAM mis à jour que vous pouvez utiliser comme base pour déployer votre application sans serveur ## Prérequis Dans ce tutoriel, vous allez utiliser la fonctionnalité de [synchronisation locale](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html) d’Infrastructure Composer pour enregistrer votre modèle et vos fichiers de code sur votre machine de génération locale. Pour utiliser cette fonctionnalité, vous devez disposer d’un navigateur compatible avec l’API d’accès au système de fichiers, qui permet aux applications Web de lire, d’écrire et d’enregistrer des fichiers dans votre système de fichiers local. Nous vous recommandons d’utiliser Google Chrome ou Microsoft Edge. Pour plus d’informations sur l’API d’accès au système de fichiers, voir [Qu’est-ce que l’API d’accès au système de fichiers ?](https://docs.aws.amazon.com/application-composer/latest/dg/reference-fsa.html#reference-fsa-api) ## Création d’une fonction Lambda Dans cette première étape, vous allez créer une fonction Lambda que vous pouvez utiliser pour terminer le reste du didacticiel. Pour simplifier les choses, vous utilisez la console Lambda pour créer une fonction de base « Hello world » à l’aide du moteur d’exécution Python 3.11. **Pour créer une fonction Lambda « Hello world » à l’aide de la console** 1. Ouvrez la [console Lambda](https://console.aws.amazon.com/lambda). 1. Choisissez **Créer une fonction**. 1. Ne désélectionnez pas l’option **Créer à partir de zéro** puis, sous **Informations de base**, saisissez **LambdaIaCDemo** pour le **nom de la fonction**. 1. Pour l’**environnement d’exécution**, sélectionnez **Python 3.11**. 1. Choisissez **Créer une fonction**. ## Afficher le modèle AWS SAM correspondant à votre fonction Avant d’exporter la configuration de votre fonction vers Infrastructure Composer, utilisez la console Lambda pour afficher la configuration actuelle de votre fonction sous forme de modèle AWS SAM. En suivant les étapes décrites dans cette section, vous découvrirez l’anatomie d’un modèle AWS SAM et comment définir des ressources telles que les fonctions Lambda pour commencer à spécifier une application sans serveur. **Pour afficher le modèle AWS SAM correspondant à votre fonction** 1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda. 1. Choisissez la fonction que vous venez de créer (`LambdaIaCDemo`). 1. Dans le volet de **Présentation de la fonction**, choisissez **Modèle**. À la place du schéma représentant la configuration de votre fonction, vous verrez un modèle AWS SAM pour votre fonction. Le modèle doit ressembler à ce qui suit. ``` # This AWS SAM template has been generated from your function's # configuration. If your function has one or more triggers, note # that the AWS resources associated with these triggers aren't fully # specified in this template and include placeholder values.Open this template # in AWS Application Composer or your favorite IDE and modify # it to specify a serverless application with other AWS resources. AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Specification template describing your function. Resources: LambdaIaCDemo: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 3 Handler: lambda_function.lambda_handler Runtime: python3.11 Architectures: - x86_64 EventInvokeConfig: MaximumEventAgeInSeconds: 21600 MaximumRetryAttempts: 2 EphemeralStorage: Size: 512 RuntimeManagementConfig: UpdateRuntimeOn: Auto SnapStart: ApplyOn: None PackageType: Zip Policies: Statement: - Effect: Allow Action: - logs:CreateLogGroup Resource: arn:aws:logs:us-east-1:123456789012:* - Effect: Allow Action: - logs:CreateLogStream - logs:PutLogEvents Resource: - >- arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/LambdaIaCDemo:* ``` Examinons le modèle YAML pour votre fonction pour comprendre certains concepts clés. Le modèle commence par la déclaration `Transform: AWS::Serverless-2016-10-31`. Cette déclaration est obligatoire car, en arrière-plan, les modèles AWS SAM sont déployés via CloudFormation. L’utilisation de l’instruction `Transform` identifie le modèle en tant que fichier modèle AWS SAM. Après la déclaration `Transform` vient la section `Resources`. C’est ici que sont définies les ressources AWS que vous souhaitez déployer avec votre modèle AWS SAM. Les modèles AWS SAM peuvent contenir une combinaison de ressources AWS SAM et de ressources CloudFormation. Cela est dû au fait que pendant le déploiement, les modèles AWS SAM se transforment en modèles CloudFormation, de sorte que toute CloudFormation syntaxe valide peut être ajoutée à un modèle AWS SAM. Pour le moment, une seule ressource est définie dans la section `Resources` du modèle, votre fonction Lambda `LambdaIaCDemo`. Pour ajouter une fonction Lambda à un modèle AWS SAM, vous devez utiliser le type de ressource `AWS::Serverless::Function`. La ressource `Properties` d’une fonction Lambda définit l’exécution de la fonction, le gestionnaire de fonctions et les autres options de configuration. Le chemin d’accès au code source de votre fonction qui doit être utilisé par AWS SAM pour déployer la fonction est également défini ici. Pour en savoir plus sur les ressources de fonction Lambda dans AWS SAM, consultez [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) dans le *Guide du développeur AWS SAM*. Outre les propriétés et les configurations des fonctions, le modèle spécifie également une politique Gestion des identités et des accès AWS (IAM) pour votre fonction. Cette stratégie autorise votre fonction à écrire des journaux dans Amazon CloudWatch Logs. Lorsque vous créez une fonction dans la console Lambda, Lambda associe automatiquement cette politique à votre fonction. Pour en savoir plus sur la spécification d’une politique IAM pour une fonction dans un modèle AWS SAM, consultez la propriété `policies` à la page [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) du *Guide du développeur AWS SAM*. Pour en savoir plus sur la structure des modèles AWS SAM, consultez la section [Anatomie des modèles AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html). ## Utiliser AWS Infrastructure Composer pour concevoir une application sans serveur Pour commencer à créer une application sans serveur simple en utilisant le modèle AWS SAM de votre fonction comme point de départ, vous devez exporter la configuration de votre fonction vers Infrastructure Composer et activer le mode de synchronisation local d’Infrastructure Composer. La synchronisation locale enregistre automatiquement le code de votre fonction et votre modèle AWS SAM sur votre machine de génération locale et synchronise votre modèle enregistré lorsque vous ajoutez d’autres ressources AWS dans Infrastructure Composer. **Pour exporter votre fonction vers Infrastructure Composer** 1. Dans le volet **Vue d’ensemble des fonctions**, choisissez **Exporter vers Application Composer**. Pour exporter la configuration et le code de votre fonction vers Infrastructure Composer, Lambda crée un compartiment Amazon S3 dans votre compte pour stocker temporairement ces données. 1. Dans la boîte de dialogue, choisissez **Confirmer et créer un projet** pour accepter le nom par défaut de ce compartiment et exporter la configuration et le code de votre fonction vers Infrastructure Composer. 1. (Facultatif) Pour choisir un autre nom pour le compartiment Amazon S3 créé par Lambda, entrez un nouveau nom et choisissez **Confirmer et créer un projet**. Les noms de compartiment Amazon S3 doivent être uniques et respecter les [règles de dénomination de compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html). Sélectionnez **Confirmer et créer un projet** pour ouvrir la console Infrastructure Composer. Sur le *canevas*, votre fonction Lambda apparaît. 1. **Dans le menu déroulant**, choisissez **Activer la synchronisation locale**. 1. Dans la boîte de dialogue qui apparaît, choisissez **Sélectionner un dossier** et un dossier sur votre machine de construction locale. 1. Choisissez **Activer** pour activer la synchronisation locale. Pour exporter votre fonction vers Infrastructure Composer, vous avez besoin d’une autorisation pour utiliser certaines actions d’API. Si vous ne parvenez pas à exporter votre fonction, vérifiez [Autorisations requises](services-appcomposer.md#services-appcomposer-permissions) et assurez-vous que vous disposez des autorisations nécessaires. **Note** La [tarification standard d’Amazon S3](https://aws.amazon.com/s3/pricing) s’applique au compartiment créé par Lambda lorsque vous exportez une fonction vers Infrastructure Composer. Les objets que Lambda place dans le compartiment sont automatiquement supprimés au bout de 10 jours, mais Lambda ne supprime pas le compartiment lui-même. Pour éviter que des frais supplémentaires ne soient ajoutés à votre Compte AWS, suivez les instructions de la section [Supprimer un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) après avoir exporté votre fonction vers Infrastructure Composer. Pour en savoir plus sur le compartiment Amazon S3 créé par Lambda, consultez [Utilisation AWS Lambda avec AWS Infrastructure Composer](services-appcomposer.md). **Pour concevoir votre application sans serveur dans Infrastructure Composer** Après avoir activé la synchronisation locale, les modifications que vous apportez dans Infrastructure Composer seront reflétées dans le modèle AWS SAM enregistré sur votre machine de génération locale. Vous pouvez désormais glisser-déposer des ressources AWS supplémentaires sur le canevas d’Infrastructure Composer pour créer votre application. Dans cet exemple, vous ajoutez une file d’attente simple Amazon SQS comme déclencheur pour votre fonction Lambda et une table DynamoDB pour la fonction dans laquelle écrire des données. 1. Ajoutez un déclencheur Amazon SQS à votre fonction Lambda en procédant comme suit : 1. Dans le champ de recherche de la palette **Ressources**, entrez **SQS**. 1. Faites glisser la ressource **SQS Queue** sur votre canevas et positionnez-la à gauche de votre fonction Lambda. 1. Choisissez **Détails**, puis, pour **Logical ID**, entrez **LambdaIaCQueue**. 1. Choisissez **Enregistrer**. 1. Connectez vos ressources Amazon SQS et Lambda en cliquant sur le port **Abonnement** sur la carte de file d’attente SQS et en le faisant glisser vers le port gauche de la carte de fonction Lambda. L’apparition d’une ligne entre les deux ressources indique que la connexion a abouti. Infrastructure Composer affiche également un message au bas du canevas indiquant que les deux ressources sont correctement connectées. 1. Ajoutez une table Amazon DynamoDB dans laquelle votre fonction Lambda pourra y écrire des données en procédant comme suit : 1. Dans le champ de recherche de la palette **Ressources**, entrez **DynamoDB**. 1. Faites glisser la ressource **Table DynamoDB** sur votre canevas et positionnez-la à droite de votre fonction Lambda. 1. Choisissez **Détails**, puis, pour **Logical ID**, entrez **LambdaIaCTable**. 1. Choisissez **Enregistrer**. 1. Connectez la table DynamoDB à votre fonction Lambda en cliquant sur le port droit de la carte de fonction Lambda et en la faisant glisser vers le port gauche de la carte DynamoDB. Maintenant que vous avez ajouté ces ressources supplémentaires, examinons le modèle AWS SAM mis à jour qu’Infrastructure Composer a créé. **Pour afficher votre modèle AWS SAM mis à jour** + Sur le canevas Infrastructure Composer, choisissez **Modèle** pour passer de la vue canevas à la vue modèle. Votre modèle AWS SAM doit désormais contenir les ressources et propriétés supplémentaires suivantes : + File d’attente Amazon SQS avec l’identifiant `LambdaIaCQueue` ``` LambdaIaCQueue: Type: AWS::SQS::Queue Properties: MessageRetentionPeriod: 345600 ``` Lorsque vous ajoutez une file d’attente Amazon SQS à l’aide d’Infrastructure Composer, Infrastructure Composer définit la propriété `MessageRetentionPeriod`. Vous pouvez également définir la propriété `FifoQueue` en sélectionnant **Détails** sur la carte SQS Queue et en cochant ou décochant la **file d’attente Fifo**. Pour définir d’autres propriétés pour votre file d’attente, vous pouvez modifier manuellement le modèle et les y ajouter. Pour en savoir plus sur la ressource `AWS::SQS::Queue` et ses propriétés disponibles, consultez [AWS::SQS::Queue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sqs-queue.html) dans le *Guide de l’utilisateur CloudFormation*. + Propriété `Events` de votre définition de fonction Lambda qui spécifie la file d’attente Amazon SQS comme déclencheur de la fonction ``` Events: LambdaIaCQueue: Type: SQS Properties: Queue: !GetAtt LambdaIaCQueue.Arn BatchSize: 1 ``` La propriété `Events` est constituée d’un type d’événement et d’un ensemble de propriétés qui dépendent du type. Pour en savoir plus sur les différents Services AWS que vous pouvez configurer pour déclencher une fonction Lambda et sur les propriétés que vous pouvez définir, consultez [EventSource](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-eventsource.html) dans le *Guide du développeur AWS SAM*. + Table DynamoDB avec l’identifiant `LambdaIaCTable` ``` LambdaIaCTable: Type: AWS::DynamoDB::Table Properties: AttributeDefinitions: - AttributeName: id AttributeType: S BillingMode: PAY_PER_REQUEST KeySchema: - AttributeName: id KeyType: HASH StreamSpecification: StreamViewType: NEW_AND_OLD_IMAGES ``` Lorsque vous ajoutez une table DynamoDB à l’aide d’Infrastructure Composer, vous pouvez définir les clés de votre table en choisissant **Détails** sur la fiche de table DynamoDB et en modifiant les valeurs clés. Infrastructure Composer définit également des valeurs par défaut pour un certain nombre d’autres propriétés, notamment `BillingMode` et `StreamViewType`. Pour en savoir plus sur ces propriétés et les autres propriétés que vous pouvez ajouter à votre modèle AWS SAM, consultez [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) dans le *Guide de l’utilisateur CloudFormation*. + Une nouvelle politique IAM qui autorise votre fonction à effectuer des opérations CRUD sur la table DynamoDB que vous avez ajoutée. ``` Policies: ... - DynamoDBCrudPolicy: TableName: !Ref LambdaIaCTable ``` Le modèle AWS SAM final complet doit ressembler à ce qui suit. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Specification template describing your function. Resources: LambdaIaCDemo: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 3 Handler: lambda_function.lambda_handler Runtime: python3.11 Architectures: - x86_64 EventInvokeConfig: MaximumEventAgeInSeconds: 21600 MaximumRetryAttempts: 2 EphemeralStorage: Size: 512 RuntimeManagementConfig: UpdateRuntimeOn: Auto SnapStart: ApplyOn: None PackageType: Zip Policies: - Statement: - Effect: Allow Action: - logs:CreateLogGroup Resource: arn:aws:logs:us-east-1:594035263019:* - Effect: Allow Action: - logs:CreateLogStream - logs:PutLogEvents Resource: - arn:aws:logs:us-east-1:594035263019:log-group:/aws/lambda/LambdaIaCDemo:* - DynamoDBCrudPolicy: TableName: !Ref LambdaIaCTable Events: LambdaIaCQueue: Type: SQS Properties: Queue: !GetAtt LambdaIaCQueue.Arn BatchSize: 1 Environment: Variables: LAMBDAIACTABLE_TABLE_NAME: !Ref LambdaIaCTable LAMBDAIACTABLE_TABLE_ARN: !GetAtt LambdaIaCTable.Arn LambdaIaCQueue: Type: AWS::SQS::Queue Properties: MessageRetentionPeriod: 345600 LambdaIaCTable: Type: AWS::DynamoDB::Table Properties: AttributeDefinitions: - AttributeName: id AttributeType: S BillingMode: PAY_PER_REQUEST KeySchema: - AttributeName: id KeyType: HASH StreamSpecification: StreamViewType: NEW_AND_OLD_IMAGES ``` ## Déployer votre application sans serveur en utilisant AWS SAM (facultatif) Si vous souhaitez utiliser AWS SAM pour déployer une application sans serveur à l’aide du modèle que vous venez de créer dans Infrastructure Composer, vous devez d’abord installer l’CLI d’AWS SAM. Pour ce faire, suivez les instructions de la section [Installation de la CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html). Avant de déployer votre application, vous devez également mettre à jour le code de fonction enregistré par Infrastructure Composer avec votre modèle. Pour le moment, le fichier `lambda_function.py` enregistré par Infrastructure Composer ne contient que le code de base « Hello world » fourni par Lambda lors de la création de la fonction. Pour mettre à jour votre code de fonction, copiez le code suivant et collez-le dans le fichier `lambda_function.py` qu’Infrastructure Composer a enregistré sur votre machine de compilation locale. Vous avez spécifié le répertoire dans lequel Infrastructure Composer doit enregistrer ce fichier lorsque vous avez activé le mode de synchronisation locale. Ce code accepte une paire clé-valeur dans un message provenant de la file d’attente Amazon SQS que vous avez créée dans Infrastructure Composer. Si la clé et la valeur sont des chaînes, le code les utilise ensuite pour écrire un élément dans la table DynamoDB définie dans votre modèle. ### Mise à jour du code de la fonction Python ``` import boto3 import os import json # define the DynamoDB table that Lambda will connect to tablename = os.environ['LAMBDAIACTABLE_TABLE_NAME'] # create the DynamoDB resource dynamo = boto3.client('dynamodb') def lambda_handler(event, context): # get the message out of the SQS event message = event['Records'][0]['body'] data = json.loads(message) # write event data to DDB table if check_message_format(data): key = next(iter(data)) value = data[key] dynamo.put_item( TableName=tablename, Item={ 'id': {'S': key}, 'Value': {'S': value} } ) else: raise ValueError("Input data not in the correct format") # check that the event object contains a single key value # pair that can be written to the database def check_message_format(message): if len(message) != 1: return False key, value = next(iter(message.items())) if not (isinstance(key, str) and isinstance(value, str)): return False else: return True ``` **Pour déployer votre application sans serveur** Pour déployer votre application à l’aide d’AWS SAM CLI, procédez comme suit. Pour que votre fonction soit correctement construite et déployée, la version 3.11 de Python doit être installée sur votre machine de compilation et sur votre `PATH`. 1. Exécutez la commande suivante depuis le répertoire dans lequel Infrastructure Composer a enregistré vos fichiers `template.yaml` et `lambda_function.py`. ``` sam build ``` Cette commande rassemble les artefacts de compilation pour votre application et les place dans le format et l’emplacement appropriés pour les déployer. 1. Pour déployer votre application et créer les ressources Lambda, Amazon SQS et DynamoDB spécifiées dans votre modèle AWS SAM, exécutez la commande suivante. ``` sam deploy --guided ``` L’utilisation du drapeau `--guided` signifie qu’AWS SAM affiche des invites pour vous guider tout au long du processus de déploiement. Pour ce déploiement, acceptez les options par défaut en appuyant sur Entrée. Au cours du processus de déploiement, AWS SAM crée les ressources suivantes dans votre Compte AWS : + Une [pile](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-whatis-concepts.html#cfn-concepts-stacks) CloudFormation nommée `sam-app` + Une fonction Lambda avec le format de nom `sam-app-LambdaIaCDemo-99VXPpYQVv1M` + Une file d’attente Amazon SQS au format de nom `sam-app-LambdaIaCQueue-xL87VeKsGiIo` + Une table DynamoDB au format de nom `sam-app-LambdaIaCTable-CN0S66C0VLNV` AWS SAM crée également les rôles et politiques IAM nécessaires pour que votre fonction Lambda puisse lire les messages de la file d’attente Amazon SQS et effectuer des opérations CRUD sur la table DynamoDB. ## Testing de votre application déployée (facultatif) Pour vérifier que votre application sans serveur s’est déployée correctement, envoyez un message à votre file d’attente Amazon SQS contenant une paire clé-valeur et vérifiez que Lambda écrit un élément dans votre table DynamoDB en utilisant ces valeurs. **Tester votre application sans serveur** 1. Ouvrez la page [Files d’attente](https://console.aws.amazon.com/sqs/v2/home#/queues) de la console Amazon SQS et sélectionnez la file d’attente créée par AWS SAM depuis votre modèle. Le nom est au format `sam-app-LambdaIaCQueue-xL87VeKsGiIo`. 1. Choisissez **Envoyer et recevoir des messages**, puis collez le code JSON suivant dans le champ **Corps du message**, dans la section **Envoyer un message**. ``` { "myKey": "myValue" } ``` 1. Choisissez **Send Message** (Envoyer un message). L’envoi de votre message à la file d’attente amène Lambda à invoquer votre fonction par le biais du mappage de la source d’événement défini dans votre modèle AWS SAM. Pour confirmer que Lambda a invoqué votre fonction comme prévu, indiquez qu’un élément a été ajouté à votre table DynamoDB. 1. Ouvrez la page [Tables](https://console.aws.amazon.com/dynamodbv2#tables) de la console DynamoDB et choisissez votre table. Le nom est au format `sam-app-LambdaIaCTable-CN0S66C0VLNV`. 1. Choisissez **Explorer les éléments de la table**. Dans le volet **Items returned** (Éléments retournés), vous devriez voir un élément avec l’**id** `myKey` et la **Valeur** `myValue`. # Déploiement de fonctions Lambda avec AWS CDK AWS Cloud Development Kit (AWS CDK) Il s'agit d'un framework d'infrastructure en tant que code (IaC) que vous pouvez utiliser pour définir une infrastructure AWS cloud en utilisant le langage de programmation de votre choix. Pour définir votre propre infrastructure de cloud, écrivez d'abord une application (dans l'un des langages pris en charge par le CDK) contenant une ou plusieurs piles. Ensuite, vous le synthétisez dans un CloudFormation modèle et déployez vos ressources sur votre Compte AWS. Suivez les étapes décrites dans cette rubrique pour déployer une fonction Lambda qui renvoie un événement depuis un point de terminaison Amazon API Gateway. La bibliothèque AWS Construct, incluse dans le CDK, fournit des modules que vous pouvez utiliser pour modéliser les ressources Services AWS fournies. Pour les services populaires, la bibliothèque fournit des constructions organisées avec des valeurs par défaut intelligentes et les bonnes pratiques. Vous pouvez utiliser le module [aws\$1lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) pour définir votre fonction et les ressources de support en quelques lignes de code. ## Conditions préalables Avant de commencer ce didacticiel, installez le AWS CDK en exécutant la commande suivante. ``` npm install -g aws-cdk ``` ## Étape 1 : Configurez votre AWS CDK projet Créez un répertoire pour votre nouvelle AWS CDK application et initialisez le projet. ------ #### [ JavaScript ] ``` mkdir hello-lambda cd hello-lambda cdk init --language javascript ``` ------ #### [ TypeScript ] ``` mkdir hello-lambda cd hello-lambda cdk init --language typescript ``` ------ #### [ Python ] ``` mkdir hello-lambda cd hello-lambda cdk init --language python ``` Une fois le projet démarré, activez l’environnement virtuel du projet et installez les dépendances de base d’ AWS CDK. ``` source .venv/bin/activate python -m pip install -r requirements.txt ``` ------ #### [ Java ] ``` mkdir hello-lambda cd hello-lambda cdk init --language java ``` Importez ce projet Maven dans votre environnement de développement intégré (IDE) Java. Par exemple, dans Eclipse, utilisez **Fichier**, **Importer**, **Maven**, **Projets Maven existants**. ------ #### [ C\$1 ] ``` mkdir hello-lambda cd hello-lambda cdk init --language csharp ``` ------ **Note** Le modèle AWS CDK d'application utilise le nom du répertoire du projet pour générer des noms pour les classes et les fichiers sources. Dans cet exemple, le répertoire est nommé `hello-lambda`. Si vous utilisez un nom répertoire différent, votre application ne correspondra pas à ces instructions. AWS CDK v2 inclut des constructions stables pour tous Services AWS dans un seul package appelé`aws-cdk-lib`. Ce package est installé en tant que dépendance lorsque vous initialisez le projet. Lorsque vous travaillez avec certains langages de programmation, le package est installé lorsque vous créez le projet pour la première fois. ## Étape 2 : définir la AWS CDK pile Une *pile* CDK est un ensemble d'une ou plusieurs constructions qui définissent AWS les ressources. Chaque pile CDK représente une CloudFormation pile dans votre application CDK. Pour définir votre pile CDK, suivez les instructions de votre langage de programmation préféré. Cette pile définit les éléments suivants : + Le nom logique de la fonction : `MyFunction` + L’emplacement du code de fonction, spécifié dans la propriété `code`. Pour plus d’informations, consultez [Handler code](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html#handler-code) dans la *Référence de l’API AWS Cloud Development Kit (AWS CDK) *. + Le nom logique de l’API REST : `HelloApi` + Le nom logique du point de terminaison d’API Gateway : `ApiGwEndpoint` Notez que toutes les piles CDK de ce tutoriel utilisent l’[environnement d’exécution](lambda-runtimes.md) Node.js pour la fonction Lambda. Vous pouvez utiliser différents langages de programmation pour la pile CDK et la fonction Lambda afin de tirer parti des points forts de chaque langage. Par exemple, vous pouvez utiliser la pile CDK TypeScript pour tirer parti des avantages du typage statique pour votre code d'infrastructure. Vous pouvez utiliser la fonction Lambda JavaScript pour tirer parti de la flexibilité et du développement rapide d'un langage typé dynamiquement. ------ #### [ JavaScript ] Ouvrez le fichier `lib/hello-lambda-stack.js` et remplacez le contenu par ce qui suit. ``` const { Stack } = require('aws-cdk-lib'); const lambda = require('aws-cdk-lib/aws-lambda'); const apigw = require('aws-cdk-lib/aws-apigateway'); class HelloLambdaStack extends Stack { /** * * @param {Construct} scope * @param {string} id * @param {StackProps=} props */ constructor(scope, id, props) { super(scope, id, props); const fn = new lambda.Function(this, 'MyFunction', { code: lambda.Code.fromAsset('lib/lambda-handler'), runtime: lambda.Runtime.NODEJS_LATEST, handler: 'index.handler' }); const endpoint = new apigw.LambdaRestApi(this, 'MyEndpoint', { handler: fn, restApiName: "HelloApi" }); } } module.exports = { HelloLambdaStack } ``` ------ #### [ TypeScript ] Ouvrez le fichier `lib/hello-lambda-stack.ts` et remplacez le contenu par ce qui suit. ``` import * as cdk from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as apigw from "aws-cdk-lib/aws-apigateway"; import * as lambda from "aws-cdk-lib/aws-lambda"; import * as path from 'node:path'; export class HelloLambdaStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps){ super(scope, id, props) const fn = new lambda.Function(this, 'MyFunction', { runtime: lambda.Runtime.NODEJS_LATEST, handler: 'index.handler', code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')), }); const endpoint = new apigw.LambdaRestApi(this, `ApiGwEndpoint`, { handler: fn, restApiName: `HelloApi`, }); } } ``` ------ #### [ Python ] Ouvrez le fichier `/hello-lambda/hello_lambda/hello_lambda_stack.py` et remplacez le contenu par ce qui suit. ``` from aws_cdk import ( Stack, aws_apigateway as apigw, aws_lambda as _lambda ) from constructs import Construct class HelloLambdaStack(Stack): def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) fn = _lambda.Function( self, "MyFunction", runtime=_lambda.Runtime.NODEJS_LATEST, handler="index.handler", code=_lambda.Code.from_asset("lib/lambda-handler") ) endpoint = apigw.LambdaRestApi( self, "ApiGwEndpoint", handler=fn, rest_api_name="HelloApi" ) ``` ------ #### [ Java ] Ouvrez le fichier `/hello-lambda/src/main/java/com/myorg/HelloLambdaStack.java` et remplacez le contenu par ce qui suit. ``` package com.myorg; import software.constructs.Construct; import software.amazon.awscdk.Stack; import software.amazon.awscdk.StackProps; import software.amazon.awscdk.services.apigateway.LambdaRestApi; import software.amazon.awscdk.services.lambda.Function; public class HelloLambdaStack extends Stack { public HelloLambdaStack(final Construct scope, final String id) { this(scope, id, null); } public HelloLambdaStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); Function hello = Function.Builder.create(this, "MyFunction") .runtime(software.amazon.awscdk.services.lambda.Runtime.NODEJS_LATEST) .code(software.amazon.awscdk.services.lambda.Code.fromAsset("lib/lambda-handler")) .handler("index.handler") .build(); LambdaRestApi api = LambdaRestApi.Builder.create(this, "ApiGwEndpoint") .restApiName("HelloApi") .handler(hello) .build(); } } ``` ------ #### [ C\$1 ] Ouvrez le fichier `src/HelloLambda/HelloLambdaStack.cs` et remplacez le contenu par ce qui suit. ``` using Amazon.CDK; using Amazon.CDK.AWS.APIGateway; using Amazon.CDK.AWS.Lambda; using Constructs; namespace HelloLambda { public class HelloLambdaStack : Stack { internal HelloLambdaStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props) { var fn = new Function(this, "MyFunction", new FunctionProps { Runtime = Runtime.NODEJS_LATEST, Code = Code.FromAsset("lib/lambda-handler"), Handler = "index.handler" }); var api = new LambdaRestApi(this, "ApiGwEndpoint", new LambdaRestApiProps { Handler = fn }); } } } ``` ------ ## Étape 3 : créer le code de la fonction Lambda 1. À partir de la racine de votre projet (`hello-lambda`), créez le répertoire `/lib/lambda-handler` pour le code de la fonction Lambda. Ce répertoire est spécifié dans la `code` propriété de votre AWS CDK pile. 1. Dans le répertoire `/lib/lambda-handler`, créez un nouveau fichier appelé `index.js`. Collez le code suivant dans le fichier. La fonction extrait des propriétés spécifiques de la requête d’API et les renvoie sous forme de réponse JSON. ``` exports.handler = async (event) => { // Extract specific properties from the event object const { resource, path, httpMethod, headers, queryStringParameters, body } = event; const response = { resource, path, httpMethod, headers, queryStringParameters, body, }; return { body: JSON.stringify(response, null, 2), statusCode: 200, }; }; ``` ## Étape 4 : Déployer la AWS CDK pile 1. À la racine de votre projet, effectuez la commande [cdk synth](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-synth.html) : ``` cdk synth ``` Cette commande synthétise un AWS CloudFormation modèle à partir de votre pile de CDK. Le modèle est un fichier YAML d’environ 400 lignes, semblable à ce qui suit. **Note** Si vous obtenez l’erreur suivante, assurez-vous que vous êtes à la racine du répertoire de votre projet. ``` --app is required either in command-line, in cdk.json or in ~/.cdk.json ``` **Example CloudFormation modèle** ``` Resources: MyFunctionServiceRole3C357FF2: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Statement: - Action: sts:AssumeRole Effect: Allow Principal: Service: lambda.amazonaws.com Version: "2012-10-17" ManagedPolicyArns: - Fn::Join: - "" - - "arn:" - Ref: AWS::Partition - :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole Metadata: aws:cdk:path: HelloLambdaStack/MyFunction/ServiceRole/Resource MyFunction1BAA52E7: Type: AWS::Lambda::Function Properties: Code: S3Bucket: Fn::Sub: cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region} S3Key: ab1111111cd32708dc4b83e81a21c296d607ff2cdef00f1d7f48338782f92l3901.zip Handler: index.handler Role: Fn::GetAtt: - MyFunctionServiceRole3C357FF2 - Arn Runtime: nodejs24.x ... ``` 1. Exécutez la commande [cdk deploy](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-deploy.html) : ``` cdk deploy ``` Patientez que vos ressources soient créées. Le résultat final inclut l’URL de votre point de terminaison d’API Gateway. Exemple : ``` Outputs: HelloLambdaStack.ApiGwEndpoint77F417B1 = https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/ ``` ## Étape 5 : tester de la fonction Pour invoquer la fonction Lambda, copiez le point de terminaison d’API Gateway et collez-le dans un navigateur Web ou exécutez une commande `curl` : ``` curl -s https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/ ``` La réponse est une représentation JSON des propriétés sélectionnées à partir de l’objet d’événement d’origine, qui contient des informations sur la requête envoyée au point de terminaison d’API Gateway. Exemple : ``` { "resource": "/", "path": "/", "httpMethod": "GET", "headers": { "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7", "Accept-Encoding": "gzip, deflate, br, zstd", "Accept-Language": "en-US,en;q=0.9", "CloudFront-Forwarded-Proto": "https", "CloudFront-Is-Desktop-Viewer": "true", "CloudFront-Is-Mobile-Viewer": "false", "CloudFront-Is-SmartTV-Viewer": "false", "CloudFront-Is-Tablet-Viewer": "false", "CloudFront-Viewer-ASN": "16509", "CloudFront-Viewer-Country": "US", "Host": "abcd1234.execute-api.us-east-1.amazonaws.com", ... ``` ## Étape 6 : Nettoyer vos ressources Le point de terminaison d’API Gateway est accessible au public. Pour éviter des frais inattendus, exécutez la commande [cdk destroy](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-destroy.html) pour supprimer la pile et toutes les ressources associées. ``` cdk destroy ``` ## Étapes suivantes Pour plus d'informations sur l'écriture d' AWS CDK applications dans la langue de votre choix, consultez les rubriques suivantes : ------ #### [ TypeScript ] [Travailler avec le AWS CDK in TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html) ------ #### [ JavaScript ] [Travailler avec le AWS CDK in JavaScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html) ------ #### [ Python ] [Travailler avec le AWS CDK en Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html) ------ #### [ Java ] [Travailler avec le AWS CDK en Java](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html) ------ #### [ C\$1 ] [Travailler avec le AWS CDK en C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html) ------ #### [ Go ] [Travailler avec le AWS CDK in Go](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-go.html) ------