Filtres d'abonnement au niveau des groupes de journaux - Amazon CloudWatch Logs

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 Kinesis Data Streams, Lambda ou Firehose. Les journaux envoyés à un service de réception via un filtre d'abonnement sont codés en base64 et compressés au format gzip.

Vous pouvez effectuer une recherche dans les données de vos journaux en utilisant la syntaxe de filtre et de modèle.

Exemple 1 : filtres d'abonnement avec Kinesis Data Streams

L'exemple suivant associe un filtre d'abonnement à un groupe de journaux contenant des AWS CloudTrail événements. Le filtre d'abonnement transmet toutes les activités enregistrées à l'aide des AWS informations d'identification « Root » à un flux appelé « RootAccess » dans Kinesis Data Streams. Pour plus d'informations sur la façon d'envoyer AWS CloudTrail des événements aux CloudWatch journaux, consultez la section Envoyer CloudTrail des événements aux CloudWatch journaux dans le guide de AWS CloudTrail 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 le distribution 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
  1. Créez un flux ​​ de destination à l'aide de la commande suivante :

    $ C:\> aws kinesis create-stream --stream-name "RootAccess" --shard-count 1
  2. 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 valeur StreamDescription.StreamArn, 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" } } ] } }
  3. Créez le rôle IAM 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 console IAM pour la 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 plus d'informations, consultez 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:*" } } } }
  4. Utilisez la commande create-role pour créer le rôle IAM, en spécifiant le fichier de politique d'approbation. 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" } }
  5. 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 console IAM pour la créer.

    { "Statement": [ { "Effect": "Allow", "Action": "kinesis:PutRecord", "Resource": "arn:aws:kinesis:region:123456789012:stream/RootAccess" } ] }
  6. 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
  7. Une fois que le flux est en état actif et que vous avez créé le rôle IAM, 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"
  8. 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 codées et décompressées en base64 sont formatées au format JSON avec la structure suivante :

    { "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

    L'ID de AWS 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 données de messages utiliseront le type « DATA_MESSAGE ». 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 fonction.

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, consultez Limites AWS Lambda.

Pour créer un filtre d'abonnements pour Lambda
  1. Créez la AWS Lambda fonction.

    Assurez-vous d'avoir configuré le rôle d'exécution Lambda. Pour plus d'informations, consultez Étape 2.2 : Créer un rôle IAM (rôle d'exécution) dans le Guide du développeur AWS Lambda .

  2. 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(); } }); };
  3. Zippez le fichier helloWorld.js et enregistrez-le sous le nom helloWorld.zip.

  4. 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 \ --role lambda-execution-role-arn \ --handler helloWorld.handler \ --runtime nodejs12.x
  5. 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"
  6. 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
  7. (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-name stream1 --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 codées et décompressées en base64 sont formatées au format JSON avec la structure suivante :

    { "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

    L'ID de AWS 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 données de messages utiliseront le type « DATA_MESSAGE ». 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
  1. 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" }
  2. Créez le rôle IAM 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" } }
  3. Utilisez la commande create-role pour créer le rôle IAM, en spécifiant le fichier de politique d'approbation. 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" } }
  4. 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/*" ] } ] }
  5. 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-name Permissions-Policy-For-Firehose --policy-document file://~/PermissionsForFirehose.json
  6. Créez un flux de diffusion Firehose de destination comme suit, en remplaçant les valeurs d'espace réservé pour Rolearn et BucketArn par les ARN du rôle et du bucket 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 format YYYY/MM/DD/HH UTC 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.

  7. 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. DeliveryStreamValeur de l'ARN, dont vous 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 } } } ] } }
  8. Créez le rôle IAM 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 plus d'informations, consultez 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:*" } } } }
  9. Utilisez la commande create-role pour créer le rôle IAM, en spécifiant le fichier de politique d'approbation. 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-document file://~/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" } }
  10. 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"] } ] }
  11. 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-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL.json
  12. Une fois que le flux de diffusion Amazon Data Firehose est actif et que vous avez créé le rôle IAM, 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:region:123456789012:deliverystream/my-delivery-stream" \ --role-arn "arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole"
  13. Une fois le filtre d'abonnement configuré, CloudWatch Logs transmet tous les événements de journal entrants correspondant au modèle de filtre à 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