

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.

# Verwaltete Prometheus-Collectors für Amazon MSK einrichten
<a name="prom-msk-integration"></a>

Um einen Amazon Managed Service for Prometheus Collector zu verwenden, erstellen Sie einen Scraper, der Metriken in Ihrem Amazon Managed Streaming for Apache Kafka Kafka-Cluster erkennt und abruft. Sie können auch einen Scraper erstellen, der in Amazon Elastic Kubernetes Service integriert ist. Weitere Informationen finden Sie unter [Integrieren von Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html).

## 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 entweder mithilfe der AWS API oder AWS CLI wie in den folgenden Verfahren beschrieben erstellen.

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 **11001 (JMX Exporter) und **11002 (Node Exporter)**** innerhalb Ihrer Amazon VPC zugelassen wird, da der Scraper Zugriff auf diese DNS-Einträge benötigt, um Prometheus-Metriken zu sammeln.
+ [In der Amazon VPC, in der sich der Amazon MSK-Cluster befindet, muss DNS aktiviert sein.](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html)

**Anmerkung**  
Der Cluster wird dem Scraper über seinen Amazon-Ressourcennamen (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. Sie [löschen Scraper](#prom-msk-delete-scraper) getrennt vom Löschen des Clusters.

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

Verwenden Sie den `CreateScraper` API-Vorgang, um einen Scraper mit der AWS API zu erstellen. Im folgenden Beispiel wird ein Scraper in der Region USA Ost (Nord-Virginia) erstellt. Ersetzen Sie den {{example}} Inhalt durch Ihre Amazon MSK-Clusterinformationen 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 Availability Zones ein.

```
                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 diesem Beispiel erfordert der `scrapeConfiguration` Parameter eine Base64-kodierte Prometheus-Konfigurations-YAML-Datei, die die DNS-Einträge des MSK-Clusters spezifiziert.

Jeder DNS-Eintrag steht für einen Broker-Endpunkt in einer bestimmten Availability Zone, sodass Clients Verbindungen zu Brokern herstellen können, die auf die von Ihnen ausgewählten Standorte verteilt sind, um eine hohe Verfügbarkeit zu gewährleisten. AZs 

Die Anzahl der DNS-Einträge in Ihren MSK-Clustereigenschaften entspricht der Anzahl der Broker-Knoten und Availability Zones in Ihrer Clusterkonfiguration:
+ **Standardkonfiguration** — 3 Broker-Knoten mit 3 AZs = 3 DNS-Einträgen
+ **Benutzerdefinierte Konfiguration** — 2 Broker-Knoten mit 2 AZs = 2 DNS-Einträgen

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

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

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

   **Individuelle Broker-Endpunkte** — Geben Sie jeden Broker-Endpunkt einzeln an, um eine detaillierte Steuerung zu gewährleisten. Verwenden Sie die vollständigen Broker-IDs (b-1, b-2) in Ihrer Konfiguration. Beispiel:

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

**Anmerkung**  
`clusterName.xxx.xxx.xxx`Ersetzen Sie in der Konsole durch Ihren tatsächlichen MSK-Cluster-Endpunkt. AWS 

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

Im Folgenden finden Sie ein Beispiel für die Scraper-Konfigurationsdatei:

```
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 die Datei auch mit einem beliebigen Online-Base64-Konverter konvertieren.

**Example Linux/macOS**  

```
echo -n {{scraper config updated with dns records}} | base64 
```

**Example Windows PowerShell**  

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

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

Verwenden Sie den `create-scraper` Befehl, um einen Scraper mit dem AWS Command Line Interface zu erstellen. Im folgenden Beispiel wird ein Scraper in der Region USA Ost (Nord-Virginia) erstellt. Ersetzen Sie den {{example}} Inhalt durch Ihre Amazon MSK-Clusterinformationen 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 Availability Zones 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 der AWS API verwenden können:

  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 der [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html)API-Operation.
+ 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.

## Kontoübergreifende Einrichtung
<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, aus dem Sie Metriken sammeln möchten, in einem anderen Konto befindet als der Amazon Managed Service for Prometheus-Collector.

Wenn Sie beispielsweise zwei Konten haben, das erste Quellkonto, auf `account_id_source` dem sich das Amazon MSK befindet, und ein zweites Zielkonto, in `account_id_target` dem sich der Amazon Managed Service for Prometheus Workspace befindet.

**Um einen Scraper in einer kontoübergreifenden Konfiguration zu erstellen**

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

   ```
   {
       "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 die folgende Vertrauensrichtlinie mit Berechtigungen für hinzufügen. [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html)

   ```
   {
     "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 Scraper mit der Option. `--role-configuration`

   ```
   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.

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

## Wechsel zwischen einer RoleConfiguration serviceverknüpften Rolle
<a name="prom-msk-changing-roles"></a>

Wenn Sie zurück zu einer serviceverknüpften Rolle wechseln möchten, anstatt in einen Amazon Managed Service for Prometheus Workspace `RoleConfiguration` zu schreiben, müssen Sie den aktualisieren `UpdateScraper` und einen Workspace im selben Konto wie der Scraper ohne die bereitstellen. `RoleConfiguration` Der `RoleConfiguration` wird aus dem Scraper entfernt und die Rolle, die mit dem Service verknüpft ist, wird verwendet.

Wenn Sie die Arbeitsbereiche in demselben Konto wie der Scraper ändern und den weiterhin verwenden möchten`RoleConfiguration`, müssen Sie erneut die Option On angeben. `RoleConfiguration` `UpdateScraper`

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

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

**Anmerkung**  
Stellen Sie sicher, dass Sie die neueste Version des AWS CLI oder SDK verwenden. Die neueste Version bietet Ihnen die neuesten Features und Funktionen sowie Sicherheitsupdates. Alternativ können Sie [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), was immer eine up-to-date Befehlszeilenerfahrung bietet, automatisch verwenden.

Die [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html)-API-Operation listet alle Scraper in Ihrem Konto auf.

Rufen Sie alternativ mit dem AWS CLI folgenden Befehl auf:

```
aws amp list-scrapers
```

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

```
{
    "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 rufen Sie mit AWS CLI dem auf:

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

## Von Amazon MSK gesammelte Metriken
<a name="prom-msk-metrics"></a>

Bei der Integration mit Amazon MSK erfasst 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 Fehler, mit denen der JMX-Exporter seine Konfigurationsdatei neu laden konnte. | 
| jmx\_scrape\_duration\_seconds | Zeitaufwand für das Scraping von JMX-Metriken in Sekunden für den aktuellen Erfassungszyklus. | 
| jmx\_scrape\_error | Gibt an, ob beim Scraping von JMX-Metriken ein Fehler aufgetreten ist (1 = Fehler, 0 = Erfolg). | 
| HeapMemoryUsageJava\_lang\_Memory\_ \_used | Menge des aktuell von der JVM verwendeten Heap-Speichers (in Byte). | 
| java\_lang\_Memory\_ \_max HeapMemoryUsage | Maximale Menge an Heap-Speicher (in Byte), die für die Speicherverwaltung verwendet werden kann. | 
| Java\_lang\_Memory\_ \_verwendet NonHeapMemoryUsage | Menge des Non-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 Verbraucher derzeit zugewiesen sind. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_latency\_avg | Durchschnittliche Zeit in Millisekunden für die Übertragung von Offsets. | 
| 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 Heartbeat 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 bei 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 Dauer einer Abrufanforderung in Millisekunden. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_rate | Anzahl der Abrufanforderungen pro Sekunde. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_consumed\_rate | Durchschnittliche Anzahl verbrauchter Datensätze pro Sekunde. | 
| 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\_metrics\_incoming\_byte\_rate | Durchschnittliche Anzahl der pro Sekunde von allen Servern empfangenen Byte. | 
| kafka\_consumer\_consumer\_metrics\_last\_poll\_seconds\_ago | Anzahl der Sekunden seit dem letzten Aufruf von consumer poll (). | 
| kafka\_consumer\_consumer\_metrics\_request\_rate | Anzahl der pro Sekunde gesendeten Anfragen. | 
| kafka\_consumer\_consumer\_metrics\_response\_rate | Anzahl der pro Sekunde eingegangenen Antworten. | 
| kafka\_consumer\_group\_ \_Value ConsumerLagMetrics | Aktueller Wert für eine Verbrauchergruppe, der angibt, wie weit der Verbraucher hinterherhinkt. | 
| KafkaControllerkafka\_controller\_ \_Value | Aktueller Status oder Wert des Kafka-Controllers (1 = aktiver Controller, 0 = nicht aktiv). | 
| ControllerEventManagerkafka\_controller\_ \_Count | Gesamtzahl der verarbeiteten Controller-Ereignisse. | 
| ControllerEventManagerkafka\_controller\_ \_Mean | Durchschnittliche (durchschnittliche) Zeit, die zur Verarbeitung von Controller-Ereignissen benötigt wird. | 
| ControllerStatskafka\_controller\_ \_ MeanRate | Durchschnittliche Rate der Controller-Statistikoperationen pro Sekunde. | 
| kafka\_coordinator\_group\_ \_Value GroupMetadataManager | Aktueller Status oder Wert des Gruppenmetadaten-Managers für Nutzergruppen. | 
| kafka\_log\_ \_Anzahl LogFlushStats | Gesamtzahl der Log-Flush-Operationen. | 
| kafka\_log\_ LogFlushStats \_Mean | Durchschnittliche (durchschnittliche) Zeit, die für Log-Flush-Operationen benötigt wird. | 
| kafka\_log\_ \_ LogFlushStats MeanRate | Durchschnittliche Rate der Log-Flush-Operationen pro Sekunde. | 
| kafka\_network\_ \_Anzahl RequestMetrics | Gesamtzahl der verarbeiteten Netzwerkanfragen. | 
| kafka\_network\_ RequestMetrics \_Mean | Durchschnittliche (durchschnittliche) Zeit für die Bearbeitung von Netzwerkanfragen. | 
| kafka\_network\_ \_ RequestMetrics MeanRate | Durchschnittliche Rate von Netzwerkanfragen pro Sekunde. | 
| Kafka\_Network\_Acceptor\_ MeanRate | Durchschnittliche Rate der akzeptierten Verbindungen pro Sekunde. | 
| KAFKA\_Server\_Fetch\_Queue\_Size | Aktuelle Größe der Warteschlange für Abrufanforderungen. | 
| 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\_ \_Anzahl BrokerTopicMetrics | Gesamtzahl der Broker-Thema-Operationen (Nachrichten). in/out, bytes in/out | 
| kafka\_server\_ \_ BrokerTopicMetrics MeanRate | Durchschnittliche Rate der Broker-Thema-Operationen pro Sekunde. | 
| kafka\_server\_ \_ BrokerTopicMetrics OneMinuteRate | Gleitender Durchschnittskurs der Transaktionen im Broker-Thema von einer Minute. | 
| kafka\_server\_ \_Wert DelayedOperationPurgatory | Aktuelle Anzahl verzögerter Operationen im Fegefeuer (die darauf warten, abgeschlossen zu werden). | 
| kafka\_server\_ \_ DelayedFetchMetrics MeanRate | Durchschnittliche Rate verzögerter Abrufvorgänge pro Sekunde. | 
| kafka\_server\_ \_Wert FetcherLagMetrics | Aktueller Verzögerungswert für Replikat-Fetcher-Threads (wie weit hinter dem Leader zurückgeblieben). | 
| kafka\_server\_ \_ FetcherStats MeanRate | Durchschnittliche Rate von Abruf-Vorgängen pro Sekunde. | 
| kafka\_server\_ \_Wert ReplicaManager | Aktueller Status oder Wert des Replikat-Managers. | 
| kafka\_server\_ \_ ReplicaManager MeanRate | Durchschnittliche Rate von Replica Manager-Vorgängen pro Sekunde. | 
| kafka\_server\_ \_byte\_rate LeaderReplication | 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 aktiver Verbindungen. | 
| kafka\_server\_socket\_server\_metrics\_connection\_creation\_rate | Rate der Erstellung neuer Verbindungen pro Sekunde. | 
| kafka\_server\_socket\_server\_metrics\_connection\_close\_rate | Rate der Verbindungsabbrüche 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 der Netzwerkoperationen pro Sekunde. I/O  | 
| kafka\_server\_socket\_server\_metrics\_io\_ratio | Bruchteil der für Operationen aufgewendeten Zeit. I/O  | 
| 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 Controllerkanäle. | 
| kafka\_server\_controller\_channel\_metrics\_outgoing\_byte\_rate | Rate der ausgehenden Byte pro Sekunde für Controllerkanäle. | 
| kafka\_server\_controller\_channel\_metrics\_request\_rate | Rate der Anfragen pro Sekunde für Controllerkanäle. | 
| kafka\_server\_replica\_fetcher\_metrics\_connection\_count | Aktuelle Anzahl aktiver Verbindungen für den Replica Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_incoming\_byte\_rate | Rate der eingehenden Byte pro Sekunde für den Replikat-Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_request\_rate | Rate der Anfragen pro Sekunde für den Replica Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_failed\_authentication\_total | Gesamtzahl der fehlgeschlagenen Authentifizierungsversuche für den Replica Fetcher. | 
| kafka\_server\_ \_Anzahl ZooKeeperClientMetrics | Gesamtzahl der Client-Operationen. ZooKeeper  | 
| kafka\_server\_ ZooKeeperClientMetrics \_Mean | Mittlere Latenz der Client-Operationen. ZooKeeper  | 
| kafka\_server\_ \_Wert KafkaServer | Aktueller Status oder Wert des Kafka-Servers (zeigt normalerweise an, dass der Server läuft). | 
| node\_cpu\_seconds\_total | Gesamtzahl der in jedem Modus (Benutzer, System, Leerlauf usw.) CPUs verbrachten Sekunden, 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 Dateisystemspeicher in Byte für Benutzer ohne Root-Rechte, 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 = lesend und schreibgeschützt). | 
| node\_filesystem\_device\_error | Zeigt 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 for 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
+ Wird für Amazon MSK Express-Broker nicht unterstützt
+ Unterstützt derzeit eine 1:1 -Zuordnung zwischen Amazon MSK-Clustern und Amazon Managed Service für Prometheus Collectors/Workspaces