É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 (Facultatif) Étape 4 : Surveiller l'état de santé 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 OpenTelemetry compatibilité avant d'activer les signaux d'application.

Étape 1 : activer Application Signals dans votre compte

Vous devez d'abord activer Application Signals dans votre compte. Si ce n'est pas le cas, voyezActivez les signaux d'application 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 une version ultérieure prennent en charge les signaux CloudWatch d'application.

Pour plus d'informations sur le téléchargement de CloudWatch l'agent, consultezTéléchargez le package de CloudWatch l'agent.
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 /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 les autorisations pour les hôtes locaux, consultezAutorisations pour les serveurs locaux.
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 locaux

Dans le cas d'un hôte sur site, vous devez fournir une AWS autorisation à votre appareil.

Pour configurer les autorisations pour un hôte local

Créez l'utilisateur IAM à utiliser pour fournir des autorisations à votre hôte local :
1. Ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.
2. Choisissez Utilisateurs, puis Créer un utilisateur.
3. Dans Détails de l'utilisateur, dans Nom d'utilisateur, entrez le nom du 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, sous Options d'autorisations, sélectionnez Joindre 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. Choisissez 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, choisissez Utilisateurs, puis sélectionnez le nom d'utilisateur de l'utilisateur que vous avez créé à l'étape précédente.
2. Sur la page de l'utilisateur, choisissez l'onglet Informations d'identification de sécurité. Ensuite, dans la section Clés d'accès, choisissez Créer une clé d'accès.
3. Pour l'étape 1 de création d'une clé d'accès, choisissez Command Line Interface (CLI).
4. Pour l'étape 2 de création d'une clé d'accès, entrez éventuellement une balise, puis choisissez Next.
5. Pour l'étape 3 de création d'une clé d'accès, 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 avez besoin de ces informations pour les prochaines étapes.
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. Il sera affiché comme nom de service pour votre application dans les tableaux de bord des signaux d'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 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, elle est définie sur 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 local, il est configuré sur 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 répertorié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 journauxOTEL_RESOURCE_ATTRIBUTES, définissez une variable d'environnement supplémentaire aws.log.group.names pour les groupes de journaux de votre application. Ce faisant, les traces et les métriques de votre application peuvent être corrélées aux entrées de journal pertinentes de ces groupes de journaux. Pour cette variable, remplacez-la $YOUR_APPLICATION_LOG_GROUP par les noms des groupes de journaux de votre application. Si vous avez plusieurs groupes de journaux, vous pouvez utiliser une esperluette (&) pour les séparer comme dans cet exemple :. aws.log.group.names=log-group-1&log-group-2 Pour activer la corrélation entre les métriques et les logs, il suffit de définir cette variable environnementale actuelle. Pour de plus amples informations, veuillez consulter Activer la corrélation entre les métriques et les journaux. Pour activer la corrélation entre le suivi et le journal, vous devez également modifier la configuration de journalisation dans votre application. Pour de plus amples informations, veuillez consulter Activer la corrélation entre le traçage et le journal.

Voici un exemple de script de démarrage qui permet d'activer la corrélation des logs.
```
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, outre les étapes suivantes décrites dans cette section, consultez les informations Aucune donnée de signal d'application pour une application Python utilisant un serveur WSGI permettant de faire fonctionner les signaux d'application.

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, elle est définie surec2: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 local, il est configuré sur 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. Il sera affiché sous forme de nom de l'application, dans les tableaux de bord des signaux d'application.
- 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 les signaux d'application pour vos applications Python, tenez compte des points suivants.
- Dans certaines applications conteneurisées, PYTHONPATH l'absence d'une variable d'environnement peut parfois empêcher l'application de démarrer. Pour résoudre ce problème, veillez à définir la variable d'PYTHONPATHenvironnement à l'emplacement du 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'auto-instrumentation Python de 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 --noreload drapeau pour empêcher le rechargement automatique.
  - Définissez la variable d'DJANGO_SETTINGS_MODULEenvironnement sur l'emplacement du settings.py fichier 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 journauxOTEL_RESOURCE_ATTRIBUTES, définissez une variable d'environnement supplémentaire aws.log.group.names pour les groupes de journaux de votre application. Ce faisant, les traces et les métriques de votre application peuvent être corrélées aux entrées de journal pertinentes de ces groupes de journaux. Pour cette variable, remplacez-la $YOUR_APPLICATION_LOG_GROUP par les noms des groupes de journaux de votre application. Si vous avez plusieurs groupes de journaux, vous pouvez utiliser une esperluette (&) pour les séparer comme dans cet exemple :. aws.log.group.names=log-group-1&log-group-2 Pour activer la corrélation entre les métriques et les logs, il suffit de définir cette variable environnementale actuelle. Pour de plus amples informations, veuillez consulter Activer la corrélation entre les métriques et les journaux. Pour activer la corrélation entre le suivi et le journal, vous devez également modifier la configuration de journalisation dans votre application. Pour de plus amples informations, veuillez consulter Activer la corrélation entre le traçage et le journal.

Voici un exemple de script de démarrage qui permet d'activer la corrélation des logs.
```
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 les signaux d'application, définissez les variables d'environnement suivantes 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 de démarrer votre application .NET. Remplacez dotnet-service-name la variable d'OTEL_RESOURCE_ATTRIBUTESenvironnement 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 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 répertorié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 obtenir des instructions.

Node.js

Note

Si vous activez les signaux d'application pour une application Node.js avec ESM, consultez ces étapes Setting up a Node.js application with the ESM module format avant de commencer.

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, elle est définie surec2: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 local, il est configuré sur 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. Il sera affiché sous forme de nom de l'application, dans les tableaux de bord des signaux d'application.


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 journauxOTEL_RESOURCE_ATTRIBUTES, définissez une variable d'environnement supplémentaire aws.log.group.names pour les groupes de journaux de votre application. Ce faisant, les traces et les métriques de votre application peuvent être corrélées aux entrées de journal pertinentes de ces groupes de journaux. Pour cette variable, remplacez-la $YOUR_APPLICATION_LOG_GROUP par les noms des groupes de journaux de votre application. Si vous avez plusieurs groupes de journaux, vous pouvez utiliser une esperluette (&) pour les séparer comme dans cet exemple :. aws.log.group.names=log-group-1&log-group-2 Pour activer la corrélation entre les métriques et les logs, il suffit de définir cette variable environnementale actuelle. Pour de plus amples informations, veuillez consulter Activer la corrélation entre les métriques et les journaux. Pour activer la corrélation entre le suivi et le journal, vous devez également modifier la configuration de journalisation dans votre application. Pour de plus amples informations, veuillez consulter Activer la corrélation entre le traçage et le journal.

Voici un exemple de script de démarrage qui permet d'activer la corrélation des logs.
```
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 au format du module ESM

Nous fournissons un support limité pour les applications Node.js au format de module ESM. Pour en savoir plus, consultez Limitations connues concernant Node.js avec ESM.

Pour activer les signaux d'application pour une application Node.js avec ESM, vous devez modifier 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 comme suit :


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

à ce qui suit :


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

(Facultatif) Étape 4 : Surveiller l'état de santé 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

Activez vos applications sur les clusters Amazon EKS

Activez vos applications sur Amazon ECS