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. Grâce à l'infrastructure sous forme de code (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 distinctes. AWS 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

AWS fournit également un service appelé AWS Infrastructure Composer à 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 Services AWS en connectant dans un canevas visuel. Infrastructure Composer crée ensuite un AWS SAM modèle ou un AWS CloudFormation modèle à 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, Infrastructure 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 IaC avec Lambda en créant un AWS SAM modèle à 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 AWS ressources sont spécifiées dans AWS SAM. Vous apprendrez également à utiliser Infrastructure Composer pour créer une application sans serveur que vous pouvez déployer à l'aide de AWS SAM ou AWS CloudFormation.

Pour compléter ce didacticiel, effectuez les tâches suivantes :

Prérequis

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

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.

Afficher le AWS SAM modèle 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 AWS SAM modèle et comment définir des ressources telles que les fonctions Lambda pour commencer à spécifier une application sans serveur.

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, dans les coulisses, les AWS SAM modèles 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 AWS ressources que vous souhaitez déployer avec votre AWS SAM modèle. AWS SAM les modèles peuvent contenir une combinaison de AWS SAM ressources et de AWS CloudFormation ressources. Cela est dû au fait que pendant le déploiement, les AWS SAM AWS CloudFormation modèles se transforment en modèles, de sorte que toute AWS CloudFormation syntaxe valide peut être ajoutée à un AWS SAM modèle.

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 AWS SAM modèle, vous devez utiliser le type de AWS::Serverless::Function ressource. 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 AWS SAM doit être utilisé pour déployer la fonction est également défini ici. Pour en savoir plus sur les ressources relatives aux fonctions Lambda dans AWS SAM, consultez le AWS::Serverless::Functionguide du AWS SAM dé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 AWS SAM modèles, consultez la section Anatomie des AWS SAM modèles.

AWS Infrastructure Composer À utiliser pour concevoir une application sans serveur

Pour commencer à créer une application sans serveur simple en utilisant le AWS SAM modèle de votre fonction comme point de départ, vous exportez la configuration de votre fonction vers Infrastructure Composer et activez le mode de synchronisation local d'Infrastructure Composer. La synchronisation locale enregistre automatiquement le code de votre fonction et votre AWS SAM modèle sur votre machine de génération locale et synchronise votre modèle enregistré lorsque vous ajoutez d'autres AWS ressources dans Infrastructure Composer.

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 et assurez-vous que vous disposez des autorisations nécessaires.

Maintenant que vous avez ajouté ces ressources supplémentaires, examinons le AWS SAM modèle mis à jour créé par Infrastructure Composer.

Votre AWS SAM modèle doit désormais contenir les ressources et propriétés supplémentaires suivantes :

Le AWS SAM modèle 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éployez votre application sans serveur à l'aide de AWS SAM (facultatif)

Si vous souhaitez déployer une application sans serveur AWS SAM à l'aide du modèle que vous venez de créer dans Infrastructure Composer, vous devez d'abord installer AWS SAM CLI. Pour ce faire, suivez les instructions de la section Installation de la AWS SAM CLI.

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.

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

Au cours du processus de déploiement, AWS SAM crée les ressources suivantes dans votre Compte AWS :

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.