Utilisation de Lambda avec infrastructure en tant que code (IaC) - AWS Lambda
Outils de l’IaC pour LambdaDémarrage avec l’IaC pour LambdaÉtapes suivantesRégions prises en charge pour l’intégration de Lambda à Application Composer

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)

Lambda propose plusieurs méthodes pour déployer votre code et créer des fonctions. Par exemple, vous pouvez utiliser la console Lambda ou l’AWS Command Line Interface (AWS CLI) pour créer ou mettre à jour manuellement des fonctions Lambda. Outre ces options manuelles, AWS propose un certain nombre de solutions pour déployer des fonctions Lambda et des applications sans serveur utilisant l’infrastructure en tant que code (IaC). Avec l’IaC, vous pouvez configurer et gérer des fonctions Lambda et d’autres ressources AWS à l’aide de code plutôt qu’utiliser des processus et des paramètres manuels.

La plupart du temps, les fonctions Lambda ne s’exécutent pas de manière isolée. Elles font plutôt 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’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

Pour déployer des fonctions Lambda et des applications sans serveur à l’aide de l’IaC, AWS propose un certain nombre d’outils et de services différents.

AWS CloudFormation a été le premier service proposé par AWS pour créer et configurer des ressources cloud. Avec AWS CloudFormation, vous créez des modèles de texte pour définir l’infrastructure et le code. À mesure que de nouveaux services étaient introduits par AWS et que la complexité de la création de modèles AWS CloudFormation augmentait, deux autres outils ont été publiés. AWS SAM est un autre framework basé sur des modèles qui permet de définir des applications sans serveur. AWS Cloud Development Kit (AWS CDK) consiste en une approche axée sur le code pour définir et approvisionner l’infrastructure à l’aide de constructions de code dans de nombreux langages de programmation courants.

Avec AWS SAM et AWS CDK, AWS CloudFormation opère en arrière-plan pour créer et déployer votre infrastructure. Le schéma suivant illustre la relation entre ces outils, et les paragraphes qui suivent le schéma expliquent leurs principales fonctionnalités.

Schéma montrant comment AWS SAM et AWS CDK déploient des ressources AWS du code à l’aide de AWS CloudFormation, ce qui crée la pile d’applications.

  • AWS CloudFormation- Avec CloudFormation vous, modélisez et configurez vos AWS ressources à l'aide d'un modèle YAML ou JSON qui décrit vos ressources et leurs propriétés. CloudFormation provisionne vos ressources de manière sûre et reproductible, ce qui vous permet de créer fréquemment votre infrastructure et vos applications sans étapes manuelles. Lorsque vous modifiez la configuration, CloudFormation détermine les opérations appropriées à effectuer pour mettre à jour votre pile. CloudFormation peut même annuler les modifications.

  • AWS Serverless Application Model (AWS SAM) - AWS SAM est une infrastructure open source qui permet de définir des applications sans serveur. Les modèles AWS SAM utilisent une syntaxe abrégée pour définir les fonctions, les API, les bases de données et les mappages de sources d’événements avec seulement quelques lignes de texte (YAML) par ressource. Pendant le déploiement, AWS SAM transforme et développe la syntaxe AWS SAM en syntaxe AWS CloudFormation. De ce fait, n'importe quelle CloudFormation syntaxe peut être ajoutée aux AWS SAM modèles. Cela donne AWS SAM toute la puissance de CloudFormation, mais avec moins de lignes de configuration.

  • AWS Cloud Development Kit (AWS CDK)- Avec leAWS CDK, vous définissez votre infrastructure à l'aide de constructions de code et vous la provisionnez par le biais AWS CloudFormation de ce code. AWS CDKvous permet de modéliser l'infrastructure d'applications avec Python TypeScript, Java, .NET et Go (dans Developer Preview) en utilisant votre IDE, vos outils de test et vos modèles de flux de travail existants. Vous bénéficiez de tous les avantages de AWS CloudFormation, notamment du déploiement reproductible, de la facilité de restauration et de la détection des dérives.

AWS fournit également un service appelé Composeur d'applications AWS pour développer des modèles IaC à l’aide d’une interface graphique simple. Avec Application Composer, vous concevez une architecture d’application en faisant glisser, en regroupant et en connectant Services AWS dans un canevas visuel. Application Composer crée ensuite un modèle AWS SAM ou un modèle AWS CloudFormation à partir de votre conception que vous pouvez utiliser pour déployer votre application.

Dans la section Démarrage avec l’IaC pour Lambda ci-dessous, Application Composer vous permet de développer un modèle pour une application sans serveur basée sur une fonction Lambda existante.

Démarrage avec l’IaC pour Lambda

Dans ce didacticiel, 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 Application Composer en ajoutant d’autres ressources AWS.

Si vous préférez commencer par suivre un didacticiel AWS SAM ou AWS CloudFormation pour apprendre à travailler avec des modèles sans utiliser Application Composer, vous trouverez des liens vers d’autres ressources dans la section Étapes suivantes à la fin de cette page.

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 apprendrez également à utiliser Application Composer pour créer une application sans serveur que vous pouvez déployer à l’aide de AWS SAM ou de AWS 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 Composeur d'applications AWS 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

Dans la section Étapes suivantes, vous trouverez des ressources que vous pouvez utiliser pour en savoir plus sur AWS SAM et Application Composer. Ces ressources incluent des liens vers des didacticiels plus avancés qui vous apprennent à déployer une application sans serveur en utilisant AWS SAM.

Prérequis

Dans ce didacticiel, vous allez utiliser la fonctionnalité de synchronisation locale d’Application 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 ?

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.

  2. Sélectionnez Créer une fonction.

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

  4. Pour l’environnement d’exécution, sélectionnez Python 3.11.

  5. Choisissez Créer une fonction.

Afficher le modèle AWS SAM correspondant à votre fonction

Avant d’exporter la configuration de votre fonction vers Application 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 (Fonctions) de la console Lambda.

  2. Choisissez la fonction que vous venez de créer (LambdaIaCDemo).

  3. 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 AWS 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 AWS CloudFormation. Cela est dû au fait que pendant le déploiement, les modèles AWS SAM se transforment en modèles AWS CloudFormation, de sorte que toute AWS 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 relatives aux fonctions Lambda dansAWS SAM, consultez le AWS::Serverless::Functionguide du AWS SAMdéveloppeur.

Outre les propriétés et les configurations des fonctions, le modèle spécifie également une politique AWS Identity and Access Management (IAM) pour votre fonction. Cette politique autorise votre fonction à écrire des journaux sur 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 AWS SAM modèle, consultez la policies propriété sur la AWS::Serverless::Functionpage du Guide du AWS SAM développeur.

Pour en savoir plus sur la structure des modèles AWS SAM, consultez la section Anatomie des modèles AWS SAM.

Utiliser Composeur d'applications AWS 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 Application Composer et activer le mode de synchronisation local d’Application 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 Application Composer.

Pour exporter votre fonction vers Application 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 Application Composer, Lambda crée un compartiment Amazon S3 dans votre compte pour stocker temporairement ces données.

  2. 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 Application Composer.

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

    Sélectionnez Confirmer et créer un projet pour ouvrir la console Application Composer. Sur le canevas, votre fonction Lambda apparaît.

  4. Dans le menu déroulant, choisissez Activer la synchronisation locale.

  5. Dans la boîte de dialogue qui apparaît, choisissez Sélectionner un dossier et un dossier sur votre machine de construction locale.

  6. Choisissez Activer pour activer la synchronisation locale.

Pour exporter votre fonction vers Application Composer, vous avez besoin d'une autorisation pour utiliser certaines actions d'API. Si vous ne parvenez pas à exporter votre fonction, vérifiez Autorisations nécessaires et assurez-vous que vous disposez des autorisations nécessaires.

Note

La tarification standard d’Amazon S3 s’applique au compartiment créé par Lambda lorsque vous exportez une fonction vers Application 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 Compte AWS, suivez les instructions de la section Supprimer un compartiment après avoir exporté votre fonction vers Application Composer. Pour en savoir plus sur le compartiment Amazon S3 créé par Lambda, consultez Utilisation AWS Lambda avec Composeur d'applications AWS.

Pour concevoir votre application sans serveur dans Application Composer

Après avoir activé la synchronisation locale, les modifications que vous apportez dans Application 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’Application 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.

    2. Faites glisser la ressource SQS Queue sur votre canevas et positionnez-la à gauche de votre fonction Lambda.

    3. Choisissez Détails, puis, pour Logical ID, entrez LambdaIaCQueue.

    4. Choisissez Enregistrer.

    5. 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. Application Composer affiche également un message au bas du canevas indiquant que les deux ressources sont correctement connectées.

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

    2. Faites glisser la ressource Table DynamoDB sur votre canevas et positionnez-la à droite de votre fonction Lambda.

    3. Choisissez Détails, puis, pour Logical ID, entrez LambdaIaCTable.

    4. Choisissez Enregistrer.

    5. 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’Application Composer a créé.

Pour afficher votre modèle AWS SAM mis à jour

  • Sur le canevas Application 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’Application Composer, Application 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 dans le Guide de l’utilisateur AWS 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érentes options Services AWS que vous pouvez configurer pour déclencher une fonction Lambda et sur les propriétés que vous pouvez définir, consultez le EventSourceguide du AWS SAMdéveloppeur.

  • 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’Application 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. Application 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 dans le Guide de l’utilisateur AWS 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 Application Composer, vous devez d’abord installer AWS SAM CLI. Pour ce faire, suivez les instructions de la section Installation de la CLI AWS SAM.

Avant de déployer votre application, vous devez également mettre à jour le code de fonction enregistré par Application Composer avec votre modèle. Pour le moment, le fichier lambda_function.py enregistré par Application 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 Application Composer enregistré sur votre machine de compilation locale. Vous avez spécifié le répertoire dans lequel Application 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 Application 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.

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

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

Pour en savoir plus sur l’utilisation d’AWS SAM pour déployer des applications sans serveur, veuillez consulter les ressources de la section Étapes suivantes.

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

  2. 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"
}

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

  4. Ouvrez la page Tables de la console DynamoDB et choisissez votre table. Le nom est au format sam-app-LambdaIaCTable-CN0S66C0VLNV.

  5. Sélectionnez Explore table items (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.

Étapes suivantes

Pour en savoir plus sur l’utilisation d’Application Composer avec AWS SAM etAWS CloudFormation, commencez par utiliser Application Composer avec AWS CloudFormation et AWS SAM.

Pour en savoir plus sur l’utilisation d’AWS SAM dans le cadre du déploiement d’une application sans serveur conçue dans Application Composer, nous vous recommandons également de suivre le didacticiel Composeur d'applications AWS guidé dans AWS Serverless Patterns Workshop.

AWS SAM offre une interface de ligne de commande (CLI) utilisable avec des modèles AWS SAM et des intégrations tierces prises en charge pour créer et exécuter vos applications sans serveur. AWS SAM CLI permet ainsi de créer et déployer votre application, d’effectuer des tests et un débogage locaux, de configurer des pipelines CI/CD, etc. Pour en savoir plus sur l’utilisation d’AWS SAM CLI, consultez la section Bien démarrer avec AWS SAM dans le Guide du développeur AWS Serverless Application Model.

Pour savoir comment déployer une application sans serveur avec un modèle AWS SAM via la console AWS CloudFormation, commencez par Utiliser la console AWS CloudFormation dans le Guide de l’utilisateur AWS CloudFormation.

Régions prises en charge pour l’intégration de Lambda à Application Composer

L’intégration de Lambda à Application Composer est prise en charge dans les Régions AWS suivantes :

  • USA Est (Virginie du Nord)

  • USA Est (Ohio)

  • USA Ouest (Californie du Nord)

  • USA Ouest (Oregon)

  • Afrique (Le Cap)

  • Asie-Pacifique (Hong Kong)

  • Asie-Pacifique (Hyderabad)

  • Asie-Pacifique (Jakarta)

  • Asie-Pacifique (Melbourne)

  • Asie-Pacifique (Mumbai)

  • Asie-Pacifique (Osaka)

  • Asia Pacific (Seoul)

  • Asie-Pacifique (Singapour)

  • Asie-Pacifique (Sydney)

  • Asie-Pacifique (Tokyo)

  • Canada (Centre)

  • Europe (Francfort)

  • Europe (Zurich)

  • Europe (Irlande)

  • Europe (Londres)

  • Europe (Stockholm)

  • Moyen-Orient (EAU)