# Introducción
Para empezar a usar OpenTelemetry en CloudWatch, puede usar la configuración de OpenTelemetry preempaquetada que está disponible con el agente de CloudWatch junto con AWS Distro para los SDK de OpenTelemetry. Esto le proporciona la supervisión más integrada de CloudWatch.
**nota**
Asegúrese de que Transaction Search esté habilitado antes de utilizar el punto de conexión de OTLP para buscar seguimientos.
Como alternativa, tiene la flexibilidad de usar el recopilador de OpenTelemetry o su propio recopilador de OpenTelemetry personalizado para enviar la telemetría directamente al punto de conexión de OTLP. Puede usar AWS Distro para OpenTelemetry para prescindir del recopilador y enviar la telemetría directamente al punto de conexión de OTLP. Tome una decisión informada en función de la compatibilidad de características:
| Característica | Recolector de OpenTelemetry | OpenTelemetry Collector personalizado | AWS Distro para OpenTelemetry |
| --- | --- | --- | --- |
| CloudWatch Application Signals (métricas de rendimiento de las aplicaciones, detección de servicios y asignación de aplicaciones) | Sí | Sí | Sí |
| Búsqueda y análisis de resúmenes de unidades de seguimiento y seguimientos | Sí | Sí | Sí |
| Búsqueda y análisis de resúmenes de registros | Sí | Sí | Sí |
| Monitoreo del rendimiento de las aplicaciones: enriquecimiento de la telemetría con los atributos de la infraestructura de AWS en la que se aloja la aplicación. | No | Sí | Sí |
| Métricas de tiempo de ejecución correlacionadas con la aplicación. Por ejemplo, las métricas de JVM | No | Sí | No |
| AWSCompatibilidad con | Datos recibidos por AWS | Datos recibidos por AWS | Datos recibidos por AWS |
| Telemetría compatible | Registros, métricas, seguimientos | Registros, seguimientos, métricas | Métricas, seguimientos |
**Topics**
+ [Recolector de OpenTelemetry](CloudWatch-OTLPSimplesetup.md)
+ [Creación de un recopilador de OpenTelemetry personalizado](CloudWatch-OTLPAdvancedsetup.md)
+ [Exportación de telemetría sin recopilador mediante el SDK de AWS Distro para OpenTelemetry (ADOT)](CloudWatch-OTLP-UsingADOT.md)
+ [Activación de las métricas suministradas en PromQL](CloudWatch-OTelEnrichment.md)
# Recolector de OpenTelemetry
OpenTelemetry Collector es un agente de código abierto, independiente del proveedor, que recibe, procesa y exporta datos de telemetría. Actúa como un canal central entre sus aplicaciones y Amazon CloudWatch, ya que recopila métricas, registros y seguimientos de varios orígenes y los envía a CloudWatch mediante OpenTelemetry Protocol (OTLP).
Usar OpenTelemetry Collector con CloudWatch proporciona los siguientes beneficios:
+ Recopile la telemetría de varias aplicaciones y hosts a través de un único agente, lo que reduce el número de conexiones a CloudWatch.
+ Procese y filtre la telemetría antes de enviarla a CloudWatch, lo que incluye agregar o eliminar atributos, agrupar datos por lotes y muestrear seguimientos.
+ Utilice la misma configuración de recopilador en AWS, en entornos locales y en otros entornos de nube, lo que proporciona una canalización de los datos telemétricos consistente independientemente del lugar en el que funcionen las aplicaciones.
+ Envíe las métricas a CloudWatch con etiquetas enriquecidas que estén disponibles para consultarlas mediante el lenguaje de consultas Prometheus (PromQL) en CloudWatch Query Studio.
## Receptores compatibles
OpenTelemetry Collector admite una amplia gama de receptores para la ingesta de datos de telemetría. Puede utilizar receptores de OpenTelemetry, como el receptor OTLP para aplicaciones equipadas con los SDK de OpenTelemetry, o los receptores Prometheus para extraer métricas de los exportadores Prometheus existentes. Algunos de los receptores Prometheus más comunes que se utilizan con CloudWatch son los siguientes:
+ Receptor Prometheus para rastrear cualquier punto de conexión compatible con Prometheus
+ Receptor de métricas del host, para recopilar métricas del sistema desde el host
+ Receptor Kubernetes Cluster, para recopilar métricas de clúster del servidor API de Kubernetes
Puede configurar varios receptores en un único recopilador, lo que le permite recopilar métricas de OpenTelemetry y Prometheus y enviarlas a CloudWatch a través de la misma canalización. Para ver la lista completa de receptores disponibles, consulte el [repositorio](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver) de OpenTelemetry Collector.
## Introducción
Requisito previo: si usa el punto de conexión de OTLP para hacer seguimientos, asegúrese de activar Transaction Search.
Pasos:
1. Descargue la última versión de la distribución de OpenTelemetry Collector. Para obtener más información sobre OpenTelemetry Collector, consulte las [versiones](https://github.com/open-telemetry/opentelemetry-collector-releases/releases) de OpenTelemetry Collector.
1. Instale OpenTelemetry Collector en su host. El recopilador funciona en cualquier sistema operativo y plataforma. Para obtener más información, consulte [Install the Collector](https://opentelemetry.io/docs/collector/installation/).
1. Configure las credenciales de AWS en Amazon EC2 o en el host en las instalaciones. El recopilador usa estas credenciales para autenticarse con CloudWatch al enviar datos de telemetría. Para obtener más información, consulte a continuación.
------
#### [ Setup IAM permissions for Amazon EC2 ]
**Siga el procedimiento que se indica a continuación para adjuntar la política de IAM `CloudWatchAgentServerPolicy` al rol de IAM de la instancia de Amazon EC2.**
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles** y busque y seleccione el rol que usa la instancia de Amazon EC2.
1. En la pestaña **Permisos**, elija **Agregar permisos**, **Vincular políticas**.
1. En el cuadro de búsqueda, busque la política `CloudWatchAgentServerPolicy`.
1. Seleccione la política **CloudWatchAgentServerPolicy** y elija **Agregar permisos.**
------
#### [ Setup IAM permissions for on-premise hosts ]
**Puede crear un usuario de IAM que se puede utilizar para conceder los permisos a los hosts 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.
1. 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.
1. Elija **Siguiente**.
1. En la página **Revisar y crear**, asegúrese de que haya decidido satisfactoriamente el nombre de usuario y de que la política **CloudWatchAgentServerPolicy** aparezca en **Resumen de permisos**.
1. Seleccione la opción **Crear un usuario**.
1. **Cree y recupere su clave de acceso y su clave secreta de AWS**: en el panel de navegación de la consola de IAM, elija **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**.
1. En la sección **Claves de acceso**, elija **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\$1KEY\$1ID * y *SECRET\$1ACCESS\$1ID* por la clave de acceso y la clave de acceso secreta generadas recientemente 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
```
------
1. Configure las credenciales de AWS para los clústeres de Amazon EKS o Kubernetes. La forma más sencilla de comenzar a utilizar Amazon EKS es utilizar el complemento de Información de contenedores con OpenTelemetry de EKS. Si prefiere usar OpenTelemetry Collector directamente, siga el procedimiento que se explica a continuación para configurar las credenciales de AWS de los clústeres de Amazon EKS o Kubernetes para enviar datos de telemetría a CloudWatch.
------
#### [ Setup IAM permissions for Amazon EKS ]
1. Cree un proveedor de identidades de OIDC de IAM para el clúster mediante el siguiente comando.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} --region ${REGION} --approve
```
1. Asigne roles de IAM a la cuenta de servicio de Kubernetes para OTel Collector mediante el siguiente comando.
```
eksctl create iamserviceaccount \
--name ${COLLECTOR_SERVICE_ACCOUNT}\
--namespace ${NAMESPACE} \
--cluster ${CLUSTER_NAME} \
--region ${REGION} \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
------
#### [ Setup IAM permissions for Kubernetes ]
1. Introduzca el siguiente comando para configurar sus credenciales de AWS en su host en las instalaciones. Sustituya *ACCESS\$1KEY\$1ID * y *SECRET\$1ACCESS\$1ID* por la clave de acceso y la clave de acceso secreta generadas recientemente y que se encuentran en archivo .csv que descargó en el paso anterior. De forma predeterminada, el archivo de credenciales se guarda en */home/user/.aws/credentials*.
```
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
```
1. Edite el recurso de OpenTelemetry Collector para agregar el secreto de credenciales de AWS creado recientemente mediante el comando `kubectl edit OpenTelemetryCollector otel_collector`.
1. Con el editor de archivos, agregue la siguiente configuración en la parte superior de la implementación para agregar las credenciales de AWS en el contenedor de OpenTelemetry Collector. Sustituya la ruta */home/user/.aws/credentials* por la ubicación del archivo local de credenciales de AWS.
```
spec:
volumeMounts:
- mountPath: /rootfs
volumeMounts:
- name: aws-credentials
mountPath: /root/.aws
readOnly: true
volumes:
- hostPath:
path: /home/user/.aws/credentials
name: aws-credentials
```
------
1. Configure el exportador de OTLP en la configuración del recopilador para enviar datos de telemetría al punto de conexión de CloudWatch. Consulte los ejemplos que aparecen a continuación.
## Ejemplos de configuración del recopilador
Copie y pegue el contenido siguiente para configurar el recopilador de modo que envíe los registros y seguimientos al punto de conexión de OTLP.
```
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
otlphttp/logs:
compression: gzip
logs_endpoint: logs_otlp_endpoint
headers:
x-aws-log-group: ency_log_group
x-aws-log-stream: default
auth:
authenticator: sigv4auth/logs
otlphttp/traces:
compression: gzip
traces_endpoint: traces_otlp_endpoint
auth:
authenticator: sigv4auth/traces
extensions:
sigv4auth/logs:
region: "region"
service: "logs"
sigv4auth/traces:
region: "region"
service: "xray"
service:
telemetry:
extensions: [sigv4auth/logs, sigv4auth/traces]
pipelines:
logs:
receivers: [otlp]
exporters: [otlphttp/logs]
traces:
receivers: [otlp]
exporters: [otlphttp/traces]
```
A continuación se muestra un ejemplo de envío de registros y seguimientos mediante sigv4 a us-east-1.
```
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
otlphttp/logs:
compression: gzip
logs_endpoint: https://logs.us-east-1.amazonaws.com/v1/logs
headers:
x-aws-log-group: MyApplicationLogs
x-aws-log-stream: default
auth:
authenticator: sigv4auth/logs
otlphttp/traces:
compression: gzip
traces_endpoint: https://xray.us-east-1.amazonaws.com/v1/traces
auth:
authenticator: sigv4auth/traces
extensions:
sigv4auth/logs:
region: "us-east-1"
service: "logs"
sigv4auth/traces:
region: "us-east-1"
service: "xray"
service:
telemetry:
extensions: [sigv4auth/logs, sigv4auth/traces]
pipelines:
logs:
receivers: [otlp]
exporters: [otlphttp/logs]
traces:
receivers: [otlp]
exporters: [otlphttp/traces]
```
**nota**
Configure los SDK de OpenTelemetry con una configuración de muestreo *always\$1on* para registrar de forma fiable el 100 % de las unidades de seguimiento y obtener una visibilidad total de las aplicaciones críticas con CloudWatch Application Signals. Para obtener más información, consulte un ejemplo de [Configuración de una muestra del SDK de Java de OpenTelemetry](https://opentelemetry.io/docs/languages/java/sdk/#sampler). Para ver un ejemplo sobre cómo configurar OpenTelemetry Collector con un punto de conexión de OTLP de X-Ray, consulte el repositorio [application signals demo](https://github.com/aws-observability/application-signals-demo/blob/main/scripts/opentelemetry/otel_simple_setup/opentelemetry.yaml).
Copie y pegue el contenido siguiente para configurar el recopilador de modo que envíe las métricas a los puntos de conexión de OTLP.
```
receivers:
otlp:
protocols:
http:
endpoint: "0.0.0.0:4318"
processors:
batch:
send_batch_size: 200
timeout: 10s
exporters:
otlphttp:
tls:
insecure: false
endpoint: metrics_otlp_endpoint
auth:
authenticator: sigv4auth
extensions:
sigv4auth:
service: "monitoring"
region: "region"
service:
extensions: [sigv4auth]
pipelines:
metrics:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp]
```
A continuación se muestra un ejemplo de envío de métricas mediante sigv4 a us-east-1.
```
receivers:
otlp:
protocols:
http:
endpoint: "0.0.0.0:4318"
processors:
batch:
send_batch_size: 200
timeout: 10s
exporters:
otlphttp:
tls:
insecure: false
endpoint: "https://monitoring.us-east-1.amazonaws.com/v1/metrics:443"
auth:
authenticator: sigv4auth
extensions:
sigv4auth:
service: "monitoring"
region: "us-east-1"
service:
extensions: [sigv4auth]
pipelines:
metrics:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp]
```
# Creación de un recopilador de OpenTelemetry personalizado
Puede crear su propio recopilador de OpenTelemetry para obtener la mejor experiencia de observabilidad de aplicaciones en CloudWatch con OpenTelemetry. En esta configuración, debe crear su propio recopilador de OpenTelemetry con componentes de CloudWatch de código abierto.
## Requisito previo
Asegúrese de que *Transaction Search* esté habilitado en CloudWatch. Para obtener más información, consulte [Transaction Search](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/CloudWatch-Transaction-Search.html).
## Creación de un recopilador
Puede crear su propio recopilador con la siguiente configuración para supervisar la aplicación en CloudWatch con OpenTelemetry. Para obtener más información, consulte [Building a custom collector](https://opentelemetry.io/docs/collector/custom-collector/).
La configuración común de CloudWatch.
```
dist:
name: otelcol-dev
description: OTel Collector for sending telemetry to CloudWatch.
output_path: ./otelcol-dev
extensions:
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/extension/sigv4authextension v0.111.0
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/extension/awsproxy v0.113.0
exporters:
- gomod: go.opentelemetry.io/collector/exporter/otlpexporter v0.111.0
- gomod: go.opentelemetry.io/collector/exporter/otlphttpexporter v0.111.0
receivers:
- gomod: go.opentelemetry.io/collector/receiver/otlpreceiver v0.111.0
```
Configuración adicional para los seguimientos.
```
# Enable Tracing
dist:
name: otelcol-dev
description: OTel Collector for sending telemetry to CloudWatch.
output_path: ./otelcol-dev
extensions:
#Include common configurations and your custom extensions
exporters:
#Include common configurations and your custom extensions
receivers:
- gomod: go.opentelemetry.io/collector/receiver/otlpreceiver v0.111.0
processors:
- gomod: github.com/amazon-contributing/opentelemetry-collector-contrib/processor/awsapplicationsignalsprocessor v0.113.0
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/processor/resourcedetectionprocessor v0.113.0
- gomod: github.com/open-telemetry/opentelemetry-collector-contrib/processor/metricstransformprocessor v0.113.0
replaces:
- github.com/open-telemetry/opentelemetry-collector-contrib/internal/aws/awsutil v0.113.0 => github.com/amazon-contributing/opentelemetry-collector-contrib/internal/aws/awsutil v0.113.0
- github.com/open-telemetry/opentelemetry-collector-contrib/internal/aws/cwlogs v0.113.0 => github.com/amazon-contributing/opentelemetry-collector-contrib/internal/aws/cwlogs v0.113.0
- github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awsemfexporter v0.113.0 => github.com/amazon-contributing/opentelemetry-collector-contrib/exporter/awsemfexporter v0.113.0
- github.com/openshift/api v3.9.0+incompatible => github.com/openshift/api v0.0.0-20180801171038-322a19404e37
```
**nota**
Tenga en cuenta lo siguiente:
Una vez creado el recopilador, implemente y configure el recopilador personalizado en un entorno de host o de kubernetes con el procedimiento que se indica en [Recolector de OpenTelemetry](CloudWatch-OTLPSimplesetup.md).
Para obtener información sobre cómo configurar un recopilador de OpenTelemetry personalizado con el procesador de Application Signals, consulte un ejemplo de [configuración personalizada de Application Signals](https://github.com/aws-observability/application-signals-demo/blob/main/scripts/opentelemetry/appsignals_custom_otel_setup/custom-opentelemetry.yaml). Application Signals Processor solo es compatible con las versiones más recientes de los recopiladores de OpenTelemetry para creaciones personalizadas. Para obtener información sobre las versiones compatibles, consulte el [repositorio opentelemetry-collector-contrib](https://github.com/amazon-contributing/opentelemetry-collector-contrib/tags).
# Exportación de telemetría sin recopilador mediante el SDK de AWS Distro para OpenTelemetry (ADOT)
Puede usar los SDK de ADOT para prescindir del recopilador y enviar métricas, seguimientos y registros directamente a puntos de conexión de OTLP.
**nota**
Application Signals incluye capacidades de búsqueda de transacciones. Para evitar la duplicación de costos, desactive Application Signals en el SDK de ADOT y mantenga `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` establecido como falso (configuración predeterminada).
**Topics**
+ [Requisito previo](#CloudWatch-OTLP-UsingADOT-Prerequisite)
+ [Configuración de los permisos de IAM para el rol](#setup-iam-permissions-role)
+ [Configuración de los proveedores de credenciales](#configure-credentials-providers)
+ [Habilitación de los SDK de ADOT](#Enabling-ADOT)
## Requisito previo
Si usa seguimientos, asegúrese de que Transaction Search esté habilitado para enviar intervalos al punto de conexión de OTLP de X-Ray. Para obtener información, consulte [Introducción a Transaction Search](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Transaction-Search-getting-started.html).
## Configuración de los permisos de IAM para el rol
Siga estos pasos para asociar las políticas de IAM necesarias a su rol:
**Seguimientos:**
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles** y busque y seleccione el rol configurado.
1. En la pestaña **Permisos**, elija **Agregar permisos**, luego **Asociar políticas**.
1. En el cuadro de búsqueda, busque `AWSXrayWriteOnlyPolicy`.
1. Seleccione la política `AWSXrayWriteOnlyPolicy` y elija **Agregar permisos**.
**Registros:**
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles** y busque y seleccione el rol configurado.
1. En la pestaña **Permisos**, elija **Agregar permisos** y después **Crear política insertada**.
1. Seleccione **Registros de CloudWatch** para el servicio y, en **Acciones permitidas**, filtre y seleccione:
```
logs:PutLogEvents
logs:DescribeLogGroups
logs:DescribeLogStreams
```
1. A continuación se muestra una política de IAM de ejemplo que concede los permisos necesarios.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CloudWatchLogsAccess",
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": [
"arn:aws:logs:*:*:log-group:*"
]
}
]
}
```
------
## Configuración de los proveedores de credenciales
ADOT utiliza los SDK de AWS para descubrir automáticamente las credenciales válidas necesarias para exportar los datos de telemetría a AWS. Para obtener instrucciones sobre cómo configurar las credenciales para su entorno en particular, [consulte la documentación sobre la manera en que los SDK de AWS recuperan las credenciales](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
**Configuración de las credenciales de IAM para hosts en las instalaciones:**
Introduzca el siguiente comando para configurar sus credenciales de AWS en su host en las instalaciones. Reemplace **ACCESS\$1KEY\$1ID** y **SECRET\$1ACCESS\$1KEY** por las credenciales del usuario o rol de IAM que haya configurado.
```
$ 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
```
## Habilitación de los SDK de ADOT
Puede habilitar los registros y seguimientos para su aplicación para que se envíen directamente a los puntos de conexión de OTLP desde el SDK de AWS Distro para OpenTelemetry (ADOT) en Java, Node.js, Python y .NET.
------
#### [ Java ]
**nota**
Debe utilizar **el agente de ADOT Java, versión 2.11.2 o posterior** para que estas características estén disponibles.
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 comando:
```
curl -L -O 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 habilitar el otro exportador que envía la telemetría directamente a los puntos de conexión de OTLP y optimizar los beneficios, utilice las variables de entorno siguientes antes de iniciar la aplicación:
**Seguimientos:**
+ Establezca `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` para especificar el punto de conexión de seguimiento de OTLP de X-Ray: `https://xray.[AWSRegion].amazonaws.com/v1/traces`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://xray.us-west-2.amazonaws.com/v1/traces"
```
+ Establezca `OTEL_TRACES_EXPORTER` en `otlp` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` en `http/protobuf` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_RESOURCE_ATTRIBUTES` para especificar la siguiente información como pares clave-valor. Application Signals usa estas variables de entorno, que se convierten en anotaciones de rastros de X-Ray y dimensiones de métricas de CloudWatch:
+ (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 su aplicación.
+ (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` por los nombres de los grupos de registro de la 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-MetricLogCorrelation.html). 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-TraceLogCorrelation.html).
**Registros:**
+ Establezca `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` para especificar el punto de conexión de registros de OTLP de CloudWatch: `https://logs.[AWSRegion].amazonaws.com/v1/logs`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="https://logs.us-west-2.amazonaws.com/v1/logs"
```
+ Establezca `OTEL_EXPORTER_OTLP_LOGS_HEADERS` para especificar el grupo de registro y el flujo de registro (nota: deben crearse **antes** de ejecutar ADOT) a los que desea exportar los registros: `x-aws-log-group=[CW-LOG-GROUP-NAME],x-aws-log-stream=[CW-LOG-STREAM-NAME]`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
```
+ Establezca `OTEL_LOGS_EXPORTER` en `otlp` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` en `http/protobuf` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
1. Establezca `JAVA_TOOL_OPTIONS` para especificar la ruta en la que se almacena el agente de instrumentación automática de Java de AWS Distro para OpenTelemetry. Por ejemplo:
```
export JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH"
export AWS_ADOT_JAVA_INSTRUMENTATION_PATH="./aws-opentelemetry-agent.jar"
```
1. Su aplicación debería ejecutarse ahora con la instrumentación Java de ADOT y generará intervalos y registros. Los intervalos se almacenarán en el grupo de registro de CloudWatch `aws/spans`, mientras que los registros se almacenarán en el grupo de registro especificado en el encabezado `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. También puede ver los registros y las métricas correlacionados con sus intervalos en la consola de seguimientos y métricas de CloudWatch.
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.
```
JAVA_TOOL_OPTIONS=" -javaagent:$AWS_ADOT_JAVA_INSTRUMENTATION_PATH" \
OTEL_METRICS_EXPORTER=none \
OTEL_TRACES_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces \
OTEL_LOGS_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs.us-east-1.amazonaws.com/v1/logs \
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
java -jar $MY_JAVA_APP.jar
```
------
#### [ Node.js ]
**nota**
Debe utilizar **ADOT JavaScript, versión 0.7.0 o posterior** para que estas características estén disponibles.
1. Descargue la última versión del agente de instrumentación automática de Java de AWS Distro para OpenTelemetry. 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-otel-js-instrumentation Releases](https://github.com/aws-observability/aws-otel-js-instrumentation/releases).
1. Para habilitar el otro exportador que envía la telemetría directamente a los puntos de conexión de OTLP y optimizar los beneficios, utilice las variables de entorno siguientes antes de iniciar la aplicación:
**Seguimientos:**
+ Establezca `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` para especificar el punto de conexión de seguimiento de OTLP de X-Ray: `https://xray.[AWSRegion].amazonaws.com/v1/traces`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://xray.us-west-2.amazonaws.com/v1/traces"
```
+ Establezca `OTEL_TRACES_EXPORTER` en `otlp` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` en `http/protobuf` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_RESOURCE_ATTRIBUTES` para especificar la siguiente información como pares clave-valor. Application Signals usa estas variables de entorno, que se convierten en anotaciones de rastros de X-Ray y dimensiones de métricas de CloudWatch:
+ (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 su aplicación.
+ (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` por los nombres de los grupos de registro de la 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-MetricLogCorrelation.html). 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-TraceLogCorrelation.html).
**Registros:**
+ Establezca `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` para especificar el punto de conexión de registros de OTLP de CloudWatch: `https://logs.[AWSRegion].amazonaws.com/v1/logs`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="https://logs.us-west-2.amazonaws.com/v1/logs"
```
+ Establezca `OTEL_EXPORTER_OTLP_LOGS_HEADERS` para especificar el grupo de registro y el flujo de registro (nota: deben crearse **antes** de ejecutar ADOT) a los que desea exportar los registros: `x-aws-log-group=[CW-LOG-GROUP-NAME],x-aws-log-stream=[CW-LOG-STREAM-NAME]`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
```
+ Establezca `OTEL_LOGS_EXPORTER` en `otlp` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` en `http/protobuf` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
1. Su aplicación debería ejecutarse ahora con la instrumentación JavaScript de ADOT y generará intervalos y registros. Los intervalos se almacenarán en el grupo de registro de CloudWatch `aws/spans`, mientras que los registros se almacenarán en el grupo de registro especificado en el encabezado `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. También puede ver los registros y las métricas correlacionados con sus intervalos en la consola de seguimientos y métricas de CloudWatch.
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.
Sustituya `$SVC_NAME` por el nombre de la aplicación. Esto se mostrará como el nombre de la aplicación.
```
OTEL_METRICS_EXPORTER=none \
OTEL_TRACES_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces \
OTEL_LOGS_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs.us-east-1.amazonaws.com/v1/logs \
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
node --require '@aws/aws-distro-opentelemetry-node-autoinstrumentation/register' your-application.js
```
------
#### [ Python ]
**nota**
Debe usar **ADOT Python, versión 0.10.0 o posterior** y tener **`botocore`** instalado para que estas características estén disponibles.
1. Descargue la última versión del agente de instrumentación automática de Python de AWS Distro para OpenTelemetry. Instálelo ejecutando el siguiente comando de .
```
pip install aws-opentelemetry-distro
```
Puede ver información sobre todas las versiones publicadas en [aws-otel-python-instrumentation Releases](https://github.com/aws-observability/aws-otel-python-instrumentation/releases).
1. Para habilitar el otro exportador que envía la telemetría directamente a los puntos de conexión de OTLP y optimizar los beneficios, utilice las variables de entorno siguientes antes de iniciar la aplicación:
**Tanto para las configuraciones de seguimientos como de registros, debe establecer las siguientes variables de entorno:**
+ `OTEL_PYTHON_DISTRO` De a `aws_distro`
+ `OTEL_PYTHON_CONFIGURATOR` De a `aws_configurator`
**Seguimientos:**
+ Establezca `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` para especificar el punto de conexión de seguimiento de OTLP de X-Ray: `https://xray.[AWSRegion].amazonaws.com/v1/traces`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://xray.us-west-2.amazonaws.com/v1/traces"
```
+ Establezca `OTEL_TRACES_EXPORTER` en `otlp` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` en `http/protobuf` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_RESOURCE_ATTRIBUTES` para especificar la siguiente información como pares clave-valor. Application Signals usa estas variables de entorno, que se convierten en anotaciones de rastros de X-Ray y dimensiones de métricas de CloudWatch:
+ (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 su aplicación.
+ (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` por los nombres de los grupos de registro de la 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-MetricLogCorrelation.html). 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Application-Signals-TraceLogCorrelation.html).
**Registros:**
+ Establezca `OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED` en `true`
+ Establezca `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` para especificar el punto de conexión de registros de OTLP de CloudWatch: `https://logs.[AWSRegion].amazonaws.com/v1/logs`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT="https://logs.us-west-2.amazonaws.com/v1/logs"
```
+ Establezca `OTEL_EXPORTER_OTLP_LOGS_HEADERS` para especificar el grupo de registro y el flujo de registro (nota: deben crearse **antes** de ejecutar ADOT) a los que desea exportar los registros: `x-aws-log-group=[CW-LOG-GROUP-NAME],x-aws-log-stream=[CW-LOG-STREAM-NAME]`
Por ejemplo:
```
export OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
```
+ Establezca `OTEL_LOGS_EXPORTER` en `otlp` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
+ Establezca la variable `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` en `http/protobuf` (esto es opcional y es el valor predeterminado si esta variable de entorno no está establecida).
1. Su aplicación debería ejecutarse ahora con la instrumentación Python de ADOT y generará intervalos y registros. Los intervalos se almacenarán en el grupo de registro de CloudWatch `aws/spans`, mientras que los registros se almacenarán en el grupo de registro especificado en el encabezado `OTEL_EXPORTER_OTLP_LOGS_HEADERS`. También puede ver los registros y las métricas correlacionados con sus intervalos en la consola de seguimientos y métricas de CloudWatch.
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.
Sustituya `$SVC_NAME` por el nombre de la aplicación. Esto se mostrará como el nombre de la aplicación.
Sustituya `$PYTHON_APP` por la ubicación y el nombre de la aplicación.
```
OTEL_METRICS_EXPORTER=none \
OTEL_TRACES_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces \
OTEL_LOGS_EXPORTER=otlp \
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=http/protobuf \
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs.us-east-1.amazonaws.com/v1/logs \
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-aws-log-group=MyLogGroup,x-aws-log-stream=default
OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED=true
OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME" \
opentelemetry-instrument python $MY_PYTHON_APP.py
```
------
#### [ .Net ]
**nota**
Se necesita **ADOT .NET, versión 1.8.0 o posterior** para que estas características estén disponibles.
En este momento, no se admite la compresión.
En este momento, no se admiten los registros.
Descargue la versión más reciente del paquete de autoinstrumentación de .NET de Distro para OpenTelemetry de AWS. Puede ver información sobre todas las versiones publicadas en [aws-otel-dotnet-instrumentation Releases](https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases).
Para habilitar otros exportadores que envían la telemetría directamente a los puntos de conexión de OTLP y optimizar los beneficios, utilice las variables de entorno siguientes antes de iniciar la aplicación (sustituya `dotnet-service-name` en la variable de entorno `OTEL_RESOURCE_ATTRIBUTES` por el nombre del servicio a su elección):
**Seguimientos:**
+ **DEBE** establecer `OTEL_TRACES_EXPORTER` en `none`.
+ **DEBE** establecer `OTEL_AWS_SIG_V4_ENABLED` en `true`.
Esta característica **no se habilita automáticamente en .NET**. La variable de entorno es obligatoria específicamente para identificar este caso de uso dentro de la instrumentación de .NET. Este requisito es exclusivo de .NET y **no se aplica a otros lenguajes admitidos**.
A continuación se muestra un ejemplo de configuración 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_TRACES_EXPORTER=none
export OTEL_AWS_SIG_V4_ENABLED=true
export OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
export OTEL_METRICS_EXPORTER=none
export OTEL_LOGS_EXPORTER=none
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces
```
A continuación se muestra un ejemplo de configuración para 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_TRACES_EXPORTER=none
$env:OTEL_AWS_SIG_V4_ENABLED=true
$env:OTEL_RESOURCE_ATTRIBUTES=service.name=dotnet-service-name
$env:OTEL_METRICS_EXPORTER=none
$env:OTEL_LOGS_EXPORTER=none
$env:OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
$env:OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://xray.us-east-1.amazonaws.com/v1/traces
```
1. Inicie la aplicación con las variables de entorno enumeradas en el paso anterior.
1. (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.shexport 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).
------
# Activación de las métricas suministradas en PromQL
Puede habilitar el enriquecimiento de OpenTelemetry para que las métricas suministradas de los [recursos de AWS compatibles](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/UsingResourceTagsForTelemetry.html) se puedan consultar mediante PromQL. Una vez habilitadas, las métricas que contienen una dimensión de identificador de recursos (por ejemplo, EC2 CPUUtilization con una dimensión InstanceId) se enriquecen con etiquetas de ARN y etiquetas de recursos y se pueden consultar mediante PromQL.
La métrica enriquecida conserva el nombre de la métrica original y las dimensiones de CloudWatch, y agrega lo siguiente
+ **Atributos del recurso**: el ARN del recurso (`cloud.resource_id`), el proveedor de servicios en la nube, la región y el ID de la cuenta.
+ **Alcance de la instrumentación**: identifica el servicio de origen y marca la métrica como enriquecida con OpenTelemetry.
+ **Etiquetas de recursos**: cualquier etiqueta de recurso de AWS asociada al recurso, que se puede consultar como etiquetas de PromQL.
La métrica clásica original de CloudWatch no se modifica y permanece disponible a través de las API de CloudWatch existentes.
## Activación del enriquecimiento de OpenTelemetry para las métricas suministradas
Antes de iniciar el enriquecimiento de OpenTelemetry, debe [habilitar las etiquetas de recursos en la telemetría](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/EnableResourceTagsOnTelemetry.html) de su cuenta.
Puede habilitar el enriquecimiento de OpenTelemetry para su cuenta en una región específica mediante la consola de CloudWatch, la AWS CLI o el SDK de AWS.
En concreto, necesita permisos para la siguiente operación: `cloudwatch:StartOTelEnrichment`
**Para habilitar el enriquecimiento de OpenTelemetry para las métricas de AWS (consola de CloudWatch)**
1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **CloudWatch** y, a continuación, **Configuración**.
1. En el panel **Habilitar el enriquecimiento de OpenTelemetry para las métricas de AWS**, active la característica.
**AWS CLI**
```
aws cloudwatch start-o-tel-enrichment
```
Para activarla en varias regiones, invoque la API en cada región de interés.
Una vez activado el enriquecimiento, puede empezar a consultar las métricas suministradas con PromQL. Consulte : [Consulta de métricas suministradas por AWS con PromQL](CloudWatch-PromQL-Querying.md#CloudWatch-PromQL-Querying-Vended).