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.
# Configurer l'agent Kinesis pour envoyer des données
L'agent Amazon Kinesis est une application logicielle Java autonome qui sert d'implémentation de référence pour montrer comment collecter et envoyer des données à Firehose. L'agent surveille en permanence un ensemble de fichiers et envoie de nouvelles données à votre flux Firehose. L'agent montre comment vous pouvez gérer la rotation des fichiers, les points de contrôle et réessayer en cas d'échec. Il montre comment vous pouvez fournir vos données de manière fiable, rapide et simple. Il montre également comment vous pouvez émettre CloudWatch des métriques pour mieux surveiller et résoudre les problèmes liés au processus de streaming. Pour en savoir plus, [awslabs/ amazon-kinesis-agent](https://github.com/awslabs/amazon-kinesis-agent).
Par défaut, les enregistrements sont analysés à partir de chaque fichier sur la base du caractère de saut de ligne (`'\n'`). Toutefois, l'agent peut également être configuré pour analyser les enregistrements de plusieurs lignes (consultez [Spécifier les paramètres de configuration de l'agent](agent-config-settings.md)).
Cet agent peut être installé dans des environnements basés sur des serveurs Linux tels que des serveurs Web, serveurs de journaux ou encore serveurs de base de données. Après avoir installé l'agent, configurez-le en spécifiant les fichiers à surveiller et le flux Firehose pour les données. Une fois l'agent configuré, il collecte de manière durable les données des fichiers et les envoie de manière fiable au flux Firehose.
## Conditions préalables
Avant de commencer à utiliser Kinesis Agent, assurez-vous de remplir les conditions préalables suivantes.
+ Votre système d'exploitation doit être Amazon Linux ou Red Hat Enterprise Linux version 7 ou ultérieure.
+ La version 2.0.0 ou ultérieure de l'agent s'exécute à l'aide de la version 1.8 ou ultérieure de JRE. La version 1.1.x de l'agent s'exécute à l'aide de la version 1.7 ou ultérieure de JRE.
+ Si vous utilisez Amazon EC2 pour exécuter votre agent, lancez votre instance EC2.
+ Le rôle ou les AWS informations d'identification IAM que vous spécifiez doivent être autorisés à effectuer l'opération Amazon Data [PutRecordBatch](https://docs.aws.amazon.com/firehose/latest/APIReference/API_PutRecordBatch.html)Firehose pour que l'agent envoie des données à votre flux Firehose. Si vous activez la CloudWatch surveillance pour l'agent, l'autorisation d'effectuer l' CloudWatch [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)opération est également nécessaire. Pour plus d'informations, consultez [Contrôler l'accès avec Amazon Data Firehose](controlling-access.md)[Surveiller l'état de santé de l'agent Kinesis](agent-health.md), et [Authentification et contrôle d'accès pour Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/auth-and-access-control-cw.html).
# Gérer les AWS informations d'identification
Gérez vos AWS informations d'identification à l'aide de l'une des méthodes suivantes :
+ Créez un fournisseur d'informations d'identification personnalisé. Pour en savoir plus, consultez [Créez des fournisseurs d'informations d'identification personnalisés](custom-cred-provider.md).
+ Spécifiez un rôle IAM lorsque vous lancez votre instance EC2.
+ Spécifiez les AWS informations d'identification lorsque vous configurez l'agent (voir les entrées pour `awsAccessKeyId` et `awsSecretAccessKey` dans le tableau de configuration ci-dessous[Spécifier les paramètres de configuration de l'agent](agent-config-settings.md)).
+ Modifiez `/etc/sysconfig/aws-kinesis-agent` pour spécifier votre AWS région et vos clés AWS d'accès.
+ Si votre instance EC2 se trouve sur un autre AWS compte, créez un rôle IAM pour accéder au service Amazon Data Firehose. [Spécifiez ce rôle lorsque vous configurez l'agent (voir [AssumeRoLearn](agent-config-settings.md#assumeRoleARN) et IdassumeRoleExternal).](agent-config-settings.md#assumeRoleExternalId) Utilisez l'une des méthodes précédentes pour spécifier les AWS informations d'identification d'un utilisateur de l'autre compte autorisé à assumer ce rôle.
# Créez des fournisseurs d'informations d'identification personnalisés
Vous pouvez créer un fournisseur d'informations d'identification personnalisées et donner son nom de classe et son chemin d'accès jar à l'agent Kinesis dans les paramètres de configuration suivants : `userDefinedCredentialsProvider.classname` et `userDefinedCredentialsProvider.location`. Pour obtenir la description de ces deux paramètres de configuration, veuillez consulter [Spécifier les paramètres de configuration de l'agent](agent-config-settings.md).
Pour créer un fournisseur d'informations d'identification personnalisé, définissez une classe qui implémente l'interface `AWS CredentialsProvider`, comme celle de l'exemple suivant.
```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
public class YourClassName implements AWSCredentialsProvider {
public YourClassName() {
}
public AWSCredentials getCredentials() {
return new BasicAWSCredentials("key1", "key2");
}
public void refresh() {
}
}
```
Votre classe doit avoir un constructeur qui ne prend aucun argument.
AWS invoque régulièrement la méthode d'actualisation pour obtenir des informations d'identification mises à jour. Si vous souhaitez que votre fournisseur d'informations d'identification fournisse différentes informations d'identification tout au long de sa durée de vie, incluez le code pour actualiser les informations d'identification dans cette méthode. Vous pouvez également laisser cette méthode vide si vous voulez un fournisseur d'informations d'identification qui vend des informations d'identification statiques (non modifiées).
# Téléchargez et installez l'agent
Commencez par vous connecter à votre instance. Pour plus d'informations, consultez [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) dans le guide de l'*utilisateur Amazon EC2*. Si vous rencontrez des difficultés pour vous connecter, consultez la section [Résolution des problèmes liés à la connexion à votre instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) dans le *guide de l'utilisateur Amazon EC2*.
Ensuite, installez l'agent à l'aide d'une des méthodes suivantes.
+ **Pour configurer l'agent à partir des référentiels Amazon Linux**
Cette méthode fonctionne uniquement pour les instances Amazon Linux. Utilisez la commande suivante :
```
sudo yum install –y aws-kinesis-agent
```
L'agent v 2.0.0 ou version ultérieure est installé sur les ordinateurs dotés du système d'exploitation Amazon Linux 2 (AL2). Cette version de l'agent nécessite Java version 1.8 ou ultérieure. Si la version Java requise n'est pas encore présente, le processus d'installation de l'agent l'installe. Pour plus d'informations concernant Amazon Linux 2, consultez [https://aws.amazon.com/amazon-linux-2/](https://aws.amazon.com/amazon-linux-2/).
+ **Pour configurer l'agent à partir d'un référentiel Amazon S3**
Cette méthode fonctionne pour Red Hat Enterprise Linux, ainsi que pour les instances Amazon Linux 2, car elle installe l'agent à partir du référentiel accessible au public. Utilisez la commande suivante pour télécharger et installer la dernière version de la version 2.x.x de l'agent :
```
sudo yum install –y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-latest.amzn2.noarch.rpm
```
Pour installer une version spécifique de l'agent, spécifiez le numéro de version dans la commande. Par exemple, la commande suivante installe la version 2.0.1 de l'agent.
```
sudo yum install –y https://streaming-data-agent.s3.amazonaws.com/aws-kinesis-agent-2.0.1-1.amzn1.noarch.rpm
```
Si vous utilisez Java 1.7 et que vous ne souhaitez pas le mettre à niveau, vous pouvez télécharger la version 1.x.x de l'agent, qui est compatible avec Java 1.7. Par exemple, pour télécharger la version 1.1.6 de l'agent, vous pouvez utiliser la commande suivante :
```
sudo yum install –y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-1.1.6-1.amzn1.noarch.rpm
```
Vous pouvez télécharger le dernier agent à l'aide de la commande suivante
```
sudo yum install -y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-latest.amzn2.noarch.rpm
```
+ **Pour configurer l'agent à partir du GitHub dépôt**
1. Tout d'abord, assurez-vous que la version de Java requise est installée, en fonction de la version de l'agent.
1. Téléchargez l'agent depuis le dépôt [awslabs/ amazon-kinesis-agent](https://github.com/awslabs/amazon-kinesis-agent) GitHub .
1. Installez l'agent en accédant au répertoire de téléchargement et en exécutant la commande suivante :
```
sudo ./setup --install
```
+
**Configuration de l'agent dans un conteneur Docker**
L'agent Kinesis peut également être exécuté dans un conteneur via la base de conteneurs [amazonlinux](https://docs.aws.amazon.com/AmazonECR/latest/userguide/amazon_linux_container_image.html). Utilisez le Dockerfile suivant, puis exécutez `docker build`.
```
FROM amazonlinux
RUN yum install -y aws-kinesis-agent which findutils
COPY agent.json /etc/aws-kinesis/agent.json
CMD ["start-aws-kinesis-agent"]
```
# Configuration et démarrage de l'agent
**Pour configurer et démarrer l'agent**
1. Ouvrez le fichier de configuration et modifiez-le (en tant que super-utilisateur si vous utilisez les autorisations d'accès fichier par défaut) :`/etc/aws-kinesis/agent.json`
Dans ce fichier de configuration, spécifiez les fichiers (`"filePattern"`) à partir desquels l'agent collecte les données, ainsi que le nom du flux Firehose (`"deliveryStream"`) auquel l'agent envoie les données. Le nom de fichier est un modèle et l'agent reconnaît les rotations de fichier. Vous pouvez effectuer une rotation de fichier ou créer de nouveaux fichiers pas plus d'une fois par seconde. L'agent utilise l'horodatage de création des fichiers pour déterminer les fichiers à suivre et à intégrer dans votre flux Firehose. La création de fichiers ou la rotation de fichiers plus d'une fois par seconde ne permet pas à l'agent de différencier correctement les fichiers.
```
{
"flows": [
{
"filePattern": "/tmp/app.log*",
"deliveryStream": "yourdeliverystream"
}
]
}
```
La AWS région par défaut est`us-east-1`. Si vous utilisez une autre région, ajoutez le paramètre `firehose.endpoint` au fichier de configuration, en spécifiant le point de terminaison de votre région. Pour de plus amples informations, veuillez consulter [Spécifier les paramètres de configuration de l'agent](agent-config-settings.md).
1. Démarrez l'agent manuellement :
```
sudo service aws-kinesis-agent start
```
1. (Facultatif) Configurez l'agent pour qu'il soit lancé au démarrage du système :
```
sudo chkconfig aws-kinesis-agent on
```
L'agent fonctionne maintenant en arrière-plan en tant que service système. Il surveille en permanence les fichiers spécifiés et envoie des données au flux Firehose spécifié. L'activité de l'agent est enregistrée dans `/var/log/aws-kinesis-agent/aws-kinesis-agent.log`.
# Spécifier les paramètres de configuration de l'agent
L'agent prend en charge les deux paramètres de configuration obligatoires `filePattern` et `deliveryStream`, plus les paramètres de configuration facultatifs des fonctionnalités supplémentaires. Vous pouvez spécifier aussi bien des paramètres de configuration obligatoires que facultatifs dans `/etc/aws-kinesis/agent.json`.
Chaque fois que vous modifiez le fichier de configuration, vous devez arrêter et démarrer l'agent en utilisant les commandes suivantes :
```
sudo service aws-kinesis-agent stop
sudo service aws-kinesis-agent start
```
Vous pouvez également utiliser la commande suivante :
```
sudo service aws-kinesis-agent restart
```
Les paramètres de configuration générale sont indiqués ci-après.
| Paramètre de configuration | Description |
| --- | --- |
| assumeRoleARN | L'ARN (Amazon Resource Name) du rôle que l'utilisateur doit assumer. Pour plus d'informations, consultez la section [Accès délégué entre AWS comptes à l'aide de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) dans le guide de l'*utilisateur IAM*. |
| assumeRoleExternalId | Identifiant facultatif qui détermine qui peut assumer le rôle. Pour en savoir plus, consultez la rubrique [Procédure d'utilisation d'un ID externe](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) dans le *Guide de l'utilisateur IAM*. |
| awsAccessKeyId | AWS ID de clé d'accès qui remplace les informations d'identification par défaut. Ce paramètre est prioritaire sur tous les autres fournisseurs d'informations d'identification. |
| awsSecretAccessKey | AWS clé secrète qui remplace les informations d'identification par défaut. Ce paramètre est prioritaire sur tous les autres fournisseurs d'informations d'identification. |
| cloudwatch.emitMetrics | Permet à l'agent d'émettre des métriques CloudWatch s'il est défini (true). Valeur par défaut : true |
| cloudwatch.endpoint | Le point de terminaison régional pour CloudWatch. Valeur par défaut : `monitoring.us-east-1.amazonaws.com` |
| firehose.endpoint | Point de terminaison régional pour Amazon Data Firehose. Valeur par défaut : `firehose.us-east-1.amazonaws.com` |
| sts.endpoint | Point de terminaison régional pour le service AWS de jetons de sécurité. Valeur par défaut : `https://sts.amazonaws.com` |
| userDefinedCredentialsProvider.classname | Si vous définissez un fournisseur d'informations d'identification personnalisées, indiquez son nom de classe complet à l'aide de ce paramètre. N'ajoutez pas .class à la fin du nom de la classe. |
| userDefinedCredentialsProvider.location | Si vous définissez un fournisseur d'informations d'identification personnalisées, utilisez ce paramètre pour spécifier le chemin absolu du fichier jar contenant le fournisseur d'informations d'identification personnalisées. L'agent recherche également le fichier jar à l'emplacement suivant : /usr/share/aws-kinesis-agent/lib/. |
Les paramètres de configuration de flux sont indiqués ci-après.
| Paramètre de configuration | Description |
| --- | --- |
| aggregatedRecordSizeBytes | Pour que l'agent agrège les enregistrements puis les place dans le flux Firehose en une seule opération, spécifiez ce paramètre. Réglez-le à la taille que vous souhaitez attribuer à l'enregistrement agrégé avant que l'agent ne le place dans le flux Firehose. Par défaut : 0 (pas de regroupement) |
| dataProcessingOptions | La liste des options de traitement appliquées à chaque enregistrement analysé avant son envoi au flux Firehose. Les options de traitement sont exécutées dans l'ordre spécifié. Pour de plus amples informations, veuillez consulter [Pré-traiter les données avec des agents](pre-processing.md). |
| deliveryStream | [Obligatoire] Nom du stream Firehose. |
| filePattern | [Obligatoire] Modèle global des fichiers qui doivent être surveillés par l'agent. N'importe quel fichier qui correspond à ce modèle est collecté automatiquement par l'agent et surveillé. Pour tous les fichiers correspondant à ce modèle, accordez l'autorisation de lecture à `aws-kinesis-agent-user`. Pour l’annuaire contenant les fichiers, accordez les autorisations de lecture et d'exécution à `aws-kinesis-agent-user`. L'agent récupère tous les fichiers correspondant à ce modèle. Pour vous assurer que l'agent ne récupère pas d’autres enregistrements que ceux prévus à cet effet, choisissez soigneusement ce modèle. |
| initialPosition | Position initiale à partir de laquelle le fichier a commencé à être analysé. Les valeurs valides sont `START_OF_FILE` et `END_OF_FILE`. Valeur par défaut : `END_OF_FILE` |
| maxBufferAgeMillis | Durée maximale, en millisecondes, pendant laquelle l'agent met les données en mémoire tampon avant de les envoyer au flux Firehose. Plage de valeurs : 1 000 à 900 000 (1 seconde à 15 minutes) Par défaut : 60 000 (1 minute) |
| maxBufferSizeBytes | Taille maximale, en octets, pour laquelle l'agent met en mémoire tampon les données avant de les envoyer au flux Firehose. Plage de valeurs : 1 à 4 194 304 (4 Mo) Par défaut : 4 194 304 (4 Mo) |
| maxBufferSizeRecords | Le nombre maximum d'enregistrements pour lesquels l'agent met les données en mémoire tampon avant de les envoyer au flux Firehose. Plage de valeurs : 1 à 500 Par défaut : 500 |
| minTimeBetweenFilePollsMillis | Fréquence, en millisecondes, à laquelle l'agent interroge et analyse les fichiers surveillés pour rechercher les nouvelles données. Plage de valeurs : 1 ou plus Par défaut : 100 |
| multiLineStartPattern | Modèle d'identification du début d'un enregistrement. Un enregistrement se compose d'une ligne qui correspond au modèle et de lignes suivantes qui ne correspondent pas au modèle. Les valeurs valides sont les expressions régulières. Par défaut, chaque nouvelle ligne comprise dans les fichiers journaux est analysée comme étant un enregistrement. |
| skipHeaderLines | Nombre de lignes que l'agent doit ignorer lors de l'analyse au début des fichiers surveillés. Plage de valeurs : 0 ou plus Par défaut : 0 (zéro) |
| truncatedRecordTerminator | Chaîne utilisée par l'agent pour tronquer un enregistrement analysé lorsque la taille de l'enregistrement dépasse la limite de taille d'enregistrement d'Amazon Data Firehose. (1,000 Ko) Par défaut : `'\n'` (nouvelle ligne) |
# Configuration de plusieurs répertoires de fichiers et de flux
En spécifiant plusieurs paramètres de configuration de flux, vous pouvez configurer l'agent pour surveiller plusieurs répertoires de fichiers et envoyer des données dans plusieurs flux. Dans l'exemple de configuration suivant, l'agent surveille deux répertoires de fichiers et envoie des données à un flux de données Kinesis et à un flux Firehose respectivement. Vous pouvez spécifier différents points de terminaison pour Kinesis Data Streams et Amazon Data Firehose afin que votre flux de données et votre flux Firehose n'aient pas besoin de se trouver dans la même région.
```
{
"cloudwatch.emitMetrics": true,
"kinesis.endpoint": "https://your/kinesis/endpoint",
"firehose.endpoint": "https://your/firehose/endpoint",
"flows": [
{
"filePattern": "/tmp/app1.log*",
"kinesisStream": "yourkinesisstream"
},
{
"filePattern": "/tmp/app2.log*",
"deliveryStream": "yourfirehosedeliverystream"
}
]
}
```
Pour plus d'informations sur l'utilisation de l'agent avec Amazon Kinesis Data Streams, consultez [Writing to Amazon Kinesis Data Streams with Kinesis Agent](https://docs.aws.amazon.com/kinesis/latest/dev/writing-with-agents.html).
# Pré-traiter les données avec des agents
L'agent peut prétraiter les enregistrements analysés à partir des fichiers surveillés avant de les envoyer à votre flux Firehose. Vous pouvez activer cette fonctionnalité en ajoutant le paramètre de configuration `dataProcessingOptions` à votre flux de fichiers. Une ou plusieurs options de traitement peuvent être ajoutées. Elles sont exécutées dans l'ordre spécifié.
L'agent prend en charge les options de traitement suivantes. Comme l'agent est open source, vous pouvez continuer à développer et étendre ses options de traitement. Vous pouvez télécharger l'agent depuis [Kinesis Agent](https://github.com/awslabs/amazon-kinesis-agent).Options de traitement
`SINGLELINE`
Convertit un enregistrement de plusieurs lignes en un enregistrement d'une seule ligne en supprimant les caractères de saut de ligne, les espaces de début et les espaces de fin.
```
{
"optionName": "SINGLELINE"
}
```
`CSVTOJSON`
Convertit un enregistrement du format séparé par délimiteur au format JSON.
```
{
"optionName": "CSVTOJSON",
"customFieldNames": [ "field1", "field2", ... ],
"delimiter": "yourdelimiter"
}
```
`customFieldNames`
[Obligatoire] Noms de domaine utilisés comme clés dans chaque paire clé-valeur JSON. Par exemple, si vous spécifiez `["f1", "f2"]`, l'enregistrement « v1, v2 » est converti en `{"f1":"v1","f2":"v2"}`.
`delimiter`
Chaîne utilisée comme délimiteur dans l'enregistrement. La valeur par défaut est une virgule (,).
`LOGTOJSON`
Convertit un enregistrement du format de journal au format JSON. Les formats de journal pris en charge sont **Apache Common Log**, **Apache Combined Log**, **Apache Error Log** et **RFC3164 Syslog**.
```
{
"optionName": "LOGTOJSON",
"logFormat": "logformat",
"matchPattern": "yourregexpattern",
"customFieldNames": [ "field1", "field2", … ]
}
```
`logFormat`
[Obligatoire] Format d'entrée de journal. Les valeurs admises sont les suivantes :
+ `COMMONAPACHELOG` : le format de journal courant d'Apache. Chaque entrée de journal a le schéma suivant par défaut : « `%{host} %{ident} %{authuser} [%{datetime}] \"%{request}\" %{response} %{bytes}` ».
+ `COMBINEDAPACHELOG` : le format de journal combiné d'Apache. Chaque entrée de journal a le schéma suivant par défaut : « `%{host} %{ident} %{authuser} [%{datetime}] \"%{request}\" %{response} %{bytes} %{referrer} %{agent}` ».
+ `APACHEERRORLOG` : le format de journal d'erreurs d'Apache. Chaque entrée de journal a le schéma suivant par défaut : « `[%{timestamp}] [%{module}:%{severity}] [pid %{processid}:tid %{threadid}] [client: %{client}] %{message}` ».
+ `SYSLOG`— Le format RFC3164 Syslog. Chaque entrée de journal a le schéma suivant par défaut : « `%{timestamp} %{hostname} %{program}[%{processid}]: %{message}` ».
`matchPattern`
Remplace le modèle par défaut pour le format de journal spécifié. Utilisez ce paramètre pour extraire les valeurs des entrées du journal si elles utilisent un format personnalisé. Si vous spécifiez `matchPattern`, vous devez également spécifier `customFieldNames`.
`customFieldNames`
Noms de champ personnalisés utilisés comme clés dans chaque paire clé-valeur JSON. Vous pouvez utiliser ce paramètre pour définir les noms de champ pour les valeurs extraites de `matchPattern`, ou remplacer les noms de champ par défaut des formats de journalisation prédéfinis.
**Example : Configuration LOGTOJSON**
Voici un exemple de configuration `LOGTOJSON` pour une entrée au format Journal courant Apache convertie au format JSON :
```
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG"
}
```
Avant la conversion :
```
64.242.88.10 - - [07/Mar/2004:16:10:02 -0800] "GET /mailman/listinfo/hsdivision HTTP/1.1" 200 6291
```
Après la conversion :
```
{"host":"64.242.88.10","ident":null,"authuser":null,"datetime":"07/Mar/2004:16:10:02 -0800","request":"GET /mailman/listinfo/hsdivision HTTP/1.1","response":"200","bytes":"6291"}
```
**Example : Configuration LOGTOJSON avec champs personnalisés**
Voici un autre exemple de configuration `LOGTOJSON` :
```
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG",
"customFieldNames": ["f1", "f2", "f3", "f4", "f5", "f6", "f7"]
}
```
Avec ce paramètre de configuration, la même entrée au format Journal courant Apache de journal issue de l'exemple précédent est convertie au format JSON comme suit :
```
{"f1":"64.242.88.10","f2":null,"f3":null,"f4":"07/Mar/2004:16:10:02 -0800","f5":"GET /mailman/listinfo/hsdivision HTTP/1.1","f6":"200","f7":"6291"}
```
**Example : Conversion d'une entrée au format Journal courant Apache**
La configuration de flux suivante convertit une entrée au format Journal courant Apache en un enregistrement d'une seule ligne au format JSON :
```
{
"flows": [
{
"filePattern": "/tmp/app.log*",
"deliveryStream": "my-delivery-stream",
"dataProcessingOptions": [
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG"
}
]
}
]
}
```
**Example : Conversion des enregistrements de plusieurs lignes**
La configuration de flux suivante analyse les enregistrements de plusieurs lignes dont la première ligne commence par « `[SEQUENCE=` ». Chaque enregistrement est d'abord converti en un enregistrement d'une seule ligne. Les valeurs sont ensuite extraites de l'enregistrement sur la base d'un séparateur tabulation. Les valeurs extraites sont mappées à des valeurs `customFieldNames` spécifiées pour former un enregistrement d'une seule ligne au format JSON.
```
{
"flows": [
{
"filePattern": "/tmp/app.log*",
"deliveryStream": "my-delivery-stream",
"multiLineStartPattern": "\\[SEQUENCE=",
"dataProcessingOptions": [
{
"optionName": "SINGLELINE"
},
{
"optionName": "CSVTOJSON",
"customFieldNames": [ "field1", "field2", "field3" ],
"delimiter": "\\t"
}
]
}
]
}
```
**Example : Configuration LOGTOJSON avec modèle de correspondance**
Voici un exemple de configuration `LOGTOJSON` pour une entrée au format Journal courant Apache convertie au format JSON, avec le dernier champ (octets) omis :
```
{
"optionName": "LOGTOJSON",
"logFormat": "COMMONAPACHELOG",
"matchPattern": "^([\\d.]+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4})\\] \"(.+?)\" (\\d{3})",
"customFieldNames": ["host", "ident", "authuser", "datetime", "request", "response"]
}
```
Avant la conversion :
```
123.45.67.89 - - [27/Oct/2000:09:27:09 -0400] "GET /java/javaResources.html HTTP/1.0" 200
```
Après la conversion :
```
{"host":"123.45.67.89","ident":null,"authuser":null,"datetime":"27/Oct/2000:09:27:09 -0400","request":"GET /java/javaResources.html HTTP/1.0","response":"200"}
```
# Utiliser les commandes courantes de l'Agent CLI
Le tableau suivant présente un ensemble de cas d'utilisation courants et les commandes correspondantes pour travailler avec l'agent AWS Kinesis.
| Cas d’utilisation | Commande |
| --- | --- |
| Démarrage automatique de l'agent au démarrage du système | sudo chkconfig aws-kinesis-agent on
|
| Vérifiez le statut de l'agent | sudo service aws-kinesis-agent status
|
| Arrêtez l'agent | sudo service aws-kinesis-agent stop
|
| Lire le fichier journal de l'agent à partir de cet emplacement | /var/log/aws-kinesis-agent/aws-kinesis-agent.log
|
| Désinstallez l'agent | sudo yum remove aws-kinesis-agent
|
# Résoudre les problèmes liés à l'envoi depuis Kinesis Agent
Ce tableau fournit des informations de dépannage et des solutions aux problèmes courants rencontrés lors de l'utilisation de l'agent Amazon Kinesis.
| Problème | Solution |
| --- | --- |
| Pourquoi Kinesis Agent ne fonctionne-t-il pas sous Windows ? | [Kinesis Agent pour Windows](https://docs.aws.amazon.com/kinesis-agent-windows/latest/userguide/what-is-kinesis-agent-windows.html) est un logiciel différent de Kinesis Agent pour les plateformes Linux. |
| Pourquoi Kinesis Agent ralentit-il ou RecordSendErrors augmente-t-il ? | Cela est généralement dû à une limitation de Kinesis. Vérifiez la `WriteProvisionedThroughputExceeded` métrique pour Kinesis Data Streams ou `ThrottledRecords` la métrique pour les flux Firehose. Toute augmentation de ces métriques par rapport à 0 indique que les limites de flux doivent être augmentées. [Pour plus d'informations, consultez les sections [Limites de Kinesis Data Stream](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html) et Firehose Streams.](https://docs.aws.amazon.com/firehose/latest/dev/limits.html) Une fois que vous avez exclu la limitation, vérifiez si Kinesis Agent est configuré pour suivre un grand nombre de petits fichiers. Il y a un délai lorsque Kinesis Agent suit un nouveau fichier, c'est pourquoi Kinesis Agent doit suivre un petit nombre de fichiers plus volumineux. Essayez de regrouper vos fichiers journaux dans des fichiers plus volumineux. |
| Comment résoudre les java.lang.OutOfMemoryError exceptions ? | Cela se produit lorsque Kinesis Agent ne dispose pas de suffisamment de mémoire pour gérer sa charge de travail actuelle. Essayez d'augmenter JAVA\$1START\$1HEAP et JAVA\$1MAX\$1HEAP dans /usr/bin/start-aws-kinesis-agent et de redémarrer l'agent. |
| Comment résoudre les IllegalStateException : connection pool shut down exceptions ? | Kinesis Agent ne dispose pas de suffisamment de connexions pour gérer sa charge de travail actuelle. Essayez d'augmenter maxConnections et maxSendingThreads dans les paramètres de configuration de votre agent général à /etc/aws-kinesis/agent.json. La valeur par défaut de ces champs est 12 fois supérieure au nombre de processeurs d'exécution disponibles. Consultez [AgentConfiguration.java](https://github.com/awslabs/amazon-kinesis-agent/blob/master/src/com/amazon/kinesis/streaming/agent/config/AgentConfiguration.java) pour en savoir plus sur les paramètres de configuration avancés des agents. |
| Comment puis-je déboguer un autre problème avec Kinesis Agent ? | Les journaux de niveau DEBUG peuvent être activés dans /etc/aws-kinesis/log4j.xml. |
| Comment dois-je configurer Kinesis Agent ? | Plus la taille de maxBufferSizeBytes est petite, plus Kinesis Agent envoie fréquemment des données. Cela peut être une bonne chose, car cela réduit le délai de livraison des enregistrements, mais cela augmente également le nombre de requêtes par seconde adressées à Kinesis. |
| Pourquoi Kinesis Agent envoie-t-il des enregistrements dupliqués ? | Cela se produit en raison d'une mauvaise configuration dans le suivi des fichiers. Assurez-vous que chaque fileFlow’s filePattern ne correspond qu'à un seul fichier. Cela peut également se produire si le mode logrotate utilisé est en mode copytruncate. Essayez de remplacer le mode par défaut ou de créer le mode pour éviter les doublons. Pour plus d'informations sur la gestion des enregistrements dupliqués, consultez la rubrique [Gestion des enregistrements dupliqués](https://docs.aws.amazon.com/streams/latest/dev/kinesis-record-processor-duplicates.html) (français non garanti). |