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.
# Instrumentation des infrastructures web déployées dans des environnements sans serveur
**Note**
Avis de SDK/Daemon maintenance de X-Ray — Le 25 février 2026, le AWS X-Ray SDKs/Daemon passera en mode maintenance, où les versions du SDK et du Daemon de X-Ray AWS seront limitées uniquement pour résoudre les problèmes de sécurité. Pour plus d'informations sur le calendrier de support, consultez[Chronologie du support pour le SDK et Daemon X-Ray](xray-sdk-daemon-timeline.md). Nous vous recommandons de migrer vers OpenTelemetry. Pour plus d'informations sur la migration vers OpenTelemetry, consultez la section [Migration de l'instrumentation X-Ray vers OpenTelemetry l'instrumentation](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).
Le SDK AWS X-Ray pour Python permet d'instrumenter les frameworks Web déployés dans des applications sans serveur. Le sans serveur désigne l'architecture native du cloud qui vous permet de déléguer davantage de responsabilités opérationnelles à AWS ce qui augmente votre agilité et votre innovation.
L'architecture sans serveur est un modèle d'application logicielle qui vous permet de créer et d'exécuter des applications et des services sans vous soucier des serveurs. Cela permet d'éliminer les tâches de gestion des infrastructures, comme le provisionnement de serveur ou de cluster, la correction, la maintenance des systèmes d'exploitation et l'allocation de capacités. Vous pouvez en concevoir des solutions sans serveur pour pratiquement n'importe quel type d'application ou de service backend. Tous les aspects nécessaires à l'exécution et à la mise à l'échelle de votre application avec une haute disponibilité sont gérés à votre place.
Ce didacticiel vous montre comment instrumenter automatiquement AWS X-Ray sur un framework Web, tel que Flask ou Django, déployé dans un environnement sans serveur. L'instrumentation X-Ray de l'application vous permet de visualiser tous les appels en aval effectués, en commençant par Amazon API Gateway via votre AWS Lambda fonction, et les appels sortants effectués par votre application.
Le SDK X-Ray pour Python prend en charge les frameworks d'applications Python suivants :
+ Flask version 0.8 ou ultérieure
+ Django version 1.0 ou ultérieure
Ce didacticiel développe un exemple d'application sans serveur déployée sur Lambda et invoquée par API Gateway. Ce didacticiel utilise Zappa pour déployer automatiquement l'application sur Lambda et pour configurer le point de terminaison API Gateway.
## Conditions préalables
+ [Zappa](https://github.com/Miserlou/Zappa)
+ [Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) — Version 2.7 ou 3.6.
+ [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)— Vérifiez que vous êtes AWS CLI configuré avec le compte Région AWS dans lequel vous allez déployer votre application.
+ [Pip](https://pypi.org/project/pip/)
+ [Virtualenv](https://virtualenv.pypa.io/en/latest/)
## Étape 1 : Créer un environnement
Au cours de cette étape, vous allez créer un environnement virtuel à l'aide de `virtualenv` pour héberger une application.
1. À l'aide du AWS CLI, créez un répertoire pour l'application. Accédez ensuite au nouveau répertoire.
```
mkdir serverless_application
cd serverless_application
```
1. Créez ensuite un environnement virtuel au sein de votre nouveau répertoire. Utilisez la commande suivante pour l'activer.
```
# Create our virtual environment
virtualenv serverless_env
# Activate it
source serverless_env/bin/activate
```
1. Installez X-Ray, Flask, Zappa et la bibliothèque Requests dans votre environnement.
```
# Install X-Ray, Flask, Zappa, and Requests into your environment
pip install aws-xray-sdk flask zappa requests
```
1. Ajoutez le code d'application au répertoire `serverless_application`. Pour cet exemple, nous pouvons effectuer la création à partir de l'exemple [Hello World](https://flask.palletsprojects.com/en/3.0.x/quickstart/) de Flasks.
Dans le répertoire `serverless_application`, créez un fichier nommé `my_app.py`. Utilisez ensuite un éditeur de texte pour ajouter les commandes suivantes. Cette application instrumente la bibliothèque Requests, applique les correctifs de l'intergiciel de l'application Flask et ouvre le point de terminaison `'/'`.
```
# Import the X-Ray modules
from aws_xray_sdk.ext.flask.middleware import XRayMiddleware
from aws_xray_sdk.core import patcher, xray_recorder
from flask import Flask
import requests
# Patch the requests module to enable automatic instrumentation
patcher.patch(('requests',))
app = Flask(__name__)
# Configure the X-Ray recorder to generate segments with our service name
xray_recorder.configure(service='My First Serverless App')
# Instrument the Flask application
XRayMiddleware(app, xray_recorder)
@app.route('/')
def hello_world():
resp = requests.get("https://aws.amazon.com")
return 'Hello, World: %s' % resp.url
```
## Étape 2 : Créer et déployer un environnement Zappa
Au cours de cette étape, vous utiliserez Zappa pour configurer automatiquement un point de terminaison API Gateway, puis le déployer sur Lambda.
1. Initialisez Zappa depuis le répertoire `serverless_application`. Pour cet exemple, nous utilisons les paramètres par défaut, mais si vous avez des préférences de personnalisation, Zappa affiche des instructions de configuration.
```
zappa init
```
```
What do you want to call this environment (default 'dev'): dev
...
What do you want to call your bucket? (default 'zappa-*******'): zappa-*******
...
...
It looks like this is a Flask application.
What's the modular path to your app's function?
This will likely be something like 'your_module.app'.
We discovered: my_app.app
Where is your app's function? (default 'my_app.app'): my_app.app
...
Would you like to deploy this application globally? (default 'n') [y/n/(p)rimary]: n
```
1. Activez X-Ray. Ouvrez le fichier `zappa_settings.json` et vérifiez s'il ressemble à l'exemple.
```
{
"dev": {
"app_function": "my_app.app",
"aws_region": "us-west-2",
"profile_name": "default",
"project_name": "serverless-exam",
"runtime": "python2.7",
"s3_bucket": "zappa-*********"
}
}
```
1. Ajoutez `"xray_tracing": true` comme entrée au fichier de configuration.
```
{
"dev": {
"app_function": "my_app.app",
"aws_region": "us-west-2",
"profile_name": "default",
"project_name": "serverless-exam",
"runtime": "python2.7",
"s3_bucket": "zappa-*********",
"xray_tracing": true
}
}
```
1. Déployez l'application. Cela configure automatiquement le point de terminaison API Gateway et télécharge votre code sur Lambda.
```
zappa deploy
```
```
...
Deploying API Gateway..
Deployment complete!: https://**********.execute-api.us-west-2.amazonaws.com/dev
```
## Étape 3 : activer le suivi X-Ray pour API Gateway
Au cours de cette étape, vous allez interagir avec la console API Gateway pour activer le suivi X-Ray.
1. Connectez-vous à la console API Gateway AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/).
1. Recherchez votre API nouvellement générée. Vous devez obtenir quelque chose de similaire à `serverless-exam-dev`.
1. Choisissez **Stages (Étapes)**.
1. Choisissez le nom de votre étape de déploiement. La valeur par défaut est `dev`.
1. Sous l'onglet **Logs/Tracing (Journaux/Suivi)**, cochez la case **Enable X-Ray Tracing (Activer le suivi X-Ray)**.
1. Choisissez **Save Changes (Enregistrer les modifications)**.
1. Accédez au point de terminaison dans votre navigateur. Si vous avez utilisé l'exemple d'application `Hello World`, il doit afficher les éléments suivants.
```
"Hello, World: https://aws.amazon.com/"
```
## Étape 4 : Afficher le suivi créé
Au cours de cette étape, vous allez interagir avec la console X-Ray pour afficher la trace créée par l'exemple d'application. Pour obtenir une présentation plus détaillée de l'analyse des suivis, veuillez consulter [Affichage de la cartographie des services](https://docs.aws.amazon.com/xray/latest/devguide/xray-console.html#xray-console-servicemap).
1. Connectez-vous à la console X-Ray AWS Management Console et ouvrez-la [https://console.aws.amazon.com/xray/chez](https://console.aws.amazon.com/xray/home) vous.
1. Affichez les segments générés par API Gateway, la fonction Lambda et le conteneur Lambda.
1. Sous le segment de fonction Lambda, visualisez un sous-segment nommé. `My First Serverless App` Il est suivi par un deuxième sous-segment nommé `https://aws.amazon.com`.
1. Lors de l'initialisation, Lambda peut également générer un troisième sous-segment nommé. `initialization`
![\[Vue du segment de suivi.\]](http://docs.aws.amazon.com/fr_fr/xray/latest/devguide/images/serverless-traceView.png)
![\[Vue du graphique de services\]](http://docs.aws.amazon.com/fr_fr/xray/latest/devguide/images/serverless-serviceView.png)
## Étape 5 : nettoyer
Supprimez toujours les ressources que vous n'utilisez plus pour éviter d'accumuler des coûts imprévus. Comme le montre ce tutoriel, des outils tels que Zappa rationalisent le redéploiement sans serveur.
Pour supprimer votre application de Lambda, d'API Gateway et d'Amazon S3, exécutez la commande suivante dans le répertoire de votre projet à l'aide du. AWS CLI
```
zappa undeploy dev
```
## Étapes suivantes
Ajoutez des fonctionnalités supplémentaires à votre application en ajoutant des AWS clients et en les instrumentant avec X-Ray. Pour en savoir plus sur les options informatiques sans serveur, rendez-vous sur [Serverless](https://aws.amazon.com/serverless) on. AWS