Exemple 1 : filtres d'abonnement avec Kinesis Data Streams Exemple 2 : filtres d'abonnement avec AWS Lambda Exemple 3 : filtres d'abonnement avec Amazon Kinesis Data Firehose

Utilisation des filtres d'abonnement CloudWatch Logs

Vous pouvez utiliser un filtre d'abonnement avec Kinesis Data Streams, Lambda ou Kinesis Data 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.

Exemples

Exemple 1 : filtres d'abonnement avec Kinesis Data Streams
Exemple 2 : filtres d'abonnement avec AWS Lambda
Exemple 3 : filtres d'abonnement avec Amazon Kinesis Data Firehose

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 deAWS 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 :

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 des métriques CloudWatch.
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 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"
                }
            }
        ]
    }
}

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:*" } 
     }
   }
}
```

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

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"
    }
  ]
}
```

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

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 LimitesAWS Lambda.

Pour créer un filtre d'abonnements pour Lambda

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éveloppeurAWS Lambda .

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();
        }
    });
};

Zippez le fichier helloWorld.js et enregistrez-le sous le 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 \
    --role lambda-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-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 Kinesis 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 Kinesis Data Firehose. Les données envoyées depuis CloudWatch Logs vers Amazon Kinesis Data Firehose sont déjà compressées avec une compression gzip de niveau 6. Vous n'avez donc pas besoin d'utiliser la compression dans votre flux de diffusion Kinesis Data Firehose.

Note

Avant de créer le flux Kinesis Data Firehose, calculez le volume de données du journal qui sera généré. Veillez à créer un flux Kinesis Data Firehose qui peut 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 applicables aux flux Kinesis Data Firehose, consultez la section Limites des données Amazon Kinesis Data Firehose.

Pour créer un filtre d'abonnements pour Kinesis Data 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 rôle IAM qui accorde à Amazon Kinesis Data Firehose l'autorisation de placer des données dans votre compartiment Amazon S3.

Pour plus d'informations, consultez Contrôle de l'accès avec Amazon Kinesis Data Firehose dans le Guide du développeur Amazon Kinesis 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 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"
    }
}

Créez une politique d'autorisations pour définir les actions permises à Kinesis Data Firehose 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-name Permissions-Policy-For-Firehose --policy-document file://~/PermissionsForFirehose.json

Créez un flux de diffusion Kinesis Data Firehose de destination comme suit, en remplaçant l'espace réservé aux valeurs de RoleARN et BucketARN par les ARN de rôle et de compartiment 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 Kinesis Data Firehose utilise automatiquement un préfixe au format AAAA/MM/JJ/HH UTC pour les objets Amazon S3 transmis. 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 commande Kinesis describe-delivery-streamData 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
                    }
                }
            }
        ]
    }
}

Créez le rôle IAM qui autorise CloudWatch Logs à insérer des données dans votre flux de diffusion Kinesis Data 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:*"
         } 
     }
  }
}
```


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

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-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL.json

Une fois que le flux de diffusion Amazon Kinesis Data Firehose est actif et que vous avez créé le rôle IAM, vous pouvez CloudWatch créer le filtre d'abonnement Logs. Le filtre d'abonnement lance immédiatement la transmission de données du journal en temps réel à partir du groupe de journaux choisi vers votre flux de diffusion Amazon Kinesis 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"
```

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 Kinesis Data Firehose. Vos données commenceront à apparaître dans votre Amazon S3 en fonction de l'intervalle de temps tampon configuré pour votre flux de diffusion Amazon Kinesis 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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Filtres d'abonnements

Partage de données du journal entre comptes avec les abonnements