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à.
# Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes
Questa sezione spiega come configurare l' CloudWatch agente con il monitoraggio Prometheus in un cluster che esegue Amazon EKS o Kubernetes. Dopo aver eseguito questa operazione, l'agente esegue automaticamente lo scraping e l'importazione dei parametri per i seguenti carichi di lavoro in esecuzione in quel cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
È inoltre possibile configurare l'agente per recuperare e importare carichi di lavoro e origini Prometheus.
Prima di seguire questi passaggi per installare l' CloudWatch agente per la raccolta di metriche Prometheus, devi avere un cluster in esecuzione su Amazon EKS o un cluster Kubernetes in esecuzione su un'istanza Amazon EC2.
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
**Topics**
+ [Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes](#ContainerInsights-Prometheus-Setup-roles)
+ [Scraping di ulteriori origini Prometheus e importazione di tali parametri](ContainerInsights-Prometheus-Setup-configure.md)
+ [(Facoltativo) Impostazione dei carichi di lavoro Amazon EKS containerizzati di esempio per i test dei parametri di Prometheus](ContainerInsights-Prometheus-Sample-Workloads.md)
## Installa l' CloudWatch agente con la raccolta di metriche Prometheus sui cluster Amazon EKS e Kubernetes
Questa sezione spiega come configurare l' CloudWatch agente con il monitoraggio Prometheus in un cluster che esegue Amazon EKS o Kubernetes. Dopo aver eseguito questa operazione, l'agente esegue automaticamente lo scraping e l'importazione dei parametri per i seguenti carichi di lavoro in esecuzione in quel cluster.
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
È inoltre possibile configurare l'agente per recuperare e importare carichi di lavoro e origini Prometheus.
Prima di seguire questi passaggi per installare l' CloudWatch agente per la raccolta di metriche Prometheus, devi avere un cluster in esecuzione su Amazon EKS o un cluster Kubernetes in esecuzione su un'istanza Amazon EC2.
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
**Topics**
+ [Impostazione dei ruoli IAM](#ContainerInsights-Prometheus-Setup-roles)
+ [Installazione dell' CloudWatch agente per raccogliere le metriche di Prometheus](#ContainerInsights-Prometheus-Setup-install-agent)
### Impostazione dei ruoli IAM
Il primo passo consiste nell'impostare il ruolo IAM necessario nel cluster. Esistono due metodi:
+ Impostare un ruolo IAM per un account di servizio, noto anche come *ruolo di servizio*. Questo metodo funziona sia per il tipo di avvio EC2 che per il tipo di avvio Fargate.
+ Aggiungere una policy IAM al ruolo IAM utilizzato per il cluster. Funziona solo per il tipo di avvio EC2.
**Impostazione di un ruolo di servizio (tipo di avvio EC2 e tipo di avvio Fargate)**
Per impostare un ruolo di servizio, immetti il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create iamserviceaccount \
--name cwagent-prometheus \
--namespace amazon-cloudwatch \
--cluster MyCluster \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
**Aggiungere una policy al ruolo IAM del nodo (solo tipo di avvio EC2)**
**Per impostare la policy IAM in un gruppo di nodi per il supporto di Prometheus**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.
1. È necessario trovare il prefisso del nome del ruolo IAM per il cluster. A tale scopo, seleziona la casella di controllo accanto al nome di un'istanza presente nel cluster e scegli **Azioni**, **Sicurezza**, **Modifica ruolo IAM**. Copia quindi il prefisso del ruolo IAM, ad esempio `eksctl-dev303-workshop-nodegroup`.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Utilizza la casella di ricerca per trovare il prefisso copiato in precedenza in questa procedura e scegli il ruolo desiderato.
1. Scegli **Collega policy**.
1. Usa la casella di ricerca per trovare **CloudWatchAgentServerPolicy**. Seleziona la casella di controllo accanto a **CloudWatchAgentServerPolicy**e scegli **Allega politica**.
### Installazione dell' CloudWatch agente per raccogliere le metriche di Prometheus
È necessario installare l' CloudWatch agente nel cluster per raccogliere le metriche. L'installazione dell'agente è diversa per cluster Amazon EKS e cluster Kubernetes.
**Eliminare le versioni precedenti dell' CloudWatch agente con il supporto Prometheus**
Se hai già installato una versione dell' CloudWatch agente con supporto Prometheus nel tuo cluster, devi eliminare quella versione immettendo il seguente comando. Questo è necessario solo per le versioni precedenti dell'agente con supporto di Prometheus. Non è necessario eliminare l' CloudWatch agente che abilita Container Insights senza il supporto di Prometheus.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
#### Installazione dell' CloudWatch agente su cluster Amazon EKS con il tipo di avvio EC2
Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS, segui questi passaggi.
**Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS**
1. Immetti il comando seguente per verificare se lo spazio dei nomi `amazon-cloudwatch` è già stato creato:
```
kubectl get namespace
```
1. Se `amazon-cloudwatch` non viene visualizzato nei risultati, crearlo immettendo il seguente comando:
```
kubectl create namespace amazon-cloudwatch
```
1. Per distribuire l'agente con la configurazione predefinita e fare in modo che invii i dati alla AWS regione in cui è installato, inserisci il seguente comando:
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Per fare in modo che l'agente invii dati a un'area diversa, attenersi alla seguente procedura:
1. Scaricare il file YAML per l'agente immettendo il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
1. Apri il file con un editor di testo e cercare il blocco `cwagentconfig.json` del file.
1. Aggiungere le linee evidenziate, specificando l'area desiderata:
```
cwagentconfig.json: |
{
"agent": {
"region": "us-east-2"
},
"logs": { ...
```
1. Salva il file e implementa l'agente utilizzando il file aggiornato.
```
kubectl apply -f prometheus-eks.yaml
```
#### Installazione dell' CloudWatch agente su cluster Amazon EKS con il tipo di avvio Fargate
Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS con il tipo di avvio Fargate, segui questi passaggi.
**Per installare l' CloudWatch agente con supporto Prometheus su un cluster Amazon EKS con il tipo di avvio Fargate**
1. Immettete il seguente comando per creare un profilo Fargate per l' CloudWatchagente in modo che possa essere eseguito all'interno del cluster. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--name amazon-cloudwatch \
--namespace amazon-cloudwatch
```
1. Per installare l' CloudWatch agente, immettere il seguente comando. Sostituisci *MyCluster* con il nome del cluster. Questo nome viene utilizzato nel nome del gruppo di log che memorizza gli eventi di log raccolti dall'agente e viene utilizzato anche come dimensione per le metriche raccolte dall'agente.
Sostituisci *region* con il nome della regione in cui desideri inviare le metriche. Ad esempio, `us-west-1`.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
#### Installazione dell' CloudWatch agente su un cluster Kubernetes
Per installare l' CloudWatch agente con supporto Prometheus su un cluster che esegue Kubernetes, inserisci il seguente comando:
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
Sostituisci *MyCluster* con il nome del cluster. Questo nome viene utilizzato nel nome del gruppo di log che memorizza gli eventi di log raccolti dall'agente e viene utilizzato anche come dimensione per le metriche raccolte dall'agente.
Sostituisci *region* con il nome della AWS regione in cui desideri inviare le metriche. Ad esempio, **us-west-1**.
#### Verifica dell'esecuzione dell'agente
In entrambi i cluster Amazon EKS e Kubernetes, puoi inserire il comando seguente per confermare che l'agente è in esecuzione.
```
kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch
```
Se i risultati includono un singolo pod di agenti `Running` nello stato, l' CloudWatch agente sta eseguendo e raccogliendo le metriche di Prometheus. Per impostazione predefinita, l' CloudWatchagente raccoglie le metriche per App Mesh, NGINX, Memcached, Java/JMX e ogni minuto. HAProxy Per ulteriori informazioni su questi parametri, consulta [Metriche di Prometheus raccolte dall'agente CloudWatch](ContainerInsights-Prometheus-metrics.md). Per istruzioni su come visualizzare le metriche di Prometheus in, consulta CloudWatch [Visualizzazione dei parametri Prometheus](ContainerInsights-Prometheus-viewmetrics.md)
Puoi anche configurare l' CloudWatch agente per raccogliere metriche da altri esportatori di Prometheus. Per ulteriori informazioni, consulta [Scraping di ulteriori origini Prometheus e importazione di tali parametri](ContainerInsights-Prometheus-Setup-configure.md).
# Scraping di ulteriori origini Prometheus e importazione di tali parametri
L' CloudWatch agente con monitoraggio Prometheus necessita di due configurazioni per analizzare le metriche di Prometheus. Una è per le configurazioni standard Prometheus come documentato in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) nella documentazione di Prometheus. L'altra è per la configurazione dell'agente. CloudWatch
Per i cluster Amazon EKS, le configurazioni sono definite in `prometheus-eks.yaml` (per il tipo di avvio EC2) o `prometheus-eks-fargate.yaml` (per il tipo di avvio Fargate) come due mappe di configurazione:
+ La sezione `name: prometheus-config` contiene le impostazioni per lo scraping di Prometheus.
+ La `name: prometheus-cwagentconfig` sezione contiene la configurazione per l' CloudWatch agente. Puoi utilizzare questa sezione per configurare la modalità di raccolta delle metriche di Prometheus da. CloudWatch Ad esempio, si specifica in quali metriche importare e si definiscono le relative dimensioni CloudWatch.
Per i cluster Kubernetes in esecuzione su istanze Amazon EC2, le configurazioni sono definite nel file YAML `prometheus-k8s.yaml` come due mappe di configurazione:
+ La sezione `name: prometheus-config` contiene le impostazioni per lo scraping di Prometheus.
+ La `name: prometheus-cwagentconfig` sezione contiene la configurazione per l' CloudWatch agente.
Per acquisire ulteriori fonti di metriche Prometheus e importare tali metriche in, è necessario modificare sia la configurazione dello scrape di Prometheus che la configurazione dell'agente, quindi ridistribuire l'agente con la configurazione aggiornata. CloudWatch CloudWatch
**Requisiti del gruppo di sicurezza VPC**
Le regole di ingresso dei gruppi di sicurezza per i carichi di lavoro Prometheus devono aprire le porte CloudWatch Prometheus all'agente per lo scraping delle metriche di Prometheus tramite l'IP privato.
Le regole di uscita del gruppo di sicurezza per l' CloudWatch agente devono consentire all'agente di connettersi alla CloudWatch porta dei carichi di lavoro Prometheus tramite IP privato.
## Configurazione di Prometheus Scrape
L' CloudWatch agente supporta le configurazioni scrape standard di Prometheus come documentato nella documentazione di Prometheus.[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) È possibile modificare questa sezione per aggiornare le configurazioni già presenti in questo file e aggiungere ulteriori destinazioni di scraping Prometheus. Per impostazione predefinita, il file di configurazione campione contiene le seguenti righe di configurazione globali:
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval**: definisce con quale frequenza recuperare le destinazioni.
+ **scrape\$1timeout**: definisce quanto tempo attendere prima che una richiesta di scrape scada.
È inoltre possibile definire valori diversi per queste impostazioni a livello di processo, per ignorare le configurazioni globali.
### Attività di scraping di Prometheus
Nei file YAML dell' CloudWatch agente sono già configurati alcuni processi di scraping predefiniti. Ad esempio, in `prometheus-eks.yaml`, i processi di scraping predefiniti sono configurati nelle righe `job_name` nella sezione `scrape_configs`. In questo file, la sezione `kubernetes-pod-jmx` predefinita seguente recupera i parametri di JMX Exporter.
```
- job_name: 'kubernetes-pod-jmx'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: labelmap
regex: __meta_kubernetes_pod_label_(.+)
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- source_labels: [__meta_kubernetes_pod_name]
action: replace
target_label: pod_name
- action: replace
source_labels:
- __meta_kubernetes_pod_container_name
target_label: container_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_name
target_label: pod_controller_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_kind
target_label: pod_controller_kind
- action: replace
source_labels:
- __meta_kubernetes_pod_phase
target_label: pod_phase
```
Ciascuno di questi obiettivi predefiniti viene eliminato e le metriche vengono inviate agli eventi di registro utilizzando il formato CloudWatch metrico incorporato. Per ulteriori informazioni, consulta [Incorporamento dei parametri nei log](CloudWatch_Embedded_Metric_Format.md).
Gli eventi di log dei cluster Amazon EKS e Kubernetes vengono archiviati nel gruppo di log **/aws/containerinsights/ /prometheus *cluster\$1name*** in Logs. CloudWatch Gli eventi di log dei cluster Amazon ECS vengono archiviati nel gruppo di log**/aws/ecs/containerinsights/*cluster\$1name*/prometheus.**
Ogni processo di scraping è contenuto in un flusso di log diverso in questo gruppo di log. Ad esempio, il processo di scraping Prometheus `kubernetes-pod-appmesh-envoy` è definito per App Mesh. **Tutte le metriche App Mesh Prometheus dei cluster Amazon EKS e Kubernetes vengono inviate al flusso di log denominato /aws/containerinsights/ >prometheus//. *cluster\$1name* kubernetes-pod-appmesh-envoy**
Per aggiungere una nuova destinazione di scraping, aggiungere una nuova sezione `job_name` alla sezione `scrape_configs` del file YAML e riavviare l'agente. Per un esempio di questo processo, vedere [Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus](#ContainerInsights-Prometheus-Setup-new-exporters).
## CloudWatch configurazione dell'agente per Prometheus
Il file di configurazione CloudWatch dell'agente ha una `prometheus` sezione sotto `metrics_collected` per la configurazione dello scraping di Prometheus. Include le opzioni di configurazione seguenti:
+ **cluster\$1name**: specifica il nome del cluster da aggiungere come etichetta nell'evento log. Questo campo è facoltativo. Se li ometti, l'agente può rilevare il nome del cluster Amazon EKS o Kubernetes.
+ **log\$1group\$1name**: specifica il nome del gruppo di log per i parametri Prometheus sottoposti a scraping. Questo campo è facoltativo. Se lo CloudWatch ometti, utilizza **/aws/containerinsights/ *cluster\$1name* /prometheus** per i log dei cluster Amazon EKS e Kubernetes.
+ **prometheus\$1config\$1path**: specifica il percorso del file di configurazione di scraping di Prometheus. Se il valore di questo campo inizia con `env:`, il contenuto del file di configurazione di scraping di Prometheus verrà recuperato dalla variabile di ambiente del container. Non modificare questo campo.
+ **ecs\$1service\$1discovery**: è la sezione per specificare la configurazione per l'individuazione del servizio Amazon ECS Prometheus. Per ulteriori informazioni, consulta la pagina [Guida dettagliata per l'individuazione automatica dei cluster Amazon ECS](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md).
La sezione `ecs_service_discovery` può contenere i seguenti campi:
+ `sd_frequency` è la frequenza di individuazione degli elementi di esportazione di Prometheus. Specifica un numero e un suffisso di unità. Ad esempio, `1m` per una volta al minuto o `30s` per una volta ogni 30 secondi. I suffissi di unità validi sono `ns`, `us`, `ms`, `s`, `m` e `h`.
Questo campo è facoltativo. Il valore predefinito è 60 secondi (1 minuto).
+ `sd_target_cluster` è il nome del cluster Amazon ECS di destinazione per l'individuazione automatica. Questo campo è facoltativo. L'impostazione predefinita è il nome del cluster Amazon ECS in cui è installato l' CloudWatch agente.
+ `sd_cluster_region` è la regione del cluster Amazon ECS di destinazione. Questo campo è facoltativo. L'impostazione predefinita è la regione del cluster Amazon ECS in cui è installato l' CloudWatch agente.
+ `sd_result_file` è il percorso del file YAML per i risultati di destinazione di Prometheus. La configurazione di scraping di Prometheus farà riferimento a questo file.
+ `docker_label` è una sezione facoltativa che è possibile utilizzare per specificare la configurazione per l'individuazione dei servizi basati su etichette Docker. Se ometti questa sezione, l'individuazione basata sull'etichetta Docker non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_port_label` è il nome dell'etichetta Docker del container che specifica la porta del container per i parametri Prometheus. Il valore predefinito è `ECS_PROMETHEUS_EXPORTER_PORT`. Se il contenitore non ha questa etichetta docker, l' CloudWatch agente la salterà.
+ `sd_metrics_path_label` è il nome dell'etichetta Docker del container che specifica il percorso dei parametri di Prometheus. Il valore predefinito è `ECS_PROMETHEUS_METRICS_PATH`. Se il container non dispone di questa etichetta Docker, l'agente assume il percorso predefinito `/metrics`.
+ `sd_job_name_label` è il nome dell'etichetta Docker del container che specifica il nome del processo di scraping di Prometheus. Il valore predefinito è `job`. Se il contenitore non ha questa etichetta docker, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ `task_definition_list` è una sezione facoltativa che è possibile utilizzare per specificare la configurazione per l'individuazione dei servizi basati sulla definizione dell'attività. Se ometti questa sezione, l'individuazione basata sulla definizione dell'attività non viene utilizzata. Questa sezione può contenere i seguenti campi:
+ `sd_task_definition_arn_pattern` è il modello da utilizzare per specificare le definizioni delle attività Amazon ECS da individuare. Questa è un'espressione regolare.
+ `sd_metrics_ports` elenca gli elementi containerPort per i parametri di Prometheus. Separa gli elementi containerPort con il punto e virgola.
+ `sd_container_name_pattern` specifica i nomi dei container dell'attività di Amazon ECS. Questa è un'espressione regolare.
+ `sd_metrics_path` specifica il percorso del parametro Prometheus. Se ometti questa opzione, l'agente assume il percorso predefinito `/metrics`
+ `sd_job_name` specifica il nome del processo di scraping di Prometheus. Se si omette questo campo, l' CloudWatch agente utilizza il nome del lavoro nella configurazione dello scrape di Prometheus.
+ **metric\$1declaration**: sono sezioni che specificano la matrice di log con formato metrico incorporato da generare. Esistono `metric_declaration` sezioni per ogni sorgente Prometheus da cui l'agente importa per impostazione predefinita CloudWatch . Ciascuna di queste sezioni include i seguenti campi:
+ `label_matcher` è un'espressione regolare che controlla il valore delle etichette elencate in `source_labels`. Le metriche corrispondenti sono abilitate per l'inclusione nel formato metrico incorporato inviato a. CloudWatch
Se sono state specificate più etichette in `source_labels`, ti consigliamo di non utilizzare `^` o caratteri `$` nell'espressione regolare per `label_matcher`.
+ `source_labels` specifica il valore delle etichette controllate dalla riga `label_matcher`.
+ `label_separator` specifica il separatore da utilizzare nella riga ` label_matcher` se sono specificati `source_labels` multipli. Il valore predefinito è `;`. È possibile visualizzare questo valore predefinito utilizzato nella riga `label_matcher` nell'esempio seguente.
+ `metric_selectors` è un'espressione regolare che specifica le metriche da raccogliere e inviare a CloudWatch.
+ `dimensions` è l'elenco delle etichette da utilizzare come dimensioni CloudWatch per ogni metrica selezionata.
Guarda l'esempio `metric_declaration` che segue.
```
"metric_declaration": [
{
"source_labels":[ "Service", "Namespace"],
"label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system",
"dimensions":[
["Service", "Namespace"]
],
"metric_selectors":[
"^coredns_dns_request_type_count_total$"
]
}
]
```
In questo esempio viene configurata una sezione di formato metrica incorporata da inviare come evento di log se sono soddisfatte le seguenti condizioni:
+ Il valore di `Service` contiene `node-exporter` o `kube-dns`.
+ Il valore di `Namespace` è `kube-system`.
+ La metrica Prometheus `coredns_dns_request_type_count_total` contiene le etichette sia `Service` che `Namespace`.
L'evento di log inviato include la seguente sezione evidenziata:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"coredns_dns_request_type_count_total"
}
],
"Dimensions":[
[
"Namespace",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"Namespace":"kube-system",
"Service":"kube-dns",
"coredns_dns_request_type_count_total":2562,
"eks_amazonaws_com_component":"kube-dns",
"instance":"192.168.61.254:9153",
"job":"kubernetes-service-endpoints",
...
}
```
## Esercitazione per l'aggiunta di nuove destinazioni di scraping di Prometheus: parametri del server API Prometheus
Kubernetes API Server espone le metriche Prometheus sugli endpoint per impostazione predefinita. L'esempio ufficiale per la configurazione di scraping Kubernetes API Server è disponibile su [Github](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml).
La seguente esercitazione mostra come eseguire le seguenti operazioni per iniziare a importare le metriche di Kubernetes API Server in CloudWatch:
+ Aggiungere la configurazione di scraping Prometheus per Kubernetes API Server al file YAML dell'agente. CloudWatch
+ Configurazione delle definizioni delle metriche in formato metrico incorporato nel file YAML dell'agente. CloudWatch
+ (Facoltativo) Creazione di una CloudWatch dashboard per le metriche del Kubernetes API Server.
**Nota**
Kubernetes API Server espone le metriche misuratore, contatore, istogramma e riepilogo. In questa versione del supporto alle metriche di Prometheus CloudWatch , importa solo le metriche con i tipi gauge, counter e summary.
**Per iniziare a raccogliere le metriche di Kubernetes API Server Prometheus in CloudWatch**
1. Scaricare la versione più recente del file `prometheus-eks.yaml`, `prometheus-eks-fargate.yaml` o `prometheus-k8s.yaml` immettendo uno dei seguenti comandi.
Per un cluster Amazon EKS con tipo di avvio EC2, immetti il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, immetti il seguente comando:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml
```
Per un cluster Kubernetes in esecuzione su un'istanza Amazon EC2, inserisci il comando seguente:
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml
```
1. Apri il file con un editor di testo, trova la sezione `prometheus-config` e aggiungi la sezione seguente all'interno di tale sezione. Salvare quindi le modifiche:
```
# Scrape config for API servers
- job_name: 'kubernetes-apiservers'
kubernetes_sd_configs:
- role: endpoints
namespaces:
names:
- default
scheme: https
tls_config:
ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
insecure_skip_verify: true
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
relabel_configs:
- source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
action: keep
regex: kubernetes;https
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- action: replace
source_labels:
- __meta_kubernetes_service_name
target_label: Service
```
1. Mentre hai ancora il file YAML aperto nell'editor di testo, trova la sezione `cwagentconfig.json`. Aggiungi la seguente sottosezione e salva le modifiche. Questa sezione inserisce le metriche del server API nell'elenco degli agenti consentiti. CloudWatch All'elenco degli agenti consentiti vengono aggiunti tre tipi di parametri del server API:
+ Conteggi di oggetti etcd
+ Metriche del controller di registrazione del server API
+ Metriche delle richieste del server API
```
{"source_labels": ["job", "resource"],
"label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
"dimensions": [["ClusterName","Service","resource"]],
"metric_selectors": [
"^etcd_object_counts$"
]
},
{"source_labels": ["job", "name"],
"label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
"dimensions": [["ClusterName","Service","name"]],
"metric_selectors": [
"^workqueue_depth$",
"^workqueue_adds_total$",
"^workqueue_retries_total$"
]
},
{"source_labels": ["job","code"],
"label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
"dimensions": [["ClusterName","Service","code"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
{"source_labels": ["job"],
"label_matcher": "^kubernetes-apiservers",
"dimensions": [["ClusterName","Service"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
```
1. Se l' CloudWatch agente con supporto Prometheus è già distribuito nel cluster, devi eliminarlo inserendo il seguente comando:
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Distribuisci l' CloudWatch agente con la configurazione aggiornata immettendo uno dei seguenti comandi. Per un cluster Amazon EKS con tipo di avvio EC2, inserisci:
```
kubectl apply -f prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, immetti il seguente comando. Sostituisci *MyCluster* e *region* con i valori corrispondenti alla tua distribuzione.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Per un cluster Kubernetes, immetti il seguente comando. Sostituisci *MyCluster* e *region* con valori adatti alla tua implementazione.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
**Dopo averlo fatto, dovresti vedere un nuovo flusso di log chiamato **kubernetes-apiservers nel gruppo di log /aws/containerinsights/** /prometheus. *cluster\$1name*** Questo flusso di log deve includere eventi log con una definizione del formato del parametro incorporata come la seguente:
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"apiserver_request_total"
}
],
"Dimensions":[
[
"ClusterName",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"ClusterName":"my-cluster-name",
"Namespace":"default",
"Service":"kubernetes",
"Timestamp":"1592267020339",
"Version":"0",
"apiserver_request_count":0,
"apiserver_request_total":0,
"code":"0",
"component":"apiserver",
"contentType":"application/json",
"instance":"192.0.2.0:443",
"job":"kubernetes-apiservers",
"prom_metric_type":"counter",
"resource":"pods",
"scope":"namespace",
"verb":"WATCH",
"version":"v1"
}
```
Puoi visualizzare le tue metriche nella CloudWatch console nel namespace **ContainerInsights/Prometheus.** Facoltativamente, puoi anche creare una CloudWatch dashboard per le metriche del server API Prometheus Kubernetes.
### (Facoltativo) Creazione di un pannello di controllo per i parametri del server API di Kubernetes
Per visualizzare le metriche del server API Kubernetes nel dashboard, è necessario prima aver completato i passaggi nelle sezioni precedenti per iniziare a raccogliere queste metriche in CloudWatch.
**Per creare un pannello di controllo per i parametri del server API Kubernetes**
1. CloudWatch Apri [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)la console all'indirizzo.
1. Assicurati di aver selezionato la AWS regione corretta.
1. Nel pannello di navigazione seleziona **Dashboards** (Pannelli di controllo).
1. Scegli **Crea pannello di controllo)**. Immetti un nome per il nuovo dashboard e scegli **Crea dashboard**.
1. In **Add to this dashboard** (Aggiungi a questo pannello di controllo), scegli **Cancel** (Annulla).
1. Seleziona **Actions (Operazioni)**, **View/edit source (Visualizza/modifica origine)**.
1. Scaricare il seguente file JSON: [origine del pannello di controllo API Kubernetes](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/kubernetes_api_server/cw_dashboard_kubernetes_api_server.json).
1. Apri il file JSON scaricato con un editor di testo e apporta le seguenti modifiche:
+ Sostituire tutte le stringhe `{{YOUR_CLUSTER_NAME}}` con il nome esatto del cluster. Assicurarti di non aggiungere spazi bianchi prima o dopo il testo.
+ Sostituisci tutte le stringhe `{{YOUR_AWS_REGION}}` con il nome della regione in cui vengono raccolti i parametri. Ad esempio, `us-west-2`. Assicurarti di non aggiungere spazi bianchi prima o dopo il testo.
1. Copiare l'intero BLOB JSON e incollarlo nella casella di testo nella console CloudWatch, sostituendo ciò che è già presente nella casella.
1. Scegli **Update** (Aggiorna), **Save dashboard** (Salva pannello di controllo).
# (Facoltativo) Impostazione dei carichi di lavoro Amazon EKS containerizzati di esempio per i test dei parametri di Prometheus
Per testare il supporto delle metriche Prometheus CloudWatch in Container Insights, puoi configurare uno o più dei seguenti carichi di lavoro containerizzati. L' CloudWatch agente con supporto Prometheus raccoglie automaticamente le metriche da ciascuno di questi carichi di lavoro. Per visualizzare le metriche raccolte per impostazione predefinita, vedere [Metriche di Prometheus raccolte dall'agente CloudWatch](ContainerInsights-Prometheus-metrics.md).
Prima di installare uno qualsiasi di questi carichi di lavoro, è necessario installare Helm 3.x immettendo i seguenti comandi:
```
brew install helm
```
Per ulteriori informazioni, consulta la pagina [Helm](https://helm.sh).
**Topics**
+ [Configura un carico AWS App Mesh di lavoro di esempio per Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md)
+ [Configurazione di NGINX con traffico di esempio su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-nginx.md)
+ [Impostazione di memcached con un esportatore di parametri su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-memcached.md)
+ [Configura un carico Java/JMX di lavoro di esempio su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md)
+ [Configura HAProxy con un esportatore di metriche su Amazon EKS e Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md)
+ [Esercitazione per l'aggiunta di una nuova destinazione di scraping di Prometheus: Redis OSS su Amazon EKS e cluster Kubernetes](ContainerInsights-Prometheus-Setup-redis-eks.md)
# Configura un carico AWS App Mesh di lavoro di esempio per Amazon EKS e Kubernetes
Il supporto di Prometheus nei supporti di Container Insights. CloudWatch AWS App Mesh Nelle sezioni seguenti viene illustrato come configurare App Mesh.
**Topics**
+ [Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di avvio EC2 o un cluster Kubernetes](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md)
+ [Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di lancio Fargate](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md)
# Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di avvio EC2 o un cluster Kubernetes
Segui queste istruzioni se stai configurando App Mesh su un cluster che esegue Amazon EKS con il tipo di avvio EC2 o un cluster Kubernetes.
## Configurazione delle autorizzazioni IAM
Devi aggiungere la **AWSAppMeshFullAccess**policy al ruolo IAM per il tuo gruppo di nodi Amazon EKS o Kubernetes. Su Amazon EKS, il nome del gruppo di nodi è simile a `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL`. Su Kubernetes, potrebbe sembrare simile a `nodes.integ-test-kops-prometheus.k8s.local`.
## Installazione di App Mesh
Per installare il controller App Mesh Kubernetes, segui le istruzioni in [Controller di App Mesh](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller).
## Installazione di un'applicazione di esempio
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)contiene diverse procedure dettagliate per Kubernetes App Mesh. Per questa esercitazione, installerai un'applicazione a colori di esempio che mostra come i routing http possono utilizzare le intestazioni per la corrispondenza delle richieste in arrivo.
**Per utilizzare un'applicazione App Mesh di esempio per testare Container Insights**
1. Installa l'applicazione seguendo queste istruzioni: [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers).
1. Avvia un pod curler per generare traffico:
```
kubectl -n default run -it curler --image=tutum/curl /bin/bash
```
1. Esegui il curl diversi endpoint modificando le intestazioni HTTP. Esegui il comando curl più volte, come illustrato:
```
curl -H "color_header: blue" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: red" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: yellow" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
```
1. CloudWatch Apri la console [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)all'indirizzo.
1. Nella AWS regione in cui è in esecuzione il cluster, scegli **Metriche** nel riquadro di navigazione. La metrica si trova nello spazio dei nomi **ContainerInsights/Prometheus.**
1. **Per visualizzare gli eventi di CloudWatch Logs, scegli Log groups nel riquadro di navigazione.** Gli eventi si trovano nel gruppo di log ` /aws/containerinsights/your_cluster_name/prometheus ` nel flusso di log `kubernetes-pod-appmesh-envoy`.
## Eliminazione dell'ambiente di test di App Mesh
Al termine dell'utilizzo di App Mesh e dell'applicazione di esempio, utilizza i seguenti comandi per eliminare le risorse non necessarie. Elimina l'applicazione di esempio immettendo il seguente comando:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/
kubectl delete -f _output/manifest.yaml
```
Elimina il controller App Mesh immettendo il seguente comando:
```
helm delete appmesh-controller -n appmesh-system
```
# Configura un carico di lavoro di AWS App Mesh esempio su un cluster Amazon EKS con il tipo di lancio Fargate
Segui queste istruzioni se stai configurando App Mesh su un cluster che esegue Amazon EKS con il tipo di avvio Fargate.
## Configurazione delle autorizzazioni IAM
Per impostare le autorizzazioni IAM, immetti il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
## Installazione di App Mesh
Per installare il controller App Mesh Kubernetes, segui le istruzioni in [Controller di App Mesh](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller). Assicurati di seguire le istruzioni per Amazon EKS con il tipo di avvio Fargate.
## Installazione di un'applicazione di esempio
[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)contiene diverse procedure dettagliate per Kubernetes App Mesh. Per questa esercitazione, installerai un'applicazione a colori di esempio che funziona per i cluster Amazon EKS con il tipo di avvio Fargate.
**Per utilizzare un'applicazione App Mesh di esempio per testare Container Insights**
1. Installa l'applicazione seguendo queste istruzioni: [https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate).
Queste istruzioni presuppongono che tu stia creando un nuovo cluster con il profilo Fargate corretto. Se si desidera utilizzare un cluster Amazon EKS già configurato, puoi utilizzare i seguenti comandi per configurare tale cluster per questa dimostrazione. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
```
eksctl create fargateprofile --cluster MyCluster \
--namespace howto-k8s-fargate --name howto-k8s-fargate
```
1. Esegui il port forwarding dell'implementazione dell'applicazione front:
```
kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080
```
1. Esegui il curl dell'App front:
```
while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done
```
1. CloudWatch Apri la console [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)all'indirizzo.
1. Nella AWS regione in cui è in esecuzione il cluster, scegli **Metriche** nel riquadro di navigazione. La metrica si trova nello spazio dei nomi **ContainerInsights/Prometheus.**
1. **Per visualizzare gli eventi di CloudWatch Logs, scegli Log groups nel riquadro di navigazione.** Gli eventi si trovano nel gruppo di log ` /aws/containerinsights/your_cluster_name/prometheus ` nel flusso di log `kubernetes-pod-appmesh-envoy`.
## Eliminazione dell'ambiente di test di App Mesh
Al termine dell'utilizzo di App Mesh e dell'applicazione di esempio, utilizza i seguenti comandi per eliminare le risorse non necessarie. Elimina l'applicazione di esempio immettendo il seguente comando:
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/
kubectl delete -f _output/manifest.yaml
```
Elimina il controller App Mesh immettendo il seguente comando:
```
helm delete appmesh-controller -n appmesh-system
```
# Configurazione di NGINX con traffico di esempio su Amazon EKS e Kubernetes
NGINX è un server web che può essere utilizzato anche come load balancer e proxy inverso. Per ulteriori informazioni sul modo in cui Kubernetes utilizza NGINX per ingresso, consulta [kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx).
**Per installare Ingress-NGINX con un servizio di traffico di esempio per testare il supporto di Container Insights Prometheus**
1. Immetti il seguente comando per aggiungere il repository Helm ingress-nginx:
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
```
1. Eseguire i comandi seguenti:
```
kubectl create namespace nginx-ingress-sample
helm install my-nginx ingress-nginx/ingress-nginx \
--namespace nginx-ingress-sample \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="10254" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. Verificare se i servizi sono stati avviati correttamente immettendo il seguente comando:
```
kubectl get service -n nginx-ingress-sample
```
L'output di questo comando dovrebbe visualizzare diverse colonne, inclusa una colonna `EXTERNAL-IP`.
1. Impostare una variabile `EXTERNAL-IP` sul valore della colonna `EXTERNAL-IP` nella riga del controller di ingresso NGINX.
```
EXTERNAL_IP=your-nginx-controller-external-ip
```
1. Avviare un esempio di traffico NGINX inserendo il seguente comando.
```
SAMPLE_TRAFFIC_NAMESPACE=nginx-sample-traffic
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/nginx-traffic/nginx-traffic-sample.yaml |
sed "s/{{external_ip}}/$EXTERNAL_IP/g" |
sed "s/{{namespace}}/$SAMPLE_TRAFFIC_NAMESPACE/g" |
kubectl apply -f -
```
1. Immetti il comando seguente per verificare che tutti e tre i pod siano nello stato `Running`.
```
kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE
```
Se sono in esecuzione, dovresti presto vedere le metriche nello spazio dei nomi **ContainerInsights/Prometheus.**
**Per disinstallare NGINX e l'applicazione di traffico di esempio**
1. Eliminare il servizio traffico di esempio immettendo il seguente comando:
```
kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE
```
1. Elimina l'uscita NGINX in base al nome della versione di Helm.
```
helm uninstall my-nginx --namespace nginx-ingress-sample
kubectl delete namespace nginx-ingress-sample
```
# Impostazione di memcached con un esportatore di parametri su Amazon EKS e Kubernetes
memcached è un sistema di memorizzazione nella cache di oggetti di memoria open source. Per ulteriori informazioni, consulta la pagina [Cos'è Memcached?](https://www.memcached.org).
Se esegui memcached in un cluster con il tipo di avvio Fargate, devi impostare un profilo Fargate prima di eseguire la procedura descritta. Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace memcached-sample --name memcached-sample
```
**Per installare memcached con un esportatore di metriche per testare il supporto di Container Insights Prometheus**
1. Inserisci il seguente comando per aggiungere il repository:
```
helm repo add bitnami https://charts.bitnami.com/bitnami
```
1. Immetti il seguente comando per creare un nuovo spazio di nomi:
```
kubectl create namespace memcached-sample
```
1. Immetti il seguente comando per installare Memcached
```
helm install my-memcached bitnami/memcached --namespace memcached-sample \
--set metrics.enabled=true \
--set-string serviceAnnotations.prometheus\\.io/port="9150" \
--set-string serviceAnnotations.prometheus\\.io/scrape="true"
```
1. Immetti il comando seguente per confermare l'annotazione del servizio in esecuzione:
```
kubectl describe service my-memcached-metrics -n memcached-sample
```
Dovresti vedere le due annotazioni seguenti:
```
Annotations: prometheus.io/port: 9150
prometheus.io/scrape: true
```
**Per disinstallare memcached**
+ Eseguire i comandi seguenti:
```
helm uninstall my-memcached --namespace memcached-sample
kubectl delete namespace memcached-sample
```
# Configura un carico Java/JMX di lavoro di esempio su Amazon EKS e Kubernetes
JMX Exporter è un esportatore ufficiale di Prometheus che può recuperare ed esporre JMX mBeans JMX come metriche Prometheus. Per ulteriori informazioni, vedere [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter).
Container Insights può raccogliere metriche Prometheus predefinite da Java Virtual Machine (JVM), Java e Tomcat (Catalina) utilizzando JMX Exporter.
## Configurazione predefinita dello scraping di Prometheus
Per impostazione predefinita, l' CloudWatch agente con supporto Prometheus analizza i parametri Java/JMX Prometheus da ogni pod in un cluster Amazon EKS o Kubernetes. `http://CLUSTER_IP:9404/metrics` Questo avviene mediante l'individuazione di `role: pod` di `kubernetes_sd_config` Prometheus. 9404 è la porta predefinita allocata per JMX Exporter da Prometheus. Per ulteriori informazioni sull'individuazione di `role: pod`, consulta [pod](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod). È possibile configurare JMX Exporter per esporre le metriche su una porta o metrics\$1path diverso. Se modifichi la porta o il percorso, aggiorna il jmx scrape\$1config predefinito nella mappa di configurazione dell'agente. CloudWatch Esegui il seguente comando per ottenere la configurazione corrente dell' CloudWatch agente Prometheus:
```
kubectl describe cm prometheus-config -n amazon-cloudwatch
```
I campi da modificare sono i campi `/metrics` e `regex: '.*:9404$'`, come evidenziato nell'esempio seguente.
```
job_name: 'kubernetes-jmx-pod'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: replace
regex: (.+)
source_labels:
```
## Altra configurazione di scraping di Prometheus
Se esponi la tua applicazione in esecuzione su un set di pod con esportatori Java/JMX Prometheus da un servizio Kubernetes, puoi anche passare all'uso dell'individuazione di `role: service` o all'individuazione di `role: endpoint` di `kubernetes_sd_config` Prometheus. Per ulteriori informazioni su questi metodi di individuazione, consulta [service](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service) (servizio), [ endpoints](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints) (endpoint) e [ .](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config).
Queste due modalità di individuazione dei servizi forniscono altre meta etichette che potrebbero essere utili per creare le dimensioni delle CloudWatch metriche. Ad esempio, puoi rietichettare `__meta_kubernetes_service_name` con `Service` e includerlo nella dimensione dei tuoi parametri. Per ulteriori informazioni sulla personalizzazione delle CloudWatch metriche e delle relative dimensioni, consulta. [CloudWatch configurazione dell'agente per Prometheus](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config)
## Immagine Docker con JMX Exporter
Successivamente, crea un'immagine Docker. Le sezioni seguenti forniscono due file Docker di esempio.
Dopo aver creato l'immagine, caricarla in Amazon EKS o Kubernetes, quindi eseguire il comando seguente per verificare che i parametri Prometheus siano esposte da `JMX_EXPORTER` sulla porta 9404. *\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD*Sostituiscilo con il nome del pod in esecuzione e sostituiscilo *\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* con lo spazio dei nomi dell'applicazione.
Se esegui JMX Exporter in un cluster con il tipo di avvio Fargate, devi anche impostare un profilo Fargate prima di eseguire la procedura descritta. Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $JAR_SAMPLE_TRAFFIC_NAMESPACE\
--name $JAR_SAMPLE_TRAFFIC_NAMESPACE
```
```
kubectl exec $JAR_SAMPLE_TRAFFIC_POD -n $JARCAT_SAMPLE_TRAFFIC_NAMESPACE -- curl http://localhost:9404
```
## Esempio: immagine Docker Apache Tomcat con parametri Prometheus
Il server Apache Tomcat espone JMX mBeans per impostazione predefinita. È possibile integrare JMX Exporter con Tomcat per esporre JMX mBeans come metriche Prometheus. L'esempio seguente di file Docker mostra i passaggi per creare un'immagine di prova:
```
# From Tomcat 9.0 JDK8 OpenJDK
FROM tomcat:9.0-jdk8-openjdk
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
COPY ./setenv.sh /usr/local/tomcat/bin
COPY your web application.war /usr/local/tomcat/webapps/
RUN chmod o+x /usr/local/tomcat/bin/setenv.sh
ENTRYPOINT ["catalina.sh", "run"]
```
Nell'elenco seguente vengono illustrate le quattro righe `COPY` di questo file Docker.
+ [Scarica il file jar JMX Exporter più recente da jmx\$1exporter. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter)
+ `config.yaml` è il file di configurazione JMX Exporter. [Per ulteriori informazioni, vedere jmx\$1exporter \$1Configuration. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter#Configuration )
Ecco un file di configurazione di esempio per Java e Tomcat:
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `setenv.sh` è uno script di startup Tomcat per avviare JMX exporter insieme a Tomcat ed esporre le metriche di Prometheus sulla porta 9404 del localhost. Fornisce inoltre al JMX Exporter il percorso del file `config.yaml`.
```
$ cat setenv.sh
export JAVA_OPTS="-javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml $JAVA_OPTS"
```
+ il tuo web application .war è il tuo file `war` dell'applicazione web che Tomcat deve caricare.
Crea un'immagine docker con questa configurazione e caricala in un repository di immagini.
## Esempio: immagine Docker dell'applicazione Java Jar con parametri Prometheus
L'esempio seguente di file Docker mostra i passaggi per creare un'immagine di prova:
```
# Alpine Linux with OpenJDK JRE
FROM openjdk:8-jre-alpine
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./SampleJavaApplication-1.0-SNAPSHOT.jar /opt/jmx_exporter
COPY ./start_exporter_example.sh /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
RUN chmod -R o+x /opt/jmx_exporter
RUN apk add curl
ENTRYPOINT exec /opt/jmx_exporter/start_exporter_example.sh
```
Nell'elenco seguente vengono illustrate le quattro righe `COPY` di questo file Docker.
+ [Scarica il file jar JMX Exporter più recente da jmx\$1exporter. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter)
+ `config.yaml` è il file di configurazione JMX Exporter. [Per ulteriori informazioni, vedere jmx\$1exporter \$1Configuration. https://github.com/prometheus/](https://github.com/prometheus/jmx_exporter#Configuration )
Ecco un file di configurazione di esempio per Java e Tomcat:
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `start_exporter_example.sh` è lo script per avviare l'applicazione JAR con le metriche Prometheus esportate. Fornisce inoltre al JMX Exporter il percorso del file `config.yaml`.
```
$ cat start_exporter_example.sh
java -javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml -cp /opt/jmx_exporter/SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App
```
+ SampleJavaApplication-1.0-Snapshot.jar è il file jar dell'applicazione Java di esempio. Sostituirlo con l'applicazione Java che si desidera monitorare.
Crea un'immagine docker con questa configurazione e caricala in un repository di immagini.
# Configura HAProxy con un esportatore di metriche su Amazon EKS e Kubernetes
HAProxy è un'applicazione proxy open source. Per ulteriori informazioni, consulta [HAProxy](https://www.haproxy.org).
Se si utilizza un cluster con il tipo di avvio Fargate, è necessario configurare un profilo Fargate prima di eseguire i passaggi di questa procedura. HAProxy Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace haproxy-ingress-sample --name haproxy-ingress-sample
```
**Da installare HAProxy con un esportatore di metriche per testare il supporto Prometheus di Container Insights**
1. Immetti il seguente comando per aggiungere il repository dell'incubatore di Helm:
```
helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts
```
1. Immetti il seguente comando per creare un nuovo spazio di nomi:
```
kubectl create namespace haproxy-ingress-sample
```
1. Inserisci i seguenti comandi per l'installazione: HAProxy
```
helm install haproxy haproxy-ingress/haproxy-ingress \
--namespace haproxy-ingress-sample \
--set defaultBackend.enabled=true \
--set controller.stats.enabled=true \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="9101" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. Immetti il seguente comando per confermare l'annotazione del servizio:
```
kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample
```
Dovresti vedere le annotazioni seguenti.
```
Annotations: prometheus.io/port: 9101
prometheus.io/scrape: true
```
**Per disinstallare HAProxy**
+ Eseguire i comandi seguenti:
```
helm uninstall haproxy --namespace haproxy-ingress-sample
kubectl delete namespace haproxy-ingress-sample
```
# Esercitazione per l'aggiunta di una nuova destinazione di scraping di Prometheus: Redis OSS su Amazon EKS e cluster Kubernetes
Questa esercitazione offre un'introduzione pratica per recuperare le metriche Prometheus di un'applicazione Redis OSS di esempio su Amazon EKS e Kubernetes. Redis OSS (https://redis.io/) è uno store di strutture dati open source (con licenza BSD), in memoria, utilizzato come database, cache e broker di messaggi. Per ulteriori informazioni, consulta la pagina [redis](https://redis.io/).
redis\$1exporter (con licenza MIT Licence) viene utilizzato per esporre le metriche Prometheus di Redis OSS sulla porta specificata (predefinita: 0.0.0.0:9121). Per ulteriori informazioni, consulta la pagina [redis\$1exporter](https://github.com/oliver006/redis_exporter).
In questa esercitazione vengono utilizzate le immagini Docker nei due repository Docker Hub seguenti:
+ [ redis](https://hub.docker.com/_/redis?tab=description)
+ [redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Per installare un carico di lavoro Redis OSS di esempio che espone le metriche Prometheus**
1. Imposta il namespace per il carico di lavoro Redis OSS di esempio.
```
REDIS_NAMESPACE=redis-sample
```
1. Se esegui Redis OSS in un cluster con il tipo di avvio Fargate, devi impostare un profilo Fargate. Per impostare il profilo, inserisci il comando seguente. Sostituisci *MyCluster* con il nome del cluster.
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE
```
1. Inserisci il comando seguente per installare il carico di lavoro Redis OSS di esempio.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml \
| sed "s/{{namespace}}/$REDIS_NAMESPACE/g" \
| kubectl apply -f -
```
1. L'installazione include un servizio denominato `my-redis-metrics` che espone la metrica Prometheus di Redis OSS sulla porta 9121 Inserisci il seguente comando per ottenere informazioni sul servizio:
```
kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE
```
Nella `Annotations` sezione dei risultati, vedrai due annotazioni che corrispondono alla configurazione dello scrape Prometheus dell'agente, in modo che possa rilevare automaticamente CloudWatch i carichi di lavoro:
```
prometheus.io/port: 9121
prometheus.io/scrape: true
```
La configurazione di scraping di Prometheus correlata è disponibile nella sezione `- job_name: kubernetes-service-endpoints` di `kubernetes-eks.yaml` o `kubernetes-k8s.yaml`.
**Per iniziare a raccogliere le metriche di Redis OSS Prometheus in CloudWatch**
1. Scaricare la versione più recente del file `kubernetes-eks.yaml` o `kubernetes-k8s.yaml` immettendo uno dei seguenti comandi. Per un cluster Amazon EKS con tipo di avvio EC2, inserisci questo comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, inserisci questo comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml
```
Per un cluster Kubernetes in esecuzione su un'istanza Amazon EC2, inserisci questo comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml
```
1. Apri il file con un editor di testo e trova la sezione `cwagentconfig.json`. Aggiungi la seguente sottosezione e salva le modifiche. Assicurati che il rientro segua il modello esistente.
```
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName"]],
"metric_selectors": [
"^redis_net_(in|out)put_bytes_total$",
"^redis_(expired|evicted)_keys_total$",
"^redis_keyspace_(hits|misses)_total$",
"^redis_memory_used_bytes$",
"^redis_connected_clients$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
La sezione che hai aggiunto inserisce le metriche Redis OSS nell'elenco degli agenti consentiti. CloudWatch Per l'elenco di questi parametri, consulta la sezione seguente.
1. Se l' CloudWatch agente con supporto Prometheus è già distribuito in questo cluster, è necessario eliminarlo immettendo il seguente comando.
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. Distribuisci l' CloudWatch agente con la configurazione aggiornata immettendo uno dei seguenti comandi. Sostituisci *MyCluster* e *region* abbina le tue impostazioni.
Per un cluster Amazon EKS con tipo di avvio EC2, inserisci questo comando.
```
kubectl apply -f prometheus-eks.yaml
```
Per un cluster Amazon EKS con tipo di avvio Fargate, inserisci questo comando.
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Per un cluster Kubernetes, inserisci il seguente comando.
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
## Visualizzazione delle metriche Prometheus di Redis OSS
Questo tutorial invia le seguenti metriche allo spazio dei nomi **ContainerInsights/Prometheus** in. CloudWatch Puoi usare la CloudWatch console per visualizzare le metriche in quel namespace.
| Nome parametro | Dimensioni |
| --- | --- |
| `redis_net_input_bytes_total` | ClusterName, `Namespace` |
| `redis_net_output_bytes_total` | ClusterName, `Namespace` |
| `redis_expired_keys_total` | ClusterName, `Namespace` |
| `redis_evicted_keys_total` | ClusterName, `Namespace` |
| `redis_keyspace_hits_total` | ClusterName, `Namespace` |
| `redis_keyspace_misses_total` | ClusterName, `Namespace` |
| `redis_memory_used_bytes` | ClusterName, `Namespace` |
| `redis_connected_clients` | ClusterName, `Namespace` |
| `redis_commands_total` | ClusterName,, cmd `Namespace` |
| `redis_db_keys` | ClusterName, `Namespace` db |
**Nota**
Il valore della dimensione **cmd** può essere `append`, `client`, `command`, `config`, `dbsize`, `flushall`, `get`, `incr`, `info`, `latency` o `slowlog`.
Il valore della dimensione **db** può essere da `db0` a `db15`.
Puoi anche creare una CloudWatch dashboard per le metriche di Redis OSS Prometheus.
**Per creare un pannello di controllo per le metriche Prometheus di Redis OSS**
1. Crea variabili di ambiente, sostituendo i valori sotto in modo che corrispondano all'implementazione.
```
DASHBOARD_NAME=your_cw_dashboard_name
REGION_NAME=your_metric_region_such_as_us-east-1
CLUSTER_NAME=your_k8s_cluster_name_here
NAMESPACE=your_redis_service_namespace_here
```
1. Inserisci il seguente comando per creare il pannello di controllo.
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
```