

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

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 pour Apache Kafka. Vous pouvez également créer un scraper qui s'intègre à Amazon Elastic Kubernetes Service ou à Amazon OpenSearch Service. Pour plus d'informations, voir [Intégrez Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html) et [Intégrez Amazon OpenSearch Service](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-opensearch-integration.html).

Pour obtenir des instructions sur la collecte du décalage par groupe de consommateurs, les compensations validées et l'adhésion à un exportateur Kafka géré, voir [Collectez des statistiques sur les groupes de consommateurs Amazon MSK](prom-msk-kafka-exporter.md). Cette procédure utilise AWS Authentification IAM (Identity and Access Management) et ne nécessite pas de surveillance ouverte. La procédure suivante collecte les métriques JMX et Node Exporter à partir d'Open Monitoring.

## 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 des métriques à partir 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 grattoir à l'aide du AWS API ou AWS CLI comme décrit 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 (Exportateur JMX)** et **11002 (exportateur de nœuds)** dans votre Amazon VPC, car le scraper a besoin d'accéder à ces enregistrements DNS pour collecter des métriques Prometheus.
+ L'Amazon VPC dans lequel se trouve le cluster Amazon MSK doit avoir [DNS activé](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 avec 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 [supprimer les grattoirs](#prom-msk-delete-scraper) séparément de la suppression du cluster.

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

Utilisez le `CreateScraper` Fonctionnement de l'API pour créer un scraper avec AWS API. L'exemple suivant crée un scraper dans la région de l'Est des États-Unis (Virginie du Nord). Remplacez le {{example}} du contenu avec 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 dans deux zones de disponibilité.

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

Dans l'exemple, `scrapeConfiguration` Le 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 les zones de disponibilité de votre choix 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 AZ = 3 enregistrements DNS
+ **Configuration personnalisée** — 2 nœuds de courtage sur 2 AZ = 2 enregistrements DNS

Pour obtenir les enregistrements DNS de votre cluster MSK, ouvrez la console MSK à l'adresse [https://console.aws.amazon.com/msk/home? region=us-east-1\#/accueil/](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/). Accédez à votre cluster MSK. Choisissez **Propriétés**, **Courtiers**, et **Points finaux**.

Deux options s'offrent à vous pour configurer Prometheus afin de récupérer les métriques de votre cluster MSK :

1. **Cluster-level Résolution DNS (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 est `b-1.clusterName.xxx.xxx.xxx`, utiliser `clusterName.xxx.xxx.xxx` en tant qu'enregistrement DNS. Cela permet à Prometheus de scraper automatiquement tous les courtiers du cluster.

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

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

**Note**  
Remplacer `clusterName.xxx.xxx.xxx` avec le point de terminaison actuel de votre cluster MSK à partir du AWS Console.

Pour plus d'informations, voir [<dns\_sd\_config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config) dans le *Prométhée* documentation.

Voici un exemple de fichier de configuration du scraper :

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

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**  

```bash,sh,zsh
echo -n {{scraper config updated with dns records}} | base64 
```

**Example Fenêtres PowerShell**  

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

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

Utilisez le `create-scraper` commande pour créer un grattoir à l'aide de AWS Command Line Interface. L'exemple suivant crée un scraper dans la région de l'Est des États-Unis (Virginie du Nord). Remplacez le {{example}} du contenu avec 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 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}}'}"
```

------
+ Vous trouverez ci-dessous une liste complète des opérations de grattage que vous pouvez utiliser avec 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 [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html) Fonctionnement de l'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).

## Cross-account installation
<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 dans 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 `account_id_source` où se trouve l'Amazon MSK, et un deuxième compte cible `account_id_target` où se trouve 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.

   ```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. Pour chaque combinaison de source (cluster Amazon MSK) et de cible (Amazon Managed Service for Prometheus workspace), vous devez créer un rôle `arn:aws:iam::{{444455556666}}:role/Target` et ajoutez la politique de confiance suivante avec des autorisations pour [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. Créez un grattoir à l'aide du `--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. Validez la création du scraper.

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

## Basculer entre RoleConfiguration et rôle lié aux services
<a name="prom-msk-changing-roles"></a>

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

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

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

Vous pouvez utiliser le AWS API ou 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 ou SDK. La dernière version vous fournit les dernières fonctionnalités et fonctionnalités, 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 automatiquement une expérience de ligne de commande toujours à jour.

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

Alternativement, avec AWS CLI, appelez :

```
aws amp list-scrapers
```

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

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

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.

Alternativement, avec AWS CLI, appelez :

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

## Statistiques 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 extrait automatiquement les métriques suivantes :

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


| Métrique | Description/Objectif | 
| --- | --- | 
| jmx\_config\_reload\_failure\_total | Nombre total de fois où l'exportateur JMX n'a pas réussi à recharger son fichier de configuration. | 
| jmx\_scrape\_duration\_seconds | Temps nécessaire pour extraire les métriques JMX en secondes pour le cycle de collecte en cours. | 
| erreur jmx\_scrape\_error | Indique si une erreur s'est produite lors de l'extraction des métriques JMX (1 = erreur, 0 = succès). | 
| java\_lang\_Memory\_HeapMemoryUsage\_used | Quantité de mémoire de tas (en octets) actuellement utilisée par la JVM. | 
| java\_lang\_Memory\_HeapMemoryUsage\_max | Quantité maximale de mémoire (en octets) pouvant être utilisée pour la gestion de la mémoire. | 
| java\_lang\_Memory\_NonHeapMemoryUsage\_used | Quantité de mémoire hors tas (en octets) actuellement utilisée par la JVM. | 
| kafka\_cluster\_Partition\_Value | État ou valeur actuel lié aux partitions du cluster Kafka, ventilé par ID de partition et par sujet. | 
| Kafka\_Consumer\_Consumer\_Coordinator\_Metrics\_Assigned\_Partitions | Nombre de partitions actuellement attribuées à ce consommateur. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_latency\_avg | Temps moyen nécessaire pour valider les décalages en millisecondes. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_rate | Nombre de validations de décalage par seconde. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_failed\_rebalance\_total | Nombre total d'échecs de rééquilibrage des groupes de consommateurs. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_last\_heartbeat\_seconds\_ago | Nombre de secondes écoulées depuis que le dernier battement de cœur a été envoyé au coordinateur. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_latency\_avg | Temps moyen nécessaire au rééquilibrage des groupes de consommateurs en millisecondes. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_total | Nombre total de rééquilibres de groupes de consommateurs. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_bytes\_consumed\_rate | Nombre moyen d'octets consommés par seconde par le consommateur. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_latency\_avg | Durée moyenne d'une demande de récupération en millisecondes. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_rate | Nombre de demandes de récupération par seconde. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_consumed\_rate | Nombre moyen d'enregistrements consommés par seconde. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_lag\_max | Latence maximale en termes de nombre d'enregistrements pour n'importe quelle partition de ce consommateur. | 
| kafka\_consumer\_consumer\_metrics\_connection\_count | Nombre actuel de connexions actives. | 
| kafka\_consumer\_consumer\_metrics\_incoming\_byte\_rate | Nombre moyen d'octets reçus par seconde en provenance de tous les serveurs. | 
| kafka\_consumer\_consumer\_metrics\_last\_poll\_seconds\_ago | Nombre de secondes écoulées depuis le dernier appel pour le sondage auprès des consommateurs (). | 
| kafka\_consumer\_consumer\_metrics\_request\_rate | Nombre de demandes envoyées par seconde. | 
| Kafka\_Consumer\_Consumer\_Metrics\_Response\_Rate | Nombre de réponses reçues par seconde. | 
| group\_consommateurs\_kafka\_ConsumerLagMetrics\_Valeur | Valeur de décalage actuelle des consommateurs pour un groupe de consommateurs, indiquant le retard par rapport au consommateur. | 
| contrôleur\_kafka\_KafkaController\_Valeur | État actuel ou valeur du contrôleur Kafka (1 = contrôleur actif, 0 = inactif). | 
| contrôleur\_kafka\_ControllerEventManager\_Compter | Nombre total d'événements de contrôleur traités. | 
| contrôleur\_kafka\_ControllerEventManager\_Moyenne | Temps moyen (moyen) nécessaire pour traiter les événements du contrôleur. | 
| contrôleur\_kafka\_ControllerStats\_MeanRate | Taux moyen d'opérations statistiques du contrôleur par seconde. | 
| group\_coordinateur\_kafka\_GroupMetadataManager\_Valeur | État actuel ou valeur du gestionnaire de métadonnées de groupe pour les groupes de consommateurs. | 
| kafka\_log\_LogFlushStats\_Compter | Nombre total d'opérations de rinçage des journaux. | 
| kafka\_log\_LogFlushStats\_Moyenne | Temps moyen (moyen) nécessaire aux opérations de vidange des journaux. | 
| kafka\_log\_LogFlushStats\_MeanRate | Taux moyen d'opérations de rinçage des journaux par seconde. | 
| réseau\_kafka\_RequestMetrics\_Compter | Nombre total de demandes réseau traitées. | 
| réseau\_kafka\_RequestMetrics\_Moyenne | Temps moyen (moyen) nécessaire au traitement des requêtes réseau. | 
| réseau\_kafka\_RequestMetrics\_MeanRate | Taux moyen de requêtes réseau par seconde. | 
| réseau\_kafka\_Acceptor\_MeanRate | Taux moyen de connexions acceptées par seconde. | 
| serveur\_kafka\_Fetch\_queue\_size | Taille actuelle de la file d'attente des demandes de récupération. | 
| serveur\_kafka\_Produce\_queue\_size | Taille actuelle de la file d'attente des demandes de production. | 
| serveur\_kafka\_Request\_queue\_size | Taille actuelle de la file d'attente générale des demandes. | 
| serveur\_kafka\_BrokerTopicMetrics\_Compter | Nombre total d'opérations thématiques effectuées par les courtiers (messages) in/out, octets in/out). | 
| serveur\_kafka\_BrokerTopicMetrics\_MeanRate | Taux moyen d'opérations thématiques effectuées par les courtiers par seconde. | 
| serveur\_kafka\_BrokerTopicMetrics\_OneMinuteRate | One-minute taux moyen mobile des opérations thématiques des courtiers. | 
| serveur\_kafka\_DelayedOperationPurgatory\_Valeur | Nombre actuel d'opérations retardées au purgatoire (en attente d'achèvement). | 
| serveur\_kafka\_DelayedFetchMetrics\_MeanRate | Taux moyen d'opérations de récupération différées par seconde. | 
| serveur\_kafka\_FetcherLagMetrics\_Valeur | Valeur de décalage actuelle pour les threads de récupération des répliques (distance par rapport au leader). | 
| serveur\_kafka\_FetcherStats\_MeanRate | Taux moyen d'opérations de récupération par seconde. | 
| serveur\_kafka\_ReplicaManager\_Valeur | État actuel ou valeur du gestionnaire de répliques. | 
| serveur\_kafka\_ReplicaManager\_MeanRate | Taux moyen d'opérations du gestionnaire de répliques par seconde. | 
| serveur\_kafka\_LeaderReplication\_byte\_rate | Taux d'octets répliqués par seconde pour les partitions où ce broker est le leader. | 
| kafka\_server\_group\_coordinator\_metrics\_group\_completed\_rebalance\_count | Nombre total de rééquilibres de groupes de consommateurs achevés. | 
| kafka\_server\_group\_coordinator\_metrics\_offset\_commit\_count | Nombre total d'opérations de validation de compensation. | 
| kafka\_server\_group\_coordinator\_metrics\_offset\_commit\_rate | Taux d'opérations de validation de décalage par seconde. | 
| kafka\_server\_socket\_server\_metrics\_connection\_count | Nombre actuel de connexions actives. | 
| kafka\_server\_socket\_server\_metrics\_connection\_creation\_rate | Taux de création de nouvelles connexions par seconde. | 
| kafka\_server\_socket\_server\_metrics\_connection\_close\_rate | Taux de fermetures de connexions par seconde. | 
| kafka\_server\_socket\_server\_metrics\_failed\_authentication\_total | Nombre total de tentatives d'authentification échouées. | 
| kafka\_server\_socket\_server\_metrics\_incoming\_byte\_rate | Taux d'octets entrants par seconde. | 
| kafka\_server\_socket\_server\_metrics\_outgoing\_byte\_rate | Taux d'octets sortants par seconde. | 
| kafka\_server\_socket\_server\_metrics\_request\_rate | Taux de demandes par seconde. | 
| kafka\_server\_socket\_server\_metrics\_response\_rate | Taux de réponses par seconde. | 
| kafka\_server\_socket\_server\_metrics\_network\_io\_rate | Débit du réseau I/O opérations par seconde. | 
| kafka\_server\_socket\_server\_metrics\_io\_ratio | Fraction du temps passé I/O opérations. | 
| kafka\_server\_controller\_channel\_metrics\_connection\_count | Nombre actuel de connexions actives pour les canaux du contrôleur. | 
| kafka\_server\_controller\_channel\_metrics\_incoming\_byte\_rate | Taux d'octets entrants par seconde pour les canaux du contrôleur. | 
| kafka\_server\_controller\_channel\_metrics\_outgoing\_byte\_rate | Taux d'octets sortants par seconde pour les canaux du contrôleur. | 
| kafka\_server\_controller\_channel\_metrics\_request\_rate | Taux de demandes par seconde pour les canaux du contrôleur. | 
| kafka\_server\_replica\_fetcher\_metrics\_connection\_count | Nombre actuel de connexions actives pour le récupérateur de répliques. | 
| kafka\_server\_replica\_fetcher\_metrics\_incoming\_byte\_rate | Taux d'octets entrants par seconde pour le récupérateur de répliques. | 
| kafka\_server\_replica\_fetcher\_metrics\_request\_rate | Taux de demandes par seconde pour le récupérateur de répliques. | 
| kafka\_server\_replica\_fetcher\_metrics\_failed\_authentication\_total | Nombre total de tentatives d'authentification échouées pour le récupérateur de répliques. | 
| serveur\_kafka\_ZooKeeperClientMetrics\_Compter | Nombre total de ZooKeeper opérations avec les clients. | 
| serveur\_kafka\_ZooKeeperClientMetrics\_Moyenne | Latence moyenne de ZooKeeper opérations avec les clients. | 
| serveur\_kafka\_KafkaServer\_Valeur | État actuel ou valeur du serveur Kafka (indique généralement que le serveur est en cours d'exécution). | 
| node\_cpu\_seconds\_total | Nombre total de secondes passées par les processeurs dans chaque mode (utilisateur, système, inactif, etc.), ventilé par processeur et par mode. | 
| node\_disk\_read\_bytes\_total | Nombre total d'octets lus avec succès à partir des disques, ventilé par périphérique. | 
| node\_disk\_reads\_completed\_total | Nombre total de lectures effectuées avec succès pour les disques, ventilé par périphérique. | 
| node\_disk\_writes\_completed\_total | Nombre total d'écritures effectuées avec succès sur les disques, ventilé par périphérique. | 
| node\_disk\_written\_bytes\_total | Nombre total d'octets écrits avec succès sur les disques, ventilé par périphérique. | 
| node\_filesystem\_avail\_bytes | Espace disponible sur le système de fichiers en octets pour les utilisateurs non root, ventilé par périphérique et point de montage. | 
| node\_filesystem\_size\_bytes | Taille totale du système de fichiers en octets, ventilée par périphérique et point de montage. | 
| node\_filesystem\_free\_bytes | Espace libre sur le système de fichiers en octets, ventilé par périphérique et point de montage. | 
| node\_filesystem\_files | Nombre total de nœuds de fichiers (inodes) sur le système de fichiers, ventilé par périphérique et point de montage. | 
| node\_filesystem\_files\_free | Nombre de nœuds de fichiers libres (inodes) sur le système de fichiers, ventilés par périphérique et point de montage. | 
| node\_filesystem\_readonly | Indique si le système de fichiers est monté en lecture seule (1 = lecture seule, 0 = lecture-écriture). | 
| node\_filesystem\_device\_error | 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 à Amazon Managed Service pour Prometheus présente les limites suivantes :
+ Uniquement pris en charge pour les clusters Amazon MSK Provisioned (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 de métadonnées Kraft
+ Supporte actuellement un mappage 1:1 entre les clusters Amazon MSK et Amazon Managed Service for Prometheus collectors/workspaces