Collecter les journaux des appareils Armis

Version de l'analyseur : 2.0

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer des journaux d'appareils Armis dans Google Security Operations à l'aide de Google Cloud Storage V2.

Armis Centrix est une plate-forme d'intelligence des ressources de niveau entreprise conçue pour offrir visibilité et protection aux appareils gérés, non gérés et IoT/OT. Le flux de données Armis Devices capture l'inventaire complet des appareils observés sur les réseaux surveillés, y compris les détails du matériel, les attributs réseau, les évaluations des risques et les métadonnées de classification. Ces journaux d'inventaire des appareils peuvent être exportés via l'API REST Armis et écrits dans un bucket GCS pour être ingérés par Google SecOps.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps
• Un projet GCP avec l'API Cloud Storage activée
• Autorisations de créer et de gérer des buckets GCS
• Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
• Une instance Armis Centrix avec accès à l'API
• Une clé secrète d'API Armis avec les autorisations de lecture des données de l'appareil

Générer une clé secrète d'API Armis

1. Connectez-vous à votre console Armis Centrix à l'adresse https://<your-instance>.armis.com.
2. Accédez à Paramètres > Gestion des éléments et sécurité > Gestion des API.
3. Cliquez sur Créer pour générer un nouveau code secret de l'API.
4. Une boîte de dialogue affiche la clé secrète.
5. Copiez et enregistrez la clé secrète de manière sécurisée.

Important : La clé secrète ne s'affiche qu'une seule fois lors de la création. Stockez-le dans un emplacement sécurisé. Vous en aurez besoin pour authentifier les requêtes API.

Vérifier l'accès à l'API

• Testez vos identifiants avant de procéder à l'intégration :

  ARMIS_INSTANCE="https://your-instance.armis.com"
  ARMIS_SECRET_KEY="your-secret-key"
  
  # Get access token
  ACCESS_TOKEN=$(curl -s -X POST "${ARMIS_INSTANCE}/api/v1/access_token/" \
      -d "secret_key=${ARMIS_SECRET_KEY}" \
      | python3 -c "import sys,json; print(json.load(sys.stdin)['data']['access_token'])")
  
  echo "Access Token: ${ACCESS_TOKEN}"
  
  # Test device search
  curl -s "${ARMIS_INSTANCE}/api/v1/search/" \
      -H "Authorization: ${ACCESS_TOKEN}" \
      -G \
      --data-urlencode "aql=in:devices timeFrame:\"1 Hours\"" \
      --data-urlencode "length=1" \
      --data-urlencode "fields=id,name,type,category,model,manufacturer,ipAddress,macAddress,operatingSystem,riskLevel,site,firstSeen,lastSeen" \
      | python3 -m json.tool
  

  Remarque : Le jeton d'accès est temporaire. Pour la fonction Cloud Run, le jeton est automatiquement actualisé avant chaque exécution de collecte de données.

Créer un bucket Google Cloud Storage

1. Accédez à la console Google Cloud.
2. Sélectionnez votre projet ou créez-en un.
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, armis-device-logs).
   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 : Activez la gestion des versions d'objets ou la règle de conservation.

6. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

La fonction Cloud Run a besoin d'un compte de service autorisé à écrire dans le bucket GCS et à être appelée par Pub/Sub.

Créer le compte de service

1. Dans la console GCP, accédez à IAM et administration > Comptes de service.
2. Cliquez sur Créer un compte de service.
3. Fournissez les informations de configuration suivantes :
   • Nom du compte de service : saisissez armis-devices-collector-sa.
   • Description du compte de service : saisissez Service account for Cloud Run function to collect Armis device inventory logs.
4. Cliquez sur Créer et continuer.
5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
   1. Cliquez sur Sélectionner un rôle.
   2. Recherchez et sélectionnez Administrateur des objets Storage.
   3. Cliquez sur + Ajouter un autre rôle.
   4. Recherchez et sélectionnez Demandeur Cloud Run.
   5. Cliquez sur + Ajouter un autre rôle.
   6. Recherchez et sélectionnez Demandeur Cloud Functions.
6. Cliquez sur Continuer.
7. Cliquez sur OK.

Ces rôles sont requis pour :

• Administrateur des objets de l'espace de stockage : écrire des journaux dans un bucket GCS et gérer les fichiers d'état
• Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction.
• Demandeur Cloud Functions : autorise l'appel de fonctions.

Accorder des autorisations IAM sur un bucket GCS

Accordez au compte de service des autorisations d'écriture sur le bucket GCS :

1. Accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom de votre 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 : saisissez l'adresse e-mail du compte de service (par exemple, armis-devices-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

Créez un sujet Pub/Sub dans lequel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

1. Dans la console GCP, accédez à Pub/Sub > Sujets.
2. Cliquez sur Créer un sujet.
3. Fournissez les informations de configuration suivantes :
   • ID du sujet : saisissez armis-devices-trigger.
   • Conservez les valeurs par défaut des autres paramètres.
4. Cliquez sur Créer.

Créer une fonction Cloud Run pour collecter les journaux

La fonction Cloud Run sera déclenchée par les messages Pub/Sub de Cloud Scheduler pour récupérer les enregistrements d'inventaire des appareils à partir de l'API REST Armis et les écrire dans GCS.

1. Dans la console GCP, accédez à Cloud Run.
2. Cliquez sur Créer un service.
3. Sélectionnez Fonction (utilisez un éditeur de modification directe pour créer une fonction).

4. Dans la section Configurer, fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom du service	armis-devices-collector
   Région	Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
   Durée d'exécution	Sélectionnez Python 3.12 ou une version ultérieure.

5. Dans la section Déclencheur (facultatif) :

   1. Cliquez sur + Ajouter un déclencheur.
   2. Sélectionnez Cloud Pub/Sub.
   3. Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet armis-devices-trigger.
   4. Cliquez sur Enregistrer.

6. Dans la section Authentification :

   1. Sélectionnez Exiger l'authentification.
   2. Vérifiez Identity and Access Management (IAM).
   Remarque : Pub/Sub gère automatiquement l'authentification lors de l'appel de la fonction.

7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

8. Accédez à l'onglet Sécurité :

   • Compte de service : sélectionnez le compte de service armis-devices-collector-sa.

9. Accédez à l'onglet Conteneurs :

   1. Cliquez sur Variables et secrets.
   2. Cliquez sur + Ajouter une variable pour chaque variable d'environnement :

   Nom de la variable	Exemple de valeur	Description
   GCS_BUCKET	armis-device-logs	Nom du bucket GCS
   GCS_PREFIX	armis-devices	Préfixe des fichiers journaux
   STATE_KEY	armis-devices/state.json	Chemin d'accès au fichier d'état
   ARMIS_INSTANCE_URL	https://your-instance.armis.com	URL de l'instance Armis
   ARMIS_SECRET_KEY	your-secret-key	Clé secrète de l'API Armis
   PAGE_SIZE	1000	Enregistrements par page d'API
   MAX_RECORDS	50000	Nombre maximal d'enregistrements par exécution
   LOOKBACK_HOURS	24	Période d'analyse initiale

10. Faites défiler la section Variables et secrets vers le bas jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 540 secondes (9 minutes).

11. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • Processeur : sélectionnez 1.

12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100 (ou ajustez en fonction de la charge attendue).

13. Cliquez sur Créer.

14. Attendez que le service soit créé (une à deux minutes).

15. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter un code de fonction

1. Saisissez main dans le champ Point d'entrée.

2. Dans l'éditeur de code intégré, créez deux fichiers :

   • Premier fichier : main.py:

     import functions_framework
     from google.cloud import storage
     import json
     import os
     import urllib3
     import urllib.parse
     from datetime import datetime, timezone, timedelta
     import time
     
     # Initialize HTTP client with timeouts
     http = urllib3.PoolManager(
       timeout=urllib3.Timeout(connect=5.0, read=60.0),
       retries=False,
     )
     
     # Initialize Storage client
     storage_client = storage.Client()
     
     # Environment variables
     GCS_BUCKET = os.environ.get('GCS_BUCKET')
     GCS_PREFIX = os.environ.get('GCS_PREFIX', 'armis-devices').strip('/')
     STATE_KEY = os.environ.get('STATE_KEY') or f"{GCS_PREFIX}/state.json"
     ARMIS_INSTANCE_URL = os.environ.get('ARMIS_INSTANCE_URL', '').rstrip('/')
     ARMIS_SECRET_KEY = os.environ.get('ARMIS_SECRET_KEY')
     PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
     MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '50000'))
     LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
     
     DEVICE_FIELDS = [
       'id', 'name', 'type', 'category', 'model', 'manufacturer',
       'ipAddress', 'macAddress', 'operatingSystem', 'operatingSystemVersion',
       'riskLevel', 'site', 'tags', 'firstSeen', 'lastSeen',
       'boundaries', 'customProperties', 'dataSources', 'userIds',
       'visibility', 'ppiSensitive'
     ]
     
     def parse_datetime(value):
       """Parse ISO datetime string to datetime object."""
       if not value:
         return None
       if value.endswith("Z"):
         value = value[:-1] + "+00:00"
       try:
         return datetime.fromisoformat(value)
       except Exception:
         try:
           return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S')
         except Exception:
           return None
     
     def get_access_token():
       """Obtain an access token from the Armis API."""
       url = f"{ARMIS_INSTANCE_URL}/api/v1/access_token/"
       body = urllib.parse.urlencode({'secret_key': ARMIS_SECRET_KEY})
       response = http.request(
         'POST', url,
         body=body,
         headers={'Content-Type': 'application/x-www-form-urlencoded'}
       )
       if response.status != 200:
         raise Exception(
           f"Failed to get access token: HTTP {response.status} - "
           f"{response.data.decode('utf-8')}"
         )
       data = json.loads(response.data.decode('utf-8'))
       return data['data']['access_token']
     
     @functions_framework.cloud_event
     def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch
       Armis Device inventory records and write to GCS.
     
       Args:
         cloud_event: CloudEvent object containing Pub/Sub message
       """
     
       if not all([GCS_BUCKET, ARMIS_INSTANCE_URL, ARMIS_SECRET_KEY]):
         print('Error: Missing required environment variables')
         return
     
       try:
         bucket = storage_client.bucket(GCS_BUCKET)
     
         # Load state
         state = load_state(bucket, STATE_KEY)
     
         # Determine time window
         now = datetime.now(timezone.utc)
         last_time = None
     
         if isinstance(state, dict) and state.get("last_event_time"):
           try:
             last_time = parse_datetime(state["last_event_time"])
             # Overlap by 2 minutes to catch delayed events
             if last_time:
               last_time = last_time - timedelta(minutes=2)
           except Exception as e:
             print(f"Warning: Could not parse last_event_time: {e}")
     
         if last_time is None:
           last_time = now - timedelta(hours=LOOKBACK_HOURS)
     
         print(
           f"Fetching device logs from "
           f"{last_time.isoformat()} to {now.isoformat()}"
         )
     
         # Get access token
         access_token = get_access_token()
         print("Successfully obtained Armis access token.")
     
         # Fetch device records
         records, newest_event_time = fetch_device_logs(
           access_token=access_token,
           start_time=last_time,
           end_time=now,
         )
     
         if not records:
           print("No new device records found.")
           save_state(bucket, STATE_KEY, now.isoformat())
           return
     
         # Write to GCS as NDJSON
         timestamp = now.strftime('%Y%m%d_%H%M%S')
         object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
         blob = bucket.blob(object_key)
     
         ndjson = '\n'.join(
           [json.dumps(record, ensure_ascii=False) for record in records]
         ) + '\n'
         blob.upload_from_string(
           ndjson, content_type='application/x-ndjson'
         )
     
         print(
           f"Wrote {len(records)} records to "
           f"gs://{GCS_BUCKET}/{object_key}"
         )
     
         # Update state
         if newest_event_time:
           save_state(bucket, STATE_KEY, newest_event_time)
         else:
           save_state(bucket, STATE_KEY, now.isoformat())
     
         print(f"Successfully processed {len(records)} records")
     
       except Exception as e:
         print(f'Error processing device logs: {str(e)}')
         raise
     
     def load_state(bucket, key):
       """Load state from GCS."""
       try:
         blob = bucket.blob(key)
         if blob.exists():
           state_data = blob.download_as_text()
           return json.loads(state_data)
       except Exception as e:
         print(f"Warning: Could not load state: {e}")
       return {}
     
     def save_state(bucket, key, last_event_time_iso):
       """Save the last event timestamp to GCS state file."""
       try:
         state = {'last_event_time': last_event_time_iso}
         blob = bucket.blob(key)
         blob.upload_from_string(
           json.dumps(state, indent=2),
           content_type='application/json'
         )
         print(f"Saved state: last_event_time={last_event_time_iso}")
       except Exception as e:
         print(f"Warning: Could not save state: {e}")
     
     def fetch_device_logs(access_token, start_time, end_time):
       """
       Fetch device inventory logs from Armis REST API with pagination.
     
       Args:
         access_token: Armis API access token
         start_time: Start time for log query
         end_time: End time for log query
     
       Returns:
         Tuple of (records list, newest_event_time ISO string)
       """
       base_url = f"{ARMIS_INSTANCE_URL}/api/v1/search/"
       headers = {'Authorization': access_token}
     
       # Build AQL query with time filter
       start_str = start_time.strftime('%Y-%m-%dT%H:%M:%S')
       aql_query = f'in:devices after:{start_str}'
     
       records = []
       newest_time = None
       page_from = 0
       backoff = 1.0
     
       while True:
         if len(records) >= MAX_RECORDS:
           print(f"Reached max_records limit ({MAX_RECORDS})")
           break
     
         params = {
           'aql': aql_query,
           'from': str(page_from),
           'orderBy': 'lastSeen',
           'length': str(PAGE_SIZE),
           'fields': ','.join(DEVICE_FIELDS),
         }
     
         try:
           response = http.request(
             'GET', base_url,
             fields=params,
             headers=headers
           )
     
           # Handle rate limiting with exponential backoff
           if response.status == 429:
             retry_after = int(
               response.headers.get(
                 'Retry-After', str(int(backoff))
               )
             )
             print(
               f"Rate limited (429). "
               f"Retrying after {retry_after}s..."
             )
             time.sleep(retry_after)
             backoff = min(backoff * 2, 30.0)
             continue
     
           # Handle token expiry
           if response.status == 401:
             print("Access token expired, refreshing...")
             access_token = get_access_token()
             headers = {'Authorization': access_token}
             continue
     
           backoff = 1.0
     
           if response.status != 200:
             print(f"HTTP Error: {response.status}")
             response_text = response.data.decode('utf-8')
             print(f"Response body: {response_text}")
             return records, newest_time
     
           data = json.loads(response.data.decode('utf-8'))
           result = data.get('data', {}).get('results', [])
           total = data.get('data', {}).get('total', 0)
           count = data.get('data', {}).get('count', 0)
           next_from = data.get('data', {}).get('next')
     
           if not result:
             print(f"No more results (empty page)")
             break
     
           print(
             f"Page from={page_from}: Retrieved {count} devices "
             f"(total: {total})"
           )
           records.extend(result)
     
           # Track newest event time using lastSeen
           for device in result:
             try:
               event_time = device.get('lastSeen')
               if event_time:
                 if newest_time is None:
                   newest_time = event_time
                 else:
                   current_dt = parse_datetime(event_time)
                   newest_dt = parse_datetime(newest_time)
                   if (
                     current_dt and newest_dt
                     and current_dt > newest_dt
                   ):
                     newest_time = event_time
             except Exception as e:
               print(
                 f"Warning: Could not parse "
                 f"event time: {e}"
               )
     
           # Check pagination
           if next_from is None or count < PAGE_SIZE:
             print("Reached last page")
             break
     
           page_from = next_from
     
         except Exception as e:
           print(f"Error fetching device logs: {e}")
           return records, newest_time
     
       print(f"Retrieved {len(records)} total device records")
       return records, newest_time
     

     Remarque : Ce script est fourni à titre d'exemple et n'est pas officiellement compatible. N'hésitez pas à nous faire part de vos commentaires pour nous aider à l'améliorer. Pour envoyer des commentaires, cliquez sur Envoyer des commentaires > Commentaires sur le produit de sécurité Google SecOps sur cette page.

   • Deuxième fichier : requirements.txt:

     functions-framework==3.*
     google-cloud-storage==2.*
     urllib3>=2.0.0
     

3. Cliquez sur Déployer pour enregistrer et déployer la fonction.

4. Attendez la fin du déploiement (deux à trois minutes).

   Remarque : L'API Armis utilise le point de terminaison /search/ avec la syntaxe ASQ (Armis Standard Query). La requête in:devices cible spécifiquement les enregistrements d'inventaire des appareils. Le filtre after: est utilisé pour la collecte incrémentielle de données en fonction du code temporel lastSeen. L'API renvoie des résultats paginés à l'aide des paramètres from et length, avec un curseur next dans la réponse.

Créer une tâche Cloud Scheduler

Cloud Scheduler publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera la fonction Cloud Run.

1. Dans la console GCP, accédez à Cloud Scheduler.
2. Cliquez sur Créer une tâche.

3. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom	armis-devices-collector-daily
   Région	Sélectionnez la même région que la fonction Cloud Run.
   Fréquence	0 2 * * * (tous les jours à 2h)
   Fuseau horaire	Sélectionnez un fuseau horaire (UTC recommandé)
   Type de cible	Pub/Sub
   Sujet	Sélectionnez le sujet armis-devices-trigger.
   Corps du message	{} (objet JSON vide)

4. Cliquez sur Créer.

Options de fréquence de programmation

Choisissez la fréquence en fonction du taux de mise à jour de l'inventaire des appareils et des exigences de latence :

Fréquence	Expression Cron	Cas d'utilisation
Toutes les 6 heures	0 */6 * * *	Mises à jour fréquentes de l'inventaire
Tous les jours	0 2 * * *	Standard (recommandé)
Toutes les 12 heures	0 */12 * * *	Environnements à faible volume

Remarque : Les données d'inventaire des appareils changent moins fréquemment que les données d'activité ou d'alerte. Une programmation quotidienne ou biquotidienne est généralement suffisante pour la plupart des environnements. L'intervalle d'interrogation et la fréquence du planificateur doivent correspondre. Si l'intervalle d'interrogation est supérieur à la durée du planificateur, une perte de données peut se produire. Si l'intervalle d'interrogation est inférieur à la durée du planificateur, des données peuvent être dupliquées. L'API Armis accepte une période maximale de 100 jours.

Tester l'intégration

1. Dans la console Cloud Scheduler, recherchez votre job.
2. Cliquez sur Forcer l'exécution pour déclencher le job manuellement.
3. Patientez pendant quelques secondes.
4. Accédez à Cloud Run > Services.
5. Cliquez sur le nom de la fonction armis-devices-collector.
6. Cliquez sur l'onglet Journaux.

7. Vérifiez que la fonction a bien été exécutée. Par exemple :

   Fetching device logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
   Successfully obtained Armis access token.
   Page from=0: Retrieved X devices (total: Y)
   Wrote X records to gs://armis-device-logs/armis-devices/logs_YYYYMMDD_HHMMSS.ndjson
   Successfully processed X records
   

8. Accédez à Cloud Storage > Buckets.

9. Cliquez sur le nom de votre bucket.

10. Accédez au dossier de préfixe armis-devices/.

11. Vérifiez qu'un nouveau fichier .ndjson a été créé avec le code temporel actuel.

Si des erreurs s'affichent dans les journaux :

• HTTP 400 : vérifiez que la syntaxe de la requête AQL est correcte. Vérifiez que l'URL de l'instance Armis ne se termine pas par une barre oblique.
• HTTP 401 : le jeton d'accès a expiré ou n'est pas valide. La fonction actualise automatiquement le jeton en cas d'erreur 401.
• HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec intervalle exponentiel entre les tentatives.
• "Jeton d'accès introuvable" : vérifiez que la clé secrète de l'API Armis est correcte.
• Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies.

Configurer un flux dans Google SecOps pour ingérer les journaux Armis Devices

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, Armis Devices).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez Armis Devices 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 :

   [e-mail]
   

8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

   Remarque : Chaque instance Google SecOps possède un compte de service unique. N'utilisez pas de comptes de service provenant d'autres documentations ou exemples.

9. Cliquez sur Suivant.

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

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

      gs://armis-device-logs/armis-devices/
      

      • Remplacez :
        • armis-device-logs : nom de votre bucket GCS.
        • armis-devices : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laissez ce champ vide pour la racine).
    Remarque : Incluez toujours la barre oblique finale (/) à la fin de l'URI.

    • 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 après un 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.
      Remarque : Si vous sélectionnez une option de suppression, le compte de service doit disposer du rôle Administrateur des objets de l'espace de stockage au lieu du rôle "Lecteur des objets Storage". Mettez à jour les autorisations IAM en conséquence.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • 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 d'actualités 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 GCS.

1. Accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom de votre 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 d'objets Storage.

6. Cliquez sur Enregistrer.

   Remarque : Si vous prévoyez d'utiliser l'option de suppression "Supprimer les fichiers transférés" ou "Supprimer les fichiers transférés et les répertoires vides", attribuez le rôle Administrateur des objets Storage au lieu de "Lecteur des objets Storage".

Table de mappage UDM

Champ du journal	Mappage UDM	Logique
datasource.firstSeen	metadata.event_timestamp	Analysé en tant que yyyy-MM-ddTHH:mm:ssZZ
datasource.lastSeen	metadata.event_timestamp	Analysé en tant que yyyy-MM-ddTHH:mm:ssZZ
firstSeen	metadata.event_timestamp	Analysé en tant que yyyy-MM-ddTHH:mm:ssZZ
lastSeen	metadata.event_timestamp	Analysé en tant que yyyy-MM-ddTHH:mm:ssZZ
time	metadata.event_timestamp	Analysé en tant que yyyy-MM-ddTHH:mm:ss.SSSZZ
id	metadata.product_entity_id	Mappage direct
relation	relations	Renommé/Mappé
N/A	metadata.entity_type	Constante : ASSET
N/A	metadata.product_name	Constante : ARMIS
N/A	metadata.vendor_name	Constante : ARMIS

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.