

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.

# Configure los recopiladores de Prometheus gestionados para Amazon OpenSearch Servicio

El servicio gestionado de Amazon para Prometheus gestionó el recopilador para Amazon OpenSearch El servicio se elimina automáticamente Prometheus-compatible métricas de su OpenSearch Domina el servicio y los reenvía a tu destino. Amazon Managed Service for Prometheus administra el recopilador por usted, lo que le brinda la escalabilidad, la seguridad y la confiabilidad que necesita, sin tener que administrar ninguna instancia, agente o raspador usted mismo. Su destino puede ser un Amazon Managed Service para Prometheus Workspace o Amazon CloudWatch.

También puede crear un scraper que se integre con Amazon Elastic Kubernetes Service o con Amazon Managed Streaming para Apache Kafka. Para obtener más información, consulte [Integre Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html) y [Integre Amazon MSK](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-msk-integration.html).

## Crear un raspador
<a name="prom-opensearch-create-scraper"></a>

Este procedimiento presupone que estás familiarizado con Amazon OpenSearch Conceptos de administración de dominios de servicio y redes de Amazon Virtual Private Cloud.

Hay algunos requisitos previos para crear un raspador para un OpenSearch Dominio de servicio:
+ Un Amazon OpenSearch Dominio de servicio con acceso a Amazon Virtual Private Cloud. Solo son compatibles con los recopiladores gestionados OpenSearch Dominios de servicio que tienen acceso a la VPC. No se admiten dominios con acceso público.
+ Grupos de seguridad que permiten que el recopilador administrado llegue a su OpenSearch Punto final del dominio de servicio a través de HTTPS (puerto 443). Agregue una regla de entrada al grupo de seguridad del dominio que permita el tráfico HTTPS desde el grupo de seguridad que proporcione para el recopilador.

Para decirle al raspador cuál OpenSearch El dominio del servicio desde el que se va a recopilar, debe especificar el dominio en `exporters` campo de la solicitud. El `exporters` el campo contiene una lista de las configuraciones del exportador; para un OpenSearch Dominio de servicio, proporcione un `openSearchConfiguration` con el `domainArn` del dominio. Usted proporciona la red (subredes y grupo de seguridad) por separado en el `source` campo, como se muestra en los siguientes ejemplos.

**nota**  
El raspador usa el punto final de la VPC del dominio tal como se resolvió al crear el raspador. Si vuelves a crear el dominio, obtiene un nuevo punto final, por lo que debes crear un nuevo raspador o actualizar el existente con [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) para recolectar de él.

Usted proporciona una configuración de raspado al crear el raspador. El recopilador administrado se conecta al dominio que especifique y recopila sus métricas automáticamente, por lo que no es necesario especificar los destinos de extracción en la configuración. La configuración debe incluir una sección `scrape_configs` con un trabajo cuyo valor de `job_name` sea exactamente `opensearch-exporter`. Una configuración que no contiene un trabajo llamado `opensearch-exporter` está rechazada. Utilice la configuración de extracción para establecer el intervalo de extracción y, si lo desea, para filtrar o volver a etiquetar las métricas recopiladas. El siguiente es un ejemplo de configuración de raspado:

```YAML
global:
  external_labels:
    domain_name: {{my-opensearch-domain}}

scrape_configs:
  - job_name: opensearch-exporter
    scrape_interval: 60s
```

Para obtener más información acerca de las opciones de configuración de raspado compatibles, consulte [Configuración del raspador](AMP-collector-how-to.md#AMP-collector-configuration).

------
#### [ To create a scraper using the AWS API ]

Usa el `CreateScraper` Operación de API para crear un raspador con el AWS API. En el siguiente ejemplo, se crea un raspador en la región EE.UU. Este (Norte de Virginia) que recopila métricas de un OpenSearch El dominio del servicio y los envía a un espacio de trabajo de Amazon Managed Service for Prometheus. Sustituya el {{example}} el contenido con su propia información de dominio, red y espacio de trabajo, y proporcione su configuración de scraper.

**nota**  
Configure el grupo de seguridad y las subredes para que coincidan con la Amazon VPC de su OpenSearch Dominio de servicio. Incluya al menos dos subredes en dos zonas de disponibilidad.

```JSON
POST /scrapers HTTP/1.1

{
    "alias": "{{myScraper}}",
    "source": {
        "vpcConfiguration": {
            "securityGroupIds": ["{{sg-security-group-id}}"],
            "subnetIds": ["{{subnet-subnet-id-1}}", "{{subnet-subnet-id-2}}"]
        }
    },
    "exporters": [
        {
            "openSearchConfiguration": {
                "domainArn": "arn:aws:es:{{us-east-1}}:{{123456789012}}:domain/{{my-opensearch-domain}}"
            }
        }
    ],
    "destination": {
        "ampConfiguration": {
            "workspaceArn": "arn:aws:aps:{{us-east-1}}:{{123456789012}}:workspace/{{ws-workspace-id}}"
        }
    },
    "scrapeConfiguration": {
        "configurationBlob": "{{base64-encoded-blob}}"
    }
}
```

Para enviar las métricas a Amazon CloudWatch en lugar de un espacio de trabajo de Amazon Managed Service para Prometheus, sustituya el `destination` con un CloudWatch configuración:

```JSON
    "destination": {
        "cloudWatchConfiguration": {
            "datasetArn": "arn:aws:cloudwatch:{{us-east-1}}:{{123456789012}}:dataset/default"
        }
    }
```

El `scrapeConfiguration` el parámetro requiere un archivo YAML de configuración de Prometheus codificado en base64. Ejecute uno de los siguientes comandos para convertir el archivo YAML a base64. También puede usar cualquier conversor de base64 en línea para convertir el archivo.

**Example Linux/macOS**  

```bash,sh,zsh
base64 -w0 {{scraper-config.yaml}}
```

**Example escaparates PowerShell**  

```powershell,ps
[Convert]::ToBase64String([System.IO.File]::ReadAllBytes("{{scraper-config.yaml}}"))
```

------
#### [ To create a scraper using the AWS CLI ]

Utilice el comando `create-scraper` para crear un scraper con la AWS Command Line Interface. El siguiente ejemplo crea un scraper en la región Este de EE. UU. (Norte de Virginia). Sustituya el {{example}} el contenido con su propia información de dominio, red y espacio de trabajo, y proporcione su configuración de scraper.

**nota**  
Configure el grupo de seguridad y las subredes para que coincidan con la Amazon VPC de su OpenSearch Dominio de servicio. Incluya al menos dos subredes en dos zonas de disponibilidad.

```
aws amp create-scraper \
 --source '{"vpcConfiguration":{"securityGroupIds":["{{sg-security-group-id}}"],"subnetIds":["{{subnet-subnet-id-1}}","{{subnet-subnet-id-2}}"]}}' \
 --exporters '[{"openSearchConfiguration":{"domainArn":"arn:aws:es:{{us-east-1}}:{{123456789012}}:domain/{{my-opensearch-domain}}"}}]' \
 --scrape-configuration configurationBlob={{base64-encoded-blob}} \
 --destination '{"ampConfiguration":{"workspaceArn":"arn:aws:aps:{{us-east-1}}:{{123456789012}}:workspace/{{ws-workspace-id}}"}}'
```

------
+ La siguiente es una lista completa de las operaciones de extracción que puede utilizar con el AWS API:

  Crear un raspador con la operación de la API [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html).
+ Enumerar sus raspadores existentes con la operación de la API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html).
+ Actualice el alias, la configuración o el destino de un raspador con [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) Operación de API.
+ Eliminar un raspador con la operación de la API [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html).
+ Obtener más detalles sobre un raspador con la operación de la API [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html).

## Cross-account configuración
<a name="prom-opensearch-cross-account"></a>

Para crear un raspador en una configuración multicuenta, cuando OpenSearch El dominio de servicio del que quieres recopilar las métricas se encuentra en una cuenta diferente a la del recopilador de Amazon Managed Service for Prometheus, sigue el siguiente procedimiento.

Por ejemplo, tienes dos cuentas: una cuenta de origen `account_id_source` donde el OpenSearch Se encuentra el dominio del servicio y una cuenta de destino `account_id_target` donde reside el espacio de trabajo de Amazon Managed Service for Prometheus.

**nota**  
Las políticas de confianza de los pasos siguientes hacen referencia al raspador por su ARN, que incluye un {{scraper-id}} eso no existe hasta que se crea el raspador. Para evitar este problema de ordenamiento, primero cree los roles con un comodín (`scraper/*`) en lugar del ARN específico del raspador, cree el raspador y, a continuación, actualice ambas políticas de confianza para reemplazar el comodín por el ARN del raspador real que `CreateScraper` devuelve.

**Para crear un scraper en una configuración entre cuentas**

1. En la cuenta de origen, cree un rol `arn:aws:iam::{{111122223333}}:role/Source` y agregue la siguiente política de confianza.

   ```JSON
   {
       "Effect": "Allow",
       "Principal": {
       "Service": [
           "scraper.aps.amazonaws.com"
        ]
       },
       "Action": "sts:AssumeRole",
       "Condition": {
           "ArnEquals": {
               "aws:SourceArn": "arn:aws:aps:{{aws-region}}:{{111122223333}}:scraper/{{scraper-id}}"
           },
           "StringEquals": {
               "AWS:SourceAccount": "{{111122223333}}"
           }
       }
   }
   ```

1. En la cuenta de destino, crea un rol `arn:aws:iam::{{444455556666}}:role/Target` y añada la siguiente política de confianza, que permite que el rol de origen lo asuma.

   ```JSON
   {
     "Effect": "Allow",
     "Principal": {
        "AWS": "arn:aws:iam::{{111122223333}}:role/Source"
     },
     "Action": "sts:AssumeRole",
     "Condition": {
        "StringEquals": {
           "sts:ExternalId": "arn:aws:aps:{{aws-region}}:{{111122223333}}:scraper/{{scraper-id}}"
         }
     }
   }
   ```

   Adjunte una política de permisos al rol de destino que le permita escribir en su destino. Si tu destino es un espacio de trabajo de Amazon Managed Service for Prometheus, adjunta [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html) (lo que otorga `aps:RemoteWrite`). Si tu destino es Amazon CloudWatch, adjunta una política que conceda `cloudwatch:PutMetricData` en el conjunto de datos.

1. Cree un scraper con la opción `--role-configuration`.

   ```
   aws amp create-scraper \
    --source '{"vpcConfiguration":{"securityGroupIds":["{{sg-security-group-id}}"],"subnetIds":["{{subnet-subnet-id-1}}","{{subnet-subnet-id-2}}"]}}' \
    --exporters '[{"openSearchConfiguration":{"domainArn":"arn:aws:es:{{aws-region}}:{{111122223333}}:domain/{{my-opensearch-domain}}"}}]' \
    --scrape-configuration configurationBlob={{<base64-encoded-blob>}} \
    --destination '{"ampConfiguration":{"workspaceArn":"arn:aws:aps:{{aws-region}}:{{444455556666}}:workspace/{{ws-workspace-id}}"}}' \
    --role-configuration '{"sourceRoleArn":"arn:aws:iam::{{111122223333}}:role/Source", "targetRoleArn":"arn:aws:iam::{{444455556666}}:role/Target"}'
   ```

1. Valide la creación del scraper.

   ```
   aws amp list-scrapers
   ```

## Buscar y eliminar raspadores
<a name="prom-opensearch-delete-scraper"></a>

Puede utilizar el AWS API o la AWS CLI para enumerar los raspadores de su cuenta o eliminarlos.

**nota**  
Asegúrese de que está utilizando la versión más reciente de AWS CLI o SDK. La última versión le proporciona las características y funcionalidades más recientes, así como actualizaciones de seguridad. Como alternativa, puede utilizar [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), que proporciona una experiencia de línea de comandos siempre actualizada de forma automática.

Para enumerar todos los raspadores de su cuenta, utilice la operación de la API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html). Alternativamente, con el AWS CLI, llame al:

```
aws amp list-scrapers
```

Para eliminar un raspador, busque `scraperId` para el raspador que desea eliminar mediante la operación `ListScrapers` y, a continuación, utilice la operación [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) para eliminarlo. Alternativamente, con el AWS CLI, llame al:

```
aws amp delete-scraper --scraper-id {{scraperId}}
```

## Métricas recopiladas de Amazon OpenSearch Servicio
<a name="prom-opensearch-metrics"></a>

Cuando te integras con Amazon OpenSearch El servicio, el recopilador de Amazon Managed Service para Prometheus, se elimina automáticamente Prometheus-compatible métricas que describen el estado y el rendimiento de tu dominio. El recopilador emite varios cientos de métricas; en las tablas siguientes se muestran las métricas representativas de cada categoría. El `opensearch_indices_` las métricas de las siguientes tablas se agregan en todo el dominio y muchas tienen variantes únicas y totales (con sufijos) `_primary` o `_total`). El recopilador también emite las mismas estadísticas por índice, con el prefijo `opensearch_index_stats_`, y las métricas por fragmento tienen un prefijo `opensearch_indices_shards_`.

### Métricas de clúster
<a name="opensearch-cluster-metrics"></a>


| Métrica | Descripción o finalidad | 
| --- | --- | 
| opensearch\_cluster\_health\_status | Estado de salud del clúster (verde, amarillo o rojo). | 
| opensearch\_cluster\_health\_number\_of\_nodes | Número de nodos en el clúster de . | 
| opensearch\_cluster\_health\_number\_of\_data\_nodes | Número de nodos de datos del clúster. | 
| opensearch\_cluster\_health\_active\_primary\_shards | Número de fragmentos primarios activos. | 
| opensearch\_cluster\_health\_active\_shards | Número total de fragmentos activos, incluidos los fragmentos principales y de réplica. | 
| opensearch\_cluster\_health\_relocating\_shards | Número de fragmentos que se reubican entre nodos. | 
| opensearch\_cluster\_health\_initializing\_shards | Número de fragmentos que se están inicializando. | 
| opensearch\_cluster\_health\_unassigned\_shards | Número de fragmentos que no están asignados a un nodo. | 
| opensearch\_cluster\_health\_delayed\_unassigned\_shards | Número de fragmentos no asignados cuya asignación está retrasada. | 
| opensearch\_cluster\_health\_number\_of\_pending\_tasks | Número de tareas a nivel de clúster que están en cola y esperando para ejecutarse. | 
| opensearch\_cluster\_health\_number\_of\_in\_flight\_fetch | Número de solicitudes de recuperación de fragmentos en curso. | 
| opensearch\_cluster\_health\_task\_max\_waiting\_in\_queue\_millis | Tiempo máximo que una tarea ha permanecido en la cola, en milisegundos. | 

### Métricas de nodos
<a name="opensearch-node-metrics"></a>


| Métrica | Descripción o finalidad | 
| --- | --- | 
| opensearch\_os\_cpu\_percent | Porcentaje de CPU utilizada por el sistema operativo en el nodo. | 
| opensearch\_os\_load1 | Media de carga del sistema operativo en el último minuto. El colector también emite `opensearch_os_load5` y `opensearch_os_load15`. | 
| opensearch\_os\_mem\_used\_bytes | Cantidad de memoria física utilizada, en bytes. El recopilador también emite `opensearch_os_mem_free_bytes`, `opensearch_os_mem_actual_used_bytes`, y `opensearch_os_mem_actual_free_bytes`. | 
| opensearch\_jvm\_memory\_used\_bytes | Cantidad de memoria de JVM utilizada, en bytes, por área de memoria (pila y sin pila). Las métricas relacionadas incluyen `opensearch_jvm_memory_committed_bytes` y `opensearch_jvm_memory_max_bytes`. | 
| opensearch\_jvm\_gc\_collection\_seconds\_count | Número total de eventos de recolección de basura de JVM. Utilícelo con `opensearch_jvm_gc_collection_seconds_sum`, el tiempo total empleado en la recolección de basura. | 
| opensearch\_jvm\_uptime\_seconds | Tiempo de actividad de JVM, en segundos. | 
| opensearch\_thread\_pool\_active\_count | Número de subprocesos activos en cada grupo de subprocesos. Las métricas relacionadas incluyen `opensearch_thread_pool_queue_count`, `opensearch_thread_pool_rejected_count`, y `opensearch_thread_pool_completed_count`. | 
| opensearch\_filesystem\_data\_available\_bytes | Cantidad de espacio en disco disponible para el nodo, en bytes. Las métricas relacionadas incluyen `opensearch_filesystem_data_free_bytes` y `opensearch_filesystem_data_size_bytes`. | 
| opensearch\_filesystem\_io\_stats\_device\_read\_operations\_count | Número de operaciones de lectura de disco. El recopilador también emite los recuentos totales de operaciones de escritura y escritura y los tamaños de lectura y escritura (por ejemplo, `opensearch_filesystem_io_stats_device_read_size_kilobytes_sum`). | 
| opensearch\_process\_cpu\_percent | Porcentaje de CPU utilizada por el OpenSearch proceso. | 
| opensearch\_process\_mem\_resident\_size\_bytes | Tamaño de la memoria residente del OpenSearch proceso, en bytes. | 
| opensearch\_process\_open\_files\_count | Número de descriptores de archivos abiertos por OpenSearch proceso. | 
| opensearch\_breakers\_tripped | Número total de veces que se ha disparado cada disyuntor. Las métricas relacionadas incluyen `opensearch_breakers_estimated_size_bytes` y `opensearch_breakers_limit_size_bytes`. | 
| opensearch\_transport\_rx\_size\_bytes\_total | Cantidad total de datos recibidos a través de la capa de transporte entre nodos, en bytes. El recopilador también emite `opensearch_transport_tx_size_bytes_total` y recuentos de paquetes. | 
| opensearch\_indexing\_pressure\_current\_all\_in\_bytes | Memoria actual consumida por las solicitudes de indexación, en bytes, con `opensearch_indexing_pressure_limit_in_bytes` como límite configurado. | 

### Métricas de índice
<a name="opensearch-index-metrics"></a>


| Métrica | Descripción o finalidad | 
| --- | --- | 
| opensearch\_indices\_docs | Número de documentos. Las métricas relacionadas incluyen `opensearch_indices_docs_deleted`, `opensearch_indices_docs_primary`, y `opensearch_indices_docs_total`. | 
| opensearch\_indices\_store\_size\_bytes | Tamaño total de los índices del disco, en bytes, con `opensearch_indices_store_size_bytes_primary` y `opensearch_indices_store_size_bytes_total` variantes. | 
| opensearch\_indices\_indexing\_index\_total | Número total de documentos indexados. Utilícelo con `opensearch_indices_indexing_index_time_seconds_total` para la latencia de indexación. | 
| opensearch\_indices\_indexing\_is\_throttled | Indica si la indexación está actualmente limitada, con `opensearch_indices_indexing_throttle_time_seconds_total` durante el tiempo total limitado. | 
| opensearch\_indices\_search\_query\_total | Número total de consultas de búsqueda. Utilícelo con `opensearch_indices_search_query_time_seconds` para la latencia de las consultas. | 
| opensearch\_indices\_search\_fetch\_total | Número total de operaciones de búsqueda, con `opensearch_indices_search_fetch_time_seconds` para la latencia de recuperación. | 
| opensearch\_indices\_get\_total | Número total de operaciones de obtención, con `opensearch_indices_get_time_seconds` para obtener latencia. | 
| opensearch\_indices\_merges\_total | Número total de fusiones de segmentos completadas. Las métricas relacionadas incluyen `opensearch_indices_merges_current` y `opensearch_indices_merges_total_time_seconds_total`. | 
| opensearch\_indices\_refresh\_total | Número total de operaciones de actualización del índice, con `opensearch_indices_refresh_time_seconds_total` para el tiempo de actualización. | 
| opensearch\_indices\_flush\_total | Número total de operaciones de limpieza de índices, con `opensearch_indices_flush_time_seconds` para el tiempo de descarga. | 
| opensearch\_indices\_segments\_count | Número de segmentos. El recopilador también emite métricas de memoria por segmento (por ejemplo, `opensearch_indices_segments_memory_bytes` y `opensearch_indices_segment_terms_memory_total`). | 
| opensearch\_indices\_translog\_operations | Número de operaciones en el registro de transacciones, con `opensearch_indices_translog_size_in_bytes` por su tamaño. | 
| opensearch\_indices\_fielddata\_memory\_size\_bytes | Memoria utilizada por la caché de datos de campo, en bytes, con `opensearch_indices_fielddata_evictions` para desalojos. | 
| opensearch\_indices\_query\_cache\_memory\_size\_bytes | Memoria utilizada por la caché de consultas, en bytes. Las métricas relacionadas incluyen `opensearch_indices_query_cache_count` y `opensearch_indices_query_cache_evictions`. | 
| opensearch\_indices\_request\_cache\_memory\_size\_bytes | Memoria utilizada por la caché de solicitudes, en bytes. Las métricas relacionadas incluyen `opensearch_indices_request_cache_count` y `opensearch_indices_request_cache_evictions`. | 

## Limitaciones
<a name="prom-opensearch-limitations"></a>

El Amazonas OpenSearch La integración del servicio con Amazon Managed Service for Prometheus tiene las siguientes limitaciones:
+ Solo es compatible con OpenSearch Dominios de servicio que tienen acceso a Amazon Virtual Private Cloud. No se admiten dominios con acceso público.
+ Un raspador recopila métricas de un solo OpenSearch Dominio de servicio. Para recopilar métricas de más de un dominio, cree un extractor independiente para cada dominio.