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.
Filtres d'abonnement au niveau des groupes de journaux
Vous pouvez utiliser un filtre d'abonnement avec Amazon Kinesis Data Streams, AWS Lambda, ou Amazon Data Firehose. Les journaux envoyés à un service via un filtre d'abonnement sont codés en base64 et compressés au format gzip. Cette section fournit des exemples que vous pouvez suivre pour créer un filtre d'abonnement aux CloudWatch journaux qui envoie les données des journaux à Firehose, Lambda et Kinesis Data Streams.
Note
Si vous souhaitez effectuer une recherche dans les données de votre journal, consultez la section Syntaxe des filtres et des modèles.
Exemples
Exemple 1 : filtres d'abonnement avec Kinesis Data Streams
L'exemple suivant associe un filtre d'abonnement à un groupe de journaux contenant AWS CloudTrail événements. Le filtre d'abonnement affiche toutes les activités enregistrées par « Root » AWS informations d'identification pour un flux dans Kinesis Data Streams appelé RootAccess « ». Pour plus d'informations sur la façon d'envoyer AWS CloudTrail événements vers CloudWatch des journaux, voir Envoyer CloudTrail des événements vers CloudWatch des journaux dans le AWS CloudTrail Guide de l'utilisateur
Note
Avant de créer le flux , calculez le volume de données de journaux qui sera généré. Assurez-vous de créer un flux avec suffisamment de partitions pour gérer le volume. Si le flux n'a pas suffisamment de partitions, le flux de journaux sera limité. Pour plus d'informations sur les limites de volume de flux, consultez Quotas et limites (français non garanti).
Les livrables limités sont réessayés pendant 24 heures au maximum. Au bout de 24 heures, les livrables ayant échoué sont supprimés.
Pour réduire le risque de limitation, procédez comme suit :
-
Spécifiez
random
ledistribution
moment où vous créez le filtre d'abonnement avec PutSubscriptionFilterou put-subscription-filter. Par défaut, la distribution du filtre de flux se fait par flux de log, ce qui peut entraîner un ralentissement. -
Surveillez votre stream à l'aide de CloudWatch métriques. Cela vous permet d'identifier toute limitation et d'ajuster votre configuration en conséquence. Par exemple, la
DeliveryThrottling
métrique peut être utilisée pour suivre le nombre d'événements de journal pour lesquels CloudWatch Logs a été limité lors du transfert des données vers la destination de l'abonnement. Pour de plus amples informations sur la surveillance, veuillez consulter Surveillance à l'aide de CloudWatch métriques. -
Utilisez le mode de capacité à la demande pour votre flux dans Kinesis Data Streams. Le mode de capacité à la demande s'adapte instantanément à vos charges de travail à mesure qu'elles augmentent ou diminuent. Pour plus d'informations sur le mode de capacité à la demande, consultez Mode de capacité à la demande.
-
Limitez votre modèle de filtre CloudWatch d'abonnement pour qu'il corresponde à la capacité de votre flux dans Kinesis Data Streams. Si vous envoyez trop de données dans le flux, il se peut que vous deviez réduire la taille du filtre ou ajuster les critères de filtrage.
Pour créer un filtre d'abonnement pour Kinesis Data Streams
-
Créez un flux de destination à l'aide de la commande suivante :
$
C:\>
aws kinesis create-stream --stream-name "RootAccess" --shard-count 1 -
Attendez que le flux devienne actif (cela peut prendre une minute ou deux). Vous pouvez utiliser la commande Kinesis Data Streams describe-stream suivante pour vérifier le. StreamDescription StreamStatuspropriété. Notez également la ARN valeur StreamDescription.Stream, car vous en aurez besoin ultérieurement :
aws kinesis describe-stream --stream-name "RootAccess"
Voici un exemple de sortie :
{ "StreamDescription": { "StreamStatus": "ACTIVE", "StreamName": "RootAccess", "StreamARN": "arn:aws:kinesis:us-east-1:123456789012:stream/RootAccess", "Shards": [ { "ShardId": "shardId-000000000000", "HashKeyRange": { "EndingHashKey": "340282366920938463463374607431768211455", "StartingHashKey": "0" }, "SequenceNumberRange": { "StartingSequenceNumber": "49551135218688818456679503831981458784591352702181572610" } } ] } }
-
Créez le IAM rôle qui autorisera CloudWatch Logs à insérer des données dans votre flux. Vous devrez tout d'abord créer une stratégie d'approbation dans un fichier (par exemple,
~/TrustPolicyForCWL-Kinesis.json
). Utilisez un éditeur de texte créer cette stratégie. N'utilisez pas la IAM console pour le créer.Cette politique comprend une clé de contexte de condition
aws:SourceArn
globale pour aider à prévenir le problème de sécurité du député confus. Pour de plus amples informations, veuillez consulter Prévention du député confus.{ "Statement": { "Effect": "Allow", "Principal": { "Service": "logs.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringLike": { "aws:SourceArn": "arn:aws:logs:
region
:123456789012
:*" } } } } -
Utilisez la commande create-role pour créer le IAM rôle, en spécifiant le fichier de politique de confiance. Notez la valeur retournée de Role.Arn, car vous en aurez aussi besoin ultérieurement :
aws iam create-role --role-name
CWLtoKinesisRole
--assume-role-policy-document file://~/TrustPolicyForCWL-Kinesis.json
Voici un exemple de la sortie.
{ "Role": { "AssumeRolePolicyDocument": { "Statement": { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": "logs.amazonaws.com" }, "Condition": { "StringLike": { "aws:SourceArn": { "arn:aws:logs:
region
:123456789012
:*" } } } } }, "RoleId": "AAOIIAH450GAB4HC5F431", "CreateDate": "2015-05-29T13:46:29.431Z", "RoleName": "CWLtoKinesisRole", "Path": "/", "Arn": "arn:aws:iam::123456789012
:role/CWLtoKinesisRole" } } -
Créez une politique d'autorisation pour définir les actions que CloudWatch Logs peut effectuer sur votre compte. Vous allez tout d'abord créer une stratégie d'autorisations dans un fichier (par exemple,
~/PermissionsForCWL-Kinesis.json
). Utilisez un éditeur de texte créer cette stratégie. N'utilisez pas la IAM console pour le créer.{ "Statement": [ { "Effect": "Allow", "Action": "kinesis:PutRecord", "Resource": "arn:aws:kinesis:
region
:123456789012
:stream/RootAccess" } ] } -
Associez la politique d'autorisations au rôle à l'aide de la put-role-policycommande suivante :
aws iam put-role-policy --role-name
CWLtoKinesisRole
--policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL-Kinesis.json
-
Une fois que le flux est en état actif et que vous avez créé le IAM rôle, vous pouvez créer le filtre d'abonnement CloudWatch Logs. Le filtre d'abonnement lance immédiatement la transmission de données de journaux en temps réel à partir du groupe de journaux choisi vers votre flux :
aws logs put-subscription-filter \ --log-group-name "CloudTrail/logs" \ --filter-name "RootAccess" \ --filter-pattern "{$.userIdentity.type = Root}" \ --destination-arn "arn:aws:kinesis:
region
:123456789012:stream/RootAccess" \ --role-arn "arn:aws:iam::123456789012
:role/CWLtoKinesisRole
" -
Après avoir configuré le filtre d'abonnement, CloudWatch Logs transmet à votre stream tous les événements de journal entrants correspondant au modèle de filtre. Vous pouvez vérifier que cela se produit en saisissant un itérateur de partition Kinesis Data Streams et en utilisant la commande get-records de Kinesis Data Streams pour rechercher des enregistrements Kinesis Data Streams :
aws kinesis get-shard-iterator --stream-name RootAccess --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON
{ "ShardIterator": "AAAAAAAAAAFGU/kLvNggvndHq2UIFOw5PZc6F01s3e3afsSscRM70JSbjIefg2ub07nk1y6CDxYR1UoGHJNP4m4NFUetzfL+wev+e2P4djJg4L9wmXKvQYoE+rMUiFq+p4Cn3IgvqOb5dRA0yybNdRcdzvnC35KQANoHzzahKdRGb9v4scv+3vaq+f+OIK8zM5My8ID+g6rMo7UKWeI4+IWiK2OSh0uP" }
aws kinesis get-records --limit 10 --shard-iterator "AAAAAAAAAAFGU/kLvNggvndHq2UIFOw5PZc6F01s3e3afsSscRM70JSbjIefg2ub07nk1y6CDxYR1UoGHJNP4m4NFUetzfL+wev+e2P4djJg4L9wmXKvQYoE+rMUiFq+p4Cn3IgvqOb5dRA0yybNdRcdzvnC35KQANoHzzahKdRGb9v4scv+3vaq+f+OIK8zM5My8ID+g6rMo7UKWeI4+IWiK2OSh0uP"
Notez que vous serez peut-être amené à renouveler cet appel plusieurs fois avant que Kinesis Data Streams commence à retourner des données.
Vous devriez obtenir une réponse constituée d'un tableau d'enregistrements. L'attribut Données dans un registre Kinesis Data Streams est codé en base64 et compressé au format gzip. Vous pouvez examiner les données brutes à partir de la ligne de commande au moyen des commandes Unix suivantes :
echo -n "<Content of Data>" | base64 -d | zcat
Les données décodées et décompressées en base64 sont formatées selon la structure suivante : JSON
{ "owner": "111111111111", "logGroup": "CloudTrail/logs", "logStream": "111111111111_CloudTrail/logs_us-east-1", "subscriptionFilters": [ "Destination" ], "messageType": "DATA_MESSAGE", "logEvents": [ { "id": "31953106606966983378809025079804211143289615424298221568", "timestamp": 1432826855000, "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" }, { "id": "31953106606966983378809025079804211143289615424298221569", "timestamp": 1432826855000, "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" }, { "id": "31953106606966983378809025079804211143289615424298221570", "timestamp": 1432826855000, "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" } ] }
Les éléments clés de la structure de données ci-dessus sont les suivants :
- owner
-
Le AWS ID de compte des données du journal d'origine.
- logGroup
-
Le nom du groupe de journaux des données du journal source.
- logStream
-
Le nom du flux de journaux des données du journal source.
- subscriptionFilters
-
La liste des noms de filtres d'abonnements qui correspondaient aux données du journal source.
- messageType
-
Les messages de données utiliseront le type MESSAGE « DATA _ ». Parfois, CloudWatch Logs peut émettre des enregistrements Kinesis Data Streams de type CONTROL « MESSAGE _ », principalement pour vérifier si la destination est accessible.
- logEvents
-
Les données du journal réelles, représentées sous la forme d'un tableau d'enregistrements d'événements du journal. La propriété « id » est un identifiant unique pour chaque événement de journal.
Exemple 2 : filtres d'abonnement avec AWS Lambda
Dans cet exemple, vous allez créer un filtre d'abonnement CloudWatch aux journaux qui envoie les données des journaux à votre AWS Lambda .
Note
Avant de créer la fonction Lambda, calculez le volume de données du journal qui sera généré. Veillez à créer une fonction qui peut gérer ce volume. Si la fonction n'a pas suffisamment de volume, le flux de journaux sera limité. Pour plus d'informations sur les limites Lambda, voir AWS Lambda Limites.
Pour créer un filtre d'abonnements pour Lambda
-
Créez le AWS Lambda .
Assurez-vous d'avoir configuré le rôle d'exécution Lambda. Pour plus d'informations, voir Etape 2.2 : Création d'un IAM rôle (rôle d'exécution) dans AWS Lambda Guide du développeur.
-
Ouvrez un éditeur de texte et créez un fichier nommé
helloWorld.js
avec le contenu suivant :var zlib = require('zlib'); exports.handler = function(input, context) { var payload = Buffer.from(input.awslogs.data, 'base64'); zlib.gunzip(payload, function(e, result) { if (e) { context.fail(e); } else { result = JSON.parse(result.toString()); console.log("Event Data:", JSON.stringify(result, null, 2)); context.succeed(); } }); };
-
Compressez le fichier helloWorld .js et enregistrez-le sous son nom
helloWorld.zip
. -
Utilisez la commande suivante, où le rôle correspond au rôle d'exécution Lambda que vous avez configuré à la première étape :
aws lambda create-function \ --function-name helloworld \ --zip-file fileb://
file-path
/helloWorld.zip \ --rolelambda-execution-role-arn
\ --handler helloWorld.handler \ --runtime nodejs12.x -
Accordez à CloudWatch Logs l'autorisation d'exécuter votre fonction. Utilisez la commande suivante en remplaçant l'espace réservé au compte par votre propre compte et l'espace réservé au groupe de journaux par le groupe de journaux à traiter :
aws lambda add-permission \ --function-name "
helloworld
" \ --statement-id "helloworld
" \ --principal "logs.amazonaws.com" \ --action "lambda:InvokeFunction" \ --source-arn "arn:aws:logs:region
:123456789123
:log-group:TestLambda
:*" \ --source-account "123456789012
" -
Créez un filtre d'abonnements à l'aide de la commande suivante en remplaçant l'espace réservé au compte par votre propre compte et l'espace réservé au groupe de journaux par le groupe de journaux à traiter :
aws logs put-subscription-filter \ --log-group-name
myLogGroup
\ --filter-name demo \ --filter-pattern "" \ --destination-arn arn:aws:lambda:region
:123456789123
:function:helloworld -
(Facultatif) Testez au moyen d'un exemple d'événement de journal. A l'invite de commande, exécutez la commande suivante, qui mettra un message de journal simple dans le flux abonné.
Pour connaître l'issue de votre fonction Lambda, accédez à la fonction Lambda où vous verrez le résultat sous /aws/lambda/helloworld :
aws logs put-log-events --log-group-name
myLogGroup
--log-stream-namestream1
--log-events "[{\"timestamp\":<CURRENT TIMESTAMP MILLIS>
, \"message\": \"Simple Lambda Test
\"}]"Vous devriez voir une réponse comportant un tableau de Lambda. L'attribut Data du registre Lambda est codé en base64 et compressé au format gzip. La charge utile réelle reçue par Lambda est au format suivant
{ "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }
. Vous pouvez examiner les données brutes à partir de la ligne de commande au moyen des commandes Unix suivantes :echo -n "<BASE64ENCODED_GZIP_COMPRESSED_DATA>" | base64 -d | zcat
Les données décodées et décompressées en base64 sont formatées selon la structure suivante : JSON
{ "owner": "123456789012", "logGroup": "CloudTrail", "logStream": "123456789012_CloudTrail_us-east-1", "subscriptionFilters": [ "Destination" ], "messageType": "DATA_MESSAGE", "logEvents": [ { "id": "31953106606966983378809025079804211143289615424298221568", "timestamp": 1432826855000, "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" }, { "id": "31953106606966983378809025079804211143289615424298221569", "timestamp": 1432826855000, "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" }, { "id": "31953106606966983378809025079804211143289615424298221570", "timestamp": 1432826855000, "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}" } ] }
Les éléments clés de la structure de données ci-dessus sont les suivants :
- owner
-
Le AWS ID de compte des données du journal d'origine.
- logGroup
-
Le nom du groupe de journaux des données du journal source.
- logStream
-
Le nom du flux de journaux des données du journal source.
- subscriptionFilters
-
La liste des noms de filtres d'abonnements qui correspondaient aux données du journal source.
- messageType
-
Les messages de données utiliseront le type MESSAGE « DATA _ ». Parfois, CloudWatch Logs peut émettre des enregistrements Lambda de type « CONTROL _ MESSAGE », principalement pour vérifier si la destination est accessible.
- logEvents
-
Les données du journal réelles, représentées sous la forme d'un tableau d'enregistrements d'événements du journal. La propriété « id » est un identifiant unique pour chaque événement de journal.
Exemple 3 : filtres d'abonnement avec Amazon Data Firehose
Dans cet exemple, vous allez créer un abonnement CloudWatch Logs qui envoie tous les événements de log entrants correspondant aux filtres que vous avez définis à votre flux de diffusion Amazon Data Firehose. Les données envoyées par CloudWatch Logs à Amazon Data Firehose sont déjà compressées avec la compression gzip de niveau 6. Vous n'avez donc pas besoin d'utiliser la compression dans votre flux de diffusion Firehose. Vous pouvez ensuite utiliser la fonction de décompression de Firehose pour décompresser automatiquement les journaux. Pour plus d'informations, consultez la section Écrire dans Kinesis Data CloudWatch Firehose à l'aide de journaux.
Note
Avant de créer le flux Firehose, calculez le volume de données de journal qui sera généré. Assurez-vous de créer un flux Firehose capable de gérer ce volume. Si le flux ne peut pas traiter le volume, le flux de journaux sera limité. Pour plus d'informations sur les limites de volume de flux Firehose, consultez Amazon Data Firehose Data Limits.
Pour créer un filtre d'abonnement pour Firehose
-
Créez un compartiment Amazon Simple Storage Service (Amazon S3). Nous vous recommandons d'utiliser un bucket créé spécifiquement pour CloudWatch Logs. Toutefois, si vous souhaitez utiliser un compartiment existant, passez directement à l'étape 2.
Exécutez la commande suivante en remplaçant l'espace réservé à la région par la région que vous voulez utiliser :
aws s3api create-bucket --bucket
my-bucket
--create-bucket-configuration LocationConstraint=region
Voici un exemple de sortie :
{ "Location": "/
my-bucket
" } -
Créez le IAM rôle qui autorise Amazon Data Firehose à placer des données dans votre compartiment Amazon S3.
Pour plus d'informations, consultez la section Contrôler l'accès avec Amazon Data Firehose dans le manuel du développeur Amazon Data Firehose.
D'abord, utilisez un éditeur de texte pour créer une politique d'approbation dans un fichier
~/TrustPolicyForFirehose.json
comme suit :{ "Statement": { "Effect": "Allow", "Principal": { "Service": "firehose.amazonaws.com" }, "Action": "sts:AssumeRole" } }
-
Utilisez la commande create-role pour créer le IAM rôle, en spécifiant le fichier de politique de confiance. Notez la valeur retournée de Role.Arn, car vous en aurez besoin ultérieurement :
aws iam create-role \ --role-name FirehosetoS3Role \ --assume-role-policy-document file://~/TrustPolicyForFirehose.json
{ "Role": { "AssumeRolePolicyDocument": { "Statement": { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": "firehose.amazonaws.com" } } }, "RoleId": "AAOIIAH450GAB4HC5F431", "CreateDate": "2015-05-29T13:46:29.431Z", "RoleName": "
FirehosetoS3Role
", "Path": "/", "Arn": "arn:aws:iam::123456789012
:role/FirehosetoS3Role
" } } -
Créez une politique d'autorisation pour définir les actions que Firehose peut effectuer sur votre compte. D'abord, utilisez un éditeur de texte pour créer une stratégie d'autorisations dans un fichier
~/PermissionsForFirehose.json
:{ "Statement": [ { "Effect": "Allow", "Action": [ "s3:AbortMultipartUpload", "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:ListBucketMultipartUploads", "s3:PutObject" ], "Resource": [ "arn:aws:s3:::
my-bucket
", "arn:aws:s3:::my-bucket
/*" ] } ] } -
Associez la politique d'autorisations au rôle à l'aide de la put-role-policy commande suivante :
aws iam put-role-policy --role-name
FirehosetoS3Role
--policy-namePermissions-Policy-For-Firehose
--policy-documentfile://~/PermissionsForFirehose
.json -
Créez un flux de diffusion Firehose de destination comme suit, en remplaçant les valeurs d'espace réservé pour Role et Bucket par le rôle ARN et le bucket ARN ARNs que vous avez créés :
aws firehose create-delivery-stream \ --delivery-stream-name 'my-delivery-stream' \ --s3-destination-configuration \ '{"RoleARN": "arn:aws:iam::
123456789012
:role/FirehosetoS3Role", "BucketARN": "arn:aws:s3:::my-bucket
"}'Notez que Firehose utilise automatiquement un préfixe au UTC format YYYY horaire /MM/DD/HH pour les objets Amazon S3 livrés. Vous pouvez spécifier un préfixe supplémentaire à ajouter devant le préfixe de format temporel. Si le préfixe se termine par une barre oblique (/), il apparaît comme un dossier dans le compartiment Amazon S3.
-
Attendez que le flux devienne actif (cela peut prendre quelques minutes). Vous pouvez utiliser la describe-delivery-streamcommande Firehose pour vérifier le. DeliveryStreamDescription DeliveryStreamStatuspropriété. En outre, notez le DeliveryStreamDescription. DeliveryStreamARNvaleur, telle que vous en aurez besoin ultérieurement :
aws firehose describe-delivery-stream --delivery-stream-name "
my-delivery-stream
"{ "DeliveryStreamDescription": { "HasMoreDestinations": false, "VersionId": "1", "CreateTimestamp": 1446075815.822, "DeliveryStreamARN": "arn:aws:firehose:
us-east-1:123456789012
:deliverystream/my-delivery-stream", "DeliveryStreamStatus": "ACTIVE", "DeliveryStreamName": "my-delivery-stream
", "Destinations": [ { "DestinationId": "destinationId-000000000001", "S3DestinationDescription": { "CompressionFormat": "UNCOMPRESSED", "EncryptionConfiguration": { "NoEncryptionConfig": "NoEncryption" }, "RoleARN": "delivery-stream-role", "BucketARN": "arn:aws:s3:::my-bucket
", "BufferingHints": { "IntervalInSeconds": 300, "SizeInMBs": 5 } } } ] } } -
Créez le IAM rôle qui autorise CloudWatch Logs à insérer des données dans votre flux de diffusion Firehose. D'abord, utilisez un éditeur de texte pour créer une stratégie d'approbation dans un fichier
~/TrustPolicyForCWL.json
:Cette politique comprend une clé de contexte de condition
aws:SourceArn
globale pour aider à prévenir le problème de sécurité du député confus. Pour de plus amples informations, veuillez consulter Prévention du député confus.{ "Statement": { "Effect": "Allow", "Principal": { "Service": "logs.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringLike": { "aws:SourceArn": "arn:aws:logs:
region
:123456789012
:*" } } } } -
Utilisez la commande create-role pour créer le IAM rôle, en spécifiant le fichier de politique de confiance. Notez la valeur retournée de Role.Arn, car vous en aurez besoin ultérieurement :
aws iam create-role \ --role-name
CWLtoKinesisFirehoseRole
\ --assume-role-policy-documentfile://~/TrustPolicyForCWL.json
{ "Role": { "AssumeRolePolicyDocument": { "Statement": { "Action": "sts:AssumeRole", "Effect": "Allow", "Principal": { "Service": "logs.amazonaws.com" }, "Condition": { "StringLike": { "aws:SourceArn": "arn:aws:logs:
region
:123456789012
:*" } } } }, "RoleId": "AAOIIAH450GAB4HC5F431
", "CreateDate": "2015-05-29T13:46:29.431Z", "RoleName": "CWLtoKinesisFirehoseRole
", "Path": "/", "Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole
" } } -
Créez une politique d'autorisation pour définir les actions que CloudWatch Logs peut effectuer sur votre compte. D'abord, utilisez un éditeur de texte pour créer une stratégie d'autorisations dans un fichier (par exemple,
~/PermissionsForCWL.json
) :{ "Statement":[ { "Effect":"Allow", "Action":["firehose:PutRecord"], "Resource":[ "arn:aws:firehose:
region
:account-id
:deliverystream/delivery-stream-name
"] } ] } -
Associez la politique d'autorisations au rôle à l'aide de la put-role-policy commande :
aws iam put-role-policy --role-name
CWLtoKinesisFirehoseRole
--policy-namePermissions-Policy-For-CWL
--policy-documentfile://~/PermissionsForCWL.json
-
Une fois que le flux de diffusion Amazon Data Firehose est actif et que vous avez créé le IAM rôle, vous pouvez créer le filtre d'abonnement CloudWatch Logs. Le filtre d'abonnement lance immédiatement le flux de données de journal en temps réel entre le groupe de journaux choisi et votre flux de diffusion Amazon Data Firehose :
aws logs put-subscription-filter \ --log-group-name "CloudTrail" \ --filter-name "Destination" \ --filter-pattern "{$.userIdentity.type = Root}" \ --destination-arn "
arn:aws:firehose:
" \ --role-arn "region
:123456789012
:deliverystream/my-delivery-streamarn:aws:iam::
"123456789012
:role/CWLtoKinesisFirehoseRole -
Après avoir configuré le filtre d'abonnement, CloudWatch Logs transfère tous les événements de journal entrants correspondant au modèle de filtre vers votre flux de diffusion Amazon Data Firehose. Vos données commenceront à apparaître dans votre Amazon S3 en fonction de l'intervalle de temps défini sur votre flux de diffusion Amazon Data Firehose. Après un délai suffisant, vous pouvez consulter votre compartiment Amazon S3 pour vérifier vos données.
aws s3api list-objects --bucket '
my-bucket
' --prefix 'firehose/
'{ "Contents": [ { "LastModified": "2015-10-29T00:01:25.000Z", "ETag": "\"a14589f8897f4089d3264d9e2d1f1610\"", "StorageClass": "STANDARD", "Key": "firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250", "Owner": { "DisplayName": "cloudwatch-logs", "ID": "1ec9cf700ef6be062b19584e0b7d84ecc19237f87b5" }, "Size": 593 }, { "LastModified": "2015-10-29T00:35:41.000Z", "ETag": "\"a7035b65872bb2161388ffb63dd1aec5\"", "StorageClass": "STANDARD", "Key": "firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-35-40-7cc92023-7e66-49bc-9fd4-fc9819cc8ed3", "Owner": { "DisplayName": "cloudwatch-logs", "ID": "1ec9cf700ef6be062b19584e0b7d84ecc19237f87b6" }, "Size": 5752 } ] }
aws s3api get-object --bucket '
my-bucket
' --key 'firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250' testfile.gz{ "AcceptRanges": "bytes", "ContentType": "application/octet-stream", "LastModified": "Thu, 29 Oct 2015 00:07:06 GMT", "ContentLength": 593, "Metadata": {} }
Les données dans l'objet Amazon S3 sont comprimées au format gzip. Vous pouvez examiner les données brutes à partir de la ligne de commande au moyen de la commande Unix suivante :
zcat testfile.gz