Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# ¿ AWS Utilizas Distro OpenTelemetry como recopilador
En esta sección se describe cómo configurar el recopilador AWS Distro for OpenTelemetry (ADOT) para extraerlo de una aplicación equipada con Prometheus y enviar las métricas a Amazon Managed Service for Prometheus. [Para obtener más información sobre el recopilador de ADOT, consulte Distro for.AWS OpenTelemetry](https://aws.amazon.com/otel/)
En los siguientes temas se describen tres formas diferentes de configurar ADOT como recopilador de las métricas, en función de si las métricas provienen de Amazon EKS, Amazon ECS o una instancia de Amazon EC2.
**Topics**
+ [Configure la ingesta de métricas mediante AWS Distro para OpenTelemetry un clúster de Amazon Elastic Kubernetes Service](AMP-onboard-ingest-metrics-OpenTelemetry.md)
+ [Configure la ingesta de métricas de Amazon ECS mediante AWS Distro for Open Telemetry](AMP-onboard-ingest-metrics-OpenTelemetry-ECS.md)
+ [Configuración de la ingesta de métricas desde una instancia de Amazon EC2 mediante escritura remota](AMP-onboard-ingest-metrics-remote-write-EC2.md)
# Configure la ingesta de métricas mediante AWS Distro para OpenTelemetry un clúster de Amazon Elastic Kubernetes Service
Puedes usar el recopilador AWS Distro for OpenTelemetry (ADOT) para extraer métricas de una aplicación equipada con Prometheus y enviarlas a Amazon Managed Service for Prometheus.
**nota**
[Para obtener más información sobre el recopilador de ADOT, consulte Distro for.AWS OpenTelemetry](https://aws.amazon.com/otel/)
Para obtener más información acerca de las aplicaciones equipadas con Prometheus, consulte [¿Cuáles son las métricas compatibles con Prometheus?](prom-compatible-metrics.md).
La recopilación de métricas de Prometheus con ADOT incluye tres OpenTelemetry componentes: el receptor Prometheus, el exportador de escritura remota de Prometheus y la extensión de autenticación Sigv4.
Puede configurar el receptor de Prometheus con la configuración de Prometheus existente para realizar la detección de servicios y el raspado de métricas. El receptor de Prometheus raspa métricas en el formato de exposición de Prometheus. Todas las aplicaciones o puntos de conexión que desee raspar deben configurarse con la biblioteca de clientes de Prometheus. El receptor de Prometheus es compatible con el conjunto completo de configuraciones de raspado y reetiquetado de Prometheus descritas en la sección [Configuración](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) de la documentación de Prometheus. Puede pegar estas configuraciones directamente en las configuraciones del recopilador de ADOT.
El exportador de escritura remota de Prometheus utiliza el punto de conexión `remote_write` para enviar las métricas raspadas al espacio de trabajo del portal de administración. Las solicitudes HTTP para exportar datos se firmarán con SigV4, el AWS protocolo de autenticación segura, con la extensión de autenticación AWS Sigv4. Para obtener más información, consulte [Proceso de firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
El recopilador descubre automáticamente los puntos de conexión de las métricas de Prometheus en Amazon EKS y utiliza la configuración de [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config).
La siguiente demostración es un ejemplo de esta configuración en un clúster que ejecuta Amazon Elastic Kubernetes Service o Kubernetes autoadministrado. Para realizar estos pasos, debe tener AWS credenciales de cualquiera de las posibles opciones de la cadena de AWS credenciales predeterminada. Para obtener más información, consulte [Configuración del AWS SDK for Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). En esta demostración se utiliza una aplicación de muestra que se utiliza para las pruebas de integración del proceso. La aplicación de ejemplo expone las métricas en el punto de conexión `/metrics`, como la biblioteca de cliente de Prometheus.
## Requisitos previos
Antes de comenzar con los siguientes pasos de configuración de la ingesta, debe configurar su rol de IAM para la cuenta de servicio y la política de confianza.
**Para configurar el rol de IAM para la cuenta de servicio y la política de confianza**
1. Cree el rol de IAM para la cuenta de servicio siguiendo los pasos que se indican en [Configuración de roles de servicio para la ingesta de métricas desde los clústeres de Amazon EKS](set-up-irsa.md#set-up-irsa-ingest).
El recopilador de ADOT utilizará este rol al raspar y exportar métricas.
1. A continuación, edite la política de confianza. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/home).
1. En el panel de navegación izquierdo, selecciona **Roles** y busca el **amp-iamproxy-ingest-role**que creaste en el paso 1.
1. Elija la pestaña **Relaciones de confianza** y, a continuación, elija **Editar la relación de confianza**.
1. En el JSON de la política de confianza, reemplace `aws-amp` por `adot-col` y, a continuación, elija **Actualizar la política de confianza**. La política de confianza resultante debe ser similar a la siguiente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
}
}
}
]
}
```
------
1. Elija la pestaña **Permisos** y asegúrese de que la siguiente política de permisos esté asociada al rol.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aps:RemoteWrite",
"aps:GetSeries",
"aps:GetLabels",
"aps:GetMetricMetadata"
],
"Resource": "*"
}
]
}
```
------
## Habilitación de la recopilación de métricas de Prometheus
**nota**
Al crear un espacio de nombres en Amazon EKS, `alertmanager` y el exportador de nodos están deshabilitados de forma predeterminada.
**Para habilitar la recopilación de Prometheus en un clúster de Amazon EKS o Kubernetes**
1. Bifurca y clona la aplicación de muestra desde el repositorio en [aws-otel-community](https://github.com/aws-observability/aws-otel-community).
A continuación, ejecute los siguientes comandos.
```
cd ./sample-apps/prometheus-sample-app
docker build . -t prometheus-sample-app:latest
```
1. Inserte esta imagen en un registro como Amazon ECR o DockerHub.
1. Implemente la aplicación de muestra en el clúster copiando esta configuración de Kubernetes y aplicándola. Cambie la imagen por la imagen que acaba de insertar reemplazando `{{PUBLIC_SAMPLE_APP_IMAGE}}` en el archivo `prometheus-sample-app.yaml`.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-sample-app.yaml -o prometheus-sample-app.yaml
kubectl apply -f prometheus-sample-app.yaml
```
1. Introduzca el siguiente comando para comprobar que la aplicación de muestra se ha iniciado. En el resultado del comando, verá `prometheus-sample-app` en la columna `NAME`.
```
kubectl get all -n aoc-prometheus-pipeline-demo
```
1. Inicie una instancia predeterminada del recopilador de ADOT. Para ello, introduzca primero el siguiente comando para obtener la configuración de Kubernetes para el recopilador de ADOT.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml
```
A continuación, edite el archivo de plantilla y reemplace el punto de conexión **remote\$1write** del espacio de trabajo de Amazon Managed Service para Prometheus por `YOUR_ENDPOINT` y la región por `YOUR_REGION`. Use el punto de conexión **remote\$1write** que se muestra en la consola de Amazon Managed Service para Prometheus al consultar los detalles del espacio de trabajo.
También tendrás que cambiar tu ID de cuenta `YOUR_ACCOUNT_ID` en la sección de cuentas de servicio de la configuración de Kubernetes. AWS
En este ejemplo, la configuración del recopilador de ADOT utiliza una anotación (`scrape=true`) para indicar qué puntos de conexión de destino deben analizarse. Esto permite al recopilador de ADOT distinguir el punto de conexión de la aplicación de muestra de los puntos de conexión del kube-system en el clúster. Puede eliminarla de las configuraciones de reetiquetado si desea raspar otra aplicación de muestra.
1. Introduzca el siguiente comando para implementar el recopilador de ADOT.
```
kubectl apply -f prometheus-daemonset.yaml
```
1. Introduzca el siguiente comando para comprobar que el recopilador de ADOT se ha iniciado. Busque `adot-col` en la columna `NAMESPACE`.
```
kubectl get pods -n adot-col
```
1. Verifique que la canalización funciona mediante el exportador de registros. Nuestra plantilla de ejemplo ya está integrada con el exportador de registros. Ejecute los comandos siguientes.
```
kubectl get pods -A
kubectl logs -n adot-col name_of_your_adot_collector_pod
```
Algunas de las métricas raspadas de la aplicación de muestra tendrán un aspecto semejante al de este ejemplo.
```
Resource labels:
-> service.name: STRING(kubernetes-service-endpoints)
-> host.name: STRING(192.168.16.238)
-> port: STRING(8080)
-> scheme: STRING(http)
InstrumentationLibraryMetrics #0
Metric #0
Descriptor:
-> Name: test_gauge0
-> Description: This is my gauge
-> Unit:
-> DataType: DoubleGauge
DoubleDataPoints #0
StartTime: 0
Timestamp: 1606511460471000000
Value: 0.000000
```
1. Para comprobar si Amazon Managed Service para Prometheus ha recibido las métricas, utilice `awscurl`. [Esta herramienta le permite enviar solicitudes HTTP a través de la línea de comandos con autenticación AWS Sigv4, por lo que debe tener AWS las credenciales configuradas localmente con los permisos correctos para realizar consultas desde Amazon Managed Service for Prometheus. Para obtener instrucciones sobre `awscurl` la instalación, consulte aws.curl.](https://github.com/okigan/awscurl)
En el siguiente comando, reemplace `AMP_REGION` y `AMP_ENDPOINT` por la información del espacio de trabajo de Amazon Managed Service para Prometheus.
```
awscurl --service="aps" --region="AMP_REGION" "https://AMP_ENDPOINT/api/v1/query?query=adot_test_gauge0"
{"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"adot_test_gauge0"},"value":[1606512592.493,"16.87214000011479"]}]}}
```
Si recibe una métrica como respuesta, significa que la configuración de la canalización se ha realizado correctamente y que la métrica se ha propagado correctamente desde la aplicación de muestra a Amazon Managed Service para Prometheus.
**Limpieza**
Para limpiar esta demostración, introduzca los siguientes comandos.
```
kubectl delete namespace aoc-prometheus-pipeline-demo
kubectl delete namespace adot-col
```
## Configuración avanzada
El receptor de Prometheus es compatible con el conjunto completo de configuraciones de raspado y reetiquetado de Prometheus descritas en la sección [Configuración](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) de la documentación de Prometheus. Puede pegar estas configuraciones directamente en las configuraciones del recopilador de ADOT.
La configuración del receptor de Prometheus incluye las configuraciones de detección de servicios, raspado y reetiquetado. La configuración del receptor tienen el aspecto siguiente.
```
receivers:
prometheus:
config:
[[Your Prometheus configuration]]
```
A continuación, se muestra una configuración de ejemplo.
```
receivers:
prometheus:
config:
global:
scrape_interval: 1m
scrape_timeout: 10s
scrape_configs:
- job_name: kubernetes-service-endpoints
sample_limit: 10000
kubernetes_sd_configs:
- role: endpoints
tls_config:
ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
insecure_skip_verify: true
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
```
Si ya dispone de una configuración de Prometheus, debe reemplazar los caracteres `$` por `$$` para evitar que los valores se sustituyan por variables de entorno. \$1Esto es especialmente importante para el valor de reemplazo de las relabel\$1configurations. Por ejemplo, si comienza con la siguiente relabel\$1configuration:
```
relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
regex: (.+);(.+);(.+)
replacement: ${1}://${2}${3}
target_label: __param_target
```
Se convertiría en lo siguiente:
```
relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
regex: (.+);(.+);(.+)
replacement: $${1}://${2}${3}
target_label: __param_target
```
**Exportador de escritura remota y extensión de autenticación SigV4 de Prometheus**
La configuración del exportador de escritura remota y la extensión de autenticación SigV4 de Prometheus es más sencilla que la del receptor de Prometheus. En esta fase de la canalización, ya se han incorporado las métricas y lo tenemos todo listo para exportar estos datos a Amazon Managed Service para Prometheus. En el siguiente ejemplo se muestra el requisito mínimo para que la configuración se comunique correctamente con Amazon Managed Service para Prometheus.
```
extensions:
sigv4auth:
service: "aps"
region: "user-region"
exporters:
prometheusremotewrite:
endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write"
auth:
authenticator: "sigv4auth"
```
Esta configuración envía una solicitud HTTPS firmada por AWS SigV4 con AWS las credenciales de la cadena de AWS credenciales predeterminada. Para obtener más información, consulte [Configuración de la AWS SDK para Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). Debe especificar el nombre del servicio como `aps`.
Independientemente del método de implementación, el recopilador de ADOT debe tener acceso a una de las opciones enumeradas en la cadena de AWS credenciales predeterminada. La extensión de autenticación Sigv4 depende de la extensión de autenticación Sigv4 AWS SDK para Go y la utiliza para obtener credenciales y autenticarse. Debe asegurarse de que estas credenciales tengan permisos de escritura remota para Amazon Managed Service para Prometheus.
# Configure la ingesta de métricas de Amazon ECS mediante AWS Distro for Open Telemetry
En esta sección se explica cómo recopilar métricas de Amazon Elastic Container Service (Amazon ECS) e incorporarlas a Amazon Managed Service for Prometheus AWS mediante Distro for Open Telemetry (ADOT). También se describe cómo visualizar las métricas en Amazon Managed Grafana.
## Requisitos previos
**importante**
Antes de empezar, debe tener un entorno de Amazon ECS en un clúster de AWS Fargate con la configuración predeterminada, un espacio de trabajo de Amazon Managed Service para Prometheus y un espacio de trabajo de Amazon Managed Grafana. Suponemos que está familiarizado con las cargas de trabajo de contenedores, Amazon Managed Service para Prometheus y Amazon Managed Grafana.
Para obtener más información, consulte los enlaces siguientes:
+ Para obtener información sobre cómo crear un entorno de Amazon ECS en un clúster de Fargate con la configuración predeterminada, consulte [Creación de un clúster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) en la *Guía para desarrolladores de Amazon ECS*.
+ Para obtener información sobre cómo crear un espacio de trabajo de Amazon Managed Service para Prometheus, consulte [Crear un espacio de trabajo](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html) en la *Guía del usuario de Amazon Managed Service para Prometheus*.
+ Para obtener información sobre cómo crear un espacio de trabajo de Amazon Managed Grafana, consulte [Creación de un espacio de trabajo](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html) en la *Guía del usuario de Amazon Managed Grafana*.
## Paso 1: definir de una imagen personalizada del contenedor del recopilador de ADOT
Utilice el siguiente archivo de configuración como plantilla para definir su propia imagen del contenedor del recopilador de ADOT. Sustituya «y» por sus valores «y». *my-remote-URL* *my-region* `endpoint` `region` Guarde la configuración en un archivo llamado *adot-config.yaml*.
**nota**
Esta configuración utiliza la extensión `sigv4auth` para autenticar las llamadas a Amazon Managed Service para Prometheus. Para obtener más información sobre la configuración`sigv4auth`, consulte [Authenticator: Sigv4 on](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/sigv4authextension). GitHub
```
receivers:
prometheus:
config:
global:
scrape_interval: 15s
scrape_timeout: 10s
scrape_configs:
- job_name: "prometheus"
static_configs:
- targets: [ 0.0.0.0:9090 ]
awsecscontainermetrics:
collection_interval: 10s
processors:
filter:
metrics:
include:
match_type: strict
metric_names:
- ecs.task.memory.utilized
- ecs.task.memory.reserved
- ecs.task.cpu.utilized
- ecs.task.cpu.reserved
- ecs.task.network.rate.rx
- ecs.task.network.rate.tx
- ecs.task.storage.read_bytes
- ecs.task.storage.write_bytes
exporters:
prometheusremotewrite:
endpoint: my-remote-URL
auth:
authenticator: sigv4auth
logging:
loglevel: info
extensions:
health_check:
pprof:
endpoint: :1888
zpages:
endpoint: :55679
sigv4auth:
region: my-region
service: aps
service:
extensions: [pprof, zpages, health_check, sigv4auth]
pipelines:
metrics:
receivers: [prometheus]
exporters: [logging, prometheusremotewrite]
metrics/ecs:
receivers: [awsecscontainermetrics]
processors: [filter]
exporters: [logging, prometheusremotewrite]
```
## Paso 2: insertar la imagen del contenedor del recopilador de ADOT en un repositorio de Amazon ECR
Utilice un Dockerfile para crear e insertar la imagen del contenedor en un repositorio de Amazon Elastic Container Registry (ECR).
1. Cree el Dockerfile para copiar y agregar la imagen del contenedor a la imagen de Docker OTEL.
```
FROM public.ecr.aws/aws-observability/aws-otel-collector:latest
COPY adot-config.yaml /etc/ecs/otel-config.yaml
CMD ["--config=/etc/ecs/otel-config.yaml"]
```
1. Cree un repositorio de Amazon ECR.
```
# create repo:
COLLECTOR_REPOSITORY=$(aws ecr create-repository --repository aws-otel-collector \
--query repository.repositoryUri --output text)
```
1. Cree la imagen del contenedor.
```
# build ADOT collector image:
docker build -t $COLLECTOR_REPOSITORY:ecs .
```
**nota**
Esto supone que está creando el contenedor en el mismo entorno en el que se ejecutará. De lo contrario, es posible que deba utilizar el parámetro `--platform` al crear la imagen.
1. Inicie sesión en el repositorio de Amazon ECR. *my-region*Sustitúyalo por su valor. `region`
```
# sign in to repo:
aws ecr get-login-password --region my-region | \
docker login --username AWS --password-stdin $COLLECTOR_REPOSITORY
```
1. Inserte la imagen del contenedor.
```
# push ADOT collector image:
docker push $COLLECTOR_REPOSITORY:ecs
```
## Paso 3: crear una definición de tareas de Amazon ECS para analizar Amazon Managed Service para Prometheus
Cree una definición de tareas de Amazon ECS para raspar Amazon Managed Service para Prometheus. La definición de la tarea debe incluir un contenedor denominado `adot-collector` y un contenedor denominado `prometheus`. `prometheus` genera métricas y `adot-collector` raspa `prometheus`.
**nota**
Amazon Managed Service para Prometheus funciona como un servicio y recopila métricas de los contenedores. En este caso, los contenedores ejecutan Prometheus de forma local, en modo agente, el cual envía las métricas locales a Amazon Managed Service para Prometheus.
**Ejemplo: definición de tarea**
A continuación se muestra un ejemplo del aspecto que puede tener la definición de la tarea. Puede utilizar este ejemplo como plantilla para crear su propia definición de tarea. Reemplace el valor `image` de `adot-collector` por la URL y la etiqueta de imagen del repositorio (`$COLLECTOR_REPOSITORY:ecs`). Reemplace los valores `region` de `adot-collector` y `prometheus` por sus valores `region`.
```
{
"family": "adot-prom",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "adot-collector",
"image": "account_id.dkr.ecr.region.amazonaws.com/image-tag",
"essential": true,
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/ecs-adot-collector",
"awslogs-region": "my-region",
"awslogs-stream-prefix": "ecs",
"awslogs-create-group": "True"
}
}
},
{
"name": "prometheus",
"image": "prom/prometheus:main",
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/ecs-prom",
"awslogs-region": "my-region",
"awslogs-stream-prefix": "ecs",
"awslogs-create-group": "True"
}
}
}
],
"requiresCompatibilities": [
"FARGATE"
],
"cpu": "1024"
}
```
## Paso 4: conceder permisos a la tarea para acceder a Amazon Managed Service para Prometheus
Para enviar las métricas recopiladas a Amazon Managed Service for Prometheus, tu tarea de Amazon ECS debe tener los permisos correctos para AWS llamar a las operaciones de la API por ti. Debe crear un rol de IAM para las tareas y adjuntarle la política `AmazonPrometheusRemoteWriteAccess`. Para obtener más información sobre cómo crear este rol y adjuntarle la política, consulte [Creación de un rol y una política de IAM para las tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#create_task_iam_policy_and_role).
Tras adjuntar `AmazonPrometheusRemoteWriteAccess` al rol de IAM y utilizarlo para llevar a cabo las tareas, Amazon ECS puede enviar las métricas raspadas a Amazon Managed Service para Prometheus.
## Paso 5: visualizar las métricas en Amazon Managed Grafana
**importante**
Antes de empezar, debe ejecutar una tarea de Fargate en la definición de la tarea de Amazon ECS. De lo contrario, Amazon Managed Service para Prometheus no podrá consumir las métricas.
1. En el panel de navegación de tu espacio de trabajo de Grafana gestionado por Amazon, selecciona **Fuentes de datos** debajo del AWS icono.
1. En la pestaña **Orígenes de datos**, en **Servicio**, seleccione **Amazon Managed Service para Prometheus** y elija la **Región predeterminada**.
1. Elija **Agregar origen de datos**.
1. Use los prefijos `ecs` y `prometheus` para consultar y ver las métricas.
# Configuración de la ingesta de métricas desde una instancia de Amazon EC2 mediante escritura remota
Esta sección explica cómo ejecutar un servidor de Prometheus con escritura remota en una instancia de Amazon Elastic Compute Cloud (Amazon EC2). También detalla cómo recopilar métricas de una aplicación de demostración escrita en Go y enviarlas a un espacio de trabajo de Amazon Managed Service para Prometheus.
## Requisitos previos
**importante**
Antes de empezar, debe haber instalado Prometheus v2.26 o posterior. Suponemos que está familiarizado con Prometheus, Amazon EC2 y Amazon Managed Service para Prometheus. Para obtener información sobre cómo instalar Prometheus, consulte [Primeros pasos](https://prometheus.io/docs/prometheus/latest/getting_started/) en el sitio web de Prometheus.
Si no está familiarizado con Amazon EC2 o Amazon Managed Service para Prometheus, le recomendamos que comience leyendo las siguientes secciones:
+ [¿Qué es Amazon Elastic Compute Cloud?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html)
+ [¿Qué es Amazon Managed Service para Prometheus?](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html)
## Creación de un rol de IAM para Amazon EC2
Para transmitir las métricas, primero debes crear un rol de IAM con la política AWS gestionada. **AmazonPrometheusRemoteWriteAccess** A continuación, puede lanzar una instancia con el rol y transmitir las métricas al espacio de trabajo de Amazon Managed Service para Prometheus.
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. En el panel de navegación, seleccione **Roles (Roles)** y, a continuación, seleccione **Create role (Crear rol)**.
1. En el tipo de entidad de confianza, elija **servicio de AWS **. En el caso de uso, elija **EC2**. Elija **Siguiente: permisos**.
1. En la barra de búsqueda, ingrese **AmazonPrometheusRemoteWriteAccess**. En el **nombre de la política**, seleccione y **AmazonPrometheusRemoteWriteAccess**, a continuación, elija **Adjuntar política**. Elija **Siguiente:Etiquetas**.
1. (Opcional) Cree etiquetas de IAM para el rol de IAM. Elija **Siguiente: Revisar**.
1. Escriba un nombre para el rol. Elija **Crear política**.
## Lanzamiento de una instancia de Amazon EC2
Para lanzar una instancia de Amazon EC2, siga las instrucciones indicadas en [Lanzar una instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) de la *Guía del usuario de Amazon Elastic Compute Cloud para instancias de Linux*.
## Ejecución de la aplicación de demostración
Tras crear el rol de IAM y lanzar una instancia de EC2 con ese rol, puede ejecutar una aplicación de demostración para comprobar cómo funciona.
**Ejecución de una aplicación de demostración y prueba de las métricas**
1. Utilice la siguiente plantilla para crear un archivo de Go llamado `main.go`.
```
package main
import (
"github.com/prometheus/client_golang/prometheus/promhttp"
"net/http"
)
func main() {
http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":8000", nil)
}
```
1. Ejecute los siguientes comandos para instalar las dependencias correctas.
```
sudo yum update -y
sudo yum install -y golang
go get github.com/prometheus/client_golang/prometheus/promhttp
```
1. Ejecute la aplicación de demostración.
```
go run main.go
```
La aplicación de demostración debería ejecutarse en el puerto 8000 y mostrar todas las métricas de Prometheus expuestas. A continuación se muestra un ejemplo de estas métricas.
```
curl -s http://localhost:8000/metrics
...
process_max_fds 4096# HELP process_open_fds Number of open file descriptors.# TYPE process_open_fds gauge
process_open_fds 10# HELP process_resident_memory_bytes Resident memory size in bytes.# TYPE process_resident_memory_bytes gauge
process_resident_memory_bytes 1.0657792e+07# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.# TYPE process_start_time_seconds gauge
process_start_time_seconds 1.61131955899e+09# HELP process_virtual_memory_bytes Virtual memory size in bytes.# TYPE process_virtual_memory_bytes gauge
process_virtual_memory_bytes 7.77281536e+08# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.# TYPE process_virtual_memory_max_bytes gauge
process_virtual_memory_max_bytes -1# HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.# TYPE promhttp_metric_handler_requests_in_flight gauge
promhttp_metric_handler_requests_in_flight 1# HELP promhttp_metric_handler_requests_total Total number of scrapes by HTTP status code.# TYPE promhttp_metric_handler_requests_total counter
promhttp_metric_handler_requests_total{code="200"} 1
promhttp_metric_handler_requests_total{code="500"} 0
promhttp_metric_handler_requests_total{code="503"} 0
```
## Creación de un espacio de trabajo de Amazon Managed Service para Prometheus
Para crear un espacio de trabajo de Amazon Managed Service para Prometheus, siga las instrucciones en [Crear un espacio de trabajo](AMP-create-workspace.md).
## Ejecución de un servidor de Prometheus
1. Utilice el siguiente archivo YAML de ejemplo como plantilla para crear un nuevo archivo denominado `prometheus.yaml`. Para`url`, *my-region* sustitúyalo por el valor de tu región y *my-workspace-id* por el ID del espacio de trabajo que Amazon Managed Service for Prometheus generó para ti. Para`region`, sustitúyalo por *my-region* el valor de tu región.
**Ejemplo: archivo YAML**
```
global:
scrape_interval: 15s
external_labels:
monitor: 'prometheus'
scrape_configs:
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:8000']
remote_write:
-
url: https://aps-workspaces.my-region.amazonaws.com/workspaces/my-workspace-id/api/v1/remote_write
queue_config:
max_samples_per_send: 1000
max_shards: 200
capacity: 2500
sigv4:
region: my-region
```
1. Ejecute el servidor de Prometheus para enviar las métricas de la aplicación de demostración al espacio de trabajo de Amazon Managed Service para Prometheus.
```
prometheus --config.file=prometheus.yaml
```
El servidor de Prometheus ahora debería enviar las métricas de la aplicación de demostración al espacio de trabajo de Amazon Managed Service para Prometheus.