Collecter les journaux de flux VPC Google Cloud

Version de l'analyseur : 6.0

Compatible avec :

Ce document explique comment ingérer des journaux de flux VPC Google Cloud dans Google Security Operations à l'aide de Cloud Storage.

Les journaux de flux VPC enregistrent un échantillon des flux réseau envoyés et reçus par les instances de VM, y compris les instances utilisées comme nœuds Google Kubernetes Engine. Ces journaux peuvent être utilisés pour la surveillance et l'investigation des réseaux, l'analyse de la sécurité en temps réel et l'optimisation des dépenses. Les journaux de flux sont regroupés par connexion à des intervalles configurables, puis exportés en temps quasi réel via Cloud Logging. Un récepteur de journaux achemine les journaux de flux VPC vers un bucket Cloud Storage, à partir duquel Google SecOps les ingère.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un projet Google Cloud avec les API suivantes activées :
    • API Cloud Storage
    • API Cloud Logging
    • API Compute Engine
  • Autorisations pour :
    • Activer les journaux de flux VPC sur des sous-réseaux
    • Créer et gérer des buckets Cloud Storage
    • Gérer les stratégies de Identity and Access Management (IAM) sur les buckets Cloud Storage
    • Créer et gérer des récepteurs de l'API Cloud Logging
  • Au moins un sous-réseau VPC sur lequel vous souhaitez activer les journaux de flux VPC

Activer les journaux de flux VPC sur des sous-réseaux

Avant de configurer le pipeline d'ingestion, assurez-vous que les journaux de flux VPC sont activés sur les sous-réseaux cibles. Google Cloud accepte deux API pour gérer les journaux de flux VPC : l'API Network Management (recommandée) et l'API Compute Engine.

Utiliser la console Google Cloud (API Network Management)

  1. Dans la consoleGoogle Cloud , accédez à Réseau VPC > Réseaux VPC.
  2. Cliquez sur l'onglet Sous-réseaux dans le projet actuel.
  3. Sélectionnez le sous-réseau pour lequel vous souhaitez activer les journaux de flux.
  4. Cliquez sur Gérer les journaux de flux.
  5. Cliquez sur Ajouter une configuration.
  6. Attribuez un nom à la configuration.
  7. Configurez les paramètres facultatifs suivants :
    • Intervalle d'agrégation : sélectionnez l'intervalle d'agrégation (par défaut : 5 secondes). Des intervalles plus courts fournissent des données plus précises, mais augmentent le volume des journaux.
    • Inclure les métadonnées : sélectionnez Inclure toutes les métadonnées pour inclure les détails de l'instance de VM et du VPC.
    • Taux d'échantillonnage secondaire : définissez le taux d'échantillonnage (par défaut : 100 % pour l'API Network Management). Des taux plus élevés capturent plus de flux, mais augmentent le volume de journaux.
    • Expression de filtre : expression de filtre CEL facultative pour inclure ou exclure des flux spécifiques (maximum 2 048 caractères).
  8. Cliquez sur Enregistrer.

Utiliser l'outil de ligne de commande gcloud (API Network Management)

  • Utilisez la syntaxe suivante :

    gcloud network-management vpc-flow-logs-configs create <CONFIG_NAME> \
            --location=global \
            --subnet=projects/<PROJECT_ID>/regions/<REGION>/subnetworks/<SUBNET_NAME> \
            --aggregation-interval=INTERVAL_5_SEC \
            --metadata=INCLUDE_ALL_METADATA \
            --flow-sampling=1.0
    

Remplacez :

  • <CONFIG_NAME> : nom descriptif de la configuration (par exemple, vpc-flow-logs-config)
  • <PROJECT_ID> : ID de votre projet Google Cloud
  • <REGION> : région du sous-réseau (par exemple, us-central1)
  • <SUBNET_NAME> : nom de votre sous-réseau

Utiliser l'outil de ligne de commande gcloud (API Compute Engine)

  • Utilisez la syntaxe suivante :

    gcloud compute networks subnets update <SUBNET_NAME> \
            --region=<REGION> \
            --enable-flow-logs \
            --logging-aggregation-interval=interval-5-sec \
            --logging-metadata=include-all \
            --logging-flow-sampling=0.5 \
            --project=<PROJECT_ID>
    

Remplacez :

  • <SUBNET_NAME> : nom de votre sous-réseau
  • <REGION> : région du sous-réseau (par exemple, us-central1)
  • <PROJECT_ID> : ID de votre projet Google Cloud

Créer un bucket Cloud Storage

  1. Accédez à la consoleGoogle Cloud .
  2. Sélectionnez votre projet.
  3. Dans le menu de navigation, accédez à Cloud Storage > Buckets.
  4. Cliquez sur Créer un bucket.
  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Attribuez un nom au bucket Saisissez un nom unique (par exemple, vpc-flow-logs-bucket).
    Type d'emplacement Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux fréquemment consultés)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activer la gestion des versions d'objets ou une règle de conservation
  6. Cliquez sur Créer.

Créer un récepteur Logging pour exporter les journaux de flux VPC vers Cloud Storage

Un récepteur de journaux Logging achemine les journaux de flux VPC de Logging vers le bucket Cloud Storage. Google SecOps ingère ensuite les objets exportés depuis le bucket.

Créer le récepteur de journaux

  1. Dans la consoleGoogle Cloud , accédez à Logging > Routeur de journaux.
  2. Cliquez sur Créer un récepteur.
  3. Fournissez les informations de configuration suivantes :
    • Nom du récepteur : saisissez un nom descriptif (par exemple, vpc-flow-to-gcs).
    • Description du récepteur : saisissez Route VPC Flow Logs to Cloud Storage for Google SecOps ingestion.
  4. Cliquez sur Suivant.
  5. Dans la section Sélectionner le service de récepteur :
    • Service de récepteur : sélectionnez Bucket Cloud Storage.
    • Sélectionner un bucket Cloud Storage : sélectionnez le bucket vpc-flow-logs-bucket.
  6. Cliquez sur Suivant.
  7. Dans la section Sélectionner les journaux à inclure dans le récepteur, saisissez le filtre suivant pour capturer les journaux de flux VPC :

    resource.type="gce_subnetwork" AND log_id("compute.googleapis.com/vpc_flows")
    
    resource.type="gce_subnetwork" AND log_id("compute.googleapis.com/vpc_flows") AND resource.labels.subnetwork_name="<SUBNET_NAME>"
    
    • Remplacez <SUBNET_NAME> par le nom du sous-réseau cible.
  8. Cliquez sur Suivant.

  9. Vérifiez la configuration, puis cliquez sur Créer un récepteur.

Accorder au rédacteur du récepteur l'autorisation d'écrire dans le bucket

Après avoir créé le récepteur, Logging lui attribue un compte de service d'écriture (l'identité de l'éditeur). Accordez à cette identité l'autorisation d'écrire des objets dans le bucket.

  1. Accédez à Logging > Routeur de journaux.
  2. Recherchez le récepteur vpc-flow-to-gcs, cliquez sur le menu à trois points, puis sélectionnez Afficher les détails du récepteur.
  3. Copiez la valeur Identité du rédacteur (au format serviceAccount:p<PROJECT_NUMBER>-<ID>@gcp-sa-logging.iam.gserviceaccount.com).
  4. Accédez à Cloud Storage > Buckets.
  5. Cliquez sur le bucket vpc-flow-logs-bucket.
  6. Accédez à l'onglet Autorisations.
  7. Cliquez sur Accorder l'accès.
  8. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'identité du rédacteur du récepteur (sans le préfixe serviceAccount:).
    • Attribuer des rôles : sélectionnez Créateur des objets de l'espace de stockage (roles/storage.objectCreator).
  9. Cliquez sur Enregistrer.

Vérifier que les journaux sont exportés

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le bucket vpc-flow-logs-bucket.
  3. Attendez quelques minutes que le récepteur écrive les premiers objets.
  4. Vérifiez qu'un dossier nommé compute.googleapis.com/vpc_flows/ (ou un chemin d'accès daté) est créé et qu'il contient les fichiers journaux exportés.

Configurer un flux dans Google SecOps pour ingérer les journaux de flux VPC

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, GCP VPC Flow Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez GCP VPC Flow comme Type de journal.
  7. Cliquez sur Get Service Account (Obtenir un compte de service). Une adresse e-mail de compte de service unique s'affiche, par exemple :

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  8. Copiez cette adresse e-mail. Vous en aurez besoin lors de la tâche suivante.

  9. Cliquez sur Suivant.

  10. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URI du bucket de stockage : saisissez l'URI du bucket Cloud Storage avec le chemin d'accès du préfixe :

      gs://vpc-flow-logs-bucket/compute.googleapis.com/vpc_flows/
      
      • Remplacez :
        • vpc-flow-logs-bucket : nom de votre bucket Cloud Storage.
        • compute.googleapis.com/vpc_flows : préfixe/chemin d'accès au dossier facultatif où le récepteur écrit les journaux (laisser vide pour la racine).
    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais les fichiers après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers une fois le transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides une fois le transfert réussi.
    • Âge maximal du fichier (jours) : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  11. Cliquez sur Suivant.

  12. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps doit disposer du rôle Lecteur des objets Storage sur votre bucket Cloud Storage.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le bucket vpc-flow-logs-bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
    • Attribuer des rôles : sélectionnez Lecteur des objets Storage (roles/storage.objectViewer).
  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ du journal Mappage UDM Logique
_field additional.fields Fusionné
textpayload_label additional.fields Fusionné
tunnel_id_label additional.fields Fusionné
description metadata.description Mappage direct
timestamp metadata.event_timestamp Analysé en tant que ISO8601
ts metadata.event_timestamp Analysé en tant que ISO8601
event_type metadata.event_type Mappage direct
product_event_type metadata.product_event_type Mappage direct
product_log_id metadata.product_log_id Mappage direct
product_name metadata.product_name Mappage direct
product_version metadata.product_version Mappage direct
vendor_name metadata.vendor_name Mappage direct
ip_protocol_out network.ip_protocol Mappage direct
jsonPayload.bytes_sent network.sent_bytes Renommé/Mappé
jsonPayload.packets_sent network.sent_packets Renommé/Mappé
principal.ip principal.asset.ip Fusionné
target.ip principal.asset.ip Fusionné
jsonPayload.src_instance.vm_name principal.hostname Mappage direct
target.hostname principal.hostname Renommé/Mappé
jsonPayload.connection.src_ip principal.ip Mappage direct
target.ip principal.ip Fusionné
jsonPayload.src_location.city principal.location.city Mappage direct
target.location.city principal.location.city Renommé/Mappé
jsonPayload.src_location.country principal.location.country_or_region Mappage direct
target.location.country_or_region principal.location.country_or_region Renommé/Mappé
jsonPayload.src_instance.region principal.location.name Mappage direct
resource.labels.location principal.location.name Mappage direct
target.location.name principal.location.name Renommé/Mappé
jsonPayload.src_location.region principal.location.state Mappage direct
target.location.state principal.location.state Renommé/Mappé
jsonPayload.src_vpc.project_id principal.namespace Mappage direct
jsonPayload.src_vpc.vpc_name principal.namespace Mappage direct
target.namespace principal.namespace Renommé/Mappé
jsonPayload.connection.src_port principal.port Mappage direct
_field principal.resource.attribute.labels Fusionné
key principal.resource.attribute.labels Mappé : jsonPayload_src_google_service_type → _field
src_gke_cluster_location principal.resource.attribute.labels Fusionné
src_gke_cluster_name principal.resource.attribute.labels Fusionné
src_gke_namespace principal.resource.attribute.labels Fusionné
src_gke_pod_name principal.resource.attribute.labels Fusionné
logName security_result.category_details Fusionné
severity security_result.severity Mappé : DEBUG → LOW
principal.ip target.asset.ip Fusionné
target.ip target.asset.ip Fusionné
jsonPayload.dest_instance.vm_name target.hostname Mappage direct
principal.hostname target.hostname Renommé/Mappé
jsonPayload.connection.dest_ip target.ip Mappage direct
principal.ip target.ip Fusionné
jsonPayload.dest_location.city target.location.city Mappage direct
principal.location.city target.location.city Renommé/Mappé
jsonPayload.dest_location.country target.location.country_or_region Mappage direct
principal.location.country_or_region target.location.country_or_region Renommé/Mappé
jsonPayload.dest_instance.region target.location.name Mappage direct
principal.location.name target.location.name Renommé/Mappé
jsonPayload.dest_location.region target.location.state Mappage direct
principal.location.state target.location.state Renommé/Mappé
jsonPayload.dest_vpc.project_id target.namespace Mappage direct
jsonPayload.dest_vpc.vpc_name target.namespace Mappage direct
principal.namespace target.namespace Renommé/Mappé
jsonPayload.connection.dest_port target.port Renommé/Mappé
dest_gke_cluster_location target.resource.attribute.labels Fusionné
dest_gke_cluster_name target.resource.attribute.labels Fusionné
dest_gke_namespace target.resource.attribute.labels Fusionné
dest_gke_pod_name target.resource.attribute.labels Fusionné
service_name_label target.resource.attribute.labels Fusionné
service_namespace_label target.resource.attribute.labels Fusionné
subnetwork_id_field target.user.attribute.labels Fusionné
N/A network.direction Constante : OUTBOUND
N/A network.ip_protocol Constante : network.ip_protocol
N/A network.sent_bytes Constante : network.sent_bytes
N/A principal.hostname Constante : target.hostname
N/A principal.location.city Constante : target.location.city
N/A principal.location.country_or_region Constante : target.location.country_or_region
N/A principal.location.name Constante : target.location.name
N/A principal.location.state Constante : target.location.state
N/A principal.namespace Constante : target.namespace
N/A principal.port Constante : principal.port
N/A security_result.severity Constante : LOW
N/A target.hostname Constante : principal.hostname
N/A target.location.city Constante : principal.location.city
N/A target.location.country_or_region Constante : principal.location.country_or_re...
N/A target.location.name Constante : principal.location.name
N/A target.location.state Constante : principal.location.state
N/A target.namespace Constante : principal.namespace
N/A target.port Constante : -99
resource.labels.subnetwork_id target.user.attribute.labels Mappé à partir du journal des modifications

Journal des modifications

Afficher le journal des modifications de cet analyseur

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