View a markdown version of this page

Configura i raccoglitori Prometheus gestiti per Amazon MSK - Amazon Managed Service per Prometheus

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 e Integra Amazon OpenSearch Servizio.

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

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.

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

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/. 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:

    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> nel Prometeo documentazione.

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

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

Esempio Linux/macOS
echo -n scraper config updated with dns records | base64
Esempio finestre PowerShell
[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 API.

  • Elenca i tuoi scraper esistenti con l'operazione ListScrapers API.

  • Aggiorna l'alias, la configurazione o la destinazione di uno scraper con UpdateScraper Funzionamento API.

  • Elimina uno scraper con l'operazione DeleteScraper API.

  • Ottieni maggiori dettagli su uno scraper con l'operazione DescribeScraper API.

Cross-account configurare

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.

    { "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" } } }
  2. 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.

    { "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" } } }
  3. Crea un raschietto con --role-configuration opzione.

    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"}'
  4. 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>" } } ] }

Cambiare tra RoleConfiguration e ruolo legato ai servizi

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

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, che fornisce automaticamente un'esperienza a riga di comando sempre aggiornata.

Per elencare tutti gli scraper del tuo account, usa l’operazione API ListScrapers.

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 per eliminarlo.

In alternativa, con AWS CLI, chiama:

aws amp delete-scraper --scraper-id scraperId

Metriche raccolte da Amazon MSK

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

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

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