# Habilitación de Application Signals en Amazon EC2
Habilite CloudWatch Application Signals en Amazon EC2 mediante los pasos de configuración personalizados de estas secciones.
Para las aplicaciones que se ejecutan en Amazon EC2, instale y configure el agente de CloudWatch y AWS Distro para OpenTelemetry. En estas arquitecturas habilitadas con una configuración personalizada de Application Signals, Application Signals no detecta automáticamente los nombres de los servicios ni los hosts o clústeres en los que se ejecutan. Debe especificar estos nombres durante la configuración personalizada, y los nombres que especifique son los que aparecen en los paneles de Application Signals.
Las instrucciones de esta sección son para aplicaciones de Java, Python y .NET. Estos pasos se probaron en instancias de Amazon EC2, pero también se espera que funcionen en otras arquitecturas compatibles con AWS Distro para OpenTelemetry.
**Requisitos**
+ Para obtener compatibilidad con Application Signals, debe usar la versión más reciente del agente CloudWatch y del agente AWS Distro para OpenTelemetry.
+ Debe tener instalado la AWS CLI en la instancia. Recomendamos la AWS CLI versión 2, pero la versión 1 también debería funcionar. Para obtener información sobre cómo instalar AWS CLI, consulte [Instalar o actualizar la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**importante**
Si ya utiliza OpenTelemetry con una aplicación que pretende habilitar para Application Signals, consulte [Sistemas compatibles](CloudWatch-Application-Signals-supportmatrix.md) antes de activar Application Signals.
## Paso 1: habilitar Application Signals en la cuenta
Primero debe habilitar Application Signals en su cuenta. Si no lo ha hecho, consulte [Habilitación de Application Signals en su cuenta](CloudWatch-Application-Signals-Enable.md).
## Paso 2: descargar e iniciar el agente de CloudWatch
**Para instalar el agente de CloudWatch como parte de la activación de Application Signals en una instancia de Amazon EC2 o en un host en las instalaciones**
1. Descargue la última versión del agente de CloudWatch en la instancia. Si la instancia ya tiene el agente de CloudWatch instalado, es posible que tenga que actualizarlo. Solo las versiones del agente publicadas el 30 de noviembre de 2023 o después son compatibles con CloudWatch Application Signals.
1. Antes de iniciar el agente de CloudWatch, configúrelo para habilitar Application Signals. El siguiente ejemplo es una configuración de agente de CloudWatch que habilita Application Signals para métricas y seguimientos en un host EC2.
Recomendamos que ubique este archivo en `/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json` en los sistemas Linux.
```
{
"traces": {
"traces_collected": {
"application_signals": {}
}
},
"logs": {
"metrics_collected": {
"application_signals": {}
}
}
}
```
1. Adjunte la política de IAM **CloudWatchAgentServerPolicy** al rol de IAM de su instancia de Amazon EC2. Para conocer sobre los permisos para los hosts en las instalaciones, consulte [Permisos para los servidores en las instalaciones](#Enable-OnPremise-Permissions).
1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles** y busque el rol que usa la instancia de Amazon EC2. A continuación, elija el nombre de esa función.
1. En la pestaña **Permisos**, elija **Añadir permisos**, **Asociar políticas**.
1. Busque **CloudWatchAgentServerPolicy**. Use el cuadro de búsqueda si es necesario. Seleccione la casilla de verificación de la política y elija **Añadir permisos**.
1. Para iniciar el agente de CloudWatch, introduzca uno de los siguientes comandos. Reemplace {{agent-config-file-path}} por la ruta al archivo de configuración del agente CloudWatch, como `./amazon-cloudwatch-agent.json`. Debe incluir el prefijo `file:` tal y como se muestra.
```
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}}
```
### Permisos para los servidores en las instalaciones
En el caso de un host en las instalaciones, tendrá que brindar autorización de AWS para su dispositivo.
**Configuración de los permisos de un host en las instalaciones**
1. Cree el usuario de IAM que se utilizará para conceder los permisos a su host en las instalaciones:
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Seleccione **Usuarios**, **Crear nuevos usuarios**.
1. En **Detalles del usuario**, en **Nombre de usuario**, introduzca un nombre para el nuevo usuario de IAM. Este es su nombre de inicio de sesión de AWS y lo utilizará para autenticar su host. A continuación, elija **Siguiente**.
1. En la página **Establecer permisos**, en **Opciones de permisos**, seleccione **Adjuntar políticas directamente**.
1. En la lista de **Políticas de permisos**, seleccione la política **CloudWatchAgentServerPolicy** para agregarla a su usuario. A continuación, elija **Siguiente**.
1. En la página **Revisar y crear**, asegúrese de que esté satisfecho con el nombre de usuario y de que la política **CloudWatchAgentServerPolicy** aparezca en **Resumen de permisos**.
1. Seleccione la opción **Crear usuario**.
1. Cree y recupere su clave de acceso y su clave secreta de AWS:
1. En el panel de navegación de la consola de IAM, seleccione **Usuarios** y, a continuación, seleccione el nombre de usuario que creó en el paso anterior.
1. En la página del usuario, seleccione la pestaña **Credenciales de seguridad**. A continuación, en la sección **Claves de acceso**, seleccione **Crear clave de acceso**.
1. En el **paso 1 de Crear clave de acceso**, elija **Interfaz de línea de comandos (CLI)**.
1. En el **Paso 2 de Crear clave de acceso**, como opción, introduzca una etiqueta y seleccione **Siguiente**.
1. En el **Paso 3 de Crear clave de acceso**, seleccione **Descargar archivo .csv** para guardar un archivo .cvs con la clave de acceso y la clave de acceso secreta de su usuario de IAM. Necesita esta información para los siguientes pasos.
1. Seleccione **Listo**.
1. Introduzca el siguiente comando para configurar sus credenciales de AWS en su host en las instalaciones. Sustituya {{ACCESS\_KEY\_ID}} y {{SECRET\_ACCESS\_ID}} por la clave de acceso y la clave de acceso secreta que generó recién y que se encuentran en archivo .csv que descargó en el paso anterior.
```
$ 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
```
## Paso 3: instrumentar la aplicación e iníciela
El siguiente paso es configurar la aplicación para CloudWatch Application Signals.
------
#### [ Java ]
**Para instrumentar las aplicaciones de Java como parte de la habilitación de Application Signals en una instancia de Amazon EC2 o un host en las instalaciones**
1. Descargue la última versión del agente de autoinstrumentación de AWS Distro para OpenTelemetry de Java. Puede descargar la última versión mediante [este enlace](https://github.com/aws-observability/aws-otel-java-instrumentation/releases/latest/download/aws-opentelemetry-agent.jar). Puede ver información sobre todas las versiones publicadas en [aws-otel-java-instrumentation Lanzamientos](https://github.com/aws-observability/aws-otel-java-instrumentation/releases).
1. Para optimizar las ventajas de Application Signals, utilice variables de entorno para proporcionar información adicional antes de iniciar la aplicación. Esta información se mostrará en los paneles de Application Signals.
1. Para la variable `OTEL_RESOURCE_ATTRIBUTES`, especifique la siguiente información como pares clave-valor:
+ (Opcional) `service.name` establece el nombre del servicio. Esto se mostrará como el nombre del servicio de la aplicación en los paneles de Application Signals. Si no proporciona ningún valor para esta clave, se utiliza el valor predeterminado de `UnknownService`.
+ (Opcional) `deployment.environment` establece el entorno en el que se ejecuta la aplicación. Se mostrará como el entorno **alojado en** de la aplicación en los paneles de Application Signals. Si esto no se especifica, se utilizará uno de los siguientes valores predeterminados:
+ Si se trata de una instancia que forma parte de un grupo de escalado automático, se establece en `ec2:{{name-of-Auto-Scaling-group}}`
+ Si se trata de una instancia de Amazon EC2 que no forma parte de un grupo de escalado automático, se establece en `ec2:default`
+ Si se trata de un host en las instalaciones, se establece en `generic:default`
Esta variable de entorno solo la usa Application Signals y se convierte en anotaciones de seguimientos de X-Ray y dimensiones métricas de CloudWatch.
+ Para la variable `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, especifique la URL del punto de conexión base a la que se van a exportar los seguimientos. El agente CloudWatch expone el 4316 como el puerto OLTP. En Amazon EC2, dado que las aplicaciones se comunican con el agente local de CloudWatch, debe establecer este valor en `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
+ Para la variable `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT`, especifique la URL del punto de conexión base a la que se van a exportar las métricas. El agente CloudWatch expone el 4316 como el puerto OLTP. En Amazon EC2, dado que las aplicaciones se comunican con el agente local de CloudWatch, debe establecer este valor en `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
+ Para la variable `JAVA_TOOL_OPTIONS`, especifique la ruta en la que se almacena el agente de autoinstrumentación AWS Distro para OpenTelemetry de Java.
```
export JAVA_TOOL_OPTIONS=" -javaagent:{{$AWS_ADOT_JAVA_INSTRUMENTATION_PATH}}"
```
Por ejemplo:
```
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH=./aws-opentelemetry-agent.jar
```
+ Para la variable `OTEL_METRICS_EXPORTER`, se recomienda establecer el valor en `none`. Esto deshabilita otros exportadores de métricas para que solo se utilice el exportador de Application Signals.
+ Establece `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` en `true`. Esto genera métricas de Application Signals a partir de los seguimientos.
1. Inicie la aplicación con las variables de entorno enumeradas en el paso anterior. A continuación se muestra un ejemplo de un script de inicio.
**nota**
La siguiente configuración solo es compatible con las versiones 1.32.2 y posteriores del agente de autoinstrumentación de AWS Distro para OpenTelemetry para 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
```
1. (Opcional) Para habilitar la correlación de registros, en `OTEL_RESOURCE_ATTRIBUTES` defina una variable de entorno adicional `aws.log.group.names` como nombre de los grupos de registro de su aplicación. De este modo, los seguimientos y métricas de su aplicación se pueden correlacionar con las entradas de registro correspondientes de estos grupos de registro. En esta variable, sustituya {{$YOUR\_APPLICATION\_LOG\_GROUP}} con los nombres de los grupos de registro de su aplicación. Si tiene varios grupos de registro, puede usar el signo `&` para separarlos, como en este ejemplo: `aws.log.group.names=log-group-1&log-group-2`. Para habilitar la correlación entre métricas y registros, basta con establecer esta variable de entorno actual. Para obtener más información, consulte [Habilitación de la correlación entre métricas y registros](Application-Signals-MetricLogCorrelation.md). Para habilitar la correlación entre seguimientos y registros, también debe cambiar la configuración de registro de su aplicación. Para obtener más información, consulte [Habilitación de la correlación entre seguimientos y registros](Application-Signals-TraceLogCorrelation.md).
A continuación, se muestra un ejemplo de un script de inicio que ayuda a habilitar la correlación de registros.
```
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 ]
**nota**
Si utiliza un servidor WSGI para su aplicación de Python, además de los siguientes pasos de esta sección, consulte [No hay datos de Application Signals para la aplicación de Python que usa un servidor WSGI](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-Python-WSGI) para obtener información sobre cómo hacer que Application Signals funcione.
**Instrumentación de aplicaciones Python como parte de la activación de Application Signals en una instancia de Amazon EC2**
1. Descargue la última versión del agente de autoinstrumentación de AWS Distro para OpenTelemetry de Python. Instálelo ejecutando el siguiente comando de .
```
pip install aws-opentelemetry-distro
```
Puede ver información sobre todas las versiones publicadas en [AWS Distro for OpenTelemetry Python instrumentation](https://github.com/aws-observability/aws-otel-python-instrumentation/releases).
1. Para optimizar las ventajas de Application Signals, utilice variables de entorno para proporcionar información adicional antes de iniciar la aplicación. Esta información se mostrará en los paneles de Application Signals.
1. Para la variable `OTEL_RESOURCE_ATTRIBUTES`, especifique la siguiente información como pares clave-valor:
+ `service.name` establece el nombre del servicio. Se mostrará como el nombre del servicio de la aplicación en los paneles de Application Signals. Si no proporciona ningún valor para esta clave, se utiliza el valor predeterminado de `UnknownService`.
+ `deployment.environment` establece el entorno en el que se ejecuta la aplicación. Se mostrará como el entorno **alojado en** de la aplicación en los paneles de Application Signals. Si esto no se especifica, se utilizará uno de los siguientes valores predeterminados:
+ Si se trata de una instancia que forma parte de un grupo de escalado automático, se establece en `ec2:{{name-of-Auto-Scaling-group}}`.
+ Si se trata de una instancia de Amazon EC2 que no forma parte de un grupo de escalado automático, se establece en `ec2:default`
+ Si se trata de un host en las instalaciones, se establece en `generic:default`
Esta clave de atributo solo la usa Application Signals y se convierte en anotaciones de trazas de X-Ray y dimensiones métricas de CloudWatch.
1. Para la variable `OTEL_EXPORTER_OTLP_PROTOCOL`, especifique `http/protobuf` para exportar datos de telemetría a través de HTTP a los puntos de conexión del agente de CloudWatch que se enumeran en los siguientes pasos.
1. Para la variable `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, especifique la URL del punto de conexión base a la que se van a exportar los seguimientos. El agente de CloudWatch expone 4316 como su puerto OTLP a través de HTTP. En Amazon EC2, dado que las aplicaciones se comunican con el agente local de CloudWatch, debe establecer este valor en `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
1. Para la variable `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT`, especifique la URL del punto de conexión base a la que se van a exportar las métricas. El agente de CloudWatch expone 4316 como su puerto OTLP a través de HTTP. En Amazon EC2, dado que las aplicaciones se comunican con el agente local de CloudWatch, debe establecer este valor en `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
1. Para la variable `OTEL_METRICS_EXPORTER`, se recomienda establecer el valor en `none`. Esto deshabilita otros exportadores de métricas para que solo se utilice el exportador de Application Signals.
1. Establezca la variable `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` en `true` para que su contenedor comience a enviar seguimientos de X-Ray y métricas de CloudWatch a Application Signals.
1. Inicie la aplicación con las variables de entorno descritas en el paso anterior. A continuación se muestra un ejemplo de un script de inicio.
+ Sustituya `$SVC_NAME` por el nombre de la aplicación. Esto se mostrará como el nombre de la aplicación, en los paneles de Application Signals.
+ Sustituya `$PYTHON_APP` por la ubicación y el nombre de la aplicación.
```
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}}
```
Antes de activar las señales de aplicación para sus aplicaciones Python, debe tener en cuenta las consideraciones siguientes.
+ En algunas aplicaciones en contenedores, la falta de una variable de entorno `PYTHONPATH` a veces puede provocar que la aplicación no se inicie. Para solucionar este problema, asegúrese de configurar la variable de entorno `PYTHONPATH` en la ubicación del directorio de trabajo de la aplicación. Esto se debe a un problema conocido con la instrumentación automática de OpenTelemetry. Para obtener más información sobre este problema, consulte [Python autoinstrumentation setting of PYTHONPATH is not compliant](https://github.com/open-telemetry/opentelemetry-operator/issues/2302).
+ Para las aplicaciones de Django, se requieren configuraciones adicionales, que se describen en la [documentación de Python de OpenTelemetry](https://opentelemetry-python.readthedocs.io/en/latest/examples/django/README.html).
+ Use el indicador `--noreload` para evitar la recarga automática.
+ Establezca la variable de entorno `DJANGO_SETTINGS_MODULE` en la ubicación del archivo `settings.py` de su aplicación Django. Esto garantiza que OpenTelemetry pueda acceder correctamente a la configuración de Django e integrarse correctamente con ella.
1. (Opcional) Para habilitar la correlación de registros, en `OTEL_RESOURCE_ATTRIBUTES` defina una variable de entorno adicional `aws.log.group.names` como nombre de los grupos de registro de su aplicación. De este modo, los seguimientos y métricas de su aplicación se pueden correlacionar con las entradas de registro correspondientes de estos grupos de registro. En esta variable, sustituya {{$YOUR\_APPLICATION\_LOG\_GROUP}} con los nombres de los grupos de registro de su aplicación. Si tiene varios grupos de registro, puede usar el signo `&` para separarlos, como en este ejemplo: `aws.log.group.names=log-group-1&log-group-2`. Para habilitar la correlación entre métricas y registros, basta con establecer esta variable de entorno actual. Para obtener más información, consulte [Habilitación de la correlación entre métricas y registros](Application-Signals-MetricLogCorrelation.md). Para habilitar la correlación entre seguimientos y registros, también debe cambiar la configuración de registro de su aplicación. Para obtener más información, consulte [Habilitación de la correlación entre seguimientos y registros](Application-Signals-TraceLogCorrelation.md).
A continuación, se muestra un ejemplo de un script de inicio que ayuda a habilitar la correlación de registros.
```
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 ]
**Para instrumentar las aplicaciones de .NET como parte de la habilitación de Application Signals en una instancia de Amazon EC2 o un host en las instalaciones**
1. Descargue la versión más reciente del paquete de autoinstrumentación de .NET de Distro para OpenTelemetry de AWS. Puede descargar la versión más reciente en [Versiones aws-otel-dotnet-instrumentation](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases).
1. Para habilitar Application Signals, establezca las siguientes variables de entorno para proporcionar información adicional antes de iniciar la aplicación. Estas variables son necesarias para configurar el enlace de inicio de la instrumentación .NET antes de iniciar la aplicación .NET. Sustituya `dotnet-service-name` en la variable de entorno `OTEL_RESOURCE_ATTRIBUTES` por el nombre de servicio que prefiera.
+ A continuación se muestra un ejemplo para 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
```
+ El siguiente es un ejemplo que se aplica a 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"
```
1. Inicie la aplicación con las variables de entorno enumeradas en el paso anterior.
(Opcional) Como alternativa, puede utilizar los scripts de instalación proporcionados para facilitar la instalación y la configuración del paquete de autoinstrumentación de AWS Distro para OpenTelemetry .NET.
En Linux, descargue y ejecute el script de instalación de Bash desde la página de versiones de GitHub:
```
# 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
```
En Windows Server, descargue y ejecute el script de instalación de PowerShell desde la página de versiones de GitHub:
```
# 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
```
Puede encontrar el paquete NuGet del paquete de autoinstrumentación de AWS Distro para OpenTelemetry .NET en el [repositorio oficial de NuGet](https://www.nuget.org/packages/AWS.Distro.OpenTelemetry.AutoInstrumentation). Asegúrese de consultar las instrucciones en el [archivo README](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/blob/main/src/AWS.Distro.OpenTelemetry.AutoInstrumentation/nuget-readme.md).
------
#### [ Node.js ]
**nota**
Si desea habilitar Application Signals para una aplicación Node.js con ESM, consulte [Setting up a Node.js application with the ESM module format](#EC2-NodeJs-ESM) antes de seguir estos pasos.
**Para instrumentar aplicaciones de Node.js como parte de la activación de Application Signals en una instancia de Amazon EC2:**
1. Descargue la última versión del agente de instrumentación automática de AWS Distro para OpenTelemetry de JavaScript para Node.js. Instálelo ejecutando el siguiente comando de .
```
npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
```
Puede ver información sobre todas las versiones publicadas en [AWS Distro for OpenTelemetry JavaScript instrumentation](https://github.com/aws-observability/aws-otel-js-instrumentation/releases).
1. Para optimizar las ventajas de Application Signals, utilice variables de entorno para proporcionar información adicional antes de iniciar la aplicación. Esta información se mostrará en los paneles de Application Signals.
1. Para la variable `OTEL_RESOURCE_ATTRIBUTES`, especifique la siguiente información como pares clave-valor:
+ `service.name` establece el nombre del servicio. Se mostrará como el nombre del servicio de la aplicación en los paneles de Application Signals. Si no proporciona ningún valor para esta clave, se utiliza el valor predeterminado de `UnknownService`.
+ `deployment.environment` establece el entorno en el que se ejecuta la aplicación. Se mostrará como el entorno **alojado en** de la aplicación en los paneles de Application Signals. Si esto no se especifica, se utilizará uno de los siguientes valores predeterminados:
+ Si se trata de una instancia que forma parte de un grupo de escalado automático, se establece en `ec2:{{name-of-Auto-Scaling-group}}`.
+ Si se trata de una instancia de Amazon EC2 que no forma parte de un grupo de escalado automático, se establece en `ec2:default`
+ Si se trata de un host en las instalaciones, se establece en `generic:default`
Esta clave de atributo solo la usa Application Signals y se convierte en anotaciones de trazas de X-Ray y dimensiones métricas de CloudWatch.
1. Para la variable `OTEL_EXPORTER_OTLP_PROTOCOL`, especifique `http/protobuf` para exportar datos de telemetría a través de HTTP a los puntos de conexión del agente de CloudWatch que se enumeran en los siguientes pasos.
1. Para la variable `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, especifique la URL del punto de conexión base a la que se van a exportar los seguimientos. El agente de CloudWatch expone 4316 como su puerto OTLP a través de HTTP. En Amazon EC2, dado que las aplicaciones se comunican con el agente local de CloudWatch, debe establecer este valor en `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4316/v1/traces`
1. Para la variable `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT`, especifique la URL del punto de conexión base a la que se van a exportar las métricas. El agente de CloudWatch expone 4316 como su puerto OTLP a través de HTTP. En Amazon EC2, dado que las aplicaciones se comunican con el agente local de CloudWatch, debe establecer este valor en `OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT=http://localhost:4316/v1/metrics`
1. Para la variable `OTEL_METRICS_EXPORTER`, se recomienda establecer el valor en `none`. Esto deshabilita otros exportadores de métricas para que solo se utilice el exportador de Application Signals.
1. Establezca la variable `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` en `true` para que su contenedor comience a enviar seguimientos de X-Ray y métricas de CloudWatch a Application Signals.
1. Inicie la aplicación con las variables de entorno descritas en el paso anterior. A continuación se muestra un ejemplo de un script de inicio.
+ Sustituya `$SVC_NAME` por el nombre de la aplicación. Esto se mostrará como el nombre de la aplicación, en los paneles de Application Signals.
```
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}}
```
1. (Opcional) Para habilitar la correlación de registros, en `OTEL_RESOURCE_ATTRIBUTES` defina una variable de entorno adicional `aws.log.group.names` como nombre de los grupos de registro de su aplicación. De este modo, los seguimientos y métricas de su aplicación se pueden correlacionar con las entradas de registro correspondientes de estos grupos de registro. En esta variable, sustituya {{$YOUR\_APPLICATION\_LOG\_GROUP}} con los nombres de los grupos de registro de su aplicación. Si tiene varios grupos de registro, puede usar el signo `&` para separarlos, como en este ejemplo: `aws.log.group.names=log-group-1&log-group-2`. Para habilitar la correlación entre métricas y registros, basta con establecer esta variable de entorno actual. Para obtener más información, consulte [Habilitación de la correlación entre métricas y registros](Application-Signals-MetricLogCorrelation.md). Para habilitar la correlación entre seguimientos y registros, también debe cambiar la configuración de registro de su aplicación. Para obtener más información, consulte [Habilitación de la correlación entre seguimientos y registros](Application-Signals-TraceLogCorrelation.md).
A continuación, se muestra un ejemplo de un script de inicio que ayuda a habilitar la correlación de registros.
```
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}}
```
**Configuración de una aplicación Node.js con el formato de módulo ESM**
La compatibilidad ofrecida para las aplicaciones Node.js con el formato de módulo ESM es limitada. Para obtener más información, consulte [Limitaciones conocidas de Node.js con ESM](CloudWatch-Application-Signals-supportmatrix.md#ESM-limitations).
Para habilitar Application Signals en una aplicación Node.js con ESM, debe modificar los pasos del procedimiento anterior.
Primero instale `@opentelemetry/instrumentation` para su aplicación Node.js:
```
npm install @opentelemetry/instrumentation@0.54.0
```
A continuación, en los pasos 3 y 4 del procedimiento anterior cambie las opciones de nodo de:
```
--require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register'
```
a las siguientes:
```
--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs
```
------
## Activación de Application Signals en Amazon EC2 con el protocolo de contexto para modelos (MCP)
Puede usar el servidor Protocolo de contexto para modelos (MCP) de CloudWatch Application Signals para activar Application Signals en instancias de Amazon EC2 mediante interacciones de IA conversacional. Proporciona una interfaz de lenguaje natural para configurar la supervisión de Application Signals.
El servidor MCP automatiza el proceso de activación al comprender sus requisitos y generar la configuración adecuada. En lugar de seguir manualmente los pasos de configuración, simplemente puede describir lo que desea activar.
### Requisitos previos
Antes de usar el servidor MCP para activar Application Signals, asegúrese de lo siguiente:
+ Entorno de desarrollo compatible con MCP (como Kiro, Claude Desktop, VSCode con extensiones MCP u otras herramientas compatibles con MCP)
+ El servidor MCP de CloudWatch Application Signals configurado en el IDE. Para obtener instrucciones de configuración detalladas, consulte la [documentación del servidor MCP de CloudWatch Application Signals](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).
### Uso del servidor MCP
Una vez que haya configurado el servidor MCP de CloudWatch Application Signals en el IDE, puede solicitar una guía de activación mediante instrucciones en lenguaje natural. Si bien el asistente de codificación puede inferir el contexto a partir de la estructura del proyecto, proporcionar detalles específicos en las instrucciones ayuda a garantizar una orientación más precisa y pertinente. Incluya información como el lenguaje de la aplicación, los detalles de la instancia y las rutas absolutas a la infraestructura y al código de la aplicación.
**Peticiones de prácticas recomendadas (específicas y completas):**
```
"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"
```
**Peticiones menos efectivas:**
```
"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
```
**Plantilla rápida:**
```
"Enable Application Signals for my [LANGUAGE] service on EC2.
App code: [ABSOLUTE_PATH_TO_APP]
IaC code: [ABSOLUTE_PATH_TO_IAC]"
```
### Beneficios de usar el servidor MCP
El uso del servidor MCP de CloudWatch Application Signals ofrece varias ventajas:
+ **Interfaz en lenguaje natural:** describa lo que desea activar sin memorizar comandos ni sintaxis de la configuración.
+ **Guía adaptada al contexto:** el servidor MCP comprende el entorno específico y proporciona recomendaciones personalizadas
+ **Reducción de errores:** la generación automática de configuraciones minimiza los errores de escritura manual.
+ **Configuración más rápida:** cambie de la intención a la implementación con mayor rapidez.
+ **Herramienta de aprendizaje:** vea las configuraciones generadas y comprenda cómo funciona Application Signals.
### Recursos adicionales
Para obtener más información sobre la configuración y el uso del servidor MCP de CloudWatch Application Signals, consulte la [documentación del servidor MCP](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server).
## (Opcional) Supervisión del estado de su aplicación
Una vez que haya habilitado sus aplicaciones en Amazon EC2, podrá supervisar el estado de las mismas. Para obtener más información, consulte [Monitoreo del estado operativo de sus aplicaciones con Application Signals](Services.md).