

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configurer des collecteurs Prometheus gérés pour Amazon MSK
<a name="prom-msk-integration"></a>

Pour utiliser un collecteur Amazon Managed Service for Prometheus, vous devez créer un scraper qui découvre et extrait des métriques dans votre cluster Amazon Managed Streaming for Apache Kafka. Vous pouvez également créer un scraper qui s'intègre à Amazon Elastic Kubernetes Service. Pour plus d'informations, consultez [Intégrer Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html).

## Créer un scraper
<a name="prom-msk-create-scraper"></a>

Un collecteur Amazon Managed Service for Prometheus consiste en un scraper qui découvre et collecte les métriques d'un cluster Amazon MSK. Amazon Managed Service for Prometheus gère le scraper pour vous, vous offrant ainsi l’évolutivité, la sécurité et la fiabilité dont vous avez besoin, sans avoir à gérer vous-même les instances, les agents ou les scrapers.

Vous pouvez créer un scraper à l'aide de l' AWS API ou de la AWS CLI manière décrite dans les procédures suivantes.

Il existe quelques prérequis pour créer votre propre scraper :
+ Vous devez avoir créé un cluster Amazon MSK.
+ Configurez le groupe de sécurité de votre cluster Amazon MSK pour autoriser le trafic entrant sur les ports **11001 (JMX Exporter) et **11002 (Node Exporter****) au sein de votre Amazon VPC, car le scraper doit accéder à ces enregistrements DNS pour collecter les métriques Prometheus.
+ [Le DNS doit être activé sur le Amazon VPC dans lequel réside le cluster Amazon MSK.](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html)

**Note**  
Le cluster sera associé au scraper par son nom de ressource Amazon (ARN). Si vous supprimez un cluster, puis que vous en créez un nouveau portant le même nom, l'ARN sera réutilisé pour le nouveau cluster. Pour cette raison, le scraper tentera de collecter des métriques pour le nouveau cluster. Vous [supprimez les scrapers](#prom-msk-delete-scraper) séparément de la suppression du cluster.

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

Utilisez l'opération `CreateScraper` API pour créer un scraper avec l' AWS API. L'exemple suivant crée un grattoir dans la région de l'est des États-Unis (Virginie du Nord). Remplacez le *example* contenu par les informations de votre cluster Amazon MSK et fournissez la configuration de votre scraper.

**Note**  
Configurez le groupe de sécurité et les sous-réseaux en fonction de votre cluster cible. Incluez au moins deux sous-réseaux répartis dans deux zones de disponibilité.

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

Dans l'exemple, le `scrapeConfiguration` paramètre nécessite un fichier YAML de configuration Prometheus codé en base64 qui spécifie les enregistrements DNS du cluster MSK.

Chaque enregistrement DNS représente un point de terminaison de courtier dans une zone de disponibilité spécifique, permettant aux clients de se connecter à des courtiers répartis sur l'ensemble de votre choix AZs pour une haute disponibilité.

Le nombre d'enregistrements DNS dans les propriétés de votre cluster MSK correspond au nombre de nœuds courtiers et de zones de disponibilité dans la configuration de votre cluster :
+ **Configuration par défaut** : 3 nœuds de courtage répartis sur 3 AZs = 3 enregistrements DNS
+ **Configuration personnalisée** : 2 nœuds de courtage répartis sur 2 AZs = 2 enregistrements DNS

[Pour obtenir les enregistrements DNS de votre cluster MSK, ouvrez-vous la console MSK à https://console.aws.amazon.com/msk/ la maison ? region=us-east-1\$1/home/](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/). Accédez à votre cluster MSK. Choisissez **Properties**, **Brokers** et **Endpoints.**

Vous avez deux options pour configurer Prometheus afin de récupérer les métriques de votre cluster MSK :

1. **Résolution DNS au niveau du cluster (recommandée)** : utilisez le nom DNS de base du cluster pour découvrir automatiquement tous les courtiers. Si le point de terminaison de votre courtier l'est`b-1.clusterName.xxx.xxx.xxx`, utilisez-le `clusterName.xxx.xxx.xxx` comme enregistrement DNS. Cela permet à Prometheus de supprimer automatiquement tous les courtiers du cluster.

   **Points de terminaison individuels du courtier** : spécifiez chaque point de terminaison du courtier individuellement pour un contrôle granulaire. Utilisez les identifiants complets du courtier (b-1, b-2) dans votre configuration. Par exemple :

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

**Note**  
`clusterName.xxx.xxx.xxx`Remplacez-le par le point de terminaison de votre cluster MSK réel depuis la AWS console.

Pour plus d'informations, consultez[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config) <dns\$1sd\$1config>la documentation de *Prometheus*.

Voici un exemple de fichier de configuration du scraper :

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

Exécutez l'une des commandes suivantes pour convertir le fichier YAML en base64. Vous pouvez également utiliser n'importe quel convertisseur base64 en ligne pour convertir le fichier.

**Example Linux/macOS**  

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

**Example Fenêtres PowerShell**  

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

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

Utilisez la `create-scraper` commande pour créer un grattoir à l'aide du AWS Command Line Interface. L'exemple suivant crée un grattoir dans la région de l'est des États-Unis (Virginie du Nord). Remplacez le *example* contenu par les informations de votre cluster Amazon MSK et fournissez la configuration de votre scraper.

**Note**  
Configurez le groupe de sécurité et les sous-réseaux en fonction de votre cluster cible. Incluez au moins deux sous-réseaux répartis dans deux zones de disponibilité.

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

------
+ Voici une liste complète des opérations de scraper que vous pouvez utiliser avec l' AWS API :

  Créez un scraper avec l’opération d’API [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html).
+ Répertoriez vos scrapers existants avec l’opération d’API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html).
+ Mettez à jour l'alias, la configuration ou la destination d'un scraper avec l'opération [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html)API.
+ Supprimez un scraper avec l’opération d’API [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html).
+ Obtenez plus de détails sur un scraper avec l’opération d’API [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html).

## Configuration multi-comptes
<a name="prom-msk-cross-account"></a>

Pour créer un scraper dans une configuration multi-comptes lorsque le cluster Amazon MSK à partir duquel vous souhaitez collecter des métriques se trouve sur un compte différent de celui du collecteur Amazon Managed Service for Prometheus, suivez la procédure ci-dessous.

Par exemple, lorsque vous avez deux comptes, le premier compte source sur `account_id_source` lequel se trouve l'Amazon MSK et un deuxième compte cible sur `account_id_target` lequel réside l'espace de travail Amazon Managed Service for Prometheus.

**Pour créer un scraper dans une configuration multi-comptes**

1. Dans le compte source, créez un rôle `arn:aws:iam::111122223333:role/Source` et ajoutez la politique de confiance suivante.

   ```
   {
       "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. Pour chaque combinaison de source (cluster Amazon MSK) et de cible (espace de travail Amazon Managed Service for Prometheus), vous devez créer un `arn:aws:iam::444455556666:role/Target` rôle et ajouter la politique de confiance suivante avec des autorisations pour. [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. Créez un grattoir avec l'`--role-configuration`option.

   ```
   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. Validez la création du grattoir.

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

## Changement entre un rôle lié à un service RoleConfiguration et un rôle lié à un service
<a name="prom-msk-changing-roles"></a>

Lorsque vous souhaitez revenir à un rôle lié à un service au lieu d'écrire dans un espace de travail Amazon Managed Service for Prometheus, vous devez mettre à jour le `UpdateScraper` et fournir un espace de travail sur le même compte que le scraper sans le. `RoleConfiguration` `RoleConfiguration` Le `RoleConfiguration` sera supprimé du scraper et le rôle lié au service sera utilisé.

Lorsque vous changez d'espace de travail dans le même compte que le scraper et que vous souhaitez continuer à utiliser le`RoleConfiguration`, vous devez à nouveau activer le`RoleConfiguration`. `UpdateScraper`

## Recherche et suppression des scrapers
<a name="prom-msk-delete-scraper"></a>

Vous pouvez utiliser l' AWS API ou le AWS CLI pour répertorier les scrapers de votre compte ou pour les supprimer.

**Note**  
Assurez-vous que vous utilisez la dernière version du AWS CLI SDK. La dernière version vous fournit les fonctionnalités les plus récentes, ainsi que des mises à jour de sécurité. Vous pouvez également utiliser [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), qui fournit une expérience de ligne de up-to-date commande permanente, automatiquement.

Pour afficher tous les scrapers de votre compte, utilisez l’opératon d’API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html).

Sinon, avec le AWS CLI, appelez :

```
aws amp list-scrapers
```

`ListScrapers` renvoie tous les scrapers de votre compte. Par exemple :

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

Pour supprimer un scraper, recherchez le `scraperId` du scraper que vous souhaitez supprimer à l'aide de l'opération `ListScrapers`, puis utilisez l'opération [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) pour le supprimer.

Sinon, avec le AWS CLI, appelez :

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

## Métriques collectées auprès d'Amazon MSK
<a name="prom-msk-metrics"></a>

Lorsque vous intégrez Amazon MSK, le collecteur Amazon Managed Service for Prometheus supprime automatiquement les statistiques suivantes :

### Métriques : jobs jmx\$1exporter et pod\$1exporter
<a name="broker-metrics"></a>


| Métrique | Description/Objectif | 
| --- | --- | 
|  jmx\$1config\$1reload\$1failure\$1total  |  Nombre total de fois où l'exportateur JMX n'a pas réussi à recharger son fichier de configuration.  | 
|  jmx\$1scrape\$1duration\$1seconds  |  Temps nécessaire pour extraire les métriques JMX en secondes pour le cycle de collecte en cours.  | 
|  erreur jmx\$1scrape  |  Indique si une erreur s'est produite lors du scraping des métriques JMX (1 = erreur, 0 = succès).  | 
|  Java\$1lang\$1memory\$1 \$1utilisé HeapMemoryUsage  |  Quantité de mémoire en tas (en octets) actuellement utilisée par la machine virtuelle Java.  | 
|  Java\$1Lang\$1Memory\$1 \$1max HeapMemoryUsage  |  Quantité maximale de mémoire en tas (en octets) pouvant être utilisée pour la gestion de la mémoire.  | 
|  Java\$1lang\$1memory\$1 \$1utilisé NonHeapMemoryUsage  |  Quantité de mémoire hors segment (en octets) actuellement utilisée par la machine virtuelle Java.  | 
|  Kafka\$1Cluster\$1Partition\$1Value  |  État ou valeur actuel lié aux partitions du cluster Kafka, ventilé par ID de partition et par sujet.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1assigned\$1partitions  |  Nombre de partitions actuellement attribuées à ce consommateur.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1commit\$1latency\$1avg  |  Temps moyen nécessaire pour valider les décalages en millisecondes.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1commit\$1rate  |  Nombre de validations de décalage par seconde.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1failed\$1rebalance\$1total  |  Nombre total de rééquilibres de groupes de consommateurs qui ont échoué.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1last\$1heartbeat\$1seconds\$1ago  |  Nombre de secondes écoulées depuis que le dernier battement de cœur a été envoyé au coordinateur.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1rebalance\$1latency\$1avg  |  Durée moyenne des rééquilibres des groupes de consommateurs en millisecondes.  | 
|  kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1rebalance\$1total  |  Nombre total de rééquilibres de groupes de consommateurs.  | 
|  kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1bytes\$1consumed\$1rate  |  Nombre moyen d'octets consommés par seconde par le consommateur.  | 
|  kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1fetch\$1latency\$1avg  |  Durée moyenne d'une demande de récupération en millisecondes.  | 
|  kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1fetch\$1rate  |  Nombre de demandes de récupération par seconde.  | 
|  kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1records\$1consumed\$1rate  |  Nombre moyen d'enregistrements consommés par seconde.  | 
|  kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1records\$1lag\$1max  |  Décalage maximal en termes de nombre d'enregistrements pour chaque partition de ce consommateur.  | 
|  kafka\$1consumer\$1consumer\$1metrics\$1connection\$1count  |  Nombre actuel de connexions actives.  | 
|  kafka\$1consumer\$1consumer\$1metrics\$1incoming\$1byte\$1rate  |  Nombre moyen d'octets reçus par seconde de tous les serveurs.  | 
|  kafka\$1consumer\$1consumer\$1metrics\$1last\$1poll\$1ago  |  Nombre de secondes écoulées depuis le dernier appel au sondage auprès des consommateurs ().  | 
|  kafka\$1consumer\$1consumer\$1metrics\$1request\$1rate  |  Nombre de demandes envoyées par seconde.  | 
|  kafka\$1consumer\$1consumer\$1metrics\$1response\$1rate  |  Nombre de réponses reçues par seconde.  | 
|  kafka\$1consumer\$1group\$1 \$1Valeur ConsumerLagMetrics  |  Valeur de décalage actuelle du consommateur pour un groupe de consommateurs, indiquant le retard pris par le consommateur.  | 
|  kafka\$1controller\$1 \$1Valeur KafkaController  |  État ou valeur actuel du contrôleur Kafka (1 = contrôleur actif, 0 = non actif).  | 
|  kafka\$1controller\$1 \$1Count ControllerEventManager  |  Nombre total d'événements du contrôleur traités.  | 
|  kafka\$1controller\$1 \$1Mean ControllerEventManager  |  Temps moyen (moyen) nécessaire pour traiter les événements du contrôleur.  | 
|  Kafka\$1controller\$1 \$1 ControllerStats MeanRate  |  Taux moyen d'opérations statistiques du contrôleur par seconde.  | 
|  kafka\$1coordinator\$1group\$1 \$1Valeur GroupMetadataManager  |  État ou valeur actuels du gestionnaire de métadonnées de groupe pour les groupes de consommateurs.  | 
|  kafka\$1log\$1 \$1Count LogFlushStats  |  Nombre total d'opérations de vidange des journaux.  | 
|  kafka\$1log\$1 \$1Mean LogFlushStats  |  Durée moyenne (moyenne) des opérations de vidange des bûches.  | 
|  kafka\$1log\$1 \$1 LogFlushStats MeanRate  |  Fréquence moyenne des opérations de vidange du journal par seconde.  | 
|  kafka\$1network\$1 \$1Count RequestMetrics  |  Nombre total de demandes réseau traitées.  | 
|  kafka\$1network\$1 \$1Mean RequestMetrics  |  Temps moyen (moyen) nécessaire au traitement des demandes réseau.  | 
|  Kafka\$1network\$1 \$1 RequestMetrics MeanRate  |  Taux moyen de requêtes réseau par seconde.  | 
|  Kafka\$1Network\$1Acceptor\$1 MeanRate  |  Taux moyen de connexions acceptées par seconde.  | 
|  Kafka\$1Server\$1Fetch\$1Queue\$1Size  |  Taille actuelle de la file d'attente des demandes de récupération.  | 
|  Kafka\$1Server\$1Produce\$1Queue\$1Size  |  Taille actuelle de la file d'attente des demandes de production.  | 
|  Taille de la file d'attente du serveur Kafka  |  Taille actuelle de la file d'attente générale des demandes.  | 
|  kafka\$1server\$1 \$1Count BrokerTopicMetrics  |  Nombre total d'opérations sur des sujets de courtage (messagesin/out, bytes in/out).  | 
|  Kafka\$1serveur\$1 \$1 BrokerTopicMetrics MeanRate  |  Taux moyen d'opérations sur des sujets de courtage par seconde.  | 
|  Kafka\$1serveur\$1 \$1 BrokerTopicMetrics OneMinuteRate  |  Taux moyen mobile sur une minute des opérations sur le sujet des courtiers.  | 
|  kafka\$1server\$1 \$1Valeur DelayedOperationPurgatory  |  Nombre actuel d'opérations retardées au purgatoire (en attente d'achèvement).  | 
|  Kafka\$1serveur\$1 \$1 DelayedFetchMetrics MeanRate  |  Taux moyen d'opérations d'extraction différées par seconde.  | 
|  kafka\$1server\$1 \$1Valeur FetcherLagMetrics  |  Valeur de décalage actuelle pour les threads de récupération de répliques (quelle est la distance par rapport au leader).  | 
|  Kafka\$1serveur\$1 \$1 FetcherStats MeanRate  |  Taux moyen d'opérations de récupération par seconde.  | 
|  kafka\$1server\$1 \$1Valeur ReplicaManager  |  État ou valeur actuels du gestionnaire de répliques.  | 
|  Kafka\$1serveur\$1 \$1 ReplicaManager MeanRate  |  Taux moyen d'opérations du gestionnaire de répliques par seconde.  | 
|  kafka\$1server\$1 \$1byte\$1rate LeaderReplication  |  Taux d'octets répliqués par seconde pour les partitions où ce broker est le leader.  | 
|  kafka\$1server\$1group\$1coordinator\$1metrics\$1group\$1completed\$1rebalance\$1count  |  Nombre total de rééquilibres de groupes de consommateurs achevés.  | 
|  kafka\$1server\$1group\$1coordinator\$1metrics\$1offset\$1commit\$1count  |  Nombre total d'opérations de validation de compensations.  | 
|  kafka\$1server\$1group\$1coordinator\$1metrics\$1offset\$1commit\$1rate  |  Taux d'opérations de validation de compensation par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1connection\$1count  |  Nombre actuel de connexions actives.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1connection\$1creation\$1rate  |  Taux de création de nouvelles connexions par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1connection\$1close\$1rate  |  Taux de fermetures de connexion par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1failed\$1authentication\$1total  |  Nombre total de tentatives d'authentification infructueuses.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1incoming\$1byte\$1rate  |  Taux d'octets entrants par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1outgoing\$1byte\$1rate  |  Taux d'octets sortants par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1request\$1rate  |  Taux de demandes par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1response\$1rate  |  Taux de réponses par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1network\$1io\$1rate  |  Taux d' I/O opérations réseau par seconde.  | 
|  kafka\$1server\$1socket\$1server\$1metrics\$1io\$1ratio  |  Fraction du temps consacré aux I/O opérations.  | 
|  kafka\$1server\$1controller\$1channel\$1metrics\$1connection\$1count  |  Nombre actuel de connexions actives pour les canaux du contrôleur.  | 
|  kafka\$1server\$1controller\$1channel\$1metrics\$1incoming\$1byte\$1rate  |  Taux d'octets entrants par seconde pour les canaux du contrôleur.  | 
|  kafka\$1server\$1controller\$1channel\$1metrics\$1outgoing\$1byte\$1rate  |  Débit d'octets sortants par seconde pour les canaux du contrôleur.  | 
|  kafka\$1server\$1controller\$1channel\$1metrics\$1request\$1rate  |  Taux de demandes par seconde pour les canaux du contrôleur.  | 
|  kafka\$1server\$1replica\$1fetcher\$1metrics\$1connection\$1count  |  Nombre actuel de connexions actives pour le récupérateur de répliques.  | 
|  kafka\$1server\$1replica\$1fetcher\$1metrics\$1incoming\$1byte\$1rate  |  Taux d'octets entrants par seconde pour le réplica fetcher.  | 
|  kafka\$1server\$1replica\$1fetcher\$1metrics\$1request\$1rate  |  Taux de demandes par seconde pour le récupérateur de répliques.  | 
|  kafka\$1server\$1replica\$1fetcher\$1metrics\$1failed\$1authentication\$1total  |  Nombre total de tentatives d'authentification infructueuses pour Replica Fetcher.  | 
|  kafka\$1server\$1 \$1Count ZooKeeperClientMetrics  |  Nombre total d'opérations menées par les ZooKeeper clients.  | 
|  kafka\$1server\$1 \$1Mean ZooKeeperClientMetrics  |  Latence moyenne des opérations ZooKeeper du client.  | 
|  kafka\$1server\$1 \$1Valeur KafkaServer  |  État ou valeur actuel du serveur Kafka (indique généralement que le serveur est en cours d'exécution).  | 
|  Nœud\$1cpu\$1secondes\$1total  |  Nombre total de secondes CPUs passées dans chaque mode (utilisateur, système, inactif, etc.), ventilé par processeur et par mode.  | 
|  node\$1disk\$1read\$1octets\$1total  |  Nombre total d'octets lus avec succès sur les disques, ventilé par périphérique.  | 
|  node\$1disk\$1reads\$1completed\$1total  |  Nombre total de lectures effectuées avec succès pour les disques, ventilé par périphérique.  | 
|  node\$1disk\$1writes\$1completed\$1total  |  Nombre total d'écritures effectuées avec succès sur les disques, ventilé par périphérique.  | 
|  node\$1disk\$1written\$1octets\$1total  |  Nombre total d'octets écrits avec succès sur les disques, ventilé par périphérique.  | 
|  node\$1filesystem\$1avail\$1bytes  |  Espace disponible dans le système de fichiers en octets pour les utilisateurs non root, ventilé par périphérique et point de montage.  | 
|  taille du système de fichiers node\$1octets  |  Taille totale du système de fichiers en octets, ventilée par périphérique et point de montage.  | 
|  node\$1filesystem\$1free\$1bytes  |  Espace libre du système de fichiers en octets, ventilé par périphérique et point de montage.  | 
|  fichiers\$1système de fichiers node\$1fichiers  |  Nombre total de nœuds de fichiers (inodes) sur le système de fichiers, ventilé par périphérique et point de montage.  | 
|  node\$1filesystem\$1files\$1free  |  Nombre de nœuds de fichiers libres (inodes) sur le système de fichiers, ventilé par périphérique et point de montage.  | 
|  node\$1filesystem\$1readonly  |  Indique si le système de fichiers est monté en lecture seule (1 = lecture seule, 0 = lecture-écriture).  | 
|  node\$1filesystem\$1device\$1error  |  Indique si une erreur s'est produite lors de l'obtention des statistiques du système de fichiers (1 = erreur, 0 = succès).  | 

## Limitations
<a name="prom-msk-limitations"></a>

L'intégration actuelle d'Amazon MSK avec Amazon Managed Service for Prometheus présente les limites suivantes :
+ Pris en charge uniquement pour les clusters provisionnés Amazon MSK (non disponible pour Amazon MSK Serverless)
+ Non pris en charge pour les clusters Amazon MSK dont l'accès public est activé en combinaison avec le mode KRaft métadonnées
+ Non pris en charge pour les courtiers Amazon MSK Express
+ Supporte actuellement un mappage 1:1 entre les clusters Amazon MSK et Amazon Managed Service pour les collecteurs/espaces de travail Prometheus