Collecter les journaux Nagios XI

Compatible avec :

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

Nagios XI est une solution complète de surveillance de l'infrastructure qui permet de surveiller les serveurs, les réseaux, les applications et les services. Il suit l'état des hôtes et des services, ainsi que les métriques de performances, et génère des alertes pour les problèmes d'infrastructure IT via son API REST.

Avant de commencer

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

  • Une instance Google SecOps
  • Un projet GCP avec les API Cloud Storage, Cloud Run, Pub/Sub et Cloud Scheduler activées
  • Autorisations permettant de créer et de 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 jobs Cloud Scheduler
  • Accès privilégié à Nagios XI avec des autorisations de gestion des utilisateurs
  • Nagios XI version 5 ou ultérieure (compatibilité avec l'API REST)

Configurer l'accès à l'API Nagios XI

Pour permettre à Google SecOps de récupérer les données de surveillance, vous devez créer un compte utilisateur avec un accès à l'API et des autorisations en lecture seule.

Créer un utilisateur en lecture seule avec accès à l'API

  1. Connectez-vous à l'interface Web Nagios XI avec des droits d'administrateur.
  2. Accédez à Admin > Gérer les utilisateurs.
  3. Cliquez sur Ajouter un nouvel utilisateur.
  4. Fournissez les informations de configuration suivantes :
    • Nom d'utilisateur : saisissez un nom descriptif (par exemple, chronicle-integration).
    • Mot de passe : saisissez un mot de passe sécurisé.
    • Nom : saisissez Chronicle Integration User.
    • Adresse e-mail : saisissez une adresse e-mail valide.
  5. Dans la section Paramètres de sécurité, configurez les éléments suivants :
    • Niveau d'autorisation : sélectionnez Utilisateur.
    • Can see all hosts and services (Peut voir tous les hôtes et services) : cochez cette option.
    • Accès en lecture seule : cochez cette option.
    • Accès à l'API : cochez cette option.
  6. Décochez les options suivantes :
    • Forcer le changement de mot de passe à la prochaine connexion
    • Envoyer les informations du compte utilisateur par e-mail
    • Créer en tant que contact Monitoring
  7. Assurez-vous que l'option Account Enabled (Compte activé) est cochée.
  8. Cliquez sur Ajouter un utilisateur.

Récupérer la clé API

  1. Sur la page Gérer les utilisateurs, cliquez sur le compte utilisateur (chronicle-integration).
  2. Sur la page des paramètres du compte utilisateur, recherchez le champ Clé API.

  3. Copiez la valeur de la clé API.

Vérifier les autorisations

Pour vérifier que le compte dispose des autorisations requises :

  1. Connectez-vous à Nagios XI avec le compte utilisateur chronicle-integration.
  2. Accédez à Accueil > État de l'hôte.
  3. Si vous pouvez voir tous les hôtes et services surveillés, vous disposez des autorisations requises.
  4. Si vous ne voyez pas d'hôtes ni de services, contactez votre administrateur pour qu'il vous accorde l'autorisation Peut voir tous les hôtes et services.

Tester l'accès à l'API

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

    # Replace with your actual values
NAGIOS_HOST="https://your-nagios-server.example.com"
API_KEY="your-api-key"

# Test API access - query host status
curl -k "${NAGIOS_HOST}/nagiosxi/api/v1/objects/hoststatus?apikey=${API_KEY}&pretty=1"

    Une réponse réussie renvoie un objet JSON contenant des informations sur l'état de l'hôte.

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, nagios-xi-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 auxquels vous accédez fréquemment)
    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

  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 nagios-logs-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Nagios XI 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.

Accorder des autorisations IAM sur le bucket GCS

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (nagios-xi-logs).
  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 (nagios-logs-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

  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 nagios-logs-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 des messages Pub/Sub provenant de Cloud Scheduler pour extraire les journaux de l'API REST Nagios XI 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 nagios-logs-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 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 nagios-logs-trigger.
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Consultez Identity and Access Management (IAM).

  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 nagios-logs-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 nagios-xi-logs Nom du bucket GCS
    GCS_PREFIX nagios-xi Préfixe des fichiers journaux
    STATE_KEY nagios-xi/state.json Chemin d'accès au fichier d'état
    NAGIOS_BASE_URL https://your-nagios-server.example.com URL de base de Nagios XI
    NAGIOS_API_KEY your-api-key Clé API Nagios XI
    MAX_RECORDS 1000 Nombre maximal d'enregistrements par point de terminaison et par exécution
    PAGE_SIZE 200 Page "Enregistrements par API"
    LOOKBACK_HOURS 24 Période d'analyse initiale

  10. Dans la section 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 la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • CPU : sélectionnez 1.

  12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100.

  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 :

    • main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time

http = urllib3.PoolManager(
  timeout=urllib3.Timeout(connect=5.0, read=30.0),
  retries=False,
)

storage_client = storage.Client()

GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'nagios-xi')
STATE_KEY = os.environ.get('STATE_KEY', 'nagios-xi/state.json')
NAGIOS_BASE_URL = os.environ.get('NAGIOS_BASE_URL', '').rstrip('/')
NAGIOS_API_KEY = os.environ.get('NAGIOS_API_KEY')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '1000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '200'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

ENDPOINTS = [
  'hoststatus',
  'servicestatus',
  'statehistory',
  'logentries',
]

@functions_framework.cloud_event
def main(cloud_event):
  if not all([GCS_BUCKET, NAGIOS_BASE_URL, NAGIOS_API_KEY]):
    print('Error: Missing required environment variables')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)
    state = load_state(bucket)
    now = datetime.now(timezone.utc)

    if isinstance(state, dict) and state.get('last_event_time'):
      try:
        last_val = state['last_event_time']
        if last_val.endswith('Z'):
          last_val = last_val[:-1] + '+00:00'
        last_time = datetime.fromisoformat(last_val)
        last_time = last_time - timedelta(minutes=2)
      except Exception as e:
        print(f"Warning: Could not parse last_event_time: {e}")
        last_time = now - timedelta(hours=LOOKBACK_HOURS)
    else:
      last_time = now - timedelta(hours=LOOKBACK_HOURS)

    print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")

    start_ts = int(last_time.timestamp())
    end_ts = int(now.timestamp())

    all_records = []
    newest_time = None

    for endpoint in ENDPOINTS:
      records, endpoint_newest = fetch_nagios_endpoint(
        endpoint, start_ts, end_ts
      )
      for record in records:
        record['_nagios_endpoint'] = endpoint
      all_records.extend(records)

      if endpoint_newest:
        if newest_time is None or endpoint_newest > newest_time:
          newest_time = endpoint_newest

    if not all_records:
      print("No new records found.")
      save_state(bucket, now.isoformat())
      return

    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/nagios_logs_{timestamp}.ndjson"
    blob = bucket.blob(object_key)

    ndjson = '\n'.join(
      [json.dumps(r, ensure_ascii=False, default=str) for r in all_records]
    ) + '\n'
    blob.upload_from_string(ndjson, content_type='application/x-ndjson')

    print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}")

    if newest_time:
      save_state(bucket, newest_time)
    else:
      save_state(bucket, now.isoformat())

    print(f"Successfully processed {len(all_records)} records")

  except Exception as e:
    print(f'Error processing logs: {str(e)}')
    raise

def fetch_nagios_endpoint(endpoint, start_ts, end_ts):
  base_url = f"{NAGIOS_BASE_URL}/nagiosxi/api/v1/objects/{endpoint}"

  records = []
  newest_time = None
  start_index = 0
  page_num = 0
  backoff = 1.0

  while True:
    page_num += 1

    if len(records) >= MAX_RECORDS:
      print(f"{endpoint}: Reached max_records limit ({MAX_RECORDS})")
      break

    remaining = min(PAGE_SIZE, MAX_RECORDS - len(records))
    params = [
      f"apikey={NAGIOS_API_KEY}",
      f"starttime={start_ts}",
      f"endtime={end_ts}",
      f"records={remaining}",
      f"start={start_index}",
    ]
    url = f"{base_url}?{'&'.join(params)}"

    try:
      response = http.request('GET', url)

      if response.status == 429:
        retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
        print(f"{endpoint}: Rate limited (429). Retrying after {retry_after}s...")
        time.sleep(retry_after)
        backoff = min(backoff * 2, 30.0)
        continue

      backoff = 1.0

      if response.status != 200:
        print(f"{endpoint}: HTTP Error {response.status}")
        response_text = response.data.decode('utf-8')
        print(f"Response body: {response_text}")
        break

      data = json.loads(response.data.decode('utf-8'))

      record_count = data.get('recordcount', 0)
      result_key = get_result_key(endpoint)
      page_results = data.get(result_key, [])

      if not page_results:
        print(f"{endpoint}: No more results at offset {start_index}")
        break

      print(f"{endpoint} page {page_num}: Retrieved {len(page_results)} events")
      records.extend(page_results)

      for event in page_results:
        try:
          event_time = event.get('state_time') or event.get('status_update_time') or event.get('entry_time')
          if event_time:
            if newest_time is None or event_time > newest_time:
              newest_time = event_time
        except Exception as e:
          print(f"Warning: Could not parse event time: {e}")

      if len(page_results) < remaining:
        print(f"{endpoint}: Reached last page (returned {len(page_results)} < {remaining})")
        break

      start_index += len(page_results)

    except Exception as e:
      print(f"{endpoint}: Error fetching logs: {e}")
      break

  print(f"{endpoint}: Retrieved {len(records)} total records from {page_num} pages")
  return records, newest_time

def get_result_key(endpoint):
  key_map = {
    'hoststatus': 'hoststatus',
    'servicestatus': 'servicestatus',
    'statehistory': 'statehistory',
    'logentries': 'logentry',
  }
  return key_map.get(endpoint, endpoint)

def load_state(bucket):
  try:
    blob = bucket.blob(STATE_KEY)
    if blob.exists():
      return json.loads(blob.download_as_text())
  except Exception as e:
    print(f"Warning: Could not load state: {e}")
  return {}

def save_state(bucket, last_event_time_iso):
  try:
    state = {
      'last_event_time': last_event_time_iso,
      'last_run': datetime.now(timezone.utc).isoformat()
    }
    blob = bucket.blob(STATE_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}")

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

Créer une tâche Cloud Scheduler

  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 nagios-logs-collector-hourly
    Région Sélectionnez la même région que la fonction Cloud Run.
    Fréquence 0 * * * * (toutes les heures, à l'heure pile)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).
    Type de cible Pub/Sub
    Sujet Sélectionner nagios-logs-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 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 de faible volume
Tous les jours 0 0 * * * Collecte de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job (nagios-logs-collector-hourly).
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur nagios-logs-collector.
  6. Cliquez sur l'onglet Journaux.

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

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
hoststatus page 1: Retrieved X events
servicestatus page 1: Retrieved X events
statehistory page 1: Retrieved X events
logentries page 1: Retrieved X events
Wrote X records to gs://nagios-xi-logs/nagios-xi/nagios_logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur nagios-xi-logs.

  10. Accédez au dossier nagios-xi/.

  11. Vérifiez qu'un nouveau fichier .ndjson a été créé avec l'horodatage actuel.

Si des erreurs s'affichent dans les journaux :

  • HTTP 401 : vérifiez que la variable d'environnement NAGIOS_API_KEY est correcte et que l'utilisateur a activé l'accès à l'API.
  • HTTP 403 : vérifiez que le compte utilisateur dispose de l'autorisation Peut voir tous les hôtes et services.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un délai d'attente.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.

Récupérer le compte de service Google SecOps

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur 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, Nagios XI Logs GCS).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Nagios comme Type de journal.
  7. Cliquez sur Obtenir un compte de service.

  8. Une adresse e-mail de compte de service unique s'affiche. Exemple :

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

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

  10. Cliquez sur Suivant.

  11. 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 au préfixe :

      gs://nagios-xi-logs/nagios-xi/

    • 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 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 : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

    • 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

  12. Cliquez sur Suivant.

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

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur nagios-xi-logs.
  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.

Table de mappage UDM

Champ de journal Mappage UDM Logique
src_ip has_principal Définie sur "true" si la fusion de src_ip avec principal.ip et principal.asset.ip réussit
src_ip principal.asset.ip Valeur copiée directement
src_ip principal.ip Valeur copiée directement
jobid jobid_label.key Définir sur "Jobid"
jobid jobid_label.value Valeur copiée directement
jobid_label principal.resource.attribute.labels Fusionné à partir de jobid_label
pid principal.process.pid Valeur copiée directement
ent metadata.product_event_type Valeur copiée directement
description metadata.description Valeur copiée directement
msg_ip has_target Défini sur "true" si la fusion de msg_ip avec target.ip et target.asset.ip réussit
msg_ip target.asset.ip Valeur copiée directement
msg_ip target.ip Valeur copiée directement
port target.port Valeur copiée directement et convertie en entier
column1 principal.asset.hostname Valeur de la colonne 1 si ent == "SERVICE ALERT", sinon valeur de la colonne 2 si ent == "SERVICE NOTIFICATION"
column1 principal.hostname Valeur de la colonne 1 si ent == "SERVICE ALERT", sinon de la colonne 2 si ent == "SERVICE NOTIFICATION"
column1 principal.user.user_display_name Valeur copiée directement si ent == "SERVICE NOTIFICATION"
column2 security_result.summary Valeur de la colonne 3 si ent == "SERVICE ALERT" et que la colonne 2 n'est pas vide, sinon de la colonne 3 si ent == "SERVICE NOTIFICATION"
column3 security_result.summary Valeur de la colonne 3 si ent == "SERVICE ALERT" et que la colonne 3 n'est pas vide, sinon valeur de la colonne 3 si ent == "SERVICE NOTIFICATION"
column4 security_result.severity Valeur copiée directement si column4 est dans ["LOW", "MEDIUM", "HIGH", "CRITICAL"] et ent dans ["SERVICE NOTIFICATION", "SERVICE ALERT"]
column4 security_result.severity_details Valeur copiée directement si column4 n'est pas dans ["LOW", "MEDIUM", "HIGH", "CRITICAL"] et ent dans ["SERVICE NOTIFICATION", "SERVICE ALERT"]
has_principal metadata.event_type Définissez sur "NETWORK_CONNECTION" si has_principal et has_target sont définis sur "true", sinon sur "STATUS_UPDATE" si has_principal est défini sur "true", sinon sur "USER_UNCATEGORIZED" si has_principal_user est défini sur "true", sinon sur "GENERIC_EVENT".
has_target metadata.event_type
has_principal_user metadata.event_type
security_result event.idm.read_only_udm.security_result Fusionné à partir de security_result
métadonnées event.idm.read_only_udm.metadata Renommé à partir des métadonnées
cible event.idm.read_only_udm.target Renommé à partir de la cible
principal event.idm.read_only_udm.principal Renommé à partir du compte principal
réseau event.idm.read_only_udm.network Renommé depuis le réseau
metadata.product_name metadata.product_name Défini sur "NAGIOS"
metadata.vendor_name metadata.vendor_name Défini sur "NAGIOS"

Journal des modifications

Afficher le journal des modifications de ce parseur

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