Impression dans le journal Utilisation d’une bibliothèque de journalisation Utilisation des contrôles de journalisation avancés de Lambda avec Python Affichage des journaux dans la console Lambda Afficher les journaux dans CloudWatch la console Affichage des journaux avec AWS CLI Suppression de journaux Outils et bibliothèques Utilisation de Powertools pour AWS Lambda (Python) et de AWS SAM pour la journalisation structurée Utilisation de Powertools pour AWS Lambda (Python) et de AWS CDK pour la journalisation structurée

Journalisation des fonctions AWS Lambda dans Python

AWS Lambdasurveille automatiquement les fonctions Lambda et envoie des entrées de journal à 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 détails sur chaque invocation et d’autres sorties provenant du code de votre fonction au flux de journaux. Pour plus d'informations sur CloudWatch les journaux, consultezUtilisation d'Amazon CloudWatch Logs avec AWS Lambda.

Pour produire des journaux à partir de votre code de fonction, vous pouvez utiliser le module intégré logging. Pour des entrées plus détaillées, vous pouvez utiliser n’importe quelle bibliothèque de journalisation qui écrit dans stdout ou stderr.

Impression dans le journal

Pour envoyer une sortie de base aux journaux, vous pouvez utiliser une méthode print dans votre fonction. L'exemple suivant enregistre les valeurs du groupe et du flux de CloudWatch journaux Logs, ainsi que l'objet de l'événement.

Notez que si votre fonction génère des journaux à l'aide d'printinstructions Python, Lambda ne peut envoyer les résultats de journal à CloudWatch Logs qu'au format texte brut. Pour capturer des journaux au format JSON structuré, vous devez utiliser une bibliothèque de journalisation prise en charge. Pour plus d’informations, consultez Utilisation des contrôles de journalisation avancés de Lambda avec Python.

Exemple lambda_function.py


import os
def lambda_handler(event, context):
    print('## ENVIRONMENT VARIABLES')
    print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
    print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
    print('## EVENT')
    print(event)

Exemple sortie de journal


START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
/aws/lambda/my-function
2023/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95  Duration: 15.74 ms  Billed Duration: 16 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1   SegmentId: 07f5xmpl2d1f6f85 Sampled: true

L’environnement d’exécution Python enregistre les lignes START, END et REPORT pour chaque invocation. La ligne REPORT comprend les données suivantes :

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.
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.
SegmentId— Pour les demandes tracées, l'identifiant du segment X-Ray.
Sampled : pour les demandes suivies, résultat de l’échantillonnage.

Utilisation d’une bibliothèque de journalisation

Pour des journaux plus détaillés, utilisez le module de journalisation de la bibliothèque standard, ou de toute bibliothèque de journalisation tierce qui écrit à stdout ou stderr.

Pour les environnements d’exécution Python pris en charge, vous pouvez choisir si les journaux créés à l’aide du module logging standard sont capturés en texte brut ou en JSON. Pour en savoir plus, veuillez consulter la section Utilisation des contrôles de journalisation avancés de Lambda avec Python.

Actuellement, le format de journal par défaut pour tous les environnements d’exécution Python est le texte brut. L'exemple suivant montre comment les sorties de journal créées à l'aide du logging module standard sont capturées en texte brut dans CloudWatch Logs.


import os
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
  
def lambda_handler(event, context):
    logger.info('## ENVIRONMENT VARIABLES')
    logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
    logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
    logger.info('## EVENT')
    logger.info(event)

La sortie de logger inclut le niveau de journal, l’horodatage et l’ID de demande.


START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## ENVIRONMENT VARIABLES
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    /aws/lambda/my-function
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    2023/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d
[INFO]  2023-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## EVENT
[INFO]  2023-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125  Duration: 2.75 ms   Billed Duration: 3 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370   SegmentId: 073cxmpl3e442861 Sampled: true

Note

Lorsque le format de journal de votre fonction est défini sur du texte brut, le paramètre de niveau de journal par défaut pour les environnements d'exécution Python est WARN. Cela signifie que Lambda envoie uniquement des sorties de journal de niveau WARN ou inférieur à CloudWatch Logs. Pour modifier le niveau de journalisation par défaut, utilisez la méthode Python logging setLevel() comme indiqué dans cet exemple de code. Si vous définissez le format de journal de votre fonction sur JSON, nous vous recommandons de configurer le niveau de journalisation de votre fonction à l'aide de Lambda Advanced Logging Controls et non en définissant le niveau de journalisation dans le code. Pour en savoir plus, consultez Utilisation du filtrage au niveau du journal avec Python

Utilisation des contrôles de journalisation avancés de Lambda avec Python

Pour mieux contrôler la manière dont les journaux de vos fonctions sont capturés, traités et consommés, vous pouvez configurer les options de journalisation suivantes pour les environnements d’exécution Lambda Python pris en charge :

Format de journal : choisissez entre le format texte brut et le format JSON structuré pour les journaux de votre fonction
Niveau de journalisation : pour les journaux au format JSON, choisissez le niveau de détail des journaux que Lambda envoie à Amazon CloudWatch, par exemple ERROR, DEBUG ou INFO
Groupe de journaux : choisissez le groupe de CloudWatch journaux auquel votre fonction envoie les journaux

Pour plus d’informations sur ces options de journalisation et pour savoir comment configurer votre fonction pour les utiliser, consultez Configuration de commandes de journalisation avancées pour votre fonction Lambda.

Pour en savoir plus sur l’utilisation du format de journal et les options de niveau de journal avec vos fonctions Python Lambda, consultez les instructions des sections suivantes.

Utilisation de journaux JSON structurés avec Python

Si vous sélectionnez JSON pour le format de journal de votre fonction, Lambda enverra les journaux produits par la bibliothèque de journalisation standard Python au CloudWatch format JSON structuré. Chaque objet de journal JSON contient au moins quatre paires clé-valeur avec les clés suivantes :

"timestamp" - heure à laquelle le message de journal a été généré
"level" - niveau de journalisation attribué au message
"message" - contenu du message de journal
"requestId" - identifiant unique de la demande pour l’invocation de la fonction

La bibliothèque Python logging peut également ajouter des paires clé-valeur supplémentaires, comme "logger", dans cet objet JSON.

Les exemples présentés dans les sections suivantes montrent comment les sorties de journal générées à l'aide de la logging bibliothèque Python sont capturées dans CloudWatch Logs lorsque vous configurez le format de journal de votre fonction au format JSON.

Notez que si vous utilisez la méthode print pour produire des sorties de journal de base comme décrit dans Impression dans le journal, Lambda capture ces sorties sous forme de texte brut, même si vous définissez le format de journalisation de votre fonction sur JSON.

Sorties JSON standard à l’aide de la bibliothèque de journalisation Python

Les exemples d'extrait de code et de sortie de journal suivants montrent comment les sorties de journal standard générées à l'aide de la logging bibliothèque Python sont capturées dans CloudWatch Logs lorsque le format de journal de votre fonction est défini sur JSON.

Exemple Code de journalisation Python


import logging  
logger = logging.getLogger()

def lambda_handler(event, context):
    logger.info("Inside the handler function")

Exemple Enregistrement de journaux JSON


{
    "timestamp":"2023-10-27T19:17:45.586Z",
    "level":"INFO",
    "message":"Inside the handler function",
    "logger": "root",
    "requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}

Enregistrement de paramètres supplémentaires au format JSON

Lorsque le format de journal de votre fonction est défini sur JSON, vous pouvez également enregistrer des paramètres supplémentaires avec la logging bibliothèque Python standard en utilisant le extra mot-clé pour transmettre un dictionnaire Python à la sortie du journal.

Exemple Code de journalisation Python


import logging

def lambda_handler(event, context):
    logging.info(
        "extra parameters example", 
        extra={"a":"b", "b": [3]},
    )

Exemple Enregistrement de journaux JSON


{
  "timestamp": "2023-11-02T15:26:28Z",
  "level": "INFO",
  "message": "extra parameters example",
  "logger": "root",
  "requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",
  "a": "b",
  "b": [
    3
  ]
}

Exceptions de journalisation au format JSON

L’extrait de code suivant montre comment les exceptions Python sont capturées dans la sortie du journal de votre fonction lorsque vous définissez le format de journal sur JSON. Notez que les sorties de journal générées en utilisant logging.exception sont affectées au niveau de journal ERROR.

Exemple Code de journalisation Python


import logging

def lambda_handler(event, context):
    try:
        raise Exception("exception")
    except:
        logging.exception("msg")

Exemple Enregistrement de journaux JSON


{
  "timestamp": "2023-11-02T16:18:57Z",
  "level": "ERROR",
  "message": "msg",
  "logger": "root",
  "stackTrace": [
    "  File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n    raise Exception(\"exception\")\n"
  ],
  "errorType": "Exception",
  "errorMessage": "exception",
  "requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",
  "location": "/var/task/lambda_function.py:lambda_handler:17"
}

Journaux structurés JSON avec d’autres outils de journalisation

Si votre code utilise déjà une autre bibliothèque de journalisation, telle que Powertools for AWS Lambda, pour produire des journaux structurés en JSON, vous n’avez pas besoin d’apporter de modifications. AWS Lambda ne double code aucun journal déjà codé au format JSON. Même si vous configurez votre fonction pour utiliser le format de journal JSON, vos sorties de journalisation apparaissent CloudWatch dans la structure JSON que vous définissez.

L'exemple suivant montre comment les sorties de journal générées à l'aide du AWS Lambda package Powertools for sont capturées dans CloudWatch Logs. Le format de cette sortie de journal est le même, que la configuration de journalisation de votre fonction soit définie sur JSON ou TEXT. Pour plus d’informations sur l’utilisation de Powertools pour AWS Lambda, consultez Utilisation de Powertools pour AWS Lambda (Python) et de AWS SAM pour la journalisation structurée et Utilisation de Powertools pour AWS Lambda (Python) et de AWS CDK pour la journalisation structurée

Exemple Extrait de code de journalisation en Python (à l’aide de Powertools for AWS Lambda)


from aws_lambda_powertools import Logger

logger = Logger()

def lambda_handler(event, context):
    logger.info("Inside the handler function")

Exemple Enregistrement de journal JSON (à l’aide de Powertools for AWS Lambda)


{ 
    "level": "INFO", 
    "location": "lambda_handler:7", 
    "message": "Inside the handler function", 
    "timestamp": "2023-10-31 22:38:21,010+0000", 
    "service": "service_undefined", 
    "xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30" 
}

Utilisation du filtrage au niveau du journal avec Python

En configurant le filtrage au niveau des journaux, vous pouvez choisir de n'envoyer que les journaux ayant un certain niveau de journalisation ou un niveau inférieur à CloudWatch Logs. Pour savoir comment configurer le filtrage de niveau journal de votre fonction, consultez Filtrage au niveau du journal.

Pour qu’AWS Lambda filtre les journaux de votre application en fonction de leur niveau de journalisation, votre fonction doit utiliser des journaux au format JSON. Vous pouvez effectuer cette opération de deux façons :

Créez des sorties de journal à l’aide de la bibliothèque Python logging standard et configurez votre fonction pour utiliser le format de journal JSON. AWS Lambda filtre ensuite les sorties de votre journal à l’aide de la paire clé-valeur « niveau » de l’objet JSON décrit dans Utilisation de journaux JSON structurés avec Python. Pour savoir comment configurer le format de journal de votre fonction, consultez Configuration de commandes de journalisation avancées pour votre fonction Lambda.
Utilisez une autre bibliothèque ou méthode de journalisation pour créer des journaux structurés JSON dans votre code qui incluent une paire clé-valeur « niveau » définissant le niveau de sortie du journal. Par exemple, vous pouvez utiliser Powertools for AWS Lambda pour générer des sorties de journal structurées JSON à partir de votre code.

Vous pouvez également utiliser une instruction print pour générer un objet JSON contenant un identifiant de niveau de journalisation. L'instruction d'impression suivante produit une sortie au format JSON dans laquelle le niveau de journalisation est défini sur INFO. AWS Lambdaenverra l'objet JSON à CloudWatch Logs si le niveau de journalisation de votre fonction est défini sur INFO, DEBUG ou TRACE.
```
print('{"msg":"My log message", "level":"info"}')
```

Pour que Lambda puisse filtrer les journaux de votre fonction, vous devez également inclure une paire "timestamp" clé-valeur dans la sortie de votre journal JSON. L'heure doit être spécifiée dans un format d'horodatage RFC 3339 valide. Si vous ne fournissez pas d’horodatage valide, Lambda attribuera au journal le niveau INFO et ajoutera un horodatage pour vous.

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 CloudWatch la 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

Ouvrez la page Groupes de journaux sur la CloudWatch console.
Choisissez le groupe de journaux pour votre fonction (your-function-name/aws/lambda/).
Choisissez un flux de journaux.

Chaque flux de journal correspond à une instance de votre fonction. Un flux de journaux apparaît lorsque vous mettez à jour votre fonction Lambda et lorsque des instances supplémentaires sont créées pour traiter plusieurs invocations simultanées. Pour trouver des journaux pour une invocation spécifique, nous vous recommandons d’utiliser votre fonction avec AWS X-Ray. X-Ray enregistre des détails sur la demande et le flux de journaux dans le suivi.

Pour un exemple d’application qui met en corrélation les journaux et les suivis avec X-Ray, consultez Exemple d'application du processeur d'erreurs pour AWS Lambda.

Affichage des journaux avec AWS CLI

La AWS CLI est un outil à code open-source qui vous permet d’interagir avec les services AWS à l’aide de commandes dans votre ligne de commande shell. Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :

Vous pouvez utiliser AWS CLI 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.

Exemple 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"
}

Exemple 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’option cli-binary-format est obligatoire si vous utilisez AWS CLI 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 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. Les utilisateurs de macOS auront peut-être besoin d’utiliser base64 -D.

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


#!/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

Exemple 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

Exemple 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 à l’issue de laquelle les journaux sont supprimés automatiquement.

Outils et bibliothèques

Powertools pour AWS Lambda (Python) est une boîte à outils pour développeurs permettant de mettre en œuvre les bonnes pratiques en matière de sans serveur et d’augmenter la rapidité des développeurs. L’utilitaire Logger fournit un enregistreur optimisé pour Lambda qui inclut des informations supplémentaires sur le contexte de fonction pour toutes vos fonctions avec une sortie structurée en JSON. Utilisez cet utilitaire pour effectuer les opérations suivantes :

Capturer les champs clés du contexte Lambda, démarrer à froid et structurer la sortie de la journalisation sous forme de JSON
Journaliser les événements d’invocation Lambda lorsque cela est demandé (désactivé par défaut)
Imprimer tous les journaux uniquement pour un pourcentage d’invocations via l’échantillonnage des journaux (désactivé par défaut)
Ajouter des clés supplémentaires au journal structuré à tout moment
Utiliser un formateur de journaux personnalisé (Apportez votre propre formateur) pour produire des journaux dans une structure compatible avec le RFC de journalisation de votre organisation

Utilisation de Powertools pour AWS Lambda (Python) et de AWS SAM pour la journalisation structurée

Suivez les étapes ci-dessous pour télécharger, créer et déployer un exemple d’application Hello World Python avec des modules Powertools for Python (français non garanti) intégrés à l’aide d’AWS SAM. Cette application met en œuvre un backend API de base et utilise Powertools pour émettre des journaux, des métriques et des traces. Elle se compose d’un point de terminaison Amazon API Gateway et d’une fonction Lambda. Lorsque vous envoyez une requête GET au point de terminaison API Gateway, la fonction Lambda appelle, envoie des journaux et des métriques au format métrique intégré à CloudWatch, et envoie des traces à. AWS X-Ray La fonction renvoie un message hello world.

Prérequis

Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :

Python 3.9
AWS CLI version 2
CLI AWS SAM version 1.75 ou ultérieure. Si vous avez une version antérieure de la CLI AWS SAM, consultez Mise à niveau de la CLI AWS SAM.

Déployer un exemple d’application AWS SAM

Initialisez l’application à l’aide du modèle Hello World Python.


sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing

Créez l’application.
```
cd sam-app && sam build
```
Déployez l’application.
```
sam deploy --guided
```
Suivez les invites à l’écran. Appuyez sur Enter pour accepter les options par défaut fournies dans l’expérience interactive.

Note
Car l'autorisation n'a HelloWorldFunction peut-être pas été définie, est-ce que ça va ? , assurez-vous de participery.

Obtenez l’URL de l’application déployée :


aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text

Invoquez le point de terminaison de l’API :
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
En cas de succès, vous obtiendrez cette réponse :
```
{"message":"hello world"}
```

Pour obtenir les journaux de la fonction, exécutez sam logs. Pour en savoir plus, consultez Utilisation des journaux dans le Guide du développeur AWS Serverless Application Model.


sam logs --stack-name sam-app

La sortie du journal se présente comme suit :


2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16    Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.114000 {
  "level": "INFO",
  "location": "hello:23",
  "message": "Hello world API - HTTP 200",
  "timestamp": "2023-02-03 14:59:51,113+0000",
  "service": "PowertoolsHelloWorld",
  "cold_start": true,
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_memory_size": "128",
  "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
  "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
  "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "function_name",
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "ColdStart",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "service": "PowertoolsHelloWorld",
  "ColdStart": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "HelloWorldInvocations",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "service": "PowertoolsHelloWorld",
  "HelloWorldInvocations": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be    Duration: 16.33 ms    Billed Duration: 17 ms    Memory Size: 128 MB    Max Memory Used: 64 MB    Init Duration: 739.46 ms    
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299    SegmentId: 3c5d18d735a1ced0    Sampled: true

Il s’agit d’un point de terminaison d’API public accessible par Internet. Nous vous recommandons de supprimer le point de terminaison après un test.
```
sam delete
```

Gestion de la conservation des journaux

Les groupes de journaux ne sont pas supprimés automatiquement quand vous supprimez une fonction. Pour éviter de stocker les journaux indéfiniment, supprimez le groupe de journaux ou configurez une période de conservation après laquelle les journaux CloudWatch sont automatiquement supprimés. Pour configurer la conservation des journaux, ajoutez les éléments suivants à votre modèle AWS SAM :


Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      # Omitting other properties

  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
      RetentionInDays: 7

Utilisation de Powertools pour AWS Lambda (Python) et de AWS CDK pour la journalisation structurée

Suivez les étapes ci-dessous pour télécharger, créer et déployer un exemple d’application Hello World Python avec des modules Powertools pour AWS Lambda (Python) intégrés à l’aide d’AWS CDK. Cette application met en œuvre un backend API de base et utilise Powertools pour émettre des journaux, des métriques et des traces. Elle se compose d’un point de terminaison Amazon API Gateway et d’une fonction Lambda. Lorsque vous envoyez une requête GET au point de terminaison API Gateway, la fonction Lambda appelle, envoie des journaux et des métriques au format métrique intégré à CloudWatch, et envoie des traces à. AWS X-Ray La fonction renvoie un message hello world.

Prérequis

Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :

Python 3.9
AWS CLI version 2
AWS CDK version 2
CLI AWS SAM version 1.75 ou ultérieure. Si vous avez une version antérieure de la CLI AWS SAM, consultez Mise à niveau de la CLI AWS SAM.

Déployer un exemple d’application AWS CDK

Créez un répertoire de projets pour votre nouvelle application.
```
mkdir hello-world
cd hello-world
```
Initialisez l’application.
```
cdk init app --language python
```
Installez les dépendances de Python.
```
pip install -r requirements.txt
```
Créez un répertoire lambda_function dans le dossier racine.
```
mkdir lambda_function
cd lambda_function
```

Créez un fichier app.py et ajoutez-y le code suivant. Il s’agit du code de la fonction Lambda.


from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit

app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")

@app.get("/hello")
@tracer.capture_method
def hello():
    # adding custom metrics
    # See: https://docs.powertools.aws.dev/lambda-python/latest/core/metrics/
    metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)

    # structured log
    # See: https://docs.powertools.aws.dev/lambda-python/latest/core/logger/
    logger.info("Hello world API - HTTP 200")
    return {"message": "hello world"}

# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
    return app.resolve(event, context)

Ouvrez le répertoire hello_world. Vous devriez voir un fichier nommé hello_world_stack.py.
```
cd ..
cd hello_world
```

Ouvrez hello_world_stack.py et ajoutez le code suivant au fichier. Il contient le constructeur Lambda, qui crée la fonction Lambda, configure les variables d'environnement pour Powertools et fixe la durée de conservation des journaux à une semaine, et le constructeur ApiGatewayv 1, qui crée l'API REST.


from aws_cdk import (
    Stack,
    aws_apigateway as apigwv1,
    aws_lambda as lambda_,
    CfnOutput,
    Duration
)
from constructs import Construct

class HelloWorldStack(Stack):

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

        # Powertools Lambda Layer
        powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
            self,
            id="lambda-powertools",
            # At the moment we wrote this example, the aws_lambda_python_alpha CDK constructor is in Alpha, o we use layer to make the example simpler
            # See https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_lambda_python_alpha/README.html
            # Check all Powertools layers versions here: https://docs.powertools.aws.dev/lambda-python/latest/#lambda-layer
            layer_version_arn=f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPythonV2:21"
        )

        function = lambda_.Function(self,
            'sample-app-lambda',
            runtime=lambda_.Runtime.PYTHON_3_9,
            layers=[powertools_layer],
            code = lambda_.Code.from_asset("./lambda_function/"),
            handler="app.lambda_handler",
            memory_size=128,
            timeout=Duration.seconds(3),
            architecture=lambda_.Architecture.X86_64,
            environment={
                "POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
                "POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
                "LOG_LEVEL": "INFO"
            }
        )

        apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))

        hello_api = apigw.root.add_resource("hello")
        hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))

        CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")

Déployez votre application.
```
cd ..
cdk deploy
```

Obtenez l’URL de l’application déployée :


aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text

Invoquez le point de terminaison de l’API :
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
En cas de succès, vous obtiendrez cette réponse :
```
{"message":"hello world"}
```

Pour obtenir les journaux de la fonction, exécutez sam logs. Pour en savoir plus, consultez Utilisation des journaux dans le Guide du développeur AWS Serverless Application Model.


sam logs --stack-name HelloWorldStack

La sortie du journal se présente comme suit :


2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16    Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.114000 {
  "level": "INFO",
  "location": "hello:23",
    "message": "Hello world API - HTTP 200",
  "timestamp": "2023-02-03 14:59:51,113+0000",
  "service": "PowertoolsHelloWorld",
  "cold_start": true,
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_memory_size": "128",
  "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
  "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
  "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "function_name",
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "ColdStart",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "service": "PowertoolsHelloWorld",
  "ColdStart": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "HelloWorldInvocations",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "service": "PowertoolsHelloWorld",
  "HelloWorldInvocations": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be    Duration: 16.33 ms    Billed Duration: 17 ms    Memory Size: 128 MB    Max Memory Used: 64 MB    Init Duration: 739.46 ms    
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299    SegmentId: 3c5d18d735a1ced0    Sampled: true

Il s’agit d’un point de terminaison d’API public accessible par Internet. Nous vous recommandons de supprimer le point de terminaison après un test.
```
cdk destroy
```

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Contexte

Test