Étape 1 : activer Application Signals dans votre compte Étape 2 : télécharger et démarrer l' CloudWatch agent Étape 3 : instrumenter votre application et la démarrer Activez les signaux d'application sur Amazon EC2 à l'aide du protocole MCP (Model Context Protocol)(Facultatif) Surveiller l’état de votre application

Activez vos applications sur Amazon EC2

Activez CloudWatch Application Signals sur Amazon EC2 en suivant les étapes de configuration personnalisées décrites dans cette section.

Pour les applications exécutées sur Amazon EC2, vous devez installer et configurer OpenTelemetry vous-même l' CloudWatch agent et AWS Distro. Sur ces architectures activées avec une configuration personnalisée d’Application Signals, Application Signals ne découvre pas automatiquement les noms de vos services ni les hôtes ou clusters sur lesquels ils s’exécutent. Vous devez spécifier ces noms lors de la configuration personnalisée, et les noms que vous spécifiez sont ceux qui sont affichés sur les tableaux de bord d’Application Signals.

Les instructions de cette section concernent les applications Java, Python et .NET. Les étapes ont été testées sur des EC2 instances Amazon, mais elles devraient également fonctionner sur d'autres architectures compatibles avec AWS Distro for OpenTelemetry.

Prérequis

Pour obtenir de l'aide pour Application Signals, vous devez utiliser la version la plus récente de l' CloudWatchagent et de la AWS distribution pour l' OpenTelemetry agent.
Vous devez l'avoir AWS CLI installé sur l'instance. Nous recommandons AWS CLI la version 2, mais la version 1 devrait également fonctionner. Pour plus d'informations sur l'installation du AWS CLI, voir Installer ou mettre à jour la dernière version du AWS CLI.

Important

Si vous utilisez OpenTelemetry déjà une application que vous avez l'intention d'activer pour les signaux d'application, consultez la section Systèmes pris en charge avant d'activer les signaux d'application.

Étape 1 : activer Application Signals dans votre compte

Vous devez d’abord activer la vigie applicative dans votre compte. Si ce n’est pas déjà fait, consultez Activation de la vigie applicative dans votre compte.

Étape 2 : télécharger et démarrer l' CloudWatch agent

Pour installer l' CloudWatch agent dans le cadre de l'activation des signaux d'application sur une EC2 instance Amazon ou un hôte sur site

Téléchargez la dernière version de l' CloudWatch agent sur l'instance. Si l' CloudWatch agent est déjà installé sur l'instance, vous devrez peut-être le mettre à jour. Seules les versions de l'agent publiées le 30 novembre 2023 ou ultérieurement prennent en charge les signaux CloudWatch d'application.
Avant de démarrer l' CloudWatch agent, configurez-le pour activer les signaux d'application. L'exemple suivant est une configuration d' CloudWatch agent qui active les signaux d'application pour les métriques et les traces sur un EC2 hôte.

Nous vous recommandons de placer ce fichier à l’emplacement /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json sur les systèmes Linux.
```
{
  "traces": {
    "traces_collected": {
      "application_signals": {}
    }
  },
  "logs": {
    "metrics_collected": {
      "application_signals": {}
    }
  }
}
```
Associez la politique CloudWatchAgentServerPolicyIAM au rôle IAM de votre instance Amazon EC2 . Pour connaître les autorisations requises pour les hôtes sur site, consultez Autorisations pour les serveurs sur site.
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à https://console.aws.amazon.com/iam/l'adresse.
2. Choisissez Rôles et recherchez le rôle utilisé par votre EC2 instance Amazon. Choisissez ensuite le nom de ce rôle.
3. Sous l’onglet Autorisations, choisissez Ajouter des autorisations, Attacher des politiques.
4. Trouvez CloudWatchAgentServerPolicy. Utilisez le champ de recherche si nécessaire. Cochez la case correspondant à la politique, puis choisissez Ajouter des autorisations.
Démarrez l' CloudWatch agent en saisissant les commandes suivantes. Remplacez agent-config-file-path par le chemin d'accès au fichier de configuration de l' CloudWatch agent, tel que./amazon-cloudwatch-agent.json. Vous devez inclure le préfixe file: comme indiqué.
```
export CONFIG_FILE_PATH=./amazon-cloudwatch-agent.json
```
```
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
-a fetch-config \
-m ec2 -s -c file:agent-config-file-path
```

Autorisations pour les serveurs sur site

Pour un hôte sur site, vous devez fournir une AWS autorisation à votre appareil.

Pour configurer les autorisations pour un hôte sur site

Créer l’utilisateur IAM destiné à fournir les autorisations à votre hôte sur site :
1. Ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.
2. Sélectionnez Utilisateurs, Créer un utilisateur.
3. Dans Détails de l’utilisateur, pour Nom d’utilisateur, saisissez un nom pour le nouvel utilisateur IAM. Il s'agit du nom de connexion AWS qui sera utilisé pour authentifier votre hôte. Ensuite, sélectionnez Next
4. Sur la page Définir les autorisations, pour les Options des autorisations, sélectionnez Attacher directement les politiques.
5. Dans la liste des politiques d'autorisation, sélectionnez la CloudWatchAgentServerPolicypolitique à ajouter à votre utilisateur. Ensuite, sélectionnez Suivant.
6. Sur la page Réviser et créer, assurez-vous que vous êtes satisfait du nom d'utilisateur et que la CloudWatchAgentServerPolicypolitique figure dans le résumé des autorisations.
7. Sélectionnez Créer un utilisateur
Créez et récupérez votre clé AWS d'accès et votre clé secrète :
1. Dans le volet de navigation de la console IAM, sélectionnez Utilisateurs, puis le nom d’utilisateur que vous avez créé à l’étape précédente.
2. Sur la page de l’utilisateur, ouvrez l’onglet Informations d’identification de sécurité. Ensuite, dans la section Clés d’accès, sélectionnez Créer une clé d’accès.
3. Pour Créer une clé d’accès – Étape 1, sélectionnez Interface de ligne de commande (CLI).
4. Pour Créer une clé d’accès – Étape 2, ajoutez éventuellement une balise puis cliquez sur Suivant.
5. Pour Créer une clé d’accès – Étape 3, sélectionnez Télécharger le fichier .csv pour enregistrer un fichier .csv avec la clé d’accès et la clé d’accès secrète de votre utilisateur IAM. Vous aurez besoin de ces informations pour l’étape suivante.
6. Sélectionnez Exécuté.
Configurez vos AWS informations d'identification sur votre hôte local en saisissant la commande suivante. Remplacez ACCESS_KEY_ID et SECRET_ACCESS_ID par votre clé d'accès et votre clé d'accès secrète nouvellement générées à partir du fichier .csv que vous avez téléchargé à l'étape précédente.
```
$ aws configure
AWS Access Key ID [None]: ACCESS_KEY_ID
AWS Secret Access Key [None]: SECRET_ACCESS_ID
Default region name [None]: MY_REGION
Default output format [None]: json
```

Étape 3 : instrumenter votre application et la démarrer

L'étape suivante consiste à instrumenter votre application pour les signaux CloudWatch d'application.

Java

Pour instrumenter vos applications Java dans le cadre de l'activation des signaux d'application sur une EC2 instance Amazon ou un hôte sur site

Téléchargez la dernière version de l'agent d'auto-instrumentation de AWS Distro pour OpenTelemetry Java. Vous pouvez télécharger la version la plus récente en utilisant ce lien. Vous pouvez consulter les informations relatives à toutes les versions publiées dans la section aws-otel-java-instrumentationReleases.
Pour optimiser vos avantages d’Application Signals, utilisez des variables d’environnement pour fournir des informations supplémentaires avant de démarrer votre application. Ces informations seront affichées dans les tableaux de bord d’Application Signals.
1. Pour la variable OTEL_RESOURCE_ATTRIBUTES, spécifiez les informations suivantes sous forme de paires clé-valeur :
  - (Facultatif) service.name définit le nom du service. Ce nom s’affichera dans les tableaux de bord de la vigie applicative comme nom du service de votre application. Si vous ne fournissez pas de valeur pour cette clé, la valeur par défaut UnknownService est utilisée.
  - (Facultatif) deployment.environment définit l’environnement d’exécution de l’application. Cet environnement sera affiché comme l’environnement hébergé de votre application dans les tableaux de bord Application Signals. Si vous ne le spécifiez pas, l’une des valeurs par défaut suivantes est utilisée :
    S’il s’agit d’une instance qui fait partie d’un groupe Auto Scaling, la valeur est ec2:name-of-Auto-Scaling-group
    S'il s'agit d'une EC2 instance Amazon qui ne fait pas partie d'un groupe Auto Scaling, elle est définie sur ec2:default
    S’il s’agit d’un hôte sur site, la valeur est generic:default
    Cette variable d'environnement est utilisée uniquement par Application Signals et est convertie en annotations de trace X-Ray et en dimensions CloudWatch métriques.
  - Pour la variable OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, spécifiez l’URL du point de terminaison de base vers lequel les suivis doivent être exportés. L' CloudWatch agent expose 4316 comme port OTLP. Sur Amazon EC2, étant donné que les applications communiquent avec l' CloudWatch agent local, vous devez définir cette valeur sur OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
  - Pour la variable OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT, spécifiez l’URL du point de terminaison de base vers lequel les métriques doivent être exportées. L' CloudWatch agent expose 4316 comme port OTLP. Sur Amazon EC2, étant donné que les applications communiquent avec l' CloudWatch agent local, vous devez définir cette valeur sur OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
  - Pour la JAVA_TOOL_OPTIONS variable, spécifiez le chemin où l'agent d'auto-instrumentation de AWS Distro for OpenTelemetry Java est stocké.
```
export JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH"
```
    Par exemple :
```
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH=./aws-opentelemetry-agent.jar
```
  - Pour la variable OTEL_METRICS_EXPORTER, nous vous recommandons de définir la valeur sur none. Cela désactive les autres exportateurs de métriques afin que seul l’exportateur d’Application Signals soit utilisé.
  - Définissez OTEL_AWS_APPLICATION_SIGNALS_ENABLED sur true. Cela génère des métriques d’Application Signals à partir des suivis.

Démarrez votre application avec les variables d’environnement mentionnées à l’étape précédente. Voici un exemple de script de démarrage.

Note

La configuration suivante ne prend en charge que les versions 1.32.2 et ultérieures de l'agent d' OpenTelemetry auto-instrumentation AWS Distro pour Java.


JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH" \
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
java -jar $MY_JAVA_APP.jar

(Facultatif) Pour activer la corrélation des journaux, ajoutez dans OTEL_RESOURCE_ATTRIBUTES une variable d’environnement supplémentaire aws.log.group.names pour les groupes de journaux de votre application. Cela permet de corréler les suivis et les métriques de votre application avec les entrées de journaux correspondantes. Pour cette variable, remplacez $YOUR_APPLICATION_LOG_GROUP par les noms des groupes de journaux de votre application. Si vous avez plusieurs groupes de journaux, vous pouvez les séparer à l’aide d’un esperluette (&), comme dans l’exemple suivant : aws.log.group.names=log-group-1&log-group-2. Pour activer la corrélation entre les métriques et les journaux, la définition de cette variable suffit. Pour de plus amples informations, veuillez consulter Activation de la corrélation entre métriques et journaux. Pour activer la corrélation entre les suivis et les journaux, vous devez également modifier la configuration de journalisation de votre application. Pour de plus amples informations, veuillez consulter Activation de la corrélation entre suivis et journaux.

L’exemple suivant montre un script de démarrage qui permet d’activer la corrélation des journaux.
```
JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH" \
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORT=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="aws.log.group.names=$YOUR_APPLICATION_LOG_GROUP,service.name=$YOUR_SVC_NAME" \
java -jar $MY_JAVA_APP.jar
```

Python

Note

Si vous utilisez un serveur WSGI pour votre application Python, en plus des étapes décrites dans cette section, consultez Aucune donnée de la vigie applicative pour les applications Python qui utilisent un serveur WSGI pour savoir comment configurer la vigie applicative afin qu’elle fonctionne correctement.

Pour instrumenter vos applications Python dans le cadre de l'activation des signaux d'application sur une EC2 instance Amazon

Téléchargez la dernière version de l'agent d'auto-instrumentation AWS Distro for OpenTelemetry Python. Pour l'installer, exécutez la commande d' ci-dessous.
```
pip install aws-opentelemetry-distro
```
Vous pouvez consulter des informations sur toutes les versions publiées sur AWS Distro pour l'instrumentation OpenTelemetry Python.
Pour optimiser vos avantages d’Application Signals, utilisez des variables d’environnement pour fournir des informations supplémentaires avant de démarrer votre application. Ces informations seront affichées dans les tableaux de bord d’Application Signals.
1. Pour la variable OTEL_RESOURCE_ATTRIBUTES, spécifiez les informations suivantes sous forme de paires clé-valeur :
  - service.name défini le nom du service. Il sera affiché comme nom de service pour votre application dans les tableaux de bord d’Application Signals. Si vous ne fournissez pas de valeur pour cette clé, la valeur par défaut UnknownService est utilisée.
  - deployment.environment définit l’environnement dans lequel l’application s’exécute. Cet environnement sera affiché comme l’environnement hébergé de votre application dans les tableaux de bord Application Signals. Si vous ne le spécifiez pas, l’une des valeurs par défaut suivantes est utilisée :
    S’il s’agit d’une instance qui fait partie d’un groupe Auto Scaling, la valeur est ec2:name-of-Auto-Scaling-group.
    S'il s'agit d'une EC2 instance Amazon qui ne fait pas partie d'un groupe Auto Scaling, elle est définie sur ec2:default
    S’il s’agit d’un hôte sur site, la valeur est generic:default
    Cette clé d'attribut est utilisée uniquement par Application Signals et est convertie en annotations de trace X-Ray et en dimensions CloudWatch métriques.
2. Pour la OTEL_EXPORTER_OTLP_PROTOCOL variable, spécifiez d'http/protobufexporter les données de télémétrie via HTTP vers les points de terminaison de l' CloudWatch agent répertoriés dans les étapes suivantes.
3. Pour la variable OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, spécifiez l’URL du point de terminaison de base vers lequel les suivis doivent être exportés. L' CloudWatch agent expose 4316 comme port OTLP sur HTTP. Sur Amazon EC2, étant donné que les applications communiquent avec l' CloudWatch agent local, vous devez définir cette valeur sur OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
4. Pour la variable OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT, spécifiez l’URL du point de terminaison de base vers lequel les métriques doivent être exportées. L' CloudWatch agent expose 4316 comme port OTLP sur HTTP. Sur Amazon EC2, étant donné que les applications communiquent avec l' CloudWatch agent local, vous devez définir cette valeur sur OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
5. Pour la variable OTEL_METRICS_EXPORTER, nous vous recommandons de définir la valeur sur none. Cela désactive les autres exportateurs de métriques afin que seul l’exportateur d’Application Signals soit utilisé.
6. Définissez la OTEL_AWS_APPLICATION_SIGNALS_ENABLED variable sur true pour que votre conteneur commence à envoyer des traces et des CloudWatch métriques X-Ray à Application Signals.
Démarrez votre application avec les variables d’environnement décrites à l’étape précédente. Voici un exemple de script de démarrage.
- Remplacez $SVC_NAME par le nom de votre application. Ce nom apparaîtra comme nom de l’application dans les tableaux de bord de la vigie applicative.
- Remplacez $PYTHON_APP par l’emplacement et le nom de votre application.
```
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_PYTHON_DISTRO=aws_distro \
OTEL_PYTHON_CONFIGURATOR=aws_configurator \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_TRACES_SAMPLER=xray \
OTEL_TRACES_SAMPLER_ARG="endpoint=http://localhost:2000" \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="service.name=$SVC_NAME" \
opentelemetry-instrument python $MY_PYTHON_APP.py
```
Avant d’activer la vigie applicative pour vos applications Python, tenez compte des considérations suivantes.
- Dans certaines applications conteneurisées, l’absence de la variable d’environnement PYTHONPATH peut empêcher l’application de démarrer. Pour résoudre ce problème, veillez à définir la variable d’environnement PYTHONPATH sur le répertoire de travail de votre application. Cela est dû à un problème connu lié à l' OpenTelemetry auto-instrumentation. Pour plus d’informations sur ce problème, consultez la section Le paramètre d’instrumentation automatique Python pour PYTHONPATH n’est pas conforme.
- Pour les applications Django, des configurations supplémentaires sont requises, qui sont décrites dans la documentation OpenTelemetry Python.
  - Utilisez le paramètre --noreload pour empêcher le rechargement automatique.
  - Définissez la variable d’environnement DJANGO_SETTINGS_MODULE sur l’emplacement du fichier settings.py de votre application Django. Cela garantit que OpenTelemetry vous pouvez accéder et intégrer correctement vos paramètres Django.
(Facultatif) Pour activer la corrélation des journaux, ajoutez dans OTEL_RESOURCE_ATTRIBUTES une variable d’environnement supplémentaire aws.log.group.names pour les groupes de journaux de votre application. Cela permet de corréler les suivis et les métriques de votre application avec les entrées de journaux correspondantes. Pour cette variable, remplacez $YOUR_APPLICATION_LOG_GROUP par les noms des groupes de journaux de votre application. Si vous avez plusieurs groupes de journaux, vous pouvez les séparer à l’aide d’un esperluette (&), comme dans l’exemple suivant : aws.log.group.names=log-group-1&log-group-2. Pour activer la corrélation entre les métriques et les journaux, la définition de cette variable suffit. Pour de plus amples informations, veuillez consulter Activation de la corrélation entre métriques et journaux. Pour activer la corrélation entre les suivis et les journaux, vous devez également modifier la configuration de journalisation de votre application. Pour de plus amples informations, veuillez consulter Activation de la corrélation entre suivis et journaux.

L’exemple suivant montre un script de démarrage qui permet d’activer la corrélation des journaux.
```
OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_PYTHON_DISTRO=aws_distro \
OTEL_PYTHON_CONFIGURATOR=aws_configurator \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_TRACES_SAMPLER=xray \
OTEL_TRACES_SAMPLER_ARG="endpoint=http://localhost:2000" \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="aws.log.group.names=$YOUR_APPLICATION_LOG_GROUP,service.name=$YOUR_SVC_NAME" \
java -jar $MY_PYTHON_APP.jar
```

.NET

Pour instrumenter vos applications .NET dans le cadre de l'activation des signaux d'application sur une EC2 instance Amazon ou un hôte sur site

Téléchargez la dernière version du package d'auto-instrumentation AWS Distro pour OpenTelemetry .NET. Vous pouvez télécharger la dernière version sur aws-otel-dotnet-instrumentationReleases.

Pour activer la vigie applicative, définissez les variables d’environnement ci-dessous afin de fournir des informations supplémentaires avant de démarrer votre application. Ces variables sont nécessaires pour configurer le hook de démarrage pour l’instrumentation .NET avant le lancement de votre application .NET. Remplacez dotnet-service-name dans la variable d’environnement OTEL_RESOURCE_ATTRIBUTES par le nom du service de votre choix.

Voici un exemple pour Linux.


export INSTALL_DIR=OpenTelemetryDistribution
export CORECLR_ENABLE_PROFILING=1
export CORECLR_PROFILER={918728DD-259F-4A6A-AC2B-B85E1B658318}
export CORECLR_PROFILER_PATH=${INSTALL_DIR}/linux-x64/OpenTelemetry.AutoInstrumentation.Native.so
export DOTNET_ADDITIONAL_DEPS=${INSTALL_DIR}/AdditionalDeps
export DOTNET_SHARED_STORE=${INSTALL_DIR}/store
export DOTNET_STARTUP_HOOKS=${INSTALL_DIR}/net/OpenTelemetry.AutoInstrumentation.StartupHook.dll
export OTEL_DOTNET_AUTO_HOME=${INSTALL_DIR}

export OTEL_DOTNET_AUTO_PLUGINS="AWS.Distro.OpenTelemetry.AutoInstrumentation.Plugin, AWS.Distro.OpenTelemetry.AutoInstrumentation"

export OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4316
export OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://127.0.0.1:4316/v1/metrics
export OTEL_METRICS_EXPORTER=none
export OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true
export OTEL_TRACES_SAMPLER=xray
export OTEL_TRACES_SAMPLER_ARG=http://127.0.0.1:2000

Voici un exemple de configuration pour Windows Server.


$env:INSTALL_DIR = "OpenTelemetryDistribution"
$env:CORECLR_ENABLE_PROFILING = 1
$env:CORECLR_PROFILER = "{918728DD-259F-4A6A-AC2B-B85E1B658318}"
$env:CORECLR_PROFILER_PATH = Join-Path $env:INSTALL_DIR "win-x64/OpenTelemetry.AutoInstrumentation.Native.dll"
$env:DOTNET_ADDITIONAL_DEPS = Join-Path $env:INSTALL_DIR "AdditionalDeps"
$env:DOTNET_SHARED_STORE = Join-Path $env:INSTALL_DIR "store"
$env:DOTNET_STARTUP_HOOKS = Join-Path $env:INSTALL_DIR "net/OpenTelemetry.AutoInstrumentation.StartupHook.dll"
$env:OTEL_DOTNET_AUTO_HOME = $env:INSTALL_DIR

$env:OTEL_DOTNET_AUTO_PLUGINS = "AWS.Distro.OpenTelemetry.AutoInstrumentation.Plugin, AWS.Distro.OpenTelemetry.AutoInstrumentation"

$env:OTEL_RESOURCE_ATTRIBUTES = "service.name=dotnet-service-name"
$env:OTEL_EXPORTER_OTLP_PROTOCOL = "http/protobuf"
$env:OTEL_EXPORTER_OTLP_ENDPOINT = "http://127.0.0.1:4316"
$env:OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT = "http://127.0.0.1:4316/v1/metrics"
$env:OTEL_METRICS_EXPORTER = "none"
$env:OTEL_AWS_APPLICATION_SIGNALS_ENABLED = "true"
$env:OTEL_TRACES_SAMPLER = "xray"
$env:OTEL_TRACES_SAMPLER_ARG = "http://127.0.0.1:2000"

Démarrez votre application avec les variables d’environnement mentionnées à l’étape précédente.

(Facultatif) Vous pouvez également utiliser les scripts d'installation fournis pour faciliter l'installation et la configuration du package d'instrumentation automatique AWS Distro for OpenTelemetry .NET.

Pour Linux, téléchargez et installez le script d'installation de Bash depuis la page des GitHub versions :


# Download and Install
curl -L -O https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/aws-otel-dotnet-install.sh
chmod +x ./aws-otel-dotnet-install.sh
./aws-otel-dotnet-install.sh

# Instrument
. $HOME/.otel-dotnet-auto/instrument.sh
export OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name

Pour Windows Server, téléchargez et installez le script PowerShell d'installation depuis la page GitHub des versions :


# Download and Install
$module_url = "https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/AWS.Otel.DotNet.Auto.psm1"
$download_path = Join-Path $env:temp "AWS.Otel.DotNet.Auto.psm1"
Invoke-WebRequest -Uri $module_url -OutFile $download_path
Import-Module $download_path
Install-OpenTelemetryCore

# Instrument
Import-Module $download_path
Register-OpenTelemetryForCurrentSession -OTelServiceName "dotnet-service-name"
Register-OpenTelemetryForIIS

Vous pouvez trouver le NuGet package du package d'auto-instrumentation AWS Distro pour OpenTelemetry .NET dans le dépôt officiel NuGet . Assurez-vous de consulter le fichier README pour des instructions.

Node.js

Note

Si vous activez la vigie applicative pour une application Node.js utilisant le format ESM, consultez Setting up a Node.js application with the ESM module format avant de commencer ces étapes.

Pour instrumenter vos applications Node.js dans le cadre de l'activation des signaux d'application sur une EC2 instance Amazon

Téléchargez la dernière version de l'agent AWS Distro for OpenTelemetry JavaScript Auto-Instrumentation pour Node.js. Pour l'installer, exécutez la commande d' ci-dessous.
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
Vous pouvez consulter des informations sur toutes les versions publiées sur AWS Distro pour l' OpenTelemetry JavaScript instrumentation.
Pour optimiser vos avantages d’Application Signals, utilisez des variables d’environnement pour fournir des informations supplémentaires avant de démarrer votre application. Ces informations seront affichées dans les tableaux de bord d’Application Signals.
1. Pour la variable OTEL_RESOURCE_ATTRIBUTES, spécifiez les informations suivantes sous forme de paires clé-valeur :
  - service.name défini le nom du service. Il sera affiché comme nom de service pour votre application dans les tableaux de bord d’Application Signals. Si vous ne fournissez pas de valeur pour cette clé, la valeur par défaut UnknownService est utilisée.
  - deployment.environment définit l’environnement dans lequel l’application s’exécute. Cet environnement sera affiché comme l’environnement hébergé de votre application dans les tableaux de bord Application Signals. Si vous ne le spécifiez pas, l’une des valeurs par défaut suivantes est utilisée :
    S’il s’agit d’une instance qui fait partie d’un groupe Auto Scaling, la valeur est ec2:name-of-Auto-Scaling-group.
    S'il s'agit d'une EC2 instance Amazon qui ne fait pas partie d'un groupe Auto Scaling, elle est définie sur ec2:default
    S’il s’agit d’un hôte sur site, la valeur est generic:default
    Cette clé d'attribut est utilisée uniquement par Application Signals et est convertie en annotations de trace X-Ray et en dimensions CloudWatch métriques.
2. Pour la OTEL_EXPORTER_OTLP_PROTOCOL variable, spécifiez d'http/protobufexporter les données de télémétrie via HTTP vers les points de terminaison de l' CloudWatch agent répertoriés dans les étapes suivantes.
3. Pour la variable OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, spécifiez l’URL du point de terminaison de base vers lequel les suivis doivent être exportés. L' CloudWatch agent expose 4316 comme port OTLP sur HTTP. Sur Amazon EC2, étant donné que les applications communiquent avec l' CloudWatch agent local, vous devez définir cette valeur sur OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces
4. Pour la variable OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT, spécifiez l’URL du point de terminaison de base vers lequel les métriques doivent être exportées. L' CloudWatch agent expose 4316 comme port OTLP sur HTTP. Sur Amazon EC2, étant donné que les applications communiquent avec l' CloudWatch agent local, vous devez définir cette valeur sur OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics
5. Pour la variable OTEL_METRICS_EXPORTER, nous vous recommandons de définir la valeur sur none. Cela désactive les autres exportateurs de métriques afin que seul l’exportateur d’Application Signals soit utilisé.
6. Définissez la OTEL_AWS_APPLICATION_SIGNALS_ENABLED variable sur true pour que votre conteneur commence à envoyer des traces et des CloudWatch métriques X-Ray à Application Signals.

Démarrez votre application avec les variables d’environnement décrites à l’étape précédente. Voici un exemple de script de démarrage.

Remplacez $SVC_NAME par le nom de votre application. Ce nom apparaîtra comme nom de l’application dans les tableaux de bord de la vigie applicative.


OTEL_METRICS_EXPORTER=none \
OTEL_LOGS_EXPORTER=none \
OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
OTEL_TRACES_SAMPLER=xray \
OTEL_TRACES_SAMPLER_ARG="endpoint=http://localhost:2000" \
OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
OTEL_RESOURCE_ATTRIBUTES="service.name=$SVC_NAME" \
node --require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register' your-application.js

(Facultatif) Pour activer la corrélation des journaux, ajoutez dans OTEL_RESOURCE_ATTRIBUTES une variable d’environnement supplémentaire aws.log.group.names pour les groupes de journaux de votre application. Cela permet de corréler les suivis et les métriques de votre application avec les entrées de journaux correspondantes. Pour cette variable, remplacez $YOUR_APPLICATION_LOG_GROUP par les noms des groupes de journaux de votre application. Si vous avez plusieurs groupes de journaux, vous pouvez les séparer à l’aide d’un esperluette (&), comme dans l’exemple suivant : aws.log.group.names=log-group-1&log-group-2. Pour activer la corrélation entre les métriques et les journaux, la définition de cette variable suffit. Pour de plus amples informations, veuillez consulter Activation de la corrélation entre métriques et journaux. Pour activer la corrélation entre les suivis et les journaux, vous devez également modifier la configuration de journalisation de votre application. Pour de plus amples informations, veuillez consulter Activation de la corrélation entre suivis et journaux.

L’exemple suivant montre un script de démarrage qui permet d’activer la corrélation des journaux.
```
export OTEL_METRICS_EXPORTER=none \
export OTEL_LOGS_EXPORTER=none \
export OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true \
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
export OTEL_TRACES_SAMPLER=xray \
export OTEL_TRACES_SAMPLER_ARG=endpoint=http://localhost:2000 \
export OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics \
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces \
export OTEL_RESOURCE_ATTRIBUTES="aws.log.group.names=$YOUR_APPLICATION_LOG_GROUP,service.name=$SVC_NAME" \
node --require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register' your-application.js
```

Configuration d’une application Node.js utilisant le format de module ESM

Un support limité est disponible pour les applications Node.js utilisant le format de module ESM. Pour en savoir plus, consultez Limitations connues concernant Node.js avec ESM.

Pour activer la vigie applicative pour une application Node.js utilisant le format ESM, vous devez adapter les étapes de la procédure précédente.

Tout d’abord, installez @opentelemetry/instrumentation pour votre application Node.js :


npm install @opentelemetry/instrumentation@0.54.0

Ensuite, aux étapes 3 et 4 de la procédure précédente, modifiez les options du nœud :


--require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register'

par :


--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs

Activez les signaux d'application sur Amazon EC2 à l'aide du protocole MCP (Model Context Protocol)

Vous pouvez utiliser le serveur MCP ( CloudWatch Application Signals Model Context Protocol) pour activer les signaux d'application sur vos EC2 instances Amazon par le biais d'interactions conversationnelles basées sur l'IA. Cela fournit une interface en langage naturel pour configurer la surveillance des signaux d'application.

Le serveur MCP automatise le processus d'activation en comprenant vos besoins et en générant la configuration appropriée. Au lieu de suivre manuellement les étapes de configuration, vous pouvez simplement décrire ce que vous souhaitez activer.

Conditions préalables

Avant d'utiliser le serveur MCP pour activer les signaux d'application, assurez-vous d'avoir :

Un environnement de développement compatible avec MCP (tel que Kiro, Claude Desktop, VSCode avec des extensions MCP ou d'autres outils compatibles avec MCP)
Le serveur MCP CloudWatch Application Signals configuré dans votre IDE. Pour des instructions de configuration détaillées, consultez la documentation du serveur MCP CloudWatch Application Signals.

Utilisation du serveur MCP

Une fois que vous avez configuré le serveur MCP CloudWatch Application Signals dans votre IDE, vous pouvez demander des conseils d'activation à l'aide d'instructions en langage naturel. Bien que l'assistant de codage puisse déduire le contexte à partir de la structure de votre projet, le fait de fournir des informations spécifiques dans vos instructions permet de garantir des conseils plus précis et plus pertinents. Incluez des informations telles que la langue de votre application, les détails de l'instance et les chemins absolus vers votre infrastructure et votre code d'application.

Instructions relatives aux meilleures pratiques (spécifiques et complètes) :


"Enable Application Signals for my Python service running on EC2.
My app code is in /home/ec2-user/flask-api and IaC is in /home/ec2-user/flask-api/terraform"

"I want to add observability to my Java application on EC2.
The application code is at /opt/apps/checkout-service and
the infrastructure code is at /opt/apps/checkout-service/cloudformation"

"Help me instrument my Node.js application on EC2 with Application Signals.
Application directory: /home/ubuntu/payment-api
Terraform code: /home/ubuntu/payment-api/terraform"

Des instructions moins efficaces :


"Enable monitoring for my app"
→ Missing: platform, language, paths

"Enable Application Signals. My code is in ./src and IaC is in ./infrastructure"
→ Problem: Relative paths instead of absolute paths

"Enable Application Signals for my EC2 service at /home/user/myapp"
→ Missing: programming language

Modèle rapide :


"Enable Application Signals for my [LANGUAGE] service on EC2.
App code: [ABSOLUTE_PATH_TO_APP]
IaC code: [ABSOLUTE_PATH_TO_IAC]"

Avantages de l'utilisation du serveur MCP

L'utilisation du serveur MCP CloudWatch Application Signals présente plusieurs avantages :

Interface en langage naturel : décrivez ce que vous souhaitez activer sans mémoriser les commandes ou la syntaxe de configuration
Conseils contextuels : le serveur MCP comprend votre environnement spécifique et fournit des recommandations personnalisées
Réduction des erreurs : la génération automatique de configuration minimise les erreurs de saisie manuelle
Configuration plus rapide : passez plus rapidement de l'intention à la mise en œuvre
Outil d'apprentissage : découvrez les configurations générées et comprenez le fonctionnement des signaux d'application

Pour plus d'informations sur la configuration et l'utilisation du serveur CloudWatch Application Signals MCP, consultez la documentation du serveur MCP.

(Facultatif) Surveiller l’état de votre application

Une fois que vous avez activé vos applications sur Amazon EC2, vous pouvez surveiller leur état de santé. Pour de plus amples informations, veuillez consulter Surveillez l’état de fonctionnement de vos applications avec Application Signals.

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

Activation de vos applications sur des clusters Amazon EKS

Activation des applications sur Amazon ECS