Collecter les journaux d'audit ServiceNow

Compatible avec :

Google SecOps SIEM

Remarque : Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions spécifiques au 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 d'audit ServiceNow dans Google Security Operations à l'aide de plusieurs méthodes.

Option A : AWS S3 avec Lambda

Cette méthode utilise AWS Lambda pour interroger régulièrement l'API REST ServiceNow afin d'obtenir les journaux d'audit et les stocker dans un bucket S3. Google Security Operations collecte ensuite les journaux du bucket S3.

Avant de commencer

• Une instance Google SecOps
• Accès privilégié au locataire ou à l'API ServiceNow
• Accès privilégié à AWS (S3, IAM, Lambda, EventBridge)

Collecter les prérequis ServiceNow (ID, clés API, ID d'organisation, jetons)

1. Connectez-vous à la console d'administration ServiceNow.
2. Accédez à Sécurité système > Utilisateurs et groupes > Utilisateurs.
3. Créez un utilisateur ou sélectionnez-en un existant disposant des autorisations appropriées pour accéder aux journaux d'audit.
4. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
   • Username (Nom d'utilisateur)
   • Mot de passe
   • URL de l'instance (par exemple, https://instance.service-now.com)

Configurer un bucket AWS S3 et IAM pour Google SecOps

1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, servicenow-audit-logs).
3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
4. Sélectionnez l'utilisateur créé.
5. Sélectionnez l'onglet Informations d'identification de sécurité.
6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
7. Sélectionnez Service tiers comme Cas d'utilisation.
8. Cliquez sur Suivant.
9. Facultatif : Ajoutez un tag de description.
10. Cliquez sur Créer une clé d'accès.
11. Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour une utilisation ultérieure.
12. Cliquez sur OK.
13. Sélectionnez l'onglet Autorisations.
14. Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations .
15. Sélectionnez Ajouter des autorisations.
16. Sélectionnez Joindre directement des règles.
17. Recherchez et sélectionnez la règle AmazonS3FullAccess.
18. Cliquez sur Suivant.
19. Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

1. Dans la console AWS, accédez à IAM > Policies > Create policy > onglet JSON.

2. Copiez et collez le règlement ci-dessous.

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::servicenow-audit-logs/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::servicenow-audit-logs/audit-logs/state.json"
       }
     ]
   }
   

   • Remplacez servicenow-audit-logs si vous avez saisi un autre nom de bucket.

3. Cliquez sur Suivant > Créer une règle.

4. Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.

5. Associez la règle nouvellement créée.

6. Nommez le rôle servicenow-audit-lambda-role, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

1. Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
2. Cliquez sur Créer à partir de zéro.

3. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom	servicenow-audit-collector
   Durée d'exécution	Python 3.13
   Architecture	x86_64
   Rôle d'exécution	servicenow-audit-lambda-role

4. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et saisissez le code suivant (servicenow-audit-collector.py) :

   import urllib3
   import json
   import os
   import datetime
   import boto3
   import base64
   
   def lambda_handler(event, context):
       # ServiceNow API details
       base_url = os.environ['API_BASE_URL']  # e.g., https://instance.service-now.com
       username = os.environ['API_USERNAME']
       password = os.environ['API_PASSWORD']
   
       # S3 details
       s3_bucket = os.environ['S3_BUCKET']
       s3_prefix = os.environ['S3_PREFIX']
   
       # State management
       state_key = os.environ.get('STATE_KEY', f"{s3_prefix}/state.json")
   
       # Pagination settings
       page_size = int(os.environ.get('PAGE_SIZE', '1000'))
       max_pages = int(os.environ.get('MAX_PAGES', '1000'))
   
       # Initialize S3 client
       s3 = boto3.client('s3')
   
       # Get last run timestamp from state file
       last_run_timestamp = get_last_run_timestamp(s3, s3_bucket, state_key)
   
       # Current timestamp for this run
       current_timestamp = datetime.datetime.now().isoformat()
   
       # Query ServiceNow API for audit logs with pagination
       audit_logs = get_audit_logs(base_url, username, password, last_run_timestamp, page_size, max_pages)
   
       if audit_logs:
           # Write logs to S3 in NDJSON format (newline-delimited JSON)
           timestamp = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
           s3_key = f"{s3_prefix}/servicenow-audit-{timestamp}.ndjson"
   
           # Format as NDJSON: one JSON object per line
           body = "\n".join(json.dumps(log) for log in audit_logs) + "\n"
   
           s3.put_object(
               Bucket=s3_bucket,
               Key=s3_key,
               Body=body,
               ContentType='application/x-ndjson'
           )
   
           # Update state file
           update_state_file(s3, s3_bucket, state_key, current_timestamp)
   
           return {
               'statusCode': 200,
               'body': json.dumps(f'Successfully exported {len(audit_logs)} audit logs to S3')
           }
       else:
           return {
               'statusCode': 200,
               'body': json.dumps('No new audit logs to export')
           }
   
   def get_last_run_timestamp(s3, bucket, key):
       try:
           response = s3.get_object(Bucket=bucket, Key=key)
           state = json.loads(response['Body'].read().decode('utf-8'))
           return state.get('last_run_timestamp', '1970-01-01T00:00:00')
       except:
           return '1970-01-01T00:00:00'
   
   def update_state_file(s3, bucket, key, timestamp):
       state = {'last_run_timestamp': timestamp}
       s3.put_object(
           Bucket=bucket,
           Key=key,
           Body=json.dumps(state),
           ContentType='application/json'
       )
   
   def get_audit_logs(base_url, username, password, last_run_timestamp, page_size=1000, max_pages=1000):
       """
       Query ServiceNow sys_audit table with proper pagination.
       Uses sys_created_on field for timestamp filtering.
       """
       # Encode credentials
       auth_string = f"{username}:{password}"
       auth_bytes = auth_string.encode('ascii')
       auth_encoded = base64.b64encode(auth_bytes).decode('ascii')
   
       # Setup HTTP client
       http = urllib3.PoolManager()
   
       headers = {
           'Authorization': f'Basic {auth_encoded}',
           'Accept': 'application/json'
       }
   
       results = []
       offset = 0
   
       for page in range(max_pages):
           # Build query with pagination
           # Use sys_created_on (not created_on) for timestamp filtering
           query_params = (
               f"sysparm_query=sys_created_onAFTER{last_run_timestamp}"
               f"&sysparm_display_value=true"
               f"&sysparm_limit={page_size}"
               f"&sysparm_offset={offset}"
           )
   
           url = f"{base_url}/api/now/table/sys_audit?{query_params}"
   
           try:
               response = http.request('GET', url, headers=headers)
   
               if response.status == 200:
                   data = json.loads(response.data.decode('utf-8'))
                   chunk = data.get('result', [])
                   results.extend(chunk)
   
                   # Stop if we got fewer records than page_size (last page)
                   if len(chunk) < page_size:
                       break
   
                   # Move to next page
                   offset += page_size
               else:
                   print(f"Error querying ServiceNow API: {response.status} - {response.data.decode('utf-8')}")
                   break
           except Exception as e:
               print(f"Exception querying ServiceNow API: {str(e)}")
               break
   
       return results
   

5. Accédez à Configuration > Variables d'environnement > Modifier > Ajouter une variable d'environnement.

6. Saisissez les variables d'environnement suivantes en remplaçant par vos valeurs.

   Clé	Exemple de valeur
   S3_BUCKET	servicenow-audit-logs
   S3_PREFIX	audit-logs/
   STATE_KEY	audit-logs/state.json
   API_BASE_URL	https://instance.service-now.com
   API_USERNAME	<your-username>
   API_PASSWORD	<your-password>
   PAGE_SIZE	1000
   MAX_PAGES	1000

   Remarque : Pour les environnements de production, il est fortement recommandé de stocker les identifiants dans AWS Secrets Manager au lieu de variables d'environnement, et de les référencer dans votre code Lambda.

7. Une fois la fonction créée, restez sur sa page (ou ouvrez Lambda > Functions > servicenow-audit-collector).

8. Accédez à l'onglet Configuration.

9. Dans le panneau Configuration générale, cliquez sur Modifier.

10. Définissez Délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

    Remarque : Le délai d'expiration est une limite supérieure stricte. Cela signifie que si la fonction est toujours en cours d'exécution lorsque le minuteur atteint cinq minutes, AWS Lambda l'arrête. Toute exécution plus courte se termine normalement. Vous n'êtes facturé que pour la durée d'exécution réelle.

Créer une programmation EventBridge

1. Accédez à Amazon EventBridge> Scheduler> Create schedule.
2. Fournissez les informations de configuration suivantes :
   • Planification récurrente : Tarif (1 hour).
   • Cible : votre fonction Lambda servicenow-audit-collector.
   • Nom : servicenow-audit-collector-1h.
3. Cliquez sur Créer la programmation.

Configurer un flux dans Google SecOps pour ingérer les journaux d'audit ServiceNow

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur + Ajouter un flux.
3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, ServiceNow Audit logs).
4. Sélectionnez Amazon S3 V2 comme type de source.
5. Sélectionnez Audit ServiceNow comme Type de journal.
6. Cliquez sur Suivant.
7. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3 : s3://servicenow-audit-logs/audit-logs/
   • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
   • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
   • ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3.
   • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
   • Espace de noms de l'élément : espace de noms de l'élément.
   • Libellés d'ingestion : libellé appliqué aux événements de ce flux.
8. Cliquez sur Suivant.
9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Option B : Agent Bindplane avec syslog

Cette méthode utilise un agent Bindplane pour collecter les journaux d'audit ServiceNow et les transférer vers Google Security Operations. Comme ServiceNow n'est pas compatible avec syslog pour les journaux d'audit, nous allons utiliser un script pour interroger l'API REST ServiceNow et transférer les journaux à l'agent Bindplane via syslog.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps
• Un hôte Windows 2016 ou version ultérieure, ou Linux avec systemd
• Si vous exécutez l'agent derrière un proxy, assurez-vous que les ports de pare-feu sont ouverts conformément aux exigences de l'agent Bindplane.
• Accès privilégié à la console ou à l'appliance de gestion ServiceNow

Obtenir le fichier d'authentification d'ingestion Google SecOps

1. Connectez-vous à la console Google SecOps.
2. Accédez à Paramètres du SIEM > Agents de collecte.
3. Téléchargez le fichier d'authentification d'ingestion. Enregistrez le fichier de manière sécurisée sur le système sur lequel Bindplane sera installé.

Obtenir l'ID client Google SecOps

1. Connectez-vous à la console Google SecOps.
2. Accédez à Paramètres SIEM> Profil.
3. Copiez et enregistrez le numéro client de la section Informations sur l'organisation.

Installer l'agent Bindplane

Installez l'agent Bindplane sur votre système d'exploitation Windows ou Linux en suivant les instructions ci-dessous.

Installation de Linux

1. Ouvrez un terminal avec les droits root ou sudo.

2. Exécutez la commande suivante :

   sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh
   

Autres ressources d'installation

• Pour plus d'options d'installation, consultez ce guide d'installation.

Configurer l'agent Bindplane pour ingérer Syslog et l'envoyer à Google SecOps

1. Accédez au fichier de configuration :

   1. Recherchez le fichier config.yaml. Il se trouve généralement dans le répertoire /etc/bindplane-agent/ sous Linux ou dans le répertoire d'installation sous Windows.
   2. Ouvrez le fichier à l'aide d'un éditeur de texte (par exemple, nano, vi ou le Bloc-notes).

2. Modifiez le fichier config.yaml comme suit :

   receivers:
     udplog:
       # Replace the port and IP address as required
       listen_address: "0.0.0.0:514"
   
   exporters:
     chronicle/chronicle_w_labels:
       compression: gzip
       # Adjust the path to the credentials file you downloaded in Step 1
       creds_file_path: '/path/to/ingestion-authentication-file.json'
       # Replace with your actual customer ID from Step 2
       customer_id: <YOUR_CUSTOMER_ID>
       # Replace with the appropriate regional endpoint
       endpoint: <CUSTOMER_REGION_ENDPOINT>
       # Add optional ingestion labels for better organization
       log_type: 'SERVICENOW_AUDIT'
       raw_log_field: body
       ingestion_labels:
   
   service:
     pipelines:
       logs/source0__chronicle_w_labels-0:
         receivers:
           - udplog
         exporters:
           - chronicle/chronicle_w_labels
   

• Remplacez le port et l'adresse IP selon les besoins de votre infrastructure.
• Remplacez <YOUR_CUSTOMER_ID> par le numéro client réel.
• Remplacez <CUSTOMER_REGION_ENDPOINT> par le point de terminaison régional approprié de la documentation sur les points de terminaison régionaux.
• Mettez à jour /path/to/ingestion-authentication-file.json en indiquant le chemin d'accès où le fichier d'authentification a été enregistré dans la section Obtenir le fichier d'authentification pour l'ingestion Google SecOps.

Redémarrez l'agent Bindplane pour appliquer les modifications.

• Pour redémarrer l'agent Bindplane sous Linux, exécutez la commande suivante :

  sudo systemctl restart bindplane-agent
  

• Pour redémarrer l'agent Bindplane sous Windows, vous pouvez utiliser la console Services ou saisir la commande suivante :

  net stop BindPlaneAgent && net start BindPlaneAgent
  

Créer un script pour transférer les journaux d'audit ServiceNow vers syslog

Comme ServiceNow n'est pas compatible avec syslog pour les journaux d'audit, nous allons créer un script qui interroge l'API REST ServiceNow et transfère les journaux vers syslog. Vous pouvez programmer l'exécution de ce script à intervalles réguliers.

Exemple de script Python (Linux)

• Créez un fichier nommé servicenow_audit_to_syslog.py avec le contenu suivant :

  import urllib3
  import json
  import datetime
  import base64
  import socket
  import time
  import os
  
  # ServiceNow API details
  BASE_URL = 'https://instance.service-now.com'  # Replace with your ServiceNow instance URL
  USERNAME = 'admin'  # Replace with your ServiceNow username
  PASSWORD = 'password'  # Replace with your ServiceNow password
  
  # Syslog details
  SYSLOG_SERVER = '127.0.0.1'  # Replace with your Bindplane agent IP
  SYSLOG_PORT = 514  # Replace with your Bindplane agent port
  
  # State file to keep track of last run
  STATE_FILE = '/tmp/servicenow_audit_last_run.txt'
  
  # Pagination settings
  PAGE_SIZE = 1000
  MAX_PAGES = 1000
  
  def get_last_run_timestamp():
      try:
          with open(STATE_FILE, 'r') as f:
              return f.read().strip()
      except:
          return '1970-01-01T00:00:00'
  
  def update_state_file(timestamp):
      with open(STATE_FILE, 'w') as f:
          f.write(timestamp)
  
  def send_to_syslog(message):
      sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
      sock.sendto(message.encode(), (SYSLOG_SERVER, SYSLOG_PORT))
      sock.close()
  
  def get_audit_logs(last_run_timestamp):
      """
      Query ServiceNow sys_audit table with proper pagination.
      Uses sys_created_on field for timestamp filtering.
      """
      # Encode credentials
      auth_string = f"{USERNAME}:{PASSWORD}"
      auth_bytes = auth_string.encode('ascii')
      auth_encoded = base64.b64encode(auth_bytes).decode('ascii')
  
      # Setup HTTP client
      http = urllib3.PoolManager()
  
      headers = {
          'Authorization': f'Basic {auth_encoded}',
          'Accept': 'application/json'
      }
  
      results = []
      offset = 0
  
      for page in range(MAX_PAGES):
          # Build query with pagination
          # Use sys_created_on (not created_on) for timestamp filtering
          query_params = (
              f"sysparm_query=sys_created_onAFTER{last_run_timestamp}"
              f"&sysparm_display_value=true"
              f"&sysparm_limit={PAGE_SIZE}"
              f"&sysparm_offset={offset}"
          )
  
          url = f"{BASE_URL}/api/now/table/sys_audit?{query_params}"
  
          try:
              response = http.request('GET', url, headers=headers)
  
              if response.status == 200:
                  data = json.loads(response.data.decode('utf-8'))
                  chunk = data.get('result', [])
                  results.extend(chunk)
  
                  # Stop if we got fewer records than PAGE_SIZE (last page)
                  if len(chunk) < PAGE_SIZE:
                      break
  
                  # Move to next page
                  offset += PAGE_SIZE
              else:
                  print(f"Error querying ServiceNow API: {response.status} - {response.data.decode('utf-8')}")
                  break
          except Exception as e:
              print(f"Exception querying ServiceNow API: {str(e)}")
              break
  
      return results
  
  def main():
      # Get last run timestamp
      last_run_timestamp = get_last_run_timestamp()
  
      # Current timestamp for this run
      current_timestamp = datetime.datetime.now().isoformat()
  
      # Query ServiceNow API for audit logs
      audit_logs = get_audit_logs(last_run_timestamp)
  
      if audit_logs:
          # Send each log to syslog
          for log in audit_logs:
              # Format the log as JSON
              log_json = json.dumps(log)
  
              # Send to syslog
              send_to_syslog(log_json)
  
              # Sleep briefly to avoid flooding
              time.sleep(0.01)
  
          # Update state file
          update_state_file(current_timestamp)
  
          print(f"Successfully forwarded {len(audit_logs)} audit logs to syslog")
      else:
          print("No new audit logs to forward")
  
  if __name__ == "__main__":
      main()
  

Configurer l'exécution planifiée (Linux)

1. Rendez le script exécutable :

   chmod +x servicenow_audit_to_syslog.py
   

2. Créez une job Cron pour exécuter le script toutes les heures :

   crontab -e
   

3. Ajoutez la ligne suivante :

   0 * * * * /usr/bin/python3 /path/to/servicenow_audit_to_syslog.py >> /tmp/servicenow_audit_to_syslog.log 2>&1
   

Exemple de script PowerShell (Windows)

• Créez un fichier nommé ServiceNow-Audit-To-Syslog.ps1 avec le contenu suivant :

  # ServiceNow API details
  $BaseUrl = 'https://instance.service-now.com'  # Replace with your ServiceNow instance URL
  $Username = 'admin'  # Replace with your ServiceNow username
  $Password = 'password'  # Replace with your ServiceNow password
  
  # Syslog details
  $SyslogServer = '127.0.0.1'  # Replace with your Bindplane agent IP
  $SyslogPort = 514  # Replace with your Bindplane agent port
  
  # State file to keep track of last run
  $StateFile = "$env:TEMP\ServiceNowAuditLastRun.txt"
  
  # Pagination settings
  $PageSize = 1000
  $MaxPages = 1000
  
  function Get-LastRunTimestamp {
      try {
          if (Test-Path $StateFile) {
              return Get-Content $StateFile
          }
          else {
              return '1970-01-01T00:00:00'
          }
      }
      catch {
          return '1970-01-01T00:00:00'
      }
  }
  
  function Update-StateFile {
      param (
          [string]$Timestamp
      )
  
      Set-Content -Path $StateFile -Value $Timestamp
  }
  
  function Send-ToSyslog {
      param (
          [string]$Message
      )
  
      $UdpClient = New-Object System.Net.Sockets.UdpClient
      $UdpClient.Connect($SyslogServer, $SyslogPort)
  
      $Encoding = [System.Text.Encoding]::ASCII
      $Bytes = $Encoding.GetBytes($Message)
  
      $UdpClient.Send($Bytes, $Bytes.Length)
      $UdpClient.Close()
  }
  
  function Get-AuditLogs {
      param (
          [string]$LastRunTimestamp
      )
  
      # Create auth header
      $Auth = [System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes("${Username}:${Password}"))
  
      $Headers = @{
          Authorization = "Basic ${Auth}"
          Accept = 'application/json'
      }
  
      $Results = @()
      $Offset = 0
  
      for ($page = 0; $page -lt $MaxPages; $page++) {
          # Build query with pagination
          # Use sys_created_on (not created_on) for timestamp filtering
          $QueryParams = "sysparm_query=sys_created_onAFTER${LastRunTimestamp}&sysparm_display_value=true&sysparm_limit=${PageSize}&sysparm_offset=${Offset}"
  
          $Url = "${BaseUrl}/api/now/table/sys_audit?${QueryParams}"
  
          try {
              $Response = Invoke-RestMethod -Uri $Url -Headers $Headers -Method Get
              $Chunk = $Response.result
  
              $Results += $Chunk
  
              # Stop if we got fewer records than PageSize (last page)
              if ($Chunk.Count -lt $PageSize) {
                  break
              }
  
              # Move to next page
              $Offset += $PageSize
          }
          catch {
              Write-Error "Error querying ServiceNow API: $_"
              break
          }
      }
  
      return $Results
  }
  
  # Main execution
  $LastRunTimestamp = Get-LastRunTimestamp
  $CurrentTimestamp = (Get-Date).ToString('yyyy-MM-ddTHH:mm:ss')
  
  $AuditLogs = Get-AuditLogs -LastRunTimestamp $LastRunTimestamp
  
  if ($AuditLogs -and $AuditLogs.Count -gt 0) {
      # Send each log to syslog
      foreach ($Log in $AuditLogs) {
          # Format the log as JSON
          $LogJson = $Log | ConvertTo-Json -Compress
  
          # Send to syslog
          Send-ToSyslog -Message $LogJson
  
          # Sleep briefly to avoid flooding
          Start-Sleep -Milliseconds 10
      }
  
      # Update state file
      Update-StateFile -Timestamp $CurrentTimestamp
  
      Write-Output "Successfully forwarded $($AuditLogs.Count) audit logs to syslog"
  }
  else {
      Write-Output "No new audit logs to forward"
  }
  

Configurer l'exécution planifiée (Windows)

1. Ouvrez le Planificateur de tâches.
2. Cliquez sur Créer une tâche.
3. Fournissez la configuration suivante :
   • Nom : ServiceNowAuditToSyslog
   • Options de sécurité : exécuter que l'utilisateur soit connecté ou non
4. Accédez à l'onglet Triggers (Déclencheurs).
5. Cliquez sur Nouveau et définissez l'exécution toutes les heures.
6. Accédez à l'onglet Actions.
7. Cliquez sur Nouveau, puis définissez les paramètres suivants :
   • Action : Démarrer un programme
   • Programme/script : powershell.exe
   • Arguments : -ExecutionPolicy Bypass -File "C:\path\to\ServiceNow-Audit-To-Syslog.ps1"
8. Cliquez sur OK pour enregistrer la tâche.

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