

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Richten Sie verwaltete Prometheus-Collectors für Amazon ein OpenSearch Bedienung

Der Amazon Managed Service für Prometheus verwaltete Collector für Amazon OpenSearch Der Service scrapt automatisch Prometheus-compatible Metriken von Ihrem OpenSearch Service-Domain und leitet sie an Ihr Ziel weiter. Amazon Managed Service for Prometheus verwaltet den Collector für Sie und bietet Ihnen die Skalierbarkeit, Sicherheit und Zuverlässigkeit, die Sie benötigen, ohne dass Sie Instanzen, Agenten oder Scraper selbst verwalten müssen. Ihr Ziel kann ein Amazon Managed Service für Prometheus Workspace oder Amazon sein CloudWatch.

Sie können auch einen Scraper erstellen, der in Amazon Elastic Kubernetes Service oder in Amazon Managed Streaming für Apache Kafka integriert ist. Weitere Informationen finden Sie unter [Integrieren Sie Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html) und [Integrieren Sie Amazon MSK](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-msk-integration.html).

## Einen Scraper erstellen
<a name="prom-opensearch-create-scraper"></a>

Bei diesem Verfahren wird davon ausgegangen, dass Sie mit Amazon vertraut sind OpenSearch Verwaltung der Servicedomäne und Netzwerkkonzepte von Amazon Virtual Private Cloud.

Es gibt einige Voraussetzungen für die Erstellung eines Scrapers für OpenSearch Dienstdomäne:
+ Ein Amazon OpenSearch Servicedomäne mit Zugriff auf Amazon Virtual Private Cloud. Nur Unterstützung für verwaltete Sammler OpenSearch Servicedomänen, die VPC-Zugriff haben. Domänen mit öffentlichem Zugriff werden nicht unterstützt.
+ Sicherheitsgruppen, die es dem verwalteten Collector ermöglichen, Ihre zu erreichen OpenSearch Service-Domain-Endpunkt über HTTPS (Port 443). Fügen Sie der Sicherheitsgruppe der Domain eine Regel für eingehenden Datenverkehr hinzu, die HTTPS-Verkehr aus der Sicherheitsgruppe zulässt, die Sie für den Collector bereitstellen.

Um dem Scraper zu sagen, welcher OpenSearch Dienstdomäne, von der die Daten abgeholt werden sollen, geben Sie die Domäne in der `exporters` Feld der Anfrage. Das `exporters` Das Feld enthält eine Liste von Exportkonfigurationen; für eine OpenSearch Dienstdomäne, geben Sie eine an `openSearchConfiguration` mit dem `domainArn` der Domain. Sie stellen das Netzwerk (Subnetze und Sicherheitsgruppe) separat in der `source` Feld, wie in den folgenden Beispielen gezeigt.

**Anmerkung**  
Der Scraper verwendet den VPC-Endpunkt der Domain, der beim Erstellen des Scrapers aufgelöst wurde. Wenn Sie die Domain neu erstellen, erhält sie einen neuen Endpunkt. Sie müssen also einen neuen Scraper erstellen oder den vorhandenen aktualisieren mit [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) um daraus zu sammeln.

Sie geben eine Scrape-Konfiguration an, wenn Sie den Scraper erstellen. Der verwaltete Collector stellt eine Verbindung zu der von Ihnen angegebenen Domain her und erfasst seine Metriken automatisch, sodass Sie in der Konfiguration keine Scrape-Ziele angeben. Die Konfiguration muss eine enthalten `scrape_configs` Abschnitt mit einem Job, dessen `job_name` ist genau `opensearch-exporter`. Eine Konfiguration, die keinen Job mit dem Namen enthält `opensearch-exporter` wird abgelehnt. Verwenden Sie die Scrape-Konfiguration, um das Scrape-Intervall festzulegen und optional die gesammelten Metriken zu filtern oder neu zu kennzeichnen. Im Folgenden finden Sie ein Beispiel für eine Scrape-Konfiguration:

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

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

Weitere Informationen zu den unterstützten Scrape-Konfigurationsoptionen finden Sie unter [Scraper-Konfiguration](AMP-collector-how-to.md#AMP-collector-configuration).

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

Benutze das `CreateScraper` API-Operation, um einen Scraper mit dem zu erstellen AWS API. Im folgenden Beispiel wird ein Scraper in der Region USA Ost (Nord-Virginia) erstellt, der Metriken von einer OpenSearch Service-Domain und sendet sie an einen Amazon Managed Service für Prometheus Workspace. Ersetzen Sie das {{example}} Inhalte mit deinen eigenen Domain-, Netzwerk- und Workspace-Informationen und gib deine Scraper-Konfiguration an.

**Anmerkung**  
Konfigurieren Sie die Sicherheitsgruppe und die Subnetze so, dass sie der Amazon-VPC Ihres OpenSearch Service-Domäne. Schließen Sie mindestens zwei Subnetze in zwei Availability Zones ein.

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

Um die Metriken an Amazon zu senden CloudWatch Ersetzen Sie anstelle eines Amazon Managed Service für Prometheus Workspace den `destination` mit einem CloudWatch Konfiguration:

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

Die `scrapeConfiguration` Der Parameter erfordert eine Base64-kodierte Prometheus-Konfigurations-YAML-Datei. Führen Sie einen der folgenden Befehle aus, um die YAML-Datei in Base64 zu konvertieren. Sie können auch einen beliebigen Online-Base64-Konverter verwenden, um die Datei zu konvertieren.

**Example Linux/macOS**  

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

**Example Windows PowerShell**  

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

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

Benutze das `create-scraper` Befehl zum Erstellen eines Schabers mit dem AWS Command Line Interface. Im folgenden Beispiel wird ein Scraper in der Region USA Ost (Nord-Virginia) erstellt. Ersetzen Sie den {{example}} Inhalte mit deinen eigenen Domain-, Netzwerk- und Workspace-Informationen und gib deine Scraper-Konfiguration an.

**Anmerkung**  
Konfigurieren Sie die Sicherheitsgruppe und die Subnetze so, dass sie der Amazon-VPC Ihres OpenSearch Service-Domäne. Schließen Sie mindestens zwei Subnetze in zwei Availability Zones ein.

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

------
+ Im Folgenden finden Sie eine vollständige Liste der Scraper-Operationen, die Sie mit dem verwenden können AWS API:

  Erstellen Sie einen Scraper mit der [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html) API-Operation.
+ Listen Sie Ihre vorhandenen Scraper mit der [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html) API-Operation auf.
+ Aktualisieren Sie den Alias, die Konfiguration oder das Ziel eines Scrapers mit dem [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) API-Betrieb.
+ Löschen Sie einen Scraper mit der [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) API-Operation.
+ Erfahren Sie mehr über einen Scraper mit der [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html) API-Operation.

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

Um einen Scraper in einem kontoübergreifenden Setup zu erstellen, wenn OpenSearch Die Service-Domain, für die Sie Metriken sammeln möchten, befindet sich in einem anderen Konto als der Amazon Managed Service for Prometheus Collector. Gehen Sie wie folgt vor.

Sie haben beispielsweise zwei Konten: ein Quellkonto `account_id_source` wo OpenSearch Die Dienstdomäne befindet sich und ein Zielkonto `account_id_target` wo sich der Amazon Managed Service für Prometheus Workspace befindet.

**Anmerkung**  
Die Vertrauensrichtlinien in den folgenden Schritten beziehen sich auf den Scraper anhand seines ARN, der Folgendes beinhaltet {{scraper-id}} das existiert erst, wenn Sie den Scraper erstellen. Um dieses Ordnungsproblem zu vermeiden, erstellen Sie zuerst die Rollen mit einem Platzhalter (`scraper/*`) erstellen Sie anstelle des spezifischen Scraper-ARN den Scraper und aktualisieren Sie dann beide Vertrauensrichtlinien, um den Platzhalter durch den tatsächlichen Scraper-ARN zu ersetzen `CreateScraper` kehrt zurück.

**Um einen Scraper in einem kontoübergreifenden Setup zu erstellen**

1. Erstelle im Quellkonto eine Rolle `arn:aws:iam::{{111122223333}}:role/Source` und fügen Sie die folgende Vertrauensrichtlinie hinzu.

   ```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. Erstellen Sie im Zielkonto eine Rolle `arn:aws:iam::{{444455556666}}:role/Target` und fügen Sie die folgende Vertrauensrichtlinie hinzu, die es der Quellrolle ermöglicht, sie zu übernehmen.

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

   Fügen Sie der Zielrolle eine Berechtigungsrichtlinie hinzu, die es ihr ermöglicht, an Ihr Ziel zu schreiben. Wenn es sich bei Ihrem Ziel um einen Amazon Managed Service für Prometheus Workspace handelt, fügen Sie das Dokument als Anhang an [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html) (welche Zuschüsse `aps:RemoteWrite`). Wenn Ihr Ziel Amazon ist CloudWatch, fügen Sie eine Police bei, die Folgendes gewährt `cloudwatch:PutMetricData` auf dem Datensatz.

1. Erstellen Sie einen Scraper mit dem `--role-configuration` Option.

   ```
   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. Bestätigen Sie die Erstellung des Scrapers.

   ```
   aws amp list-scrapers
   ```

## Suchen und Löschen von Scrapern
<a name="prom-opensearch-delete-scraper"></a>

Sie können das verwenden AWS API oder die AWS CLI um die Scraper in deinem Konto aufzulisten oder zu löschen.

**Anmerkung**  
Stellen Sie sicher, dass Sie die neueste Version von verwenden AWS CLI oder SDK. Die neueste Version bietet Ihnen die neuesten Features und Funktionen sowie Sicherheitsupdates. Verwenden Sie alternativ [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), das automatisch ein stets aktuelles Befehlszeilenerlebnis bietet.

Die [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html)-API-Operation listet alle Scraper in Ihrem Konto auf. Alternativ können Sie mit dem AWS CLI, rufen Sie an:

```
aws amp list-scrapers
```

Suchen Sie zum Löschen eines Scrapers mithilfe der `ListScrapers`-Operation die `scraperId` für den Scraper, den Sie löschen möchten, und verwenden Sie dann die [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html)-Operation, um ihn zu löschen. Alternativ mit dem AWS CLI, rufen Sie an:

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

## Von Amazon gesammelte Kennzahlen OpenSearch Service
<a name="prom-opensearch-metrics"></a>

Wenn Sie mit Amazon integrieren OpenSearch Service, der Amazon Managed Service für Prometheus Collector, scrapft automatisch Prometheus-compatible Metriken, die den Zustand und die Leistung Ihrer Domain beschreiben. Der Collector gibt mehrere hundert Metriken aus. In den folgenden Tabellen sind repräsentative Metriken aus jeder Kategorie aufgeführt. Die `opensearch_indices_` Die Metriken in den folgenden Tabellen sind domänenübergreifend aggregiert, und viele haben reine Primärvarianten und Gesamtvarianten (Suffix `_primary` oder `_total`). Der Collector gibt auch die gleichen Statistiken pro Index mit einem Präfix aus `opensearch_index_stats_`, und Kennzahlen pro Shard mit Präfix `opensearch_indices_shards_`.

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


| Metrik | Beschreibung/Zweck | 
| --- | --- | 
| opensearch\_cluster\_health\_status | Integritätsstatus des Clusters (grün, gelb oder rot). | 
| opensearch\_cluster\_health\_number\_of\_nodes | Anzahl der Knoten im -Cluster. | 
| opensearch\_cluster\_health\_number\_of\_data\_nodes | Anzahl der Datenknoten im Cluster. | 
| opensearch\_cluster\_health\_active\_primary\_shards | Anzahl der aktiven primären Shards. | 
| opensearch\_cluster\_health\_active\_shards | Gesamtzahl der aktiven Shards, einschließlich primärer Shards und Replikat-Shards. | 
| opensearch\_cluster\_health\_relocating\_shards | Anzahl der Shards, die zwischen Knoten verschoben werden. | 
| opensearch\_cluster\_health\_initializing\_shards | Anzahl der Shards, die initialisiert werden. | 
| opensearch\_cluster\_health\_unassigned\_shards | Anzahl der Shards, die keinem Knoten zugewiesen sind. | 
| opensearch\_cluster\_health\_delayed\_unassigned\_shards | Anzahl der nicht zugewiesenen Shards, deren Zuweisung verzögert ist. | 
| opensearch\_cluster\_health\_number\_of\_pending\_tasks | Anzahl der Aufgaben auf Clusterebene, die sich in der Warteschlange befinden und auf ihre Ausführung warten. | 
| opensearch\_cluster\_health\_number\_of\_in\_flight\_fetch | Anzahl der laufenden Shard-Abrufanfragen. | 
| opensearch\_cluster\_health\_task\_max\_waiting\_in\_queue\_millis | Längste Zeit, die eine Aufgabe in der Warteschlange gewartet hat, in Millisekunden. | 

### Knoten-Metriken
<a name="opensearch-node-metrics"></a>


| Metrik | Beschreibung/Zweck | 
| --- | --- | 
| opensearch\_os\_cpu\_percent | Prozentsatz der vom Betriebssystem auf dem Knoten verwendeten CPU. | 
| opensearch\_os\_load1 | Durchschnittliche Auslastung des Betriebssystems in der letzten 1 Minute. Der Kollektor emittiert außerdem `opensearch_os_load5` und `opensearch_os_load15`. | 
| opensearch\_os\_mem\_used\_bytes | Menge des verwendeten physischen Speichers in Byte. Der Kollektor sendet außerdem `opensearch_os_mem_free_bytes`, `opensearch_os_mem_actual_used_bytes`, und `opensearch_os_mem_actual_free_bytes`. | 
| Öffnen Sie search\_jvm\_memory\_used\_bytes | Menge des verwendeten JVM-Speichers in Byte, aufgeschlüsselt nach Speicherbereich (Heap und Nicht-Heap). Zu den verwandten Metriken gehören `opensearch_jvm_memory_committed_bytes` und `opensearch_jvm_memory_max_bytes`. | 
| opensearch\_jvm\_gc\_collection\_seconds\_count | Gesamtzahl der JVM-Garbage-Collection-Ereignisse. Verwenden Sie mit `opensearch_jvm_gc_collection_seconds_sum`, die Gesamtzeit, die für die Müllabfuhr aufgewendet wurde. | 
| opensearch\_jvm\_uptime\_seconds | JVM-Verfügbarkeit in Sekunden. | 
| öffnen Sie search\_thread\_pool\_active\_count | Anzahl der aktiven Threads in jedem Threadpool. Zu den verwandten Metriken gehören `opensearch_thread_pool_queue_count`, `opensearch_thread_pool_rejected_count`, und `opensearch_thread_pool_completed_count`. | 
| opensearch\_filesystem\_data\_available\_bytes | Menge an Speicherplatz, der dem Knoten zur Verfügung steht, in Byte. Zu den verwandten Metriken gehören `opensearch_filesystem_data_free_bytes` und `opensearch_filesystem_data_size_bytes`. | 
| opensearch\_filesystem\_io\_stats\_device\_read\_operations\_count | Anzahl der Lesevorgänge auf der Festplatte. Der Kollektor gibt auch die Anzahl der Schreib- und Gesamtvorgänge sowie die Lese- und Schreibgrößen aus (z. B. `opensearch_filesystem_io_stats_device_read_size_kilobytes_sum`). | 
| opensearch\_process\_cpu\_percent | Prozentsatz der von der verwendeten CPU OpenSearch Prozess. | 
| opensearch\_process\_mem\_resident\_size\_bytes | Größe des residenten Speichers von OpenSearch Prozess, in Byte. | 
| opensearch\_process\_open\_files\_count | Anzahl der Dateideskriptoren, die von der geöffnet wurden OpenSearch prozess. | 
| opensearch\_breakers\_tripped | Gesamtzahl der Auslösevorgänge, mit denen jeder Leistungsschalter ausgelöst wurde. Zu den verwandten Metriken gehören `opensearch_breakers_estimated_size_bytes` und `opensearch_breakers_limit_size_bytes`. | 
| opensearch\_transport\_rx\_size\_bytes\_total | Gesamtmenge der über die Transportschicht zwischen den Knoten empfangenen Daten, in Byte. Der Kollektor sendet auch `opensearch_transport_tx_size_bytes_total` und die Anzahl der Pakete. | 
| opensearch\_indexing\_pressure\_current\_all\_in\_bytes | Aktueller Speicher, der von Indexierungsanfragen verbraucht wird, in Byte, mit `opensearch_indexing_pressure_limit_in_bytes` als konfiguriertes Limit. | 

### Metriken indexieren
<a name="opensearch-index-metrics"></a>


| Metrik | Beschreibung/Zweck | 
| --- | --- | 
| opensearch\_indices\_docs | Anzahl der Dokumente. Zu den verwandten Metriken gehören `opensearch_indices_docs_deleted`, `opensearch_indices_docs_primary`, und `opensearch_indices_docs_total`. | 
| opensearch\_indices\_store\_size\_bytes | Gesamtgröße der Indizes auf der Festplatte, in Byte, mit `opensearch_indices_store_size_bytes_primary` und `opensearch_indices_store_size_bytes_total` Varianten. | 
| opensearch\_indices\_indexing\_index\_total | Gesamtzahl der indizierten Dokumente. Verwenden Sie mit `opensearch_indices_indexing_index_time_seconds_total` zur Indizierung der Latenz. | 
| opensearch\_indices\_indexing\_ist\_gedrosselt | Gibt an, ob die Indizierung derzeit gedrosselt ist, mit `opensearch_indices_indexing_throttle_time_seconds_total` für die gesamte gedrosselte Zeit. | 
| opensearch\_indices\_search\_query\_total | Gesamtzahl der Suchanfragen. Verwenden Sie mit `opensearch_indices_search_query_time_seconds` für die Latenz bei Abfragen. | 
| opensearch\_indices\_search\_fetch\_total | Gesamtzahl der Abrufvorgänge, mit `opensearch_indices_search_fetch_time_seconds` für die Latenz beim Abrufen. | 
| opensearch\_indices\_get\_total | Gesamtzahl der Get-Operationen, mit `opensearch_indices_get_time_seconds` für Get-Latenz. | 
| opensearch\_indices\_merges\_total | Gesamtzahl der abgeschlossenen Segmentzusammenführungen. Zu den verwandten Metriken gehören `opensearch_indices_merges_current` und `opensearch_indices_merges_total_time_seconds_total`. | 
| opensearch\_indices\_refresh\_total | Gesamtzahl der Indexaktualisierungsvorgänge, mit `opensearch_indices_refresh_time_seconds_total` für die Aktualisierungszeit. | 
| opensearch\_indices\_flush\_total | Gesamtzahl der Index-Flush-Operationen, mit `opensearch_indices_flush_time_seconds` für die Spülzeit. | 
| opensearch\_indices\_segments\_count | Anzahl der Segmente. Der Collector gibt auch segmentspezifische Speichermetriken aus (z. B. `opensearch_indices_segments_memory_bytes` und `opensearch_indices_segment_terms_memory_total`). | 
| opensearch\_indices\_translog\_operations | Anzahl der Operationen im Transaktionslog, mit `opensearch_indices_translog_size_in_bytes` für seine Größe. | 
| opensearch\_indices\_fielddata\_memory\_size\_bytes | Vom Felddaten-Cache verwendeter Speicher, in Byte, mit `opensearch_indices_fielddata_evictions` für Räumungen. | 
| opensearch\_indices\_query\_cache\_memory\_size\_bytes | Vom Abfrage-Cache verwendeter Speicher in Byte. Zu den verwandten Metriken gehören `opensearch_indices_query_cache_count` und `opensearch_indices_query_cache_evictions`. | 
| opensearch\_indices\_request\_cache\_memory\_size\_bytes | Vom Anforderungs-Cache verwendeter Speicher in Byte. Zu den verwandten Metriken gehören `opensearch_indices_request_cache_count` und `opensearch_indices_request_cache_evictions`. | 

## Einschränkungen
<a name="prom-opensearch-limitations"></a>

Der Amazonas OpenSearch Die Serviceintegration mit Amazon Managed Service für Prometheus hat die folgenden Einschränkungen:
+ Wird nur unterstützt für OpenSearch Servicedomänen, die Zugriff auf Amazon Virtual Private Cloud haben. Domains mit öffentlichem Zugriff werden nicht unterstützt.
+ Ein Scraper sammelt Metriken von einem einzigen OpenSearch Service-Domäne. Um Metriken von mehr als einer Domain zu sammeln, erstellen Sie für jede Domain einen separaten Scraper.