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à.
# Installazione del carico di lavoro di esempio del proxy inverso NGINX per cluster Amazon ECS
L'esportatore NGINX Prometheus può sottoporre a scraping ed esporre i dati NGINX come parametri Prometheus. Questo esempio utilizza l'esportatore in tandem con il servizio proxy inverso NGINX per Amazon ECS.
Per ulteriori informazioni sull'esportatore NGINX Prometheus, vedi su Github. [ nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) Per ulteriori informazioni sul reverse proxy NGINX, vedi su Github. [ ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)
L' CloudWatch agente con supporto Prometheus analizza i parametri di NGINX Prometheus in base alla configurazione del service discovery nel cluster Amazon ECS. È possibile configurare NGINX dell'esportatore Prometheus per esporre i parametri su una porta o percorso diverso. Se modifichi la porta o il percorso, aggiorna la sezione nel file di configurazione dell'agente. `ecs_service_discovery` CloudWatch
## Installazione del carico di lavoro di esempio del proxy inverso NGINX per cluster Amazon ECS
Procedi come segue per installare il carico di lavoro di esempio del proxy inverso NGINX.
### Creazione delle immagini Docker
**Per creare le immagini Docker per il carico di lavoro di esempio del proxy inverso NGINX**
1. [Scarica la seguente cartella dal repository reverse proxy di NGINX: https://github.com/awslabs/ecs-nginx-reverse-proxy/-proxy/. tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
1. Trova la directory `app` e crea un'immagine da quella directory:
```
docker build -t web-server-app ./path-to-app-directory
```
1. Crea un'immagine personalizzata per NGINX. Innanzitutto, crea una directory con i due file seguenti:
+ Un file Docker di esempio:
```
FROM nginx
COPY nginx.conf /etc/nginx/nginx.conf
```
+ [Un `nginx.conf` file, modificato da/-proxy/: https://github.com/awslabs/ ecs-nginx-reverse-proxy tree/master/reverse](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
server{
listen 8080;
location /stub_status {
stub_status on;
}
}
server {
listen 80;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://app:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
**Nota**
`stub_status` deve essere abilitato nella stessa porta da cui `nginx-prometheus-exporter` è configurato per eseguire lo scraping dei parametri. Nella nostra definizione di attività di esempio, `nginx-prometheus-exporter` è configurato per eseguire lo scraping dei parametri dalla porta 8080.
1. Crea un'immagine dai file nella tua nuova directory:
```
docker build -t nginx-reverse-proxy ./path-to-your-directory
```
1. Carica le nuove immagini in un repository di immagini per utilizzarle in un secondo momento.
### Creazione della definizione dell'attività per eseguire NGINX e l'app del server Web in Amazon ECS
Successivamente, imposta la definizione dell'attività.
Questa definizione dell'attività consente la raccolta e l'esportazione deli parametri Prometheus NGINX. Il container NGINX tiene traccia dell'input dall'app ed espone tali dati alla porta 8080, come impostato in `nginx.conf`. Il contenitore NGINX prometheus exporter analizza queste metriche e le invia alla porta 9113, per utilizzarle in. CloudWatch
**Per impostare la definizione dell'attività per il carico di lavoro Amazon ECS di NGINX di esempio**
1. Crea un file JSON di definizione dell'attività con il seguente contenuto. *your-customized-nginx-iamge*Sostituiscila con l'URI dell'immagine per la tua immagine NGINX personalizzata e *your-web-server-app-image* sostituiscila con l'URI dell'immagine per l'immagine dell'app del server web.
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 256,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.scrape-uri",
"http://nginx:8080/stub_status"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-sample-stack"
}
```
1. Registra la definizione dell'attività inserendo il seguente comando.
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. Crea un servizio per eseguire l'attività inserendo il seguente comando:
Assicurati di non modificare il nome del servizio. Eseguiremo un servizio CloudWatch agente utilizzando una configurazione che cerca le attività utilizzando i modelli di nomi dei servizi che le hanno avviate. Ad esempio, per consentire all' CloudWatch agente di trovare l'attività avviata da questo comando, è possibile specificare il valore di `sd_service_name_pattern` to be`^nginx-service$`. La sezione successiva offre ulteriori dettagli.
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-service \
--task-definition nginx-sample-stack:1 \
--desired-count 1
```
### Configura l' CloudWatch agente per acquisire le metriche di NGINX Prometheus
Il passaggio finale consiste nel configurare l'agente per l'analisi delle metriche NGINX CloudWatch . In questo esempio, l' CloudWatch agente rileva l'attività tramite il modello del nome del servizio e la porta 9113, dove l'esportatore espone le metriche di Prometheus per NGINX. Una volta individuata l'attività e disponibili le metriche, l'agente inizia a pubblicare le metriche raccolte nel CloudWatch flusso di log. **nginx-prometheus-exporter**
**Per configurare l' CloudWatch agente per l'analisi delle metriche NGINX**
1. Scarica la versione più recente del file YAML necessario immettendo il seguente comando.
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. Apri il file con un editor di testo e trova la configurazione completa dell' CloudWatch agente nella chiave della sezione. `value` `resource:CWAgentConfigSSMParameter` Quindi, nella sezione `ecs_service_discovery` aggiungi la seguente sezione `service_name_list_for_tasks`.
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-service$"
}
],
```
1. Nello stesso file aggiungi la sezione seguente nella sezione `metric_declaration` per consentire i parametri NGINX. Assicurati di seguire il modello di rientro esistente.
```
{
"source_labels": ["job"],
"label_matcher": ".*nginx.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginx_.*$"
]
},
```
1. Se l' CloudWatch agente non è già distribuito in questo cluster, vai al passaggio 8.
Se hai già distribuito l' CloudWatch agente nel cluster Amazon ECS utilizzando AWS CloudFormation, puoi creare un set di modifiche inserendo i seguenti comandi:
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-scraping-support
```
1. [Apri la CloudFormation console in /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Rivedi il changeset appena creato. **nginx-scraping-support** Dovresti vedere una modifica applicata alla risorsa **CWAgentConfig. SSMParameter** Esegui il changeset e riavvia l'attività dell' CloudWatch agente inserendo il seguente comando:
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Attendi circa 10 secondi e inserisci il comando seguente.
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. Se stai installando l' CloudWatch agente con la raccolta delle metriche di Prometheus sul cluster per la prima volta, inserisci i seguenti comandi.
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Visualizzazione dei parametri e dei log di NGINX
Ora puoi visualizzare i parametri NGINX raccolti.
**Per visualizzare i parametri per il carico di lavoro NGINX**
1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nella regione in cui è in esecuzione il cluster, scegli **Metrics** (Parametri) nel pannello di navigazione sinistro. Trova lo spazio dei nomi **ContainerInsights/Prometheus per visualizzare le** metriche.
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/ /prometheus *your\$1cluster\$1name***, nel flusso di log. *nginx-prometheus-exporter*