

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

# Configura i raccoglitori Prometheus gestiti per Amazon MSK

Per utilizzare un collector Amazon Managed Service for Prometheus, devi creare uno scraper che individua ed estrae le metriche nel tuo cluster Amazon Managed Streaming for Apache Kafka. Puoi anche creare uno scraper che si integri con Amazon Elastic Kubernetes Service o con Amazon OpenSearch Servizio. Per ulteriori informazioni, vedere [Integra Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html) e [Integra Amazon OpenSearch Servizio](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-opensearch-integration.html).

Per istruzioni su come riscuotere il ritardo in base al gruppo di consumatori, le compensazioni impegnate e l'adesione a un esportatore Kafka gestito, vedere [Raccogli le metriche relative ai gruppi di consumatori di Amazon MSK](prom-msk-kafka-exporter.md). Tale procedura utilizza AWS L'autenticazione IAM (Identity and Access Management) e non richiede Open Monitoring. La procedura seguente raccoglie le metriche JMX e Node Exporter da Open Monitoring.

## 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 le metriche 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 uno dei AWS API o AWS CLI come descritto nelle seguenti procedure.

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 le metriche 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 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. Tu [eliminare i raschietti](#prom-msk-delete-scraper) separatamente dall'eliminazione del cluster.

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

Usa il `CreateScraper` Operazione API per creare uno scraper con AWS API. L'esempio seguente crea uno scraper nella regione Stati Uniti orientali (Virginia settentrionale). Sostituisci il {{example}} inserisci le informazioni del tuo 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à.

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

Nell'esempio, `scrapeConfiguration` il 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 specifica zona di disponibilità, che consente ai clienti di connettersi ai broker distribuiti negli AZ prescelti per un'elevata disponibilità.

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 AZ = 3 record DNS
+ **Configurazione personalizzata** — 2 nodi broker su 2 AZ = 2 record DNS

Per ottenere i record DNS per il tuo cluster MSK, apri la console MSK all'indirizzo [https://console.aws.amazon.com/msk/home? region=us-est-1\#/home/](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/). Vai al tuo cluster MSK. Scegli **Proprietà**, **Mediatori**, e **Punti finali**.

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

1. **Cluster-level Risoluzione DNS (consigliata)** — Usa il nome DNS di base del cluster per scoprire automaticamente tutti i broker. Se l'endpoint del tuo broker è `b-1.clusterName.xxx.xxx.xxx`, usa `clusterName.xxx.xxx.xxx` come record DNS. Ciò consente a Prometheus di eseguire automaticamente lo scraping di tutti i broker del cluster.

   **Endpoint dei singoli broker** — Specifica ogni endpoint del broker singolarmente per un controllo granulare. Utilizza gli identificativi completi del broker (b-1, b-2) nella tua configurazione. Ad esempio:

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

**Nota**  
Sostituisci `clusterName.xxx.xxx.xxx` con l'endpoint effettivo del cluster MSK proveniente da AWS Console.

Per ulteriori informazioni, vedere [<dns\_sd\_config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config) nel *Prometeo* documentazione.

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

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

**Example Linux/macOS**  

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

**Example finestre PowerShell**  

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

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

Usa il `create-scraper` comando per creare un raschietto usando il AWS Command Line Interface. L'esempio seguente crea uno scraper nella regione Stati Uniti orientali (Virginia settentrionale). Sostituisci il {{example}} inserisci le informazioni del tuo 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 di scraper che è possibile utilizzare con AWS API:

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

## Cross-account configurare
<a name="prom-msk-cross-account"></a>

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

Ad esempio, quando hai due account, il primo account di origine `account_id_source` dove si trova Amazon MSK e un secondo account di destinazione `account_id_target` dove risiede l'area di lavoro di 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.

   ```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. Su ogni combinazione di origine (cluster Amazon MSK) e destinazione (Amazon Managed Service for Prometheus workspace), devi creare un ruolo `arn:aws:iam::{{444455556666}}:role/Target` e aggiungi la seguente politica di fiducia con le autorizzazioni per [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. Crea un raschietto con `--role-configuration` opzione.

   ```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. Convalida la creazione dello 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>"
               }
           }
       ]
   }
   ```

## Cambiare tra RoleConfiguration e ruolo legato ai servizi
<a name="prom-msk-changing-roles"></a>

Quando si desidera tornare a un ruolo collegato ai servizi anziché a `RoleConfiguration` per scrivere su un workspace Amazon Managed Service for Prometheus, devi aggiornare il `UpdateScraper` e fornisci uno spazio di lavoro nello stesso account dello scraper senza `RoleConfiguration`. Il `RoleConfiguration` verrà rimosso dallo scraper e verrà utilizzato il ruolo collegato al servizio.

Quando si modificano gli spazi di lavoro nello stesso account dello scraper e si desidera continuare a utilizzare `RoleConfiguration`, è necessario fornire nuovamente il `RoleConfiguration` sul `UpdateScraper`.

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

Puoi usare il AWS API o AWS CLI per elencare gli scraper nel tuo account o per eliminarli.

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

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:

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

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 le seguenti metriche:

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


| Parametro | 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). | 
| java\_lang\_Memory\_HeapMemoryUsage\_used | Quantità di memoria heap (in byte) attualmente utilizzata dalla JVM. | 
| java\_lang\_Memory\_HeapMemoryUsage\_max | Quantità massima di memoria heap (in byte) che può essere utilizzata per la gestione della memoria. | 
| java\_lang\_Memory\_NonHeapMemoryUsage\_used | Quantità di memoria non heap (in byte) attualmente utilizzata dalla JVM. | 
| kafka\_cluster\_Partition\_Value | Stato o valore corrente 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 tra gruppi di consumatori. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_last\_heartbeat\_secondi\_fa | Numero di secondi trascorsi dall'ultimo battito cardiaco inviato al coordinatore. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_latency\_avg | Tempo medio impiegato per i ribilanciamenti dei gruppi di consumatori in millisecondi. | 
| kafka\_consumer\_consumer\_coordinator\_metrics\_rebalance\_total | Numero totale di ribilanciamenti tra 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\_secondi\_fa | Numero di secondi 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 di consumo per un gruppo di consumatori, che indica il ritardo del consumatore. | 
| kafka\_controller\_KafkaController\_Valore | Stato o valore attuale del controller Kafka (1 = controller attivo, 0 = non attivo). | 
| kafka\_controller\_ControllerEventManager\_Conta | Numero totale di eventi del controller elaborati. | 
| kafka\_controller\_ControllerEventManager\_Significa | Tempo medio (medio) impiegato per elaborare gli eventi del controller. | 
| kafka\_controller\_ControllerStats\_MeanRate | Frequenza media delle 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\_LogFlushStats\_Conta | Numero totale di operazioni di log flush. | 
| kafka\_log\_LogFlushStats\_Significa | Tempo medio (medio) impiegato per le operazioni di log flush. | 
| kafka\_log\_LogFlushStats\_MeanRate | Frequenza media delle operazioni di log flush al secondo. | 
| kafka\_network\_RequestMetrics\_Conta | Numero totale di richieste di rete elaborate. | 
| kafka\_network\_RequestMetrics\_Significa | Tempo medio (medio) impiegato per elaborare le richieste di rete. | 
| kafka\_network\_RequestMetrics\_MeanRate | Frequenza 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 di richiesta generale. | 
| kafka\_server\_BrokerTopicMetrics\_Conta | Numero totale di operazioni sull'argomento del broker (messaggi) in/out, byte in/out). | 
| kafka\_server\_BrokerTopicMetrics\_MeanRate | Tasso medio di operazioni al secondo relative tematiche del broker. | 
| kafka\_server\_BrokerTopicMetrics\_OneMinuteRate | One-minute tasso medio mobile delle operazioni relative ai broker. | 
| kafka\_server\_DelayedOperationPurgatory\_Valore | Numero attuale di operazioni ritardate nel purgatorio (in attesa di essere completate). | 
| kafka\_server\_DelayedFetchMetrics\_MeanRate | Frequenza media di operazioni di recupero ritardate al secondo. | 
| kafka\_server\_FetcherLagMetrics\_Valore | Valore di ritardo corrente per i thread di recupero delle repliche (quanto distanziato dal leader). | 
| kafka\_server\_FetcherStats\_MeanRate | Frequenza media delle operazioni di recupero al secondo. | 
| kafka\_server\_ReplicaManager\_Valore | Stato o valore corrente del gestore delle repliche. | 
| kafka\_server\_ReplicaManager\_MeanRate | Frequenza media di operazioni di Replica Manager al secondo. | 
| kafka\_server\_LeaderReplication\_byte\_rate | Frequenza 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 tra i 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 | Tasso 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 di connessione 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 | Frequenza di byte in entrata al secondo. | 
| kafka\_server\_socket\_server\_metrics\_outgoing\_byte\_rate | Frequenza di byte in uscita al secondo. | 
| kafka\_server\_socket\_server\_metrics\_request\_rate | Tasso di richieste al secondo. | 
| kafka\_server\_socket\_server\_metrics\_response\_rate | Tasso di risposte al secondo. | 
| kafka\_server\_socket\_server\_metrics\_network\_io\_rate | Tasso di rete I/O operazioni al secondo. | 
| kafka\_server\_socket\_server\_metrics\_io\_ratio | Frazione del tempo trascorso in I/O operazioni. | 
| 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 | Frequenza di byte in ingresso al secondo per i canali del controller. | 
| kafka\_server\_controller\_channel\_metrics\_outgoing\_byte\_rate | Frequenza 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 | Frequenza 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 non riusciti per il replica fetcher. | 
| kafka\_server\_ZooKeeperClientMetrics\_Conta | Conteggio totale di ZooKeeper operazioni con i clienti. | 
| kafka\_server\_ZooKeeperClientMetrics\_Significa | Latenza media di ZooKeeper operazioni con i clienti. | 
| kafka\_server\_KafkaServer\_Valore | Stato o valore corrente del server Kafka (in genere indica che il server è in esecuzione). | 
| node\_cpu\_seconds\_total | Numero totale di secondi trascorsi dalle CPU in ciascuna modalità (utente, sistema, inattività, ecc.), suddivisi per CPU e modalità. | 
| node\_disk\_read\_bytes\_total | Numero totale di byte letti correttamente dai dischi, suddivisi per dispositivo. | 
| node\_disk\_reads\_completed\_total | Numero totale di letture completate con successo per i dischi, suddiviso per dispositivo. | 
| node\_disk\_writes\_completed\_total | Numero totale di scritture completate con successo per i dischi, suddiviso per dispositivo. | 
| node\_disk\_written\_bytes\_total | Numero totale di byte scritti correttamente sui dischi, suddivisi per dispositivo. | 
| node\_filesystem\_avail\_bytes | Spazio disponibile nel file system in byte per utenti non root, suddiviso per dispositivo e punto di montaggio. | 
| node\_filesystem\_size\_bytes | Dimensione totale del file system in byte, suddivisa per dispositivo e punto di montaggio. | 
| node\_filesystem\_free\_bytes | Spazio libero sul file system in byte, suddiviso per dispositivo e punto di montaggio. | 
| node\_filesystem\_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 file system (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 la modalità metadati KRAFT
+ Attualmente supporta una mappatura 1:1 tra i cluster Amazon MSK e Amazon Managed Service for Prometheus collectors/workspaces