Construction d’applications Web évolutives avec AWS Lambda et API Gateway

Photo by Andras Vas on Unsplash

Introduction

Dans le paysage numérique d’aujourd’hui en constante évolution, la mise à l’échelle est un aspect crucial du développement d’applications Web. Avec des modèles de trafic imprévisibles et des bases d’utilisateurs en croissance rapide, les architectures traditionnelles basées sur des serveurs peuvent avoir du mal à suivre la demande. Heureusement, AWS Lambda et API Gateway offrent une solution idéale pour construire des applications Web évolutives capables de gérer des charges de travail variables sans se soucier de la gestion et du provisionnement des serveurs.

Dans cet article, nous explorerons comment exploiter AWS Lambda et API Gateway pour créer une architecture d’application Web évolutive capable de répondre dynamiquement aux demandes des utilisateurs tout en garantissant une utilisation rentable et efficace des ressources.

Premiers pas avec AWS Lambda

AWS Lambda est un service de calcul sans serveur qui permet aux développeurs d’exécuter du code sans provisionner ni gérer de serveurs. Il met automatiquement à l’échelle votre application en réponse au trafic entrant, garantissant une utilisation optimale des ressources. Commençons par créer une fonction Lambda simple à l’aide de Python qui renvoie la requête entrante.

import json

def lambda_handler(event, context):
    response = {
        'statusCode': 200,
        'body': json.dumps(event)
    }
    return response

Explication :

• Nous utilisons le module json en Python pour gérer les données JSON, de manière similaire à la façon dont JSON.stringify() fonctionne en JavaScript.
• La fonction lambda_handler est le point d’entrée de l’exécution AWS Lambda.
• Le paramètre event contient les données d’événement transmises à la fonction Lambda. Il inclut généralement des informations sur la requête entrante.
• Nous créons un dictionnaire de réponse avec un statusCode de 200 pour indiquer une réponse réussie.
• Le corps de la réponse contient la représentation JSON du paramètre event en utilisant json.dumps().
• Enfin, nous retournons le dictionnaire de réponse, qui sera renvoyé en tant que réponse HTTP depuis la fonction Lambda.

Création d’une API avec AWS API Gateway :

AWS API Gateway agit comme une interface pour vos fonctions Lambda, les exposant sur le web et vous permettant de créer des API RESTful sans effort. Configurons un point de terminaison API Gateway qui se connecte à notre fonction Lambda.

• Ouvrez la console de gestion AWS et accédez à API Gateway.
• Cliquez sur “Créer une API” et choisissez le type d’API REST.
• Sélectionnez “Nouvelle API” et donnez un nom à votre API.
• Cliquez sur “Créer une API” pour continuer.

Création d’une ressource et d’une méthode :

Maintenant, créons une ressource et une méthode pour gérer les requêtes entrantes et les connecter à la fonction Lambda.

• Sous votre API, cliquez sur “Créer une ressource” et donnez-lui un nom (par exemple, “echo”).
• Avec la ressource “echo” sélectionnée, cliquez sur “Créer une méthode”, choisissez “POST” et sélectionnez votre fonction Lambda dans la liste.
• Enregistrez vos modifications et déployez l’API pour la rendre accessible sur le web.

BONUS : déploiement avec CDK

AWS CDK (Cloud Development Kit) est un cadre d’infrastructure en tant que code qui permet aux développeurs de définir des ressources cloud à l’aide de langages de programmation familiers.

Tout d’abord, assurez-vous d’avoir installé AWS CDK :

npm install -g aws-cdk-lib

Ensuite, vous pouvez créer une nouvelle pile CDK à l’aide du code Python suivant :

from aws_cdk import core
from aws_cdk import aws_lambda as _lambda
from aws_cdk import aws_apigateway as apigw


class LambdaApiStack(core.Stack):

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

        # Create the Lambda function
        my_lambda = _lambda.Function(
            self,
            "MyLambda",
            runtime=_lambda.Runtime.PYTHON_3_8,
            handler="index.lambda_handler",
            code=_lambda.Code.from_asset("lambda")  # Make sure to have your lambda code in a "lambda" folder
        )

        # Create the API Gateway
        api = apigw.RestApi(
            self,
            "MyApi",
            rest_api_name="My API",
            description="My first API Gateway"
        )

        # Create a resource named "echo" under the API
        echo_resource = api.root.add_resource("echo")

        # Add a method "POST" to the "echo" resource and connect it to the Lambda function
        echo_resource.add_method(
            "POST",
            _lambda_integration=_lambda.LambdaIntegration(my_lambda)
        )


app = core.App()
LambdaApiStack(app, "LambdaApiStack")
app.synth()

Explication :

• Nous importons les modules CDK nécessaires : core, aws_lambda et aws_apigateway.
• Nous définissons une classe LambdaApiStack qui représente notre pile CDK.
• À l’intérieur de la classe, nous créons une fonction Lambda nommée “MyLambda” à l’aide de _lambda.Function.
• Ensuite, nous créons une passerelle API nommée “MyApi” à l’aide de apigw.RestApi.
• Nous ajoutons une ressource nommée “echo” sous la racine de l’API à l’aide de la méthode add_resource.
• Nous ajoutons une méthode “POST” à la ressource “echo” et la connectons à la fonction Lambda en utilisant la méthode add_method avec _lambda.LambdaIntegration.

Assurez-vous d’avoir configuré les informations d’identification AWS nécessaires, puis vous pouvez déployer la pile à l’aide de la commande CDK :

cdk deploy

Tester l’API

Maintenant que notre API est déployée, testons-la à l’aide d’un outil comme httpie ou Postman. Effectuez une requête POST vers le point de terminaison de votre API (par exemple, https://votre-id-api.execute-api.votre-region.amazonaws.com/echo) avec n’importe quelle charge utile, et vous devriez recevoir une réponse renvoyant la requête.

Mise à l’échelle de l’application Web

Un des avantages les plus importants de l’utilisation d’AWS Lambda et d’API Gateway est l’évolutivité automatique. À mesure que le nombre de demandes entrantes augmente, AWS provisionne automatiquement des instances supplémentaires de votre fonction Lambda pour gérer la charge. Cela signifie que votre application peut évoluer sans problème sans aucune intervention manuelle.

Gestion rentable des ressources

AWS Lambda suit un modèle de tarification à la demande, ce qui signifie que vous ne payez que pour le nombre réel d’invocations et le temps d’exécution de votre code. Lorsqu’il n’y a pas de demandes entrantes, aucune ressource n’est consommée, ce qui le rend très rentable, surtout pour les applications avec des modèles de trafic variables.

Conclusion

Dans cet article, nous avons exploré comment construire des applications Web évolutives en utilisant AWS Lambda et API Gateway. En exploitant la puissance du calcul sans serveur, nous pouvons développer des applications qui s’adaptent automatiquement à la demande, garantissant une utilisation optimale des ressources et une rentabilité.

AWS Lambda et API Gateway fournissent une excellente base pour créer des applications Web robustes et évolutives capables de gérer des charges de travail imprévisibles et offrir une expérience utilisateur fluide. Pendant que vous poursuivez votre voyage avec l’architecture sans serveur, n’oubliez pas d’explorer d’autres services AWS pour compléter davantage les fonctionnalités de votre application.

Commencez dès aujourd’hui à construire des applications Web évolutives avec AWS Lambda et API Gateway et découvrez les avantages de l’architecture sans serveur de première main. Bon codage !

📚 Vous voulez rester informé des dernières tendances technologiques, des astuces de codage et de l’expertise AWS ? Ne manquez pas cette occasion ! Abonnez-vous à mon profil Medium et rejoignez-moi dans cette passionnante aventure technologique. Explorons et apprenons ensemble ! 🚀 Suivez-moi dès maintenant pour des mises à jour régulières !