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 parametri da log eventi mediante filtri
*Puoi cercare e filtrare i dati di registro che entrano in CloudWatch Logs creando uno o più filtri metrici.* I filtri metrici definiscono i termini e i modelli da cercare nei dati di registro quando vengono inviati ai registri. CloudWatch CloudWatch Logs utilizza questi filtri metrici per trasformare i dati di registro in CloudWatch metriche numeriche su cui è possibile rappresentare graficamente o impostare un allarme.
Quando si crea un parametro da un filtro di log, è anche possibile scegliere di assegnare dimensioni e un'unità al parametro. Se si sceglie un'unità, assicurarsi di specificare quella corretta quando si crea il filtro. In seguito, la modifica dell'unità per il filtro non avrà alcun effetto.
Se hai configurato AWS Organizations e stai lavorando con gli account dei membri, puoi utilizzare la centralizzazione dei log per raccogliere i dati di registro dagli account di origine in un account di monitoraggio centralizzato.
Quando si lavora con gruppi di log centralizzati, è possibile utilizzare le dimensioni di questi campi di sistema per creare filtri metrici.
+ `@aws.account`- Questa dimensione rappresenta l'ID dell' AWS account da cui ha avuto origine l'evento di registro.
+ `@aws.region`- Questa dimensione rappresenta la AWS regione in cui è stato generato l'evento di registro.
Queste dimensioni aiutano a identificare l'origine dei dati di registro, consentendo un filtraggio e un'analisi più granulari delle metriche derivate dai log centralizzati. Per ulteriori informazioni, consulta [Centralizzazione dei log per tutti gli account e tutte le Regioni](CloudWatchLogs_Centralization.md).
Se un gruppo di log con un abbonamento utilizza la trasformazione dei log, lo schema di filtro viene applicato alle versioni trasformate degli eventi di registro. Per ulteriori informazioni, consulta [Trasforma i log durante l'ingestione](CloudWatch-Logs-Transformation.md).
**Nota**
I filtri metrici sono supportati solo per i gruppi di log nella classe di log Standard. Per ulteriori informazioni sulle classi di log, consultate[Classi di registro](CloudWatch_Logs_Log_Classes.md).
Puoi utilizzare qualsiasi tipo di CloudWatch statistica, incluse le statistiche sui percentili, durante la visualizzazione di queste metriche o l'impostazione degli allarmi.
**Nota**
Le statistiche dei percentili sono supportate per un parametro solo se nessuno dei valori del parametro è negativo. Se configuri il filtro parametri in modo che possa indicare i numeri negativi, le statistiche dei percentili non saranno disponibili per i parametri quando includono numeri negativi come valore. Per ulteriori informazioni, consulta [Percentili](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Percentiles).
Filtri non filtrano retroattivamente i dati. I filtri pubblicano solo i punti di dati dei parametri per eventi che accadono dopo la creazione del filtro. Quando si testa un modello di filtro, l'anteprima dei **risultati del filtro** mostra fino alle prime 50 righe di registro corrispondenti a fini di convalida. Se il timestamp sui risultati filtrati è precedente all'ora di creazione della metrica, non viene visualizzato alcun registro.
**Topics**
+ [Concetti](#search-filter-concepts)
+ [Sintassi del modello di filtro per i filtri di parametri](FilterAndPatternSyntaxForMetricFilters.md)
+ [Creazione di filtri di parametri](MonitoringPolicyExamples.md)
+ [Elencazione di filtri di parametri](ListingMetricFilters.md)
+ [Eliminazione di un filtro di parametri](DeletingMetricFilter.md)
## Concetti
Ogni filtro parametri è formato dai seguenti elementi chiave:
**Valore predefinito**
Il valore riportato per il filtro di parametri durante un periodo di tempo in cui i log vengono inseriti ma non ne vengono individuati di corrispondenti. Impostandolo su 0, ti assicuri che i dati siano riportati durante ogni periodo, evitando parametri "instabili" con periodi di assenza di dati. Se nessun log viene inserito nell'arco di tempo di un minuto, allora nessun valore viene segnalato.
Se si assegnano dimensioni a un parametro creato da un filtro di parametri, non è possibile assegnare un valore predefinito per tale parametro.
**dimensioni**
Le dimensioni sono le coppie chiave-valore che definiscono ulteriormente un parametro. È possibile assegnare dimensioni al parametro creato da un filtro di parametri. Poiché le dimensioni fanno parte dell'identificatore univoco di una metrica, ogni volta che una name/value coppia univoca viene estratta dai log, viene creata una nuova variante di quella metrica.
**Modello di filtro**
Una descrizione simbolica di come CloudWatch Logs deve interpretare i dati in ogni evento di registro. Ad esempio, una voce di log potrebbe contenere timestamp, indirizzi IP, stringhe e così via. Utilizza il modello per specificare che cosa ricercare nei file di log.
**nome parametro**
Il nome della CloudWatch metrica su cui devono essere pubblicate le informazioni di registro monitorate. Ad esempio, puoi pubblicare su una metrica chiamata. ErrorCount
**Spazio dei nomi del parametro:**
Lo spazio dei nomi di destinazione della nuova metrica. CloudWatch
**Valore del parametro:**
Il valore numerico da pubblicare nel parametro ogni volta che viene trovato un log corrispondente. Ad esempio, se stai contando le occorrenze di un determinato termine come "Error", il valore sarà "1" per ogni ricorrenza. Se stai contando i byte trasferiti, puoi incrementare con il numero effettivo di byte presenti nel log eventi.
# Sintassi del modello di filtro per i filtri di parametri
**Nota**
**In che modo i filtri metrici differiscono dalle CloudWatch query di Logs Insights**
I filtri metrici differiscono dalle query di CloudWatch Logs Insights in quanto un valore numerico specificato viene aggiunto a un filtro metrico ogni volta che viene trovato un log corrispondente. Per ulteriori informazioni, consulta [Configurazione di valori di parametri per un filtro di parametri](#changing-default-increment-value).
Per informazioni su come interrogare i tuoi gruppi di log con il linguaggio di query Amazon CloudWatch Logs Insights, consulta[CloudWatch Sintassi delle interrogazioni in linguaggio Logs Insights](CWL_QuerySyntax.md).
**Esempi di modelli di filtro generici**
Per ulteriori informazioni sulla sintassi del modello di filtro generico applicabile ai filtri di parametri, nonché ai [filtri di sottoscrizione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SubscriptionFilters.html) e ai [filtri di log eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SearchDataFilterPattern.html), consulta [Sintassi del modello di filtro per filtri di parametri, filtri di sottoscrizione e filtri di log eventi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html), che include i seguenti esempi:
Sintassi delle espressioni regolari (regex) supportate
Corrispondenza dei termini nei log eventi non strutturati
Corrispondenza dei termini negli log eventi JSON
Corrispondenza dei termini in log eventi delimitati da spazi
*I filtri metrici* consentono di cercare e filtrare i dati di log che entrano in CloudWatch Logs, estrarre osservazioni metriche dai dati di log filtrati e trasformare i punti dati in una metrica Logs. CloudWatch Puoi definire i termini e i modelli da cercare nei dati di registro man mano che vengono inviati ai registri. CloudWatch I filtri di parametro vengono assegnati ai gruppi di log e tutti i filtri assegnati a un gruppo di log vengono applicati ai relativi flussi di log.
Quando un modello di filtro trova un termine corrispondente, aumenta il conteggio del parametro di un valore numerico specificato. Ad esempio, puoi creare un filtro di parametri per ricercare e contare l'occorrenza della parola ***ERROR*** nei tuoi log eventi.
È possibile assegnare unità e dimensioni ai parametri. Ad esempio, se crei un filtro di parametri che conta l'occorrenza della parola ***ERROR*** nei tuoi log eventi, puoi specificare una dimensione chiamata `ErrorCode` per mostrare il numero totale di log eventi che contengono la parola ***ERROR*** e filtrare i dati per codici di errore segnalati.
**Suggerimento**
Quando assegni un'unità di misura a un parametro, assicurati di specificare quella corretta. Se cambi l'unità in un secondo momento, la modifica potrebbe non avere effetto. Per l'elenco completo delle unità CloudWatch supportate, [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html)consulta Amazon CloudWatch API Reference.
**Topics**
+ [Configurazione di valori di parametri per un filtro di parametri](#changing-default-increment-value)
+ [Pubblicazione di dimensioni con parametri da valori in JSON o log eventi delimitati da spazi](#logs-metric-filters-dimensions)
+ [Utilizzo di valori nei log eventi per incrementare il valore di un parametro](#publishing-values-found-in-logs)
## Configurazione di valori di parametri per un filtro di parametri
Quando crei un filtro di parametri, definisci il modello di filtro e specifichi il valore del parametro e il valore predefinito. Puoi impostare i valori dei parametri su numeri, identificatori di nome o identificatori numerici. Se non specifichi un valore predefinito, CloudWatch non riporterà i dati quando il filtro metrico non trova una corrispondenza. Consigliamo di specificare un valore predefinito, anche se il valore è 0. L'impostazione di un valore predefinito aiuta a CloudWatch riportare i dati in modo più accurato e CloudWatch impedisce l'aggregazione di metriche disomogenee. CloudWatch aggrega e riporta i valori delle metriche ogni minuto.
Quando il filtro di parametri trova una corrispondenza nei log eventi, aumenta il conteggio del parametro in base al valore dello stesso. Se il filtro metrico non trova una corrispondenza, CloudWatch riporta il valore predefinito della metrica. Ad esempio, il gruppo di log pubblica due record ogni minuto, il valore del parametro è 1 e quello predefinito è 0. Se il filtro di parametri rileva corrispondenze in entrambi i record di log nel primo minuto, il valore del parametro per quel minuto è pari a 2. Se il filtro di parametri non trova corrispondenze in entrambi i record durante il secondo minuto, il valore predefinito per quel minuto è 0. Se assegni dimensioni ai parametri generati dai filtri di parametri, non puoi specificare i valori predefiniti per tali parametri.
Puoi anche impostare un filtro di parametri per incrementare un parametro con un valore estratto da un log eventi, anziché un valore statico. Per ulteriori informazioni, consulta [Utilizzo di valori nei log eventi per incrementare il valore di un parametro](#publishing-values-found-in-logs).
## Pubblicazione di dimensioni con parametri da valori in JSON o log eventi delimitati da spazi
Puoi utilizzare la CloudWatch console o la AWS CLI per creare filtri metrici che pubblicano dimensioni con metriche generate da JSON e da eventi di registro delimitati da spazi. Le dimensioni sono coppie di name/value valori e sono disponibili solo per JSON e modelli di filtro delimitati da spazi. Puoi creare filtri di parametri JSON e delimitati da spazi con un massimo di tre dimensioni. Per ulteriori informazioni sulle dimensioni e su come assegnare dimensioni ai parametri, consulta le seguenti sezioni:
+ [Dimensioni](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Dimension) nella *guida per gli CloudWatch utenti di Amazon*
+ [Esempio: estrai i campi da un log di Apache e assegna le dimensioni](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/ExtractBytesExample.html) nella *Amazon CloudWatch Logs* User Guide
**Importante**
Le dimensioni contengono valori che raccolgono addebiti identici ai parametri personalizzati. Per evitare addebiti imprevisti, non specificare come dimensioni campi ad alta cardinalità, ad esempio `IPAddress` o `requestID`.
Se estrai parametri dai log eventi, ti verranno fatturati come parametri personalizzati. Per evitare di riscuotere addebiti elevati accidentali, Amazon potrebbe disattivare il filtro metrico se genera 1000 name/value coppie diverse per dimensioni specificate in un determinato periodo di tempo.
Puoi creare allarmi di fatturazione per ricevere una notifica sugli addebiti stimati. Per ulteriori informazioni, consulta [Creazione di un allarme di fatturazione per il monitoraggio dei costi di AWS stimati](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html).
### Pubblicazione di dimensioni con parametri dal log eventi JSON
Gli esempi seguenti contengono frammenti di codice che descrivono come specificare le dimensioni in un filtro di parametri JSON.
------
#### [ Example: JSON log event ]
```
{
"eventType": "UpdateTrail",
"sourceIPAddress": "111.111.111.111",
"arrayKey": [
"value",
"another value"
],
"objectList": [
{"name": "a",
"id": 1
},
{"name": "b",
"id": 2
}
]
}
```
**Nota**
Se testi il filtro di parametri di esempio con il log eventi JSON di esempio, devi inserire il log JSON di esempio su una singola riga.
------
#### [ Example: Metric filter ]
Il filtro di parametri incrementa il parametro ogni volta che un log eventi JSON contiene le proprietà `eventType` e `"sourceIPAddress"`.
```
{ $.eventType = "*" && $.sourceIPAddress != 123.123.* }
```
Quando crei un filtro di parametri JSON, puoi specificare una qualsiasi proprietà del filtro di parametri come dimensione. Ad esempio, per impostare `eventType` come dimensione, segui questa procedura:
```
"eventType" : $.eventType
```
La metrica di esempio contiene una dimensione denominata `"eventType"` e il valore della dimensione nel log eventi di esempio è `"UpdateTrail"`.
------
### Pubblicazione di dimensioni con parametri da log eventi delimitati da spazi
Gli esempi seguenti contengono frammenti di codice che descrivono come specificare le dimensioni in un filtro di parametri delimitato da spazi.
------
#### [ Example: Space-delimited log event ]
```
127.0.0.1 Prod frank [10/Oct/2000:13:25:15 -0700] "GET /index.html HTTP/1.0" 404 1534
```
------
#### [ Example: Metric filter ]
```
[ip, server, username, timestamp, request, status_code, bytes > 1000]
```
Il filtro di parametri incrementa il parametro quando un log eventi delimitato da spazi include uno dei campi specificati nel filtro. Ad esempio, il filtro di parametri trova i seguenti campi e valori nell'esempio del log eventi delimitato da spazi.
```
{
"$bytes": "1534",
"$status_code": "404",
"$request": "GET /index.html HTTP/1.0",
"$timestamp": "10/Oct/2000:13:25:15 -0700",
"$username": "frank",
"$server": "Prod",
"$ip": "127.0.0.1"
}
```
Quando crei un filtro di parametri delimitato da spazi, puoi specificare uno dei campi nel filtro di parametri come dimensione. Ad esempio, per impostare `server` come dimensione, segui questa procedura:
```
"server" : $server
```
Il filtro di parametri di esempio ha una dimensione denominata `server` e il valore della dimensione nel log eventi di esempio è `"Prod"`.
------
#### [ Example: Match terms with AND (&&) and OR (\$1\$1) ]
Puoi utilizzare gli operatori logici AND ("&&") e OR ("\$1\$1") per creare filtri di parametri delimitati da spazi che contengono condizioni. Il seguente modello di filtro restituisce log eventi in cui la prima parola è ERROR o WARNING.
```
[w1=ERROR || w1=%WARN%, w2]
```
------
## Utilizzo di valori nei log eventi per incrementare il valore di un parametro
Puoi creare filtri di parametri che pubblicano i valori numerici trovati nei log eventi. La procedura in questa sezione utilizza il seguente filtro di parametri di esempio per mostrare come è possibile pubblicare un valore numerico in un log eventi JSON in un parametro.
```
{ $.latency = * } metricValue: $.latency
```
**Creazione di un filtro di parametri che pubblica un valore in un log eventi**
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. Seleziona o crea un gruppo di log.
Per informazioni su come creare un gruppo di log, consulta [Creare un gruppo di log in CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) nella *Amazon CloudWatch Logs User* Guide.
1. Scegli **Actions** (Operazioni) e quindi **Create metric filter** (Crea filtro parametri).
1. In **Modello di filtro**, digita **\$1 \$1.latency = \$1 \$1**, quindi scegli **Next (Successivo)**.
1. In **Metric Name (Nome parametro)**, digita **myMetric**.
1. Per **Valore parametro**, immettere **\$1.latency**.
1. (Facoltativo) In **Valore predefinito** immetti **0**, quindi scegli **Next (Successivo)**.
Consigliamo di specificare un valore predefinito, anche se il valore è 0. L'impostazione di un valore predefinito aiuta a CloudWatch riportare i dati in modo più accurato e CloudWatch impedisce l'aggregazione di metriche errate. CloudWatch aggrega e riporta i valori delle metriche ogni minuto.
1. Scegli **Crea filtro parametri**.
Il filtro di parametri di esempio corrisponde al termine `"latency"` nel log eventi JSON di esempio e pubblica un valore numerico pari a 50 per il parametro **myMetric**.
```
{
"latency": 50,
"requestType": "GET"
}
```
# 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
```
# Elencazione di filtri di parametri
Puoi creare un elenco di tutti i filtri di parametri in un gruppo di log.
**Per elencare i filtri metrici 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. Nel riquadro contenuti, nell'elenco dei gruppi di log, nella colonna **Filtri di parametri**, seleziona il numero di filtri.
Nella schermata **Gruppi di log > Filtri per** sono elencati tutti i filtri di parametri associati al gruppo di log.
**Per elencare i filtri metrici utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs describe-metric-filters --log-group-name MyApp/access.log
```
Di seguito è riportato un output di esempio:
```
{
"metricFilters": [
{
"filterName": "HTTP404Errors",
"metricTransformations": [
{
"metricValue": "1",
"metricNamespace": "MyNamespace",
"metricName": "ApacheNotFoundErrorCount"
}
],
"creationTime": 1399277571078,
"filterPattern": "[ip, id, user, timestamp, request, status_code=404, size]"
}
]
}
```
# Eliminazione di un filtro di parametri
Una policy è identificata dal relativo nome e dal gruppo di log a cui appartiene.
**Per eliminare 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. Nel riquadro contenuti, nella colonna **Metric Filters (Filtro di parametri)**, seleziona il numero di filtri di parametri per il gruppo di log.
1. Nella schermata **Metric Filters (Filtri di parametri)** seleziona la casella corrispondente al nome del filtro che si desidera eliminare. Scegli **Elimina**.
1. Quando viene richiesta la conferma, seleziona **Elimina**.
**Per eliminare un filtro metrico utilizzando il AWS CLI**
Al prompt dei comandi, esegui il comando seguente:
```
aws logs delete-metric-filter --log-group-name MyApp/access.log \
--filter-name MyFilterName
```