

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Configurare i raccoglitori Prometheus gestiti per Amazon MSK
<a name="prom-msk-integration"></a>

Per utilizzare un collector Amazon Managed Service for Prometheus, devi creare uno scraper che rileva e recupera i parametri nel tuo cluster Amazon Managed Streaming for Apache Kafka. Puoi anche creare uno scraper che si integri con Amazon Elastic Kubernetes Service. Per ulteriori informazioni, consulta [Integrate Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html).

## Creare uno scraper
<a name="prom-msk-create-scraper"></a>

Un collettore Amazon Managed Service for Prometheus è costituito da uno scraper che rileva e raccoglie i parametri da un cluster Amazon MSK. Il servizio gestito da Amazon per Prometheus gestisce lo scraper per te, offrendoti la scalabilità, la sicurezza e l'affidabilità di cui hai bisogno, senza dover gestire personalmente istanze, agenti o scraper.

Puoi creare uno scraper utilizzando l'API o come descritto nelle AWS seguenti procedure. AWS CLI 

Esistono alcuni prerequisiti per creare il proprio scraper:
+ È necessario creare un cluster Amazon MSK.
+ Configura il gruppo di sicurezza del tuo cluster Amazon MSK per consentire il traffico in entrata sulle porte **11001 (JMX Exporter) e 11002 (Node Exporter****) all'interno del tuo Amazon VPC, poiché lo scraper richiede** l'accesso a questi record DNS per raccogliere i parametri di Prometheus.
+ [L'Amazon VPC in cui risiede il cluster Amazon MSK deve avere DNS abilitato.](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html)

**Nota**  
Il cluster verrà associato allo scraper tramite il relativo nome di risorsa Amazon (ARN). Se elimini un cluster e poi ne crei uno nuovo con lo stesso nome, l'ARN verrà riutilizzato per il nuovo cluster. Per questo motivo, lo scraper tenterà di raccogliere le metriche per il nuovo cluster. [Gli scraper vengono eliminati](#prom-msk-delete-scraper) separatamente dall'eliminazione del cluster.

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

Utilizzate l'operazione `CreateScraper` API per creare uno scraper con l'API. AWS L'esempio seguente crea uno scraper nella regione Stati Uniti orientali (Virginia settentrionale). Sostituisci il {{example}} contenuto con le informazioni del cluster Amazon MSK e fornisci la configurazione dello scraper.

**Nota**  
Configura il gruppo di sicurezza e le sottoreti in modo che corrispondano al cluster di destinazione. Includi almeno due sottoreti in due zone di 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}}
    }
}
```

Nell'esempio, il `scrapeConfiguration` parametro richiede un file YAML di configurazione Prometheus con codifica Base64 che specifica i record DNS del cluster MSK.

Ogni record DNS rappresenta un endpoint del broker in una zona di disponibilità specifica, che consente ai clienti di connettersi ai broker distribuiti tra i broker prescelti per un'elevata disponibilità. AZs 

Il numero di record DNS nelle proprietà del cluster MSK corrisponde al numero di nodi broker e zone di disponibilità nella configurazione del cluster:
+ **Configurazione predefinita**: 3 nodi broker su 3 AZs = 3 record DNS
+ **Configurazione personalizzata**: 2 nodi broker su 2 AZs = 2 record DNS

[Per ottenere i record DNS per il tuo cluster MSK, apri la console MSK a casa? https://console.aws.amazon.com/msk/ region=us-east-1\#/home/.](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/) Vai al tuo cluster MSK. **Scegli **Proprietà**, **Broker** ed Endpoints.**

Sono disponibili due opzioni per configurare Prometheus per acquisire metriche dal cluster MSK:

1. **Risoluzione DNS a livello di cluster (consigliata): utilizza il nome DNS** di base del cluster per scoprire automaticamente tutti i broker. Se l'endpoint del broker lo è`b-1.clusterName.xxx.xxx.xxx`, utilizzalo come record DNS. `clusterName.xxx.xxx.xxx` Ciò consente a Prometheus di eliminare automaticamente tutti i broker del cluster.

   Endpoint **individuali del broker: specifica ogni endpoint** del broker singolarmente per un controllo granulare. Utilizza gli identificatori completi del broker (b-1, b-2) nella tua configurazione. Esempio:

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

**Nota**  
`clusterName.xxx.xxx.xxx`Sostituiscilo con l'attuale endpoint del cluster MSK dalla console. AWS 

Per ulteriori informazioni, consulta <dns\_sd\_config>la[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config) documentazione di *Prometheus.*

Di seguito è riportato un esempio del file di configurazione dello 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}'
```

Eseguite uno dei seguenti comandi per convertire il file YAML in base64. Puoi anche utilizzare qualsiasi convertitore base64 online per convertire il file.

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

Utilizzate il `create-scraper` comando per creare un raschietto utilizzando il AWS Command Line Interface. L'esempio seguente crea uno scraper nella regione Stati Uniti orientali (Virginia settentrionale). Sostituisci il {{example}} contenuto con le informazioni del cluster Amazon MSK e fornisci la configurazione dello scraper.

**Nota**  
Configura il gruppo di sicurezza e le sottoreti in modo che corrispondano al cluster di destinazione. Includi almeno due sottoreti in due zone di 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}}'}"
```

------
+ Di seguito è riportato un elenco completo delle operazioni dello scraper che è possibile utilizzare con l'API: AWS 

  Creare uno scraper con l'operazione [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html) API.
+ Elenca i tuoi scraper esistenti con l'operazione [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html) API.
+ Aggiorna l'alias, la configurazione o la destinazione di uno scraper con l'[UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html)operazione API.
+ Elimina uno scraper con l'operazione [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) API.
+ Ottieni maggiori dettagli su uno scraper con l'operazione [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html) API.

## Configurazione tra più account
<a name="prom-msk-cross-account"></a>

Per creare uno scraper in una configurazione tra più account quando il cluster Amazon MSK da cui desideri raccogliere le metriche si trova in un account diverso dal raccoglitore Amazon Managed Service for Prometheus, utilizza la procedura seguente.

Ad esempio, se disponi di due account, il primo account di origine `account_id_source` in cui si trova Amazon MSK e un secondo account di destinazione `account_id_target` in cui risiede l'area di lavoro Amazon Managed Service for Prometheus.

**Per creare uno scraper in una configurazione con più account**

1. Nell'account di origine, crea un ruolo `arn:aws:iam::{{111122223333}}:role/Source` e aggiungi la seguente politica di fiducia.

   ```
   {
       "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. In ogni combinazione di origine (cluster Amazon MSK) e destinazione (Amazon Managed Service for Prometheus workspace), devi creare un `arn:aws:iam::{{444455556666}}:role/Target` ruolo e aggiungere la seguente politica di fiducia con autorizzazioni per. [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. Crea uno scraper con l'opzione. `--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. Convalida la creazione dello scraper.

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

## Passaggio da un ruolo collegato al servizio RoleConfiguration e viceversa
<a name="prom-msk-changing-roles"></a>

Se desideri tornare a un ruolo collegato al servizio anziché scrivere su un'area di lavoro Amazon Managed Service for Prometheus, devi aggiornare `UpdateScraper` e fornire un'area di lavoro nello stesso account dello scraper senza il. `RoleConfiguration` `RoleConfiguration` `RoleConfiguration`Verrà rimosso dallo scraper e verrà utilizzato il ruolo collegato al servizio.

Quando si modificano le aree di lavoro nello stesso account dello scraper e si desidera continuare a utilizzare il`RoleConfiguration`, è necessario fornire nuovamente l'attivazione. `RoleConfiguration` `UpdateScraper`

## Trova ed elimina gli scraper
<a name="prom-msk-delete-scraper"></a>

Puoi utilizzare l' AWS API o il AWS CLI per elencare gli scraper presenti nel tuo account o eliminarli.

**Nota**  
Assicurati di utilizzare la versione più recente di AWS CLI o SDK. La versione più recente offre le caratteristiche e le funzionalità più recenti, oltre agli aggiornamenti di sicurezza. In alternativa, usa [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), che fornisce sempre un'esperienza a riga di up-to-date comando, automaticamente.

Per elencare tutti gli scraper del tuo account, usa l’operazione API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html).

In alternativa, con AWS CLI, chiama:

```
aws amp list-scrapers
```

`ListScrapers` restituisce tutti gli scraper del tuo account, ad esempio:

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

Per eliminare uno scraper, trova `scraperId` relativo allo scraper che desideri eliminare, utilizzando l'operazione `ListScrapers`, quindi usa l'operazione [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) per eliminarlo.

In alternativa, con AWS CLI, chiama:

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

## Metriche raccolte da Amazon MSK
<a name="prom-msk-metrics"></a>

Quando effettui l'integrazione con Amazon MSK, il collettore Amazon Managed Service for Prometheus analizza automaticamente i seguenti parametri:

### Metriche: lavori jmx\_exporter e pod\_exporter
<a name="broker-metrics"></a>


| Metrica | Descrizione/Scopo | 
| --- | --- | 
| jmx\_config\_reload\_failure\_total | Numero totale di volte in cui l'esportatore JMX non è riuscito a ricaricare il file di configurazione. | 
| jmx\_scrape\_duration\_seconds | Tempo impiegato per acquisire le metriche JMX in secondi per il ciclo di raccolta corrente. | 
| jmx\_scrape\_error | Indica se si è verificato un errore durante lo scraping metrico JMX (1 = errore, 0 = successo). | 
| HeapMemoryUsagejava\_lang\_memory\_ \_usato | Quantità di memoria heap (in byte) attualmente utilizzata dalla JVM. | 
| HeapMemoryUsagejava\_lang\_memory\_ \_max | Quantità massima di memoria heap (in byte) che può essere utilizzata per la gestione della memoria. | 
| java\_lang\_memory\_ \_usato NonHeapMemoryUsage | Quantità di memoria non heap (in byte) attualmente utilizzata dalla JVM. | 
| Kafka\_CLUSTER\_PARTITION\_VALUE | Stato o valore attuale relativo alle partizioni del cluster Kafka, suddiviso per ID di partizione e argomento. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_assigned\_partitions | Numero di partizioni attualmente assegnate a questo consumatore. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_latency\_avg | Tempo medio impiegato per eseguire il commit degli offset in millisecondi. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_commit\_rate | Numero di commit di offset al secondo. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_failed\_rebalance\_total | Numero totale di ribilanciamenti falliti dei gruppi di consumatori. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_last\_heartbeat\_seconds\_ago | Numero di secondi trascorsi dall'ultimo battito cardiaco inviato al coordinatore. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_latency\_avg | Tempo medio impiegato per il riequilibrio del gruppo di consumatori in millisecondi. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_total | Numero totale di ribilanciamenti dei gruppi di consumatori. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_bytes\_consumed\_rate | Numero medio di byte consumati al secondo dal consumatore. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_latency\_avg | Tempo medio impiegato per una richiesta di recupero in millisecondi. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_fetch\_rate | Numero di richieste di recupero al secondo. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_consumed\_rate | Numero medio di record consumati al secondo. | 
| kafka\_consumer\_consumer\_fetch\_manager\_metrics\_records\_lag\_max | Ritardo massimo in termini di numero di record per qualsiasi partizione di questo consumatore. | 
| kafka\_consumer\_consumer\_metrics\_connection\_count | Numero attuale di connessioni attive. | 
| kafka\_consumer\_consumer\_metrics\_incoming\_byte\_rate | Numero medio di byte ricevuti al secondo da tutti i server. | 
| kafka\_consumer\_consumer\_metrics\_last\_poll\_seconds\_ago | Numero di secondi trascorsi dall'ultima chiamata consumer poll (). | 
| kafka\_consumer\_consumer\_metrics\_request\_rate | Numero di richieste inviate al secondo. | 
| kafka\_consumer\_consumer\_metrics\_response\_rate | Numero di risposte ricevute al secondo. | 
| kafka\_consumer\_group\_ ConsumerLagMetrics \_Valore | Valore attuale del ritardo dei consumatori per un gruppo di consumatori, che indica il ritardo del consumatore. | 
| KafkaControllerkafka\_controller\_ \_Valore | Stato o valore attuale del controller Kafka (1 = controller attivo, 0 = non attivo). | 
| kafka\_controller\_ \_Count ControllerEventManager | Numero totale di eventi del controller elaborati. | 
| ControllerEventManagerkafka\_controller\_ \_Mean | Tempo medio (medio) impiegato per elaborare gli eventi del controller. | 
| ControllerStatskafka\_controller\_ \_ MeanRate | Velocità media di operazioni statistiche del controller al secondo. | 
| kafka\_coordinator\_group\_ GroupMetadataManager \_Valore | Stato o valore attuale del gestore dei metadati di gruppo per i gruppi di consumatori. | 
| kafka\_log\_ \_Count LogFlushStats | Numero totale di operazioni di log flush. | 
| kafka\_log\_ \_Mean LogFlushStats | Tempo medio (medio) impiegato per le operazioni di scarico dei log. | 
| LogFlushStatskafka\_log\_ \_ MeanRate | Velocità media delle operazioni di log flush al secondo. | 
| kafka\_network\_ \_Count RequestMetrics | Numero totale di richieste di rete elaborate. | 
| kafka\_network\_ \_Media RequestMetrics | Tempo medio (medio) impiegato per elaborare le richieste di rete. | 
| kafka\_network\_ \_ RequestMetrics MeanRate | Velocità media di richieste di rete al secondo. | 
| Kafka\_Network\_Acceptor\_ MeanRate | Velocità media di connessioni accettate al secondo. | 
| Kafka\_server\_fetch\_queue\_size | Dimensione attuale della coda delle richieste di recupero. | 
| Kafka\_server\_produce\_queue\_size | Dimensione attuale della coda di richiesta di produzione. | 
| Kafka\_server\_request\_queue\_size | Dimensione attuale della coda delle richieste generali. | 
| kafka\_server\_ \_Count BrokerTopicMetrics | Numero totale di operazioni (messaggi) sull'argomento del broker. in/out, bytes in/out | 
| kafka\_server\_ \_ BrokerTopicMetrics MeanRate | Tasso medio di operazioni relative all'argomento del broker per secondo. | 
| kafka\_server\_ \_ BrokerTopicMetrics OneMinuteRate | Frequenza media mobile di un minuto delle operazioni relative al broker. | 
| DelayedOperationPurgatorykafka\_server\_ \_Valore | Numero attuale di operazioni ritardate nel purgatorio (in attesa di essere completate). | 
| DelayedFetchMetricskafka\_server\_ \_ MeanRate | Frequenza media di operazioni di recupero ritardate al secondo. | 
| kafka\_server\_ \_Valore FetcherLagMetrics | Valore di ritardo attuale per i thread di replica fetcher (quanto è indietro rispetto al leader). | 
| FetcherStatskafka\_server\_ \_ MeanRate | Velocità media di operazioni di recupero al secondo. | 
| ReplicaManagerkafka\_server\_ \_Valore | Stato o valore attuale del gestore di repliche. | 
| ReplicaManagerkafka\_server\_ \_ MeanRate | Velocità media di operazioni di Replica Manager al secondo. | 
| LeaderReplicationkafka\_server\_ \_byte\_rate | Velocità di byte replicati al secondo per le partizioni in cui questo broker è il leader. | 
| kafka\_server\_group\_coordinator\_metrics\_group\_completed\_rebalance\_count | Numero totale di ribilanciamenti completati per gruppi di consumatori. | 
| kafka\_server\_group\_coordinator\_metrics\_offset\_commit\_count | Numero totale di operazioni di offset commit. | 
| kafka\_server\_group\_coordinator\_metrics\_offset\_commit\_rate | Velocità di operazioni di offset commit al secondo. | 
| kafka\_server\_socket\_server\_metrics\_connection\_count | Numero attuale di connessioni attive. | 
| kafka\_server\_socket\_server\_metrics\_connection\_creation\_rate | Velocità di creazione di nuove connessioni al secondo. | 
| kafka\_server\_socket\_server\_metrics\_connection\_close\_rate | Frequenza di chiusure delle connessioni al secondo. | 
| kafka\_server\_socket\_server\_metrics\_failed\_authentication\_total | Numero totale di tentativi di autenticazione falliti. | 
| kafka\_server\_socket\_server\_metrics\_incoming\_byte\_rate | Velocità di byte in entrata al secondo. | 
| kafka\_server\_socket\_server\_metrics\_outgoing\_byte\_rate | Velocità di byte in uscita al secondo. | 
| kafka\_server\_socket\_server\_metrics\_request\_rate | Frequenza di richieste al secondo. | 
| kafka\_server\_socket\_server\_metrics\_response\_rate | Frequenza di risposte al secondo. | 
| kafka\_server\_socket\_server\_metrics\_network\_io\_rate | Velocità di operazioni di rete al secondo. I/O  | 
| kafka\_server\_socket\_server\_metrics\_io\_ratio | Frazione del tempo impiegato nelle operazioni. I/O  | 
| kafka\_server\_controller\_channel\_metrics\_connection\_count | Numero attuale di connessioni attive per i canali del controller. | 
| kafka\_server\_controller\_channel\_metrics\_incoming\_byte\_rate | Velocità di byte in ingresso al secondo per i canali del controller. | 
| kafka\_server\_controller\_channel\_metrics\_outgoing\_byte\_rate | Velocità di byte in uscita al secondo per i canali del controller. | 
| kafka\_server\_controller\_channel\_metrics\_request\_rate | Frequenza di richieste al secondo per i canali del controller. | 
| kafka\_server\_replica\_fetcher\_metrics\_connection\_count | Numero attuale di connessioni attive per Replica Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_incoming\_byte\_rate | Velocità di byte in entrata al secondo per Replica Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_request\_rate | Frequenza di richieste al secondo per Replica Fetcher. | 
| kafka\_server\_replica\_fetcher\_metrics\_failed\_authentication\_total | Numero totale di tentativi di autenticazione falliti per Replica Fetcher. | 
| kafka\_server\_ \_Count ZooKeeperClientMetrics | Numero totale delle operazioni del client. ZooKeeper  | 
| kafka\_server\_ \_Media ZooKeeperClientMetrics | Latenza media delle operazioni del client. ZooKeeper  | 
| KafkaServerkafka\_server\_ \_Valore | Stato o valore attuale del server Kafka (in genere indica che il server è in esecuzione). | 
| node\_cpu\_seconds\_total | Secondi totali CPUs trascorsi in ciascuna modalità (utente, sistema, inattività, ecc.), suddivisi per CPU e modalità. | 
| node\_disk\_read\_bytes\_total | Numero totale di byte letti con successo dai dischi, suddivisi per dispositivo. | 
| node\_disk\_reads\_completed\_total | Numero totale di letture completate con successo per i dischi, suddivise per dispositivo. | 
| node\_disk\_writes\_completed\_total | Numero totale di scritture completate con successo per i dischi, suddivise per dispositivo. | 
| node\_disk\_written\_bytes\_total | Numero totale di byte scritti correttamente su dischi, suddivisi per dispositivo. | 
| node\_filesystem\_avail\_bytes | Spazio disponibile nel filesystem in byte per utenti non root, suddiviso per dispositivo e punto di montaggio. | 
| node\_filesystem\_size\_bytes | Dimensione totale del filesystem in byte, suddivisa per dispositivo e punto di montaggio. | 
| node\_filesystem\_free\_bytes | Spazio libero nel filesystem in byte, suddiviso per dispositivo e punto di montaggio. | 
| filesystem\_node\_files | Numero totale di nodi di file (inode) sul filesystem, suddivisi per dispositivo e punto di montaggio. | 
| node\_filesystem\_files\_free | Numero di nodi di file liberi (inode) sul filesystem, suddivisi per dispositivo e punto di montaggio. | 
| node\_filesystem\_readonly | Indica se il filesystem è montato in sola lettura (1 = sola lettura, 0 = lettura-scrittura). | 
| node\_filesystem\_device\_error | Indica se si è verificato un errore durante l'acquisizione delle statistiche del filesystem (1 = errore, 0 = successo). | 

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

L'attuale integrazione di Amazon MSK con Amazon Managed Service for Prometheus presenta le seguenti limitazioni:
+ Supportato solo per i cluster Amazon MSK Provisioned (non disponibile per Amazon MSK Serverless)
+ Non supportato per i cluster Amazon MSK con accesso pubblico abilitato in combinazione con KRaft la modalità metadati
+ Non supportato per i broker Amazon MSK Express
+ Attualmente supporta una mappatura 1:1 tra i cluster Amazon MSK e i collezionisti/spazi di lavoro Amazon Managed Service for Prometheus