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à.
# (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" \
```