Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Collecter les journaux des fonctions AWS Lambda

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer des journaux de fonction AWS Lambda dans Google Security Operations à l'aide d'Amazon S3.

AWS Lambda est un service de calcul sans serveur qui exécute votre code en réponse à des événements et gère automatiquement les ressources de calcul sous-jacentes. Lambda envoie automatiquement tous les journaux de fonction (journaux de plate-forme, journaux d'extension et sortie d'application) à Amazon CloudWatch Logs, en créant un groupe de journaux par fonction. Cette intégration utilise Amazon Data Firehose pour diffuser en flux continu les événements de journaux Lambda de CloudWatch Logs vers un bucket S3, que Google SecOps ingère ensuite à l'aide d'un flux Amazon S3 V2.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

Une instance Google SecOps
Accès privilégié à la console AWS Management Console avec les autorisations de gestion suivantes :
- AWS Lambda (fonctions, configuration de la journalisation)
- Journaux Amazon CloudWatch (groupes de journaux, filtres d'abonnement)
- Amazon Data Firehose (flux de diffusion)
- Amazon S3 (buckets)
- AWS IAM (rôles, stratégies, utilisateurs)

Vérifier le groupe de journaux CloudWatch Logs pour votre fonction Lambda

AWS Lambda crée automatiquement un groupe de journaux CloudWatch Logs pour chaque fonction lors de sa première invocation. La convention d'attribution de noms par défaut pour les groupes de journaux est la suivante :
```
/aws/lambda/<function-name>
```

Pour effectuer la validation, procédez comme suit :

Dans la console AWS, accédez à CloudWatch > Logs > Log groups.
Recherchez /aws/lambda/.
Vérifiez qu'un groupe de journaux existe pour chaque fonction Lambda dont vous souhaitez ingérer les journaux.

Remarque : Si vous avez configuré un groupe de journaux personnalisé pour votre fonction Lambda, utilisez plutôt le nom de ce groupe de journaux. Les noms de groupes de journaux personnalisés sont configurés dans les paramètres de configuration de la journalisation de la fonction Lambda.

Configurer un bucket AWS S3

Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, lambda-logs-to-secops).

Configurer un rôle IAM pour Amazon Data Firehose

Amazon Data Firehose nécessite un rôle IAM pour écrire les journaux dans votre bucket S3.

Créer la stratégie IAM

Dans la console AWS, accédez à IAM > Stratégies > Créer une stratégie.
Sélectionnez l'onglet JSON.

Collez la règle suivante (remplacez lambda-logs-to-secops par le nom réel de votre bucket) :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3Delivery",
            "Effect": "Allow",
            "Action": [
                "s3:AbortMultipartUpload",
                "s3:GetBucketLocation",
                "s3:GetObject",
                "s3:ListBucket",
                "s3:ListBucketMultipartUploads",
                "s3:PutObject"
            ],
            "Resource": [
                "arn:aws:s3:::lambda-logs-to-secops",
                "arn:aws:s3:::lambda-logs-to-secops/*"
            ]
        },
        {
            "Sid": "CloudWatchLogging",
            "Effect": "Allow",
            "Action": [
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:log-group:/aws/kinesisfirehose/lambda-logs-to-secops:log-stream:*"
        }
    ]
}

Cliquez sur Suivant.
Dans le champ Policy name (Nom de la règle), saisissez LambdaLogsFirehoseS3Policy.
Cliquez sur Créer une règle.

Créer le rôle IAM

Accédez à IAM > Rôles > Créer un rôle.
Sélectionnez Règle d'approbation personnalisée.

Collez la stratégie d'approbation suivante :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "firehose.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Cliquez sur Suivant.
Recherchez et sélectionnez LambdaLogsFirehoseS3Policy.
Cliquez sur Suivant.
Dans le champ Nom du rôle, saisissez LambdaLogsFirehoseToS3Role.
Cliquez sur Créer un rôle.

Créer le flux Amazon Data Firehose

Ouvrez la console Kinesis à l'adresse https://console.aws.amazon.com/kinesis.
Dans le volet de navigation, sélectionnez Amazon Data Firehose.
Cliquez sur Créer un flux Firehose.
Sous Choisir la source et la destination, fournissez la configuration suivante :
- Source : sélectionnez PUT direct.
- Destination : sélectionnez Amazon S3.
Dans le champ Nom du flux Firehose, saisissez lambda-logs-to-secops.
Sous Transformer les enregistrements, dans la section Décompresser les enregistrements sources à partir d'Amazon CloudWatch Logs :
1. Sélectionnez Activer la décompression.
2. Ne sélectionnez pas Activer l'extraction des messages.
Remarque : Si vous désactivez l'extraction des messages, les métadonnées CloudWatch (logGroup, logStream, subscriptionFilters) sont conservées dans les journaux fournis. L'analyseur AWS_LAMBDA_FUNCTION est compatible avec le format complet de l'enveloppe CloudWatch Logs, y compris la structure logEvents.
Sous Paramètres de destination :
- Bucket S3 : sélectionnez le bucket S3 lambda-logs-to-secops.
- Préfixe du bucket S3 (facultatif) : saisissez lambda-logs/.
- Préfixe de sortie d'erreur du bucket S3 (facultatif) : saisissez firehose-errors/.
Sous Indices de mémoire tampon :
- Taille de la mémoire tampon : 5 Mio (par défaut).
- Intervalle de mise en mémoire tampon : 300 secondes (par défaut).
Sous Paramètres avancés :
- Chiffrement côté serveur : facultatif. Activez cette option si le chiffrement est requis.
- Journalisation des erreurs : sélectionnez Activé (recommandé).
- Autorisations : sélectionnez Choisir un rôle IAM existant, puis sélectionnez LambdaLogsFirehoseToS3Role.
Cliquez sur Créer un flux Firehose.
Attendez que l'état du flux indique Actif.

Configurer un rôle IAM pour CloudWatch Logs

CloudWatch Logs nécessite un rôle IAM pour envoyer des données de journaux au flux Firehose.

Créer la stratégie IAM

Accédez à IAM > Stratégies > Créer une stratégie.
Sélectionnez l'onglet JSON.

Collez la stratégie suivante (remplacez <region> et <account-id> par votre région AWS et votre ID de compte) :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "firehose:PutRecord",
                "firehose:PutRecordBatch"
            ],
            "Resource": "arn:aws:firehose:<region>:<account-id>:deliverystream/lambda-logs-to-secops"
        }
    ]
}

Cliquez sur Suivant.
Dans le champ Policy name (Nom de la règle), saisissez LambdaLogsCWLtoFirehosePolicy.
Cliquez sur Créer une règle.

Créer le rôle IAM

Accédez à IAM > Rôles > Créer un rôle.
Sélectionnez Règle d'approbation personnalisée.

Collez la stratégie d'approbation suivante (remplacez <region> par votre région AWS) :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "logs.<region>.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Cliquez sur Suivant.
Recherchez et sélectionnez LambdaLogsCWLtoFirehosePolicy.
Cliquez sur Suivant.
Dans le champ Nom du rôle, saisissez LambdaLogsCWLtoFirehoseRole.
Cliquez sur Créer un rôle.

Créer un filtre d'abonnement CloudWatch Logs

Dans la console AWS, accédez à CloudWatch > Logs > Log groups.
Sélectionnez le groupe de journaux /aws/lambda/<function-name>.
Sélectionnez l'onglet Filtres d'abonnement.
Cliquez sur Créer > Créer un filtre d'abonnement Amazon Data Firehose.
Fournissez les informations de configuration suivantes :
- Destination : sélectionnez le flux Firehose lambda-logs-to-secops.
- Accorder l'autorisation : sélectionnez le rôle LambdaLogsCWLtoFirehoseRole.
- Nom du filtre d'abonnement : saisissez un nom descriptif (par exemple, lambda-logs-to-secops-filter).
- Format du journal : sélectionnez Autre.
- Modèle de filtre d'abonnement : laissez ce champ vide pour envoyer tous les événements de journal de la fonction Lambda.
Cliquez sur Démarrer le streaming.

Remarque Répétez les étapes 1 à 6 pour chaque groupe de journaux de fonction Lambda supplémentaire que vous souhaitez diffuser en streaming vers Google SecOps. Chaque fonction Lambda possède un groupe de journaux distinct à l'adresse /aws/lambda/<function-name>. Tous les filtres d'abonnement peuvent utiliser le même flux Firehose et les mêmes rôles IAM.

Configurer un utilisateur IAM pour Google SecOps

Google SecOps a besoin d'un utilisateur IAM ayant accès au bucket S3 pour ingérer les journaux fournis.

Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
Sélectionnez l'utilisateur créé.
Sélectionnez l'onglet Informations d'identification de sécurité.
Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
Sélectionnez Service tiers comme Cas d'utilisation.
Cliquez sur Suivant.
- Facultatif : Ajoutez une balise de description.
Cliquez sur Créer une clé d'accès.
Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
Cliquez sur OK.
Sélectionnez l'onglet Autorisations.
Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
Sélectionnez Ajouter des autorisations.
Sélectionnez Joindre directement des règles.
Recherchez la règle AmazonS3FullAccess.
Sélectionnez la règle.
Cliquez sur Suivant.
Cliquez sur Ajouter des autorisations.

Configurer un flux dans Google SecOps pour ingérer les journaux de fonction AWS Lambda

Accédez à Paramètres SIEM> Flux.
Cliquez sur Add New Feed (Ajouter un flux).
Sur la page suivante, cliquez sur Configurer un seul flux.
Saisissez un nom unique pour le nom du flux.
Sélectionnez Amazon S3 V2 comme type de source.
Sélectionnez Fonction AWS Lambda comme Type de journal.
Cliquez sur Suivant, puis sur Envoyer.
Indiquez les valeurs des champs suivants :
- URI S3 : s3://lambda-logs-to-secops/lambda-logs/
- Option de suppression de la source : sélectionnez l'option de suppression de votre choix.
- Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).
- ID de clé d'accès : clé d'accès utilisateur avec accès au bucket S3
- Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3
- Espace de noms de l'élément : espace de noms de l'élément
- Libellés d'ingestion : libellé à appliquer aux événements de ce flux
Cliquez sur Suivant, puis sur Envoyer.

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
`Activity_id_label`	`additional.fields`	Fusionné
`Arrays_label`	`additional.fields`	Fusionné
`Name_label`	`additional.fields`	Fusionné
`Type_1_label`	`additional.fields`	Fusionné
`Type_id_label`	`additional.fields`	Fusionné
`Type_label`	`additional.fields`	Fusionné
`Uid_label`	`additional.fields`	Fusionné
`Uid_label_1`	`additional.fields`	Fusionné
`Value_label`	`additional.fields`	Fusionné
`__type_label`	`additional.fields`	Fusionné
`attempts_label`	`additional.fields`	Fusionné
`class_name_label`	`additional.fields`	Fusionné
`contentType_label`	`additional.fields`	Fusionné
`env_label`	`additional.fields`	Fusionné
`extendedRequestId_label`	`additional.fields`	Fusionné
`feature_name_label`	`additional.fields`	Fusionné
`line_number_label`	`additional.fields`	Fusionné
`logType_label`	`additional.fields`	Fusionné
`product_name_label`	`additional.fields`	Fusionné
`requestid_label`	`additional.fields`	Fusionné
`sourceAccount_label`	`additional.fields`	Fusionné
`stack_label`	`additional.fields`	Fusionné
`totalRetryDelay_label`	`additional.fields`	Fusionné
`vendor_name_label`	`additional.fields`	Fusionné
`version_label`	`additional.fields`	Fusionné
`has_principal`	`extensions.auth.type`	Mappé : `true` → `AUTHTYPE_UNSPECIFIED`
`description`	`metadata.description`	Mappé directement
`file_desc`	`metadata.description`	Mappé directement
`Time`	`metadata.event_timestamp`	Analysé comme `UNIX`
`time`	`metadata.event_timestamp`	Analysé comme `yyyy-MM-ddTHH:mm:ss.SSSZ`
`has_principal`	`metadata.event_type`	Mappé : `true` → `USER_LOGIN`, `true` → `NETWORK_HTTP`, `true` → `NETWORK_CONNECTION`, `true...
`has_principal_user`	`metadata.event_type`	Mappé : `true` → `USER_RESOURCE_ACCESS`
`Api.Operation`	`metadata.product_event_type`	Mappé directement
`name`	`metadata.product_event_type`	Mappé directement
`Api.Request.Uid`	`metadata.product_log_id`	Mappé directement
`id`	`metadata.product_log_id`	Mappé directement
`meta_data.requestId`	`metadata.product_log_id`	Mappé directement
`Metadata.Version`	`metadata.product_version`	Mappé directement
`version`	`metadata.product_version`	Mappé directement
`meta_data.httpStatusCode`	`network.http.response_code`	Mappé directement
`Http_request.User_agent`	`network.http.user_agent`	Mappé directement
`Actor.Invoked_by`	`principal.administrative_domain`	Mappé directement
`Src_endpoint.Domain`	`principal.asset.hostname`	Mappé directement
`Src_endpoint.Domain`	`principal.hostname`	Mappé directement
`Cloud.Region`	`principal.resource.attribute.cloud.availability_zone`	Mappé directement
`Actor.User.Name`	`principal.user.userid`	Mappé directement
`Status`	`security_result.action_details`	Mappé directement
`Category_name`	`security_result.category_details`	Fusionné
`error`	`security_result.description`	Mappé directement
`errorMessage`	`security_result.description`	Mappé directement
`Metadata_uid_label`	`security_result.detection_fields`	Fusionné
`category_uid_label`	`security_result.detection_fields`	Fusionné
`class_uid_label`	`security_result.detection_fields`	Fusionné
`errorType_label`	`security_result.detection_fields`	Fusionné
`event_code_label`	`security_result.detection_fields`	Fusionné
`fault_label`	`security_result.detection_fields`	Fusionné
`functionName_label`	`security_result.detection_fields`	Fusionné
`severity_id_label`	`security_result.detection_fields`	Fusionné
`sourceArn_label`	`security_result.detection_fields`	Fusionné
`type_name_label`	`security_result.detection_fields`	Fusionné
`type_uid_label`	`security_result.detection_fields`	Fusionné
`user_type_label`	`security_result.detection_fields`	Fusionné
`Severity`	`security_result.severity`	Mappé : `Informational` → `INFORMATIONAL`
`severity`	`security_result.severity`	Mappé : `INFO` → `INFORMATIONAL`
`msg`	`security_result.summary`	Mappé directement
`Api.Service.Name`	`target.application`	Mappé directement
`service`	`target.application`	Mappé directement
`size`	`target.file.size`	Mappé directement
`filename`	`target.process.file.full_path`	Mappé directement
`Activity_name`	`target.resource.name`	Mappé directement
`targetVar`	`target.resource.name`	Mappé directement
N/A	`extensions.auth.type`	Constante : `AUTHTYPE_UNSPECIFIED`
N/A	`metadata.event_type`	Constante : `USER_UNCATEGORIZED`
N/A	`metadata.product_name`	Constante : `AWS_Lambda_Function`
N/A	`metadata.vendor_name`	Constante : `AWS_Lambda_Function`
N/A	`principal.resource.attribute.cloud.environment`	Constante : `AMAZON_WEB_SERVICES`
N/A	`security_result.severity`	Constante : `INFORMATIONAL`

Journal des modifications

Afficher le journal des modifications pour ce parseur

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.