

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Configura raccoglitori Prometheus gestiti per Amazon OpenSearch Assistenza

Il collettore gestito Amazon Managed Service for Prometheus per Amazon OpenSearch Il servizio esegue automaticamente lo scraping Prometheus-compatible metriche tratte dalle tue OpenSearch Domini di servizio e li inoltra a destinazione. Amazon Managed Service for Prometheus gestisce il collettore per te, offrendoti la scalabilità, la sicurezza e l'affidabilità di cui hai bisogno, senza dover gestire personalmente istanze, agenti o scraper. La tua destinazione può essere Amazon Managed Service for Prometheus workspace o Amazon CloudWatch.

Puoi anche creare uno scraper che si integri con Amazon Elastic Kubernetes Service o con Amazon Managed Streaming per Apache Kafka. Per ulteriori informazioni, consulta [Integra Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html) e [Integra Amazon MSK](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-msk-integration.html).

## Creare uno scraper
<a name="prom-opensearch-create-scraper"></a>

Questa procedura presuppone che tu conosca Amazon OpenSearch Concetti di amministrazione dei domini di servizio e di rete Amazon Virtual Private Cloud.

Esistono alcuni prerequisiti per creare uno scraper per un OpenSearch Dominio di servizio:
+ Un Amazon OpenSearch Dominio di servizio con accesso ad Amazon Virtual Private Cloud. Supporta solo i raccoglitori gestiti OpenSearch Domini di servizio con accesso VPC. I domini con accesso pubblico non sono supportati.
+ Gruppi di sicurezza che consentono al raccoglitore gestito di raggiungere il tuo OpenSearch Endpoint del dominio di servizio su HTTPS (porta 443). Aggiungi una regola in entrata al gruppo di sicurezza del dominio che consenta il traffico HTTPS dal gruppo di sicurezza indicato per il raccoglitore.

Per dire al raschietto quale OpenSearch Dominio di servizio da cui effettuare il prelievo, si specifica il dominio nel `exporters` campo della richiesta. Il `exporters` il campo contiene un elenco di configurazioni dell'esportatore; per un OpenSearch Dominio di servizio, fornire un `openSearchConfiguration` con `domainArn` del dominio. La rete (sottoreti e gruppo di sicurezza) viene fornita separatamente nel `source` campo, come mostrato negli esempi seguenti.

**Nota**  
Lo scraper utilizza l'endpoint VPC del dominio così come risolto al momento della creazione dello scraper. Se si ricrea il dominio, ottiene un nuovo endpoint, quindi è necessario creare un nuovo scraper o aggiornare quello esistente con [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) da prelevare da esso.

Fornisci una configurazione di scrape quando crei lo scraper. Il raccoglitore gestito si connette al dominio specificato e ne raccoglie le metriche automaticamente, quindi non devi specificare destinazioni per lo scraping nella configurazione. La configurazione deve includere una sezione `scrape_configs` con un job con valore `job_name` uguale a `opensearch-exporter`. Una configurazione che non contiene un lavoro denominato `opensearch-exporter` viene rifiutata. Utilizza la configurazione di scrape per impostare l'intervallo di scrape e, facoltativamente, per filtrare o rietichettare le metriche raccolte. Di seguito è riportato un esempio di configurazione scrape:

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

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

Per ulteriori informazioni sulle opzioni di configurazione scrape supportate, vedere [Configurazione dello scraper](AMP-collector-how-to.md#AMP-collector-configuration).

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

Usa il `CreateScraper` Operazione API per creare uno scraper con AWS API. L'esempio seguente crea uno scraper nella regione Stati Uniti orientali (Virginia settentrionale) che raccoglie le metriche da un OpenSearch Domini di servizio e li invia a uno spazio di lavoro Amazon Managed Service for Prometheus. Sostituisci il {{example}} inserisci le tue informazioni sul dominio, sulla rete e sull'area di lavoro e fornisci la configurazione dello scraper.

**Nota**  
Configura il gruppo di sicurezza e le sottoreti in modo che corrispondano all'Amazon VPC del tuo OpenSearch Dominio di servizio. Includi almeno due sottoreti in due zone di disponibilità.

```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}}"
    }
}
```

Per inviare le metriche ad Amazon CloudWatch invece di un Amazon Managed Service for Prometheus workspace, sostituisci il `destination` con un CloudWatch configurazione:

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

La `scrapeConfiguration` il parametro richiede un file YAML di configurazione Prometheus con codifica base64. Eseguite uno dei seguenti comandi per convertire il file YAML in base64. Puoi anche usare qualsiasi convertitore base64 online per convertire il file.

**Example Linux/macOS**  

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

**Example finestre PowerShell**  

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

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

Usa il `create-scraper` comando per creare un raschietto usando il AWS Command Line Interface. L'esempio seguente crea uno scraper nella regione Stati Uniti orientali (Virginia settentrionale). Sostituisci il {{example}} inserisci le tue informazioni sul dominio, sulla rete e sull'area di lavoro e fornisci la configurazione dello scraper.

**Nota**  
Configura il gruppo di sicurezza e le sottoreti in modo che corrispondano all'Amazon VPC del tuo OpenSearch Dominio di servizio. Includi almeno due sottoreti in due zone di disponibilità.

```
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}}"}}'
```

------
+ Di seguito è riportato un elenco completo delle operazioni di scraper che è possibile utilizzare con AWS API:

  Creare uno scraper con l'operazione [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html) API.
+ Elenca i tuoi scraper esistenti con l'operazione [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html) API.
+ Aggiorna l'alias, la configurazione o la destinazione di uno scraper con [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) Funzionamento API.
+ Elimina uno scraper con l'operazione [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) API.
+ Ottieni maggiori dettagli su uno scraper con l'operazione [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html) API.

## Cross-account configurare
<a name="prom-opensearch-cross-account"></a>

Per creare uno scraper in una configurazione con più account, quando OpenSearch Il dominio di servizio da cui desideri raccogliere le metriche si trova in un account diverso dal collector Amazon Managed Service for Prometheus, utilizza la seguente procedura.

Ad esempio, hai due account: un account sorgente `account_id_source` dove OpenSearch si trova il dominio di servizio e un account di destinazione `account_id_target` dove risiede lo spazio di lavoro di Amazon Managed Service for Prometheus.

**Nota**  
Le politiche di fiducia nei passaggi seguenti si riferiscono allo scraper in base al relativo ARN, che include un {{scraper-id}} questo non esiste finché non si crea lo scraper. Per evitare questo problema di ordinamento, crea prima i ruoli con un carattere jolly (`scraper/*`) al posto dello specifico ARN dello scraper, create lo scraper, quindi aggiornate entrambe le policy di fiducia per sostituire la jolly con l'ARN dello scraper effettivo che `CreateScraper` ritorna.

**Per creare uno scraper in una configurazione con più account**

1. Nell'account di origine, crea un ruolo `arn:aws:iam::{{111122223333}}:role/Source` e aggiungi la seguente politica di fiducia.

   ```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. Nell'account di destinazione, crea un ruolo `arn:aws:iam::{{444455556666}}:role/Target` e aggiungi la seguente politica di fiducia, che consente al ruolo di origine di assumerla.

   ```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}}"
         }
     }
   }
   ```

   Allega una politica di autorizzazioni al ruolo di destinazione che gli consenta di scrivere nella tua destinazione. Se la tua destinazione è un'area di lavoro Amazon Managed Service for Prometheus, allega [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html) (che concede `aps:RemoteWrite`). Se la tua destinazione è Amazon CloudWatch, allega una polizza che conceda `cloudwatch:PutMetricData` sul set di dati.

1. Crea un raschietto con `--role-configuration` opzione.

   ```
   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. Convalida la creazione dello scraper.

   ```
   aws amp list-scrapers
   ```

## Trova ed elimina gli scraper
<a name="prom-opensearch-delete-scraper"></a>

Puoi usare AWS API o AWS CLI per elencare gli scraper nel tuo account o per eliminarli.

**Nota**  
Assicurati di utilizzare la versione più recente di AWS CLI o SDK. L'ultima versione offre le caratteristiche e le funzionalità più recenti, nonché gli aggiornamenti di sicurezza. In alternativa, usa [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), che fornisce automaticamente un'esperienza a riga di comando sempre aggiornata.

Per elencare tutti gli scraper del tuo account, usa l’operazione API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html). In alternativa, con AWS CLI, chiama:

```
aws amp list-scrapers
```

Per eliminare uno scraper, trova `scraperId` relativo allo scraper che desideri eliminare, utilizzando l'operazione `ListScrapers`, quindi usa l'operazione [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) per eliminarlo. In alternativa, con AWS CLI, chiama:

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

## Metriche raccolte da Amazon OpenSearch Servizio
<a name="prom-opensearch-metrics"></a>

Quando effettui l'integrazione con Amazon OpenSearch Service, il collettore Amazon Managed Service for Prometheus esegue automaticamente lo scraping Prometheus-compatible metriche che descrivono lo stato e le prestazioni del tuo dominio. Il raccoglitore emette diverse centinaia di metriche; nelle tabelle seguenti sono elencate le metriche rappresentative di ciascuna categoria. Il `opensearch_indices_` le metriche nelle tabelle seguenti sono aggregate in tutto il dominio e molte hanno varianti solo primarie e totali (con suffisso `_primary` o `_total`). Il raccoglitore emette anche le stesse statistiche per indice, con prefisso `opensearch_index_stats_`e metriche per shard con prefisso `opensearch_indices_shards_`.

### Parametri cluster
<a name="opensearch-cluster-metrics"></a>


| Parametro | Descrizione/Scopo | 
| --- | --- | 
| opensearch\_cluster\_health\_status | Stato di integrità del cluster (verde, giallo o rosso). | 
| opensearch\_cluster\_health\_number\_of\_nodes | Numero di nodi nel cluster . | 
| opensearch\_cluster\_health\_number\_of\_data\_nodes | Numero di nodi di dati nel cluster. | 
| opensearch\_cluster\_health\_active\_primary\_shards | Numero di frammenti primari attivi. | 
| opensearch\_cluster\_health\_active\_shards | Numero totale di frammenti attivi, inclusi frammenti primari e di replica. | 
| opensearch\_cluster\_health\_relocating\_shards | Numero di frammenti che si stanno riposizionando tra i nodi. | 
| opensearch\_cluster\_health\_initializing\_shards | Numero di frammenti in fase di inizializzazione. | 
| opensearch\_cluster\_health\_unassigned\_shards | Numero di frammenti non assegnati a un nodo. | 
| opensearch\_cluster\_health\_delayed\_unassigned\_shards | Numero di frammenti non assegnati la cui assegnazione è ritardata. | 
| opensearch\_cluster\_health\_number\_of\_pending\_tasks | Numero di attività a livello di cluster in coda e in attesa di esecuzione. | 
| opensearch\_cluster\_health\_number\_of\_in\_flight\_fetch | Numero di richieste di shard fetch in corso. | 
| opensearch\_cluster\_health\_task\_max\_waiting\_in\_queue\_millis | Tempo massimo di attesa di un'attività in coda, in millisecondi. | 

### Metriche dei nodi
<a name="opensearch-node-metrics"></a>


| Parametro | Descrizione/Scopo | 
| --- | --- | 
| opensearch\_os\_cpu\_percent | Percentuale di CPU utilizzata dal sistema operativo sul nodo. | 
| opensearch\_os\_load1 | Carico medio del sistema operativo nell'ultimo minuto. Il raccoglitore emette anche `opensearch_os_load5` e `opensearch_os_load15`. | 
| opensearch\_os\_mem\_used\_bytes | Quantità di memoria fisica utilizzata, in byte. Il raccoglitore emette anche `opensearch_os_mem_free_bytes`, `opensearch_os_mem_actual_used_bytes`, e `opensearch_os_mem_actual_free_bytes`. | 
| opensearch\_jvm\_memory\_used\_bytes | Quantità di memoria JVM utilizzata, in byte, per area di memoria (heap e non heap). Le metriche correlate includono `opensearch_jvm_memory_committed_bytes` e `opensearch_jvm_memory_max_bytes`. | 
| opensearch\_jvm\_gc\_collection\_seconds\_count | Numero totale di eventi di garbage collection JVM. Usare con `opensearch_jvm_gc_collection_seconds_sum`, il tempo totale dedicato alla raccolta dei rifiuti. | 
| opensearch\_jvm\_uptime\_seconds | Tempo di attività della JVM, in secondi. | 
| opensearch\_thread\_pool\_active\_count | Numero di thread attivi in ogni pool di thread. Le metriche correlate includono `opensearch_thread_pool_queue_count`, `opensearch_thread_pool_rejected_count`, e `opensearch_thread_pool_completed_count`. | 
| opensearch\_filesystem\_data\_available\_bytes | Quantità di spazio su disco disponibile per il nodo, in byte. Le metriche correlate includono `opensearch_filesystem_data_free_bytes` e `opensearch_filesystem_data_size_bytes`. | 
| opensearch\_filesystem\_io\_stats\_device\_read\_operations\_count | Numero di operazioni di lettura del disco. Il raccoglitore emette anche i conteggi delle operazioni di scrittura e totali e le dimensioni di lettura e scrittura (ad esempio, `opensearch_filesystem_io_stats_device_read_size_kilobytes_sum`). | 
| opensearch\_process\_cpu\_percent | Percentuale di CPU utilizzata da OpenSearch processo. | 
| opensearch\_process\_mem\_resident\_size\_bytes | Dimensione della memoria residente di OpenSearch processo, in byte. | 
| opensearch\_process\_open\_files\_count | Numero di descrittori di file aperti da OpenSearch processo. | 
| opensearch\_breakers\_tripped | Numero totale di volte in cui ogni interruttore automatico è scattato. Le metriche correlate includono `opensearch_breakers_estimated_size_bytes` e `opensearch_breakers_limit_size_bytes`. | 
| opensearch\_transport\_rx\_size\_bytes\_total | Quantità totale di dati ricevuti sul livello di trasporto tra i nodi, in byte. Il raccoglitore emette anche `opensearch_transport_tx_size_bytes_total` e conta i pacchetti. | 
| opensearch\_indexing\_pressure\_current\_all\_in\_bytes | Memoria corrente consumata dalle richieste di indicizzazione, in byte, con `opensearch_indexing_pressure_limit_in_bytes` come limite configurato. | 

### Metriche dell'indice
<a name="opensearch-index-metrics"></a>


| Parametro | Descrizione/Scopo | 
| --- | --- | 
| opensearch\_indices\_docs | Numero di documenti. Le metriche correlate includono `opensearch_indices_docs_deleted`, `opensearch_indices_docs_primary`, e `opensearch_indices_docs_total`. | 
| opensearch\_indices\_store\_size\_bytes | Dimensione totale degli indici su disco, in byte, con `opensearch_indices_store_size_bytes_primary` e `opensearch_indices_store_size_bytes_total` varianti. | 
| opensearch\_indices\_indexing\_index\_total | Numero totale di documenti indicizzati. Usare con `opensearch_indices_indexing_index_time_seconds_total` per la latenza di indicizzazione. | 
| opensearch\_indices\_indexing\_is\_throttled | Indica se l'indicizzazione è attualmente limitata, con `opensearch_indices_indexing_throttle_time_seconds_total` per il tempo totale di limitazione. | 
| opensearch\_indices\_search\_query\_total | Numero totale di query di ricerca. Usare con `opensearch_indices_search_query_time_seconds` per la latenza delle interrogazioni. | 
| opensearch\_indices\_search\_fetch\_total | Numero totale di operazioni di recupero, con `opensearch_indices_search_fetch_time_seconds` per la latenza di recupero. | 
| opensearch\_indices\_get\_total | Numero totale di operazioni get, con `opensearch_indices_get_time_seconds` per get latency. | 
| opensearch\_indices\_merges\_total | Numero totale di fusioni di segmenti completate. Le metriche correlate includono `opensearch_indices_merges_current` e `opensearch_indices_merges_total_time_seconds_total`. | 
| opensearch\_indices\_refresh\_total | Numero totale di operazioni di aggiornamento dell'indice, con `opensearch_indices_refresh_time_seconds_total` per il tempo di aggiornamento. | 
| opensearch\_indices\_flush\_total | Numero totale di operazioni di svuotamento dell'indice, con `opensearch_indices_flush_time_seconds` per il tempo di lavaggio. | 
| opensearch\_indices\_segments\_count | Numero di segmenti. Il raccoglitore emette anche metriche di memoria per segmento (ad esempio, `opensearch_indices_segments_memory_bytes` e `opensearch_indices_segment_terms_memory_total`). | 
| opensearch\_indices\_translog\_operations | Numero di operazioni nel registro delle transazioni, con `opensearch_indices_translog_size_in_bytes` per le sue dimensioni. | 
| opensearch\_indices\_fielddata\_memory\_size\_bytes | Memoria utilizzata dalla cache dei dati del campo, in byte, con `opensearch_indices_fielddata_evictions` per gli sfratti. | 
| opensearch\_indices\_query\_cache\_memory\_size\_bytes | Memoria utilizzata dalla cache delle query, in byte. Le metriche correlate includono `opensearch_indices_query_cache_count` e `opensearch_indices_query_cache_evictions`. | 
| opensearch\_indices\_request\_cache\_memory\_size\_bytes | Memoria utilizzata dalla cache delle richieste, in byte. Le metriche correlate includono `opensearch_indices_request_cache_count` e `opensearch_indices_request_cache_evictions`. | 

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

L'Amazon OpenSearch L'integrazione del servizio con Amazon Managed Service for Prometheus presenta le seguenti limitazioni:
+ Supportato solo per OpenSearch Domini di servizio con accesso ad Amazon Virtual Private Cloud. I domini con accesso pubblico non sono supportati.
+ Uno scraper raccoglie le metriche da un singolo OpenSearch Dominio di servizio. Per raccogliere metriche da più di un dominio, crea uno scraper diverso per ogni dominio.