Creare uno scraper Cross-account configurazione Passaggio da un ruolo all'altro RoleConfiguration e collegato ai servizi Trova ed elimina gli scraper Metriche raccolte da Amazon MSK Limitazioni

Configura 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 Service. OpenSearch Per ulteriori informazioni, consulta Integrare Amazon EKS e Integrare Amazon Service. OpenSearch

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 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 le metriche di Prometheus.
L'Amazon VPC in cui risiede il cluster Amazon MSK deve avere il 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. Gli scraper vengono eliminati separatamente dall'eliminazione del cluster.

To create a scraper using the AWS API

Usa 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 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, il scrapeConfiguration parametro richiede un file YAML di configurazione Prometheus con codifica base64 che specifichi 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-east-1#/home/. Vai al tuo cluster MSK. Scegli Proprietà, Broker ed Endpoints.

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

Cluster-level Risoluzione DNS (consigliata): utilizza 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, utilizzalo 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

Sostituiscilo clusterName.xxx.xxx.xxx con il tuo endpoint del cluster MSK effettivo dalla console. AWS

Per ulteriori informazioni, consulta la documentazione di <dns_sd_config>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}'

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

Cross-account configurazione

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 in cui si trova Amazon MSK e un secondo account di destinazione account_id_source in cui risiede l'area di lavoro Amazon Managed Service for account_id_target 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"
        }
    }
}

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

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 all'altro RoleConfiguration e collegato al servizio

Quando desideri tornare a un ruolo collegato al servizio invece di RoleConfiguration scrivere su uno spazio di lavoro Amazon Managed Service for Prometheus, devi aggiornare UpdateScraper e fornire uno spazio di lavoro nello stesso account dello scraper senza. RoleConfiguration RoleConfigurationVerrà 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 ilRoleConfiguration, è necessario fornire nuovamente l'RoleConfigurationattivazione. UpdateScraper

Trova ed elimina gli scraper

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

Nota

Assicurati di utilizzare la versione più recente di AWS CLI or SDK. L'ultima versione offre le caratteristiche e le funzionalità più recenti, nonché gli aggiornamenti di sicurezza. In alternativa, utilizza AWS CloudShell, che fornisce un'esperienza a riga di comando sempre aggiornata, automaticamente.

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

In alternativa, con il 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 il 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:

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).
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_ _Value ConsumerLagMetrics	Valore attuale del ritardo di consumo per un gruppo di consumatori, che indica il ritardo del consumatore.
KafkaControllerkafka_controller_ _Value	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	Frequenza media delle operazioni statistiche del controller al secondo.
kafka_coordinator_group_ _Value GroupMetadataManager	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 log flush.
LogFlushStatskafka_log_ _ MeanRate	Frequenza media delle operazioni di log flush al secondo.
kafka_network_ _Count RequestMetrics	Numero totale di richieste di rete elaborate.
kafka_network_ _Mean RequestMetrics	Tempo medio (medio) impiegato per elaborare le richieste di rete.
kafka_network_ _ RequestMetrics MeanRate	Frequenza media delle 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_ _Count BrokerTopicMetrics	Numero totale delle operazioni sull'argomento del broker (messaggi, byte). in/out in/out
BrokerTopicMetricskafka_server_ _ MeanRate	Frequenza media al secondo delle operazioni effettuate dai broker sulle varie tematiche.
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).
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 dista dal leader).
FetcherStatskafka_server_ _ MeanRate	Frequenza media delle operazioni di recupero al secondo.
ReplicaManagerkafka_server_ _Valore	Stato o valore corrente del gestore delle repliche.
kafka_server_ _ ReplicaManager MeanRate	Frequenza media delle operazioni di Replica Manager al secondo.
kafka_server_ _byte_rate LeaderReplication	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	Velocità delle 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	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_ _Count ZooKeeperClientMetrics	Numero totale delle operazioni del cliente. ZooKeeper
kafka_server_ _Mean ZooKeeperClientMetrics	Latenza media delle operazioni del client. ZooKeeper
KafkaServerkafka_server_ _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

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

OpenSearch Integra Amazon Service