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à.
# Creazione di filtri di parametri
La procedura e gli esempi seguenti mostrano come creare filtri di parametri.
**Topics**
+ [Creazione di un filtro di parametri per un gruppo di log](CreateMetricFilterProcedure.md)
+ [Esempio: conteggio di log eventi](CountingLogEventsExample.md)
+ [Esempio: conteggio delle occorrenze di un termine](CountOccurrencesExample.md)
+ [Esempio: conteggio di codici HTTP 404](Counting404Responses.md)
+ [Esempio: conteggio di codici HTTP 4xx](FindCountMetric.md)
+ [Esempio: estrazione di campi da un log di Apache e assegnare dimensioni](ExtractBytesExample.md)
# Creazione di un filtro di parametri per un gruppo di log
Per creare un filtro di parametri per un gruppo di log, procedi nel seguente modo. Il parametro non sarà visibile finché non saranno disponibili alcuni punti dati.
**Per creare un filtro metrico utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione scegli **Log**, quindi **Gruppi di log**.
1. Scegli il nome del gruppo di log.
1. Scegli `Actions` e quindi **Crea filtro parametri**.
1. Per **Modello di filtro** inserisci il modello di filtro. Per ulteriori informazioni, consulta [Sintassi del modello di filtro per filtri di parametri, filtri di sottoscrizione, filtri di log eventi e Live Tail](FilterAndPatternSyntax.md).
1. (Facoltativo) Se si utilizzano gruppi di log centralizzati, in **Criteri di selezione del filtro**, è possibile specificare filtri in base all'account di origine (`@aws.account`), alla regione di origine (`@aws.region`) o a entrambe le condizioni.
1. (Facoltativo) Per testare il modello di filtro, in **Test Pattern (Modello di test)**, inserisci uno o più log eventi per testare il modello. Ogni log eventi deve essere formattato su una riga. Le interruzioni di riga vengono utilizzate per separare i log eventi nel riquadro **Messaggi del log eventi**.
1. Scegli **Successivo** e poi inserisci un nome per il filtro.
1. In **Dettagli metrici**, per **Metric namespace**, inserisci un nome per lo spazio dei CloudWatch nomi in cui verrà pubblicata la metrica. Se questo spazio dei nomi non esiste già, assicurati che sia selezionato **Crea nuovo**.
1. Per **Metric name (Nome parametro)** inserisci un nome per il nuovo parametro.
1. In **Metric value (Valore del parametro)**, se il filtro di parametri conta le occorrenze delle parole chiave nel filtro, inserisci 1. In questo modo il parametro viene incrementato di 1 per ogni log eventi che include una delle parole chiave.
In alternativa, inserisci un token come **\$1size**. In questo modo il parametro viene incrementato in base al valore del numero nel campo `size` per ogni log eventi che contiene un campo `size`.
1. (Facoltativo) Per **Unit (Unità)**, seleziona un'unità da assegnare al parametro. Se non specifichi un'unità, l'unità viene impostata come `None`.
1. (Facoltativo) Inserisci i nomi e i token per fino a tre dimensioni per il parametro. Se assegni dimensioni ai parametri creati dai filtri di parametri, non puoi assegnare i valori predefiniti per tali parametri.
**Nota**
Le dimensioni sono supportate solo nei filtri JSON o di parametri delimitati da spazi.
1. Scegli **Crea filtro parametri**. Puoi trovare il filtro dei parametri che hai creato nel riquadro di navigazione. Scegli **Log** e quindi il **gruppo di log**. Scegli il nome del gruppo di log per cui hai creato il filtro dei parametri, quindi seleziona il tab **Filtri dei parametri**.
# Esempio: conteggio di log eventi
Il tipo più semplice di monitoraggio di eventi di log è contare il numero di eventi di log che si verificano. Potresti voler eseguire questa operazione per mantenere un conteggio di tutti gli eventi, per creare un monitor in stile "battito cardiaco" o anche solo per provare la creazione di filtri di parametro.
Nel seguente esempio CLI, un filtro metrico chiamato MyAppAccessCount viene applicato al gruppo di log MyApp /access.log per creare la metrica nello spazio dei nomi EventCount . CloudWatch MyNamespace Il filtro è configurato corrispondere a qualsiasi log eventi e per incrementare il parametro con "1".
**Per creare un filtro metrico utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**.
1. Scegliere il nome di un gruppo di log.
1. Scegli `Actions`, **Crea filtro parametri**.
1. Lasciare vuoti i campi **Modello di filtro** e **Seleziona i dati di log per il test** .
1. Scegliere **Avanti**, quindi per **Nome filtro**, digitare **EventCount**.
1. In **Metric Details (Dettagli parametro)**, per **Metric Namespace (Spazio dei nomi del parametro)**, inserisci **MyNameSpace**.
1. Per **Metric Name (Nome parametro)** digita **MyAppEventCount**.
1. Verificare che il **Valore parametro** sia 1. Questo specifica che il conteggio viene incrementato di 1 per ogni log eventi.
1. In **Valore predefinito** immettere 0, quindi scegliere **Avanti**. La specificazione di un valore predefinito garantisce che i dati siano riportati anche durante i periodi in cui non si verificano eventi di log, impedendo parametri instabili in cui i dati talvolta non esistono.
1. Scegli **Crea filtro parametri**.
**Per creare un filtro metrico utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs put-metric-filter \
--log-group-name MyApp/access.log \
--filter-name EventCount \
--filter-pattern " " \
--metric-transformations \
metricName=MyAppEventCount,metricNamespace=MyNamespace,metricValue=1,defaultValue=0
```
Puoi testare questa nuova policy pubblicando qualsiasi dati di evento. Dovresti vedere i punti dati pubblicati nella metrica MyAppAccessEventCount.
**Per pubblicare i dati degli eventi utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs put-log-events \
--log-group-name MyApp/access.log --log-stream-name TestStream1 \
--log-events \
timestamp=1394793518000,message="Test event 1" \
timestamp=1394793518000,message="Test event 2" \
timestamp=1394793528000,message="This message also contains an Error"
```
# Esempio: conteggio delle occorrenze di un termine
Gli eventi di log includono spesso messaggi importanti che desideri contare, forse per quel che concerne il successo o il fallimento delle operazioni. Ad esempio, se una determinata operazione non riesce, potrebbe verificarsi un errore che viene registrato in un file di log. Potresti voler monitorare queste voci per comprendere l'andamento dei tuoi errori.
Nell'esempio sottostante, una filtro parametri viene creato per monitorare il termine Error. **La policy è stata creata e aggiunta al gruppo di log /message.log. MyApp** CloudWatch Logs pubblica un punto dati nella metrica CloudWatch personalizzata ErrorCount nello spazio dei nomi **MyApp/message.log** con un valore di «1" per ogni evento contenente Error. Se nessun evento contiene la parola Error, il valore pubblicato è 0. Quando rappresentate graficamente questi dati nella CloudWatch console, assicuratevi di utilizzare la statistica della somma.
Dopo aver creato un filtro metrico, puoi visualizzare la metrica nella console. CloudWatch Quando si seleziona il parametro da visualizzare, selezionare lo spazio dei nomi del parametro che corrisponde al nome del gruppo di log. Per ulteriori informazioni, consulta [Visualizzazione dei parametri disponibili](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html).
**Per creare un filtro metrico utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**.
1. Scegli il nome del gruppo di log.
1. Scegliere **Operazioni**, **Crea filtro parametri**.
1. In **Modello di filtro**, immettere **Error**.
**Nota**
Tutte le voci in **Filtra Pattern** (Modello File) fanno distinzione tra lettere maiuscole e minuscole.
1. (Facoltativo) Per testare il modello di filtro, in **Test Pattern (Modello di test)**, inserisci uno o più log eventi da utilizzare per testare il modello. Ogni log eventi deve essere all'interno di una riga, in quanto le interruzioni di riga vengono utilizzate per separare i log eventi nella casella **Log event messages (Messaggi di registro eventi)**.
1. Scegliere **Avanti**, quindi nella pagina **Assegna parametro**, per **Nome filtro**, digitare **MyAppErrorCount**.
1. In **Metric Details (Dettagli parametro)**, per **Metric Namespace (Spazio dei nomi del parametro)**, inserisci **MyNameSpace**.
1. Per **Metric Name (Nome parametro)** digita **ErrorCount**.
1. Verificare che il **Valore parametro** sia 1. Questo specifica che il conteggio viene incrementato di 1 per ogni log eventi contente "Error".
1. Per **Valore predefinito** digitare 0, quindi scegliere **Avanti**.
1. Scegli **Crea filtro parametri**.
**Per creare un filtro metrico utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs put-metric-filter \
--log-group-name MyApp/message.log \
--filter-name MyAppErrorCount \
--filter-pattern 'Error' \
--metric-transformations \
metricName=ErrorCount,metricNamespace=MyNamespace,metricValue=1,defaultValue=0
```
Puoi verificare questa nuova policy pubblicando eventi che contengano la parola "Error" nel messaggio.
**Per pubblicare eventi utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente. Nota che i modelli fanno distinzione tra lettere maiuscole e minuscole.
```
aws logs put-log-events \
--log-group-name MyApp/access.log --log-stream-name TestStream1 \
--log-events \
timestamp=1394793518000,message="This message contains an Error" \
timestamp=1394793528000,message="This message also contains an Error"
```
# Esempio: conteggio di codici HTTP 404
Utilizzando CloudWatch Logs, è possibile monitorare quante volte i server Apache restituiscono una risposta HTTP 404, che è il codice di risposta per la pagina non trovata. Potresti voler monitorare questo per comprendere quanto spesso i visitatori del tuo sito non sono in grado di individuare le risorse ricercate. Supponiamo che i tuoi record di log siano strutturati per includere le seguenti informazioni per ogni log eventi (visita del sito):
+ Indirizzo IP del richiedente
+ Identità RFC 1413
+ Username
+ Time stamp
+ Richiedi metodo con risorsa di richiesta e protocollo
+ Codice di risposta HTTP per richiesta
+ Byte trasferiti nella richiesta
Un esempio del genere potrebbe apparire come segue:
```
127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 404 2326
```
Potresti specificare una regola che cerca di confrontare gli eventi di tale struttura per errori HTTP 404, come mostrato nell'esempio seguente:
**Per creare un filtro metrico utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**.
1. Scegli `Actions`, **Crea filtro parametri**.
1. In **Modello di filtro**, digitare **[IP, UserInfo, User, Timestamp, RequestInfo, StatusCode=404, Bytes]**.
1. (Facoltativo) Per testare il modello di filtro, in **Test Pattern (Modello di test)**, inserisci uno o più log eventi da utilizzare per testare il modello. Ogni log eventi deve essere all'interno di una riga, in quanto le interruzioni di riga vengono utilizzate per separare i log eventi nella casella **Log event messages (Messaggi di registro eventi)**.
1. Scegli **Avanti**, quindi in **Nome filtro** digita **HTTP404Errori**.
1. In **Dettagli parametro**, per **Spazio dei nomi del parametro**, immettere **MyNameSpace**.
1. Per **Nome parametro**, immettere **ApacheNotFoundErrorCount**.
1. Verificare che il **Valore parametro** sia 1. Questo specifica che il conteggio viene incrementato di 1 per ogni evento di errore 404.
1. In **Valore predefinito** immettere 0, quindi scegliere **Avanti**.
1. Scegli **Crea filtro parametri**.
**Per creare un filtro metrico utilizzando AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs put-metric-filter \
--log-group-name MyApp/access.log \
--filter-name HTTP404Errors \
--filter-pattern '[ip, id, user, timestamp, request, status_code=404, size]' \
--metric-transformations \
metricName=ApacheNotFoundErrorCount,metricNamespace=MyNamespace,metricValue=1
```
In questo esempio, sono stati utilizzati caratteri letterali, ad esempio le parentesi quadre sinistra e destra, le virgolette e la stringa di caratteri 404. Il modello deve corrispondere con l'intero messaggio del log eventi, in modo da essere considerato per il monitoraggio.
Puoi verificare la creazione del filtro parametri utilizzando il comando **describe-metric-filters**. L'output visualizzato dovrebbe essere di questo tipo:
```
aws logs describe-metric-filters --log-group-name MyApp/access.log
{
"metricFilters": [
{
"filterName": "HTTP404Errors",
"metricTransformations": [
{
"metricValue": "1",
"metricNamespace": "MyNamespace",
"metricName": "ApacheNotFoundErrorCount"
}
],
"creationTime": 1399277571078,
"filterPattern": "[ip, id, user, timestamp, request, status_code=404, size]"
}
]
}
```
Ora puoi pubblicare alcuni eventi manualmente:
```
aws logs put-log-events \
--log-group-name MyApp/access.log --log-stream-name hostname \
--log-events \
timestamp=1394793518000,message="127.0.0.1 - bob [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb.gif HTTP/1.0\" 404 2326" \
timestamp=1394793528000,message="127.0.0.1 - bob [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb2.gif HTTP/1.0\" 200 2326"
```
Subito dopo aver inserito questi eventi di registro di esempio, puoi recuperare la metrica denominata nella CloudWatch console come. ApacheNotFoundErrorCount
# Esempio: conteggio di codici HTTP 4xx
Come nell'esempio precedente, potresti voler monitorare i tuoi log di accesso al servizio Web e monitorare i livelli del codice di risposta HTTP. Ad esempio, potresti voler monitorare tutti gli errori di livello HTTP 400. Tuttavia, è possibile tu non voglia specificare un nuovo filtro parametri per ogni codice restituito.
L'esempio seguente spiega come creare un parametro che includa tutte le risposte del codice di livello HTTP 400 da un log di accesso utilizzando il formato di log di accesso Apache dall'esempio [Esempio: conteggio di codici HTTP 404](Counting404Responses.md).
**Per creare un filtro metrico utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**.
1. Scegli il nome del gruppo di log per il server Apache.
1. Scegli `Actions`, **Crea filtro parametri**.
1. In **Filter pattern (Modello di filtro)**, inserisci **[ip, id, user, timestamp, request, status\$1code=4\$1, size]**.
1. (Facoltativo) Per testare il modello di filtro, in **Modello di test**, inserisci uno o più log eventi da utilizzare per testare il modello. Ogni log eventi deve essere all'interno di una riga, in quanto le interruzioni di riga vengono utilizzate per separare i log eventi nella casella **Log event messages (Messaggi di registro eventi)**.
1. Scegli **Next (Avanti)**, quindi per **Filter name (Nome filtro)**, digita **HTTP4xxErrors**.
1. In **Metric details (Dettagli parametro)**, per **Metric namespace (Spazio dei nomi del parametro)**, inserisci **MyNameSpace**.
1. Per **Nome della metrica**, inserisci **HTTP4xxErrori**.
1. In **Metric value (Valore parametro)**, inserisci 1. Questo specifica che il conteggio viene incrementato di 1 per ogni log contente un errore 4xx.
1. In **Default value (Valore predefinito)** inserisci 0, quindi scegli **Next (Avanti)**.
1. Scegli **Crea filtro parametri**.
**Per creare un filtro metrico utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs put-metric-filter \
--log-group-name MyApp/access.log \
--filter-name HTTP4xxErrors \
--filter-pattern '[ip, id, user, timestamp, request, status_code=4*, size]' \
--metric-transformations \
metricName=HTTP4xxErrors,metricNamespace=MyNamespace,metricValue=1,defaultValue=0
```
Puoi utilizzare i seguenti dati in chiamate put-event per verificare questa regola. Se non rimuovi la regola di monitoraggio nell'esempio precedente, genererai due parametri differenti.
```
127.0.0.1 - - [24/Sep/2013:11:49:52 -0700] "GET /index.html HTTP/1.1" 404 287
127.0.0.1 - - [24/Sep/2013:11:49:52 -0700] "GET /index.html HTTP/1.1" 404 287
127.0.0.1 - - [24/Sep/2013:11:50:51 -0700] "GET /~test/ HTTP/1.1" 200 3
127.0.0.1 - - [24/Sep/2013:11:50:51 -0700] "GET /favicon.ico HTTP/1.1" 404 308
127.0.0.1 - - [24/Sep/2013:11:50:51 -0700] "GET /favicon.ico HTTP/1.1" 404 308
127.0.0.1 - - [24/Sep/2013:11:51:34 -0700] "GET /~test/index.html HTTP/1.1" 200 3
```
# Esempio: estrazione di campi da un log di Apache e assegnare dimensioni
A volte, invece di contare, è utile utilizzare i valori all'interno dei singoli eventi di log per i valori di parametro. Questo esempio illustra il modo in cui puoi creare una regola di estrazione per creare un parametro che misura i byte trasferiti da un server Web Apache.
In questo esempio viene inoltre illustrato come assegnare le dimensioni al parametro che si sta creando.
**Per creare un filtro metrico utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, selezionare **Log groups (Gruppi di log)**.
1. Scegli il nome del gruppo di log per il server Apache.
1. Scegli `Actions`, **Crea filtro parametri**.
1. In **Filter pattern (Modello di filtro)**, inserisci **[ip, id, user, timestamp, request, status\$1code, size]**.
1. (Facoltativo) Per testare il modello di filtro, in **Modello di test**, inserisci uno o più log eventi da utilizzare per testare il modello. Ogni log eventi deve essere all'interno di una riga, in quanto le interruzioni di riga vengono utilizzate per separare i log eventi nella casella **Log event messages (Messaggi di registro eventi)**.
1. Scegli **Next (Avanti)**, quindi per **Filter name (Nome filtro)**, digita **size**.
1. In **Metric details (Dettagli parametro)**, per **Metric namespace (Spazio dei nomi del parametro)**, inserisci **MyNameSpace**. Poiché si tratta di un nuovo spazio dei nomi, assicurarsi che sia selezionato **Create new (Creazione di nuovi)**.
1. Per **Metric name (Nome parametro)**, inserisci **BytesTransferred**
1. In **Metric value (Valore parametro)**, inserisci **\$1size**.
1. Per **Unit (Unità)** seleziona **Bytes (Byte)**.
1. In **Dimension Name (Nome dimensione)** digita **IP**.
1. Per **Dimension Value (Valore dimensione)** digita **\$1ip**, quindi scegli **Next (Avanti)**.
1. Scegli **Crea filtro parametri**.
**Per creare questo filtro metrico utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente.
```
aws logs put-metric-filter \
--log-group-name MyApp/access.log \
--filter-name BytesTransferred \
--filter-pattern '[ip, id, user, timestamp, request, status_code, size]' \
--metric-transformations \
metricName=BytesTransferred,metricNamespace=MyNamespace,metricValue='$size'
```
```
aws logs put-metric-filter \
--log-group-name MyApp/access.log \
--filter-name BytesTransferred \
--filter-pattern '[ip, id, user, timestamp, request, status_code, size]' \
--metric-transformations \
metricName=BytesTransferred,metricNamespace=MyNamespace,metricValue='$size',unit=Bytes,dimensions='{{IP=$ip}}'
```
**Nota**
In questo comando, utilizzare questo formato per specificare più dimensioni.
```
aws logs put-metric-filter \
--log-group-name my-log-group-name \
--filter-name my-filter-name \
--filter-pattern 'my-filter-pattern' \
--metric-transformations \
metricName=my-metric-name,metricNamespace=my-metric-namespace,metricValue=my-token,unit=unit,dimensions='{dimension1=$dim,dimension2=$dim2,dim3=$dim3}'
```
È possibile utilizzare i seguenti dati nelle put-log-event chiamate per testare questa regola. Questo genererà due parametri differenti, se non rimuovi la regola di monitoraggio nell'esempio precedente.
```
127.0.0.1 - - [24/Sep/2013:11:49:52 -0700] "GET /index.html HTTP/1.1" 404 287
127.0.0.1 - - [24/Sep/2013:11:49:52 -0700] "GET /index.html HTTP/1.1" 404 287
127.0.0.1 - - [24/Sep/2013:11:50:51 -0700] "GET /~test/ HTTP/1.1" 200 3
127.0.0.1 - - [24/Sep/2013:11:50:51 -0700] "GET /favicon.ico HTTP/1.1" 404 308
127.0.0.1 - - [24/Sep/2013:11:50:51 -0700] "GET /favicon.ico HTTP/1.1" 404 308
127.0.0.1 - - [24/Sep/2013:11:51:34 -0700] "GET /~test/index.html HTTP/1.1" 200 3
```