Creare uno scraper Configurazione su più account Passaggio da un ruolo collegato al servizio RoleConfiguration e viceversa Trova ed elimina gli scraper Metriche raccolte da Amazon MSK Limitazioni

Configurare i raccoglitori Prometheus gestiti per Amazon MSK

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.

Creare uno scraper

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.

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 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/. Vai al tuo cluster MSK. Scegli Proprietà, Broker ed Endpoints.

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

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

clusterName.xxx.xxx.xxxSostituiscilo con l'attuale endpoint del cluster MSK dalla console. AWS

Per ulteriori informazioni, consulta <dns_sd_config>lahttps://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.

Esempio Linux/macOS


echo -n scraper config updated with dns records | base64

Esempio 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 API.
Elenca i tuoi scraper esistenti con l'operazione ListScrapers API.
Aggiorna l'alias, la configurazione o la destinazione di uno scraper con l'UpdateScraperoperazione API.
Elimina uno scraper con l'operazione DeleteScraper API.
Ottieni maggiori dettagli su uno scraper con l'operazione DescribeScraper API.

Configurazione tra più account

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

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

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


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

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

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

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 RoleConfigurationVerrà 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 ilRoleConfiguration, è necessario fornire nuovamente l'attivazione. RoleConfiguration UpdateScraper

Trova ed elimina gli scraper

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

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 i seguenti parametri:

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

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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Integra Amazon EKS

Parametri compatibili con Prometheus