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à.
# Configurazione di Amazon Kinesis Agent per Microsoft Windows
Prima di avviare Amazon Kinesis Agent per Microsoft Windows, è necessario creare un file di configurazione e distribuirlo. Il file di configurazione fornisce le informazioni necessarie per raccogliere, trasformare e trasmettere dati su server e computer desktop Windows ai vari servizi AWS. I file di configurazione definiscono set di origini, sink e pipe che collegano origini a sink, insieme a trasformazioni opzionali.
Il file di configurazione Kinesis Agent per Windows è denominato`appsettings.json`: . Distribuisci il file in `%PROGRAMFILES%\Amazon\AWSKinesisTap`.
**Topics**
+ [Struttura configurazione di base](basic-configuration-structure.md)
+ [Dichiarazioni delle origini](source-object-declarations.md)
+ [Dichiarazioni dei sink](sink-object-declarations.md)
+ [Dichiarazioni delle pipe](pipe-object-declarations.md)
+ [Configurazione di aggiornamenti automatici](update-configuration-options.md)
+ [Esempi di configurazione di Kinesis Agent per Windows](configuring-kaw-examples.md)
+ [Configurazione della Telemetria](telemetrics-configuration-option.md)
# Struttura configurazione di base
La struttura di base del file di configurazione di Amazon Kinesis Agent per Microsoft Windows è un documento in formato JSON con il seguente modello:
```
{
"Sources": [ ],
"Sinks": [ ],
"Pipes": [ ]
}
```
+ Il valore di `Sources` è uno o più [Dichiarazioni delle origini](source-object-declarations.md).
+ Il valore di `Sinks` è uno o più [Dichiarazioni dei sink](sink-object-declarations.md).
+ Il valore di `Pipes` è uno o più [Dichiarazioni delle pipe](pipe-object-declarations.md).
Per ulteriori informazioni sui concetti di origine, pipe e sink di Kinesis Agent per Windows, consulta[Amazon Kinesis Agent per Microsoft Windows Concetti](kinesis-agent-windows-concepts.md): .
L'esempio seguente è un`appsettings.json`Configurare che configura l'agente Kinesis per Windows per lo streaming di eventi di log delle applicazioni Windows a Kinesis Data Firehose.
```
{
"Sources": [
{
"LogName": "Application",
"Id": "ApplicationLog",
"SourceType": "WindowsEventLogSource"
}
],
"Sinks": [
{
"StreamName": "ApplicationLogFirehoseStream",
"Region": "us-west-2",
"Id": "MyKinesisFirehoseSink",
"SinkType": "KinesisFirehose"
}
],
"Pipes": [
{
"Id": "ApplicationLogTotestKinesisFirehoseSink",
"SourceRef": "ApplicationLog",
"SinkRef": "MyKinesisFirehoseSink"
}
]
}
```
Per ulteriori informazioni su ciascun tipo di dichiarazione, consultare le sezioni seguenti:
+ [Dichiarazioni delle origini](source-object-declarations.md)
+ [Dichiarazioni dei sink](sink-object-declarations.md)
+ [Dichiarazioni delle pipe](pipe-object-declarations.md)
## Distinzione tra lettere maiuscole e minuscole nella configurazione
I file in formato JSON effettuano in genere la distinzione tra lettere maiuscole e minuscole ed è necessario presumere che tutte le chiavi e i valori nei file di configurazione di Kinesis Agent per Windows si comporta allo stesso modo. Alcune chiavi e valori nel file di configurazione `appsettings.json` non effettuano la distinzione tra lettere maiuscole e minuscole, ad esempio:
+ Il valore della coppia chiave-valore `Format` per i sink. Per ulteriori informazioni, consulta [Dichiarazioni dei sink](sink-object-declarations.md).
+ Il valore della coppia chiave-valore `SourceType` per le origini, la coppia chiave-valore `SinkType` per i sink e la coppia chiave-valore `Type` per pipe e plug-in.
+ Il valore della coppia chiave-valore `RecordParser` per l'origine `DirectorySource`. Per ulteriori informazioni, consulta [Configurazione DirectorySource](source-object-declarations.md#directory-source-configuration).
+ Il valore della coppia chiave-valore `InitialPosition` per le origini. Per ulteriori informazioni, consulta [Configurazione del segnalibro](source-object-declarations.md#advanced-source-configuration).
+ Prefissi per sostituzioni variabili. Per ulteriori informazioni, consulta [Configurazione di sostituzione di variabili sink](sink-object-declarations.md#configuring-kinesis-agent-windows-sink-variable-substitution).
# Dichiarazioni delle origini
In Amazon Kinesis Agent per Microsoft Windows,*Dichiarazioni delle origini*descrivono dove e quali dati di registro, evento e metrica devono essere raccolti. Inoltre, è possibile specificare le informazioni per l'analisi dei tali dati in modo che possano essere trasformati. Le seguenti sezioni descrivono le configurazioni per i tipi di origine integrati che sono disponibili in Kinesis Agent per Windows. Poiché Kinesis Agent per Windows è ampliabile, è possibile aggiungere tipi di origine personalizzati. Ogni tipo di origine di solito richiede coppie chiave-valore specifiche negli oggetti di configurazione che sono rilevanti per quel tipo di origine.
Tutte le dichiarazioni di origini devono contenere almeno le seguenti coppie chiave-valore:
`Id`
Una stringa univoca che identifica un determinato oggetto di origine all'interno del file di configurazione.
`SourceType`
Il nome del tipo di origine per questo oggetto origine. Il tipo di origine specifica l'origine dei dati di log, eventi o parametri raccolti da tale oggetto. Controlla anche quali altri aspetti dell'origine possono essere dichiarati.
Per esempi di file di configurazione completi che utilizzano diversi tipi di dichiarazioni di origini, vedi [Streaming da diverse origini a Kinesis Data Streams](configuring-kaw-examples.md#configuring-kaw-examples-sources).
**Topics**
+ [Configurazione DirectorySource](#directory-source-configuration)
+ [Configurazione ExchangeLogSource](#exchange-source-configuration)
+ [Configurazione W3SVCLogSource](#iis-source-configuration)
+ [Configurazione UlsSource](#sharepoint-source-configuration)
+ [Configurazione WindowsEventLogSource](#window-event-source-configuration)
+ [Configurazione WindowsEventLogPollingSource](#eventlogpolling-source-configuration)
+ [Configurazione WindowsETWEventSource](#etw-source-configuration)
+ [Configurazione WindowsPerformanceCounterSource](#performance-counter-source-configuration)
+ [Origine dei parametri integrati di Kinesis Agent per Windows](#kinesis-agent-builin-metrics-source)
+ [Elenco delle metriche di Kinesis Agent per Windows](#kinesis-agent-metric-list)
+ [Configurazione del segnalibro](#advanced-source-configuration)
## Configurazione DirectorySource
### Overview
Il tipo di origine `DirectorySource` raccoglie i log di file memorizzati nella directory specificata. Poiché i file di log sono disponibili in molti formati diversi, la dichiarazione `DirectorySource` consente di specificare il formato dei dati nel file di log. Quindi è possibile trasformare i contenuti dei log in un formato standard, ad esempio JSON o XML, prima di eseguire lo streaming a vari servizi AWS.
Di seguito è riportato un esempio della dichiarazione `DirectorySource`:
```
{
"Id": "myLog",
"SourceType": "DirectorySource",
"Directory": "C:\\Program Data\\MyCompany\\MyService\\logs",
"FileNameFilter": "*.log",
"IncludeSubdirectories": true,
"IncludeDirectoryFilter": "cpu\\cpu-1;cpu\\cpu-2;load;memory",
"RecordParser": "Timestamp",
"TimestampFormat": "yyyy-MM-dd HH:mm:ss.ffff",
"Pattern": "\\d{4}-\\d{2}-\\d(2}",
"ExtractionPattern": "",
"TimeZoneKind": "UTC",
"SkipLines": 0,
"Encoding": "utf-16",
"ExtractionRegexOptions": "Multiline"
}
```
Tutte le dichiarazioni `DirectorySource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"DirectorySource"` (obbligatoria).
`Directory`
Il percorso alla directory contenente i file di log (obbligatorio).
`FileNameFilter`
Eventualmente limita il set di file nella directory in cui i dati di log sono raccolti in base al modello di denominazione dei file jolly. Se si dispone di più modelli di nomi di file di registro, questa funzionalità consente di utilizzare un singolo`DirectorySource`, come mostrato nell'esempio seguente.
```
FileNameFilter: "*.log|*.txt"
```
Gli amministratori di sistema a volte comprimere i file di registro prima di archiviarli. Se si specifica`"*.*"`in`FileNameFilter`, i file compressi noti sono ora esclusi. Questa funzione impedisce`.zip`,`.gz`, e`.bz2`di essere trasmessi accidentalmente. Se questa coppia chiave-valore non viene specificata, i dati provenienti da tutti i file nella directory sono raccolti per impostazione predefinita.
`IncludeSubdirectories`
Specifica di monitorare le sottodirectory a profondità arbitraria limitata dal sistema operativo. Questa funzione è utile per monitorare i server Web con più siti Web. È possibile utilizzare anche l'`IncludeDirectoryFilter`per monitorare solo alcune sottodirectory specificate nel filtro.
`RecordParser`
Specifica il modo in cui il tipo di origine `DirectorySource` deve analizzare i file di log disponibili nella directory specificata. Questa coppia chiave-valore è obbligatoria e i valori validi sono i seguenti:
+ `SingleLine`— Ogni riga del file di log è un record di log.
+ `SingleLineJson`— Ogni riga del file di log è un record di log in formato JSON. Questo parser è utile quando si desidera aggiungere ulteriori coppie chiave-valore al JSON tramite la decorazione degli oggetti. Per ulteriori informazioni, consulta [Configurazione delle decorazioni sink](sink-object-declarations.md#configuring-kinesis-agent-windows-decoration-configuration). Per un esempio che utilizza il parser di record`SingleLineJson`, consulta [Tutorial: Trasmetti file di registro JSON ad Amazon S3 utilizzando Kinesis Agent per Windows](directory-source-to-s3-tutorial.md).
+ `Timestamp`: Una o più righe possono includere un record di log. I record di log iniziano con un timestamp. Questa opzione richiede di specificare la coppia chiave-valore `TimestampFormat`.
+ `Regex`— Ogni record inizia con il testo che corrisponde a una determinata espressione regolare. Questa opzione richiede di specificare la coppia chiave-valore `Pattern`.
+ `SysLog`— Indica che il file di log viene scritto nella[syslog](https://en.wikipedia.org/wiki/Syslog)formato standard. Il file di log viene analizzato in record in base a tali specifiche.
+ `Delimited`— Una versione più semplice del parser di record Regex in cui gli elementi dei dati nei record di log sono separati da un delimitatore coerente. Questa opzione è più facile da usare e più veloce nell'esecuzione rispetto al parser Regex ed è da preferire quando questa opzione è disponibile. Quando si utilizza questa opzione, è necessario specificare la coppia chiave-valore `Delimiter`.
`TimestampField`
Specifica quale campo JSON contiene il timestamp per il record. Questo viene utilizzato solo con `SingleLineJson` `RecordParser`. Questa coppia chiave-valore è facoltativa. Se non viene specificato, Kinesis Agent per Windows usa l'ora in cui il record è stato letto per il timestamp. Uno dei vantaggi di specificare questa coppia chiave-valore è che le statistiche di latenza generate da Kinesis Agent per Windows sono più accurate.
`TimestampFormat`
Specifica come analizzare la data e l'ora associati al record. Il valore è una stringa con il formato `epoch` o una stringa data/ora .NET. Se il valore è `epoch`, l'ora viene analizzata in base all'ora UNIX Epoch. Per ulteriori informazioni sull'ora UNIX Epoch, consulta [Ora Unix](https://en.wikipedia.org/wiki/Unix_time). Per ulteriori informazioni sulle stringhe di formato data/ora .NET, consulta [Stringhe personalizzate nel formato data e ora](https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings) nella documentazione di Microsoft .NET). Questa coppia chiave-valore è obbligatoria solo se viene specificato il parser di record `Timestamp` oppure il parser di record `SingleLineJson` viene specificato con la coppia chiave-valore `TimestampField`.
`Pattern`
Specifica un'espressione regolare che deve corrispondere alla prima riga di un record potenzialmente multiriga. Questa coppia chiave-valore è necessaria solo per il parser di record `Regex`.
`ExtractionPattern`
Specifica un'espressione regolare che deve utilizzare gruppi denominati. Il record è analizzato con l'utilizzo di questa espressione regolare e i gruppi denominati formano i campi del record analizzato. Questi campi vengono quindi utilizzati come base per la costruzione di oggetti o documenti JSON o XML, che sono poi trasmessi dai sink ai vari servizi AWS. Questa coppia chiave-valore è facoltativa ed è disponibile con l'`Regex`e il parser Timestamp.
Il nome del gruppo `Timestamp` viene appositamente elaborato, poiché indica al parser `Regex` quale campo contiene la data e l'ora per ogni record di ciascun file di log.
`Delimiter`
Specifica il carattere o la stringa che separa ciascun elemento in ogni record di log. Questa coppia chiave-valore deve essere (e può solo essere) disponibile solo con il parser di record `Delimited`. Utilizzare la sequenza di due caratteri `\t` per rappresentare il carattere di tabulazione.
`HeaderPattern`
Specifica un'espressione regolare per la riga corrispondente nel file di log che contiene il set di intestazioni per il record. Se il file di log non contiene le informazioni dell'intestazione, utilizzare la coppia chiave-valore `Headers` per specificare le intestazioni implicite. La coppia chiave-valore `HeaderPattern` è facoltativa ed è solo valida per il parser di record `Delimited`.
Una voce di intestazione vuota (lunghezza 0) per una colonna comporta che i dati per quella colonna vengono filtrati dall'output finale dell'output analizzato `DirectorySource`.
`Headers`
Specifica i nomi delle colonne di dati analizzati utilizzando il delimitatore specificato. Questa coppia chiave-valore è facoltativa ed è solo valida per il parser di record `Delimited`.
Una voce di intestazione vuota (lunghezza 0) per una colonna comporta che i dati per quella colonna vengono filtrati dall'output finale dell'output analizzato `DirectorySource`.
`RecordPattern`
Specifica un'espressione regolare che identifica righe del file di log che contengono dati di record. A parte la riga di intestazione facoltativa identificata da `HeaderPattern`, le righe che non corrispondono al `RecordPattern` specificato vengono ignorate durante l'elaborazione dei record. Questa coppia chiave-valore è facoltativa ed è solo valida per il parser di record `Delimited`. Se non viene fornito, il valore di default è da considerare qualsiasi riga che non corrisponde all'opzionale `HeaderPattern` o l'opzionale `CommentPattern` come riga che contiene i dati dei record analizzabili.
`CommentPattern`
Specifica un'espressione regolare che identifica le righe del file di log che devono essere escluse prima di analizzare i dati nel file di log. Questa coppia chiave-valore è facoltativa ed è solo valida per il parser di record `Delimited`. Se non viene fornito, il valore di default è da considerare qualsiasi riga che non corrisponde all'opzionale `HeaderPattern` ed è una riga che contiene i dati dei record analizzabili, a meno che non venga specificato `RecordPattern`.
`TimeZoneKind`
Specifica se il timestamp nel file di log deve essere considerato nel fuso orario locale o nel fuso orario UTC. Si tratta di un'opzione facoltativa, impostata di default su UTC. Gli unici valori validi per questa coppia chiave-valore sono `Local` o `UTC`. Il timestamp non è mai alterato, se `TimeZoneKind` non è specificato o se il valore è UTC. Il timestamp viene convertito in UTC quando il`TimeZoneKind`Il valore è`Local`Se il sink che riceve il timestamp è CloudWatch Logs, oppure il record analizzato viene inviato ad altri sink. Date e ore incorporate nei messaggi non vengono convertite.
`SkipLines`
Quando specificato, controlla il numero di righe ignorati all'inizio di ogni file di log prima che avvenga l'analisi dei record. Si tratta di un'opzione facoltativa e il valore di default è 0.
Encoding
Per impostazione predefinita, Kinesis Agent per Windows è in grado di rilevare automaticamente la codifica dal bytemark. Tuttavia, la codifica automatica potrebbe non funzionare correttamente su alcuni formati unicode precedenti. Nell'esempio seguente viene specificata la codifica necessaria per eseguire lo streaming di un registro di Microsoft SQL Server.
```
"Encoding": "utf-16"
```
Per un elenco dei nomi di codifica, consulta[Elenco delle codificazioni](https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding?view=netframework-4.8#list-of-encodings)nella documentazione di Microsoft.NET.
ExtractionRegexOptions
È possibile utilizzare`ExtractionRegexOptions`Per semplificare le espressioni regolari. Questa coppia chiave-valore è facoltativa. Il valore di default è `"None"`.
L'esempio seguente specifica che l'`"."`l'espressione corrisponde a qualsiasi carattere incluso`\r\n`: .
```
"ExtractionRegexOptions" = "Multiline"
```
Per un elenco dei campi possibili per ExtractionRegexOptions, consulta le[RegexOptions Enum](https://docs.microsoft.com/en-us/dotnet/api/system.text.regularexpressions.regexoptions?view=netframework-4.7.2#fields)nella documentazione di Microsoft.NET.
### Parser di record `Regex`
È possibile analizzare i log di testo non strutturati usando il parser di record `Regex` insieme alle coppie chiave-valore `TimestampFormat`, `Pattern` e `ExtractionPattern`. Supponiamo, ad esempio, che il file di log appaia come il seguente:
```
[FATAL][2017/05/03 21:31:00.534][0x00003ca8][0000059c][][ActivationSubSystem][GetActivationForSystemID][0] 'ActivationException.File: EQCASLicensingSubSystem.cpp'
[FATAL][2017/05/03 21:31:00.535][0x00003ca8][0000059c][][ActivationSubSystem][GetActivationForSystemID][0] 'ActivationException.Line: 3999'
```
È possibile specificare l'espressione regolare per la coppia chiave-valore `Pattern` per aiutare a dividere il file di log in singole voci di log:
```
^\[\w+\]\[(?\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\]
```
Questa espressione regolare corrisponde alla sequenza seguente:
1. La posizione iniziale della stringa analizzata.
1. Uno o più caratteri di parole racchiusi in parentesi quadre.
1. Un timestamp circondato da parentesi quadre. Al timestamp corrisponde la sequenza indicata:
1. Anno a quattro cifre
1. Una barra
1. Mese di due cifre
1. Una barra
1. Giorno di due cifre
1. Carattere di spazio
1. Ora di due cifre
1. Due punti
1. Minuto di due cifre
1. Due punti
1. Secondo di due cifre
1. Un punto
1. Millisecondo di tre cifre
È possibile specificare il formato seguente per la coppia chiave-valore `TimestampFormat` per convertire il timestamp testuale in una data e un'ora:
```
yyyy/MM/dd HH:mm:ss.fff
```
È possibile utilizzare la seguente espressione regolare per estrarre i campi dei record di log tramite la coppia chiave-valore `ExtractionPattern`.
```
^\[(?\w+)\]\[(?\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\]\[[^]]*\]\[[^]]*\]\[[^]]*\]\[(?\w+)\]\[(?\w+)\]\[[^]]*\] '(?.*)'$
```
Questa espressione regolare corrisponde ai seguenti gruppi in sequenza:
1. `Severity`— Uno o più caratteri di parole racchiusi in parentesi quadre.
1. `TimeStamp`— Consulta la descrizione precedente per il timestamp.
1. Tre sequenze tra parentesi quadre senza nome di zero o più caratteri vengono ignorate.
1. `SubSystem`— Uno o più caratteri di parole racchiusi in parentesi quadre.
1. `Module`— Uno o più caratteri di parole racchiusi in parentesi quadre.
1. Una sequenza tra parentesi quadre senza nome di zero o più caratteri viene ignorata.
1. Uno spazio senza nome viene ignorato.
1. `Message`— Zero o più caratteri racchiusi in virgolette singole.
La seguente dichiarazione di origine abbina queste espressioni regolari e il formato data ora per fornire le istruzioni complete all'agente Kinesis per Windows per l'analisi di questo tipo di file di log.
```
{
"Id": "PrintLog",
"SourceType": "DirectorySource",
"Directory": "C:\\temp\\PrintLogTest",
"FileNameFilter": "*.log",
"RecordParser": "Regex",
"TimestampFormat": "yyyy/MM/dd HH:mm:ss.fff",
"Pattern": "^\\[\\w+\\]\\[(?\\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3})\\]",
"ExtractionPattern": "^\\[(?\\w+)\\]\\[(?\\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2}\\.\\d{3})\\]\\[[^]]*\\]\\[[^]]*\\]\\[[^]]*\\]\\[(?\\w+)\\]\\[(?\\w+)\\]\\[[^]]*\\] '(?.*)'$",
"TimeZoneKind": "UTC"
}
```
**Nota**
Le barre oblique in file in formato JSON devono essere precedute da un'ulteriore barra obliqua.
Per ulteriori informazioni sulle espressioni regolari, vedere [Regular Expression Language - Guida di riferimento rapida](https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference) nella documentazione di Microsoft.NET.
### Parser di record `Delimited`
È possibile usare il parser di record `Delimited` per analizzare file di dati e di log semistrutturati in cui vi è una sequenza di caratteri coerente che separa ogni colonna di dati in ogni riga di dati. Ad esempio, i file CSV utilizzano la virgola per separare ogni colonna di dati, mentre i file TSV utilizzano una tabulazione.
Supponiamo che si desidera analizzare un file di log Microsoft [NPS Database Format](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc771748(v=ws.10)) creato da un server dei criteri di rete. Di seguito è riportato un possibile esempio di tale file:
```
"NPS-MASTER","IAS",03/22/2018,23:07:55,1,"user1","Domain1\user1",,,,,,,,0,"192.168.86.137","Nate - Test 1",,,,,,,1,,0,"311 1 192.168.0.213 03/15/2018 08:14:29 1",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"Use Windows authentication for all users",1,,,,
"NPS-MASTER","IAS",03/22/2018,23:07:55,3,,"Domain1\user1",,,,,,,,0,"192.168.86.137","Nate - Test 1",,,,,,,1,,16,"311 1 192.168.0.213 03/15/2018 08:14:29 1",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"Use Windows authentication for all users",1,,,,
```
Il seguente file di configurazione di esempio `DirectorySource` include una dichiarazione `appsettings.json` che utilizza il parser di record `Delimited` per analizzare questo testo nella rappresentazione di un oggetto. Quindi, effettua lo streaming di dati in formato JSON a Kinesis Data Firehose:
```
{
"Sources": [
{
"Id": "NPS",
"SourceType": "DirectorySource",
"Directory": "C:\\temp\\NPS",
"FileNameFilter": "*.log",
"RecordParser": "Delimited",
"Delimiter": ",",
"Headers": "ComputerName,ServiceName,Record-Date,Record-Time,Packet-Type,User-Name,Fully-Qualified-Distinguished-Name,Called-Station-ID,Calling-Station-ID,Callback-Number,Framed-IP-Address,NAS-Identifier,NAS-IP-Address,NAS-Port,Client-Vendor,Client-IP-Address,Client-Friendly-Name,Event-Timestamp,Port-Limit,NAS-Port-Type,Connect-Info,Framed-Protocol,Service-Type,Authentication-Type,Policy-Name,Reason-Code,Class,Session-Timeout,Idle-Timeout,Termination-Action,EAP-Friendly-Name,Acct-Status-Type,Acct-Delay-Time,Acct-Input-Octets,Acct-Output-Octets,Acct-Session-Id,Acct-Authentic,Acct-Session-Time,Acct-Input-Packets,Acct-Output-Packets,Acct-Terminate-Cause,Acct-Multi-Ssn-ID,Acct-Link-Count,Acct-Interim-Interval,Tunnel-Type,Tunnel-Medium-Type,Tunnel-Client-Endpt,Tunnel-Server-Endpt,Acct-Tunnel-Conn,Tunnel-Pvt-Group-ID,Tunnel-Assignment-ID,Tunnel-Preference,MS-Acct-Auth-Type,MS-Acct-EAP-Type,MS-RAS-Version,MS-RAS-Vendor,MS-CHAP-Error,MS-CHAP-Domain,MS-MPPE-Encryption-Types,MS-MPPE-Encryption-Policy,Proxy-Policy-Name,Provider-Type,Provider-Name,Remote-Server-Address,MS-RAS-Client-Name,MS-RAS-Client-Version",
"TimestampField": "{Record-Date} {Record-Time}",
"TimestampFormat": "MM/dd/yyyy HH:mm:ss"
}
],
"Sinks": [
{
"Id": "npslogtest",
"SinkType": "KinesisFirehose",
"Region": "us-west-2",
"StreamName": "npslogtest",
"Format": "json"
}
],
"Pipes": [
{
"Id": "W3SVCLog1ToKinesisStream",
"SourceRef": "NPS",
"SinkRef": "npslogtest"
}
]
}
```
I dati in formato JSON trasmessi in streaming a Kinesis Data Firehose hanno l'aspetto seguente:
```
{
"ComputerName": "NPS-MASTER",
"ServiceName": "IAS",
"Record-Date": "03/22/2018",
"Record-Time": "23:07:55",
"Packet-Type": "1",
"User-Name": "user1",
"Fully-Qualified-Distinguished-Name": "Domain1\\user1",
"Called-Station-ID": "",
"Calling-Station-ID": "",
"Callback-Number": "",
"Framed-IP-Address": "",
"NAS-Identifier": "",
"NAS-IP-Address": "",
"NAS-Port": "",
"Client-Vendor": "0",
"Client-IP-Address": "192.168.86.137",
"Client-Friendly-Name": "Nate - Test 1",
"Event-Timestamp": "",
"Port-Limit": "",
"NAS-Port-Type": "",
"Connect-Info": "",
"Framed-Protocol": "",
"Service-Type": "",
"Authentication-Type": "1",
"Policy-Name": "",
"Reason-Code": "0",
"Class": "311 1 192.168.0.213 03/15/2018 08:14:29 1",
"Session-Timeout": "",
"Idle-Timeout": "",
"Termination-Action": "",
"EAP-Friendly-Name": "",
"Acct-Status-Type": "",
"Acct-Delay-Time": "",
"Acct-Input-Octets": "",
"Acct-Output-Octets": "",
"Acct-Session-Id": "",
"Acct-Authentic": "",
"Acct-Session-Time": "",
"Acct-Input-Packets": "",
"Acct-Output-Packets": "",
"Acct-Terminate-Cause": "",
"Acct-Multi-Ssn-ID": "",
"Acct-Link-Count": "",
"Acct-Interim-Interval": "",
"Tunnel-Type": "",
"Tunnel-Medium-Type": "",
"Tunnel-Client-Endpt": "",
"Tunnel-Server-Endpt": "",
"Acct-Tunnel-Conn": "",
"Tunnel-Pvt-Group-ID": "",
"Tunnel-Assignment-ID": "",
"Tunnel-Preference": "",
"MS-Acct-Auth-Type": "",
"MS-Acct-EAP-Type": "",
"MS-RAS-Version": "",
"MS-RAS-Vendor": "",
"MS-CHAP-Error": "",
"MS-CHAP-Domain": "",
"MS-MPPE-Encryption-Types": "",
"MS-MPPE-Encryption-Policy": "",
"Proxy-Policy-Name": "Use Windows authentication for all users",
"Provider-Type": "1",
"Provider-Name": "",
"Remote-Server-Address": "",
"MS-RAS-Client-Name": "",
"MS-RAS-Client-Version": ""
}
```
### Parser di record `SysLog`
Per il parser di record `SysLog`, l'output analizzato dalla sorgente include le informazioni riportate di seguito:
| Attributo | Tipo | Descrizione |
| --- | --- | --- |
| SysLogTimeStamp | Stringa | La data e l'ora originali dal file di log in formato syslog. |
| Hostname | Stringa | Il nome del computer in cui risiede il file di log in formato syslog. |
| Program | Stringa | Il nome dell'applicazione o del servizio che ha generato il file di log. |
| Message | Stringa | Il messaggio di log generato dall'applicazione o dal servizio. |
| TimeStamp | Stringa | La data e l'ora analizzati nel formato ISO 8601. |
Di seguito è riportato un esempio di dati SysLog trasformati nel formato JSON:
```
{
"SysLogTimeStamp": "Jun 18 01:34:56",
"Hostname": "myhost1.example.mydomain.com",
"Program": "mymailservice:",
"Message": "Info: ICID 123456789 close",
"TimeStamp": "2017-06-18T01:34.56.000"
}
```
### Summary
Di seguito sono illustrate le coppie chiave-valore disponibili per l'origine `DirectorySource` e i `RecordParser` relativi alle coppie chiave-valore.
| Nome chiave | RecordParser | Note |
| --- | --- | --- |
| SourceType | Obbligatorio per tutti | Deve avere il valore DirectorySource |
| Directory | Obbligatorio per tutti | |
| FileNameFilter | Facoltativo per tutti | |
| RecordParser | Obbligatorio per tutti | |
| TimestampField | Facoltativo per SingleLineJson | |
| TimestampFormat | Richiesto per Timestamp e per SingleLineJson se viene specificato il TimestampField | |
| Pattern | Obbligatorio per Regex | |
| ExtractionPattern | Facoltativo per Regex | Richiesto per Regex se il sink specifica il formato json o xml |
| Delimiter | Obbligatorio per Delimited | |
| HeaderPattern | Facoltativo per Delimited | |
| Headers | Facoltativo per Delimited | |
| RecordPattern | Facoltativo per Delimited | |
| CommentPattern | Facoltativo per Delimited | |
| TimeZoneKind | Facoltativo per Regex, Timestamp, SysLog e SingleLineJson quando viene identificato un campo data e ora | |
| SkipLines | Facoltativo per tutti | |
## Configurazione ExchangeLogSource
Il tipo `ExchangeLogSource` viene utilizzato per raccogliere i log da Microsoft Exchange. Exchange produce log in diversi tipi di formati di log. Questo tipo di origine li analizza tutti. Sebbene sia possibile analizzarli utilizzando il tipo `DirectorySource` con il record parser `Regex`, è molto più semplice utilizzare `ExchangeLogSource`. Questo perché non è più necessario progettare e fornire espressioni regolari per i formati di file di log. Di seguito è riportato un esempio della dichiarazione `ExchangeLogSource`:
```
{
"Id": "MyExchangeLog",
"SourceType": "ExchangeLogSource",
"Directory": "C:\\temp\\ExchangeLogTest",
"FileNameFilter": "*.log"
}
```
Tutte le dichiarazioni di scambio possono offrire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"ExchangeLogSource"` (obbligatoria).
`Directory`
Il percorso alla directory contenente i file di log (obbligatorio).
`FileNameFilter`
Eventualmente limita il set di file nella directory in cui i dati di log sono raccolti in base al modello di denominazione dei file jolly. Se questa coppia chiave-valore non viene specificata, allora, per impostazione predefinita, vengono raccolti i dati di log da parte di tutti i file nella directory.
`TimestampField`
Il nome della colonna contenente la data e l'ora del record. Questa coppia chiave-valore è facoltativa e non deve essere specificata se il nome del campo è `date-time` o `DateTime`. Altrimenti, è obbligatoria.
## Configurazione W3SVCLogSource
Il tipo `W3SVCLogSource` viene utilizzato per raccogliere i log da Internet Information Services (IIS) per Windows.
Di seguito è riportato un esempio della dichiarazione `W3SVCLogSource`:
```
{
"Id": "MyW3SVCLog",
"SourceType": "W3SVCLogSource",
"Directory": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
"FileNameFilter": "*.log"
}
```
Tutte le dichiarazioni `W3SVCLogSource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"W3SVCLogSource"` (obbligatoria).
`Directory`
Il percorso alla directory contenente i file di log (obbligatorio).
`FileNameFilter`
Eventualmente limita il set di file nella directory in cui i dati di log sono raccolti in base al modello di denominazione dei file jolly. Se questa coppia chiave-valore non viene specificata, allora, per impostazione predefinita, vengono raccolti i dati di log da parte di tutti i file nella directory.
## Configurazione UlsSource
Il tipo `UlsSource` viene utilizzato per raccogliere i log da Microsoft SharePoint. Di seguito è riportato un esempio della dichiarazione `UlsSource`:
```
{
"Id": "UlsSource",
"SourceType": "UlsSource",
"Directory": "C:\\temp\\uls",
"FileNameFilter": "*.log"
}
```
Tutte le dichiarazioni `UlsSource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"UlsSource"` (obbligatoria).
`Directory`
Il percorso alla directory contenente i file di log (obbligatorio).
`FileNameFilter`
Eventualmente limita il set di file nella directory in cui i dati di log sono raccolti in base al modello di denominazione dei file jolly. Se questa coppia chiave-valore non viene specificata, allora, per impostazione predefinita, vengono raccolti i dati di log da parte di tutti i file nella directory.
## Configurazione WindowsEventLogSource
Il tipo `WindowsEventLogSource` viene utilizzato per raccogliere gli eventi dal servizio Log eventi di Windows. Di seguito è riportato un esempio della dichiarazione `WindowsEventLogSource`:
```
{
"Id": "mySecurityLog",
"SourceType": "WindowsEventLogSource",
"LogName": "Security"
}
```
Tutte le dichiarazioni `WindowsEventLogSource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"WindowsEventLogSource"` (obbligatoria).
`LogName`
Gli eventi vengono raccolti dal log specificato. I valori comuni includono `Application`, `Security` e `System`, ma è possibile specificare qualsiasi nome di log di eventi di Windows valido. Questa coppia chiave-valore è obbligatoria.
`Query`
Eventualmente limita gli eventi output di `WindowsEventLogSource`. Se questa coppia chiave-valore non viene specificata, allora, per impostazione predefinita, tutti gli eventi sono output. Per ulteriori informazioni sulla sintassi di questo valore, consulta [Query ed XML di eventi](https://msdn.microsoft.com/en-us/library/bb399427(v=vs.90).aspx) nella documentazione di Windows. Per ulteriori informazioni sulle definizioni del livello di log, consulta [Tipi di eventi](https://docs.microsoft.com/en-us/windows/desktop/eventlog/event-types) nella documentazione di Windows.
`IncludeEventData`
Eventualmente consente la raccolta e lo streaming di dati di eventi specifici del provider associati a eventi dal log di eventi di Windows specificato quando il valore di questa coppia chiave-valore è `"true"`. Vengono inclusi solo i dati di eventi che possono essere correttamente serializzati. Questa coppia chiave-valore è facoltativa e, se non è specificata, i dati di eventi specifici del provider non vengono raccolti.
L'inclusione di dati relativi a eventi potrebbe aumentare in modo significativo la quantità di dati provenienti da questa origine. La dimensione massima di un evento può essere 262.143 byte con dati relativi a eventi inclusi.
L'output analizzato da `WindowsEventLogSource` contiene le informazioni riportate di seguito:
| Attributo | Tipo | Descrizione |
| --- | --- | --- |
| EventId | Int | L'identificatore del tipo di evento. |
| Description | Stringa | Testo che descrive i dettagli dell'evento. |
| LevelDisplayName | Stringa | La categoria dell'evento (uno tra Error, Warning, Information, Success Audit, Failure Audit). |
| LogName | Stringa | Dove l'evento è stato registrato (i valori tipici sono Application, Security e System, ma ci sono molte possibilità). |
| MachineName | Stringa | Quale computer ha registrato l'evento. |
| ProviderName | Stringa | Quale applicazione o servizio ha registrato l'evento. |
| TimeCreated | Stringa | Quando si è verificato l'evento nel formato ISO 8601. |
| Index | Int | Dove si trova la voce all'interno del log. |
| UserName | Stringa | Chi ha creato la voce, se noto. |
| Keywords | Stringa | Tipo di evento. I valori standard includono AuditFailure (eventi di audit di sicurezza non riusciti), AuditSuccess (eventi di audit di sicurezza riusciti), Classic (eventi generati con la funzione RaiseEvent), Correlation Hint (eventi di trasferimento), SQM (eventi Service Quality Mechanism), WDI Context (eventi di contesto infrastrutturale della diagnostica Windows) e WDI Diag (eventi di diagnostica infrastrutturale della diagnostica Windows). |
| EventData | Elenco di oggetti | Dati aggiuntivi facoltativi specifici del provider sull'evento di log. Questo è incluso solo se il valore per la coppia chiave-valore IncludeEventData è "true". |
Di seguito è illustrato un esempio di un evento trasformato in JSON:
```
{[
"EventId": 7036,
"Description": "The Amazon SSM Agent service entered the stopped state.",
"LevelDisplayName": "Informational",
"LogName": "System",
"MachineName": "mymachine.mycompany.com",
"ProviderName": "Service Control Manager",
"TimeCreated": "2017-10-04T16:42:53.8921205Z",
"Index": 462335,
"UserName": null,
"Keywords": "Classic",
"EventData": [
"Amazon SSM Agent",
"stopped",
"rPctBAMZFhYubF8zVLcrBd3bTTcNzHvY5Jc2Br0aMrxxx=="
]}
```
## Configurazione WindowsEventLogPollingSource
`WindowsEventLogPollingSource`utilizza un meccanismo basato sul polling per raccogliere tutti i nuovi eventi dal registro eventi che corrispondono ai parametri configurati. L'intervallo di polling viene aggiornato dinamicamente tra 100 ms e 5000 ms a seconda del numero di eventi raccolti durante l'ultimo sondaggio. Di seguito è riportato un esempio della dichiarazione `WindowsEventLogPollingSource`:
```
{
"Id": "MySecurityLog",
"SourceType": "WindowsEventLogPollingSource",
"LogName": "Security",
"IncludeEventData": "true",
"Query": "",
"CustomFilters": "ExcludeOwnSecurityEvents"
}
```
Tutte le dichiarazioni `WindowsEventLogPollingSource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"WindowsEventLogPollingSource"` (obbligatoria).
`LogName`
Specifica il registro. Opzioni valide sono`Application`,`Security`,`System`o altri registri validi.
`IncludeEventData`
Facoltativo. Quando`true`, specifica che EventData extra quando viene eseguito lo streaming come JSON e XML è incluso. Il valore predefinito è `false`.
`Query`
Facoltativo. I registri eventi di Windows supportano l'esecuzione di query di eventi utilizzando espressioni XPath, che è possibile specificare utilizzando`Query`: . Per ulteriori informazioni, consulta[Query di eventi e XML di eventi](https://docs.microsoft.com/en-us/previous-versions/bb399427(v=vs.90))nella documentazione di Microsoft.
`CustomFilters`
Facoltativo. Un elenco di filtri separati da un punto e virgola (`;`). È possibile specificare i seguenti filtri.
`ExcludeOwnSecurityEvents`
Esclude gli eventi di protezione generati dall'agente Kinesis per Windows stesso.
## Configurazione WindowsETWEventSource
Il tipo `WindowsETWEventSource` viene utilizzato per raccogliere tracce di eventi di servizi e di applicazioni utilizzando una funzionalità denominata Event Tracing for Windows (ETW). Per ulteriori informazioni, consulta [Tracciamento degli eventi](https://docs.microsoft.com/en-us/windows/desktop/etw/event-tracing-portal) nella documentazione di Windows.
Di seguito è riportato un esempio della dichiarazione `WindowsETWEventSource`:
```
{
"Id": "ClrETWEventSource",
"SourceType": "WindowsETWEventSource",
"ProviderName": "Microsoft-Windows-DotNETRuntime",
"TraceLevel": "Verbose",
"MatchAnyKeyword": 32768
}
```
Tutte le dichiarazioni `WindowsETWEventSource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"WindowsETWEventSource"` (obbligatoria).
`ProviderName`
Specifica quale provider di eventi utilizzare per raccogliere gli eventi di traccia. Questo deve essere un nome di provider ETW valido per un fornitore installato. Per stabilire quali fornitori sono installati, eseguire il seguente comando in una finestra del prompt dei comandi di Windows:
```
logman query providers
```
`TraceLevel`
Specifica quali categorie di eventi di traccia devono essere raccolte. I valori consentiti includono `Critical`, `Error`, `Warning`, `Informational` e `Verbose`. Il significato esatto dipende dal provider ETW selezionato.
`MatchAnyKeyword`
Questo valore è un numero a 64 bit, in cui ogni bit rappresenta una singola parola chiave. Ogni parola chiave descrive una categoria di eventi da raccogliere. Per le parole chiave supportate e i relativi valori e come sono correlati a `TraceLevel`, consulta la documentazione del provider relativo. Ad esempio, per informazioni sul provider CLR ETW, consulta [Parole chiave e livelli CLR ETW](https://docs.microsoft.com/en-us/dotnet/framework/performance/clr-etw-keywords-and-levels) nella documentazione di Microsoft.NET Framework.
Nell'esempio precedente, 32768 (0x00008000) rappresenta la `ExceptionKeyword` per il provider CLR ETW che indica al provider di raccogliere informazioni sulle eccezioni generate. Sebbene JSON non supporti nativamente costanti hex, è possibile specificarle per `MatchAnyKeyword` inserendole in una stringa. È anche possibile specificare diverse costanti separate da virgole. Ad esempio, è possibile usare quanto segue per specificare `ExceptionKeyword` e `SecurityKeyword` (0x00000400):
```
{
"Id": "MyClrETWEventSource",
"SourceType": "WindowsETWEventSource",
"ProviderName": "Microsoft-Windows-DotNETRuntime",
"TraceLevel": "Verbose",
"MatchAnyKeyword": "0x00008000, 0x00000400"
}
```
Per assicurarsi che tutte le parole chiave specificate per un provider vengano attivate, vengono abbinati più valori di parole chiave utilizzando O che vengono trasferiti poi a tale provider.
L'output da `WindowsETWEventSource` contiene le informazioni riportate di seguito per ogni evento:
| Attributo | Tipo | Descrizione |
| --- | --- | --- |
| EventName | Stringa | Che tipo di evento si è verificato. |
| ProviderName | Stringa | Quale provider ha rilevato l'evento. |
| FormattedMessage | Stringa | Un riepilogo testuale dell'evento. |
| ProcessID | Int | Quale processo ha segnalato l'evento. |
| ExecutingThreadID | Int | Quale thread all'interno del processo ha segnalato l'evento. |
| MachineName | Stringa | Il nome del desktop o del server che effettua la segnalazione dell'evento. |
| Payload | Tabella hash | Una tabella con una chiave stringa e qualsiasi tipo di oggetto come valore. La chiave è il nome della voce di payload e il valore è il valore della voce di payload. Il payload dipende dal provider. |
Di seguito è illustrato un esempio di un evento trasformato in JSON:
```
{
"EventName": "Exception/Start",
"ProviderName": "Microsoft-Windows-DotNETRuntime",
"FormattedMessage": "ExceptionType=System.Exception;\r\nExceptionMessage=Intentionally unhandled exception.;\r\nExceptionEIP=0x2ab0499;\r\nExceptionHRESULT=-2,146,233,088;\r\nExceptionFlags=CLSCompliant;\r\nClrInstanceID=9 ",
"ProcessID": 3328,
"ExecutingThreadID": 6172,
"MachineName": "MyHost.MyCompany.com",
"Payload":
{
"ExceptionType": "System.Exception",
"ExceptionMessage": "Intentionally unhandled exception.",
"ExceptionEIP": 44762265,
"ExceptionHRESULT": -2146233088,
"ExceptionFlags": 16,
"ClrInstanceID": 9
}
}
```
## Configurazione WindowsPerformanceCounterSource
Il tipo `WindowsPerformanceCounterSource` raccoglie parametri contatori di prestazioni da Windows. Di seguito è riportato un esempio della dichiarazione `WindowsPerformanceCounterSource`:
```
{
"Id": "MyPerformanceCounter",
"SourceType": "WindowsPerformanceCounterSource",
"Categories": [{
"Category": "Server",
"Counters": ["Files Open", "Logon Total", "Logon/sec", "Pool Nonpaged Bytes"]
},
{
"Category": "System",
"Counters": ["Processes", "Processor Queue Length", "System Up Time"]
},
{
"Category": "LogicalDisk",
"Instances": "*",
"Counters": [
"% Free Space", "Avg. Disk Queue Length",
{
"Counter": "Disk Reads/sec",
"Unit": "Count/Second"
},
"Disk Writes/sec"
]
},
{
"Category": "Network Adapter",
"Instances": "^Local Area Connection\* \d$",
"Counters": ["Bytes Received/sec", "Bytes Sent/sec"]
}
]
}
```
Tutte le dichiarazioni `WindowsPerformanceCounterSource` possono fornire le seguenti coppie chiave-valore:
`SourceType`
Deve essere una stringa letterale `"WindowsPerformanceCounterSource"` (obbligatoria).
`Categories`
Specifica un set di gruppi di parametri contatori delle prestazioni da raccogliere da Windows. Ogni gruppo di parametri contiene le seguenti coppie chiave-valore:
`Category`
Specifica il set di contatori di parametri da raccogliere (obbligatorio).
`Instances`
Specifica il set di oggetti di interesse quando c'è un set unico di contatori delle prestazioni per oggetto. Ad esempio, quando la categoria è `LogicalDisk`, c'è un set di contatori delle prestazioni per unità disco. Questa coppia chiave-valore è facoltativa. È possibile utilizzare i caratteri jolly `*` e `?` per soddisfare più istanze. Per aggregare i valori su tutte le istanze, specificare `_Total`.
È possibile utilizzare anche`InstanceRegex`, che accetta espressioni regolari che contengono`*`carattere jolly come parte del nome dell'istanza.
`Counters`
Specifica quali parametri raccogliere per la categoria specificata. Questa coppia chiave-valore è obbligatoria. È possibile utilizzare i caratteri jolly `*` e `?` per soddisfare più contatori. È possibile specificare `Counters` utilizzando solo il nome oppure utilizzando il nome e l'unità. Se le unità del contatore non sono specificate, Kinesis Agent per Windows tenta di dedurre le unità dal nome. Se tali estrapolazioni non sono corrette, l'unità può essere specificata in modo esplicito. È possibile modificare i nomi dei `Counter`, se necessario. La rappresentazione più complessa di un contatore è un oggetto con le seguenti coppie chiave-valore:
`Counter`
Il nome del contatore. Questa coppia chiave-valore è obbligatoria.
`Rename`
Il nome del contatore da presentare al sink. Questa coppia chiave-valore è facoltativa.
`Unit`
Il significato del valore associato al contatore. Per un elenco completo dei nomi di unità validi, consulta la documentazione sulle unità in[MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html)nella*Guida di riferimento all'API di Amazon CloudWatch*: .
Di seguito è riportato un esempio di una specifica complessa di un contatore:
```
{
"Counter": "Disk Reads/sec,
"Rename": "Disk Reads per second",
"Unit": "Count/Second"
}
```
`WindowsPerformanceCounterSource`Può essere utilizzato solo con una pipe che specifica un sink Amazon CloudWatch. Utilizzare un sink separato se i parametri integrati di Kinesis Agent per Windows vengono trasmessi in streaming anche a CloudWatch. Esaminare il log di Kinesis Agent per Windows dopo l'avvio del servizio per stabilire quali unità sono state desunte per i contatori quando queste non sono state specificate nella finestra di`WindowsPerformanceCounterSource`Dichiarazioni. Utilizzare PowerShell per stabilire i nomi validi per categorie, istanze e contatori.
Per visualizzare informazioni su tutte le categorie, inclusi i contatori associati a set di contatori, eseguire questo comando in una finestra di PowerShell:
```
Get-Counter -ListSet * | Sort-Object
```
Per stabilire quali istanze sono disponibili per ciascuno dei contatori nel set di contatori, eseguire un comando simile a quello dell'esempio seguente in una finestra di PowerShell:
```
Get-Counter -Counter "\Process(*)\% Processor Time"
```
Il valore del parametro `Counter` deve essere uno dei percorsi da un membro `PathsWithInstances` elencato dalla precedente invocazione del comando `Get-Counter -ListSet`.
## Origine dei parametri integrati di Kinesis Agent per Windows
Oltre alle fonti di metriche ordinarie, come il`WindowsPerformanceCounterSource`tipo (vedere[Configurazione WindowsPerformanceCounterSource](#performance-counter-source-configuration)), il tipo di sink CloudWatch è in grado di ricevere i parametri da un'origine speciale che raccoglie i parametri sull'agente Kinesis per Windows. I parametri di Kinesis Agent per Windows sono disponibili anche nella`KinesisTap`dei contatori delle prestazioni di Windows.
La`MetricsFilter`La coppia chiave-valore per le dichiarazioni sink CloudWatch specifica quali parametri vengono trasmessi a CloudWatch dall'origine integrata di parametri Kinesis Agent per Windows. Il valore è una stringa che contiene una o più espressioni di filtro separate da punti e virgola; ad esempio:
`"MetricsFilter": "`*FilterExpression1*`;`*FilterExpression2*`"`
Una metrica che corrisponde a una o più espressioni di filtro viene inviata in streaming a CloudWatch.
I parametri di istanze singole sono di natura globale e non sono associati a origini o sink particolari. I parametri di più istanze sono dimensionali in base alla sorgente o alla dichiarazione del sink `Id`. Ogni tipo di origine o sink può avere una serie diversa di parametri.
Per un elenco dei nomi dei parametri integrati di Kinesis Agent per Windows, consulta[Elenco delle metriche di Kinesis Agent per Windows](#kinesis-agent-metric-list): .
Per i parametri di una singola istanza, l'espressione di filtro è il nome della metrica, ad esempio:
```
"MetricsFilter": "SourcesFailedToStart;SinksFailedToStart"
```
Per più parametri di istanza, l'espressione del filtro è il nome del parametro, un punto (`.`) e quindi l'`Id` dell'origine o la dichiarazione del sink che ha generato tale parametro. Ad esempio, supponiamo che ci sia una dichiarazione sink con un `Id` di `MyFirehose`:
```
"MetricsFilter": "KinesisFirehoseRecordsFailedNonrecoverable.MyFirehose"
```
È possibile utilizzare i modelli di carattere jolly speciali progettati per distinguere i parametri di istanze singole e multiple.
+ L'asterisco (`*`) corrisponde a zero o più caratteri tranne il punto (`.`).
+ Il punto interrogativo (`?`) corrisponde a un carattere tranne il punto.
+ Qualsiasi altro carattere corrisponde solo a se stesso.
+ `_Total` è un token speciale che provoca l'aggregazione di tutti i valori che corrispondono a più istanze in tutta la dimensione.
L'esempio seguente corrisponde a tutti i parametri di istanze singole:
```
"MetricsFilter": "*"
```
Poiché un asterisco non corrisponde al carattere punto, sono inclusi solo i parametri di istanze singole.
L'esempio seguente corrisponde a tutti i parametri di istanze multiple:
```
"MetricsFilter": "*.*"
```
L'esempio seguente corrisponde a tutti i parametri (singoli e multipli):
```
"MetricsFilter": "*;*.*"
```
L'esempio seguente aggrega tutti i parametri di istanze multiple in tutte le origini e i sink:
```
"MetricsFilter": "*._Total"
```
L'esempio seguente aggrega tutti i parametri di Kinesis Data Firehose per tutti i sink di Kinesis Data:
```
"MetricsFilter": "*Firehose*._Total"
```
L'esempio seguente corrisponde a tutti i parametri di errore delle istanze singole e multiple:
```
"MetricsFilter": "*Failed*;*Error*.*;*Failed*.*"
```
L'esempio seguente corrisponde a tutti i parametri di errori non recuperabili in tutte le origini e i sink:
```
"MetricsFilter": "*Nonrecoverable*._Total"
```
Per informazioni su come specificare una pipe che utilizza l'origine dei parametri integrati di Kinesis Agent per Windows, vedi[Configurazione dell'agente Kinesis per le pipe metriche di Windows](pipe-object-declarations.md#kinesis-agent-metric-pipe-configuration): .
## Elenco delle metriche di Kinesis Agent per Windows
Di seguito è riportato un elenco di parametri di istanze singole e multiple disponibili per Kinesis Agent per Windows.
### Parametri di istanze singole
Sono disponibili i seguenti parametri di istanze singole:
`KinesisTapBuildNumber`
Il numero di versione di Kinesis Agent per Windows.
`PipesConnected`
Quante pipe hanno collegato l'origine al sink in modo corretto.
`PipesFailedToConnect`
Quante pipe hanno collegato l'origine al sink in modo errato.
`SinkFactoriesFailedToLoad`
Quanti tipi di sink non è stato possibile caricare in Kinesis Agent per Windows correttamente.
`SinkFactoriesLoaded`
Quanti tipi di sink sono stati caricati in Kinesis Agent per Windows correttamente.
`SinksFailedToStart`
Quanti sink non sono stati iniziati correttamente, di solito a causa di dichiarazioni sink errate.
`SinksStarted`
Quanti sink sono stati avviati correttamente.
`SourcesFailedToStart`
Quante origini non sono state iniziate correttamente, di solito a causa di dichiarazioni errate.
`SourcesStarted`
Quante origini sono state avviate correttamente.
`SourceFactoriesFailedToLoad`
Quanti tipi di origine non sono stati caricati in Kinesis Agent per Windows correttamente.
`SourceFactoriesLoaded`
Quanti tipi di origine sono stati caricati in Kinesis Agent per Windows.
### Parametri di istanze multiple
Per le istanze multiple sono disponibili i seguenti parametri:
#### Parametri DirectorySource
`DirectorySourceBytesRead`
Quanti byte sono stati letti durante l'intervallo per questo `DirectorySource`.
`DirectorySourceBytesToRead`
Quanti numeri noti di byte sono disponibili da leggere che non sono stati ancora letti da Kinesis Agent per Windows.
`DirectorySourceFilesToProcess`
Quanti file noti da esaminare che non sono ancora stati esaminati da Kinesis Agent per Windows.
`DirectorySourceRecordsRead`
Quanti record sono stati letti durante l'intervallo per questo `DirectorySource`.
#### Parametri WindowsEventLogSource
`EventLogSourceEventsError`
Quanti eventi di log di eventi di Windows non sono stati letti correttamente.
`EventLogSourceEventsRead`
Quanti eventi di log di eventi di Windows sono stati letti correttamente.
#### Parametri sink KinesisFirehose
`KinesisFirehoseBytesAccepted`
Quanti byte sono stati accettati durante l'intervallo.
`KinesisFirehoseClientLatency`
Quanto tempo è trascorso tra la generazione e lo streaming dei record al servizio Kinesis Data Firehose.
`KinesisFirehoseLatency`
Quanto tempo è trascorso tra l'inizio e la fine dello streaming dei record al servizio Kinesis Data Firehose.
`KinesisFirehoseNonrecoverableServiceErrors`
Quante volte i record non potevano essere inviati senza errori al servizio Kinesis Data Firehose nonostante i tentativi.
`KinesisFirehoseRecordsAttempted`
Quanti record hanno tentato di eseguire lo streaming al servizio Kinesis Data Firehose.
`KinesisFirehoseRecordsFailedNonrecoverable`
Quanti record non sono stati trasmessi correttamente al servizio Kinesis Data Firehose nonostante i tentativi.
`KinesisFirehoseRecordsFailedRecoverable`
Quanti record sono stati trasmessi correttamente al servizio Kinesis Data Firehose ma solo dopo nuovi tentativi.
`KinesisFirehoseRecordsSuccess`
Quanti record sono stati trasmessi correttamente al servizio Kinesis Data Firehose senza nuovi tentativi.
`KinesisFirehoseRecoverableServiceErrors`
Quante volte i record sono stati inviati correttamente al servizio Kinesis Data Firehose ma solo dopo nuovi tentativi.
#### Parametri KinesisStream
`KinesisStreamBytesAccepted`
Quanti byte sono stati accettati durante l'intervallo.
`KinesisStreamClientLatency`
Quanto tempo è trascorso tra la generazione e lo streaming dei record al servizio Kinesis Data Streams.
`KinesisStreamLatency`
Quanto tempo è trascorso tra l'inizio e la fine dello streaming dei record al servizio Kinesis Data Streams.
`KinesisStreamNonrecoverableServiceErrors`
Quante volte i record non potevano essere inviati senza errori al servizio Kinesis Data Streams nonostante i tentativi.
`KinesisStreamRecordsAttempted`
Quanti record hanno tentato di eseguire lo streaming al servizio Kinesis Data Streams.
`KinesisStreamRecordsFailedNonrecoverable`
Quanti record non sono stati trasmessi correttamente al servizio Kinesis Data Streams nonostante i tentativi.
`KinesisStreamRecordsFailedRecoverable`
Quanti record sono stati trasmessi correttamente al servizio Kinesis Data Streams ma solo dopo nuovi tentativi.
`KinesisStreamRecordsSuccess`
Quanti record sono stati trasmessi correttamente al servizio Kinesis Data Streams senza nuovi tentativi.
`KinesisStreamRecoverableServiceErrors`
Quante volte i record sono stati inviati correttamente al servizio Kinesis Data Streams ma solo dopo nuovi tentativi.
#### Parametri CloudWatchLog
`CloudWatchLogBytesAccepted`
Quanti byte sono stati accettati durante l'intervallo.
`CloudWatchLogClientLatency`
Quanto tempo è trascorso tra la generazione e lo streaming dei record al servizio CloudWatch Logs.
`CloudWatchLogLatency`
Quanto tempo è trascorso tra l'inizio e la fine dello streaming dei record al servizio CloudWatch Logs.
`CloudWatchLogNonrecoverableServiceErrors`
Quante volte i record non potevano essere inviati senza errori al servizio CloudWatch Logs nonostante i tentativi.
`CloudWatchLogRecordsAttempted`
Quanti record hanno tentato di eseguire lo streaming al servizio CloudWatch Logs.
`CloudWatchLogRecordsFailedNonrecoverable`
Quanti record non sono stati trasmessi correttamente al servizio CloudWatch Logs nonostante i tentativi.
`CloudWatchLogRecordsFailedRecoverable`
Quanti record sono stati trasmessi correttamente al servizio CloudWatch Logs ma solo dopo nuovi tentativi.
`CloudWatchLogRecordsSuccess`
Quanti record sono stati trasmessi correttamente al servizio CloudWatch Logs senza nuovi tentativi.
`CloudWatchLogRecoverableServiceErrors`
Quante volte i record sono stati inviati correttamente al servizio CloudWatch Logs ma solo dopo nuovi tentativi.
#### Parametri di CloudWatch
`CloudWatchLatency`
Quanto tempo in media è trascorso tra l'inizio e la fine dello streaming dei parametri al servizio CloudWatch.
`CloudWatchNonrecoverableServiceErrors`
Quante volte i parametri non potevano essere inviati senza errori al servizio CloudWatch nonostante i tentativi.
`CloudWatchRecoverableServiceErrors`
Quante volte i parametri sono stati inviati senza errori al servizio CloudWatch ma solo dopo nuovi tentativi.
`CloudWatchServiceSuccess`
Quante volte i parametri sono stati inviati senza errori al servizio CloudWatch senza nuovi tentativi.
## Configurazione del segnalibro
Per impostazione predefinita, Kinesis Agent per Windows invia i record di log ai sink creati dopo l'avvio dell'agente. Talvolta è utile inviare i record di log precedenti, ad esempio, i record di log creati quando Kinesis Agent per Windows si blocca durante un aggiornamento automatico. La funzione di segnalibro monitora quali record sono stati inviati ai sink. Quando Kinesis Agent per Windows è in modalità segnalibro e si avvia, invia tutti i record di log creati dopo l'arresto di Kinesis Agent per Windows, insieme a qualsiasi record di log creato successivamente. Per controllare questo comportamento, le dichiarazioni di origine basate su file possono eventualmente includere le seguenti coppie chiave-valore:
`InitialPosition`
Specifica la situazione iniziale del segnalibro. I valori possibili sono i seguenti:
`EOS`
Specifica la fine del flusso (EOS). Solo i record di log creati durante l'esecuzione dell'agente vengono inviati ai sink.
`0`
Tutti gli eventi e i record di log vengono inizialmente inviati. Quindi viene creato un segnalibro che assicura che ogni nuovo record di log ed evento creato dopo la creazione del segnalibro venga infine inviato, se Kinesis Agent for Windows è in esecuzione oppure no.
`Bookmark`
Il segnalibro viene inizializzato solo dopo l'ultimo record di log o evento. Quindi viene creato un segnalibro che assicura che ogni nuovo record di log ed evento creato dopo la creazione del segnalibro venga infine inviato, se Kinesis Agent for Windows è in esecuzione oppure no.
I segnalibri sono abilitati come impostazione predefinita. I file vengono memorizzati nella`%ProgramData%\Amazon\KinesisTap`directory.
`Timestamp`
Vengono inviati i record di log e gli eventi creati dopo il valore `InitialPositionTimestamp` (segue la definizione). Quindi viene creato un segnalibro che assicura che ogni nuovo record di log ed evento creato dopo la creazione del segnalibro venga infine inviato, se Kinesis Agent per Windows è in esecuzione oppure no.
`InitialPositionTimestamp`
Specifica il primo timestamp desiderato di record di log o evento. Specificare questa coppia chiave-valore solo quando `InitialPosition` ha un valore di `Timestamp`.
`BookmarkOnBufferFlush`
Questa impostazione può essere aggiunta a qualsiasi fonte segnalibro. Se impostato su`true`, assicura che gli aggiornamenti dei segnalibri si verifichino solo quando un sink invia correttamente un evento a AWS. È possibile sottoscrivere un solo sink a una fonte. Se spedisci i registri a più destinazioni, duplicare le origini per evitare potenziali problemi con la perdita di dati.
Quando Kinesis Agent per Windows viene arrestato per un periodo di tempo prolungato, potrebbe essere necessario eliminare questi segnalibri, perché i record di log ed eventi contrassegnati dal segnalibro non esistono più. I file del segnalibro per un dato *id origine* sono situati in `%PROGRAMDATA%\Amazon\AWSKinesisTap\source id.bm`.
I segnalibri non funzionano su file rinominati o troncati. Per propria natura, gli eventi ETW e i contatori delle prestazioni non possono essere contrassegnati da segnalibri.
# Dichiarazioni dei sink
Le *Dichiarazioni dei sink* specificano dove e in quale forma log, eventi e parametri devono essere inviati ai diversi servizi AWS. Le seguenti sezioni descrivono le configurazioni per i tipi di sink integrati disponibili in Amazon Kinesis Agent per Microsoft Windows. Poiché Kinesis Agent per Windows è ampliabile, è possibile aggiungere tipi di sink personalizzati. Ogni tipo di sink richiede in genere coppie chiave-valore univoche nella dichiarazioni di configurazione pertinenti per quel tipo di sink.
Tutte le dichiarazioni di sink possono offrire le seguenti coppie chiave-valore:
`Id`
Una stringa univoca che identifica un determinato sink all'interno del file di configurazione (obbligatorio).
`SinkType`
Il nome del tipo di sink per questo sink (obbligatorio). Il tipo di sink specifica la destinazione dei dati di log, degli eventi o dei parametri inviati in streaming da questo sink.
`AccessKey`
Specifica la chiave di accesso AWS da utilizzare per autorizzare l'accesso al servizio AWS associato al tipo di sink. Questa coppia chiave-valore è facoltativa. Per ulteriori informazioni, consulta [Configurazione di sicurezza del sink](#configuring-kinesis-agent-windows-sink-security-configuration).
`SecretKey`
Specifica la chiave segreta AWS da utilizzare per autorizzare l'accesso al servizio AWS associato al tipo di sink. Questa coppia chiave-valore è facoltativa. Per ulteriori informazioni, consulta [Configurazione di sicurezza del sink](#configuring-kinesis-agent-windows-sink-security-configuration).
`Region`
Specifica la regione AWS che contiene le risorse di destinazione per lo streaming. Questa coppia chiave-valore è facoltativa.
`ProfileName`
Specifica il profilo AWS da utilizzare per l'autenticazione. Questa coppia chiave-valore è facoltativa, ma se specificata, sostituisce qualsiasi chiave di accesso e chiave segreta specificata. Per ulteriori informazioni, consulta [Configurazione di sicurezza del sink](#configuring-kinesis-agent-windows-sink-security-configuration).
`RoleARN`
Specifica il ruolo IAM da utilizzare per accedere al servizio AWS associato al tipo di sink. Questa opzione è utile quando Kinesis Agent per Windows è in esecuzione su un'istanza di EC2, ma un altro ruolo sarà più appropriato rispetto al ruolo referenziato dal profilo dell'istanza. Ad esempio, il ruolo su più account può essere utilizzato per risorse di destinazione che non sono nello stesso account AWS come l'istanza EC2. Questa coppia chiave-valore è facoltativa.
`Format`
Specifica il tipo di serializzazione applicato ai dati di eventi e di log prima dello streaming. I valori validi sono `json` e `xml`. Questa opzione è utile quando i dati di analisi downstream nella pipeline dei dati richiedono o preferiscono i dati in una determinata forma. Questa coppia chiave-valore è facoltativa e, se non è specificato, il testo normale dall'origine viene inviato in streaming dal sink al servizio AWS associato al tipo di sink.
`TextDecoration`
Quando non viene specificato un `Format`, `TextDecoration` specifica quale testo aggiuntivo includere durante lo streaming di record di eventi o di log. Per ulteriori informazioni, consulta [Configurazione delle decorazioni sink](#configuring-kinesis-agent-windows-decoration-configuration). Questa coppia chiave-valore è facoltativa.
`ObjectDecoration`
Quando viene specificato `Format`, `ObjectDecoration` specifica i dati aggiuntivi inclusi nei record di eventi o di log prima della serializzazione e dello streaming. Per ulteriori informazioni, consulta [Configurazione delle decorazioni sink](#configuring-kinesis-agent-windows-decoration-configuration). Questa coppia chiave-valore è facoltativa.
`BufferInterval`
Per ridurre al minimo le chiamate API al servizio AWS associato al tipo di sink Kinesis il buffering di più record di log, eventi o parametri prima dello streaming. In questo modo è possibile risparmiare denaro per servizi che comportano un addebito per chiamata API. `BufferInterval` specifica il tempo massimo (in secondi) in cui deve essere eseguito il buffering dei record prima dello streaming al servizio AWS. Questa coppia chiave-valore è facoltativa e, se specificata, utilizza una stringa per rappresentare il valore.
`BufferSize`
Per ridurre al minimo le chiamate API al servizio AWS associato al tipo di sink Kinesis il buffering di più record di log, eventi o parametri prima dello streaming. In questo modo è possibile risparmiare denaro per servizi che comportano un addebito per chiamata API. `BufferSize` specifica il numero massimo di record per cui deve essere eseguito il buffering prima dello streaming al servizio AWS. Questa coppia chiave-valore è facoltativa e, se specificata, utilizza una stringa per rappresentare il valore.
`MaxAttempts`
Specifica il numero massimo di volte in cui Kinesis Agent per Windows tenta di trasmettere un set di record di log, eventi e parametri a un servizio AWS se lo streaming in maniera regolare ha esito negativo. Questa coppia chiave-valore è facoltativa. Se è specificato, utilizza una stringa per rappresentare il valore. Il valore predefinito è "`3`".
Per esempi di file di configurazione completi che utilizzano vari tipi di sink, consulta [Streaming da log di eventi di applicazioni Windows ai sink](configuring-kaw-examples.md#configuring-kaw-examples-sinks).
**Topics**
+ [Configurazione sink `KinesisStream`](#sink-object-declarations-kinesis-stream)
+ [Configurazione sink `KinesisFirehose`](#sink-object-declarations-kinesis-firehose)
+ [Configurazione sink CloudWatch](#sink-object-declarations-cloud-watch)
+ [Configurazione sink `CloudWatchLogs`](#sink-object-declarations-cloud-watch-logs)
+ [Locale`FileSystem`Configurazione sink](#sink-object-declarations-local-filesystem)
+ [Configurazione di sicurezza del sink](#configuring-kinesis-agent-windows-sink-security-configuration)
+ [Configurazione di`ProfileRefreshingAWSCredentialProvider`Per aggiornare le credenziali AWS](#configuring-credential-refresh)
+ [Configurazione delle decorazioni sink](#configuring-kinesis-agent-windows-decoration-configuration)
+ [Configurazione di sostituzione di variabili sink](#configuring-kinesis-agent-windows-sink-variable-substitution)
+ [Configurazione dell'accodamento dei sink](#configuring-kinesis-agent-windows-queuing)
+ [Configurazione di un Proxy per i sink](#configuring-kinesis-agent-windows-sink-proxy)
+ [Configurazione delle variabili di risoluzione in più attributi sink](#configuring-resolving-variables)
+ [Configurazione degli endpoint regionali di AWS STS quando si utilizza la proprietà RoleARN nei sink AWS](#configuring-sts-endpoints)
+ [Configurazione di VPC Endpoint per i sink AWS](#configuring-vpc-endpoint)
+ [Configurazione di un mezzo alternativo di proxy](#configuring-alternate-proxy)
## Configurazione sink `KinesisStream`
La`KinesisStream`Il tipo di sink invia in streaming record di log e di eventi al servizio di Kinesis Data Streams. Di solito, i dati inviati in streaming a Kinesis Data Streams vengono elaborati da una o più applicazioni personalizzate eseguite utilizzando diversi servizi AWS. I dati vengono inviati in streaming a un flusso denominato configurato utilizzando Kinesis Data Streams. Per ulteriori informazioni, consulta la .*[Guida per gli sviluppatori di Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/)*: .
Di seguito è riportato un esempio Kinesis Data Streams di:
```
{
"Id": "TestKinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "MyTestStream",
"Region": "us-west-2"
}
```
Tutte le dichiarazioni sink `KinesisStream` possono offrire le seguenti coppie chiave-valore aggiuntive:
`SinkType`
Deve essere specificato e il valore deve essere la stringa letterale `KinesisStream`.
`StreamName`
Specifica il nome del flusso di dati Kinesis che riceve i dati provenienti dalla`KinesisStream`tipo di sink (obbligatorio). Prima di inviare i dati in streaming, configurare il flusso nella console di gestione AWS, nell'interfaccia della riga di comando AWS o tramite un'applicazione utilizzando l'API Kinesis Data Streams.
`RecordsPerSecond`
Specifica il numero massimo di record in Kinesis Data Streams a al secondo. Questa coppia chiave-valore è facoltativa. Se è specificato, utilizza un numero intero per rappresentare il valore. Il valore predefinito è 1000 record.
`BytesPerSecond`
Specifica il numero massimo di byte in Kinesis Data Streams a al secondo. Questa coppia chiave-valore è facoltativa. Se è specificato, utilizza un numero intero per rappresentare il valore. Il valore predefinito è 1 MB.
L'impostazione predefinita di `BufferInterval` per questo tipo di sink è di 1 secondo, e l'impostazione predefinita di `BufferSize` è di 500 record.
## Configurazione sink `KinesisFirehose`
La`KinesisFirehose`Il tipo di sink invia in streaming record di log e di eventi al servizio Kinesis Data Firehose. Kinesis Data Firehose fornisce i dati provenienti da altri servizi per lo storage. In genere i dati archiviati vengono poi analizzati in fasi successive della pipeline di dati. I dati vengono inviati in streaming a un flusso di distribuzione denominato configurato utilizzando Kinesis Data Firehose. Per ulteriori informazioni, consulta la .*[Guida per sviluppatori di Amazon Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/)*: .
Di seguito è riportato un esempio della dichiarazione Kinesis Data Firehose:
```
{
"Id": "TestKinesisFirehoseSink",
"SinkType": "KinesisFirehose",
"StreamName": "MyTestFirehoseDeliveryStream",
"Region": "us-east-1",
"CombineRecords": "true"
}
```
Tutte le dichiarazioni sink `KinesisFirehose` possono offrire le seguenti coppie chiave-valore aggiuntive:
`SinkType`
Deve essere specificato e il valore deve essere la stringa letterale `KinesisFirehose`.
`StreamName`
Specifica il nome del flusso di distribuzione Kinesis Data Firehose che riceve i dati provenienti dalla`KinesisStream`tipo di sink (obbligatorio). Prima di inviare i dati in streaming, configurare il flusso di distribuzione utilizzando la console di gestione AWS, l'interfaccia della riga di comando AWS o tramite un'applicazione utilizzando l'API Kinesis Data Firehose.
`CombineRecords`
Se impostato su`true`, specifica di combinare più record di piccole dimensioni in un record di grandi dimensioni con una dimensione massima di 5 KB. Questa coppia chiave-valore è facoltativa. I record combinati utilizzando questa funzione sono separati da`\n`: . Se si utilizza AWS Lambda per trasformare un record Kinesis Data Firehose, la funzione Lambda deve tenere conto del carattere separatore.
`RecordsPerSecond`
Specifica il numero massimo di record in Kinesis Data Streams a al secondo. Questa coppia chiave-valore è facoltativa. Se è specificato, utilizza un numero intero per rappresentare il valore. Il valore predefinito è 5000 record.
`BytesPerSecond`
Specifica il numero massimo di byte in Kinesis Data Streams a al secondo. Questa coppia chiave-valore è facoltativa. Se è specificato, utilizza un numero intero per rappresentare il valore. Il valore predefinito è 5 MB.
L'impostazione predefinita di `BufferInterval` per questo tipo di sink è di 1 secondo, e l'impostazione predefinita di `BufferSize` è di 500 record.
## Configurazione sink CloudWatch
La`CloudWatch`Il tipo di sink effettua lo streaming dei parametri al servizio CloudWatch. Puoi visualizzare i parametri nella console di gestione AWS. Per ulteriori informazioni, consulta la *[Guida per l'utente di Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
Di seguito è riportato un esempio della dichiarazione sink `CloudWatch`:
```
{
"Id": "CloudWatchSink",
"SinkType": "CloudWatch"
}
```
Tutte le dichiarazioni sink `CloudWatch` possono offrire le seguenti coppie chiave-valore aggiuntive:
`SinkType`
Deve essere specificato e il valore deve essere la stringa letterale `CloudWatch`.
`Interval`
Specifica la frequenza (in secondi) con cui Kinesis Agent per Windows comunica i parametri al servizio CloudWatch. Questa coppia chiave-valore è facoltativa. Se è specificato, utilizza un numero intero per rappresentare il valore. Il valore predefinito è 60 secondi. Specificare 1 secondo se si desiderano parametri CloudWatch ad alta risoluzione.
`Namespace`
Specifica lo spazio dei nomi CloudWatch in cui vengono riportati i dati dei parametri. Gli spazi dei nomi CloudWatch raggruppano un set di parametri. Questa coppia chiave-valore è facoltativa. Il valore predefinito è `KinesisTap`.
`Dimensions`
Specifica le dimensioni CloudWatch utilizzate per isolare i set di parametri all'interno di uno spazio dei nomi. Questo può essere utile per fornire set separati di dati di parametri per ogni desktop o server, ad esempio. Questa coppia chiave-valore è facoltativa e, se specificata, il valore deve rispettare il seguente formato: `"`*chiave1*`=`*valore1*;*chiave2*`=`*valore2...*`"`. Il valore predefinito è `"ComputerName={computername};InstanceId={instance_id}"`. Questo valore supporta la sostituzione delle variabili sink. Per ulteriori informazioni, consulta [Configurazione di sostituzione di variabili sink](#configuring-kinesis-agent-windows-sink-variable-substitution).
`MetricsFilter`
Specifica quali parametri vengono trasmessi in streaming a CloudWatch dall'origine integrata di Kinesis Agent per Windows. Per ulteriori informazioni sull'origine di parametri integrata di Kinesis Agent per Windows, inclusi i dettagli della sintassi del valore di questa coppia chiave-valore, vedere[Origine dei parametri integrati di Kinesis Agent per Windows](source-object-declarations.md#kinesis-agent-builin-metrics-source): .
## Configurazione sink `CloudWatchLogs`
La`CloudWatchLogs`Il tipo di sink invia in streaming record di log e di eventi a Amazon CloudWatch Logs. Puoi visualizzare i log nella console di gestione AWS o elaborarli tramite altre fasi di una pipeline di dati. I dati vengono inviati in streaming a un flusso di log denominato configurato nei CloudWatch Logs. I flussi di log sono organizzati in gruppi di log denominati. Per ulteriori informazioni, consulta la .*[Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/)*: .
Di seguito è riportato un esempio della dichiarazione sink CloudWatch Logs:
```
{
"Id": "MyCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"BufferInterval": "60",
"BufferSize": "100",
"Region": "us-west-2",
"LogGroup": "MyTestLogGroup",
"LogStream": "MyTestStream"
}
```
Tutte le dichiarazioni sink `CloudWatchLogs` devono offrire le seguenti coppie chiave-valore aggiuntive:
`SinkType`
Deve essere la stringa letterale `CloudWatchLogs`.
`LogGroup`
Specifica il nome del gruppo di log di CloudWatch Logs contenente il flusso di log che riceve i record di eventi e di log in streaming dalla proprietà di`CloudWatchLogs`tipo di lavello. Se il gruppo di log specificato non esiste, Kinesis Agent per Windows tenta di crearlo.
`LogStream`
Specifica il nome del flusso di log CloudWatch Logs che riceve il flusso di record di eventi e di log dal`CloudWatchLogs`tipo di lavello. Questo valore supporta la sostituzione delle variabili sink. Per ulteriori informazioni, consulta [Configurazione di sostituzione di variabili sink](#configuring-kinesis-agent-windows-sink-variable-substitution). Se il flusso di log specificato non esiste, Kinesis Agent per Windows tenta di crearlo.
L'impostazione predefinita di `BufferInterval` per questo tipo di sink è di 1 secondo, e l'impostazione predefinita di `BufferSize` è di 500 record. La dimensione massima del buffer è di 10.000 record.
## Locale`FileSystem`Configurazione sink
Il tipo di lavello`FileSystem`salva i record di log ed eventi in un file nel file system locale invece di inviarli in streaming ai servizi AWS.`FileSystem`sono utili per test e diagnostica. Ad esempio, è possibile utilizzare questo tipo di sink per esaminare i record prima di inviarli a AWS.
con`FileSystem`, è anche possibile utilizzare i parametri di configurazione per simulare batch, limitazione e retry-on-error per simulare il comportamento dei sink AWS effettivi.
Tutti i record di tutte le origini connesse a un`FileSystem`vengono salvati nel singolo file specificato come`FilePath`: . Se`FilePath`non viene specificato, i record vengono salvati in un file denominato`SinkId.txt`nella`%TEMP%`, che di solito è`C:\Users\UserName\AppData\Local\Temp`, dove`SinkId`è l'identificatore univoco del sink e`UserName`è il nome utente di Windows dell'utente attivo.
Questo tipo di sink supporta gli attributi di decorazione del testo. Per ulteriori informazioni, consulta [Configurazione delle decorazioni sink](#configuring-kinesis-agent-windows-decoration-configuration).
Un esempio`FileSystem`Nell'esempio seguente viene visualizzata la seguente configurazione.
```
{
"Id": "LocalFileSink",
"SinkType": "FileSystem",
"FilePath": "C:\\ProgramData\\Amazon\\local_sink.txt",
"Format": "json",
"TextDecoration": "",
"ObjectDecoration": ""
}
```
La`FileSystem`è costituito dalle seguenti coppie chiave-valore.
`SinkType`
Deve essere la stringa letterale `FileSystem`.
`FilePath`
Specifica il percorso e il file in cui vengono salvati i record. Questa coppia chiave-valore è facoltativa. Se il valore non viene specificato, viene usato`TempPath\\SinkId.txt`, dove`TempPath`è la cartella memorizzata nella`%TEMP%`Variabile e`SinkId`è l'identificatore univoco del sink.
`Format`
Specifica il formato dell'evento da`json`o`xml`: . Questa coppia di valori è facoltativa e senza distinzione tra maiuscole e minuscole Se omesso, gli eventi vengono scritti nel file in testo normale.
`TextDecoration`
Si applica solo agli eventi scritti in testo normale. Questa coppia chiave-valore è facoltativa.
`ObjectDecoration`
Si applica solo agli eventi in cui`Format`è impostato su .`json`: . Questa coppia chiave-valore è facoltativa.
### Utilizzo avanzato: simulazione di limitazione dei record e guasti
`FileSystem`può imitare il comportamento dei sink AWS simulando la limitazione dei record. È possibile utilizzare le seguenti coppie chiave-valore per specificare gli attributi di limitazione dei record e di simulazione di errori.
Acquisendo un blocco sul file di destinazione e impedendo le scritture su di esso, è possibile utilizzare`FileSystem`per simulare ed esaminare il comportamento dei sink AWS quando la rete fallisce.
L'esempio seguente mostra un`FileSystem`con attributi di simulazione.
```
{
"Id": "LocalFileSink",
"SinkType": "FileSystem",
"FilePath": "C:\\ProgramData\\Amazon\\local_sink.txt",
"TextDecoration": "",
"RequestsPerSecond": "100",
"BufferSize": "10",
"MaxBatchSize": "1024"
}
```
`RequestsPerSecond`
Facoltativo e specificato come tipo di stringa. Se omesso, viene usato il valore predefinito`"5"`: . Controlla la frequenza delle richieste che il sink elabora, ovvero scrive sul file, non il numero di record. Kinesis Agent per Windows effettua richieste batch agli endpoint AWS, pertanto una richiesta può contenere più record.
`BufferSize`
Facoltativo e specificato come tipo di stringa. Specifica il numero massimo di record di eventi che il sink batch prima di salvare nel file.
`MaxBatchSize`
Facoltativo e specificato come tipo di stringa. Specifica la quantità massima di dati del record di eventi in byte che il sink batch prima di salvare nel file.
Il limite massimo di velocità di registrazione è una funzione di`BufferSize`, che determina il numero massimo di record per richiesta e`RequestsPerSecond`: . È possibile calcolare il limite di velocità record al secondo utilizzando la formula seguente.
**RecordRate**=`BufferSize`\$1`RequestsPerSecond`
Dati i valori di configurazione nell'esempio precedente, esiste una velocità massima di record di 1000 record al secondo.
## Configurazione di sicurezza del sink
### Configurazione dell'autenticazione
Per consentire a Kinesis Agent per Windows di trasmettere in streaming log, eventi e parametri ai servizi AWS, l'accesso deve essere autenticato. Vi sono diversi modi per fornire l'autenticazione per Kinesis Agent per Windows. Il metodo scelto dipende dalla situazione in cui è in esecuzione Kinesis Agent per Windows e i requisiti di sicurezza specifici di una determinata organizzazione.
+ Se Kinesis Agent per Windows è in esecuzione su un host Amazon EC2, il modo più semplice e sicuro per fornire l'autenticazione è creare un ruolo IAM con accesso sufficiente alle operazioni richieste per i servizi AWS necessari e un profilo dell'istanza EC2 che fa riferimento a tale ruolo. Per ulteriori informazioni su come creare i profili dell'istanza, consulta [Uso dei profili dell'istanza](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html). Per ulteriori informazioni sulle policy da collegare al ruolo IAM, consulta[Configurazione dell'autorizzazione](#configuring-kinesis-agent-windows-authorization): .
Dopo aver creato il profilo dell'istanza, è possibile associarlo a qualsiasi istanza EC2 che utilizza Kinesis Agent per Windows. Se le istanze hanno già un profilo di istanza associato, è possibile allegare policy appropriate al ruolo associato a quel profilo dell'istanza.
+ Se Kinesis Agent per Windows viene eseguito su un host EC2 in un account, ma le risorse che sono la destinazione del sink risiedono in un altro account, è possibile creare un ruolo IAM per l'accesso a più account. Per ulteriori informazioni, consulta[Tutorial: Delegare l'accesso agli account AWS tramite ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html): . Dopo aver creato il ruolo tra più account, specificare l'ARN (Amazon Resource Name) per il ruolo tra più account come valore dell'opzione`RoleARN`Coppia chiave-valore nella dichiarazione sink. Kinesis Agent per Windows tenta quindi di assumersi il ruolo specificato tra più account per l'accesso alle risorse AWS associate al tipo di sink per quel sink.
+ Se Kinesis Agent per Windows è in esecuzione al di fuori di Amazon EC2 (ad esempio, in locale), esistono diverse opzioni:
+ Se è accettabile registrare il server locale o il computer desktop come istanza gestita da Amazon EC2 Systems Manager, utilizzare la seguente procedura per configurare l'autenticazione:
1. Utilizzare il processo descritto in [Impostazione di AWS Systems Manager in ambienti ibridi](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-managedinstances.html) per creare un ruolo di servizio, creare un'attivazione per un'istanza gestita e installare l'agente SSM.
1. Collegare le policy appropriate per il ruolo del servizio per consentire a Kinesis Agent per Windows di accedere alle risorse necessarie per lo streaming dei dati dai sink configurati. Per ulteriori informazioni sulle policy da collegare al ruolo IAM, consulta[Configurazione dell'autorizzazione](#configuring-kinesis-agent-windows-authorization): .
1. Utilizzare il processo descritto in[Configurazione di`ProfileRefreshingAWSCredentialProvider`Per aggiornare le credenziali AWS](#configuring-credential-refresh)Per aggiornare le credenziali AWS.
Questo è l'approccio consigliato per le istanze non EC2, perché le credenziali sono gestite in modo sicuro da SSM e AWS.
+ Se è accettabile eseguire il servizio AWSKinesisTap per Kinesis Agent per Windows con un determinato utente anziché con l'account di sistema predefinito, utilizzare la seguente procedura:
1. Creare un utente IAM nell'account AWS in cui i servizi AWS saranno utilizzati. Acquisire la chiave di accesso e la chiave segreta di questo utente durante il processo di creazione. Queste informazioni saranno necessarie più avanti in questa procedura.
1. Collegare i criteri all'utente IAM che autorizza l'accesso alle operazioni necessarie per i servizi richiesti. Per ulteriori informazioni sulle policy da collegare all'utente IAM, consulta[Configurazione dell'autorizzazione](#configuring-kinesis-agent-windows-authorization): .
1. Cambiare il servizio AWSKinesisTap su ogni desktop o server in modo che venga eseguito con un determinato utente piuttosto che con l'account predefinito del sistema.
1. Creare un profilo nell'archivio SDK utilizzando la chiave di accesso e la chiave segreta registrate in precedenza. Per ulteriori informazioni, vedi [Configurazione delle credenziali AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html).
1. Aggiornare il file `AWSKinesisTap.exe.config` nella directory `%PROGRAMFILES%\Amazon\AWSKinesisTap` per specificare il nome del profilo creato nel passo precedente. Per ulteriori informazioni, vedi [Configurazione delle credenziali AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html).
Questo approccio è consigliato per host non EC2 che non possono essere istanze gestite poiché le credenziali sono crittografate per l'host specifico e l'utente specifico.
+ Se è necessario eseguire il servizio AWSKinesisTap per Kinesis Agent per Windows con l'account di sistema predefinito, è necessario utilizzare un file di credenziali condiviso. Questo perché l'account di sistema non ha un profilo utente Windows per l'abilitazione dell'archivio SDK. I file di credenziali condivise non sono crittografati, perciò non consigliamo di adottare questo approccio. Per informazioni su come utilizzare i file di configurazione condivisi, consulta[Configurazione delle credenziali AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html)nella*SDK AWS per .NET*: . Se si utilizza questo approccio, è consigliabile utilizzare la crittografia NTFS e l'accesso ai file limitato per il file di configurazione condiviso. Le chiavi devono essere ruotate da una piattaforma di gestione e il file di configurazione condiviso deve essere aggiornato quando si verifica la rotazione della chiave.
Anche se è possibile fornire direttamente le chiavi di accesso e le chiavi segrete nelle dichiarazioni dei sink, questo approccio è sconsigliato perché le dichiarazioni non sono crittografate.
### Configurazione dell'autorizzazione
Collegare le policy appropriate per l'utente o il ruolo IAM che verrà utilizzato da Kinesis Agent per Windows per trasmettere i dati ai servizi AWS:
#### Kinesis Data Streams
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"kinesis:PutRecord",
"kinesis:PutRecords"
],
"Resource": "arn:aws:kinesis:*:*:stream/*"
}
]
}
```
Per limitare l'autorizzazione a una regione, un account o un nome di flusso specifici, sostituire gli asterischi appropriati nell'ARN con valori specifici. Per ulteriori informazioni, vedere "Amazon Resource Name (ARN) per flussi di dati di Kinesis" in [Controllo degli accessi alle risorse dei flussi di dati di Amazon Kinesis tramite IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html).
#### Kinesis Data Firehose
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": "arn:aws:firehose:*:*:deliverystream/*"
}
]
}
```
Per limitare l'autorizzazione a una regione, un account o un flusso di distribuzione specifici, sostituire gli asterischi appropriati nell'ARN con valori specifici. Per ulteriori informazioni, consulta[Controllare gli accessi con Amazon Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html)nella*Guida per sviluppatori di Amazon Kinesis Data Firehose*: .
#### CloudWatch
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": "cloudwatch:PutMetricData",
"Resource": "*"
}
]
}
```
Per ulteriori informazioni, consulta[Panoramica sulla gestione delle autorizzazioni di accesso alle risorse CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-access-control-overview-cw.html)nella*Amazon CloudWatch Logs*: .
#### CloudWatch Logs con un gruppo di log e di flussi di log
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor3",
"Effect": "Allow",
"Action": [
"logs:DescribeLogGroups",
"logs:DescribeLogStreams",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:log-group:*"
},
{
"Sid": "VisualEditor4",
"Effect": "Allow",
"Action": "logs:PutLogEvents",
"Resource": "arn:aws:logs:*:*:log-group:*:*:*"
}
]
}
```
Per limitare l'accesso a una regione, un account, un gruppo o un flusso di log specifico, sostituire gli asterischi opportuni negli ARN con i valori appropriati. Per ulteriori informazioni, consulta[Panoramica sulla gestione delle autorizzazioni di accesso alle risorse CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html)nella*Amazon CloudWatch Logs*: .
#### CloudWatch Logs con autorizzazioni aggiuntive per Kinesis Agent per Windows per creare gruppi di log e flussi di log
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor5",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:log-group:*"
},
{
"Sid": "VisualEditor6",
"Effect": "Allow",
"Action": "logs:PutLogEvents",
"Resource": "arn:aws:logs:*:*:log-group:*:*:*"
},
{
"Sid": "VisualEditor7",
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "*"
}
]
}
```
Per limitare l'accesso a una regione, un account, un gruppo o un flusso di log specifico, sostituire gli asterischi opportuni negli ARN con i valori appropriati. Per ulteriori informazioni, consulta[Panoramica sulla gestione delle autorizzazioni di accesso alle risorse CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html)nella*Amazon CloudWatch Logs*: .
#### Le autorizzazioni necessarie per l'espansione delle variabili dei tag EC2
L'utilizzo dell'espansione delle variabili con il prefisso della variabile `ec2tag` richiede l'autorizzazione `ec2:Describe*`.
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "VisualEditor8",
"Effect": "Allow",
"Action": "ec2:Describe*",
"Resource": "*"
}
]
}
```
**Nota**
È possibile abbinare più dichiarazioni in una singola policy finché il `Sid` per ogni istruzione è univoco all'interno di tale policy. Per informazioni sulla creazione di policy, consulta[Creazione di policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)nella*Guida per l'utente di IAM*: .
## Configurazione di`ProfileRefreshingAWSCredentialProvider`Per aggiornare le credenziali AWS
Se si utilizza AWS Systems Manager per ambienti ibridi per gestire le credenziali AWS, Systems Manager ruota le credenziali di sessione in`c:\Windows\System32\config\systemprofile\.aws\credentials`: . Per ulteriori informazioni su Systems Manager per gli ambienti ibridi, consulta[Configurazione di AWS Systems Manager per ambienti ibridi](https://docs.aws.amazon.com/(systems-manager/latest/userguide/systems-manager-managedinstances.html))nella*AWS Systems Manager*: .
Poiché AWS .net SDK non rileva automaticamente nuove credenziali, forniamo il`ProfileRefreshingAWSCredentialProvider`per aggiornare le credenziali.
Puoi utilizzare`CredentialRef`di qualsiasi configurazione di sincronizzazione AWS per fare riferimento a`Credentials`in cui viene`CredentialType`L'attributo è impostato su`ProfileRefreshingAWSCredentialProvider`Come mostrato nell'esempio seguente.
```
{
"Sinks": [{
"Id": "myCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"CredentialRef": "ssmcred",
"Region": "us-west-2",
"LogGroup": "myLogGroup",
"LogStream": "myLogStream"
}],
"Credentials": [{
"Id": "ssmcred",
"CredentialType": "ProfileRefreshingAWSCredentialProvider",
"Profile": "default",
"FilePath": "%USERPROFILE%//.aws//credentials",
"RefreshingInterval": 300
}]
}
```
Una definizione di credenziali è costituita dai seguenti attributi come coppie chiave-valore.
`Id`
Definisce la stringa che le definizioni di sink possono specificare utilizzando`CredentialRef`per fare riferimento a questa configurazione delle credenziali.
`CredentialType`
Impostare sulla stringa letterale`ProfileRefreshingAWSCredentialProvider`: .
`Profile`
Facoltativo. Il valore di default è `default`.
`FilePath`
Facoltativo. Specifica il percorso per il file delle credenziali AWS. Se omesso, il valore predefinito è `%USERPROFILE%/.aws/credentials`.
`RefreshingInterval`
Facoltativo. Frequenza con cui le credenziali vengono aggiornate, in secondi. Se omesso, il valore predefinito è `300`.
## Configurazione delle decorazioni sink
Le dichiarazioni sink possono facoltativamente includere coppie chiave-valore che specificano dati aggiuntivi per lo streaming ai vari servizi AWS per aumentare i record raccolti dall'origine.
`TextDecoration`
Utilizzare questa coppia chiave-valore quando nessun `Format` viene specificato nella dichiarazione sink. Il valore è una stringa con formato speciale in cui si verifica la sostituzione delle variabili. Ad esempio, supponiamo che `TextDecoration` di `"{ComputerName}:::{timestamp:yyyy-MM-dd HH:mm:ss}:::{_record}"` venga fornito per un sink. Quando un'origine emette un record di log che contiene il testo `The system has resumed from sleep.` e tale origine è connessa al sink tramite una pipe, allora il testo `MyComputer1:::2017-10-26 06:14:22:::The system has resumed from sleep.` viene inviato in streaming al servizio AWS associato al tipo di sink. La variabile `{_record}` si riferisce al record del testo originale distribuito dall'origine.
`ObjectDecoration`
Utilizzare questa coppia chiave-valore quando `Format` viene specificato nella dichiarazione del sink per aggiungere ulteriori dati prima della serializzazione dei record. Ad esempio, supponiamo che una `ObjectDecoration` di `"ComputerName={ComputerName};DT={timestamp:yyyy-MM-dd HH:mm:ss}"` venga fornita per un sink che specifica JSON `Format`. Il risultante JSON in streaming al servizio AWS associato al tipo di sink include le seguenti coppie chiave-valore in aggiunta ai dati originali dell'origine:
```
{
ComputerName: "MyComputer2",
DT: "2017-10-17 21:09:04"
}
```
Per un esempio di utilizzo di `ObjectDecoration`, vedi [Tutorial: Trasmetti file di registro JSON ad Amazon S3 utilizzando Kinesis Agent per Windows](directory-source-to-s3-tutorial.md).
`ObjectDecorationEx`
Specifica un'espressione, che consente l'estrazione e la formattazione dei dati più flessibili rispetto a`ObjectDecoration`: . Questo campo può essere utilizzato quando il formato del sink è`json`: . La sintassi dell'espressione è illustrata di seguito.
```
"ObjectDecorationEx": "attribute1={expression1};attribute2={expression2};attribute3={expression3}(;...)"
```
Ad esempio,`ObjectDecorationEx`Attributo
```
"ObjectDecorationEx": "host={env:ComputerName};message={upper(_record)};time={format(_timestamp, 'yyyyMMdd')}"
```
Trasforma il record letterale:
`System log message`
In un oggetto JSON come segue, con i valori restituiti dalle espressioni:
```
{
"host": "EC2AMAZ-1234",
"message": "SYSTEM LOG MESSAGE",
"time": "20210201"
}
```
Per ulteriori informazioni sulla formulazione di espressioni, consulta[Suggerimenti per scrivere espressioni](#configuring-expressions): . La maggior parte dei`ObjectDecoration`dovrebbe funzionare usando la nuova sintassi con l'eccezione delle variabili timestamp. A`{timestamp:yyyyMMdd}`Campo in`ObjectDecoration`è espresso come`{format(_timestamp,'yyyyMMdd')}`in`ObjectDecorationEx`: .
`TextDecorationEx`
Specifica un'espressione, che consente l'estrazione e la formattazione dei dati più flessibili rispetto a`TextDecoration`come mostrato nell'esempio seguente.
```
"TextDecorationEx": "Message '{lower(_record)}' at {format(_timestamp, 'yyyy-MM-dd')}"
```
Puoi utilizzare`TextDecorationEx`per comporre oggetti JSON. Utilizzare '@ \$1'per sfuggire alla parentesi graffa aperta, come mostrato nell'esempio seguente.
```
"TextDecorationEx": "@{ \"var\": \"{upper($myvar1)}\" }"
```
Se il tipo di origine dell'origine connessa al sink è `DirectorySource`, allora il sink può utilizzare tre variabili aggiuntive:
`_FilePath`
Il percorso completo al file di log.
`_FileName`
Il nome file e l'estensione del nome file del file.
`_Position`
Un numero intero che rappresenta dove si trova il record nel file di log.
Queste variabili sono utili quando si utilizza un'origine che raccoglie record di log da più file connessi a un sink che invia tutti i record a un solo flusso. Inserire i valori di queste variabili nel record di streaming consente di effettuare analisi downstream nella pipeline di dati per ordinare i record per file e per ubicazione all'interno di ciascun file.
### Suggerimenti per scrivere espressioni
Un'espressione può essere qualsiasi tra i seguenti:
+ Espressione variabile.
+ Un'espressione costante, ad esempio`'hello'`,`1`,`1.21`,`null`,`true`,`false`: .
+ Espressione di chiamata che chiama una funzione, come mostrato nell'esempio seguente.
```
regexp_extract('Info: MID 118667291 ICID 197973259 RID 0 To: ', 'To: (\\\\S+)', 1)
```
#### Caratteri speciali
Per sfuggire a caratteri speciali sono necessari due barre rovesciate.
#### Nesting
Le chiamate di funzione possono essere nidificate, come mostrato nell'esempio seguente.
```
format(date(2018, 11, 28), 'MMddyyyy')
```
#### Variables
Ci sono tre tipi di variabili: locale, meta e globale.
+ **Variabili locali**Inizia con un'`$`come`$message`: . Vengono utilizzati per risolvere la proprietà dell'oggetto evento, una voce se l'evento è un dizionario o un attributo se l'evento è un oggetto JSON. Se la variabile locale contiene spazio o caratteri speciali, utilizzare una variabile locale tra virgolette, ad esempio`$'date created'`: .
+ **Variabili di meta**Inizia con un trattino basso (`_`) e vengono utilizzati per risolvere i metadati dell'evento. Tutti i tipi di eventi supportano le seguenti meta-variabili.
`_timestamp`
Il timestamp dell'evento.
`_record`
La rappresentazione in formato non elaborato dell'evento.
Gli eventi di registro supportano le seguenti meta-variabili aggiuntive.
`_filepath`
`_filename`
`_position`
`_linenumber`
+ **Variabili globali**risolvere le variabili di ambiente, i metadati dell'istanza EC2 o EC2tag. Per prestazioni migliori, ti consigliamo di utilizzare il prefisso per limitare l'ambito di ricerca, ad esempio`{env:ComputerName}`,`{ec2:InstanceId}`, e`{ec2tag:Name}`: .
#### Funzioni integrate
Kinesis Agent per Windows supporta le seguenti funzioni integrate. Se uno qualsiasi degli argomenti è`NULL`e la funzione non è progettata per gestire`NULL`, un`NULL`viene restituito.
```
//string functions
int length(string input)
string lower(string input)
string lpad(string input, int size, string padstring)
string ltrim(string input)
string rpad(string input, int size, string padstring)
string rtrim(string input)
string substr(string input, int start)
string substr(string input, int start, int length)
string trim(string input)
string upper(string str)
//regular expression functions
string regexp_extract(string input, string pattern)
string regexp_extract(string input, string pattern, int group)
//date functions
DateTime date(int year, int month, int day)
DateTime date(int year, int month, int day, int hour, int minute, int second)
DateTime date(int year, int month, int day, int hour, int minute, int second, int millisecond)
//conversion functions
int? parse_int(string input)
decimal? parse_decimal(string input)
DateTime? parse_date(string input, string format)
string format(object o, string format)
//coalesce functions
object coalesce(object obj1, object obj2)
object coalesce(object obj1, object obj2, object obj3)
object coalesce(object obj1, object obj2, object obj3, object obj4)
object coalesce(object obj1, object obj2, object obj3, object obj4, object obj5)
object coalesce(object obj1, object obj2, object obj3, object obj4, object obj5, object obj6)
```
## Configurazione di sostituzione di variabili sink
Le dichiarazioni sink `KinesisStream`, `KinesisFirehose` e `CloudWatchLogs` richiedono una coppia chiave-valore `LogStream` o `StreamName`. Il valore di queste coppie chiave-valore può contenere riferimenti a variabili che vengono automaticamente risolti da Kinesis Agent per Windows. Per`CloudWatchLogs`, il`LogGroup`È richiesta anche una coppia chiave-valore e può contenere riferimenti a variabili automaticamente risolti da Kinesis Agent per Windows. Le variabili sono specificate utilizzando il modello `{`*`prefix`*`:`*`variablename`*`}` in cui *`prefix`*`:` è facoltativo. I prefissi supportati sono i seguenti:
+ `env`— Il riferimento alla variabile viene risolto dal valore della variabile di ambiente con lo stesso nome.
+ `ec2`— Il riferimento alla variabile viene risolto dai metadati dell'istanza EC2 con lo stesso nome.
+ `ec2tag`— Il riferimento alla variabile viene risolto dal valore del tag dell'istanza EC2 con lo stesso nome. L'autorizzazione `ec2:Describe*` è obbligatoria per accedere ai tag di istanza. Per ulteriori informazioni, consulta [Le autorizzazioni necessarie per l'espansione delle variabili dei tag EC2](#ec2-permissions).
Se il prefisso non è specificato, se c'è una variabile di ambiente con lo stesso nome di `variablename`, il riferimento alla variabile viene risolto dal valore della variabile di ambiente. Altrimenti, se `variablename` è `instance_id` o `hostname`, il riferimento alla variabile viene risolto dal valore dei metadati EC2 con lo stesso nome. In caso contrario, il riferimento alla variabile non viene risolto.
Di seguito sono elencati alcuni esempi di coppie chiave-valore valide che utilizzano i riferimenti alle variabili:
```
"LogStream": "LogStream_{instance_id}"
"LogStream": "LogStream_{hostname}"
"LogStream": "LogStream_{ec2:local-hostname}"
"LogStream": "LogStream_{computername}"
"LogStream": "LogStream_{env:computername}"
```
Le dichiarazioni sink `CloudWatchLogs` supportano una variabile timestamp con un formato speciale che consente al timestamp del record dell'evento o del log originale dell'origine di modificare il nome del flusso di log. Il formato è `{timestamp:``timeformat``}`. Fai riferimento al file di esempio seguente:
```
"LogStream": "LogStream_{timestamp:yyyyMMdd}"
```
Se il record di eventi o di log è stato generato il 5 giugno 2017, il valore della coppia chiave-valore `LogStream` dell'esempio precedente si risolverebbe in `"LogStream_20170605"`.
Se autorizzato, il tipo di sink `CloudWatchLogs` è in grado di creare automaticamente nuovi flussi di log generati quando richiesto in base ai nomi. Non è possibile eseguire questa operazione per altri tipi di sink perché richiedono un'ulteriore configurazione oltre il nome del flusso.
Non ci sono sostituzioni specifiche di variabili che si verificano nel testo e nella decorazione dell'oggetto. Per ulteriori informazioni, consulta [Configurazione delle decorazioni sink](#configuring-kinesis-agent-windows-decoration-configuration).
## Configurazione dell'accodamento dei sink
Le dichiarazioni dei sink `KinesisStream`, `KinesisFirehose` e `CloudWatchLogs` possono facoltativamente abilitare l'accodamento di record che non hanno lo streaming per il servizio AWS associato a questi tipi di sink a causa di problemi di connessione transitori. Per abilitare nuovi tentativi di streaming automatico e di accodamento quando la connettività viene ripristinata, utilizzare le seguenti coppie chiave-valore nelle dichiarazioni sink:
`QueueType`
Specifica il tipo di meccanismo di accodamento da utilizzare. L'unico valore supportato è `file`, che indica che i record devono essere messi in coda in un file. Questa coppia chiave-valore è necessaria per abilitare la funzione di accodamento di Kinesis Agent per Windows. Se non è specificato, il comportamento predefinito consiste nell'accodare solo in memoria e lo streaming dà esito negativo quando vengono raggiunti i limiti di accodamento in memoria.
`QueuePath`
Specificare il percorso alla cartella che contiene i file di record in coda. Questa coppia chiave-valore è facoltativa. Il valore predefinito è `%PROGRAMDATA%\KinesisTap\Queue\`*SinkId* dove *SinkId* è l'identificatore assegnato come valore di `Id` per la dichiarazione del sink.
`QueueMaxBatches`
Limita la quantità totale di spazio che Kinesis Agent per Windows può consumare quando si verifica l'accodamento dei record per lo streaming. La quantità di spazio è limitato al valore di questa coppia chiave-valore moltiplicato per il numero massimo di byte per batch. Il numero massimo di byte per batch per i tipi di sink `KinesisStream`, `KinesisFirehose` e `CloudWatchLogs` sono, rispettivamente, 5 MB, 4 MB e 1 MB. Quando viene raggiunto il limite, qualsiasi tentativo non riuscito di streaming non viene messo in coda e viene segnalato come tentativo non recuperabile. Questa coppia chiave-valore è facoltativa. Il valore predefinito è 10.000 batch.
## Configurazione di un Proxy per i sink
Per configurare un proxy per tutti i tipi di sink di Kinesis Agent per Windows che accedono ai servizi AWS, modificare il file di configurazione dell'Agente Kinesis per Windows che si trova in`%Program Files%\Amazon\KinesisTap\AWSKinesisTap.exe.config`: . Per istruzioni, consulta`proxy`Sezione[Documentazione di riferimento per AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/net-dg-config-ref.html#net-dg-config-ref-elements-proxy)nella*Guida per gli sviluppatori dell'SDK AWS per .NET*: .
## Configurazione delle variabili di risoluzione in più attributi sink
L'esempio seguente mostra una configurazione sink che utilizza il`Region`Variabile di ambiente per il valore del`Region`Coppia chiave-valore dell'attributo. Per`RoleARN`, specifica la chiave del tag EC2`MyRoleARN`, che restituisce il valore associato a quella chiave.
```
"Id": "myCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"LogGroup": "EC2Logs",
"LogStream": "logs-{instance_id}"
"Region": "{env:Region}"
"RoleARN": "{ec2tag:MyRoleARN}"
```
## Configurazione degli endpoint regionali di AWS STS quando si utilizza la proprietà RoleARN nei sink AWS
Questa funzione si applica solo se utilizzi KinesiStap su Amazon EC2 e utilizzi il`RoleARN`dei sink AWS per assumere un ruolo IAM esterno per l'autenticazione con i servizi AWS di destinazione.
Impostando`UseSTSRegionalEndpoints`Da a`true`, è possibile specificare che un agente utilizzi l'endpoint regionale (ad esempio`https://sts.us-east-1.amazonaws.com`) invece dell'endpoint globale (ad esempio,`https://sts.amazonaws.com`). L'utilizzo di un endpoint STS regionale riduce la latenza di andata e ritorno per l'operazione e limita l'impatto degli errori nel servizio endpoint globale.
## Configurazione di VPC Endpoint per i sink AWS
È possibile specificare un endpoint VPC nella configurazione sink per`CloudWatchLogs`,`CloudWatch`,`KinesisStreams`, e`KinesisFirehose`tipi di lavello. Un endpoint VPC consente di connettere privatamente il VPC a servizi AWS supportati e servizi endpoint VPC powered by AWS PrivateLink senza richiedere un Internet gateway, un dispositivo NAT, una connessione VPN o una connessione AWS Direct Connect. Le istanze nel VPC non richiedono indirizzi IP pubblici per comunicare con risorse nel servizio. Il traffico tra il VPC e gli altri servizi non lascia la rete Amazon. Per ulteriori informazioni, consulta[Endpoint VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html)nella*Guida per l'utente di Amazon VPC*: .
È possibile specificare l'endpoint VPC utilizzando il comando`ServiceURL`come mostrato nell'esempio seguente di un'`CloudWatchLogs`configurazione del sink. Impostare il valore`ServiceURL`al valore mostrato nella scheda**Dettagli dell'endpoint VPC**con la console Amazon VPC.
```
{
"Id": "myCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"LogGroup": "EC2Logs",
"LogStream": "logs-{instance_id}",
"ServiceURL":"https://vpce-ab1c234de56-ab7cdefg.logs.us-east-1.vpce.amazonaws.com"
}
```
## Configurazione di un mezzo alternativo di proxy
Questa funzionalità consente di configurare un server proxy in una configurazione sink utilizzando il supporto proxy incorporato in AWS SDK anziché .NET. In precedenza, l'unico modo per configurare l'agente per utilizzare un proxy era utilizzare una funzionalità nativa di .NET, che instradava automaticamente tutte le richieste HTTP/S tramite il proxy definito nel file proxy.
Se si sta attualmente utilizzando l'agente con un server proxy, non è necessario modificare per utilizzare questo metodo.
Puoi utilizzare`ProxyHost`e`ProxyPort`Per configurare un proxy alternativo, come mostrato nell'esempio seguente.
```
{
"Id": "myCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"LogGroup": "EC2Logs",
"LogStream": "logs-{instance_id}",
"Region": "us-west-2",
"ProxyHost": "myproxy.mydnsdomain.com",
"ProxyPort": "8080"
}
```
# Dichiarazioni delle pipe
Utilizza*Dichiarazioni delle pipe*per connettere una sorgente (vedere[Dichiarazioni delle origini](source-object-declarations.md)) a un lavandino (vedi[Dichiarazioni dei sink](sink-object-declarations.md)) nell'agente Amazon Kinesis per Microsoft Windows. Una dichiarazione della pipe viene espressa come un oggetto JSON. Una volta avviato l'agente Kinesis per Windows, i log, gli eventi o i parametri vengono raccolti dall'origine per una determinata pipe. Vengono quindi trasmessi a diversi servizi AWS utilizzando il sink associato a tale pipe.
Di seguito è riportato un esempio della dichiarazione di una pipe :
```
{
"Id": "MyAppLogToCloudWatchLogs",
"SourceRef": "MyAppLog",
"SinkRef": "MyCloudWatchLogsSink"
}
```
**Topics**
+ [Configurazione di pipe](#kinesis-agent-pipe-configuration)
+ [Configurazione dell'agente Kinesis per le pipe metriche di Windows](#kinesis-agent-metric-pipe-configuration)
## Configurazione di pipe
Tutte le dichiarazioni di pipe possono contenere le seguenti coppie chiave-valore:
`Id`
Specifica il nome della pipe (obbligatorio). Deve essere univoco all'interno del file di configurazione.
`Type`
Specifica il tipo di trasformazione (se presente) che viene applicata dalla pipe quando i dati dei log vengono trasferiti dall'origine al sink. L'unico valore supportato è `RegexFilterPipe`. Questo valore consente il filtraggio regolare di espressioni della sottostante rappresentazione testuale del record di log. L'utilizzo del filtraggio può ridurre i costi di trasmissione e di storage inviando solo alla pipeline di dati il downstream di record di log pertinenti. Questa coppia chiave-valore è facoltativa. Il valore di default è di non fornire alcuna trasformazione.
`FilterPattern`
Specifica l'espressione regolare per le pipeline `RegexFilterPipe` che consentono di filtrare record di log raccolti dall'origine prima di essere trasferite al sink. I record dei log vengono trasferiti dalle pipe di tipo `RegexFilterPipe` quando l'espressione regolare corrisponde alla rappresentazione testuale sottostante del record. Record di log strutturati, generati, ad esempio, quando si utilizza la coppia chiave-valore `ExtractionPattern` in una dichiarazione `DirectorySource` possono comunque essere filtrati tramite il meccanismo `RegexFilterPipe`. Questo perché questo meccanismo agisce sulla rappresentazione testuale originale prima di eseguire l'analisi. Questa coppia chiave-valore è facoltativa, ma deve essere fornita se la pipe specifica il tipo `RegexFilterPipe`.
Di seguito è riportato un esempio della dichiarazione di una pipe `RegexFilterPipe`:
```
{
"Id": "MyAppLog2ToFirehose",
"Type": "RegexFilterPipe",
"SourceRef": "MyAppLog2",
"SinkRef": "MyFirehose",
"FilterPattern": "^(10|11),.*",
"IgnoreCase": false,
"Negate": false
}
```
`SourceRef`
Specifica il nome (il valore della coppia chiave-valore `Id`) della dichiarazione di definizione dell'origine che raccoglie dati di log, eventi e parametri per la pipe (obbligatorio).
`SinkRef`
Specifica il nome (il valore della coppia chiave-valore `Id`) della dichiarazione di definizione del sink che raccoglie dati di log, eventi e parametri per la pipe (obbligatorio).
`IgnoreCase`
Facoltativo. Accetta valori di`true`o`false`: . Se impostato su`true`, Regex corrisponderà ai record in modo senza distinzione tra maiuscole e minuscole.
`Negate`
Facoltativo. Accetta valori di`true`o`false`: . Se impostato su`true`, la pipe inoltrerà i record che*NON FARE*Corrispondono all'espressione regolare.
Per un esempio di un file di configurazione completo che usa il tipo di pipe `RegexFilterPipe`, consulta [Utilizzo di pipe](configuring-kaw-examples.md#configuring-kaw-examples-pipes).
## Configurazione dell'agente Kinesis per le pipe metriche di Windows
Vi è una sorgente di metrica integrata denominata`_KinesisTapMetricsSource`che produce metriche sull'agente Kinesis per Windows. Se è presente un`CloudWatch`dichiarazione sink con un`Id`di`MyCloudWatchSink`La seguente dichiarazione di pipeline di Kinesis isce i parametri generati da da Windows a tale sink:
```
{
"Id": "KinesisAgentMetricsToCloudWatch",
"SourceRef": "_KinesisTapMetricsSource",
"SinkRef": "MyCloudWatchSink"
}
```
Per ulteriori informazioni sull'origine dei parametri integrati di Kinesis Agent per Windows, consulta[Origine dei parametri integrati di Kinesis Agent per Windows](source-object-declarations.md#kinesis-agent-builin-metrics-source): .
Se il file di configurazione invia anche i parametri contatori delle prestazioni, si consiglia di utilizzare una pipe e un sink separati anziché utilizzare lo stesso sink sia Kinesis parametri sia per i parametri contatori delle prestazioni di Windows.
# Configurazione di aggiornamenti automatici
Utilizzo dell'`appsettings.json`File di configurazione per abilitare gli aggiornamenti automatici di Amazon Kinesis Agent per Microsoft Windows e il file di configurazione per Kinesis Agent per Windows. Per controllare il comportamento di aggiornamento, specificare la coppia chiave-valore `Plugins` allo stesso livello nel file di configurazione di `Sources`, `Sinks` e `Pipes`.
La coppia chiave-valore `Plugins` specifica le funzionalità generali aggiuntive da utilizzare che non rientrano specificamente nelle categorie di origini, sink e pipe. Ad esempio, c'è un plug-in per l'aggiornamento di Kinesis Agent per Windows e c'è un plug-in per l'aggiornamento del file`appsettings.json`File di configurazione. I plug-in sono rappresentati come oggetti JSON e hanno sempre a disposizione una coppia chiave-valore `Type`. `Type` definisce le altre coppie chiave-valore che possono essere specificate per il plug-in. Sono supportati i seguenti tipi di plug-in:
`PackageUpdate`
Specifica che Kinesis Agent per Windows deve controllare periodicamente un file di configurazione della versione del pacchetto. Se il file della versione del pacchetto indica che deve essere installata un'altra versione di Kinesis Agent per Windows, allora Kinesis Agent per Windows scarica tale versione e la installa. Le coppie chiave-valore del plug-in `PackageUpdate` includono:
`Type`
Il valore deve essere la stringa `PackageUpdate` ed è obbligatorio.
`Interval`
Specifica la frequenza con cui verificare il file della versione del pacchetto per eventuali modifiche in pochi minuti rappresentate come stringa. Questa coppia chiave-valore è facoltativa. Se non specificato, il valore predefinito è 60 minuti. Se il valore è inferiore a 1, non è possibile verificare gli aggiornamenti.
`PackageVersion`
Specifica la posizione del file JSON della versione del pacchetto. Il file può risiedere su una condivisione di file (`file://`), un sito web (`http://`), o Amazon S3 (`s3://`). Ad esempio, un valore compreso tra e rappresenta`s3://mycompany/config/agent-package-version.json`indica che Kinesis Agent per Windows deve controllare il contenuto della`config/agent-package-version.json`file nel file`mycompany`Bucket Amazon S3. È necessario eseguire gli aggiornamenti in base al contenuto del file.
Il valore della proprietà`PackageVersion`coppia chiave-valore effettua la distinzione tra maiuscole Amazon S3 uscole
Di seguito è riportato un esempio dei contenuti di un file della versione di un pacchetto:
```
{
"Name": "AWSKinesisTap",
"Version": "1.0.0.106",
"PackageUrl": "https://s3-us-west-2.amazonaws.com/kinesis-agent-windows/downloads/AWSKinesisTap.{Version}.nupkg"
}
```
La`Version`Specifica la versione di Kinesis Agent per Windows da installare se non è già installata. La variabile di riferimento `{Version}` in `PackageUrl` risolve il valore specificato per la coppia chiave-valore `Version`. In questo esempio, la variabile restituisce la stringa `1.0.0.106`. Questa risoluzione di variabile viene fornita in modo che ci sia un'unica posizione della versione del pacchetto di file laddove la versione desiderata specificata viene memorizzata. È possibile utilizzare più file della versione del pacchetto per controllare il ritmo di implementazione di nuove versioni di Kinesis Agent per Windows e convalidare una nuova versione prima di un'implementazione di dimensioni maggiori. Per eseguire il rollback di una distribuzione di Kinesis Agent per Windows, modificare uno o più file della versione del pacchetto per specificare una versione precedente di Kinesis Agent per Windows che funziona correttamente nell'ambiente.
Il valore della coppia chiave-valore `PackageVersion` subisce la sostituzione delle variabili per facilitare la selezione automatica dei file della versione di pacchetti differenti. Per ulteriori informazioni sulla sostituzione delle variabili, consulta [Configurazione di sostituzione di variabili sink](sink-object-declarations.md#configuring-kinesis-agent-windows-sink-variable-substitution).
`AccessKey`
Specifica la chiave di accesso da utilizzare per autenticare l'accesso al file della versione del pacchetto in Amazon S3. Questa coppia chiave-valore è facoltativa. Non è consigliabile utilizzare questa coppia chiave-valore. Per gli approcci di autenticazione alternativi raccomandati, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`SecretKey`
Specifica la chiave segreta da utilizzare per autenticare l'accesso al file della versione del pacchetto in Amazon S3. Questa coppia chiave-valore è facoltativa. Non è consigliabile utilizzare questa coppia chiave-valore. Per gli approcci di autenticazione alternativi raccomandati, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`Region`
Specifica l'endpoint della regione da utilizzare per accedere al file della versione del pacchetto da Amazon S3. Questa coppia chiave-valore è facoltativa.
`ProfileName`
Specifica il profilo di sicurezza da utilizzare per autenticare l'accesso al file della versione del pacchetto in Amazon S3. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). Questa coppia chiave-valore è facoltativa.
`RoleARN`
Specifica quale ruolo assumere durante l'autenticazione dell'accesso al file della versione del pacchetto in Amazon S3 in uno scenario tra più account. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). Questa coppia chiave-valore è facoltativa.
Se nessun plug-in `PackageUpdate` viene specificato, allora nessun file della versione del pacchetto viene controllato per stabilire se un aggiornamento è obbligatorio.
`ConfigUpdate`
Specifica che Kinesis Agent per Windows deve controllare periodicamente la presenza di`appsettings.json`File di configurazione archiviato in una condivisione di file, sito Web o Amazon S3. Se un file di configurazione aggiornato esiste, viene scaricato e installato da Kinesis Agent per Windows.`ConfigUpdate`Le coppie chiave-valore includono quanto segue:
`Type`
Il valore deve essere la stringa `ConfigUpdate` ed è obbligatorio.
`Interval`
Specifica la frequenza con cui verificare un nuovo file di configurazione in pochi minuti rappresentato come stringa. Questa coppia chiave-valore è facoltativa e, se non è specificato, il valore predefinito sarà 5 minuti. Se il valore è inferiore a 1, l'aggiornamento del file di configurazione non viene selezionato.
`Source`
Specifica dove cercare un file di configurazione aggiornato. Il file può risiedere su una condivisione di file (`file://`), un sito web (`http://`), o Amazon S3 (`s3://`). Ad esempio, un valore compreso tra e rappresenta`s3://mycompany/config/appsettings.json`indica che Kinesis Agent per Windows deve verificare la disponibilità di aggiornamenti per`config/appsettings.json`file nel file`mycompany`Bucket Amazon S3.
Il valore della proprietà`Source`Specifica la distinzione tra maiuscole e minuscole per Amazon S3.
Il valore della coppia chiave-valore `Source` subisce la sostituzione delle variabili per facilitare la selezione automatica di file di configurazione differenti. Per ulteriori informazioni sulla sostituzione delle variabili, consulta [Configurazione di sostituzione di variabili sink](sink-object-declarations.md#configuring-kinesis-agent-windows-sink-variable-substitution).
`Destination`
Specifica dove archiviare il file di configurazione nel computer locale. Questo può essere un percorso relativo, un percorso assoluto o un percorso contenente riferimenti a variabili di ambiente, ad esempio `%PROGRAMDATA%`. Se il percorso è relativo, è relativo al percorso in cui è installato Kinesis Agent per Windows. In genere, il valore deve essere `.\appsettings.json`. Questa coppia chiave-valore è obbligatoria.
`AccessKey`
Specifica la chiave di accesso da utilizzare per autenticare l'accesso al file di configurazione in Amazon S3. Questa coppia chiave-valore è facoltativa. Non è consigliabile utilizzare questa coppia chiave-valore. Per gli approcci di autenticazione alternativi raccomandati, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`SecretKey`
Specifica la chiave segreta da utilizzare per autenticare l'accesso al file di configurazione in Amazon S3. Questa coppia chiave-valore è facoltativa. Non è consigliabile utilizzare questa coppia chiave-valore. Per gli approcci di autenticazione alternativi raccomandati, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`Region`
Specifica l'endpoint della regione da utilizzare per accedere al file di configurazione da Amazon S3. Questa coppia chiave-valore è facoltativa.
`ProfileName`
Specifica il profilo di sicurezza da utilizzare per autenticare l'accesso al file di configurazione in Amazon S3. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). Questa coppia chiave-valore è facoltativa.
`RoleARN`
Specifica quale ruolo assumere durante l'autenticazione dell'accesso al file di configurazione in Amazon S3 in uno scenario tra più account. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). Questa coppia chiave-valore è facoltativa.
Se nessun plug-in `ConfigUpdate` viene specificato, allora nessun file di configurazione viene controllato per stabilire se un aggiornamento del file di configurazione è obbligatorio.
Il seguente file di configurazione di esempio `appsettings.json` dimostra l'utilizzo dei plug-in `PackageUpdate` e `ConfigUpdate`. In questo esempio, c'è un file della versione del pacchetto che si trova nel file`mycompany`Bucket Amazon S3 denominato`config/agent-package-version.json`: . Questo file è selezionato per eventuali modifiche circa ogni 2 ore. Se un'altra versione di Kinesis Agent per Windows è specificata nel file della versione del pacchetto, la versione dell'agente specificata viene installata dal percorso specificato nel file della versione del pacchetto.
Inoltre, c'è un file`appsettings.json`file di configurazione archiviato nel file`mycompany`Bucket Amazon S3 denominato`config/appsettings.json`: . Circa ogni 30 minuti, il file viene confrontato con l'attuale file di configurazione. Se sono diversi, il file di configurazione aggiornato viene scaricato da Amazon S3 e installato nel percorso locale tipico per il file`appsettings.json`File di configurazione.
```
{
"Sources": [
{
"Id": "ApplicationLogSource",
"SourceType": "DirectorySource",
"Directory": "C:\\LogSource\\",
"FileNameFilter": "*.log",
"RecordParser": "SingleLine"
}
],
"Sinks": [
{
"Id": "ApplicationLogKinesisFirehoseSink",
"SinkType": "KinesisFirehose",
"StreamName": "ApplicationLogFirehoseDeliveryStream",
"Region": "us-east-1"
}
],
"Pipes": [
{
"Id": "ApplicationLogSourceToApplicationLogKinesisFirehoseSink",
"SourceRef": "ApplicationLogSource",
"SinkRef": "ApplicationLogKinesisFirehoseSink"
}
],
"Plugins": [
{
"Type": "PackageUpdate"
"Interval": "120",
"PackageVersion": "s3://mycompany/config/agent-package-version.json"
},
{
"Type": "ConfigUpdate",
"Interval": "30",
"Source": "s3://mycompany/config/appsettings.json",
"Destination": ".\appSettings.json"
}
]
}
```
# Esempi di configurazione di Kinesis Agent per Windows
La`appsettings.json`Il file di configurazione è un documento JSON che controlla il modo in cui Amazon Kinesis Agent per Microsoft Windows raccoglie i log, gli eventi e i parametri. Controlla anche il modo in cui Kinesis Agent per Windows trasforma i dati e li trasmette ai vari servizi AWS. Per ulteriori informazioni sulle dichiarazioni di pipe, sink e origine nel file di configurazione, consulta [Dichiarazioni delle origini](source-object-declarations.md), [Dichiarazioni dei sink](sink-object-declarations.md) e [Dichiarazioni delle pipe](pipe-object-declarations.md).
Le seguenti sezioni contengono esempi di file di configurazione per diversi tipi di scenari.
**Topics**
+ [Streaming da diverse origini a Kinesis Data Streams](#configuring-kaw-examples-sources)
+ [Streaming da log di eventi di applicazioni Windows ai sink](#configuring-kaw-examples-sinks)
+ [Utilizzo di pipe](#configuring-kaw-examples-pipes)
+ [Utilizzo di più origini e pipe](#configuring-kaw-examples-multiple)
## Streaming da diverse origini a Kinesis Data Streams
L'esempio seguente`appsettings.json`I file di configurazione mostrano i log di streaming e gli eventi da origini diverse a Kinesis Data Streams e da contatori di performance Windows a parametri Amazon CloudWatch.
### Parser di record `DirectorySource`, `SysLog`
Il seguente file effettua lo streaming di record di log in formato syslog da tutti i file con un`.log`Estensione file nella directory`C:\LogSource\`directory alla directory`SyslogKinesisDataStream`Kinesis Data Streams nella regione us-east-1. Viene definito un segnalibro per garantire che vengano inviati tutti i dati dai file di log anche se l'agente viene arrestato e riavviato più tardi. Un'applicazione personalizzata può leggere ed elaborare i record dal flusso `SyslogKinesisDataStream`.
```
{
"Sources": [
{
"Id": "SyslogDirectorySource",
"SourceType": "DirectorySource",
"Directory": "C:\\LogSource\\",
"FileNameFilter": "*.log",
"RecordParser": "SysLog",
"TimeZoneKind": "UTC",
"InitialPosition": "Bookmark"
}
],
"Sinks": [
{
"Id": "KinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "SyslogKinesisDataStream",
"Region": "us-east-1"
}
],
"Pipes": [
{
"Id": "SyslogDS2KSSink",
"SourceRef": "SyslogDirectorySource",
"SinkRef": "KinesisStreamSink"
}
]
}
```
### Parser di record `DirectorySource`, `SingleLineJson`
Il seguente file effettua lo streaming di record di log in formato JSON da tutti i file con un`.log`Estensione file nella directory`C:\LogSource\`directory alla directory`JsonKinesisDataStream`Kinesis Data Streams nella regione us-east-1. Prima dello streaming, le coppie chiave-valore per le chiavi `ComputerName` e `DT` vengono aggiunte a ogni oggetto JSON, con i valori per il nome del computer e la data e l'ora in cui il record viene elaborato. Un'applicazione personalizzata può leggere ed elaborare i record dal flusso `JsonKinesisDataStream`.
```
{
"Sources": [
{
"Id": "JsonLogSource",
"SourceType": "DirectorySource",
"RecordParser": "SingleLineJson",
"Directory": "C:\\LogSource\\",
"FileNameFilter": "*.log",
"InitialPosition": 0
}
],
"Sinks": [
{
"Id": "KinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "JsonKinesisDataStream",
"Region": "us-east-1",
"Format": "json",
"ObjectDecoration": "ComputerName={ComputerName};DT={timestamp:yyyy-MM-dd HH:mm:ss}"
}
],
"Pipes": [
{
"Id": "JsonLogSourceToKinesisStreamSink",
"SourceRef": "JsonLogSource",
"SinkRef": "KinesisStreamSink"
}
]
}
```
### `ExchangeLogSource`
Il seguente file effettua lo streaming di record di log generati da Microsoft Exchange e archiviati in file con il`.log`Estensione nella directory`C:\temp\ExchangeLog\`directory alla directory`ExchangeKinesisDataStream`Streaming di dati di kinesis nella regione us-east-1 in formato JSON. Anche se i log di Exchange non sono in formato JSON, Kinesis Agent per Windows è in grado di analizzare i log e di trasformarli in formato JSON. Prima dello streaming, le coppie chiave-valore per le chiavi `ComputerName` e `DT` vengono aggiunte a ogni oggetto JSON contenente i valori per il nome del computer e la data e l'ora in cui il record viene elaborato. Un'applicazione personalizzata può leggere ed elaborare i record dal flusso `ExchangeKinesisDataStream`.
```
{
"Sources": [
{
"Id": "ExchangeSource",
"SourceType": "ExchangeLogSource",
"Directory": "C:\\temp\\ExchangeLog\",
"FileNameFilter": "*.log"
}
],
"Sinks": [
{
"Id": "KinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "ExchangeKinesisDataStream",
"Region": "us-east-1",
"Format": "json",
"ObjectDecoration": "ComputerName={ComputerName};DT={timestamp:yyyy-MM-dd HH:mm:ss}"
}
],
"Pipes": [
{
"Id": "ExchangeSourceToKinesisStreamSink",
"SourceRef": "ExchangeSource",
"SinkRef": "KinesisStreamSink"
}
]
}
```
### `W3SVCLogSource`
Il seguente file effettua lo streaming di record di log di Internet Information Services (IIS) per Windows archiviati nel percorso standard di tali file al file di`IISKinesisDataStream`Kinesis Data Streams nella regione us-east-1. Un'applicazione personalizzata può leggere ed elaborare i record dal flusso `IISKinesisDataStream`. IIS è un server Web per Windows.
```
{
"Sources": [
{
"Id": "IISLogSource",
"SourceType": "W3SVCLogSource",
"Directory": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
"FileNameFilter": "*.log"
}
],
"Sinks": [
{
"Id": "KinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "IISKinesisDataStream",
"Region": "us-east-1"
}
],
"Pipes": [
{
"Id": "IISLogSourceToKinesisStreamSink",
"SourceRef": "IISLogSource",
"SinkRef": "KinesisStreamSink"
}
]
}
```
### `WindowsEventLogSource` con Query
Il file seguente esegue flussi di eventi di registro dal registro eventi di sistema di Windows con un livello di`Critical`o`Error`(minore di o uguale a 2) al`SystemKinesisDataStream`Streaming di dati di kinesis nella regione us-east-1 in formato JSON. Un'applicazione personalizzata può leggere ed elaborare i record dal flusso `SystemKinesisDataStream`.
```
{
"Sources": [
{
"Id": "SystemLogSource",
"SourceType": "WindowsEventLogSource",
"LogName": "System",
"Query": "*[System/Level<=2]"
}
],
"Sinks": [
{
"Id": "KinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "SystemKinesisDataStream",
"Region": "us-east-1",
"Format": "json"
}
],
"Pipes": [
{
"Id": "SLSourceToKSSink",
"SourceRef": "SystemLogSource",
"SinkRef": "KinesisStreamSink"
}
]
}
```
### `WindowsETWEventSource`
Il seguente file effettua lo streaming dell'eccezione Microsoft Common Language Runtime (CLR) e degli eventi di sicurezza al`ClrKinesisDataStream`Streaming di dati di kinesis nella regione us-east-1 in formato JSON. Un'applicazione personalizzata può leggere ed elaborare i record dal flusso `ClrKinesisDataStream`.
```
{
"Sources": [
{
"Id": "ClrETWEventSource",
"SourceType": "WindowsETWEventSource",
"ProviderName": "Microsoft-Windows-DotNETRuntime",
"TraceLevel": "Verbose",
"MatchAnyKeyword": "0x00008000, 0x00000400"
}
],
"Sinks": [
{
"Id": "KinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "ClrKinesisDataStream",
"Region": "us-east-1",
"Format": "json"
}
],
"Pipes": [
{
"Id": "ETWSourceToKSSink",
"SourceRef": "ClrETWEventSource",
"SinkRef": "KinesisStreamSink"
}
]
}
```
### `WindowsPerformanceCounterSource`
Il seguente file effettua lo streaming di contatori di prestazioni per i file totali aperti, i tentativi di accesso totali dal riavvio, il numero di letture del disco al secondo e la percentuale di spazio di disco libero ai parametri CloudWatch nella regione us-east-1. Puoi tracciare un grafico di queste metriche in CloudWatch, creare dashboard dai grafici e impostare allarmi che inviano notifiche quando vengono superate soglie.
```
{
"Sources": [
{
"Id": "PerformanceCounter",
"SourceType": "WindowsPerformanceCounterSource",
"Categories": [
{
"Category": "Server",
"Counters": [
"Files Open",
"Logon Total"
]
},
{
"Category": "LogicalDisk",
"Instances": "*",
"Counters": [
"% Free Space",
{
"Counter": "Disk Reads/sec",
"Unit": "Count/Second"
}
]
}
],
}
],
"Sinks": [
{
"Namespace": "MyServiceMetrics",
"Region": "us-east-1",
"Id": "CloudWatchSink",
"SinkType": "CloudWatch"
}
],
"Pipes": [
{
"Id": "PerformanceCounterToCloudWatch",
"SourceRef": "PerformanceCounter",
"SinkRef": "CloudWatchSink"
}
]
}
```
## Streaming da log di eventi di applicazioni Windows ai sink
L'esempio seguente`appsettings.json`I file di configurazione mostrano lo streaming di log di eventi di applicazioni Windows a diversi sink in Amazon Kinesis Agent per Microsoft Windows. Per esempi di utilizzo dei tipi di sink `KinesisStream` e `CloudWatch`, consulta [Streaming da diverse origini a Kinesis Data Streams](#configuring-kaw-examples-sources).
### `KinesisFirehose`
I seguenti flussi di file`Critical`o`Error`Eventi del registro applicazioni di Windows nel`WindowsLogFirehoseDeliveryStream`Streaming di distribuzione di Kinesis Data Firehose nella regione us-east-1. Se la connettività a Kinesis Data Firehose viene interrotta, gli eventi vengono prima messi in coda in memoria. Quindi, se necessario, sono in coda a un file su disco fino al ripristino della connettività. Quindi gli eventi non sono in coda e vengono inviati seguiti da eventuali nuovi eventi.
È possibile configurare Kinesis Data Firehose per memorizzare i dati in streaming in diversi tipi di storage e servizi di analisi in base ai requisiti della pipeline di dati.
```
{
"Sources": [
{
"Id": "ApplicationLogSource",
"SourceType": "WindowsEventLogSource",
"LogName": "Application",
"Query": "*[System/Level<=2]"
}
],
"Sinks": [
{
"Id": "WindowsLogKinesisFirehoseSink",
"SinkType": "KinesisFirehose",
"StreamName": "WindowsLogFirehoseDeliveryStream",
"Region": "us-east-1",
"QueueType": "file"
}
],
"Pipes": [
{
"Id": "ALSource2ALKFSink",
"SourceRef": "ApplicationLogSource",
"SinkRef": "WindowsLogKinesisFirehoseSink"
}
]
}
```
### `CloudWatchLogs`
I seguenti flussi di file`Critical`o`Error`Registrazione degli eventi di log di applicazioni Windows ai flussi di CloudWatch Logs nella directory`MyServiceApplicationLog-Group`gruppo di log. Il nome di ogni flusso inizia con `Stream-`. Termina con l'anno di quattro cifre, il mese di due cifre e il giorno di due cifre in cui il flusso è stato creato, tutti concatenati (per esempio, `Stream-20180501` è il flusso creato il 1° maggio 2018).
```
{
"Sources": [
{
"Id": "ApplicationLogSource",
"SourceType": "WindowsEventLogSource",
"LogName": "Application",
"Query": "*[System/Level<=2]"
}
],
"Sinks": [
{
"Id": "CloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"LogGroup": "MyServiceApplicationLog-Group",
"LogStream": "Stream-{timestamp:yyyyMMdd}",
"Region": "us-east-1",
"Format": "json"
}
],
"Pipes": [
{
"Id": "ALSource2CWLSink",
"SourceRef": "ApplicationLogSource",
"SinkRef": "CloudWatchLogsSink"
}
]
}
```
## Utilizzo di pipe
Il seguente file di configurazione di esempio `appsettings.json` dimostra l'utilizzo di funzionalità relative alle pipe.
In questo esempio viene eseguito lo streaming di voci di log dal`c:\LogSource\`al`ApplicationLogFirehoseDeliveryStream`Streaming di distribuzione di Kinesis Data Firehose. Include solo le linee che soddisfano l'espressione regolare specificata dalla coppia chiave-valore `FilterPattern`. In particolare, solo le righe del file di log che iniziano con`10`o`11`vengono trasmesse a Kinesis Data Firehose.
```
{
"Sources": [
{
"Id": "ApplicationLogSource",
"SourceType": "DirectorySource",
"Directory": "C:\\LogSource\\",
"FileNameFilter": "*.log",
"RecordParser": "SingleLine"
}
],
"Sinks": [
{
"Id": "ApplicationLogKinesisFirehoseSink",
"SinkType": "KinesisFirehose",
"StreamName": "ApplicationLogFirehoseDeliveryStream",
"Region": "us-east-1"
}
],
"Pipes": [
{
"Id": "ALSourceToALKFSink",
"Type": "RegexFilterPipe",
"SourceRef": "ApplicationLogSource",
"SinkRef": "ApplicationLogKinesisFirehoseSink",
"FilterPattern": "^(10|11),.*"
}
]
}
```
## Utilizzo di più origini e pipe
Il seguente file di configurazione di esempio `appsettings.json` dimostra l'utilizzo di più origini e pipe.
In questo esempio viene eseguito lo streaming di log di sistema Windows Event, dell'applicazione e di sicurezza al`EventLogStream`Il flusso di distribuzione di Kinesis Data Firehose utilizza tre origini, tre tubi e un unico lavandino.
```
{
"Sources": [
{
"Id": "ApplicationLog",
"SourceType": "WindowsEventLogSource",
"LogName": "Application"
},
{
"Id": "SecurityLog",
"SourceType": "WindowsEventLogSource",
"LogName": "Security"
},
{
"Id": "SystemLog",
"SourceType": "WindowsEventLogSource",
"LogName": "System"
}
],
"Sinks": [
{
"Id": "EventLogSink",
"SinkType": "KinesisFirehose",
"StreamName": "EventLogStream",
"Format": "json"
},
],
"Pipes": [
{
"Id": "ApplicationLogToFirehose",
"SourceRef": "ApplicationLog",
"SinkRef": "EventLogSink"
},
{
"Id": "SecurityLogToFirehose",
"SourceRef": "SecurityLog",
"SinkRef": "EventLogSink"
},
{
"Id": "SystemLogToFirehose",
"SourceRef": "SystemLog",
"SinkRef": "EventLogSink"
}
]
}
```
# Configurazione della Telemetria
Per abilitare un supporto migliore, per impostazione predefinita, Amazon Kinesis Agent per Microsoft Windows raccoglie le statistiche relative al funzionamento dell'agente e le invia ad AWS. Queste informazioni non contengono informazioni personali. Non include i dati raccolti o inviati ai servizi AWS. Raccogliamo circa 1-2 KB di questi dati dei parametri ogni 60 minuti.
È possibile annullare la raccolta e la trasmissione di queste statistiche. Per eseguire questa operazione, aggiungere la seguente coppia chiave-valore al file di configurazione `appsettings.json` allo stesso livello di origini, sink e pipe:
```
"Telemetrics":
{ "off": "true" }
```
Ad esempio, il seguente file di configurazione configura un'origine, un sink e una pipe e disabilita anche la telemetria:
```
{
"Sources": [
{
"Id": "ApplicationLogSource",
"SourceType": "DirectorySource",
"Directory": "C:\\LogSource\\",
"FileNameFilter": "*.log",
"RecordParser": "SingleLine"
}
],
"Sinks": [
{
"Id": "ApplicationLogKinesisFirehoseSink",
"SinkType": "KinesisFirehose",
"StreamName": "ApplicationLogFirehoseDeliveryStream",
"Region": "us-east-1"
}
],
"Pipes": [
{
"Id": "ApplicationLogSourceToApplicationLogKinesisFirehoseSink",
"SourceRef": "ApplicationLogSource",
"SinkRef": "ApplicationLogKinesisFirehoseSink"
}
],
"Telemetrics":
{
"off": "true"
}
}
```
Quando la telemetria è abilitata raccogliamo i seguenti parametri:
`ClientId`
L'ID univoco assegnato automaticamente quando il software è installato.
`ClientTimestamp`
La data e l'ora in cui la telemetria viene raccolta.
`OSDescription`
Una descrizione del sistema operativo.
`DotnetFramework`
L'attuale versione del framework dotnet.
`MemoryUsage`
La quantità di memoria che consuma Kinesis Agent per Windows (MB).
`CPUUsage`
La percentuale Kinesis della CPU di in decimali. Ad esempio, 0,01 equivale a 1%.
`InstanceId`
ID istanza Amazon EC2 se Kinesis Agent per Windows è in esecuzione su un'istanza Amazon EC2.
`InstanceType (string)`
Tipo di istanza Amazon EC2 se Kinesis Agent per Windows è in esecuzione su un'istanza Amazon EC2.
Inoltre, raccogliamo i parametri elencati in [Elenco delle metriche di Kinesis Agent per Windows](source-object-declarations.md#kinesis-agent-metric-list).