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.
# Création de fonctions Lambda avec PowerShell
Les sections suivantes expliquent comment les modèles de programmation courants et les concepts de base s'appliquent lorsque vous créez du code de fonction Lambda dans. PowerShell
Lambda fournit les exemples d'applications suivants pour : PowerShell
+ [blank-powershell](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-powershell) — PowerShell Fonction qui montre l'utilisation de la journalisation, des variables d'environnement et du SDK. AWS
Avant de commencer, vous devez d'abord configurer un environnement PowerShell de développement. Pour obtenir des instructions sur la façon de procéder, veuillez consulter [Configuration d’un environnement de développement PowerShell](powershell-devenv.md).
Pour savoir comment utiliser le AWSLambda PSCore module pour télécharger des exemples de PowerShell projets à partir de modèles, créer des packages de PowerShell déploiement et déployer PowerShell des fonctions AWS dans le cloud, consultez[Déployer des fonctions Lambda PowerShell avec des archives de fichiers .zip](powershell-package.md).
Lambda fournit les exécutions suivantes pour les langages .NET :
| Name | Identifiant | Système d’exploitation | Date d’obsolescence | Créer la fonction de blocage | Mettre à jour la fonction de blocage |
| --- | --- | --- | --- | --- | --- |
| .NET 10 | `dotnet10` | Amazon Linux 2023 | 14 novembre 2028 | 14 déc. 2028 | 15 janvier 2029 |
| .NET 9 (conteneur uniquement) | `dotnet9` | Amazon Linux 2023 | 10 novembre 2026 | Non planifié | Non planifié |
| .NET 8 | `dotnet8` | Amazon Linux 2023 | 10 novembre 2026 | 10 déc. 2026 | 11 janvier 2027 |
**Topics**
+ [Configuration d’un environnement de développement PowerShell](powershell-devenv.md)
+ [Déployer des fonctions Lambda PowerShell avec des archives de fichiers .zip](powershell-package.md)
+ [Définition du gestionnaire de fonction Lambda dans PowerShell](powershell-handler.md)
+ [Utilisation de l’objet de contexte Lambda pour récupérer les informations de la fonction PowerShell](powershell-context.md)
+ [Journalisation et surveillance des fonctions Lambda Powershell](powershell-logging.md)
# Configuration d’un environnement de développement PowerShell
Lambda fournit un ensemble d’outils et de bibliothèques pour l’environnement d’exécution PowerShell. Pour obtenir des instructions d’installation, consultez [Outils Lambda pour PowerShell](https://github.com/aws/aws-lambda-dotnet/tree/master/PowerShell) sur GitHub.
Le module AWSLambdaPSCore inclut les cmdlets suivantes pour vous aider à créer et publier des fonctions Lambda PowerShell.
+ **Get-AWSPowerShellLambdaTemplate** – Renvoie une liste de modèles de mise en route.
+ **New-AWSPowerShellLambda** – Crée un script PowerShell basé sur un modèle.
+ **Publish-AWSPowerShellLambda** – Publie un script PowerShell donné pour Lambda.
+ **New-AWSPowerShellLambdaPackage** – Crée un package de déploiement Lambda que vous pouvez utiliser dans un système de CI/CD pour le déploiement.
# Déployer des fonctions Lambda PowerShell avec des archives de fichiers .zip
Un package de déploiement pour le runtime PowerShell contient votre script PowerShell, les modules PowerShell requis pour votre script PowerShell, ainsi que les assemblies nécessaires pour héberger PowerShell Core.
## Création de la fonction Lambda
Pour commencer à écrire et appeler un script PowerShell avec Lambda, vous pouvez utiliser la cmdlet `New-AWSPowerShellLambda` pour créer un script de démarrage basé sur un modèle. Vous pouvez utiliser la cmdlet `Publish-AWSPowerShellLambda` pour déployer votre script vers Lambda. Ensuite, vous pouvez tester votre script via la ligne de commande ou la console Lambda.
Pour créer un nouveau script PowerShell, le charger et le tester, procédez aux étapes suivantes :
1. Pour afficher la liste des modèles disponibles, exécutez la commande suivante :
```
PS C:\> Get-AWSPowerShellLambdaTemplate
Template Description
-------- -----------
Basic Bare bones script
CodeCommitTrigger Script to process AWS CodeCommit Triggers
...
```
1. Pour créer un exemple de script basé sur le modèle `Basic`, exécutez la commande suivante :
```
New-AWSPowerShellLambda -ScriptName MyFirstPSScript -Template Basic
```
Un nouveau fichier nommé `MyFirstPSScript.ps1` est créé dans un nouveau sous-répertoire du répertoire actuel. Le nom de ce répertoire est basé sur le paramètre `-ScriptName`. Vous pouvez utiliser le paramètre `-Directory` pour choisir un autre répertoire.
Vous pouvez voir que le nouveau fichier a le contenu suivant :
```
# PowerShell script file to run as a Lambda function
#
# When executing in Lambda the following variables are predefined.
# $LambdaInput - A PSObject that contains the Lambda function input data.
# $LambdaContext - An Amazon.Lambda.Core.ILambdaContext object that contains information about the currently running Lambda environment.
#
# The last item in the PowerShell pipeline is returned as the result of the Lambda function.
#
# To include PowerShell modules with your Lambda function, like the AWSPowerShell.NetCore module, add a "#Requires" statement
# indicating the module and version.
#Requires -Modules @{ModuleName='AWSPowerShell.NetCore';ModuleVersion='3.3.618.0'}
# Uncomment to send the input to CloudWatch Logs
# Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 5)
```
1. Pour voir comment les messages du journal de votre script PowerShell sont envoyés à Amazon CloudWatch Logs, supprimez le commentaire de la ligne `Write-Host` de l'exemple de script.
Pour illustrer comment renvoyer des données à partir de vos fonctions Lambda, ajoutez une ligne à la fin du script avec `$PSVersionTable`. Cela ajoute `$PSVersionTable` dans le pipeline PowerShell. Une fois l'exécution du script PowerShell terminée, le dernier objet figurant dans le pipeline PowerShell correspond aux données de retour de la fonction Lambda. `$PSVersionTable` est une variable globale PowerShell qui fournit également des informations sur l'environnement d'exécution.
Après avoir effectué ces modifications, les deux dernières lignes de l'exemple de script ressemblent à ce qui suit :
```
Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 5)
$PSVersionTable
```
1. Après avoir modifié le fichier `MyFirstPSScript.ps1`, modifiez le répertoire en spécifiant l'emplacement du script. Exécutez ensuite la commande suivante pour publier le script dans Lambda :
```
Publish-AWSPowerShellLambda -ScriptPath .\MyFirstPSScript.ps1 -Name MyFirstPSScript -Region us-east-2
```
Notez que le paramètre `-Name` spécifie le nom de la fonction Lambda qui s'affiche dans la console Lambda. Vous pouvez utiliser cette fonction pour appeler manuellement votre script.
1. Appelez votre fonction à l'aide de la commande AWS Command Line Interface (AWS CLI) `invoke`.
```
> aws lambda invoke --function-name MyFirstPSScript out
```
# Définition du gestionnaire de fonction Lambda dans PowerShell
Lors de l'appel d'une fonction Lambda, le gestionnaire Lambda appelle le script PowerShell.
Lorsque le script PowerShell est appelé, les variables suivantes sont prédéfinies :
+ *\$1LambdaInput* – Objet PSObject contenant l'entrée pour le gestionnaire. Ces données d'entrée peuvent être des données d'événement (publiées par une source d'événement) ou des données d'entrée personnalisées que vous fournissez, telles qu'une chaîne ou n'importe quel objet de données personnalisé.
+ *\$1LambdaContext* – Objet Amazon.Lambda.Core.ILambdaContext qui vous permet d'accéder à des informations sur l'appel en cours, comme le nom de la fonction en cours d'exécution, la limite de mémoire, le temps d'exécution restant et la journalisation.
Prenons l'exemple de code PowerShell suivant.
```
#Requires -Modules @{ModuleName='AWSPowerShell.NetCore';ModuleVersion='3.3.618.0'}
Write-Host 'Function Name:' $LambdaContext.FunctionName
```
Ce script renvoie la propriété FunctionName qui est obtenue à partir de la variable \$1LambdaContext.
**Note**
Vous êtes tenu d'utiliser l'instruction `#Requires` dans vos scripts PowerShell pour indiquer les modules dont vos scripts dépendent. Cette instruction effectue deux tâches importantes. 1) Elle communique aux autres développeurs les modules que le script utilise, et 2) elle identifie les modules dépendants que les outils AWS PowerShell doivent mettre en package avec le script, dans le cadre du déploiement. Pour plus d'informations sur l'instruction `#Requires` dans PowerShell, consultez [About Requires (À propos de Requires)](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_requires?view=powershell-6). Pour de plus amples informations sur les packages de déploiement PowerShell, veuillez consulter [Déployer des fonctions Lambda PowerShell avec des archives de fichiers .zip](powershell-package.md).
Lorsque votre fonction Lambda PowerShell utilise les cmdlets AWS PowerShell, veillez à définir une instruction `#Requires` faisant référence au module `AWSPowerShell.NetCore` qui prend en charge PowerShell Core, et non au module `AWSPowerShell` qui prend en charge uniquement Windows PowerShell. De plus, veillez à utiliser la version 3.3.270.0 ou plus récente de `AWSPowerShell.NetCore`, qui optimise le processus d'importation d'applet de commande. Si vous utilisez une version plus ancienne, vous connaîtrez des démarrages à froid plus longs. Pour plus d'informations, consultez [Tools for PowerShell AWS](https://aws.amazon.com/powershell/?track=sdk).
## Renvoi de données
Certains appels Lambda sont destinés à renvoyer des données à leur appelant. Par exemple, si un appel répond à une demande web provenant d'API Gateway, notre fonction Lambda doit renvoyer la réponse. Pour PowerShell Lambda, le dernier objet ajouté dans le pipeline PowerShell correspond aux données de retour de l'appel Lambda. Si l'objet est une chaîne, les données sont renvoyées en l'état. Dans le cas contraire, l'objet est converti en données JSON à l'aide de l'applet de commande `ConvertTo-Json`.
Par exemple, prenez en considération l'instruction PowerShell suivante, qui ajoute `$PSVersionTable` dans le pipeline PowerShell :
```
$PSVersionTable
```
Une fois le script PowerShell terminé, le dernier objet figurant dans le pipeline PowerShell correspond aux données de retour de la fonction Lambda. `$PSVersionTable` est une variable globale PowerShell qui fournit également des informations sur l'environnement d'exécution.
# Utilisation de l’objet de contexte Lambda pour récupérer les informations de la fonction PowerShell
Lorsque Lambda exécute votre fonction, il transmet les informations de contexte en mettant une variable `$LambdaContext` à la disposition du [gestionnaire](powershell-handler.md). Cette variable fournit des méthodes et des propriétés avec des informations sur l'appel, la fonction et l'environnement d'exécution.
**Propriétés du contexte**
+ `FunctionName` – Nom de la fonction Lambda.
+ `FunctionVersion` – [Version](configuration-versions.md) de la fonction.
+ `InvokedFunctionArn` – Amazon Resource Name (ARN) utilisé pour appeler la fonction. Indique si l’appelant a spécifié un numéro de version ou un alias.
+ `MemoryLimitInMB` – Quantité de mémoire allouée à la fonction.
+ `AwsRequestId` – Identifiant de la demande d’invocation.
+ `LogGroupName` – Groupe de journaux pour la fonction.
+ `LogStreamName` – Flux de journal de l'instance de fonction.
+ `RemainingTime` – Nombre de millisecondes restant avant l'expiration de l'exécution.
+ `Identity` – (applications mobiles) Informations sur l'identité Amazon Cognito qui a autorisé la demande.
+ `ClientContext` – (applications mobiles) Contexte client fourni à Lambda par l'application client.
+ `Logger` – [Objet enregistreur](powershell-logging.md) pour la fonction.
L'extrait de code PowerShell suivant illustre une fonction simple de gestionnaire qui affiche certaines informations de contexte.
```
#Requires -Modules @{ModuleName='AWSPowerShell.NetCore';ModuleVersion='3.3.618.0'}
Write-Host 'Function name:' $LambdaContext.FunctionName
Write-Host 'Remaining milliseconds:' $LambdaContext.RemainingTime.TotalMilliseconds
Write-Host 'Log group name:' $LambdaContext.LogGroupName
Write-Host 'Log stream name:' $LambdaContext.LogStreamName
```
# Journalisation et surveillance des fonctions Lambda Powershell
AWS Lambda surveille automatiquement les fonctions Lambda en votre nom et envoie les journaux à Amazon. CloudWatch Votre fonction Lambda est fournie avec un groupe de CloudWatch journaux Logs et un flux de journaux pour chaque instance de votre fonction. L’environnement d’exécution Lambda envoie des informations sur chaque invocation au flux de journaux et transmet les journaux et autres sorties provenant du code de votre fonction. Pour de plus amples informations, veuillez consulter [Envoi automatique des journaux de la fonction Lambda à CloudWatch Logs](monitoring-cloudwatchlogs.md).
Cette page explique comment générer une sortie de journal à partir du code de votre fonction Lambda et comment accéder aux journaux à l'aide de la AWS Command Line Interface console Lambda ou de la console. CloudWatch
**Topics**
+ [Création d’une fonction qui renvoie des journaux](#powershell-logging-output)
+ [Affichage des journaux dans la console Lambda](#powershell-logging-console)
+ [Afficher les journaux dans la CloudWatch console](#powershell-logging-cwconsole)
+ [Afficher les journaux à l'aide de AWS Command Line Interface (AWS CLI)](#powershell-logging-cli)
+ [Suppression de journaux](#powershell-logging-delete)
## Création d’une fonction qui renvoie des journaux
[Pour générer des journaux à partir de votre code de fonction, vous pouvez utiliser des applets de commande sur Microsoft. PowerShell.Utility](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility), ou tout module de journalisation qui écrit dans `stdout` ou`stderr`. L’exemple suivant utilise `Write-Host`.
**Example [function/Handler.ps1](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-powershell/function/Handler.ps1) – Journalisation**
```
#Requires -Modules @{ModuleName='AWSPowerShell.NetCore';ModuleVersion='3.3.618.0'}
Write-Host `## Environment variables
Write-Host AWS_LAMBDA_FUNCTION_VERSION=$Env:AWS_LAMBDA_FUNCTION_VERSION
Write-Host AWS_LAMBDA_LOG_GROUP_NAME=$Env:AWS_LAMBDA_LOG_GROUP_NAME
Write-Host AWS_LAMBDA_LOG_STREAM_NAME=$Env:AWS_LAMBDA_LOG_STREAM_NAME
Write-Host AWS_EXECUTION_ENV=$Env:AWS_EXECUTION_ENV
Write-Host AWS_LAMBDA_FUNCTION_NAME=$Env:AWS_LAMBDA_FUNCTION_NAME
Write-Host PATH=$Env:PATH
Write-Host `## Event
Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 3)
```
**Example format des journaux**
```
START RequestId: 56639408-xmpl-435f-9041-ac47ae25ceed Version: $LATEST
Importing module ./Modules/AWSPowerShell.NetCore/3.3.618.0/AWSPowerShell.NetCore.psd1
[Information] - ## Environment variables
[Information] - AWS_LAMBDA_FUNCTION_VERSION=$LATEST
[Information] - AWS_LAMBDA_LOG_GROUP_NAME=/aws/lambda/blank-powershell-function-18CIXMPLHFAJJ
[Information] - AWS_LAMBDA_LOG_STREAM_NAME=2020/04/01/[$LATEST]53c5xmpl52d64ed3a744724d9c201089
[Information] - AWS_EXECUTION_ENV=AWS_Lambda_dotnet6_powershell_1.0.0
[Information] - AWS_LAMBDA_FUNCTION_NAME=blank-powershell-function-18CIXMPLHFAJJ
[Information] - PATH=/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin
[Information] - ## Event
[Information] -
{
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1523232000000",
"SenderId": "123456789012",
"ApproximateFirstReceiveTimestamp": "1523232000001"
},
...
END RequestId: 56639408-xmpl-435f-9041-ac47ae25ceed
REPORT RequestId: 56639408-xmpl-435f-9041-ac47ae25ceed Duration: 3906.38 ms Billed Duration: 9867 ms Memory Size: 512 MB Max Memory Used: 367 MB Init Duration: 5960.19 ms
XRAY TraceId: 1-5e843da6-733cxmple7d0c3c020510040 SegmentId: 3913xmpl20999446 Sampled: true
```
L’environnement d’exécution .NET enregistre les lignes `START`, `END` et `REPORT` pour chaque invocation. La ligne de rapport fournit les détails suivants.
**Champs de données de la ligne REPORT**
+ **RequestId**— L'identifiant de demande unique pour l'invocation.
+ **Duration** – Temps que la méthode de gestion du gestionnaire de votre fonction a consacré au traitement de l’événement.
+ **Billed Duration** : temps facturé pour l’invocation.
+ **Memory Size** – Quantité de mémoire allouée à la fonction.
+ **Max Memory Used** – Quantité de mémoire utilisée par la fonction. Lorsque les appels partagent un environnement d’exécution, Lambda indique la mémoire maximale utilisée pour toutes les invocations. Ce comportement peut entraîner une valeur signalée plus élevée que prévu.
+ **Init Duration** : pour la première requête servie, temps qu’il a pris à l’exécution charger la fonction et exécuter le code en dehors de la méthode du gestionnaire.
+ **XRAY TraceId** — Pour les demandes suivies, l'[ID de AWS X-Ray trace.](services-xray.md)
+ **SegmentId**— Pour les demandes tracées, l'identifiant du segment X-Ray.
+ **Sampled** – Pour les demandes suivies, résultat de l’échantillonnage.
## Affichage des journaux dans la console Lambda
Vous pouvez utiliser la console Lambda pour afficher la sortie du journal après avoir invoqué une fonction Lambda.
Si votre code peut être testé à partir de l’éditeur **Code** intégré, vous trouverez les journaux dans les **résultats d’exécution**. Lorsque vous utilisez la fonctionnalité de test de console pour invoquer une fonction, vous trouverez **Sortie du journal** dans la section **Détails**.
## Afficher les journaux dans la CloudWatch console
Vous pouvez utiliser la CloudWatch console Amazon pour consulter les journaux de toutes les invocations de fonctions Lambda.
**Pour afficher les journaux sur la CloudWatch console**
1. Ouvrez la [page Groupes de journaux](https://console.aws.amazon.com/cloudwatch/home?#logs:) sur la CloudWatch console.
1. Choisissez le groupe de journaux pour votre fonction (***your-function-name*/aws/lambda/**).
1. Choisissez un flux de journaux.
Chaque flux de journal correspond à une [instance de votre fonction](lambda-runtime-environment.md). Un flux de journal apparaît lorsque vous mettez à jour votre fonction Lambda et lorsque des instances supplémentaires sont créées pour gérer les appels simultanés. Pour trouver les journaux d'un appel spécifique, nous vous recommandons d'instrumenter votre fonction avec. AWS X-Ray X-Ray enregistre des détails sur la demande et le flux de journaux dans le suivi.
## Afficher les journaux à l'aide de AWS Command Line Interface (AWS CLI)
AWS CLI Il s'agit d'un outil open source qui vous permet d'interagir avec les AWS services à l'aide de commandes dans votre interface de ligne de commande. Pour effectuer les étapes de cette section, vous devez disposer de la [version 2 de l’AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Vous pouvez utiliser [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) pour récupérer les journaux d’une invocation à l’aide de l’option de commande `--log-type`. La réponse inclut un champ `LogResult` qui contient jusqu’à 4 Ko de journaux codés en base64 provenant de l’invocation.
**Example récupérer un ID de journal**
L’exemple suivant montre comment récupérer un *ID de journal* à partir du champ `LogResult` d’une fonction nommée `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Vous devriez voir la sortie suivante:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example décoder les journaux**
Dans la même invite de commandes, utilisez l’utilitaire `base64` pour décoder les journaux. L’exemple suivant montre comment récupérer les journaux encodés en base64 pour `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
L'**cli-binary-format**option est obligatoire si vous utilisez AWS CLI la version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, consultez les [options de ligne de commande globales AWS CLI prises en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) dans le *Guide de l’utilisateur AWS Command Line Interface version 2*.
Vous devriez voir la sortie suivante :
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
L’utilitaire `base64` est disponible sous Linux, macOS et [Ubuntu sous Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Les utilisateurs de macOS auront peut-être besoin d’utiliser `base64 -D`.
**Example Script get-logs.sh**
Dans la même invite de commandes, utilisez le script suivant pour télécharger les cinq derniers événements de journalisation. Le script utilise `sed` pour supprimer les guillemets du fichier de sortie et attend 15 secondes pour permettre la mise à disposition des journaux. La sortie comprend la réponse de Lambda, ainsi que la sortie de la commande `get-log-events`.
Copiez le contenu de l’exemple de code suivant et enregistrez-le dans votre répertoire de projet Lambda sous `get-logs.sh`.
L'**cli-binary-format**option est obligatoire si vous utilisez AWS CLI la version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, consultez les [options de ligne de commande globales AWS CLI prises en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) dans le *Guide de l’utilisateur AWS Command Line Interface version 2*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS et Linux (uniquement)**
Dans la même invite de commandes, les utilisateurs macOS et Linux peuvent avoir besoin d’exécuter la commande suivante pour s’assurer que le script est exécutable.
```
chmod -R 755 get-logs.sh
```
**Example récupérer les cinq derniers événements de journal**
Dans la même invite de commande, exécutez le script suivant pour obtenir les cinq derniers événements de journalisation.
```
./get-logs.sh
```
Vous devriez voir la sortie suivante:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Suppression de journaux
Les groupes de journaux ne sont pas supprimés automatiquement quand vous supprimez une fonction. Pour éviter de stocker des journaux indéfiniment, supprimez le groupe de journaux ou [configurez une période de conservation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) à l’issue de laquelle les journaux sont supprimés automatiquement.