Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Configuration d'Amazon Kinesis Agent pour Microsoft Windows
Avant de démarrer Amazon Kinesis Agent pour Microsoft Windows, vous devez créer un fichier de configuration et le déployer. Le fichier de configuration fournit les informations nécessaires pour collecter, transformer et diffuser les données entre les serveurs et les ordinateurs de bureau Windows et les différents services AWS. Les fichiers de configuration définissent les ensembles de sources, récepteurs et canaux qui connectent les sources aux récepteurs, ainsi que les transformations facultatives.
Le fichier de configuration de l'Agent Kinesis pour Windows est nommé`appsettings.json`. Déployez ce fichier sur `%PROGRAMFILES%\Amazon\AWSKinesisTap`.
**Topics**
+ [Structure de la configuration de base](basic-configuration-structure.md)
+ [Déclarations de sources](source-object-declarations.md)
+ [Déclarations de récepteurs](sink-object-declarations.md)
+ [Déclarations de canal](pipe-object-declarations.md)
+ [Configuration des mises à jour automatiques](update-configuration-options.md)
+ [Exemples de configuration de l'agent Kinesis pour Windows](configuring-kaw-examples.md)
+ [Configuration de la télémétrie](telemetrics-configuration-option.md)
# Structure de la configuration de base
La structure de base du fichier de configuration de Amazon Kinesis Agent for Microsoft Windows est un document JSON suivant :
```
{
"Sources": [ ],
"Sinks": [ ],
"Pipes": [ ]
}
```
+ La valeur de `Sources` est une ou plusieurs [Déclarations de sources](source-object-declarations.md).
+ La valeur de `Sinks` est une ou plusieurs [Déclarations de récepteurs](sink-object-declarations.md).
+ La valeur de `Pipes` est une ou plusieurs [Déclarations de canal](pipe-object-declarations.md).
Pour plus d'informations sur les concepts de source, canal (pipe) et récepteur (sink) de Kinesis Agent (sink), consultez[Amazon Kinesis Agent pour Microsoft Windows Concepts](kinesis-agent-windows-concepts.md).
L'exemple suivant est un`appsettings.json`Configurez Kinesis Agent pour Windows pour diffuser les événements des journaux d'application Windows sur 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"
}
]
}
```
Pour plus d'informations sur chaque type de déclaration, consultez les sections suivantes :
+ [Déclarations de sources](source-object-declarations.md)
+ [Déclarations de récepteurs](sink-object-declarations.md)
+ [Déclarations de canal](pipe-object-declarations.md)
## Sensibilité à la casse de la configuration
Les fichiers au format JSON sont généralement sensibles à la casse et vous devez supposer que toutes les clés et valeurs des fichiers de configuration de Kinesis Agent for Windows le sont également. Certaines clés et valeurs du fichier de configuration `appsettings.json` ne sont pas sensibles à la casse. Par exemple :
+ Valeur de la paire clé-valeur `Format` pour les récepteurs. Pour plus d'informations, consultez [Déclarations de récepteurs](sink-object-declarations.md).
+ Valeur de la paire clé-valeur `SourceType` pour les sources, de la paire clé-valeur `SinkType` pour les récepteurs et de la paire clé-valeur `Type` pour les canaux et les plug-ins.
+ Valeur de la paire clé-valeur `RecordParser` pour la source `DirectorySource`. Pour plus d'informations, consultez [Configuration de DirectorySource](source-object-declarations.md#directory-source-configuration).
+ Valeur de la paire clé-valeur `InitialPosition` pour les sources. Pour plus d'informations, consultez [Configuration des signets](source-object-declarations.md#advanced-source-configuration).
+ Préfixes pour les substitutions de variables. Pour plus d'informations, consultez [Configuration des substitutions de variables de récepteur](sink-object-declarations.md#configuring-kinesis-agent-windows-sink-variable-substitution).
# Déclarations de sources
Dans Amazon Kinesis Agent pour Microsoft Windows,*Déclarations de sources*Décrire l'emplacement et la nature des données de journaux, d'événements et de métriques qui doivent être collectées. Elles spécifient également, le cas échéant, des informations destinées à l'analyse des données afin que ces dernières puissent être transformées. Les sections suivantes décrivent les configurations des types de sources intégrés qui sont disponibles dans Kinesis Agent pour Windows. Étant donné que l'Agent Kinesis pour Windows est extensible, vous pouvez ajouter des types de sources personnalisés. Chaque type de source nécessite généralement des paires clé-valeur spécifiques dans les objets de configuration qui sont pertinents pour ce type de source.
Toutes les déclarations de sources doivent contenir au moins les paires clé-valeur suivantes :
`Id`
Chaîne unique qui identifie un objet source particulier dans le fichier de configuration.
`SourceType`
Nom du type de source pour cet objet source. Le type de source spécifie l'origine des données de journal, d'événement ou de métrique qui sont collectées par cet objet source. Il détermine également les autres aspects de la source pouvant être déclarés.
Pour obtenir des exemples de fichiers de configuration complets utilisant différents types de déclarations de sources, consultez [Diffusion à partir de diverses sources vers les Kinesis Data Streams](configuring-kaw-examples.md#configuring-kaw-examples-sources).
**Topics**
+ [Configuration de DirectorySource](#directory-source-configuration)
+ [Configuration de ExchangeLogSource](#exchange-source-configuration)
+ [Configuration de W3SVCLogSource](#iis-source-configuration)
+ [Configuration de UlsSource](#sharepoint-source-configuration)
+ [Configuration de WindowsEventLogSource](#window-event-source-configuration)
+ [Configuration de WindowsEventLogPollingSource](#eventlogpolling-source-configuration)
+ [Configuration de WindowsETWEventSource](#etw-source-configuration)
+ [Configuration de WindowsPerformanceCounterSource](#performance-counter-source-configuration)
+ [Source des métriques prédéfinies de Kinesis Agent pour Windows](#kinesis-agent-builin-metrics-source)
+ [Liste des mesures Kinesis Agent pour Windows](#kinesis-agent-metric-list)
+ [Configuration des signets](#advanced-source-configuration)
## Configuration de DirectorySource
### Overview
Le type de source `DirectorySource` recueille les journaux des fichiers qui sont stockés dans le répertoire spécifié. Étant donné que les fichiers journaux ont de nombreux formats différents, la déclaration `DirectorySource` vous permet de spécifier le format des données dans le fichier journal. Vous pouvez ensuite transformer le contenu du journal dans un format standard tel que JSON ou XML avant de le diffuser vers différents services AWS.
Voici un exemple de déclaration `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"
}
```
Toutes les déclarations `DirectorySource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"DirectorySource"` (obligatoire).
`Directory`
Chemin du répertoire contenant les fichiers journaux (obligatoire).
`FileNameFilter`
Limite le cas échéant l'ensemble de fichiers dans le répertoire dans lequel les données de journal sont collectées sur la base d'un modèle d'attribution de noms de fichiers contenant des caractères génériques. Si vous disposez de plusieurs modèles de nom de fichier journal, cette fonctionnalité vous permet d'utiliser un`DirectorySource`, comme illustré dans l'exemple suivant.
```
FileNameFilter: "*.log|*.txt"
```
Les administrateurs système compressent parfois les fichiers journaux avant de les archiver. Si vous spécifiez`"*.*"`in`FileNameFilter`, les fichiers compressés connus sont désormais exclus. Cette fonctionnalité empêche`.zip`,`.gz`, et`.bz2`d'être diffusés accidentellement. Si cette paire clé-valeur n'est pas spécifiée, les données de tous les fichiers du répertoire sont collectées par défaut.
`IncludeSubdirectories`
Spécifie de surveiller les sous-répertoires à une profondeur arbitraire limitée par le système d'exploitation. Cette fonctionnalité est utile pour surveiller les serveurs Web avec plusieurs sites Web. Vous pouvez également utiliser l'`IncludeDirectoryFilter`pour surveiller uniquement certains sous-répertoires spécifiés dans le filtre.
`RecordParser`
Spécifie la façon dont le type de source `DirectorySource` doit analyser les fichiers journaux qui se trouvent dans le répertoire spécifié. Cette paire clé-valeur est obligatoire et les valeurs valides sont les suivantes :
+ `SingleLine`— Chaque ligne du fichier journal est un enregistrement de journal.
+ `SingleLineJson`— Chaque ligne du fichier journal est un enregistrement de journal au format JSON. Cet analyseur est utile lorsque vous souhaitez ajouter des paires clé-valeur supplémentaires au JSON à l'aide d'un élément ObjectDecoration. Pour plus d'informations, consultez [Configuration des décorations de récepteurs](sink-object-declarations.md#configuring-kinesis-agent-windows-decoration-configuration). Pour obtenir un exemple utilisant l'analyseur d'enregistrements `SingleLineJson`, consultez [Didacticiel : Diffuser les fichiers journaux JSON vers Amazon S3 à l'aide de Kinesis Agent pour Windows](directory-source-to-s3-tutorial.md).
+ `Timestamp`— Une ou plusieurs lignes peuvent inclure un enregistrement de journal. L'enregistrement de journal commence par un horodatage. Cette option requiert la spécification de la paire clé-valeur `TimestampFormat`.
+ `Regex`— Chaque enregistrement commence par du texte qui correspond à une expression régulière particulière. Cette option requiert la spécification de la paire clé-valeur `Pattern`.
+ `SysLog`— Indique que que le fichier journal est écrit dans l'[syslog](https://en.wikipedia.org/wiki/Syslog)format standard. Le fichier journal est analysé dans les enregistrements en fonction de cette spécification.
+ `Delimited`— Version plus simple de l'analyseur d'enregistrements Regex dans laquelle les éléments de données des enregistrements de journaux sont séparés par un délimiteur cohérent. Cette option est plus facile à utiliser et s'exécute plus rapidement que l'analyseur Regex. Il est préférable de l'utiliser lorsqu'elle est disponible. Lorsque vous utilisez cette option, vous devez spécifier la paire clé-valeur `Delimiter`.
`TimestampField`
Spécifie le champ JSON qui contient l'horodatage de l'enregistrement. Est uniquement utilisé avec l'élément `RecordParser` `SingleLineJson`. La paire clé-valeur est facultative. Si cet élément n'est pas spécifié, Kinesis Agent pour Windows utilise l'heure à laquelle l'enregistrement a été lu comme horodatage. La spécification de cette paire clé-valeur permet à de générer Kinesis de latence plus précises.
`TimestampFormat`
Spécifie comment analyser la date et l'heure associées à l'enregistrement. La valeur est la chaîne `epoch` ou une chaîne de format date/heure .NET. Si la valeur est `epoch`, l'heure est analysée en fonction de l'heure UNIX Epoch. Pour plus d'informations sur l'heure UNIX Epoch, consultez [Heure UNIX](https://en.wikipedia.org/wiki/Unix_time). Pour plus d'informations sur les chaînes de format date/heure .NET, consultez[Chaînes de format de date et d'heure personnalisées](https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings)dans la documentation Microsoft .NET). Cette paire clé-valeur est uniquement obligatoire si l'analyseur d'enregistrements `Timestamp` est spécifié ou si l'analyseur d'enregistrements `SingleLineJson` est spécifié en même temps que la paire clé-valeur `TimestampField`.
`Pattern`
Spécifie une expression régulière qui doit correspondre à la première ligne d'un enregistrement comportant potentiellement plusieurs lignes. Cette paire clé-valeur est uniquement obligatoire pour l'analyseur d'enregistrements `Regex`.
`ExtractionPattern`
Spécifie une expression régulière qui doit utiliser des groupes nommés. L'enregistrement est analysé à l'aide de cette expression régulière et les groupes nommés forment les champs de l'enregistrement analysé. Ces champs sont ensuite utilisés comme base pour construire des objets ou des documents JSON ou XML qui sont ensuite diffusés par les récepteurs vers différents services AWS. Cette paire clé-valeur est facultative et est disponible avec l'`Regex`analyseur d'enregistrement et l'analyseur d'horodatage.
Le nom de groupe `Timestamp` fait l'objet d'un traitement spécial, car il indique à l'analyseur `Regex` le champ qui contient la date et l'heure de chaque enregistrement dans chaque fichier journal.
`Delimiter`
Spécifie le caractère ou la chaîne qui sépare chaque élément de chaque enregistrement de journal. Cette paire clé-valeur doit être (et peut uniquement être) utilisée avec l'analyseur d'enregistrements `Delimited`. Utilisez la séquence de deux caractères `\t` pour représenter le caractère de tabulation.
`HeaderPattern`
Spécifie une expression régulière correspondant à la ligne du fichier journal qui contient l'ensemble des en-têtes de l'enregistrement. Si le fichier journal ne contient aucune information d'en-tête, utilisez la paire clé-valeur `Headers` pour spécifier les en-têtes implicites. La paire clé-valeur `HeaderPattern` est facultative et est uniquement valide pour l'analyseur d'enregistrements `Delimited`.
Une entrée d'en-tête vide (longueur 0) pour une colonne provoque le filtrage des données de cette colonne dans la sortie finale de la sortie analysée `DirectorySource`.
`Headers`
Spécifie les noms des colonnes de données analysées à l'aide du délimiteur spécifié. Cette paire clé-valeur est facultative et est uniquement valide pour l'analyseur d'enregistrements `Delimited`.
Une entrée d'en-tête vide (longueur 0) pour une colonne provoque le filtrage des données de cette colonne dans la sortie finale de la sortie analysée `DirectorySource`.
`RecordPattern`
Spécifie une expression régulière qui identifie les lignes du fichier journal contenant des données d'enregistrement. En dehors de la ligne d'en-tête facultative identifiée par `HeaderPattern`, les lignes qui ne correspondent pas à l'élément `RecordPattern` spécifié sont ignorées pendant le traitement. Cette paire clé-valeur est facultative et est uniquement valide pour l'analyseur d'enregistrements `Delimited`. Si cet élément n'est pas fourni, par défaut, toute ligne qui ne correspond pas à l'élément facultatif `HeaderPattern` ou `CommentPattern` est considérée comme une ligne contenant des données d'enregistrement analysables.
`CommentPattern`
Spécifie une expression régulière qui identifie les lignes du fichier journal devant être exclues avant l'analyse des données du fichier journal. Cette paire clé-valeur est facultative et est uniquement valide pour l'analyseur d'enregistrements `Delimited`. Si cet élément n'est pas fourni, par défaut, toute ligne qui ne correspond pas à l'élément facultatif `HeaderPattern` est considérée comme une ligne contenant des données d'enregistrement analysables, sauf si `RecordPattern` est spécifié.
`TimeZoneKind`
Indique si l'horodatage dans le fichier journal doit être considéré dans le fuseau horaire local ou dans le fuseau horaire en temps universel coordonné (UTC). Cette option est facultative et a pour valeur par défaut l'heure UTC. Les seules valeurs valides pour cette paire clé-valeur sont `Local` ou `UTC`. L'horodatage n'est jamais modifié si `TimeZoneKind` n'est pas spécifié ou si la valeur est UTC. L'horodatage est converti en UTC lorsque le paramètre`TimeZoneKind`Valeur est`Local`et que le récepteur recevant l'horodatage est CloudWatch Logs ou que l'enregistrement analysé est envoyé à d'autres récepteurs. Les dates et heures qui sont intégrées dans les messages ne sont pas converties.
`SkipLines`
Lorsque cet élément est spécifié, il contrôle le nombre de lignes ignorées au début de chaque fichier journal avant l'exécution de l'analyse des enregistrements. Cet élément est facultatif et sa valeur par défaut est 0.
Encodage
Par défaut, Kinesis Agent pour Windows peut détecter automatiquement l'encodage à partir du signet d'octème. Cependant, l'encodage automatique peut ne pas fonctionner correctement sur certains formats Unicode plus anciens. L'exemple suivant spécifie le codage requis pour diffuser un journal Microsoft SQL Server.
```
"Encoding": "utf-16"
```
Pour obtenir la liste des noms d'encodages, consultez[Liste des encodages](https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding?view=netframework-4.8#list-of-encodings)dans la documentation Microsoft .NET.
ExtractionRegexOptions
Vous pouvez utiliser`ExtractionRegexOptions`Pour simplifier les expressions régulières. La paire clé-valeur est facultative. La valeur par défaut est `"None"`.
L'exemple suivant spécifie que l'`"."`correspond à n'importe quel caractère, y compris`\r\n`.
```
"ExtractionRegexOptions" = "Multiline"
```
Pour obtenir la liste des champs possibles pour ExtractionRegexOptions, consultez l'[Énumération RegexOptions](https://docs.microsoft.com/en-us/dotnet/api/system.text.regularexpressions.regexoptions?view=netframework-4.7.2#fields)dans la documentation Microsoft .NET.
### Analyseur d'enregistrements `Regex`
Vous pouvez analyser les journaux de texte non structuré à l'aide de l'analyseur d'enregistrements `Regex`, ainsi qu'avec les paires clé-valeur `TimestampFormat`, `Pattern` et `ExtractionPattern`. Par exemple, supposons que votre fichier journal ressemble à ce qui suit :
```
[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'
```
Vous pouvez spécifier l'expression régulière suivante pour la paire clé-valeur `Pattern` afin de faciliter la décomposition du fichier journal en enregistrements de journaux individuels :
```
^\[\w+\]\[(?\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\]
```
Cette expression régulière correspond à la séquence suivante :
1. Début de la chaîne évaluée
1. Un ou plusieurs caractères alphabétiques entre crochets
1. Horodatage entre crochets L'horodatage correspond à la séquence suivante :
1. Année sur quatre chiffres
1. Barre oblique
1. Mois sur deux chiffres
1. Barre oblique
1. Jour sur deux chiffres
1. Caractère espace
1. Heures sur deux chiffres
1. Deux-points
1. Minutes sur deux chiffres
1. Deux-points
1. Secondes sur deux chiffres
1. Point
1. Millisecondes sur trois chiffres
Vous pouvez spécifier le format suivant pour la paire clé-valeur `TimestampFormat`afin de convertir l'horodatage textuel en date et heure :
```
yyyy/MM/dd HH:mm:ss.fff
```
Vous pouvez utiliser l'expression régulière suivante pour extraire les champs de l'enregistrement de journal via la paire clé-valeur `ExtractionPattern`.
```
^\[(?\w+)\]\[(?\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\]\[[^]]*\]\[[^]]*\]\[[^]]*\]\[(?\w+)\]\[(?\w+)\]\[[^]]*\] '(?.*)'$
```
Cette expression régulière correspond aux groupes suivants en séquence :
1. `Severity`— Un ou plusieurs caractères alphabétiques entre crochets.
1. `TimeStamp`— Consultez la description précédente pour l'horodatage.
1. Trois séquences anonymes de zéro ou plusieurs caractères entre crochets sont ignorées.
1. `SubSystem`— Un ou plusieurs caractères alphabétiques entre crochets.
1. `Module`— Un ou plusieurs caractères alphabétiques entre crochets.
1. Une séquence anonyme de zéro ou plusieurs caractères entre crochets est ignorée.
1. Un espace anonyme est ignoré.
1. `Message`— Zéro ou plusieurs caractères entre guillemets simples.
La déclaration de sources suivante combine ces expressions régulières et le format de date/heure pour fournir à Kinesis Agent for Windows les instructions complètes d'analyse de ce type de fichier journal.
```
{
"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"
}
```
**Note**
Les barres obliques inverses dans les fichiers au format JSON doivent être placés dans une séquence d'échappement avec une barre oblique inverse supplémentaire.
Pour plus d'informations sur les expressions régulières, consultez [Langage des expressions régulières - Aide-mémoire](https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference) dans la documentation Microsoft .NET.
### Analyseur d'enregistrements `Delimited`
Vous pouvez utiliser l'analyseur d'enregistrements `Delimited` pour analyser des fichiers journaux et des fichiers de données semi-structurés dans lesquels il y a une séquence de caractères constante séparant chaque colonne de données dans chaque ligne de données. Par exemple, les fichiers CSV, utilisent une virgule pour séparer chaque colonne de données et les fichiers TSV utilisent une tabulation.
Supposons que vous souhaitiez analyser un fichier journal 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)) généré par un serveur de stratégies réseau. Ce type de fichier peut se présenter comme suit :
```
"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,,,,
```
L'exemple de fichier de configuration `appsettings.json` suivant comprend une déclaration `DirectorySource` qui utilise l'analyseur d'enregistrements `Delimited` pour analyser ce texte dans une représentation d'objet. Ensuite, il diffuse des données au format JSON vers 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"
}
]
}
```
Les données au format JSON diffusées vers Kinesis Data Firehose se présentent comme suit :
```
{
"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": ""
}
```
### Analyseur d'enregistrements `SysLog`
Pour l'analyseur d'enregistrements `SysLog`, la sortie analysée à partir de la source inclut les informations suivantes :
| Attribut | Type | Description |
| --- | --- | --- |
| SysLogTimeStamp | Chaîne | Date et heure d'origine du fichier journal au format syslog. |
| Hostname | Chaîne | Nom de l'ordinateur sur lequel le fichier journal au format syslog réside. |
| Program | Chaîne | Nom de l'application ou du service qui a généré le fichier journal. |
| Message | Chaîne | Message de journal généré par l'application ou le service. |
| TimeStamp | Chaîne | Date et heure d'analyse au format ISO 8601. |
Vous trouverez ci-dessous un exemple de données SysLog transformées en 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
Voici un récapitulatif des paires clé-valeur disponibles pour la source `DirectorySource` et les éléments `RecordParser` associés à ces paires clé-valeur.
| Nom de clé | RecordParser | Remarques |
| --- | --- | --- |
| SourceType | Obligatoire pour tous | Doit avoir la valeur DirectorySource |
| Directory | Obligatoire pour tous | |
| FileNameFilter | Facultatif pour tous | |
| RecordParser | Obligatoire pour tous | |
| TimestampField | Facultatif pour SingleLineJson | |
| TimestampFormat | Obligatoire pour Timestamp et obligatoire pour SingleLineJson si TimestampField est spécifié | |
| Pattern | Obligatoire pour Regex | |
| ExtractionPattern | Facultatif pour Regex | Obligatoire pour le xml si le récepteur spécifie le format json ou Regex |
| Delimiter | Obligatoire pour Delimited | |
| HeaderPattern | Facultatif pour Delimited | |
| Headers | Facultatif pour Delimited | |
| RecordPattern | Facultatif pour Delimited | |
| CommentPattern | Facultatif pour Delimited | |
| TimeZoneKind | Facultatif pour Regex, Timestamp, SysLog et SingleLineJson quand un champ d'horodatage est identifié | |
| SkipLines | Facultatif pour tous | |
## Configuration de ExchangeLogSource
Le type `ExchangeLogSource` est utilisé pour collecter les journaux à partir de Microsoft Exchange. Exchange génère des journaux dans différents types de formats. Ce type de source peut tous les analyser. Bien qu'il soit possible de les analyser en utilisant le type `DirectorySource` avec l'analyseur d'enregistrements `Regex`, il est beaucoup plus simple d'utiliser `ExchangeLogSource`. En effet, vous n'avez pas besoin de concevoir et de fournir des expressions régulières pour les formats de fichier journal. Voici un exemple de déclaration `ExchangeLogSource` :
```
{
"Id": "MyExchangeLog",
"SourceType": "ExchangeLogSource",
"Directory": "C:\\temp\\ExchangeLogTest",
"FileNameFilter": "*.log"
}
```
Toutes les déclarations Exchange peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"ExchangeLogSource"` (obligatoire).
`Directory`
Chemin du répertoire contenant les fichiers journaux (obligatoire).
`FileNameFilter`
Limite le cas échéant l'ensemble de fichiers dans le répertoire dans lequel les données de journal sont collectées sur la base d'un modèle d'attribution de noms de fichiers contenant des caractères génériques. Si cette paire clé-valeur n'est pas spécifiée, par défaut, les données de journal de tous les fichiers du répertoire sont collectées.
`TimestampField`
Nom de la colonne contenant la date et l'heure de l'enregistrement. Cette paire clé-valeur est facultative et n'a pas besoin d'être spécifiée si le nom du champ est `date-time` ou `DateTime`. Sinon, elle est obligatoire.
## Configuration de W3SVCLogSource
Le type `W3SVCLogSource` est utilisé pour collecter les journaux provenant d'Internet Information Services (IIS) pour Windows.
Voici un exemple de déclaration `W3SVCLogSource` :
```
{
"Id": "MyW3SVCLog",
"SourceType": "W3SVCLogSource",
"Directory": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
"FileNameFilter": "*.log"
}
```
Toutes les déclarations `W3SVCLogSource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"W3SVCLogSource"` (obligatoire).
`Directory`
Chemin du répertoire contenant les fichiers journaux (obligatoire).
`FileNameFilter`
Limite le cas échéant l'ensemble de fichiers dans le répertoire dans lequel les données de journal sont collectées sur la base d'un modèle d'attribution de noms de fichiers contenant des caractères génériques. Si cette paire clé-valeur n'est pas spécifiée, par défaut, les données de journal de tous les fichiers du répertoire sont collectées.
## Configuration de UlsSource
Le type `UlsSource` est utilisé pour collecter les journaux à partir de Microsoft SharePoint. Voici un exemple de déclaration `UlsSource` :
```
{
"Id": "UlsSource",
"SourceType": "UlsSource",
"Directory": "C:\\temp\\uls",
"FileNameFilter": "*.log"
}
```
Toutes les déclarations `UlsSource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"UlsSource"` (obligatoire).
`Directory`
Chemin du répertoire contenant les fichiers journaux (obligatoire).
`FileNameFilter`
Limite le cas échéant l'ensemble de fichiers dans le répertoire dans lequel les données de journal sont collectées sur la base d'un modèle d'attribution de noms de fichiers contenant des caractères génériques. Si cette paire clé-valeur n'est pas spécifiée, par défaut, les données de journal de tous les fichiers du répertoire sont collectées.
## Configuration de WindowsEventLogSource
Le type `WindowsEventLogSource` est utilisé pour collecter des événements à partir du service de journal des événements Windows. Voici un exemple de déclaration `WindowsEventLogSource` :
```
{
"Id": "mySecurityLog",
"SourceType": "WindowsEventLogSource",
"LogName": "Security"
}
```
Toutes les déclarations `WindowsEventLogSource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"WindowsEventLogSource"` (obligatoire).
`LogName`
Les événements sont collectés à partir du journal spécifié. Les valeurs courantes incluent `Application`, `Security` et `System`, mais vous pouvez spécifier n'importe quel nom de journal d'événements Windows valide. Cette paire clé-valeur est requise.
`Query`
(Facultatif) Limite les événements en sortie à partir de `WindowsEventLogSource`. Si cette paire clé-valeur n'est pas spécifiée, par défaut, tous les événements sont générés en sortie. Pour plus d'informations sur la syntaxe de cette valeur, consultez [Event Queries et Event XML](https://msdn.microsoft.com/en-us/library/bb399427(v=vs.90).aspx) dans la documentation Windows. Pour plus d'informations sur les définitions de niveau de journalisation, consultez [Event Types](https://docs.microsoft.com/en-us/windows/desktop/eventlog/event-types) dans la documentation Windows.
`IncludeEventData`
(Facultatif) Active la collecte et la diffusion des données d'événements spécifiques au fournisseur associées à des événements provenant du journal des événements Windows spécifié lorsque la valeur de cette paire clé-valeur est `"true"`. Seules les données d'événement qui peuvent être sérialisées avec succès sont incluses. Cette paire clé-valeur est facultative et, si elle n'est pas spécifiée, les données d'événement spécifiques au fournisseur ne sont pas collectées.
L'inclusion des données d'événement peut augmenter de manière significative la quantité de données diffusées à partir de cette source. La taille maximale d'un événement peut être de 262 143 octets en incluant les données d'événement.
La sortie analysée à partir de `WindowsEventLogSource` contient les informations suivantes :
| Attribut | Type | Description |
| --- | --- | --- |
| EventId | Int | Identifiant du type d'événement. |
| Description | Chaîne | Texte qui décrit les détails de l'événement. |
| LevelDisplayName | Chaîne | Catégorie d'événement (Erreur, Avertissement, Information, Audit réussi, Échec de l'audit). |
| LogName | Chaîne | Lieu d'enregistrement de l'événement (les valeurs courantes sont Application, Security et System, mais il existe de nombreuses possibilités). |
| MachineName | Chaîne | Ordinateur ayant enregistré l'événement. |
| ProviderName | Chaîne | Application ou service ayant enregistré l'événement. |
| TimeCreated | Chaîne | Moment où l'événement s'est produit au format ISO 8601. |
| Index | Int | Emplacement de l'entrée dans le journal. |
| UserName | Chaîne | Auteur de l'entrée s'il est connu. |
| Keywords | Chaîne | Type d'événement. Les valeurs standard incluent AuditFailure (événements d'audit de sécurité ayant échoué), AuditSuccess (événements d'audit de sécurité ayant réussi), Classic (événements déclenchés via la fonction RaiseEvent), Correlation Hint (événements de transfert), SQM (événements de mécanisme de qualité de service), WDI Context (événements de contexte de l'infrastructure de diagnostics Windows) et WDI Diag (événements de diagnostic de l'infrastructure de diagnostics Windows). |
| EventData | Liste d'objets | Données supplémentaires spécifiques au fournisseur et facultatives concernant l'événement de journal. Cet élément est uniquement inclus si la valeur de la paire clé-valeur IncludeEventData est "true". |
Voici un exemple d'événement transformé au format 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=="
]}
```
## Configuration de WindowsEventLogPollingSource
`WindowsEventLogPollingSource`utilise un mécanisme basé sur l'interrogation pour rassembler tous les nouveaux événements du journal des événements qui correspondent aux paramètres configurés. L'intervalle d'interrogation est mis à jour dynamiquement entre 100 ms et 5000 ms en fonction du nombre d'événements recueillis lors du dernier sondage. Voici un exemple de déclaration `WindowsEventLogPollingSource` :
```
{
"Id": "MySecurityLog",
"SourceType": "WindowsEventLogPollingSource",
"LogName": "Security",
"IncludeEventData": "true",
"Query": "",
"CustomFilters": "ExcludeOwnSecurityEvents"
}
```
Toutes les déclarations `WindowsEventLogPollingSource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"WindowsEventLogPollingSource"` (obligatoire).
`LogName`
Spécifie le journal. Les options valides sont`Application`,`Security`,`System`, ou d'autres journaux valides.
`IncludeEventData`
Facultatif. Quand`true`, spécifie que EventData supplémentaires lorsqu'il est diffusé en format JSON et XML est inclus. La valeur par défaut est `false`.
`Query`
Facultatif. Les journaux d'événements Windows prennent en charge l'interrogation d'événements à l'aide d'expressions XPath, que vous pouvez spécifier en utilisant`Query`. Pour de plus amples informations, veuillez consulter[Requêtes d'événement et XML d'événement](https://docs.microsoft.com/en-us/previous-versions/bb399427(v=vs.90))dans la documentation Microsoft.
`CustomFilters`
Facultatif. Liste des filtres séparés par un point-virgule (`;`). Les filtres suivants peuvent être spécifiés.
`ExcludeOwnSecurityEvents`
Exclut les événements de sécurité générés par Kinesis Agent pour Windows lui-même.
## Configuration de WindowsETWEventSource
Le type `WindowsETWEventSource` est utilisé pour collecter des suivis d'événements d'application et de service à l'aide d'une fonctionnalité nommée Event Tracing for Windows (ETW). Pour plus d'informations, consultez [Event tracing](https://docs.microsoft.com/en-us/windows/desktop/etw/event-tracing-portal) dans la documentation Windows.
Voici un exemple de déclaration `WindowsETWEventSource` :
```
{
"Id": "ClrETWEventSource",
"SourceType": "WindowsETWEventSource",
"ProviderName": "Microsoft-Windows-DotNETRuntime",
"TraceLevel": "Verbose",
"MatchAnyKeyword": 32768
}
```
Toutes les déclarations `WindowsETWEventSource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"WindowsETWEventSource"` (obligatoire).
`ProviderName`
Spécifie le fournisseur d'événements à utiliser pour collecter les événements de suivi. Il doit s'agir d'un nom de fournisseur ETW valide pour un fournisseur installé. Pour déterminer quels sont les fournisseurs installés, exécutez la commande suivante dans une fenêtre d'invite de commande Windows :
```
logman query providers
```
`TraceLevel`
Spécifie les catégories d'événements de suivi qui doivent être collectées. Les valeurs autorisées incluent `Critical`, `Error`, `Warning`, `Informational` et `Verbose`. La signification exacte dépend du fournisseur ETW qui est sélectionné.
`MatchAnyKeyword`
Cette valeur est un nombre de 64 bits, dans lequel chaque bits représente un mot-clé. Chaque mot-clé décrit une catégorie d'événements à collecter. Pour connaître les mots-clés pris en charge et leurs valeurs, ainsi que leur lien avec `TraceLevel`, consultez la documentation de ce fournisseur. Par exemple, pour obtenir des informations sur le fournisseur ETW CLR, consultez [Niveaux et mots clés ETW du CLR](https://docs.microsoft.com/en-us/dotnet/framework/performance/clr-etw-keywords-and-levels) dans la documentation Microsoft .NET Framework.
Dans l'exemple précédent, 32768 (0x00008000) représente l'élément `ExceptionKeyword` du fournisseur ETW CLR qui demande au fournisseur de collecter des informations sur les exceptions déclenchées. Bien que le format JSON ne prenne pas en charge en mode natif les constantes hexadécimales, vous pouvez les spécifier pour `MatchAnyKeyword` en les plaçant dans une chaîne. Vous pouvez également spécifier plusieurs constantes séparées par des virgules. Par exemple, utilisez la commande suivante pour spécifier à la fois `ExceptionKeyword` et `SecurityKeyword` (0x00000400) :
```
{
"Id": "MyClrETWEventSource",
"SourceType": "WindowsETWEventSource",
"ProviderName": "Microsoft-Windows-DotNETRuntime",
"TraceLevel": "Verbose",
"MatchAnyKeyword": "0x00008000, 0x00000400"
}
```
Pour assurer que tous les mots-clés spécifiés sont activés pour un fournisseur, plusieurs valeurs de mots-clés sont combinées en utilisant OR et transmises à ce fournisseur.
La sortie de l'élément `WindowsETWEventSource` contient les informations suivantes pour chaque événement :
| Attribut | Type | Description |
| --- | --- | --- |
| EventName | Chaîne | Type d'événement qui s'est produit. |
| ProviderName | Chaîne | Fournisseur ayant détecté l'événement. |
| FormattedMessage | Chaîne | Résumé textuel de l'événement. |
| ProcessID | Int | Processus ayant signalé l'événement. |
| ExecutingThreadID | Int | Thread du processus ayant signalé l'événement. |
| MachineName | Chaîne | Nom de l'ordinateur de bureau ou du serveur qui signale l'événement. |
| Payload | Table de hachage | Table avec une clé de type chaîne et n'importe quel type d'objet comme valeur. La clé est le nom de l'élément de charge utile et la valeur est la valeur de l'élément de charge utile. La charge utile dépend du fournisseur. |
Voici un exemple d'événement transformé au format 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
}
}
```
## Configuration de WindowsPerformanceCounterSource
Le type `WindowsPerformanceCounterSource` collecte les métriques de compteur de performances à partir de Windows. Voici un exemple de déclaration `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"]
}
]
}
```
Toutes les déclarations `WindowsPerformanceCounterSource` peuvent fournir les paires clé-valeur suivantes :
`SourceType`
Doit avoir pour valeur la chaîne littérale `"WindowsPerformanceCounterSource"` (obligatoire).
`Categories`
Spécifie un ensemble de groupes de métriques de compteur de performances à collecter à partir de Windows. Chaque groupe de métriques contient les paires clé-valeur suivantes :
`Category`
Spécifie l'ensemble de métriques de compteur à collecter (obligatoire).
`Instances`
Spécifie l'ensemble d'objets d'intérêt lorsqu'il y a un ensemble unique de compteurs de performances par objet. Par exemple, lorsque la catégorie est `LogicalDisk`, il y a un ensemble de compteurs de performances par unité de disque. La paire clé-valeur est facultative. Vous pouvez utiliser les caractères génériques `*` et `?` pour représenter plusieurs instances. Pour regrouper les valeurs de toutes les instances, spécifiez `_Total`.
Vous pouvez également utiliser`InstanceRegex`, qui accepte les expressions régulières qui contiennent le`*`caractère générique faisant partie du nom de l'instance.
`Counters`
Spécifie les métriques à collecter pour la catégorie spécifiée. Cette paire clé-valeur est requise. Vous pouvez utiliser les caractères génériques `*` et `?` pour représenter plusieurs compteurs. Vous pouvez spécifier `Counters` en utilisant uniquement le nom ou en utilisant le nom et l'unité. Si les unités de compteur ne sont pas spécifiées, Kinesis Agent pour Windows tente de déduire les unités à partir du nom. Si ces conclusions sont incorrectes, l'unité peut être explicitement spécifiée. Vous pouvez modifier les noms `Counter` si vous le souhaitez. La représentation la plus complexe d'un compteur est un objet avec les paires clé-valeur suivantes :
`Counter`
Nom du compteur. Cette paire clé-valeur est requise.
`Rename`
Nom du compteur à présenter au récepteur. La paire clé-valeur est facultative.
`Unit`
Signification de la valeur qui est associée au compteur. Pour obtenir la liste complète des noms d'unité valides, consultez la documentation sur les unités dans[MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html)dans le*Référence d'API Amazon CloudWatch*.
Voici un exemple de spécification de compteur complexe :
```
{
"Counter": "Disk Reads/sec,
"Rename": "Disk Reads per second",
"Unit": "Count/Second"
}
```
`WindowsPerformanceCounterSource`peut uniquement être utilisé avec un récepteur qui spécifie un récepteur Amazon CloudWatch. Utilisez un récepteur distinct si les métriques prédéfinies Kinesis Agent for Windows sont également diffusées vers CloudWatch. Examinez le journal Kinesis Agent pour Windows après le démarrage du service pour déterminer quelles sont les unités qui ont été déduites pour les compteurs lorsque les unités n'ont pas été spécifiées dans le champ`WindowsPerformanceCounterSource`Déclarations. Utilisez PowerShell pour déterminer les noms valides pour les catégories, instances et compteurs.
Pour afficher des informations sur toutes les catégories, y compris les compteurs associés aux ensembles de compteurs, exécutez cette commande dans une fenêtre PowerShell :
```
Get-Counter -ListSet * | Sort-Object
```
Pour déterminer quelles sont les instances disponibles pour chacun des compteurs de l'ensemble de compteurs, exécutez une commande similaire à ce qui suit dans une fenêtre PowerShell :
```
Get-Counter -Counter "\Process(*)\% Processor Time"
```
La valeur du paramètre `Counter` doit être l'un des chemins d'accès d'un membre `PathsWithInstances` répertoriés au cours du précédent appel de la commande `Get-Counter -ListSet`.
## Source des métriques prédéfinies de Kinesis Agent pour Windows
En plus des sources de métriques ordinaires telles que le`WindowsPerformanceCounterSource`type (voir[Configuration de WindowsPerformanceCounterSource](#performance-counter-source-configuration)), le type de récepteur CloudWatch peut recevoir des métriques à partir d'une source spéciale qui collecte des métriques sur Kinesis Agent pour Windows lui-même. Les métriques Kinesis Agent pour Windows sont également disponibles dans le manuel`KinesisTap`catégorie des compteurs de performances Windows.
La .`MetricsFilter`clé-valeur des déclarations de récepteurs CloudWatch spécifie les métriques qui sont diffusées vers CloudWatch à partir de la source de métriques Kinesis Agent pour Windows intégrée. La valeur est une chaîne qui contient une ou plusieurs expressions de filtre séparées par des points-virgules. Par exemple :
`"MetricsFilter": "`*ExpressionFiltre1*`;`*ExpressionFiltre2*`"`
Une métrique qui correspond à une ou plusieurs expressions de filtre est diffusée vers CloudWatch.
Les métriques d'instance unique sont de nature globale et ne sont pas liées à une source particulière ou à un récepteur particulier. Les métriques d'instances multiples sont des dimensions basées sur la déclaration source ou de récepteurs `Id`. Chaque type de source ou de récepteur peut avoir un ensemble de métriques différent.
Pour obtenir la liste des noms de métriques prédéfinies Kinesis Agent pour Windows, consultez[Liste des mesures Kinesis Agent pour Windows](#kinesis-agent-metric-list).
Pour les métriques d'instance unique, l'expression de filtre est le nom de la métrique, par exemple :
```
"MetricsFilter": "SourcesFailedToStart;SinksFailedToStart"
```
Pour les métriques d'instances multiples, l'expression de filtre se présente sous la forme du nom de la métrique, d'un point (`.`), puis de l'élément `Id` de la déclaration source ou de récepteurs qui a généré cette métrique. Supposons par exemple qu'il y a une déclaration de récepteurs avec un élément `Id` ayant pour valeur `MyFirehose` :
```
"MetricsFilter": "KinesisFirehoseRecordsFailedNonrecoverable.MyFirehose"
```
Vous pouvez utiliser des modèles de caractères génériques spéciaux conçus pour faire une distinction entre les métriques d'instance unique et les métriques d'instances multiples.
+ L'astérisque (`*`) correspond à zéro ou plusieurs caractères, à l'exception des points (`.`).
+ Le point d'interrogation (`?`) correspond à un caractère, à l'exception des points.
+ Tous les autres caractères correspondent uniquement à eux-mêmes.
+ `_Total` est un jeton spécial qui provoque l'agrégation de toutes les valeurs d'instances multiples correspondantes au sein de la dimension.
L'exemple suivant représente toutes les métriques d'instance unique :
```
"MetricsFilter": "*"
```
Étant donné qu'un astérisque ne correspond pas à un point, seules les métriques d'instance unique sont incluses.
L'exemple suivant représente toutes les métriques d'instances multiples :
```
"MetricsFilter": "*.*"
```
L'exemple suivant représente toutes les métriques (instance unique ou instances multiples) :
```
"MetricsFilter": "*;*.*"
```
L'exemple suivant regroupe toutes les métriques d'instances multiples pour l'ensemble des sources et des récepteurs :
```
"MetricsFilter": "*._Total"
```
L'exemple suivant regroupe toutes les métriques Kinesis Data Firehose pour tous les récepteurs Kinesis Data Firehose :
```
"MetricsFilter": "*Firehose*._Total"
```
L'exemple suivant représente toutes les métriques d'erreur d'instance unique et d'instances multiples :
```
"MetricsFilter": "*Failed*;*Error*.*;*Failed*.*"
```
L'exemple suivant représente toutes les métriques d'erreur irrécupérable agrégées pour toutes les sources et tous les récepteurs :
```
"MetricsFilter": "*Nonrecoverable*._Total"
```
Pour plus d'informations sur la façon de spécifier un canal utilisant la source de métriques prédéfinies Kinesis Agent pour Windows, consultez[Configuration de Kinesis Agent pour les canaux métriques Windows](pipe-object-declarations.md#kinesis-agent-metric-pipe-configuration).
## Liste des mesures Kinesis Agent pour Windows
Voici une liste des métriques d'instance unique et d'instances multiples qui sont disponibles pour Kinesis Agent pour Windows.
### Métriques d'instance unique
Les métriques d'instance unique disponibles sont les suivantes :
`KinesisTapBuildNumber`
Numéro de version de Kinesis Agent pour Windows.
`PipesConnected`
Nombre de pipelines ayant connecté leur source à leur récepteur avec succès.
`PipesFailedToConnect`
Nombre de pipelines n'ayant pas réussi à connecter leur source à leur récepteur.
`SinkFactoriesFailedToLoad`
Nombre de types de récepteurs n'ayant pas pu être chargés dans l'Agent Kinesis pour Windows.
`SinkFactoriesLoaded`
Nombre de types de récepteurs ayant été chargés dans Kinesis Agent pour Windows avec succès.
`SinksFailedToStart`
Nombre de récepteurs dont le démarrage a échoué, généralement en raison de déclarations de récepteurs incorrectes.
`SinksStarted`
Nombre de récepteurs ayant démarré avec succès.
`SourcesFailedToStart`
Nombre de sources dont le démarrage a échoué, généralement en raison de déclarations de sources incorrectes.
`SourcesStarted`
Nombre de sources ayant démarré avec succès.
`SourceFactoriesFailedToLoad`
Nombre de types de sources n'ayant pas pu être chargés dans Kinesis Agent for Windows.
`SourceFactoriesLoaded`
Nombre de types de sources ayant été chargés dans Kinesis Agent pour Windows.
### Métriques d'instances multiples
Les métriques d'instances multiples disponibles sont les suivantes :
#### Métriques DirectorySource
`DirectorySourceBytesRead`
Nombre d'octets ayant été lus au cours de l'intervalle pour cet élément `DirectorySource`.
`DirectorySourceBytesToRead`
Nombre d'octets connus disponibles en lecture n'ayant pas encore été lus par l'Agent Kinesis pour Windows.
`DirectorySourceFilesToProcess`
Nombre de fichiers connus à examiner qui n'ont pas encore été examinés par Kinesis Agent for Windows.
`DirectorySourceRecordsRead`
Nombre d'enregistrements ayant été lus au cours de l'intervalle pour cet élément `DirectorySource`.
#### Métriques WindowsEventLogSource
`EventLogSourceEventsError`
Nombre d'événements du journal d'événements Windows n'ayant pas été lus avec succès.
`EventLogSourceEventsRead`
Nombre d'événements du journal d'événements Windows ayant été lus avec succès.
#### Métriques de récepteur KinesisFirehose
`KinesisFirehoseBytesAccepted`
Nombre d'octets ayant été acceptés au cours de l'intervalle.
`KinesisFirehoseClientLatency`
Temps écoulé entre la génération des enregistrements et leur diffusion vers le service Kinesis Data Firehose.
`KinesisFirehoseLatency`
Temps écoulé entre le début et la fin de la diffusion des enregistrements pour le service Kinesis Data Firehose.
`KinesisFirehoseNonrecoverableServiceErrors`
Nombre de fois où des enregistrements n'ont pas pu être envoyés sans erreur au service Kinesis Data Firehose malgré les nouvelles tentatives.
`KinesisFirehoseRecordsAttempted`
Nombre d'enregistrements ayant tenté d'être diffusés vers le service Kinesis Data Firehose.
`KinesisFirehoseRecordsFailedNonrecoverable`
Nombre d'enregistrements n'ayant pas pu être diffusés vers le service Kinesis Data Firehose malgré les nouvelles tentatives.
`KinesisFirehoseRecordsFailedRecoverable`
Nombre d'enregistrements ayant pu être diffusés vers le service Kinesis Data Firehose, mais uniquement à la suite de nouvelles tentatives.
`KinesisFirehoseRecordsSuccess`
Nombre d'enregistrements ayant pu être diffusés vers le service Kinesis Data Firehose sans nouvelles tentatives.
`KinesisFirehoseRecoverableServiceErrors`
Nombre de fois où des enregistrements ont pu être envoyés au service Kinesis Data Firehose, mais uniquement à la suite de nouvelles tentatives.
#### Métriques KinesisStream
`KinesisStreamBytesAccepted`
Nombre d'octets ayant été acceptés au cours de l'intervalle.
`KinesisStreamClientLatency`
Temps écoulé entre la génération des enregistrements et leur diffusion vers le service Kinesis Data Streams.
`KinesisStreamLatency`
Temps écoulé entre le début et la fin de la diffusion des enregistrements pour le service Kinesis Data Streams.
`KinesisStreamNonrecoverableServiceErrors`
Nombre de fois où des enregistrements n'ont pas pu être envoyés sans erreur au service Kinesis Data Streams malgré les nouvelles tentatives.
`KinesisStreamRecordsAttempted`
Nombre d'enregistrements ayant tenté d'être diffusés vers le service de Kinesis Data Streams.
`KinesisStreamRecordsFailedNonrecoverable`
Nombre d'enregistrements n'ayant pas pu être diffusés vers le service Kinesis Data Streams malgré les nouvelles tentatives.
`KinesisStreamRecordsFailedRecoverable`
Nombre d'enregistrements ayant pu être diffusés vers le service Kinesis Data Streams, mais uniquement à la suite de nouvelles tentatives.
`KinesisStreamRecordsSuccess`
Nombre d'enregistrements ayant pu être diffusés vers le service de Kinesis Data Streams sans nouvelles tentatives.
`KinesisStreamRecoverableServiceErrors`
Nombre de fois où des enregistrements ont pu être envoyés au service Kinesis Data Streams, mais uniquement à la suite de nouvelles tentatives.
#### Métriques CloudWatchLog
`CloudWatchLogBytesAccepted`
Nombre d'octets ayant été acceptés au cours de l'intervalle.
`CloudWatchLogClientLatency`
Temps écoulé entre la génération des enregistrements et leur diffusion vers le service CloudWatch Logs.
`CloudWatchLogLatency`
Temps écoulé entre le début et la fin de la diffusion des enregistrements pour le service CloudWatch Logs.
`CloudWatchLogNonrecoverableServiceErrors`
Nombre de fois où des enregistrements n'ont pas pu être envoyés sans erreur au service CloudWatch Logs malgré les nouvelles tentatives.
`CloudWatchLogRecordsAttempted`
Nombre d'enregistrements ayant tenté d'être diffusés vers le service CloudWatch Logs.
`CloudWatchLogRecordsFailedNonrecoverable`
Nombre d'enregistrements n'ayant pas pu être diffusés vers le service CloudWatch Logs malgré les nouvelles tentatives.
`CloudWatchLogRecordsFailedRecoverable`
Nombre d'enregistrements ayant pu être diffusés vers le service CloudWatch Logs, mais uniquement à la suite de nouvelles tentatives.
`CloudWatchLogRecordsSuccess`
Nombre d'enregistrements ayant pu être diffusés vers le service CloudWatch Logs sans nouvelles tentatives.
`CloudWatchLogRecoverableServiceErrors`
Nombre de fois où des enregistrements ont pu être envoyés au service CloudWatch Logs, mais uniquement à la suite de nouvelles tentatives.
#### Métriques CloudWatch
`CloudWatchLatency`
Temps écoulé en moyenne entre le début et la fin de la diffusion des métriques pour le service CloudWatch.
`CloudWatchNonrecoverableServiceErrors`
Nombre de fois où des métriques n'ont pas pu être envoyées sans erreur au service CloudWatch malgré les nouvelles tentatives.
`CloudWatchRecoverableServiceErrors`
Nombre de fois où des métriques ont été envoyées sans erreur au service CloudWatch, mais uniquement à la suite de nouvelles tentatives.
`CloudWatchServiceSuccess`
Nombre de fois où des métriques ont été envoyées sans erreur au service CloudWatch sans aucune nouvelle tentative.
## Configuration des signets
Par défaut, l'agent Kinesis pour Windows envoie les enregistrements de journaux aux récepteurs créés après le démarrage de l'agent. Parfois, il est utile d'envoyer des enregistrements de journaux plus tôt, par exemple, les enregistrements de journaux créés pendant l'arrêt de Kinesis Agent pour Windows au cours d'une mise à jour automatique. La fonction de signet suit les enregistrements qui ont été envoyés aux récepteurs. Lorsque Kinesis Agent pour Windows est en mode signet et démarre, il envoie tous les enregistrements de journal créés après l'arrêt de Kinesis Agent pour Windows, ainsi que tous les enregistrements de journal créés ultérieurement. Pour contrôler ce comportement, les déclarations de sources basées sur un fichier peuvent éventuellement inclure les paires clé-valeur suivantes :
`InitialPosition`
Spécifie la position initiale du signet. Les valeurs possibles sont les suivantes :
`EOS`
Spécifie la fin du flux (EOS). Seuls les enregistrements de journaux créés pendant l'exécution de l'agent sont envoyés aux récepteurs.
`0`
Tous les enregistrements de journaux et les événements disponibles sont initialement envoyés. Ensuite, un signet est créé pour faire en sorte que chaque nouvel enregistrement de journal et événement créé après le signet soit finalement envoyé, que Kinesis Agent pour Windows soit en cours d'exécution ou non.
`Bookmark`
Le signet est initialisé juste après le dernier enregistrement de journal ou événement. Ensuite, un signet est créé pour faire en sorte que chaque nouvel enregistrement de journal et événement créé après le signet soit finalement envoyé, que Kinesis Agent pour Windows soit en cours d'exécution ou non.
Les signets sont activés par défaut. Les fichiers sont stockés dans l'`%ProgramData%\Amazon\KinesisTap`Répertoire.
`Timestamp`
Les enregistrements de journaux et événements qui sont créés après la valeur `InitialPositionTimestamp` (définition ci-après) sont envoyés. Ensuite, un signet est créé pour faire en sorte que chaque nouvel enregistrement de journal et événement créé après le signet soit finalement envoyé, que Kinesis Agent pour Windows soit en cours d'exécution ou non.
`InitialPositionTimestamp`
Spécifie le premier horodatage d'enregistrement de journal ou d'événement que vous voulez. Spécifiez cette paire clé-valeur uniquement si `InitialPosition` a la valeur `Timestamp`.
`BookmarkOnBufferFlush`
Ce paramètre peut être ajouté à n'importe quelle source marquable. Lorsqu'il est défini sur`true`, garantit que les mises à jour de signet se produisent uniquement lorsqu'un puits envoie un événement à AWS. Vous ne pouvez abonner qu'un seul puits à une source. Si vous expédiez des journaux vers plusieurs destinations, dupliquez vos sources pour éviter d'éventuels problèmes de perte de données.
Lorsque Kinesis Agent pour Windows a été arrêté pendant longtemps, il peut être nécessaire de supprimer ces signets, car les enregistrements de journaux et les événements qui sont signés peuvent ne plus exister. Les fichiers de signets pour un *ID de source* donné sont situés dans `%PROGRAMDATA%\Amazon\AWSKinesisTap\source id.bm`.
Les signets ne fonctionnent pas sur les fichiers qui sont renommés ou tronqués. En raison de la nature des événements et des compteurs de performances ETW, ils ne peuvent pas faire l'objet d'un signet.
# Déclarations de récepteurs
Les *déclarations de récepteurs* spécifient la forme sous laquelle les journaux, les événements et les métriques doivent être envoyés aux divers services AWS ainsi que leur emplacement de destination. Les sections suivantes décrivent les configurations des types de récepteur intégrés qui sont disponibles dans Amazon Kinesis Agent pour Microsoft Windows. Étant donné que Kinesis Agent pour Windows est extensible, vous pouvez ajouter des types de récepteurs personnalisés. Chaque type de récepteur nécessite généralement des paires clé-valeur uniques dans les déclarations de configuration qui sont pertinentes pour ce type de récepteur.
Toutes les déclarations de récepteurs peuvent contenir les paires clé-valeur suivantes :
`Id`
Chaîne unique qui identifie un récepteur spécifique au sein du fichier de configuration (obligatoire).
`SinkType`
Nom du type de ce récepteur (obligatoire). Le type de récepteur spécifie la destination des données de journal, d'événement ou de métrique qui sont diffusées par ce récepteur.
`AccessKey`
Spécifie la clé d'accès AWS à utiliser pour autoriser l'accès au service AWS associé au type de récepteur. La paire clé-valeur est facultative. Pour plus d'informations, consultez [Configuration de la sécurité des récepteurs](#configuring-kinesis-agent-windows-sink-security-configuration).
`SecretKey`
Spécifie la clé secrète AWS à utiliser pour autoriser l'accès au service AWS associé au type de récepteur. La paire clé-valeur est facultative. Pour plus d'informations, consultez [Configuration de la sécurité des récepteurs](#configuring-kinesis-agent-windows-sink-security-configuration).
`Region`
Spécifie la région AWS qui contient les ressources de destination pour le streaming. La paire clé-valeur est facultative.
`ProfileName`
Spécifie le profil AWS à utiliser pour l'authentification. Cette paire clé-valeur est facultative, mais si elle est spécifiée, elle remplace toute clé d'accès ou clé secrète spécifiée. Pour plus d'informations, consultez [Configuration de la sécurité des récepteurs](#configuring-kinesis-agent-windows-sink-security-configuration).
`RoleARN`
Spécifie le rôle IAM à utiliser pour accéder au service AWS associé au type de récepteur. Cette option est utile lorsque Kinesis Agent pour Windows s'exécute sur une instance EC2, mais qu'un rôle différent serait plus approprié que le rôle référencé par le profil d'instance. Par exemple, il est possible d'utiliser un rôle entre comptes pour cibler les ressources qui ne sont pas dans le même compte AWS que l'instance EC2. La paire clé-valeur est facultative.
`Format`
Spécifie le type de sérialisation qui est appliqué aux données de journaux et d'événements avant leur diffusion. Les valeurs valides sont `json` et `xml`. Cette option est utile lorsque les analyses en aval dans le pipeline de données nécessitent des données sous un format particulier ou réagissent mieux à un type de format particulier. Cette paire clé-valeur est facultative et, si elle n'est pas spécifiée, le texte ordinaire provenant de la source est diffusé du récepteur vers le service AWS associé à ce type de récepteur.
`TextDecoration`
Lorsqu'aucun élément `Format` n'est spécifié, `TextDecoration` spécifie le texte supplémentaire à inclure lors de la diffusion des enregistrements de journaux ou d'événements. Pour plus d'informations, consultez [Configuration des décorations de récepteurs](#configuring-kinesis-agent-windows-decoration-configuration). La paire clé-valeur est facultative.
`ObjectDecoration`
Lorsque l'élément `Format` est spécifié, `ObjectDecoration` spécifie les données supplémentaires à inclure dans l'enregistrement de journal ou d'événement avant la sérialisation ou la diffusion. Pour plus d'informations, consultez [Configuration des décorations de récepteurs](#configuring-kinesis-agent-windows-decoration-configuration). La paire clé-valeur est facultative.
`BufferInterval`
Afin de réduire les appels d'API au service AWS associé au type de récepteur, Kinesis Agent pour Windows place en mémoire tampon plusieurs enregistrements de journaux, d'événements ou de métriques avant la diffusion. Cela permet d'économiser de l'argent pour les services qui sont facturés en fonction du nombre d'appels d'API. `BufferInterval` spécifie la durée maximale (en secondes) du placement des enregistrements en mémoire tampon avant leur diffusion vers le service AWS. Cette paire clé-valeur est facultative et, si elle est spécifiée, vous devez utiliser une chaîne pour représenter la valeur.
`BufferSize`
Afin de réduire les appels d'API au service AWS associé au type de récepteur, Kinesis Agent pour Windows place en mémoire tampon plusieurs enregistrements de journaux, d'événements ou de métriques avant la diffusion. Cela permet d'économiser de l'argent pour les services qui sont facturés en fonction du nombre d'appels d'API. `BufferSize` spécifie le nombre maximal d'enregistrements à placer en mémoire tampon avant leur diffusion vers le service AWS. Cette paire clé-valeur est facultative et, si elle est spécifiée, vous devez utiliser une chaîne pour représenter la valeur.
`MaxAttempts`
Spécifie le nombre maximum de tentatives de Kinesis Agent pour Windows pour tente de diffuser un ensemble de journaux, d'événements et de métriques vers un service AWS par si le streaming échoue systématiquement. La paire clé-valeur est facultative. Si cet élément est spécifié, utilisez une chaîne pour représenter la valeur. La valeur par défaut est « `3` ».
Pour obtenir des exemples de fichiers de configuration complets utilisant différents types de récepteurs, consultez [Diffusion à partir du journal des événements d'application Windows vers les récepteurs](configuring-kaw-examples.md#configuring-kaw-examples-sinks).
**Topics**
+ [Configuration du récepteur `KinesisStream`](#sink-object-declarations-kinesis-stream)
+ [Configuration du récepteur `KinesisFirehose`](#sink-object-declarations-kinesis-firehose)
+ [Configuration du récepteur CloudWatch Sink](#sink-object-declarations-cloud-watch)
+ [Configuration du récepteur `CloudWatchLogs`](#sink-object-declarations-cloud-watch-logs)
+ [Locale`FileSystem`Configuration du récepteur](#sink-object-declarations-local-filesystem)
+ [Configuration de la sécurité des récepteurs](#configuring-kinesis-agent-windows-sink-security-configuration)
+ [Configuration`ProfileRefreshingAWSCredentialProvider`Pour actualiser les informations d'identification AWS](#configuring-credential-refresh)
+ [Configuration des décorations de récepteurs](#configuring-kinesis-agent-windows-decoration-configuration)
+ [Configuration des substitutions de variables de récepteur](#configuring-kinesis-agent-windows-sink-variable-substitution)
+ [Configuration de la mise en file d'attente des récepteurs](#configuring-kinesis-agent-windows-queuing)
+ [Configuration d'un proxy pour les récepteurs](#configuring-kinesis-agent-windows-sink-proxy)
+ [Configuration de la résolution de variables dans d'autres attributs de collecteur](#configuring-resolving-variables)
+ [Configuration des points de terminaison régionaux AWS STS lors de l'utilisation de la propriété RoleARN dans les puits AWS](#configuring-sts-endpoints)
+ [Configuration du point de terminaison VPC pour les puits AWS](#configuring-vpc-endpoint)
+ [Configuration d'un autre moyen de proxy](#configuring-alternate-proxy)
## Configuration du récepteur `KinesisStream`
La .`KinesisStream`Le type de récepteur diffuse des enregistrements de journaux et des événements vers le service Kinesis Data Streams. En général, les données diffusées vers Kinesis Data Streams sont traitées par une ou plusieurs applications personnalisées qui s'exécutent via différents services AWS. Les données sont diffusées vers un flux nommé qui est configuré à l'aide Kinesis Data Streams. Pour plus d'informations, consultez le .*[Guide du développeur Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/)*.
Voici un exemple de déclaration de récepteurs Kinesis Data Streams :
```
{
"Id": "TestKinesisStreamSink",
"SinkType": "KinesisStream",
"StreamName": "MyTestStream",
"Region": "us-west-2"
}
```
Toutes les déclarations de récepteurs `KinesisStream` peuvent fournir les paires clé-valeur supplémentaires suivantes :
`SinkType`
Doit être spécifié. La valeur doit être la chaîne littérale `KinesisStream`.
`StreamName`
Spécifie le nom du flux de données Kinesis qui reçoit les données diffusées à partir de l'`KinesisStream`type d'évier (requis). Avant de diffuser les données, configurez le flux dans AWS Management Console, l'AWS CLI ou via une application à l'aide de l'API Kinesis Data Streams.
`RecordsPerSecond`
Spécifie le nombre maximum d'enregistrements diffusés vers les Kinesis Data Streams par seconde. La paire clé-valeur est facultative. Si cet élément est spécifié, utilisez un entier pour représenter la valeur. La valeur par défaut est de 1 000 enregistrements.
`BytesPerSecond`
Spécifie le nombre maximum d'octets diffusés vers les Kinesis Data Streams par seconde. La paire clé-valeur est facultative. Si cet élément est spécifié, utilisez un entier pour représenter la valeur. La valeur par défaut est de 1 Mo.
La valeur par défaut de `BufferInterval` pour ce type de récepteur est d'une seconde et la valeur par défaut de `BufferSize` est de 500 enregistrements.
## Configuration du récepteur `KinesisFirehose`
La .`KinesisFirehose`Le type de récepteur diffuse des enregistrements de journaux et des événements vers le service Kinesis Data Firehose. Kinesis Data Firehose transmet les données diffusées à d'autres services en vue de leur stockage. En général, les données stockées sont ensuite analysées au cours des étapes ultérieures du pipeline de données. Les données sont diffusées vers un flux de diffusion nommé qui est configuré à l'aide de Kinesis Data Firehose. Pour plus d'informations, consultez le .*[Guide du développeur Amazon Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/)*.
Voici un exemple de déclaration de récepteurs Kinesis Data Firehose :
```
{
"Id": "TestKinesisFirehoseSink",
"SinkType": "KinesisFirehose",
"StreamName": "MyTestFirehoseDeliveryStream",
"Region": "us-east-1",
"CombineRecords": "true"
}
```
Toutes les déclarations de récepteurs `KinesisFirehose` peuvent fournir les paires clé-valeur supplémentaires suivantes :
`SinkType`
Doit être spécifié. La valeur doit être la chaîne littérale `KinesisFirehose`.
`StreamName`
Spécifie le nom du flux de diffusion Kinesis Data Firehose qui reçoit les données diffusées à partir de l'`KinesisStream`type d'évier (requis). Avant de diffuser les données, configurez le flux de diffusion via AWS Management Console, l'interface de ligne de commande AWS ou via une application à l'aide de l'API Kinesis Data Firehose.
`CombineRecords`
Lorsqu'il est défini sur`true`, spécifie de combiner plusieurs petits enregistrements dans un enregistrement volumineux avec une taille maximale de 5 Ko. La paire clé-valeur est facultative. Les enregistrements combinés à l'aide de cette fonction sont séparés par`\n`. Si vous utilisez AWS Lambda pour transformer un enregistrement Kinesis Data Firehose, votre fonction Lambda doit tenir compte du caractère séparateur.
`RecordsPerSecond`
Spécifie le nombre maximum d'enregistrements diffusés vers les Kinesis Data Streams par seconde. La paire clé-valeur est facultative. Si cet élément est spécifié, utilisez un entier pour représenter la valeur. La valeur par défaut est de 5 000 enregistrements.
`BytesPerSecond`
Spécifie le nombre maximum d'octets diffusés vers les Kinesis Data Streams par seconde. La paire clé-valeur est facultative. Si cet élément est spécifié, utilisez un entier pour représenter la valeur. La valeur par défaut est de 5 Mo.
La valeur par défaut de `BufferInterval` pour ce type de récepteur est d'une seconde et la valeur par défaut de `BufferSize` est de 500 enregistrements.
## Configuration du récepteur CloudWatch Sink
La .`CloudWatch`Type de récepteur diffuse les métriques vers le service CloudWatch. Vous pouvez afficher les métriques dans AWS Management Console. Pour plus d’informations, consultez le *[Guide de l'utilisateur Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
Voici un exemple de déclaration de récepteurs `CloudWatch` :
```
{
"Id": "CloudWatchSink",
"SinkType": "CloudWatch"
}
```
Toutes les déclarations de récepteurs `CloudWatch` peuvent fournir les paires clé-valeur supplémentaires suivantes :
`SinkType`
Doit être spécifié. La valeur doit être la chaîne littérale `CloudWatch`.
`Interval`
Spécifie la fréquence (en secondes) à laquelle Kinesis Agent pour Windows communique les métriques au service CloudWatch. La paire clé-valeur est facultative. Si cet élément est spécifié, utilisez un entier pour représenter la valeur. La valeur par défaut est de 60 secondes. Spécifiez 1 seconde si vous voulez des métriques CloudWatch haute résolution.
`Namespace`
Spécifie l'espace de noms CloudWatch où les données de métriques sont présentées. Les espaces de noms CloudWatch regroupent un ensemble de métriques. La paire clé-valeur est facultative. La valeur par défaut est `KinesisTap`.
`Dimensions`
Spécifie les dimensions CloudWatch utilisées pour isoler les ensembles de métriques au sein d'un espace de noms. Cela peut être utile pour fournir des ensembles de données de métriques distincts pour chaque ordinateur de bureau ou serveur, par exemple. Cette paire clé-valeur est facultative et, si elle est spécifiée, la valeur doit respecter le format suivant : `"`*clé1*`=`*valeur1**clé2*`=`*valeur...*`"`. La valeur par défaut est `"ComputerName={computername};InstanceId={instance_id}"`. Cette valeur prend en charge la substitution des variables de récepteur. Pour plus d'informations, consultez [Configuration des substitutions de variables de récepteur](#configuring-kinesis-agent-windows-sink-variable-substitution).
`MetricsFilter`
Spécifie les métriques qui sont diffusées vers CloudWatch à partir de la source de métriques Kinesis Agent for Windows intégrée. Pour plus d'informations sur la source de métriques intégrée de Kinesis Agent pour Windows, notamment sur les détails de la syntaxe de la valeur de cette paire clé-valeur, consultez[Source des métriques prédéfinies de Kinesis Agent pour Windows](source-object-declarations.md#kinesis-agent-builin-metrics-source).
## Configuration du récepteur `CloudWatchLogs`
La .`CloudWatchLogs`Le type de récepteur diffuse des enregistrements de journaux et des événements vers des Amazon CloudWatch Logs. Vous pouvez afficher les journaux dans AWS Management Console ou les traiter au cours des étapes supplémentaires d'un pipeline de données. Les données sont diffusées dans un flux de journaux nommé qui est configuré dans CloudWatch Logs. Les flux de journaux sont organisés en groupes de journaux nommés. Pour plus d'informations, consultez le .*[Guide de l'utilisateur Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/)*.
Voici un exemple de déclaration de récepteurs CloudWatch Logs :
```
{
"Id": "MyCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"BufferInterval": "60",
"BufferSize": "100",
"Region": "us-west-2",
"LogGroup": "MyTestLogGroup",
"LogStream": "MyTestStream"
}
```
Toutes les déclarations de récepteurs `CloudWatchLogs` doivent fournir les paires clé-valeur supplémentaires suivantes :
`SinkType`
Cet élément doit avoir pour valeur la chaîne littérale `CloudWatchLogs`.
`LogGroup`
Spécifie le nom du groupe de journaux CloudWatch Logs qui contient le flux de journaux qui reçoit les enregistrements de journaux et d'événements diffusés par l'`CloudWatchLogs`type d'évier. Si le groupe de journaux spécifié n'existe pas, Kinesis Agent for Windows tente de le créer.
`LogStream`
Spécifie le nom du flux de CloudWatch Logs qui reçoit le flux d'enregistrements de journaux et d'événements diffusés par l'`CloudWatchLogs`type d'évier. Cette valeur prend en charge la substitution des variables de récepteur. Pour plus d'informations, consultez [Configuration des substitutions de variables de récepteur](#configuring-kinesis-agent-windows-sink-variable-substitution). Si le flux de journaux spécifié n'existe pas, Kinesis Agent for Windows tente de le créer.
La valeur par défaut de `BufferInterval` pour ce type de récepteur est d'une seconde et la valeur par défaut de `BufferSize` est de 500 enregistrements. La taille de tampon maximale est de 10 000 enregistrements.
## Locale`FileSystem`Configuration du récepteur
Le type d'évier`FileSystem`enregistre les enregistrements de journaux et d'événements dans un fichier sur le système de fichiers local au lieu de les diffuser vers les services AWS.`FileSystem`sont utiles pour les tests et les diagnostics. Par exemple, vous pouvez utiliser ce type de collecteur pour examiner les enregistrements avant de les envoyer à AWS.
avec`FileSystem`, vous pouvez également utiliser des paramètres de configuration pour simuler le traitement par lots, la limitation et le retour sur erreur pour imiter le comportement des puits AWS réels.
Tous les enregistrements de toutes les sources connectées à un`FileSystem`sont enregistrés dans le fichier unique spécifié en tant que`FilePath`. Si`FilePath`n'est pas spécifié, les enregistrements sont enregistrés dans un fichier nommé`SinkId.txt`dans le`%TEMP%`, qui est généralement`C:\Users\UserName\AppData\Local\Temp`où :`SinkId`est l'identifiant unique du récepteur et`UserName`est le nom d'utilisateur Windows de l'utilisateur actif.
Ce type de puits prend en charge les attributs de décoration de texte. Pour plus d'informations, consultez [Configuration des décorations de récepteurs](#configuring-kinesis-agent-windows-decoration-configuration).
Un exemple d'`FileSystem`La configuration de type de récepteur apparaît dans l'exemple suivant.
```
{
"Id": "LocalFileSink",
"SinkType": "FileSystem",
"FilePath": "C:\\ProgramData\\Amazon\\local_sink.txt",
"Format": "json",
"TextDecoration": "",
"ObjectDecoration": ""
}
```
La .`FileSystem`La configuration se compose des paires clé-valeur suivantes.
`SinkType`
Cet élément doit avoir pour valeur la chaîne littérale `FileSystem`.
`FilePath`
Spécifie le chemin d'accès et le fichier où les enregistrements sont enregistrés. La paire clé-valeur est facultative. S'il n'est pas spécifié, la valeur par défaut est`TempPath\\SinkId.txt`où :`TempPath`est le dossier stocké dans la stratégie`%TEMP%`Variable et`SinkId`est l'identifiant unique du récepteur.
`Format`
Spécifie le format de l'événement à`json`ou`xml`. Cette paire de valeur de clé est facultative et ne respecte pas la casse. S'il est omis, les événements sont écrits dans le fichier en texte brut.
`TextDecoration`
S'applique uniquement aux événements écrits en texte brut. La paire clé-valeur est facultative.
`ObjectDecoration`
S'applique uniquement aux événements où`Format`a la valeur`json`. La paire clé-valeur est facultative.
### Utilisation avancée — Limitation des enregistrements et simulation des défaillances
`FileSystem`peut imiter le comportement des puits AWS en simulant la limitation des enregistrements. Vous pouvez utiliser les paires clé-valeur suivantes pour spécifier des attributs de limitation d'enregistrements et de simulation d'échec.
En acquérant un verrou sur le fichier de destination et en empêchant les écritures sur celui-ci, vous pouvez utiliser`FileSystem`pour simuler et examiner le comportement des puits AWS en cas de défaillance du réseau.
L'exemple suivant illustre un`FileSystem`avec des attributs de simulation.
```
{
"Id": "LocalFileSink",
"SinkType": "FileSystem",
"FilePath": "C:\\ProgramData\\Amazon\\local_sink.txt",
"TextDecoration": "",
"RequestsPerSecond": "100",
"BufferSize": "10",
"MaxBatchSize": "1024"
}
```
`RequestsPerSecond`
Facultatif et spécifié en tant que type de chaîne. S'il n'est pas spécifié, la valeur par défaut est`"5"`. Contrôle le taux de demandes que le sovier traite, c'est-à-dire les écritures dans un fichier, et non le nombre d'enregistrements. Kinesis Agent pour Windows effectue des requêtes par lots aux points de terminaison AWS, de sorte qu'une demande peut contenir plusieurs enregistrements.
`BufferSize`
Facultatif et spécifié en tant que type de chaîne. Spécifie le nombre maximal d'enregistrements d'événements que le sovier effectue par lots avant d'enregistrer dans le fichier.
`MaxBatchSize`
Facultatif et spécifié en tant que type de chaîne. Spécifie la quantité maximale de données d'enregistrement d'événement, en octets, que le sovier effectue par lots avant d'enregistrer dans le fichier.
La limite de taux d'enregistrement maximal est fonction de`BufferSize`, qui détermine le nombre maximum d'enregistrements par demande, et`RequestsPerSecond`. Vous pouvez calculer la limite de taux d'enregistrement par seconde à l'aide de la formule suivante.
**Taux d'enregistrement**=`BufferSize`\$1`RequestsPerSecond`
Compte tenu des valeurs de configuration dans l'exemple ci-dessus, il y a un taux d'enregistrement maximal de 1000 enregistrements par seconde.
## Configuration de la sécurité des récepteurs
### Configuration de l'authentification
Pour que Kinesis Agent pour Windows diffuse des journaux, des événements et des métriques vers les services AWS, l'accès doit être authentifié. Il existe plusieurs manières de fournir une authentification pour Kinesis Agent for Windows. La façon dont vous procédez dépend de la situation dans laquelle l'Agent Kinesis pour Windows s'exécute et des exigences de sécurité spécifiques pour une organisation donnée.
+ Si Kinesis Agent pour Windows s'exécute sur un hôte Amazon EC2, la façon la plus simple et la plus sécurisée de fournir une authentification consiste à créer un rôle IAM ayant suffisamment de droits d'accès aux opérations requises pour les services AWS requis, ainsi qu'un profil d'instance EC2 faisant référence à ce rôle. Pour plus d'informations sur la création de profils d'instance, consultez [Utilisation de profils d'instance](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html). Pour plus d'informations sur les stratégies à attacher au rôle IAM, consultez[Configuration de l'autorisation](#configuring-kinesis-agent-windows-authorization).
Après avoir créé le profil d'instance, vous pouvez l'associer à des instances EC2 qui utilisent Kinesis Agent pour Windows. Si les instances disposent déjà d'un profil d'instance associé, vous pouvez attacher les stratégies appropriées au rôle associé à ce profil d'instance.
+ Si Kinesis Agent pour Windows s'exécute sur un hôte EC2 dans un compte, mais que les ressources qui sont la cible du récepteur résident dans un autre compte, vous pouvez créer un rôle IAM pour l'accès entre comptes. Pour de plus amples informations, veuillez consulter[Didacticiel : Delegate Access Across AWS Accounts Using IAM Roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html). Après avoir créé le rôle entre comptes, spécifiez son Amazon Resource Name (ARN) sous la forme de la valeur de l'`RoleARN`Paire clé-valeur dans la déclaration. Kinesis Agent pour Windows tente ensuite d'assumer le rôle entre comptes spécifié lors de l'accès aux ressources AWS qui sont associées au type de récepteur.
+ Si Kinesis Agent pour Windows s'exécute en dehors d'Amazon EC2 (par exemple, sur site), il existe plusieurs options :
+ S'il est acceptable d'enregistrer le serveur ou l'ordinateur de bureau sur site en tant qu'instance gérée par Amazon EC2 Systems Manager, utilisez la procédure suivante pour configurer l'authentification :
1. Utilisez le processus décrit dans [Configuration d'AWS Systems Manager dans des environnements hybrides](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-managedinstances.html) pour créer un rôle de service, créer une activation pour une instance gérée et installer l'agent SSM.
1. Attachez les stratégies appropriées au rôle de service pour permettre à Kinesis Agent pour Windows d'accéder aux ressources nécessaires pour la diffusion des données à partir des récepteurs configurés. Pour plus d'informations sur les stratégies à attacher au rôle IAM, consultez[Configuration de l'autorisation](#configuring-kinesis-agent-windows-authorization).
1. Utilisez le processus décrit dans[Configuration`ProfileRefreshingAWSCredentialProvider`Pour actualiser les informations d'identification AWS](#configuring-credential-refresh)pour actualiser les informations d'identification AWS.
Il s'agit de l'approche recommandée pour les instances autres qu'EC2, car les informations d'identification sont gérées en toute sécurité par SSM et AWS.
+ S'il est acceptable d'exécuter le service AWSKinesisTap pour Kinesis Agent pour Windows sous un utilisateur spécifique au lieu du compte système par défaut, utilisez la procédure suivante :
1. Créez un utilisateur IAM dans le compte AWS où les services AWS seront utilisés. Capturez la clé d'accès et la clé secrète de cet utilisateur pendant le processus de création. Vous aurez besoin de ces informations pour les étapes ultérieures de cette procédure.
1. Attachez à l'utilisateur IAM des stratégies qui autorisent l'accès aux opérations requises pour les services requis. Pour plus d'informations sur les stratégies à attacher à l'utilisateur IAM, consultez[Configuration de l'autorisation](#configuring-kinesis-agent-windows-authorization).
1. Modifiez le service AWSKinesisTap sur chaque ordinateur de bureau ou serveur afin qu'il s'exécute sous un utilisateur spécifique et non sous le compte système par défaut.
1. Créez un profil dans le magasin SDK à l'aide de la clé d'accès et de la clé secrète enregistrées précédemment. Pour plus d'informations, consultez [Configuration des informations d'identification AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html).
1. Mettez à jour le fichier `AWSKinesisTap.exe.config` du répertoire `%PROGRAMFILES%\Amazon\AWSKinesisTap` en spécifiant le nom du profil créé à l'étape précédente. Pour plus d'informations, consultez [Configuration des informations d'identification AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html).
Il s'agit de la méthode recommandée pour les hôtes autres qu'EC2 qui ne peuvent pas être des instances gérées, car les informations d'identification sont chiffrées pour l'hôte et l'utilisateur spécifiques.
+ S'il est nécessaire d'exécuter le service AWSKinesisTap pour Kinesis Agent pour Windows sous le compte système par défaut, vous devez utiliser un fichier d'informations d'identification partagé. En effet, le compte système n'a pas de profil utilisateur Windows pour activer le magasin SDK. Les fichiers d'informations d'identification ne sont pas chiffrés ; nous déconseillons donc cette approche. Pour plus d'informations sur l'utilisation des fichiers de configuration partagés, consultez[Configuration des informations d'identification AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html)dans le*Kit AWS SDK pour .NET*. Si vous utilisez cette approche, nous vous recommandons d'utiliser le chiffrement NTFS et l'accès restreint au fichier de configuration partagé. Les clés doivent faire l'objet d'une rotation par une plateforme de gestion et le fichier de configuration partagé doit être mis à jour lors de la rotation des clés.
Bien qu'il soit possible de fournir directement les clés d'accès et les clés secrètes dans les déclarations de récepteur, cette approche est déconseillée, car les déclarations ne sont pas chiffrées.
### Configuration de l'autorisation
Attachez les stratégies appropriées qui suivent à l'utilisateur ou au rôle IAM que utilisera Kinesis Agent pour Windows pour diffuser les données vers les services AWS :
#### Kinesis Data Streams
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"kinesis:PutRecord",
"kinesis:PutRecords"
],
"Resource": "arn:aws:kinesis:*:*:stream/*"
}
]
}
```
Pour limiter l'autorisation à un nom de région, de compte ou de flux spécifique, remplacez les astérisques appropriés dans l'ARN par des valeurs spécifiques. Pour plus d'informations, consultez « Amazon Resource Names (ARN) pour Kinesis Data Streams » dans [Contrôle de l'accès aux ressources Amazon Kinesis Data Streams avec 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/*"
}
]
}
```
Pour limiter l'autorisation à un nom de région, de compte ou de flux de diffusion spécifique, remplacez les astérisques appropriés dans l'ARN par des valeurs spécifiques. Pour de plus amples informations, veuillez consulter[Contrôle de l'accès avec Amazon Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html)dans le*Guide du développeur Amazon Kinesis Data Firehose*.
#### CloudWatch
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor2",
"Effect": "Allow",
"Action": "cloudwatch:PutMetricData",
"Resource": "*"
}
]
}
```
Pour de plus amples informations, veuillez consulter[Présentation de la gestion des autorisations d'accès à vos ressources CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-access-control-overview-cw.html)dans le*Guide de l'utilisateur Amazon CloudWatch Logs*.
#### CloudWatch Logs avec un groupe de journaux et un flux de journaux existants
```
{
"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:*:*:*"
}
]
}
```
Pour limiter l'accès à une région, un compte, un groupe de journaux ou un flux de journaux spécifique, remplacez les astérisques appropriés dans l'ARN par les valeurs appropriées. Pour de plus amples informations, veuillez consulter[Présentation de la gestion des autorisations d'accès à vos ressources de CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html)dans le*Guide de l'utilisateur Amazon CloudWatch Logs*.
#### CloudWatch Logs avec des autorisations supplémentaires permettant à Kinesis Agent for Windows de créer des groupes de journaux et des flux de journaux
```
{
"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": "*"
}
]
}
```
Pour limiter l'accès à une région, un compte, un groupe de journaux ou un flux de journaux spécifique, remplacez les astérisques appropriés dans l'ARN par les valeurs appropriées. Pour de plus amples informations, veuillez consulter[Présentation de la gestion des autorisations d'accès à vos ressources de CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html)dans le*Guide de l'utilisateur Amazon CloudWatch Logs*.
#### Autorisations requises pour l'extension des variables EC2 Tag
L'utilisation de l'extension des variables avec le préfixe de variable `ec2tag` nécessite l'autorisation `ec2:Describe*`.
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "VisualEditor8",
"Effect": "Allow",
"Action": "ec2:Describe*",
"Resource": "*"
}
]
}
```
**Note**
Vous pouvez combiner plusieurs instructions dans une seule stratégie, du moment que l'élément `Sid` de chaque instruction est unique au sein de cette stratégie. Pour plus d'informations sur la création de stratégies, consultez[Création de stratégies IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)dans le*Guide de l'utilisateur IAM*.
## Configuration`ProfileRefreshingAWSCredentialProvider`Pour actualiser les informations d'identification AWS
Si vous utilisez AWS Systems Manager pour les environnements hybrides pour gérer les informations d'identification AWS, Systems Manager fait pivoter les informations d'identification de session dans`c:\Windows\System32\config\systemprofile\.aws\credentials`. Pour plus d'informations sur Systems Manager pour les environnements hybrides, consultez[Configuration d'AWS Systems Manager pour les environnements hybrides](https://docs.aws.amazon.com/(systems-manager/latest/userguide/systems-manager-managedinstances.html))dans le*Guide de l'utilisateur AWS Systems Manager*.
Étant donné que le kit SDK .net AWS ne récupère pas automatiquement de nouvelles informations d'identification, nous fournissons le`ProfileRefreshingAWSCredentialProvider`pour actualiser les informations d'identification.
Vous pouvez utiliser la stratégie`CredentialRef`de n'importe quelle configuration de synchronisation AWS pour référencer un`Credentials`où la stratégie`CredentialType`est défini sur`ProfileRefreshingAWSCredentialProvider`Comme illustré dans l'exemple suivant.
```
{
"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
}]
}
```
Une définition d'informations d'identification se compose des attributs suivants sous forme de paires clé-valeur.
`Id`
Définit la chaîne que les définitions de puits peuvent spécifier en utilisant`CredentialRef`pour référencer cette configuration d'informations d'identification.
`CredentialType`
Définissez sur la chaîne littérale`ProfileRefreshingAWSCredentialProvider`.
`Profile`
Facultatif. La valeur par défaut est `default`.
`FilePath`
Facultatif. Indique le chemin d'accès au fichier d'informations d'identification AWS. Si ce paramètre n'est pas spécifié, `%USERPROFILE%/.aws/credentials` est la valeur par défaut.
`RefreshingInterval`
Facultatif. Fréquence à laquelle les informations d'identification sont actualisées, en secondes. Si ce paramètre n'est pas spécifié, `300` est la valeur par défaut.
## Configuration des décorations de récepteurs
Les déclarations de récepteurs peuvent éventuellement inclure des paires clé-valeur qui spécifient des données supplémentaires à diffuser vers différents services AWS pour améliorer les enregistrements recueillis à partir de la source.
`TextDecoration`
Utilisez cette paire clé-valeur si aucun élément `Format` n'est spécifié dans la déclaration. La valeur est une chaîne de format spécial dans laquelle se produit une substitution de variables. Par exemple, supposons qu'un élément `TextDecoration` de `"{ComputerName}:::{timestamp:yyyy-MM-dd HH:mm:ss}:::{_record}"` soit fourni pour un récepteur. Lorsqu'une source émet un enregistrement de journal contenant le texte `The system has resumed from sleep.` et que cette source est connectée au récepteur via un pipeline, le texte `MyComputer1:::2017-10-26 06:14:22:::The system has resumed from sleep.` est diffusé vers le service AWS associé au type de récepteur. La variable `{_record}` fait référence à l'enregistrement de texte d'origine fourni par la source.
`ObjectDecoration`
Utilisez cette paire clé-valeur lorsque `Format` est spécifié dans la déclaration de récepteurs pour ajouter des données supplémentaires avant la sérialisation des enregistrements. Par exemple, supposons qu'un élément `ObjectDecoration` de `"ComputerName={ComputerName};DT={timestamp:yyyy-MM-dd HH:mm:ss}"` soit fourni pour un récepteur qui spécifie l'élément JSON `Format`. Le JSON résultant diffusé vers le service AWS associé au type de récepteur inclut les paires clé-valeur suivantes, en plus des données d'origine provenant de la source :
```
{
ComputerName: "MyComputer2",
DT: "2017-10-17 21:09:04"
}
```
Pour obtenir un exemple d'utilisation de `ObjectDecoration`, consultez la section [Didacticiel : Diffuser les fichiers journaux JSON vers Amazon S3 à l'aide de Kinesis Agent pour Windows](directory-source-to-s3-tutorial.md).
`ObjectDecorationEx`
Spécifie une expression qui permet une extraction et une mise en forme plus flexibles des données par rapport à`ObjectDecoration`. Ce champ peut être utilisé lorsque le format de l'évier est`json`. La syntaxe d'expression est illustrée dans ce qui suit.
```
"ObjectDecorationEx": "attribute1={expression1};attribute2={expression2};attribute3={expression3}(;...)"
```
Par exemple,`ObjectDecorationEx`Attribut :
```
"ObjectDecorationEx": "host={env:ComputerName};message={upper(_record)};time={format(_timestamp, 'yyyyMMdd')}"
```
Transforme l'enregistrement littéral :
`System log message`
Dans un objet JSON comme suit, avec les valeurs renvoyées par les expressions :
```
{
"host": "EC2AMAZ-1234",
"message": "SYSTEM LOG MESSAGE",
"time": "20210201"
}
```
Pour plus d'informations sur la formulation des expressions, consultez[Conseils pour écrire des expressions](#configuring-expressions). La plupart des`ObjectDecoration`doit fonctionner en utilisant la nouvelle syntaxe à l'exception des variables d'horodatage. A`{timestamp:yyyyMMdd}`Champ dans`ObjectDecoration`est exprimé sous forme de`{format(_timestamp,'yyyyMMdd')}`in`ObjectDecorationEx`.
`TextDecorationEx`
Spécifie une expression qui permet une extraction et une mise en forme plus flexibles des données par rapport à`TextDecoration`, comme illustré dans l'exemple suivant.
```
"TextDecorationEx": "Message '{lower(_record)}' at {format(_timestamp, 'yyyy-MM-dd')}"
```
Vous pouvez utiliser`TextDecorationEx`pour composer des objets JSON. Utilisez '@ \$1'pour échapper à l'accolade ouverte, comme illustré dans l'exemple suivant.
```
"TextDecorationEx": "@{ \"var\": \"{upper($myvar1)}\" }"
```
Si le type de la source connectée au récepteur est `DirectorySource`, le récepteur peut utiliser trois variables supplémentaires :
`_FilePath`
Chemin complet du fichier journal.
`_FileName`
Nom et extension de nom du fichier.
`_Position`
Entier qui représente l'emplacement de l'enregistrement dans le fichier journal.
Ces variables sont utiles lorsque vous utilisez une source qui recueille les enregistrements de journaux de plusieurs fichiers connectés à un récepteur qui diffuse tous les enregistrements vers un seul flux. L'injection des valeurs de ces variables dans les enregistrements diffusés permet aux analyses en aval du pipeline de données de classer les enregistrements par fichier et par emplacement au sein de chaque fichier.
### Conseils pour écrire des expressions
Une expression peut avoir l'une des expressions suivantes :
+ Une expression variable.
+ Une expression constante, par exemple,`'hello'`,`1`,`1.21`,`null`,`true`,`false`.
+ Expression d'appel qui appelle une fonction, comme illustré dans l'exemple suivant.
```
regexp_extract('Info: MID 118667291 ICID 197973259 RID 0 To: ', 'To: (\\\\S+)', 1)
```
#### Caractères spéciaux
Deux barres obliques inverses sont nécessaires pour échapper aux caractères spéciaux.
#### Nesting
Les invocations de fonctions peuvent être imbriquées, comme illustré dans l'exemple suivant.
```
format(date(2018, 11, 28), 'MMddyyyy')
```
#### Variables
Il existe trois types de variables : locale, méta et globale.
+ **Variables locales**Commencez par un`$`tels que`$message`. Ils sont utilisés pour résoudre la propriété de l'objet d'événement, une entrée si l'événement est un dictionnaire, ou un attribut si l'événement est un objet JSON. Si la variable locale contient de l'espace ou des caractères spéciaux, utilisez une variable locale entre guillemets telle que`$'date created'`.
+ **Variables Métadonnées**Commencez par un trait de soulignement (`_`) et sont utilisés pour résoudre les métadonnées de l'événement. Tous les types d'événements prennent en charge les méta variables suivantes.
`_timestamp`
Horodatage de l'événement.
`_record`
Représentation de texte brut de l'événement.
Les événements de journal prennent en charge les méta variables supplémentaires suivantes.
`_filepath`
`_filename`
`_position`
`_linenumber`
+ **Variables globales**résoudre en variables d'environnement, métadonnées d'instance EC2 ou EC2Tag. Pour des performances améliorées, nous vous recommandons d'utiliser le préfixe pour limiter la portée de la recherche, comme`{env:ComputerName}`,`{ec2:InstanceId}`, et`{ec2tag:Name}`.
#### Fonctions intégrées
Kinesis Agent pour Windows prend en charge les fonctions prédéfinies ci-dessous. Si l'un des arguments est`NULL`et la fonction n'est pas conçue pour gérer`NULL`, un`NULL`est retourné.
```
//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)
```
## Configuration des substitutions de variables de récepteur
Les déclarations de récepteurs `KinesisStream`, `KinesisFirehose` et `CloudWatchLogs` nécessitent une paire clé-valeur `LogStream` ou `StreamName`. La valeur de ces paires clé-valeur peut contenir des références de variables qui sont automatiquement résolues par l'Agent Kinesis pour Windows. Pour`CloudWatchLogs`, le`LogGroup`paire clé-valeur est également requise et peut contenir des références de variables qui sont automatiquement résolues par l'Agent Kinesis pour Windows. Les variables sont spécifiées en utilisant le modèle `{`*`prefix`*`:`*`variablename`*`}`, où *`prefix`*`:` est facultatif. Les préfixes pris en charge sont les suivants :
+ `env`— La référence de variable est résolue par la valeur de la variable d'environnement portant le même nom.
+ `ec2`— La référence de variable est résolue par les métadonnées d'instance EC2 portant le même nom.
+ `ec2tag`— La référence de variable est résolue par la valeur de la balise d'instance EC2 portant le même nom. L'autorisation `ec2:Describe*` est nécessaire pour accéder aux balises d'instance. Pour plus d'informations, consultez [Autorisations requises pour l'extension des variables EC2 Tag](#ec2-permissions).
Si le préfixe n'est pas spécifié et s'il y a une variable d'environnement portant le même nom que `variablename`, la référence de variable est résolue par la valeur de la variable d'environnement. Sinon, si `variablename` a pour valeur `instance_id` ou `hostname`, la référence de variable est résolue par la valeur des métadonnées EC2 portant le même nom. Dans le cas contraire, la référence de variable n'est pas résolue.
Voici des exemples de paires clé-valeur valides utilisant des références de variable :
```
"LogStream": "LogStream_{instance_id}"
"LogStream": "LogStream_{hostname}"
"LogStream": "LogStream_{ec2:local-hostname}"
"LogStream": "LogStream_{computername}"
"LogStream": "LogStream_{env:computername}"
```
Les déclarations de récepteurs `CloudWatchLogs` prennent en charge une variable d'horodatage de format spécial qui autorise l'horodatage de l'enregistrement de journal ou d'événement d'origine à partir de la source pour modifier le nom du flux de journaux. Le format est `{timestamp:``timeformat``}`. Consultez l'exemple suivant:
```
"LogStream": "LogStream_{timestamp:yyyyMMdd}"
```
Si l'enregistrement de journal ou d'événement a été généré le 5 juin 2017, la valeur de la paire clé-valeur `LogStream` de l'exemple précédent sera résolue par `"LogStream_20170605"`.
Si cela est autorisé, le type de récepteur `CloudWatchLogs` peut créer automatiquement de nouveaux flux de journaux lorsque cela est nécessaire en fonction des noms générés. Vous ne pouvez pas le faire pour d'autres types de récepteurs, car ils nécessitent une configuration supplémentaire au-delà du nom du flux.
Il existe des substitutions de variables spéciales qui se produisent dans les éléments TextDecoration et ObjectDecoration. Pour plus d'informations, consultez [Configuration des décorations de récepteurs](#configuring-kinesis-agent-windows-decoration-configuration).
## Configuration de la mise en file d'attente des récepteurs
Les déclarations de récepteurs `CloudWatchLogs`, `KinesisStream` et `KinesisFirehose` peuvent éventuellement autoriser la mise en file d'attente des enregistrements qui n'ont pas pu être diffusés vers le service AWS associé à ces types de récepteurs en raison de problèmes de connectivité transitoires. Pour activer la mise en file d'attente et l'automatisation des nouvelles tentatives de diffusion en streaming lorsque la connectivité est restaurée, utilisez les paires clé-valeur suivantes dans les déclarations de récepteurs :
`QueueType`
Spécifie le type de mécanisme de mise en file d'attente à utiliser. La seule valeur prise en charge est `file`, ce qui indique que les enregistrements doivent être mis en file d'attente dans un fichier. Cette paire clé-valeur est obligatoire pour activer la fonctionnalité de mise en file d'attente de Kinesis Agent for Windows. Si cet élément n'est pas spécifié, le comportement par défaut est le placement en file d'attente en mémoire uniquement et l'échec de la diffusion lorsque les limites de la mise en file d'attente en mémoire sont atteintes.
`QueuePath`
Spécifie le chemin d'accès au dossier contenant les fichiers des enregistrements placés en file d'attente. La paire clé-valeur est facultative. La valeur par défaut est `%PROGRAMDATA%\KinesisTap\Queue\`*SinkId*, où *SinkId* représente l'identifiant que vous avez affecté comme valeur de l'élément `Id` pour la déclaration de récepteurs.
`QueueMaxBatches`
Limite la quantité totale d'espace pouvant être consommée par Kinesis Agent pour Windows lors de la mise en file d'attente des enregistrements pour la diffusion en streaming. La quantité d'espace est limitée à la valeur de cette paire clé-valeur multipliée par le nombre maximal d'octets par lot. Le nombre maximal d'octets par lot des types de récepteurs `CloudWatchLogs`, `KinesisStream` et `KinesisFirehose` est respectivement 5 Mo, 4 Mo et 1 Mo. Lorsque cette limite est atteinte, les défaillances de diffusion en streaming ne sont pas mises en file d'attente et sont signalées comme des défaillances irrécupérables. La paire clé-valeur est facultative. La valeur par défaut est de 10 000 lots.
## Configuration d'un proxy pour les récepteurs
Pour configurer un proxy pour tous les types de récepteur Kinesis Agent pour Windows qui accèdent aux services AWS, modifiez le fichier de configuration Kinesis Agent for Windows situé à l'adresse`%Program Files%\Amazon\KinesisTap\AWSKinesisTap.exe.config`. Pour obtenir des instructions, consultez`proxy`Section dans[Référence aux fichiers de configuration pour le 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)dans le*Manuel du développeur du kit SDK AWS pour .NET*.
## Configuration de la résolution de variables dans d'autres attributs de collecteur
L'exemple suivant illustre une configuration de récepteur qui utilise l'`Region`Variable d'environnement pour la valeur de la stratégie`Region`paire clé/valeur d'attribut. Pour`RoleARN`, il spécifie la clé de balise EC2`MyRoleARN`, qui évalue la valeur associée à cette clé.
```
"Id": "myCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"LogGroup": "EC2Logs",
"LogStream": "logs-{instance_id}"
"Region": "{env:Region}"
"RoleARN": "{ec2tag:MyRoleARN}"
```
## Configuration des points de terminaison régionaux AWS STS lors de l'utilisation de la propriété RoleARN dans les puits AWS
Cette fonctionnalité ne s'applique que si vous utilisez KinesiStap sur Amazon EC2 et que vous utilisez l'`RoleARN`des puits AWS pour assumer un rôle IAM externe pour s'authentifier auprès des services AWS de destination.
En définissant`UseSTSRegionalEndpoints`sur`true`, vous pouvez spécifier qu'un agent utilise le point de terminaison régional (par exemple,`https://sts.us-east-1.amazonaws.com`) au lieu du point de terminaison global (par exemple,`https://sts.amazonaws.com`). L'utilisation d'un point de terminaison STS régional réduit la latence aller-retour pour l'opération et limite l'impact des défaillances dans le service de point de terminaison global.
## Configuration du point de terminaison VPC pour les puits AWS
Vous pouvez spécifier un point de terminaison VPC dans la configuration du récepteur pour`CloudWatchLogs`,`CloudWatch`,`KinesisStreams`, et`KinesisFirehose`types d'évier. Un point de terminaison de VPC permet une connexion privée entre votre VPC et les services AWS pris en charge ou les services de point de terminaison VPC gérés par AWS PrivateLink sans nécessiter une passerelle Internet, un périphérique NAT et une connexion VPN ou une connexion AWS Direct Connect. Les instances de votre VPC ne requièrent pas d'adresses IP publiques pour communiquer avec les ressources du service. Le trafic entre votre VPC et les autres services ne quitte pas le réseau Amazon. Pour de plus amples informations, veuillez consulter[Points de terminaison d'un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html)dans le*Guide de l'utilisateur Amazon VPC*.
Vous spécifiez le point de terminaison VPC à l'aide de la`ServiceURL`comme illustré dans l'exemple suivant d'un`CloudWatchLogs`configuration de l'évier. Définissez la valeur de`ServiceURL`à la valeur affichée sur le**Détails du point de terminaison du VPC**À l'aide de 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"
}
```
## Configuration d'un autre moyen de proxy
Cette fonctionnalité vous permet de configurer un serveur proxy dans une configuration de collecteur à l'aide de la prise en charge du proxy intégrée au kit SDK AWS au lieu de .NET. Auparavant, la seule façon de configurer l'agent pour qu'il utilise un proxy était d'utiliser une fonctionnalité native de .NET, qui acheminait automatiquement toutes les requêtes HTTP/S via le proxy défini dans le fichier proxy.
Si vous utilisez actuellement l'agent avec un serveur proxy, vous n'avez pas besoin de changer pour utiliser cette méthode.
Vous pouvez utiliser la stratégie`ProxyHost`and`ProxyPort`Pour configurer un proxy alternatif, comme illustré dans l'exemple suivant.
```
{
"Id": "myCloudWatchLogsSink",
"SinkType": "CloudWatchLogs",
"LogGroup": "EC2Logs",
"LogStream": "logs-{instance_id}",
"Region": "us-west-2",
"ProxyHost": "myproxy.mydnsdomain.com",
"ProxyPort": "8080"
}
```
# Déclarations de canal
Utiliser*Déclarations de canal*pour connecter une source (voir[Déclarations de sources](source-object-declarations.md)) à un évier (voir[Déclarations de récepteurs](sink-object-declarations.md)) dans Amazon Kinesis Agent pour Microsoft Windows. Une déclaration de canal est exprimée sous la forme d'un objet JSON. Lorsque Kinesis Agent pour Windows démarre, les journaux, les événements ou les métriques sont collectés à partir de la source d'un canal donné. Ils sont ensuite diffusés vers différents services AWS à l'aide d'un récepteur associé à ce canal.
Voici un exemple de déclaration de canal :
```
{
"Id": "MyAppLogToCloudWatchLogs",
"SourceRef": "MyAppLog",
"SinkRef": "MyCloudWatchLogsSink"
}
```
**Topics**
+ [Configuration des canaux](#kinesis-agent-pipe-configuration)
+ [Configuration de Kinesis Agent pour les canaux métriques Windows](#kinesis-agent-metric-pipe-configuration)
## Configuration des canaux
Toutes les déclarations de canal peuvent contenir les paires clé-valeur suivantes :
`Id`
Spécifie le nom du canal (obligatoire). Il doit être unique dans le fichier de configuration.
`Type`
Spécifie le type de transformation (le cas échéant) qui est appliqué par le canal lorsque les données de journaux sont transférées de la source au récepteur. La seule valeur prise en charge est `RegexFilterPipe`. Cette valeur permet de filtrer les expressions régulières de la représentation textuelle sous-jacente de l'enregistrement de journal. L'utilisation du filtrage permet de réduire les coûts de transmission et de stockage par l'envoi des seuls enregistrements de journal pertinents en aval vers le pipeline de données. La paire clé-valeur est facultative. La valeur par défaut consiste à ne fournir aucune transformation.
`FilterPattern`
Spécifie l'expression régulière pour les pipelines `RegexFilterPipe` qui sont utilisés pour filtrer les enregistrements de journal collectés par la source avant le transfert vers le récepteur. Les enregistrements de journal sont transférés par les canaux de type `RegexFilterPipe` lorsque l'expression régulière correspond à la représentation textuelle sous-jacente de l'enregistrement. Les enregistrements de journal structurés qui sont générés, par exemple lors de l'utilisation de la paire clé-valeur `ExtractionPattern` dans une déclaration `DirectorySource`, peuvent toujours être filtrés à l'aide du mécanisme `RegexFilterPipe`. En effet, ce mécanisme agit sur la représentation textuelle d'origine avant de procéder à l'analyse. Cette paire clé-valeur est facultative, mais elle doit être indiquée si le canal spécifie le type `RegexFilterPipe`.
Voici un exemple de déclaration de canal `RegexFilterPipe` :
```
{
"Id": "MyAppLog2ToFirehose",
"Type": "RegexFilterPipe",
"SourceRef": "MyAppLog2",
"SinkRef": "MyFirehose",
"FilterPattern": "^(10|11),.*",
"IgnoreCase": false,
"Negate": false
}
```
`SourceRef`
Spécifie le nom (la valeur de la paire clé-valeur `Id`) de la déclaration de source qui définit la source qui collecte les données de journaux, d'événements et de métriques pour le canal (obligatoire).
`SinkRef`
Spécifie le nom (la valeur de la paire clé-valeur `Id`) de la déclaration de récepteur qui définit le récepteur qui reçoit les données de journaux, d'événements et de métriques pour le canal (obligatoire).
`IgnoreCase`
Facultatif. Accepte les valeurs de`true`ou`false`. Lorsqu'il est défini sur`true`, l'expression Regex fait correspondre les enregistrements d'une manière insensible à la casse.
`Negate`
Facultatif. Accepte les valeurs de`true`ou`false`. Lorsqu'il est défini sur`true`, le tuyau transmettra les enregistrements*Ne*Correspond à l'expression régulière.
Pour obtenir un exemple d'un fichier de configuration complet qui utilise le type de canal `RegexFilterPipe`, consultez [Utilisation des canaux](configuring-kaw-examples.md#configuring-kaw-examples-pipes).
## Configuration de Kinesis Agent pour les canaux métriques Windows
Il existe une source de métrique intégrée nommée`_KinesisTapMetricsSource`qui produit des mesures sur Kinesis Agent pour Windows. S'il y a un`CloudWatch`déclaration de lavabo avec une`Id`de`MyCloudWatchSink`, l'exemple de déclaration de pipeline suivant transfère les métriques générées par Kinesis Agent pour Windows vers ce récepteur :
```
{
"Id": "KinesisAgentMetricsToCloudWatch",
"SourceRef": "_KinesisTapMetricsSource",
"SinkRef": "MyCloudWatchSink"
}
```
Pour plus d'informations sur les sources de métriques intégrées à Kinesis Agent pour Windows, consultez[Source des métriques prédéfinies de Kinesis Agent pour Windows](source-object-declarations.md#kinesis-agent-builin-metrics-source).
Si le fichier de configuration diffuse également les métriques de compteurs de performances Windows, nous vous conseillons d'utiliser un autre canal et un autre récepteur plutôt que d'utiliser le même récepteur pour les métriques Kinesis Agent pour Windows et les métriques de compteurs de performances Windows.
# Configuration des mises à jour automatiques
Utilisation de l'`appsettings.json`Pour permettre la mise à jour automatique d'Amazon Kinesis Agent for Microsoft Windows et du fichier de configuration de Kinesis Agent for Windows. Pour contrôler le comportement de mise à jour, spécifiez la paire clé-valeur `Plugins` au même niveau du fichier de configuration que `Sources`, `Sinks` et `Pipes`.
La paire clé-valeur `Plugins` spécifie les fonctionnalités générales supplémentaires à utiliser et qui ne relèvent pas spécifiquement des catégories sources, récepteurs (sinks) et canaux (pipes). Par exemple, il existe un plug-in pour la mise à jour de Kinesis Agent pour Windows et un plug-in pour la mise à jour de`appsettings.json`Fichier de configuration. Les plug-ins sont représentés en tant qu'objets JSON et ont toujours une paire clé-valeur `Type`. La paire `Type` détermine les autres paires clé-valeur qui peuvent être spécifiées pour le plug-in. Les types de plug-ins suivants sont pris en charge :
`PackageUpdate`
Spécifie que l'agent Kinesis pour Windows doit vérifier périodiquement le fichier de configuration de la version du package. Si le fichier de la version du package indique qu'une autre version de Kinesis Agent pour Windows doit être installée, Kinesis Agent pour Windows la télécharge et l'installe. Les paires clé-valeur du plug-in `PackageUpdate` incluent :
`Type`
La valeur est obligatoire et doit être la chaîne `PackageUpdate`.
`Interval`
Spécifie en minutes (sous forme de chaîne) la fréquence à laquelle le fichier de la version du package doit être contrôlé en cas de modifications éventuelles. La paire clé-valeur est facultative. Si elle n'est pas spécifiée, la valeur par défaut est 60 minutes. Si la valeur est inférieure à 1, il n'est procédé à aucun contrôle de mise à jour.
`PackageVersion`
Spécifie l'emplacement du fichier JSON de la version du package. Le fichier peut résider sur un partage de fichiers (`file://`), un site web (`http://`) ou Amazon S3 (`s3://`). Par exemple, une valeur de`s3://mycompany/config/agent-package-version.json`indique que Kinesis Agent pour Windows doit vérifier le contenu de la`config/agent-package-version.json`Dans le fichier`mycompany`Compartiment Amazon S3. Il doit effectuer les mises à jour en fonction du contenu de ce fichier.
La valeur de la propriété`PackageVersion`La paire clé-valeur est sensible à la casse pour Amazon S3.
L'exemple suivant est celui du contenu du fichier d'une version de package :
```
{
"Name": "AWSKinesisTap",
"Version": "1.0.0.106",
"PackageUrl": "https://s3-us-west-2.amazonaws.com/kinesis-agent-windows/downloads/AWSKinesisTap.{Version}.nupkg"
}
```
La .`Version`Spécifie la version de Kinesis Agent pour Windows à installer si elle n'est pas déjà installée. La référence de la variable `{Version}` dans `PackageUrl` résout la valeur que vous spécifiez pour la paire clé-valeur `Version`. Dans cet exemple, la variable est résolue dans la chaîne `1.0.0.106`. Cette résolution de variable est fournie de telle sorte qu'il y ait un seul emplacement dans le fichier de la version du package où la version spécifique souhaitée est stockée. Vous pouvez utiliser plusieurs fichiers de la version du package pour contrôler le rythme du déploiement de nouvelles versions de Kinesis Agent pour Windows afin de valider une nouvelle version avant un déploiement plus important. Pour restaurer un déploiement de Kinesis Agent pour Windows, modifiez un ou plusieurs fichiers de la version du package afin de spécifier une version antérieure de Kinesis Agent pour Windows connue pour fonctionner dans votre environnement.
La valeur de la paire clé-valeur `PackageVersion` est affectée par la substitution de variable afin de faciliter la sélection automatique des différents fichiers de version du package. Pour plus d'informations sur la substitution de variable, consultez [Configuration des substitutions de variables de récepteur](sink-object-declarations.md#configuring-kinesis-agent-windows-sink-variable-substitution).
`AccessKey`
Spécifie la clé d'accès à utiliser lors de l'authentification de l'accès au fichier de la version du package dans Amazon S3. La paire clé-valeur est facultative. Il est déconseillé d'utiliser cette paire clé-valeur. Pour obtenir les autres méthodes d'authentification recommandées, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`SecretKey`
Spécifie la clé secrète à utiliser lors de l'authentification de l'accès au fichier de la version du package dans Amazon S3. La paire clé-valeur est facultative. Il est déconseillé d'utiliser cette paire clé-valeur. Pour obtenir les autres méthodes d'authentification recommandées, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`Region`
Spécifie le point de terminaison de la région à utiliser lors de l'accès au fichier de la version du package depuis Amazon S3. La paire clé-valeur est facultative.
`ProfileName`
Spécifie le profil de sécurité à utiliser lors de l'authentification de l'accès au fichier de la version du package dans Amazon S3. Pour plus d'informations, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). La paire clé-valeur est facultative.
`RoleARN`
Spécifie le rôle à endosser lors de l'authentification de l'accès au fichier de la version du package dans Amazon S3 dans au sein d'un scénario entre comptes. Pour plus d'informations, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). La paire clé-valeur est facultative.
S'il n'est pas spécifié de plug-in `PackageUpdate`, aucun fichier de la version du package n'est vérifié pour déterminer si une mise à jour est requise.
`ConfigUpdate`
Spécifie que Kinesis Agent pour Windows doit vérifier périodiquement la présence d'un`appsettings.json`Fichier de configuration stocké dans un partage de fichiers, sur un site web ou sur Amazon S3. S'il existe un fichier de configuration mis à jour, il est téléchargé et installé par Kinesis Agent pour Windows.`ConfigUpdate`Les paires clé-valeur incluent les informations suivantes :
`Type`
La valeur est obligatoire et doit être la chaîne `ConfigUpdate`.
`Interval`
Spécifie en minutes (sous la forme d'une chaîne) la fréquence à laquelle un nouveau fichier de configuration doit être recherché. Cette paire clé-valeur est facultative, et si elle n'est pas spécifiée, la valeur par défaut est de 5 minutes. Si la valeur est inférieure à 1, la mise à jour du fichier de configuration n'est pas contrôlée.
`Source`
Spécifie à quel emplacement rechercher un fichier de configuration mis à jour. Le fichier peut résider sur un partage de fichiers (`file://`), un site web (`http://`) ou Amazon S3 (`s3://`). Par exemple, une valeur de`s3://mycompany/config/appsettings.json`indique que Kinesis Agent pour Windows doit rechercher les mises à jour de la`config/appsettings.json`Dans le fichier`mycompany`Compartiment Amazon S3.
La valeur de la propriété`Source`La paire clé-valeur est sensible à la casse pour Amazon S3.
La valeur de la paire clé-valeur `Source` est affectée par la substitution de variable afin de faciliter la sélection automatique des différents fichiers de configuration. Pour plus d'informations sur la substitution de variable, consultez [Configuration des substitutions de variables de récepteur](sink-object-declarations.md#configuring-kinesis-agent-windows-sink-variable-substitution).
`Destination`
Spécifie à quel emplacement le fichier de configuration doit être stocké sur l'ordinateur local. Il peut s'agir d'un chemin relatif, d'un chemin absolu ou d'un chemin contenant les références de variables d'environnement telles que `%PROGRAMDATA%`. Si le chemin est relatif, il l'est à l'emplacement où Kinesis Agent pour Windows est installé. Généralement, la valeur est `.\appsettings.json`. Cette paire clé-valeur est requise.
`AccessKey`
Spécifie la clé d'accès à utiliser lors de l'authentification de l'accès au fichier de configuration dans Amazon S3. La paire clé-valeur est facultative. Il est déconseillé d'utiliser cette paire clé-valeur. Pour obtenir les autres méthodes d'authentification recommandées, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`SecretKey`
Spécifie la clé secrète à utiliser lors de l'authentification de l'accès au fichier de configuration dans Amazon S3. La paire clé-valeur est facultative. Il est déconseillé d'utiliser cette paire clé-valeur. Pour obtenir les autres méthodes d'authentification recommandées, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication).
`Region`
Spécifie le point de terminaison de la région à utiliser lors de l'accès au fichier de configuration à partir d'Amazon S3. La paire clé-valeur est facultative.
`ProfileName`
Spécifie le profil de sécurité à utiliser lors de l'authentification de l'accès au fichier de configuration dans Amazon S3. Pour plus d'informations, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). La paire clé-valeur est facultative.
`RoleARN`
Spécifie le rôle à endosser lors de l'authentification de l'accès au fichier de configuration dans Amazon S3 dans au sein d'un scénario entre comptes. Pour plus d'informations, consultez [Configuration de l'authentification](sink-object-declarations.md#configuring-kinesis-agent-windows-authentication). La paire clé-valeur est facultative.
S'il n'est pas spécifié de plug-in `ConfigUpdate`, aucun fichier de configuration n'est vérifié pour déterminer si une mise à jour du fichier de configuration est requise.
L'exemple suivant présente un fichier de configuration `appsettings.json` qui illustre l'utilisation des plug-ins `PackageUpdate` et `ConfigUpdate`. Dans cet exemple, il existe un fichier de la version du package situé dans le`mycompany`Compartiment Amazon S3 nommé`config/agent-package-version.json`. Le fichier est vérifié en quête de modification éventuelle toutes les 2 heures environ. Si une autre version de Kinesis Agent pour Windows est mentionnée dans le fichier, la version de l'agent spécifiée est installée à partir de l'emplacement indiqué dans le fichier de la version du package.
De plus, il existe un`appsettings.json`stocké dans le fichier de configuration`mycompany`Compartiment Amazon S3 nommé`config/appsettings.json`. Environ toutes les 30 minutes, le fichier est comparé au fichier de configuration actuel. S'ils sont différents, le fichier de configuration mis à jour est téléchargé à partir d'Amazon S3 et installé à l'emplacement local standard pour le`appsettings.json`Fichier de configuration.
```
{
"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"
}
]
}
```
# Exemples de configuration de l'agent Kinesis pour Windows
La .`appsettings.json`est un document JSON qui vérifie la manière dont Amazon Kinesis Agent pour Microsoft Windows collecte les journaux, les événements et les métriques. Il vérifie également la manière dont Kinesis Agent for Windows transforme ces données et les diffuse vers différents services AWS. Pour plus d'informations sur les déclarations des sources, des récepteur et des canaux dans le fichier de configuration, consultez [Déclarations de sources](source-object-declarations.md), [Déclarations de récepteurs](sink-object-declarations.md) et [Déclarations de canal](pipe-object-declarations.md).
Les sections suivantes proposent des exemples de fichiers de configuration pour différents types de scénarios.
**Topics**
+ [Diffusion à partir de diverses sources vers les Kinesis Data Streams](#configuring-kaw-examples-sources)
+ [Diffusion à partir du journal des événements d'application Windows vers les récepteurs](#configuring-kaw-examples-sinks)
+ [Utilisation des canaux](#configuring-kaw-examples-pipes)
+ [Utilisation de plusieurs sources et canaux](#configuring-kaw-examples-multiple)
## Diffusion à partir de diverses sources vers les Kinesis Data Streams
L'exemple suivant`appsettings.json`Les fichiers de configuration illustrent les événements et les journaux de diffusion à partir de diverses sources vers Kinesis Data Streams et à partir des compteurs de performance Windows vers les métriques Amazon CloudWatch.
### `DirectorySource`, Analyseur d'enregistrement `SysLog`
Le fichier suivant diffuse les enregistrements des journaux au format syslog à partir de tous les fichiers avec`.log`extension de fichier dans le fichier`C:\LogSource\`Accédez au répertoire`SyslogKinesisDataStream`Diffusion Kinesis Data Streams dans la région us-east-1. Un signet est créé pour veiller à ce que toutes les données des fichiers journaux soient envoyées, même si l'agent est arrêté et redémarré ultérieurement. Une application personnalisée peut lire et traiter les enregistrements à partir du flux `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"
}
]
}
```
### `DirectorySource`, Analyseur d'enregistrement `SingleLineJson`
Le fichier suivant diffuse les enregistrements des journaux au format JSON à partir de tous les fichiers avec`.log`extension de fichier dans le fichier`C:\LogSource\`Accédez au répertoire`JsonKinesisDataStream`Diffusion Kinesis Data Streams dans la région us-east-1. Avant la diffusion, les paires clé-valeur des clés `ComputerName` et `DT` sont ajoutées à chaque objet JSON, avec les valeurs du nom de l'ordinateur et de la date et de l'heure auxquelles l'enregistrement est traité. Une application personnalisée peut lire et traiter les enregistrements à partir du flux `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`
Le fichier suivant diffuse les enregistrements des journaux générés par Microsoft Exchange et stockés dans des fichiers avec`.log`extension dans le fichier`C:\temp\ExchangeLog\`Accédez au répertoire`ExchangeKinesisDataStream`Flux de données Kinesis dans la région us-east-1 au format JSON. Bien que les journaux Exchange ne soient pas au format JSON, Kinesis Agent pour Windows peut les analyser et les convertir au format JSON. Avant la diffusion, les paires clé-valeur des clés `ComputerName` et `DT` sont ajoutées à chaque objet JSON contenant les valeurs du nom de l'ordinateur et de la date et de l'heure auxquelles l'enregistrement est traité. Une application personnalisée peut lire et traiter les enregistrements à partir du flux `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`
Le fichier suivant diffuse les enregistrements des journaux Internet Information Services (IIS) pour Windows stockés à l'emplacement standard de ces fichiers vers le répertoire`IISKinesisDataStream`Diffusion Kinesis Data Streams dans la région us-east-1. Une application personnalisée peut lire et traiter les enregistrements à partir du flux `IISKinesisDataStream`. IIS (Internet Information Services) est un serveur web pour 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` avec requête (Query)
Le fichier suivant transmet les événements du journal des événements système Windows qui ont un niveau de`Critical`ou`Error`(inférieurs ou égaux à 2) au`SystemKinesisDataStream`Flux de données Kinesis dans la région us-east-1 au format JSON. Une application personnalisée peut lire et traiter les enregistrements à partir du flux `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`
Le fichier suivant diffuse les événements de sécurité et d'exception Microsoft Common Language Runtime (CLR) vers le répertoire`ClrKinesisDataStream`Flux de données Kinesis dans la région us-east-1 au format JSON. Une application personnalisée peut lire et traiter les enregistrements à partir du flux `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`
Le fichier suivant diffuse les compteurs de performance relatifs au nombre total de fichiers ouverts, au nombre total de tentatives de connexion depuis le redémarrage, au nombre de lectures disque par seconde et au pourcentage d'espace disque disponible, vers les métriques CloudWatch de la région us-east-1. Vous pouvez représenter graphiquement ces métriques dans CloudWatch, créer des tableaux de bord à partir des graphiques et définir des alarmes qui envoient des notifications lorsque les seuils sont dépassés.
```
{
"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"
}
]
}
```
## Diffusion à partir du journal des événements d'application Windows vers les récepteurs
L'exemple suivant`appsettings.json`Les fichiers de configuration illustrent la diffusion de journaux d'événements d'application Windows vers différents récepteurs dans Amazon Kinesis Agent for Microsoft Windows. Pour obtenir des exemples d'utilisation des types de récepteur `KinesisStream` et `CloudWatch`, consultez [Diffusion à partir de diverses sources vers les Kinesis Data Streams](#configuring-kaw-examples-sources).
### `KinesisFirehose`
Les flux de fichiers suivants`Critical`ou`Error`Les événements du journal de l'application Windows dans le`WindowsLogFirehoseDeliveryStream`Diffusion Kinesis Data Firehose dans la région us-east-1. Si la connexion à Kinesis Data Firehose est interrompue, les événements sont d'abord mis en file d'attente en mémoire. Ensuite, si nécessaire, ils sont mis en file d'attente dans un fichier disque jusqu'à ce que la connexion soit rétablie. Enfin, les événements sont extraits de la file d'attente et envoyés, suivis par les nouveaux événements éventuels.
Vous pouvez configurer Kinesis Data Firehose pour stocker les données diffusées selon différents types de services de stockage et d'analyse en fonction des exigences des canaux de données.
```
{
"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`
Les flux de fichiers suivants`Critical`ou`Error`Journalisation des événements d'application Windows vers CloudWatch Logs diffuse les flux de diffusion de la page`MyServiceApplicationLog-Group`log group. Le nom de chaque flux commence par `Stream-`. Il se termine par l'année (quatre chiffres), le mois (deux chiffres) et le jour (deux chiffres) de création du flux ; toutes les valeurs sont concaténées (par exemple, `Stream-20180501` représente le flux créé le 1er mai 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"
}
]
}
```
## Utilisation des canaux
L'exemple suivant de fichier de configuration `appsettings.json` illustre l'utilisation des fonctions liées aux canaux.
Cet exemple diffuse les entrées des journaux à partir du fichier`c:\LogSource\`à la`ApplicationLogFirehoseDeliveryStream`Flux de diffusion Kinesis Data Firehose. Il inclut uniquement les lignes qui correspondent à l'expression régulière spécifiée par la paire clé-valeur `FilterPattern`. Plus précisément, seules les lignes du fichier journal qui commencent par`10`ou`11`sont diffusés vers 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),.*"
}
]
}
```
## Utilisation de plusieurs sources et canaux
L'exemple suivant de fichier de configuration `appsettings.json` illustre l'utilisation de plusieurs sources et canaux.
Cet exemple diffuse les journaux d'événements d'application, les journaux d'événements de sécurité et les journaux d'événements système Windows vers`EventLogStream`Diffusion Kinesis Data Firehose à l'aide de trois sources, de trois canaux et d'un seul récepteur.
```
{
"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"
}
]
}
```
# Configuration de la télémétrie
Pour assurer une meilleure prise en charge, Amazon Kinesis Agent pour Microsoft Windows collecte par défaut des statistiques sur le fonctionnement de l'agent et les envoie à AWS. Ces données ne comportent pas d'informations personnelles identifiables. Elles n'incluent aucune donnée collectée depuis les services AWS ou diffusée vers ces services. Nous recueillons environ 1 à 2 Ko de ces données métriques toutes les 60 minutes.
Vous pouvez choisir de désactiver la collecte et la transmission de ces statistiques. Pour cela, ajoutez la paire clé-valeur suivante au fichier de configuration `appsettings.json` au même niveau que les sources, récepteurs et canaux :
```
"Telemetrics":
{ "off": "true" }
```
Par exemple, le fichier de configuration suivant configure une source, un récepteur et un canal, et désactive également la télémétrie :
```
{
"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"
}
}
```
Nous collectons les métriques suivantes lorsque la télémétrie est activée :
`ClientId`
ID unique affecté automatiquement lorsque le logiciel est installé.
`ClientTimestamp`
Date et heure de collecte des données télémétriques.
`OSDescription`
Description du système d'exploitation.
`DotnetFramework`
Version de l'infrastructure dotnet actuelle.
`MemoryUsage`
Quantité de mémoire utilisée par Kinesis Agent pour Windows (en Mo).
`CPUUsage`
Quantité d'Kinesis C (pourcentage au format décimal). Par exemple, 0,01 équivaut à 1 %.
`InstanceId`
ID d'instance Amazon EC2 si Kinesis Agent pour Windows est exécuté sur une instance Amazon EC2.
`InstanceType (string)`
Type d'instance Amazon EC2 si Kinesis Agent pour Windows s'exécute sur une instance Amazon EC2.
En outre, nous collectons les métriques indiquées dans [Liste des mesures Kinesis Agent pour Windows](source-object-declarations.md#kinesis-agent-metric-list).