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. # Présentation des tests à l'aide de la sam local commande Utilisez la AWS Serverless Application Model commande Command Line Interface (AWS SAMCLI) `sam local` pour tester vos applications sans serveur localement. Pour une introduction à la AWS SAMCLI, voir[Qu'est-ce que c'est AWS SAMCLI ?](what-is-sam-overview.md#what-is-sam-cli). ## Conditions préalables Pour utiliser `sam local`, installez la CLI AWS SAM en procédant comme suit : + [AWS SAM prérequis](prerequisites.md). + [Installer la CLI  AWS SAM](install-sam-cli.md). Avant d'utiliser `sam local`, nous vous recommandons d'avoir des connaissances de base sur les points suivants : + [Configuration de la CLI  AWS SAM](using-sam-cli-configure.md). + [Créez votre application dans AWS SAM](using-sam-cli-init.md). + [Initiation à la construction avec AWS SAM](using-sam-cli-build.md). + [Présentation du déploiement avec AWS SAM](using-sam-cli-deploy.md). ## Utilisation de la commande sam local Utilisez la commande `sam local` avec l'une de ses sous-commandes pour effectuer différents types de tests locaux pour votre application. ``` $ sam local ``` Pour en savoir plus sur chaque sous-commande, consultez les ressources suivantes : + **[Présentation de sam local generate-event](using-sam-cli-local-generate-event.md)**— Génère Service AWS des événements pour les tests locaux. + **[Présentation de sam local invoke](using-sam-cli-local-invoke.md)** : lancez un appel unique d'une fonction AWS Lambda au niveau local. + **[Présentation de sam local start-api](using-sam-cli-local-start-api.md)** : exécutez vos fonctions Lambda à l'aide d'un serveur HTTP local. + **[Présentation de sam local start-lambda](using-sam-cli-local-start-lambda.md)**— Exécutez vos fonctions Lambda à l'aide d'un serveur HTTP local à utiliser avec le AWS CLI ou. SDKs # Présentation des tests avec sam local generate-event Utilisez la AWS Serverless Application Model `sam local generate-event` sous-commande Command Line Interface (AWS SAMCLI) pour générer des échantillons de charge utile d'événements pour les applications prises en charge. Services AWS Vous pouvez ensuite modifier et transmettre ces événements à des ressources locales pour les tester. + Pour une introduction à la AWS SAMCLI, voir [Qu'est-ce que c'est AWS SAMCLI ?](what-is-sam-overview.md#what-is-sam-cli) + Pour obtenir la liste des options de commande `sam local generate-event`, consultez [sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Un *événement* est un objet JSON qui est généré lorsqu'un utilisateur Service AWS exécute une action ou une tâche. Ces événements contiennent des informations spécifiques, telles que les données traitées ou le timestamp de l'événement. La plupart des Services AWS génèrent des événements et les événements de chaque service sont formatés de manière unique pour le service en question. Les événements générés par un service sont transmis à d'autres services en tant que *source d'événements*. Par exemple, un élément placé dans un compartiment Amazon Simple Storage Service (Amazon S3) peut générer un événement. Cet événement peut ensuite être utilisé comme source d'événement pour une fonction AWS Lambda afin de poursuivre le traitement des données. Les événements que vous générez avec `sam local generate-event` sont formatés selon la même structure que les événements réels créés par le AWS service. Vous pouvez modifier le contenu de ces événements et les utiliser pour tester les ressources de votre application. ## Conditions préalables Pour utiliser `sam local generate-event`, installez la CLI AWS SAM en procédant comme suit : + [AWS SAM prérequis](prerequisites.md). + [Installer la CLI  AWS SAM](install-sam-cli.md). Avant d'utiliser `sam local generate-event`, nous vous recommandons d'avoir des connaissances de base sur les points suivants : + [Configuration de la CLI  AWS SAM](using-sam-cli-configure.md). + [Créez votre application dans AWS SAM](using-sam-cli-init.md). + [Initiation à la construction avec AWS SAM](using-sam-cli-build.md). + [Présentation du déploiement avec AWS SAM](using-sam-cli-deploy.md). ## Générer des exemples d'événements Utilisez la AWS SAMCLI `sam local generate-event` sous-commande pour générer des événements pour les personnes prises en charge Services AWS. **Pour voir la liste des produits pris en charge Services AWS** 1. Exécutez les commandes suivantes : ``` $ sam local generate-event ``` 1. La liste des produits pris en charge Services AWS s'affichera. Voici un exemple : ``` $ sam local generate-event ... Commands: alb alexa-skills-kit alexa-smart-home apigateway appsync batch cloudformation ... ``` **Pour générer un événement local** 1. Exécutez `sam local generate-event` et fournissez le nom du service pris en charge. La liste des types d'événements que vous pouvez générer s'affichera. Voici un exemple : ``` $ sam local generate-event s3 Usage: sam local generate-event s3 [OPTIONS] COMMAND [ARGS]... Options: -h, --help Show this message and exit. Commands: batch-invocation Generates an Amazon S3 Batch Operations Invocation Event delete Generates an Amazon S3 Delete Event put Generates an Amazon S3 Put Event ``` 1. Pour générer l'exemple d'événement, exécutez `sam local generate-event` en fournissant le service et le type d'événement. ``` $ sam local generate-event ``` Voici un exemple : ``` $ sam local generate-event s3 put { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` Ces exemples d'événements contiennent des valeurs d'espace réservé. Vous pouvez modifier ces valeurs pour faire référence aux ressources réelles dans votre application ou pour faciliter les tests locaux. **Pour modifier un exemple d'événement** 1. Vous pouvez modifier les exemples d'événements à l'invite de commande. Pour afficher vos options, exécutez ce qui suit : ``` $ sam local generate-event --help ``` Voici un exemple : ``` $ sam local generate-event s3 put --help Usage: sam local generate-event s3 put [OPTIONS] Options: --region TEXT Specify the region name you'd like, otherwise the default = us-east-1 --partition TEXT Specify the partition name you'd like, otherwise the default = aws --bucket TEXT Specify the bucket name you'd like, otherwise the default = example-bucket --key TEXT Specify the key name you'd like, otherwise the default = test/key --debug Turn on debug logging to print debug message generated by AWS SAM CLI and display timestamps. --config-file TEXT Configuration file containing default parameter values. [default: samconfig.toml] --config-env TEXT Environment name specifying default parameter values in the configuration file. [default: default] -h, --help Show this message and exit. ``` 1. Utilisez l'une de ces options à l'invite de commande pour modifier votre exemple de charge utile d'événement. Voici un exemple : ``` $ sam local generate-event s3 put--bucket sam-s3-demo-bucket { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` ## Utiliser les événements générés pour les tests locaux Enregistrez les événements générés localement et utilisez d'autres sous-commandes `sam local` pour les tester. **Pour enregistrer vos événements générés localement** + Exécutez les commandes suivantes : ``` $ sam local generate-event > ``` Voici un exemple d'événement enregistré sous forme de fichier `s3.json` dans le dossier `events` de notre projet. ``` sam-app$ sam local generate-event s3 put --bucket amzn-s3-demo-bucket > events/s3.json ``` **Pour utiliser un événement généré pour des tests locaux** + Transmettez l'événement avec d'autres sous-commandes `sam local` à l'aide de l'option `--event`. Voici un exemple d'utilisation de l'événement `s3.json` pour appeler notre fonction Lambda localement : ``` sam-app$ sam local invoke --event events/s3.json S3JsonLoggerFunction Invoking src/handlers/s3-json-logger.s3JsonLoggerHandler (nodejs18.x) Local image is up-to-date Using local image: public.ecr.aws/lambda/nodejs:18-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/S3JsonLoggerFunction as /var/task:ro,delegated, inside runtime container START RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Version: $LATEST END RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 REPORT RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Init Duration: 1.23 ms Duration: 9371.93 ms Billed Duration: 9372 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` ## En savoir plus Pour obtenir la liste de toutes les options `sam local generate-event`, consultez [sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Pour une démonstration de l'utilisation de `sam local`, consultez [AWS SAM pour le développement local. Tester AWS Cloud des ressources issues d'environnements de développement locaux](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) dans le cadre de la *série Serverless Land Sessions with SAM on YouTube*. # Présentation des tests avec sam local invoke Utilisez la AWS Serverless Application Model `sam local invoke` sous-commande Command Line Interface (AWS SAMCLI) pour lancer un appel unique d'une AWS Lambda fonction localement. + Pour une introduction à la AWS SAMCLI, voir [Qu'est-ce que c'est AWS SAMCLI ?](what-is-sam-overview.md#what-is-sam-cli) + Pour obtenir la liste des options de commande `sam local invoke`, consultez [sam local invoke](sam-cli-command-reference-sam-local-invoke.md). + Pour un exemple d'utilisation de `sam local invoke` dans le cadre d'un flux de travail de développement classique, consultez [Étape 7 : (Facultatif) testez votre application localement](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **Note** Il n'est pas recommandé d'utiliser les fonctionnalités d'appel local de la SAM CLI dans du code non fiable. Pour vous isoler complètement de votre environnement local, exécutez le code directement dans le service Lambda. **Note** `sam local invoke`prend en charge des fonctions durables avec des fonctionnalités de point de contrôle et de rediffusion automatiques. Lorsque des fonctions durables sont invoquées localement, l'état d'exécution est automatiquement géré. ## Conditions préalables Pour utiliser `sam local invoke`, installez la CLI AWS SAM en procédant comme suit : + [AWS SAM prérequis](prerequisites.md). + [Installer la CLI  AWS SAM](install-sam-cli.md). Avant d'utiliser `sam local invoke`, nous vous recommandons d'avoir des connaissances de base sur les points suivants : + [Configuration de la CLI  AWS SAM](using-sam-cli-configure.md). + [Créez votre application dans AWS SAM](using-sam-cli-init.md). + [Initiation à la construction avec AWS SAM](using-sam-cli-build.md). + [Présentation du déploiement avec AWS SAM](using-sam-cli-deploy.md). ## Appel d'une fonction Lambda localement Lorsque vous utilisez `sam local invoke`, la CLI AWS SAM suppose que le répertoire de travail actuel est le répertoire racine du projet. La CLI AWS SAM recherche d'abord un fichier `template.[yaml|yml]` dans un sous-dossier `.aws-sam`. Si elle ne le trouve pas, la CLI AWS SAM recherche un fichier `template.[yaml|yml]` dans votre répertoire de travail actuel. **Pour appeler une fonction Lambda localement** 1. À partir du répertoire racine de votre projet, effectuez les actions suivantes : ``` $ sam local invoke ``` 1. Si votre application contient plusieurs fonctions, indiquez l'identifiant logique de la fonction. Voici un exemple : ``` $ sam local invoke HelloWorldFunction ``` 1. La CLI  AWS SAM crée votre fonction dans un conteneur local à l'aide de Docker. Elle invoque ensuite votre fonction et génère la réponse de votre fonction. Voici un exemple : ``` $ sam local invoke Invoking app.lambda_handler (python3.9) Local image is out of date and will be updated to the latest runtime. To skip this, pass in the parameter --skip-pull-image Building image.................................................................................................................... Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Version: $LATEST END RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df REPORT RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Init Duration: 1.09 ms Duration: 608.42 ms Billed Duration: 609 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"hello world\"}"}% ``` ### Gestion des journaux Lorsque vous utilisez `sam local invoke`, le résultat d'exécution de la fonction Lambda (par exemple, les journaux) sort vers `stderr` et le résultat de la fonction Lambda sors vers `stdout`. Voici un exemple de fonction Lambda de base : ``` def handler(event, context): print("some log") # this goes to stderr return "hello world" # this goes to stdout ``` Vous pouvez enregistrer ces résultats standard. Voici un exemple : ``` $ sam local invoke 1> stdout.log ... $ cat stdout.log "hello world" $ sam local invoke 2> stderr.log ... $ cat stderr.log Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Version: $LATEST some log END RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 REPORT RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Init Duration: 0.91 ms Duration: 589.19 ms Billed Duration: 590 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` Vous pouvez utiliser ces résultats standard pour automatiser davantage vos processus de développement locaux. ## Options ### Transmettez des événements personnalisés pour appeler la fonction Lambda Pour transmettre un événement à la fonction Lambda, utilisez l'option `--event`. Voici un exemple : ``` $ sam local invoke --event events/s3.json S3JsonLoggerFunction ``` Vous pouvez créer des événements à l'aide de la sous-commande `sam local generate-event`. Pour en savoir plus, veuillez consulter la section [Présentation des tests avec sam local generate-event](using-sam-cli-local-generate-event.md). ### Transmettre des variables d'environnement lors de l'appel de votre fonction Lambda Si votre fonction Lambda utilise des variables d'environnement, vous pouvez les transmettre lors des tests locaux à l'aide de l'option `--env-vars`. C'est un excellent moyen de tester une fonction Lambda localement avec des services de votre application déjà déployés dans le cloud. Voici un exemple : ``` $ sam local invoke --env-vars locals.json ``` ### Spécifier un modèle ou une fonction Pour spécifier un modèle à référencer par la CLI AWS SAM, utilisez l'option `--template`. Ils AWS SAMCLI chargeront uniquement ce AWS SAM modèle et les ressources vers lesquelles il pointe. Pour appeler une fonction d'une application ou d'une pile imbriquée, fournissez l'identifiant logique de l'application ou de la pile avec l'identifiant logique. Voici un exemple : ``` $ sam local invoke StackLogicalId/FunctionLogicalId ``` ### Tester une fonction Lambda à partir de votre projet Terraform Utilisez l'option `--hook-name` pour tester localement les fonctions Lambda de vos projets Terraform. Pour en savoir plus, veuillez consulter la section [Utilisation de la CLI  AWS SAM avec Terraform pour le débogage et les tests locaux](using-samcli-terraform.md). Voici un exemple : ``` $ sam local invoke --hook-name terraform --beta-features ``` ## Bonnes pratiques Si votre application possède un répertoire `.aws-sam` qui exécute `sam build`, assurez-vous d'exécuter `sam build` chaque fois que vous mettez à jour le code de votre fonction. Exécutez ensuite `sam local invoke` pour tester localement votre code de fonction mis à jour. Les tests locaux constituent une excellente solution pour un développement et des tests rapides avant le déploiement dans le cloud. Toutefois, les tests locaux ne valident pas tout, notamment les autorisations entre vos ressources dans le cloud. Dans la mesure du possible, testez vos applications dans le cloud. Nous vous recommandons d'[utiliser `sam sync`](using-sam-cli-sync.md) pour accélérer vos flux de travail de test dans le cloud. ## Exemples ### Générer un exemple d'événement Amazon API Gateway et l'utiliser pour appeler une fonction Lambda localement Tout d'abord, nous générons une charge utile d'événement API HTTP API Gateway et l'enregistrons dans notre dossier `events`. ``` $ sam local generate-event apigateway http-api-proxy > events/apigateway_event.json ``` Ensuite, nous modifions notre fonction Lambda pour qu'elle renvoie une valeur de paramètre à partir de l'événement. ``` def lambda_handler(event, context): print("HelloWorldFunction invoked") return { "statusCode": 200, "body": json.dumps({ "message": event['queryStringParameters']['parameter2'], }), } ``` Ensuite, nous invoquons localement notre fonction Lambda et fournissons notre événement personnalisé. ``` $ sam local invoke --event events/apigateway_event.json Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"value\"}"}% ``` ### Transmettre des variables d'environnement lors de l'appel d'une fonction Lambda localement Cette application possède une fonction Lambda qui utilise une variable d'environnement pour un nom de table Amazon DynamoDB. Voici un exemple de la fonction définie dans le AWS SAM modèle : ``` AWSTemplateFormatVersion: 2010-09-09 Transform: AWS::Serverless-2016-10-31 ... Resources: getAllItemsFunction: Type: AWS::Serverless::Function Properties: Handler: src/get-all-items.getAllItemsHandler Description: get all items Policies: - DynamoDBReadPolicy: TableName: !Ref SampleTable Environment: Variables: SAMPLE_TABLE: !Ref SampleTable ... ``` Nous souhaitons tester localement notre fonction Lambda tout en la faisant interagir avec notre table DynamoDB dans le cloud. Pour ce faire, nous créons notre fichier de variables d'environnement et l'enregistrons dans le répertoire racine de notre projet sous le nom `locals.json`. La valeur fournie ici pour `SAMPLE_TABLE` fait référence à notre table DynamoDB dans le cloud. ``` { "getAllItemsFunction": { "SAMPLE_TABLE": "dev-demo-SampleTable-1U991234LD5UM98" } } ``` Ensuite, nous exécutons `sam local invoke` et transmettons nos variables d'environnement avec l'option `--env-vars`. ``` $ sam local invoke getAllItemsFunction --env-vars locals.json Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode":200,"body":"{}"} ``` ## En savoir plus Pour obtenir la liste de toutes les options `sam local invoke`, consultez [sam local invoke](sam-cli-command-reference-sam-local-invoke.md). Pour une démonstration de l'utilisation de `sam local`, consultez [AWS SAM pour le développement local. Tester AWS Cloud des ressources issues d'environnements de développement locaux](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) dans le cadre de la *série Serverless Land Sessions with SAM on YouTube*. # Présentation des tests avec sam local start-api Utilisez la AWS Serverless Application Model `sam local start-api` sous-commande Command Line Interface (AWS SAMCLI) pour exécuter vos AWS Lambda fonctions localement et les tester via un hôte de serveur HTTP local. Ce type de test est utile pour les fonctions Lambda qui sont appelées par un point de terminaison Amazon API Gateway. + Pour une introduction à la AWS SAMCLI, voir [Qu'est-ce que c'est AWS SAMCLI ?](what-is-sam-overview.md#what-is-sam-cli) + Pour obtenir la liste des options de commande `sam local start-api`, consultez [sam local start-api](sam-cli-command-reference-sam-local-start-api.md). + Pour un exemple d'utilisation de `sam local start-api` dans le cadre d'un flux de travail de développement classique, consultez [Étape 7 : (Facultatif) testez votre application localement](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **Note** `sam local start-api`prend en charge des fonctions durables avec des fonctionnalités de point de contrôle et de rediffusion automatiques. Les fonctions durables fonctionnent parfaitement avec le point de terminaison API Gateway local. ## Conditions préalables Pour utiliser `sam local start-api`, installez la CLI AWS SAM en procédant comme suit : + [AWS SAM prérequis](prerequisites.md). + [Installer la CLI  AWS SAM](install-sam-cli.md). Avant d'utiliser `sam local start-api`, nous vous recommandons d'avoir des connaissances de base sur les points suivants : + [Configuration de la CLI  AWS SAM](using-sam-cli-configure.md). + [Créez votre application dans AWS SAM](using-sam-cli-init.md). + [Initiation à la construction avec AWS SAM](using-sam-cli-build.md). + [Présentation du déploiement avec AWS SAM](using-sam-cli-deploy.md). ## Utilisation de sam local start-api Lorsque vous utilisez `sam local start-api`, la CLI AWS SAM suppose que le répertoire de travail actuel est le répertoire racine du projet. La CLI AWS SAM recherche d'abord un fichier `template.[yaml|yml]` dans un sous-dossier `.aws-sam`. Si elle ne le trouve pas, la CLI AWS SAM recherche un fichier `template.[yaml|yml]` dans votre répertoire de travail actuel. **Pour démarrer un serveur HTTP local** 1. À partir du répertoire racine de votre projet, effectuez les actions suivantes : ``` $ sam local start-api ``` 1. La CLI AWS SAM crée vos fonctions Lambda dans un conteneur Docker local. Elle affiche ensuite l'adresse locale du point de terminaison de votre serveur HTTP. Voici un exemple : ``` $ sam local start-api Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-12 14:41:05 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 ``` 1. Vous pouvez appeler votre fonction Lambda via le navigateur ou l'invite de commande. Voici un exemple : ``` sam-app$ curl http://127.0.0.1:3000/hello {"message": "Hello world!"}% ``` 1. Lorsque vous modifiez le code de votre fonction Lambda, tenez compte des points suivants pour actualiser votre serveur HTTP local : + Si votre application ne possède pas de répertoire `.aws-sam` et que votre fonction utilise un langage interprété, la CLI  AWS SAM met automatiquement à jour votre fonction en créant un nouveau conteneur et en l'hébergeant. + Si votre application possède un répertoire `.aws-sam`, vous devez exécuter `sam build` pour mettre à jour votre fonction. Exécutez ensuite à nouveau `sam local start-api` pour héberger la fonction. + Si votre fonction utilise un langage compilé ou si votre projet nécessite une prise en charge complexe d'empaquetage, exécutez votre propre solution de création pour mettre à jour votre fonction. Exécutez ensuite à nouveau `sam local start-api` pour héberger la fonction. ### Fonctions Lambda qui utilisent des mécanismes d'autorisation Lambda **Note** Cette fonctionnalité est nouvelle dans la version 1.80.0 de la CLI  AWS SAM. Pour effectuer une mise à niveau, consultez [Mise à niveau de la CLI  AWS SAM en cours](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Pour les fonctions Lambda qui utilisent des mécanismes d'autorisation Lambda, la CLI  AWS SAM invoquera automatiquement votre mécanisme d'autorisation Lambda avant d'appeler le point de terminaison de votre fonction Lambda. Voici un exemple de démarrage d'un serveur HTTP local pour une fonction qui utilise un mécanisme d'autorisation Lambda : ``` $ sam local start-api 2023-04-17 15:02:13 Attaching import module proxy for analyzing dynamic imports AWS SAM CLI does not guarantee 100% fidelity between authorizers locally and authorizers deployed on AWS. Any application critical behavior should be validated thoroughly before deploying to production. Testing application behaviour against authorizers deployed on AWS can be done using the sam sync command. Mounting HelloWorldFunction at http://127.0.0.1:3000/authorized-request [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-17 15:02:13 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 2023-04-17 15:02:13 Press CTRL+C to quit ``` Lorsque vous invoquez le point de terminaison de votre fonction Lambda via le serveur HTTP local, la CLI  AWS SAM invoque d'abord votre mécanisme d'autorisation Lambda. Si l'autorisation est réussie, la CLI  AWS SAM invoquera le point de terminaison de votre fonction Lambda. Voici un exemple : ``` $ curl http://127.0.0.1:3000/authorized-request --header "header:my_token" {"message": "from authorizer"}% Invoking app.authorizer_handler (python3.8) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Version: $LATEST END RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 REPORT RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Init Duration: 1.08 ms Duration: 628.26 msBilled Duration: 629 ms Memory Size: 128 MB Max Memory Used: 128 MB Invoking app.request_handler (python3.8) Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Version: $LATEST END RequestId: fdc12255-79a3-4365-97e9-9459d06446ff REPORT RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Init Duration: 0.95 ms Duration: 659.13 msBilled Duration: 660 ms Memory Size: 128 MB Max Memory Used: 128 MB No Content-Type given. Defaulting to 'application/json'. 2023-04-17 15:03:03 127.0.0.1 - - [17/Apr/2023 15:03:03] "GET /authorized-request HTTP/1.1" 200 - ``` ## Options ### Réutiliser en permanence les conteneurs pour accélérer les appels de fonctions locales Par défaut, la CLI  AWS SAM crée un nouveau conteneur chaque fois que votre fonction est invoquée via le serveur HTTP local. Utilisez l'option `--warm-containers` pour réutiliser automatiquement votre conteneur pour les appels de fonctions. Cela accélère le temps nécessaire à la CLI  AWS SAM pour préparer votre fonction Lambda pour l'invocation locale. Vous pouvez personnaliser davantage cette option en fournissant l'argument `eager` ou `lazy`. + `eager` : les conteneurs pour toutes les fonctions sont chargés au démarrage et persistent entre les appels. + `lazy` : les conteneurs ne sont chargés que lorsque chaque fonction est appelée pour la première fois. Ils persistent ensuite pour des appels supplémentaires. Voici un exemple : ``` $ sam local start-api --warm-containers eager ``` Lorsque vous utilisez `--warm-containers` et modifiez le code de votre fonction Lambda : + Si votre application dispose d'un répertoire `.aws-sam`, exécutez `sam build` pour mettre à jour le code de votre code de fonction dans les artefacts de création de votre application. + Lorsqu'une modification de code est détectée, la CLI  AWS SAM arrête automatiquement le conteneur de fonctions Lambda. + Lorsque vous invoquez à nouveau la fonction, la CLI  AWS SAM crée automatiquement un nouveau conteneur. ### Spécifier une image de conteneur à utiliser pour vos fonctions Lambda Par défaut, la CLI  AWS SAM utilise les images de base Lambda provenant d'Amazon Elastic Container Registry (Amazon ECR) pour invoquer vos fonctions localement. Utilisez l'option `--invoke-image` pour référencer une image de conteneur personnalisée. Voici un exemple : ``` $ sam local start-api --invoke-image public.ecr.aws/sam/emu-python3.8 ``` Vous pouvez spécifier la fonction à utiliser avec l'image de conteneur personnalisée. Voici un exemple : ``` $ sam local start-api --invoke-image Function1=amazon/aws/sam-cli-emulation-image-python3.8 ``` ### Spécifier un modèle à tester localement Pour spécifier un modèle à référencer par la CLI AWS SAM, utilisez l'option `--template`. Ils AWS SAMCLI chargeront uniquement ce AWS SAM modèle et les ressources vers lesquelles il pointe. Voici un exemple : ``` $ sam local start-api --template myTemplate.yaml ``` ### Spécifier l'environnement de développement hôte de votre fonction Lambda Par défaut, la sous-commande `sam local start-api` crée un serveur HTTP utilisant `localhost` avec l'adresse IP `127.0.0.1`. Vous pouvez personnaliser ces valeurs si votre environnement de développement local est isolé de votre ordinateur local. Utilisez l'option `--container-host` pour spécifier un hôte. Voici un exemple : ``` $ sam local start-api --container-host host.docker.internal ``` Utilisez l'option `--container-host-interface` pour spécifier l'adresse IP du réseau hôte à laquelle les ports de conteneur doivent se relier. Voici un exemple : ``` $ sam local start-api --container-host-interface 0.0.0.0 ``` ## Bonnes pratiques Si votre application possède un répertoire `.aws-sam` qui exécute `sam build`, assurez-vous d'exécuter `sam build` chaque fois que vous mettez à jour le code de votre fonction. Exécutez ensuite `sam local start-api` pour tester localement votre code de fonction mis à jour. Les tests locaux constituent une excellente solution pour un développement et des tests rapides avant le déploiement dans le cloud. Toutefois, les tests locaux ne valident pas tout, notamment les autorisations entre vos ressources dans le cloud. Dans la mesure du possible, testez vos applications dans le cloud. Nous vous recommandons d'[utiliser `sam sync`](using-sam-cli-sync.md) pour accélérer vos flux de travail de test dans le cloud. ## En savoir plus Pour obtenir la liste de toutes les options `sam local start-api`, consultez [sam local start-api](sam-cli-command-reference-sam-local-start-api.md). # Présentation des tests avec sam local start-lambda Utilisez la AWS SAMCLI sous-commande `sam local start-lambda` pour appeler votre fonction Lambda via AWS CLI le et. SDKs Cette commande démarre un point de terminaison local qui émule Lambda. + Pour une introduction à la AWS SAMCLI, voir [Qu'est-ce que c'est AWS SAMCLI ?](what-is-sam-overview.md#what-is-sam-cli) + Pour obtenir la liste des options de commande `sam local start-lambda`, consultez [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md). **Note** `sam local start-lambda`prend en charge des fonctions durables avec des fonctionnalités de point de contrôle et de rediffusion automatiques. Les fonctions durables fonctionnent parfaitement avec le point de terminaison Lambda local. ## Conditions préalables Pour utiliser `sam local start-lambda`, installez la CLI AWS SAM en procédant comme suit : + [AWS SAM prérequis](prerequisites.md). + [Installer la CLI  AWS SAM](install-sam-cli.md). Avant d'utiliser `sam local start-lambda`, nous vous recommandons d'avoir des connaissances de base sur les points suivants : + [Configuration de la CLI  AWS SAM](using-sam-cli-configure.md). + [Créez votre application dans AWS SAM](using-sam-cli-init.md). + [Initiation à la construction avec AWS SAM](using-sam-cli-build.md). + [Présentation du déploiement avec AWS SAM](using-sam-cli-deploy.md). ## Utilisation de sam local start-lambda Lorsque vous utilisez `sam local start-lambda`, la CLI AWS SAM suppose que le répertoire de travail actuel est le répertoire racine du projet. La CLI AWS SAM recherche d'abord un fichier `template.[yaml|yml]` dans un sous-dossier `.aws-sam`. Si elle ne le trouve pas, la CLI AWS SAM recherche un fichier `template.[yaml|yml]` dans votre répertoire de travail actuel. **Pour utiliser sam local start-lambda** 1. À partir du répertoire racine de votre projet, effectuez les actions suivantes : ``` $ sam local start-lambda ``` 1. La CLI AWS SAM crée vos fonctions Lambda dans un conteneur Docker local. Elle transmet ensuite l'adresse locale au point de terminaison de votre serveur HTTP. Voici un exemple : ``` $ sam local start-lambda Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/hello_world as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Starting the Local Lambda Service. You can now invoke your Lambda Functions defined in your template through the endpoint. 2023-04-13 07:25:43 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3001 2023-04-13 07:25:43 Press CTRL+C to quit ``` 1. Utilisez le AWS CLI ou SDKs pour appeler votre fonction Lambda localement. Voici un exemple avec utilisation de la AWS CLI : ``` $ aws lambda invoke --function-name "HelloWorldFunction" --endpoint-url "http://127.0.0.1:3001" --no-verify-ssl out.txt StatusCode: 200 (END) ``` Voici un exemple d'utilisation du AWS SDK for Python : ``` import boto3 from botocore.config import Config from botocore import UNSIGNED lambda_client = boto3.client('lambda', endpoint_url="http://127.0.0.1:3001", use_ssl=False, verify=False, config=Config(signature_version=UNSIGNED, read_timeout=1, retries={'max_attempts': 0} ) ) lambda_client.invoke(FunctionName="HelloWorldFunction") ``` ## Options ### Spécifier un modèle Pour spécifier un modèle à référencer par la CLI AWS SAM, utilisez l'option `--template`. Ils AWS SAMCLI chargeront uniquement ce AWS SAM modèle et les ressources vers lesquelles il pointe. Voici un exemple : ``` $ sam local start-lambda --template myTemplate.yaml ``` Pour plus d'informations sur les AWS SAM modèles, consultez[AWS SAM anatomie du modèle](sam-specification-template-anatomy.md). ## Bonnes pratiques Si votre application possède un répertoire `.aws-sam` qui exécute `sam build`, assurez-vous d'exécuter `sam build` chaque fois que vous mettez à jour le code de votre fonction. Exécutez ensuite `sam local start-lambda` pour tester localement votre code de fonction mis à jour. Les tests locaux constituent une excellente solution pour un développement et des tests rapides avant le déploiement dans le cloud. Toutefois, les tests locaux ne valident pas tout, notamment les autorisations entre vos ressources dans le cloud. Dans la mesure du possible, testez vos applications dans le cloud. Nous vous recommandons d'[utiliser `sam sync`](using-sam-cli-sync.md) pour accélérer vos flux de travail de test dans le cloud. ## En savoir plus Pour obtenir la liste de toutes les options `sam local start-lambda`, consultez [sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md).