Collecter les journaux Cisco CloudLock CASB

Compatible avec :

Google SecOps SIEM

Remarque : Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions spécifiques du service Google Security Operations. Les fonctionnalités pré-DG (avant disponibilité générale) sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les Instructions relatives aux services d'assistance technique Google SecOps et les Conditions spécifiques du service Google SecOps.

Ce document explique comment ingérer des journaux Cisco CloudLock CASB dans Google Security Operations à l'aide de Google Cloud Storage .L'analyseur extrait les champs des journaux JSON, les transforme et les mappe au modèle de données unifié (UDM). Il gère l'analyse des dates, convertit des champs spécifiques en chaînes, mappe les champs aux entités UDM (métadonnées, cible, résultat de sécurité, à propos) et parcourt les correspondances pour extraire les champs de détection, en fusionnant finalement toutes les données extraites dans le champ @output.

Cisco CloudLock est un agent de sécurité des accès au cloud (CASB) natif du cloud qui offre visibilité et contrôle sur les applications cloud. Elle aide les entreprises à découvrir le shadow IT, à appliquer des règles de protection contre la perte de données, à détecter les menaces et à assurer la conformité dans les applications SaaS.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

• Une instance Google SecOps
• Projet GCP avec l'API Cloud Storage activée
• Autorisations pour créer et gérer des buckets GCS
• Autorisations permettant de gérer les stratégies IAM sur les buckets GCS
• Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des tâches Cloud Scheduler
• Accès privilégié à la console d'administration Cisco CloudLock

Obtenir les conditions préalables de l'API Cisco CloudLock

Pour commencer, contactez l'assistance Cloudlock afin d'obtenir votre URL de l'API Cloudlock. Générez un jeton d'accès dans l'application Cloudlock en sélectionnant l'onglet "Authentication & API" (Authentification et API) sur la page "Settings" (Paramètres), puis en cliquant sur "Generate" (Générer).

1. Connectez-vous à la console d'administration Cisco CloudLock.
2. Accédez à Paramètres> Authentification et API.
3. Sous API, cliquez sur Générer pour créer votre jeton d'accès.
4. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
   • Jeton d'accès à l'API
   • URL de base de l'API (fournie par l'assistance Cisco CloudLock à l'adresse [email protected])

Remarque : Les clés API, les mots de passe, les secrets et les jetons permettent d'accéder à vos données client privées. Vous ne devez jamais les partager avec un autre utilisateur ni une autre organisation.

Créer un bucket Google Cloud Storage

1. Accédez à la consoleGoogle 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
   Nommer votre bucket	Saisissez un nom unique (par exemple, cisco-cloudlock-logs).
   Type d'emplacement	Choisissez en fonction de vos besoins (région, birégion ou multirégion).
   Emplacement	Sélectionnez l'emplacement (par exemple, us-central1).
   Classe de stockage	Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
   Access control (Contrôle des accès)	Uniforme (recommandé)
   Outils de protection	Facultatif : Activer la gestion des versions des 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 disposant des autorisations nécessaires pour écrire dans le bucket GCS.

Créer un 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 cloudlock-data-export-sa.
   • Description du compte de service : saisissez Service account for Cloud Run function to collect Cisco CloudLock logs.
4. Cliquez sur Créer et continuer.
5. Dans la section Autoriser ce compte de service à accéder au projet :
   1. Cliquez sur Sélectionner un rôle.
   2. Recherchez et sélectionnez Administrateur des objets de l'espace de stockage.
   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.

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 du 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, cloudlock-data-export-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 auquel 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 Create topic (Créer un sujet).
3. Fournissez les informations de configuration suivantes :
   • ID du sujet : saisissez cloudlock-data-export-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 extraire les journaux de l'API Cisco CloudLock 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 intégré pour créer une fonction).

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

   Paramètre	Valeur
   Nom du service	cloudlock-data-export
   Région	Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
   Runtime (durée d'exécution)	Sélectionnez Python 3.12 ou version ultérieure.

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

   • Cliquez sur + Ajouter un déclencheur.
   • Sélectionnez Cloud Pub/Sub.
   • Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet (cloudlock-data-export-trigger).
   • Cliquez sur Enregistrer.

6. Dans la section Authentification :

   • Sélectionnez Exiger l'authentification.
   • Consultez 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 jusqu'à Conteneurs, mise en réseau, sécurité, puis développez cette section.

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

   • Compte de service : sélectionnez le compte de service (cloudlock-data-export-sa).

9. Accédez à l'onglet Conteneurs :

   • Cliquez sur Variables et secrets.

   • Cliquez sur + Ajouter une variable pour chaque variable d'environnement :

     Nom de la variable	Exemple de valeur
     GCS_BUCKET	cisco-cloudlock-logs
     GCS_PREFIX	cloudlock/
     STATE_KEY	cloudlock/state.json
     CLOUDLOCK_API_TOKEN	your-api-token
     CLOUDLOCK_API_BASE	https://api.cloudlock.com

10. Dans l'onglet Variables et secrets, faites défiler la page jusqu'à Requêtes :

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

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

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • CPU : sélectionnez 1.
    • Cliquez sur OK.

12. Faites défiler la page jusqu'à Environnement d'exécution :

    • Sélectionnez Par défaut (recommandé).

13. 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).

14. Cliquez sur Créer.

15. Attendez que le service soit créé (1 à 2 minutes).

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

Ajouter un code de fonction

1. Saisissez main dans Point d'entrée de la fonction.

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
     from datetime import datetime, timezone, timedelta
     import time
     
     # Initialize HTTP client
     http = urllib3.PoolManager()
     
     # Initialize Storage client
     storage_client = storage.Client()
     
     @functions_framework.cloud_event
     def main(cloud_event):
         """
         Cloud Run function triggered by Pub/Sub to fetch logs from Cisco CloudLock API and write to GCS.
     
         Args:
             cloud_event: CloudEvent object containing Pub/Sub message
         """
     
         # Get environment variables
         bucket_name = os.environ.get('GCS_BUCKET')
         prefix = os.environ.get('GCS_PREFIX', 'cloudlock/')
         state_key = os.environ.get('STATE_KEY', 'cloudlock/state.json')
         api_token = os.environ.get('CLOUDLOCK_API_TOKEN')
         api_base = os.environ.get('CLOUDLOCK_API_BASE')
     
         if not all([bucket_name, api_token, api_base]):
             print('Error: Missing required environment variables')
             return
     
         try:
             # Get GCS bucket
             bucket = storage_client.bucket(bucket_name)
     
             # Load state (last processed offset for each endpoint)
             state = load_state(bucket, state_key)
     
             print(f'Processing logs with state: {state}')
     
             # Create Authorization header
             headers = {
                 'Authorization': f'Bearer {api_token}',
                 'Content-Type': 'application/json'
             }
     
             # Fetch incidents data (using offset-based pagination)
             incidents_offset = state.get('incidents_offset', 0)
             incidents, new_incidents_offset = fetch_cloudlock_incidents(
                 http, api_base, headers, incidents_offset
             )
     
             if incidents:
                 upload_to_gcs_ndjson(bucket, prefix, 'incidents', incidents)
                 print(f'Uploaded {len(incidents)} incidents to GCS')
                 state['incidents_offset'] = new_incidents_offset
     
             # Fetch activities data (using time-based filtering with offset pagination)
             activities_last_time = state.get('activities_last_time')
             if not activities_last_time:
                 activities_last_time = (datetime.now(timezone.utc) - timedelta(hours=24)).isoformat()
     
             activities_offset = state.get('activities_offset', 0)
             activities, new_activities_offset, newest_activity_time = fetch_cloudlock_activities(
                 http, api_base, headers, activities_last_time, activities_offset
             )
     
             if activities:
                 upload_to_gcs_ndjson(bucket, prefix, 'activities', activities)
                 print(f'Uploaded {len(activities)} activities to GCS')
                 state['activities_offset'] = new_activities_offset
                 if newest_activity_time:
                     state['activities_last_time'] = newest_activity_time
     
             # Fetch entities data (using offset-based pagination)
             entities_offset = state.get('entities_offset', 0)
             entities, new_entities_offset = fetch_cloudlock_entities(
                 http, api_base, headers, entities_offset
             )
     
             if entities:
                 upload_to_gcs_ndjson(bucket, prefix, 'entities', entities)
                 print(f'Uploaded {len(entities)} entities to GCS')
                 state['entities_offset'] = new_entities_offset
     
             # Update consolidated state
             state['updated_at'] = datetime.now(timezone.utc).isoformat()
             save_state(bucket, state_key, state)
     
             print('CloudLock data export completed successfully')
     
         except Exception as e:
             print(f'Error processing logs: {str(e)}')
             raise
     
     def make_api_request(http, url, headers, retries=3):
         """Make API request with exponential backoff retry logic."""
         for attempt in range(retries):
             try:
                 response = http.request('GET', url, headers=headers)
     
                 if response.status == 200:
                     return response
                 elif response.status == 429:
                     # Rate limit
                     retry_after = int(response.headers.get('Retry-After', 60))
                     print(f'Rate limited, waiting {retry_after} seconds')
                     time.sleep(retry_after)
                 else:
                     print(f'API request failed with status {response.status}: {response.data.decode("utf-8")}')
             except Exception as e:
                 print(f'Request attempt {attempt + 1} failed: {str(e)}')
                 if attempt < retries - 1:
                     wait_time = 2 ** attempt
                     time.sleep(wait_time)
                 else:
                     raise
     
         return None
     
     def fetch_cloudlock_incidents(http, api_base, headers, start_offset=0):
         """
         Fetch incidents data from Cisco CloudLock API using offset-based pagination.
     
         Note: The CloudLock API does not support updated_after parameter. This function
         uses offset-based pagination. For production use, consider implementing time-based
         filtering using created_at or updated_at fields in the response data.
         """
         url = f"{api_base}/api/v2/incidents"
     
         limit = 1000
         offset = start_offset
         all_data = []
     
         try:
             while True:
                 # Build URL with parameters
                 full_url = f"{url}?limit={limit}&offset={offset}"
     
                 print(f"Fetching incidents with offset: {offset}")
     
                 response = make_api_request(http, full_url, headers)
                 if not response:
                     break
     
                 data = json.loads(response.data.decode('utf-8'))
     
                 # CloudLock API returns items in 'items' array
                 batch_data = data.get('items', [])
     
                 if not batch_data:
                     print("No more incidents to fetch")
                     break
     
                 all_data.extend(batch_data)
     
                 # Check if we've reached the end
                 total = data.get('total', 0)
                 results = data.get('results', len(batch_data))
     
                 print(f"Fetched {results} incidents (total available: {total})")
     
                 if results < limit or offset + results >= total:
                     print("Reached end of incidents")
                     break
     
                 offset += limit
     
             print(f"Fetched {len(all_data)} total incidents")
             return all_data, offset
     
         except Exception as e:
             print(f"Error fetching incidents: {str(e)}")
             return [], start_offset
     
     def fetch_cloudlock_activities(http, api_base, headers, from_time, start_offset=0):
         """
         Fetch activities data from Cisco CloudLock API using time-based filtering and offset pagination.
         """
         url = f"{api_base}/api/v2/activities"
     
         limit = 1000
         offset = start_offset
         all_data = []
         newest_time = None
     
         try:
             while True:
                 # Build URL with time filter and pagination
                 full_url = f"{url}?limit={limit}&offset={offset}"
     
                 print(f"Fetching activities with offset: {offset}")
     
                 response = make_api_request(http, full_url, headers)
                 if not response:
                     break
     
                 data = json.loads(response.data.decode('utf-8'))
                 batch_data = data.get('items', [])
     
                 if not batch_data:
                     print("No more activities to fetch")
                     break
     
                 # Filter activities by time (client-side filtering since API may not support time parameters)
                 filtered_batch = []
                 for item in batch_data:
                     item_time = item.get('timestamp') or item.get('created_at')
                     if item_time and item_time >= from_time:
                         filtered_batch.append(item)
                         if not newest_time or item_time > newest_time:
                             newest_time = item_time
     
                 all_data.extend(filtered_batch)
     
                 results = data.get('results', len(batch_data))
                 total = data.get('total', 0)
     
                 print(f"Fetched {results} activities, {len(filtered_batch)} after time filter (total available: {total})")
     
                 if results < limit or offset + results >= total:
                     print("Reached end of activities")
                     break
     
                 offset += limit
     
             print(f"Fetched {len(all_data)} total activities")
             return all_data, offset, newest_time
     
         except Exception as e:
             print(f"Error fetching activities: {str(e)}")
             return [], start_offset, None
     
     def fetch_cloudlock_entities(http, api_base, headers, start_offset=0):
         """
         Fetch entities data from Cisco CloudLock API using offset-based pagination.
     
         Note: This endpoint requires the Entity Cache feature. If not enabled,
         use the incident entities endpoint as an alternative.
         """
         url = f"{api_base}/api/v2/entities"
     
         limit = 1000
         offset = start_offset
         all_data = []
     
         try:
             while True:
                 full_url = f"{url}?limit={limit}&offset={offset}"
     
                 print(f"Fetching entities with offset: {offset}")
     
                 response = make_api_request(http, full_url, headers)
                 if not response:
                     break
     
                 data = json.loads(response.data.decode('utf-8'))
                 batch_data = data.get('items', [])
     
                 if not batch_data:
                     print("No more entities to fetch")
                     break
     
                 all_data.extend(batch_data)
     
                 results = data.get('results', len(batch_data))
                 total = data.get('total', 0)
     
                 print(f"Fetched {results} entities (total available: {total})")
     
                 if results < limit or offset + results >= total:
                     print("Reached end of entities")
                     break
     
                 offset += limit
     
             print(f"Fetched {len(all_data)} total entities")
             return all_data, offset
     
         except Exception as e:
             print(f"Error fetching entities: {str(e)}")
             return [], start_offset
     
     def upload_to_gcs_ndjson(bucket, prefix, data_type, data):
         """Upload data to GCS bucket in NDJSON format (one JSON object per line)."""
         timestamp = datetime.now(timezone.utc).strftime('%Y/%m/%d/%H')
         filename = f"{prefix}{data_type}/{timestamp}/cloudlock_{data_type}_{int(datetime.now(timezone.utc).timestamp())}.jsonl"
     
         try:
             # Convert to NDJSON format
             ndjson_content = '\n'.join([json.dumps(item, separators=(',', ':')) for item in data])
     
             blob = bucket.blob(filename)
             blob.upload_from_string(
                 ndjson_content,
                 content_type='application/x-ndjson'
             )
     
             print(f"Successfully uploaded {filename} to GCS")
     
         except Exception as e:
             print(f"Error uploading to GCS: {str(e)}")
             raise
     
     def load_state(bucket, key):
         """Load state from GCS with separate tracking for each endpoint."""
         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: {str(e)}')
     
         print("No previous state found, starting fresh")
         return {}
     
     def save_state(bucket, key, state):
         """Save consolidated state to GCS."""
         try:
             blob = bucket.blob(key)
             blob.upload_from_string(
                 json.dumps(state, indent=2),
                 content_type='application/json'
             )
             print("Updated state successfully")
         except Exception as e:
             print(f"Error updating state: {str(e)}")
             raise
     

     • 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 : Ce script utilise les points de terminaison de l'API Cisco CloudLock avec pagination basée sur le décalage, comme indiqué dans la spécification officielle de l'API. L'API CloudLock n'est pas compatible avec le paramètre updated_after pour la synchronisation incrémentielle sur les points de terminaison des incidents et des entités. Pour les déploiements en production, envisagez d'implémenter une logique de filtrage supplémentaire basée sur le temps ou contactez l'assistance Cisco CloudLock à l'adresse [email protected] pour vérifier les fonctionnalités d'API les plus récentes pour votre locataire.

Créer une tâche Cloud Scheduler

Cloud Scheduler publie des messages sur le sujet Pub/Sub à intervalles réguliers, ce qui déclenche 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	cloudlock-data-export-hourly
   Région	Sélectionnez la même région que la fonction Cloud Run.
   Fréquence	0 * * * * (toutes les heures)
   Fuseau horaire	Sélectionnez un fuseau horaire (UTC recommandé).
   Type de cible	Pub/Sub
   Topic	Sélectionnez le thème (cloudlock-data-export-trigger).
   Corps du message	{} (objet JSON vide)

4. Cliquez sur Créer.

Options de fréquence de planification

• Choisissez la fréquence en fonction du volume de journaux et des exigences de latence :

  Fréquence	Expression Cron	Cas d'utilisation
  Toutes les 5 minutes	*/5 * * * *	Volume élevé, faible latence
  Toutes les 15 minutes	*/15 * * * *	Volume moyen
  Toutes les heures	0 * * * *	Standard (recommandé)
  Toutes les 6 heures	0 */6 * * *	Traitement par lot à faible volume
  Tous les jours	0 0 * * *	Collecte de données historiques

Tester le job Scheduler

1. Dans la console Cloud Scheduler, recherchez votre job.
2. Cliquez sur Forcer l'exécution pour déclencher manuellement l'exécution.
3. Patientez quelques secondes, puis accédez à Cloud Run > Services > cloudlock-data-export > Journaux.
4. Vérifiez que la fonction s'est exécutée correctement.
5. Vérifiez le bucket GCS pour confirmer que les journaux ont été écrits.

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket GCS. Vous devez accorder à ce compte de service l'accès à votre bucket.

Obtenir l'adresse e-mail du compte de service

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Add New Feed (Ajouter un flux).
3. Cliquez sur Configurer un flux unique.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Cisco CloudLock logs).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez Cisco CloudLock comme Type de journal.

7. Cliquez sur Obtenir un compte de service. Une adresse e-mail unique pour le compte de service 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 documents ou exemples.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin du rôle Lecteur des objets Storage sur votre bucket GCS.

1. Accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom du 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.
   • Attribuez des rôles : sélectionnez Lecteur des objets de l'espace de stockage.
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", accordez le rôle Administrateur des objets Storage au lieu de Lecteur des objets Storage.

Configurer un flux dans Google SecOps pour ingérer les journaux Cisco CloudLock

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Add New Feed (Ajouter un flux).
3. Cliquez sur Configurer un flux unique.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Cisco CloudLock logs).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez Cisco CloudLock comme Type de journal.
7. Cliquez sur Suivant.

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

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

     gs://cisco-cloudlock-logs/cloudlock/
     

     • Remplacez :

       • cisco-cloudlock-logs : nom de votre bucket GCS.
       • cloudlock/ : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laisser vide pour la racine).

     • Exemples :

       • Bucket racine : gs://cisco-cloudlock-logs/
       • Avec préfixe : gs://cisco-cloudlock-logs/cloudlock/
       • Avec un sous-dossier : gs://cisco-cloudlock-logs/cloudlock/incidents/
   Remarque : Incluez toujours la barre oblique (/) à la fin de l'URI.

   • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

     • Jamais : ne supprime jamais aucun fichier 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 après un transfert réussi.

       Remarque : Si vous sélectionnez une option de suppression, le compte de service doit disposer du rôle Administrateur des objets Storage au lieu de celui de lecteur. Mettez à jour les autorisations IAM en conséquence.

   • Âge maximal des fichiers : 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.

   • Libellés d'ingestion : libellé à appliquer aux événements de ce flux.

9. Cliquez sur Suivant.

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

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
created_at	about.resource.attribute.labels.key	La valeur du champ "created_at" est attribuée à la clé "labels".
created_at	about.resource.attribute.labels.value	La valeur du champ "created_at" est attribuée à la valeur des libellés.
created_at	about.resource.attribute.creation_time	Le champ "created_at" est analysé en tant qu'horodatage et mappé.
entity.id	target.asset.product_object_id	Le champ "entity.id" est renommé.
entity.ip	target.ip	Le champ entity.ip est fusionné dans le champ IP cible.
entity.mime_type	target.file.mime_type	Le champ entity.mime_type est renommé lorsque entity.origin_type est défini sur "document".
entity.name	target.application	Le champ entity.name est renommé lorsque entity.origin_type est défini sur "app".
entity.name	target.file.full_path	Le champ entity.name est renommé lorsque entity.origin_type est défini sur "document".
entity.origin_id	target.resource.product_object_id	Le champ "entity.origin_id" est renommé.
entity.origin_type	target.resource.resource_subtype	Le nom du champ entity.origin_type a été modifié.
entity.owner_email	target.user.email_addresses	Le champ entity.owner_email est fusionné dans le champ d'adresse e-mail de l'utilisateur cible s'il correspond à une expression régulière d'adresse e-mail.
entity.owner_email	target.user.user_display_name	Le nom du champ "entity.owner_email" est modifié s'il ne correspond pas à une expression régulière d'adresse e-mail.
entity.owner_name	target.user.user_display_name	Le nom du champ entity.owner_name est modifié lorsque entity.owner_email correspond à une expression régulière d'adresse e-mail.
entity.vendor.name	target.platform_version	Le champ "entity.vendor.name" est renommé.
id	metadata.product_log_id	Le champ "id" est renommé.
incident_status	metadata.product_event_type	Le champ "incident_status" est renommé.
	metadata.event_timestamp	La valeur est codée en dur sur "updated_at". La valeur est dérivée du champ "updated_at". Le champ "updated_at" est analysé en tant qu'horodatage et mappé.
	security_result.detection_fields.key	Définissez sur "true" si la gravité est "ALERT" et que l'état de l'incident est "NEW". Converti en valeur booléenne.
	security_result.detection_fields.value	Définissez sur "true" si la gravité est "ALERT" et que l'état de l'incident est "NEW". Converti en valeur booléenne.
	metadata.event_type	La valeur est codée en dur sur "GENERIC_EVENT".
	metadata.product_name	La valeur est codée en dur sur "CISCO_CLOUDLOCK_CASB".
	metadata.vendor_name	La valeur est codée en dur sur "CloudLock".
	metadata.product_version	La valeur est codée en dur sur "Cisco".
	security_result.alert_state	Définissez la valeur sur "ALERTING" si la gravité est "ALERT" et que l'état de l'incident n'est pas "RESOLVED" ni "DISMISSED". Définissez sur "NOT_ALERTING" si la gravité est "ALERT" et que l'état de l'incident est "RESOLVED" ou "DISMISSED".
	security_result.detection_fields.key	Dérivé du tableau des correspondances, plus précisément de la clé de chaque objet de correspondance.
	security_result.detection_fields.value	Dérivé du tableau des correspondances, plus précisément de la valeur de chaque objet de correspondance.
	security_result.rule_id	Dérivé de policy.id.
	security_result.rule_name	Dérivé de policy.name.
	security_result.severity	Définissez la valeur sur "INFORMATIONAL" si la gravité est "INFO". Définissez la valeur sur "CRITICAL" si la gravité est "CRITICAL". Dérivé de la gravité.
	security_result.summary	La valeur est définie sur "match count: " concaténée avec la valeur de match_count.
	target.resource.resource_type	Définissez sur "STORAGE_OBJECT" lorsque entity.origin_type est défini sur "document".
	target.url	Dérivé de entity.direct_url lorsque entity.origin_type est défini sur "document".
policy.id	security_result.rule_id	Le champ "policy.id" est renommé.
policy.name	security_result.rule_name	Le champ "policy.name" est renommé.
de gravité,	security_result.severity_details	Le nom du champ "severity" (gravité) a été modifié.
updated_at	about.resource.attribute.labels.key	La valeur du champ "updated_at" est attribuée à la clé "labels".
updated_at	about.resource.attribute.labels.value	La valeur du champ "updated_at" est attribuée à la valeur des libellés.
updated_at	about.resource.attribute.last_update_time	Le champ "updated_at" est analysé en tant qu'horodatage et mappé.

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