

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-Sammler für Amazon MSK ein

Um einen Amazon Managed Service for Prometheus Collector zu verwenden, erstellen Sie einen Scraper, der Metriken in Ihrem Amazon Managed Streaming for Apache Kafka-Cluster erkennt und abruft. Sie können auch einen Scraper erstellen, der in Amazon Elastic Kubernetes Service oder Amazon integriert werden kann OpenSearch Dienst. 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 OpenSearch Service](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-opensearch-integration.html).

Anweisungen zur Erfassung von Verzögerungen bei Verbrauchergruppen, zugesagten Kompensationen und zur Mitgliedschaft bei einem von Kafka verwalteten Exporteur finden Sie unter [Erfassen Sie Kennzahlen zu Amazon MSK-Verbrauchergruppen](prom-msk-kafka-exporter.md). Dieses Verfahren verwendet AWS Identity and Access Management (IAM) -Authentifizierung und erfordert kein Open Monitoring. Das folgende Verfahren erfasst JMX- und Node Exporter-Metriken aus Open Monitoring.

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

Ein Amazon Managed Service for Prometheus Collector besteht aus einem Scraper, der Metriken aus einem Amazon MSK-Cluster erkennt und sammelt. Amazon Managed Service für Prometheus verwaltet den Scraper für Sie und bietet Ihnen so die Skalierbarkeit, Sicherheit und Zuverlässigkeit, die Sie benötigen, ohne Instances, Agenten oder Scraper selbst verwalten zu müssen.

Sie können einen Scraper erstellen, indem Sie entweder AWS API oder die AWS CLI wie in den folgenden Verfahren beschrieben.

Es gibt einige Voraussetzungen, um Ihren eigenen Scraper zu erstellen:
+ Sie müssen einen Amazon MSK-Cluster erstellt haben.
+ Konfigurieren Sie die Sicherheitsgruppe Ihres Amazon MSK-Clusters so, dass eingehender Datenverkehr auf den Ports zugelassen wird **11001 (JMX-Exporteur)** und **11002 (Node Exporter)** innerhalb Ihrer Amazon-VPC, da der Scraper Zugriff auf diese DNS-Einträge benötigt, um Prometheus-Metriken zu sammeln.
+ Die Amazon VPC, in der sich der Amazon MSK-Cluster befindet, muss [DNS aktiviert](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html).

**Anmerkung**  
Der Cluster wird dem Scraper anhand seines Amazon-Ressourcennamens (ARN) zugeordnet. Wenn Sie einen Cluster löschen und dann einen neuen mit demselben Namen erstellen, wird der ARN für den neuen Cluster wiederverwendet. Aus diesem Grund versucht der Scraper, Metriken für den neuen Cluster zu sammeln. Du [löscht Scraper](#prom-msk-delete-scraper) getrennt vom Löschen des Clusters.

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

Verwenden Sie den `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. Ersetzen Sie den {{example}} Geben Sie Ihre Amazon MSK-Cluster-Informationen ein und geben Sie Ihre Scraper-Konfiguration an.

**Anmerkung**  
Konfigurieren Sie die Sicherheitsgruppe und die Subnetze so, dass sie Ihrem Zielcluster entsprechen. Schließen Sie mindestens zwei Subnetze in zwei Verfügbarkeitszonen ein.

```JSON
                POST /scrapers HTTP/1.1
Content-Length: 415 
Authorization: AUTHPARAMS
X-Amz-Date: 20201201T193725Z
User-Agent: aws-cli/1.18.147 Python/2.7.18 Linux/5.4.58-37.125.amzn2int.x86_64 botocore/1.18.6

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

In dem Beispiel ist der `scrapeConfiguration` Der Parameter erfordert eine Base64-kodierte Prometheus-Konfigurations-YAML-Datei, die die DNS-Einträge des MSK-Clusters angibt.

Jeder DNS-Eintrag stellt einen Broker-Endpunkt in einer bestimmten Availability Zone dar, sodass Kunden eine Verbindung zu Brokern herstellen können, die über die von Ihnen ausgewählten AZs verteilt sind, um eine hohe Verfügbarkeit zu gewährleisten.

Die Anzahl der DNS-Einträge in den Eigenschaften Ihres MSK-Clusters entspricht der Anzahl der Brokerknoten und Availability Zones in Ihrer Clusterkonfiguration:
+ **Standardkonfiguration** — 3 Broker-Knoten auf 3 AZs = 3 DNS-Einträge
+ **Benutzerdefinierte Konfiguration** — 2 Broker-Knoten auf 2 AZs = 2 DNS-Einträge

Um die DNS-Einträge für Ihren MSK-Cluster abzurufen, öffnen Sie die MSK-Konsole unter [https://console.aws.amazon.com/msk/home? region=us-east-1\#/start/](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/). Gehen Sie zu Ihrem MSK-Cluster. Wählen Sie **Eigenschaften**, **Makler**, und **Endpunkte**.

Sie haben zwei Möglichkeiten, Prometheus so zu konfigurieren, dass Metriken aus Ihrem MSK-Cluster entfernt werden:

1. **Cluster-level DNS-Auflösung (empfohlen)** — Verwenden Sie den DNS-Basisnamen des Clusters, um automatisch alle Broker zu ermitteln. Wenn Ihr Broker-Endpunkt ist `b-1.clusterName.xxx.xxx.xxx`, verwenden `clusterName.xxx.xxx.xxx` als DNS-Eintrag. Dadurch kann Prometheus automatisch alle Broker im Cluster scrapen.

   **Einzelne Broker-Endpunkte** — Geben Sie jeden Broker-Endpunkt einzeln an, um eine detaillierte Steuerung zu ermöglichen. Verwenden Sie die vollständigen Broker-Identifikatoren (b-1, b-2) in Ihrer Konfiguration. Beispiel:

   ```YAML
   dns_sd_configs:
     - names:
       - b-1.clusterName.xxx.xxx.xxx
       - b-2.clusterName.xxx.xxx.xxx  
       - b-3.clusterName.xxx.xxx.xxx
   ```

**Anmerkung**  
Ersetzen `clusterName.xxx.xxx.xxx` mit Ihrem tatsächlichen MSK-Cluster-Endpunkt aus dem AWS Konsole.

Weitere Informationen finden Sie unter [<dns\_sd\_config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config) in der *Prometheus* Dokumentation.

Das Folgende ist ein Beispiel für die Scraper-Konfigurationsdatei:

```YAML
global:
  scrape_interval: 30s
  external_labels:
    clusterArn: msk-test-1

scrape_configs:
  - job_name: msk-jmx
    scheme: http
    metrics_path: /metrics
    scrape_timeout: 10s
    dns_sd_configs:
      - names:
          - {{dns-record-1}}
          - {{dns-record-2}}
          - {{dns-record-3}}
        type: A
        port: 11001
    relabel_configs:
      - source_labels: [__meta_dns_name]
        target_label: broker_dns
      - source_labels: [__address__]
        target_label: instance
        regex: '(.*)'
        replacement: '${1}'

  - job_name: msk-node
    scheme: http
    metrics_path: /metrics
    scrape_timeout: 10s
    dns_sd_configs:
      - names:
          - {{dns-record-1}}
          - {{dns-record-2}}
          - {{dns-record-3}}
        type: A
        port: 11002
    relabel_configs:
      - source_labels: [__meta_dns_name]
        target_label: broker_dns
      - source_labels: [__address__]
        target_label: instance
        regex: '(.*)'
        replacement: '${1}'
```

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
echo -n {{scraper config updated with dns records}} | base64 
```

**Example Windows PowerShell**  

```powershell,ps
[Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes({{scraper config updated with dns records}}))
```

------
#### [ 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}} Geben Sie Ihre Amazon MSK-Cluster-Informationen ein und geben Sie Ihre Scraper-Konfiguration an.

**Anmerkung**  
Konfigurieren Sie die Sicherheitsgruppe und die Subnetze so, dass sie Ihrem Zielcluster entsprechen. Schließen Sie mindestens zwei Subnetze in zwei Verfügbarkeitszonen ein.

```
aws amp create-scraper \
 --source vpcConfiguration="{securityGroupIds=['{{sg-security-group-id}}'],subnetIds=['{{subnet-subnet-id-1}}', '{{subnet-subnet-id-2}}']}" \ 
--scrape-configuration configurationBlob={{base64-encoded-blob}} \
 --destination ampConfiguration="{workspaceArn='arn:aws:aps:{{us-west-2}}:{{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-msk-cross-account"></a>

Gehen Sie wie folgt vor, um einen Scraper in einer kontoübergreifenden Konfiguration zu erstellen, wenn sich Ihr Amazon MSK-Cluster, von dem Sie Metriken sammeln möchten, in einem anderen Konto als der Amazon Managed Service for Prometheus Collector befindet.

Wenn Sie beispielsweise zwei Konten haben, das erste Quellkonto `account_id_source` wo sich das Amazon MSK befindet, und ein zweites Zielkonto `account_id_target` wo sich der Amazon Managed Service für Prometheus Workspace befindet.

**Um einen Scraper in einer kontoübergreifenden Konfiguration 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. Für jede Kombination aus Quelle (Amazon MSK-Cluster) und Ziel (Amazon Managed Service for Prometheus Workspace) müssen Sie eine Rolle erstellen `arn:aws:iam::{{444455556666}}:role/Target` und fügen Sie die folgende Vertrauensrichtlinie mit Berechtigungen für hinzu [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html).

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

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

   ```JSON
   aws amp create-scraper \ --source vpcConfiguration="{subnetIds={{[subnet-subnet-id]}}, "securityGroupIds": ["{{sg-security-group-id}}"]}" \ --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.

   ```JSON
   aws amp list-scrapers
   {
       "scrapers": [
           {
               "scraperId": "s-example123456789abcdef0",
               "arn": "arn:aws:aps:{{aws-region}}:111122223333:scraper/s-example123456789abcdef0": "arn:aws:iam::111122223333:role/Source",
               "status": "ACTIVE",
               "creationTime": "2025-10-27T18:45:00.000Z",
               "lastModificationTime": "2025-10-27T18:50:00.000Z",
               "tags": {},
               "statusReason": "Scraper is running successfully",
               "source": {
                   "vpcConfiguration": {
                       "subnetIds": ["subnet-subnet-id"],
                       "securityGroupIds": ["sg-security-group-id"]
                   }
               },
               "destination": {
                   "ampConfiguration": {
                       "workspaceArn": "arn:aws:aps:{{aws-region}}:444455556666:workspace/ws-workspace-id'"
                   }
               },
               "scrapeConfiguration": {
                   "configurationBlob": "<base64-encoded-blob>"
               }
           }
       ]
   }
   ```

## Wechselt zwischen RoleConfiguration und dienstbezogene Rolle
<a name="prom-msk-changing-roles"></a>

Wenn Sie zurück zu einer dienstverknüpften Rolle wechseln möchten, anstatt zu `RoleConfiguration` um in einen Amazon Managed Service for Prometheus-Workspace zu schreiben, müssen Sie den `UpdateScraper` und stelle einen Workspace im gleichen Konto wie der Scraper bereit, ohne `RoleConfiguration`. Das `RoleConfiguration` wird aus dem Scraper entfernt und die dienstgebundene Rolle wird verwendet.

Wenn Sie die Arbeitsbereiche im selben Konto wie der Scraper wechseln und den weiterhin verwenden möchten `RoleConfiguration`, müssen Sie erneut Folgendes angeben `RoleConfiguration` auf `UpdateScraper`.

## Suchen und Löschen von Scrapern
<a name="prom-msk-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
```

`ListScrapers` gibt alle Scraper in Ihrem Konto zurück, zum Beispiel:

```JSON
{
    "scrapers": [
        {
            "scraperId": "s-1234abcd-56ef-7890-abcd-1234ef567890",
            "arn": "arn:aws:aps:{{aws-region}}:123456789012:scraper/s-1234abcd-56ef-7890-abcd-1234ef567890",
            "roleArn": "arn:aws:iam::123456789012:role/aws-service-role/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-2931",
            "status": {
                "statusCode": "DELETING"
            },
            "createdAt": "2023-10-12T15:22:19.014000-07:00",
            "lastModifiedAt": "2023-10-12T15:55:43.487000-07:00",
            "tags": {},
            "source": {
                "vpcConfiguration": {
                   "securityGroupIds": [
                        "sg-1234abcd5678ef90"
                    ],
                    "subnetIds": [
                        "subnet-abcd1234ef567890", 
                        "subnet-1234abcd5678ab90"
                    ]
                }
            },
            "destination": {
                "ampConfiguration": {
                    "workspaceArn": "arn:aws:aps:{{aws-region}}:123456789012:workspace/ws-1234abcd-5678-ef90-ab12-cdef3456a78"
                }
            }
        }
    ]
}
```

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 MSK gesammelte Metriken
<a name="prom-msk-metrics"></a>

Bei der Integration mit Amazon MSK entfernt der Amazon Managed Service for Prometheus Collector automatisch die folgenden Metriken:

### Metriken: jmx\_exporter- und pod\_exporter-Jobs
<a name="broker-metrics"></a>


| Metrik | Beschreibung//Zweck | 
| --- | --- | 
| jmx\_config\_reload\_failure\_total | Gesamtzahl der Male, mit denen der JMX-Exporter seine Konfigurationsdatei nicht neu laden konnte. | 
| jmx\_scrape\_duration\_seconds | Zeit, die zum Scrapen von JMX-Metriken in Sekunden für den aktuellen Erfassungszyklus benötigt wurde. | 
| jmx\_scrape\_error | Gibt an, ob beim JMX-Metrik-Scraping ein Fehler aufgetreten ist (1 = Fehler, 0 = Erfolg). | 
| java\_lang\_Memory\_HeapMemoryUsage\_used | Menge des Heap-Speichers (in Byte), der derzeit von der JVM verwendet wird. | 
| java\_lang\_Memory\_HeapMemoryUsage\_max | Maximale Menge an Heap-Speicher (in Byte), die für die Speicherverwaltung verwendet werden kann. | 
| java\_lang\_Memory\_NonHeapMemoryUsage\_used | Menge des Nicht-Heap-Speichers (in Byte), der derzeit von der JVM verwendet wird. | 
| kafka\_cluster\_Partition\_Value | Aktueller Status oder Wert in Bezug auf Kafka-Cluster-Partitionen, aufgeschlüsselt nach Partitions-ID und Thema. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_assigned\_partitions | Anzahl der Partitionen, die diesem Consumer derzeit zugewiesen sind. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_latency\_avg | Durchschnittliche Zeit in Millisekunden, die für die Berechnung von Offsets benötigt wird. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_rate | Anzahl der Offset-Commits pro Sekunde. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_failed\_rebalance\_total | Gesamtzahl der fehlgeschlagenen Neugewichte bei Verbrauchergruppen. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_last\_heartbeat\_seconds\_ago | Anzahl der Sekunden, seit der letzte Herzschlag an den Koordinator gesendet wurde. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_latency\_avg | Durchschnittliche Zeit, die für die Neugewichtung von Verbrauchergruppen benötigt wird, in Millisekunden. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_total | Gesamtzahl der Neugewichte der Verbrauchergruppen. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_bytes\_consumed\_rate | Durchschnittliche Anzahl der vom Verbraucher pro Sekunde verbrauchten Byte. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_latency\_avg | Durchschnittliche Zeit, die für eine Abrufanforderung in Millisekunden benötigt wird. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_rate | Anzahl der Abrufanforderungen pro Sekunde. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_consumed\_rate | Durchschnittliche Anzahl der pro Sekunde verbrauchten Datensätze. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_lag\_max | Maximale Verzögerung in Bezug auf die Anzahl der Datensätze für jede Partition in diesem Consumer. | 
| kafka\_consumer\_consumer\_metrics\_connection\_count | Aktuelle Anzahl aktiver Verbindungen. | 
| kafka\_consumer\_consumer\_metrics\_incoming\_byte\_rate | Durchschnittliche Anzahl an Bytes, die pro Sekunde von allen Servern empfangen wurden. | 
| kafka\_consumer\_consumer\_metrics\_last\_poll\_seconds\_ago | Anzahl der Sekunden seit dem letzten Consumer-Aufruf von poll (). | 
| kafka\_consumer\_consumer\_metrics\_request\_rate | Anzahl der pro Sekunde gesendeten Anfragen. | 
| kafka\_consumer\_consumer\_metrics\_response\_rate | Anzahl der pro Sekunde empfangenen Antworten. | 
| kafka\_consumer\_group\_ConsumerLagMetrics\_Wert | Aktueller Verbraucherverzögerungswert für eine Verbrauchergruppe, der angibt, wie weit der Verbraucher hinterherhinkt. | 
| kafka\_controller\_KafkaController\_Wert | Aktueller Status oder Wert des Kafka-Controllers (1 = aktiver Controller, 0 = nicht aktiv). | 
| kafka\_controller\_ControllerEventManager\_Zählen | Gesamtzahl der verarbeiteten Controller-Ereignisse. | 
| kafka\_controller\_ControllerEventManager\_Gemein | Mittlere (durchschnittliche) Zeit, die für die Verarbeitung von Controller-Ereignissen benötigt wird. | 
| kafka\_controller\_ControllerStats\_MeanRate | Mittlere Rate der Controller-Statistikoperationen pro Sekunde. | 
| kafka\_koordinator\_gruppe\_GroupMetadataManager\_Wert | Aktueller Status oder Wert des Gruppen-Metadaten-Managers für Verbrauchergruppen. | 
| kafka\_log\_LogFlushStats\_Zählen | Gesamtzahl der Log-Flush-Operationen. | 
| kafka\_log\_LogFlushStats\_Gemein | Mittlere (durchschnittliche) Zeit, die für Log-Flush-Operationen benötigt wurde. | 
| kafka\_log\_LogFlushStats\_MeanRate | Mittlere Rate von Log-Flush-Vorgängen pro Sekunde. | 
| kafka\_network\_RequestMetrics\_Zählen | Gesamtzahl der verarbeiteten Netzwerkanfragen. | 
| kafka\_network\_RequestMetrics\_Gemein | Mittlere (durchschnittliche) Zeit, die für die Bearbeitung von Netzwerkanfragen benötigt wurde. | 
| kafka\_network\_RequestMetrics\_MeanRate | Mittlere Rate von Netzwerkanfragen pro Sekunde. | 
| kafka\_network\_Acceptor\_MeanRate | Durchschnittliche Rate akzeptierter Verbindungen pro Sekunde. | 
| kafka\_server\_Fetch\_queue\_size | Aktuelle Größe der Warteschlange für Abrufanfragen. | 
| kafka\_server\_Produce\_queue\_size | Aktuelle Größe der Warteschlange für Produktionsanfragen. | 
| kafka\_server\_Request\_queue\_size | Aktuelle Größe der allgemeinen Anforderungswarteschlange. | 
| kafka\_server\_BrokerTopicMetrics\_Zählen | Gesamtzahl der Broker-Themenoperationen (Nachrichten) in/out, Byte in/out). | 
| kafka\_server\_BrokerTopicMetrics\_MeanRate | Durchschnittliche Rate der Transaktionen pro Sekunde bei Broker-Themen. | 
| kafka\_server\_BrokerTopicMetrics\_OneMinuteRate | One-minute gleitender Durchschnittskurs der Geschäfte im Zusammenhang mit Brokern. | 
| kafka\_server\_DelayedOperationPurgatory\_Wert | Aktuelle Anzahl verspäteter Operationen im Fegefeuer (die darauf warten, abgeschlossen zu werden). | 
| kafka\_server\_DelayedFetchMetrics\_MeanRate | Mittlere Rate verzögerter Abrufvorgänge pro Sekunde. | 
| kafka\_server\_FetcherLagMetrics\_Wert | Aktueller Lag-Wert für Replica-Fetcher-Threads (wie weit hinter dem Leader). | 
| kafka\_server\_FetcherStats\_MeanRate | Mittlere Rate der Abruf-Operationen pro Sekunde. | 
| kafka\_server\_ReplicaManager\_Wert | Aktueller Status oder Wert des Replikatmanagers. | 
| kafka\_server\_ReplicaManager\_MeanRate | Durchschnittliche Rate der Replica-Manager-Operationen pro Sekunde. | 
| kafka\_server\_LeaderReplication\_Byte\_Rate | Rate der pro Sekunde replizierten Byte für Partitionen, bei denen dieser Broker führend ist. | 
| kafka\_server\_group\_coordinator\_metrics\_group\_completed\_rebalance\_count | Gesamtzahl der abgeschlossenen Neugewichte bei Verbrauchergruppen. | 
| kafka\_server\_group\_coordinator\_metrics\_offset\_commit\_count | Gesamtzahl der Offset-Commit-Operationen. | 
| kafka\_server\_group\_coordinator\_metrics\_offset\_commit\_rate | Rate der Offset-Commit-Operationen pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_connection\_count | Aktuelle Anzahl der aktiven Verbindungen. | 
| kafka\_server\_socket\_server\_metrics\_connection\_creation\_rate | Geschwindigkeit, mit der neue Verbindungen pro Sekunde hergestellt werden. | 
| kafka\_server\_socket\_server\_metrics\_connection\_close\_rate | Rate der Verbindungsschließungen pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_failed\_authentication\_total | Gesamtzahl der fehlgeschlagenen Authentifizierungsversuche. | 
| kafka\_server\_socket\_server\_metrics\_incoming\_byte\_rate | Rate der eingehenden Byte pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_outgoing\_byte\_rate | Rate der ausgehenden Byte pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_request\_rate | Rate der Anfragen pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_response\_rate | Rate der Antworten pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_network\_io\_rate | Rate des Netzwerks I/O Operationen pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_io\_ratio | Bruchteil der Zeit, die in verbracht wurde I/O Operationen. | 
| kafka\_server\_controller\_channel\_metrics\_connection\_count | Aktuelle Anzahl aktiver Verbindungen für Controller-Kanäle. | 
| kafka\_server\_controller\_channel\_metrics\_incoming\_byte\_rate | Rate der eingehenden Byte pro Sekunde für Controller-Kanäle. | 
| kafka\_server\_controller\_channel\_metrics\_outgoing\_byte\_rate | Rate der ausgehenden Byte pro Sekunde für Controller-Kanäle. | 
| kafka\_server\_controller\_channel\_metrics\_request\_rate | Rate der Anfragen pro Sekunde für Controller-Kanäle. | 
| kafka\_server\_replica\_fetcher\_metrics\_connection\_count | Aktuelle Anzahl aktiver Verbindungen für Replica Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_incoming\_byte\_rate | Rate der eingehenden Byte pro Sekunde für den Replikatabruf. | 
| kafka\_server\_replica\_fetcher\_metrics\_request\_rate | Rate der Anfragen pro Sekunde für den Replikatabruf. | 
| kafka\_server\_replica\_fetcher\_metrics\_failed\_authentication\_total | Gesamtzahl der fehlgeschlagenen Authentifizierungsversuche für den Replikatabruf. | 
| kafka\_server\_ZooKeeperClientMetrics\_Zählen | Gesamtzahl von ZooKeeper Client-Operationen. | 
| kafka\_server\_ZooKeeperClientMetrics\_Gemein | Mittlere Latenz von ZooKeeper Client-Operationen. | 
| kafka\_server\_KafkaServer\_Wert | Aktueller Status oder Wert des Kafka-Servers (zeigt in der Regel an, dass der Server läuft). | 
| node\_cpu\_seconds\_total | Gesamtzahl der Sekunden, die die CPUs in jedem Modus (Benutzer, System, Leerlauf usw.) verbracht haben, aufgeschlüsselt nach CPU und Modus. | 
| node\_disk\_read\_bytes\_total | Gesamtzahl der erfolgreich von Festplatten gelesenen Byte, aufgeschlüsselt nach Geräten. | 
| node\_disk\_reads\_completed\_total | Gesamtzahl der erfolgreich abgeschlossenen Lesevorgänge für Festplatten, aufgeschlüsselt nach Geräten. | 
| node\_disk\_writes\_completed\_total | Gesamtzahl der erfolgreich abgeschlossenen Schreibvorgänge für Festplatten, aufgeschlüsselt nach Geräten. | 
| node\_disk\_written\_bytes\_total | Gesamtzahl der erfolgreich auf Festplatten geschriebenen Byte, aufgeschlüsselt nach Geräten. | 
| node\_filesystem\_avail\_bytes | Verfügbarer Speicherplatz im Dateisystem in Byte für Nicht-Root-Benutzer, aufgeschlüsselt nach Gerät und Einhängepunkt. | 
| node\_filesystem\_size\_bytes | Gesamtgröße des Dateisystems in Byte, aufgeschlüsselt nach Gerät und Einhängepunkt. | 
| node\_filesystem\_free\_bytes | Freier Speicherplatz im Dateisystem in Byte, aufgeschlüsselt nach Gerät und Einhängepunkt. | 
| node\_filesystem\_files | Gesamtzahl der Dateiknoten (Inodes) im Dateisystem, aufgeschlüsselt nach Gerät und Einhängepunkt. | 
| node\_filesystem\_files\_free | Anzahl der freien Dateiknoten (Inodes) im Dateisystem, aufgeschlüsselt nach Gerät und Einhängepunkt. | 
| node\_filesystem\_readonly | Gibt an, ob das Dateisystem schreibgeschützt eingehängt ist (1 = schreibgeschützt, 0 = lesen/schreiben). | 
| node\_filesystem\_device\_error | Gibt an, ob beim Abrufen der Dateisystemstatistiken ein Fehler aufgetreten ist (1 = Fehler, 0 = Erfolg). | 

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

Die aktuelle Amazon MSK-Integration mit Amazon Managed Service für Prometheus hat die folgenden Einschränkungen:
+ Wird nur für von Amazon MSK bereitgestellte Cluster unterstützt (nicht verfügbar für Amazon MSK Serverless)
+ Nicht unterstützt für Amazon MSK-Cluster mit aktiviertem öffentlichen Zugriff in Kombination mit dem Kraft-Metadatenmodus
+ Unterstützt derzeit eine 1:1 -Zuordnung zwischen Amazon MSK-Clustern und Amazon Managed Service for Prometheus collectors/workspaces