Collecter les journaux de contexte Jamf Pro

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer les journaux de contexte Jamf Pro (contexte de l'appareil et de l'utilisateur) dans Google Security Operations à l'aide de Cloud Storage avec les fonctions Cloud Run, Pub/Sub et Cloud Scheduler. Jamf Pro est une solution de gestion complète pour les appareils Apple. Elle fournit des fonctionnalités d'inventaire des appareils, de contexte utilisateur et de gestion de la configuration.

Avant de commencer

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

• Une instance Google SecOps
• Un projet Google Cloud avec l'API Cloud Storage activée
• Autorisations permettant de créer et de gérer des buckets Cloud Storage
• Autorisations permettant de gérer les stratégies IAM sur les buckets Cloud Storage
• Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des tâches Cloud Scheduler
• Accès privilégié au locataire Jamf Pro

Configurer le rôle de l'API Jamf

1. Connectez-vous à l'interface utilisateur Web Jamf.
2. Accédez à Paramètres > section "Système" > Rôles et clients de l'API.
3. Sélectionnez l'onglet Rôles de l'API.
4. Cliquez sur New (Nouveau).
5. Saisissez un nom à afficher pour le rôle d'API (par exemple, context_role).

6. Dans Droits d'accès au rôle de l'API Jamf Pro, saisissez le nom d'un droit d'accès, puis sélectionnez-le dans le menu :

   • Inventaire des ordinateurs
   • Inventaire des appareils mobiles
   Remarque : Vous pouvez continuer à ajouter des droits jusqu'à ce que vous ayez terminé.

7. Cliquez sur Enregistrer.

Configurer le client API Jamf

1. Dans Jamf Pro, accédez à Paramètres > section "Système" > Rôles et clients de l'API.
2. Sélectionnez l'onglet Clients API.
3. Cliquez sur New (Nouveau).
4. Saisissez un nom à afficher pour le client API (par exemple, context_client).
5. Dans le champ Rôles d'API, ajoutez le rôle context_role que vous avez créé précédemment.
6. Sous Durée de vie du jeton d'accès, saisissez la durée de validité des jetons d'accès en secondes.
7. Cliquez sur Enregistrer.
8. Cliquez sur Modifier.
9. Cliquez sur Activer le client API.
10. Cliquez sur Enregistrer.

Configurer le code secret du client Jamf

1. Dans Jamf Pro, accédez au client API que vous venez de créer.
2. Cliquez sur Générer le code secret du client.
3. Sur l'écran de confirmation, cliquez sur Créer un secret.
4. Enregistrez les paramètres suivants dans un emplacement sécurisé :
   • URL de base : https://<your>.jamfcloud.com
   • ID client : UUID.
   • Code secret du client : la valeur n'est affichée qu'une seule fois.

Créer un bucket 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, jamfpro).
   Type d'emplacement	Choisissez en fonction de vos besoins (région, birégion ou multirégion).
   Emplacement	Sélectionnez le lieu (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 des objets ou une 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 Cloud Storage et être appelée par Pub/Sub.

Créer un compte de service

1. Dans la console, 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 jamf-pro-collector-sa.
   • Description du compte de service : saisissez Service account for Cloud Run function to collect Jamf Pro context 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 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.

Ces rôles sont requis pour :

• Administrateur des objets Storage : écrire des journaux dans le bucket Cloud Storage 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 le bucket Cloud Storage

Accordez au compte de service des autorisations en écriture sur le bucket Cloud Storage :

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, jamf-pro-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 auquel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

1. Dans la console, accédez à Pub/Sub > Sujets.
2. Cliquez sur Créer un sujet.
3. Fournissez les informations de configuration suivantes :
   • ID du sujet : saisissez jamf-pro-context-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 Jamf Pro et les écrire dans Cloud Storage.

1. Dans la console, 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	jamf-pro-context-collector
   Région	Sélectionnez la région correspondant à votre bucket Cloud Storage (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 Pub/Sub.
   3. Dans Sélectionner un sujet Pub/Sub, choisissez le sujet Pub/Sub (jamf-pro-context-trigger).
   4. Cliquez sur Enregistrer.

6. Dans la section Authentification :

   1. Sélectionnez Exiger l'authentification.
   2. 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 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 (jamf-pro-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
   GCS_BUCKET	jamfpro
   GCS_PREFIX	jamf-pro/context/
   JAMF_CLIENT_ID	Saisissez l'ID client Jamf
   JAMF_CLIENT_SECRET	Saisissez le code secret client Jamf
   JAMF_BASE_URL	Saisissez l'URL Jamf, puis remplacez <your> dans https://<your>.jamfcloud.com.
   PAGE_SIZE	200

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
   import gzip
   import io
   import time
   
   # Initialize HTTP client
   http = urllib3.PoolManager()
   
   # Initialize Storage client
   storage_client = storage.Client()
   
   # Configuration
   BASE_URL = os.environ.get("JAMF_BASE_URL", "").rstrip("/")
   CLIENT_ID = os.environ.get("JAMF_CLIENT_ID")
   CLIENT_SECRET = os.environ.get("JAMF_CLIENT_SECRET")
   GCS_BUCKET = os.environ.get("GCS_BUCKET")
   GCS_PREFIX = os.environ.get("GCS_PREFIX", "jamf-pro/context/")
   PAGE_SIZE = int(os.environ.get("PAGE_SIZE", "200"))
   
   SECTIONS = [
       "GENERAL", "HARDWARE", "OPERATING_SYSTEM", "USER_AND_LOCATION",
       "DISK_ENCRYPTION", "SECURITY", "EXTENSION_ATTRIBUTES", "APPLICATIONS",
       "CONFIGURATION_PROFILES", "LOCAL_USER_ACCOUNTS", "CERTIFICATES",
       "SERVICES", "PRINTERS", "SOFTWARE_UPDATES", "GROUP_MEMBERSHIPS",
       "CONTENT_CACHING", "STORAGE", "FONTS", "PACKAGE_RECEIPTS",
       "PLUGINS", "ATTACHMENTS", "LICENSED_SOFTWARE", "IBEACONS", "PURCHASING"
   ]
   
   # Cached access token, refreshed shortly before it expires
   _token_cache = {"value": None, "expires_at": 0.0}
   
   def get_token():
       """OAuth2 client credentials > access_token"""
       url = f"{BASE_URL}/api/oauth/token"
   
       fields = {
           "grant_type": "client_credentials",
           "client_id": CLIENT_ID,
           "client_secret": CLIENT_SECRET
       }
   
       # encode_multipart=False is required. It sends a real
       # application/x-www-form-urlencoded body, which is what the Jamf token
       # endpoint expects. Without it, urllib3 sends a multipart/form-data body
       # and Jamf cannot read grant_type, client_id and client_secret.
       response = http.request(
           'POST',
           url,
           fields=fields,
           encode_multipart=False,
           timeout=30.0
       )
   
       if response.status != 200:
           raise Exception(f"Failed to get token: {response.status} {response.data.decode('utf-8')}")
   
       data = json.loads(response.data.decode('utf-8'))
       return data["access_token"], int(data.get("expires_in", 1200))
   
   def get_valid_token():
       """Return a cached token, refreshing it before it expires."""
       now = time.time()
       if _token_cache["value"] and now < _token_cache["expires_at"] - 60:
           return _token_cache["value"]
   
       token, ttl = get_token()
       _token_cache["value"] = token
       _token_cache["expires_at"] = now + ttl
       return token
   
   def fetch_page(token, page):
       """GET /api/v1/computers-inventory with sections & pagination"""
       url = f"{BASE_URL}/api/v1/computers-inventory"
   
       # Build query parameters
       params = [("page", str(page)), ("page-size", str(PAGE_SIZE))]
       params.extend([("section", s) for s in SECTIONS])
   
       # Encode parameters
       query_string = "&".join([f"{k}={v}" for k, v in params])
       full_url = f"{url}?{query_string}"
   
       headers = {
           "Authorization": f"Bearer {token}",
           "Accept": "application/json"
       }
   
       response = http.request(
           'GET',
           full_url,
           headers=headers,
           timeout=60.0
       )
   
       if response.status != 200:
           raise Exception(f"Failed to fetch page {page}: {response.status} {response.data.decode('utf-8')}")
   
       return json.loads(response.data.decode('utf-8'))
   
   def write_ndjson_gz(objs, when):
       buf = io.BytesIO()
       with gzip.GzipFile(filename="-", mode="wb", fileobj=buf, mtime=int(time.time())) as gz:
           for obj in objs:
               line = json.dumps(obj, separators=(",", ":")) + "\n"
               gz.write(line.encode("utf-8"))
   
       buf.seek(0)
   
       prefix = GCS_PREFIX.strip("/") + "/" if GCS_PREFIX else ""
       key = f"{prefix}{when:%Y/%m/%d}/jamf_pro_context_{int(when.timestamp())}.ndjson.gz"
   
       bucket = storage_client.bucket(GCS_BUCKET)
       blob = bucket.blob(key)
       blob.upload_from_file(buf, content_type="application/gzip")
   
       return key
   
   @functions_framework.cloud_event
   def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch Jamf Pro context logs and write to Cloud Storage.
   
       Each computer is written exactly as Jamf returns it: the inventory sections
       (general, hardware, operatingSystem, userAndLocation, and so on) are top-level
       keys on the record. The default parser reads this shape directly, so the records
       are not reshaped here.
   
       Args:
           cloud_event: CloudEvent object containing Pub/Sub message
       """
   
       if not all([BASE_URL, CLIENT_ID, CLIENT_SECRET, GCS_BUCKET]):
           print("Error: Missing required environment variables")
           return
   
       try:
           page = 0
           total = 0
           batch = []
           now = datetime.now(timezone.utc)
   
           while True:
               payload = fetch_page(get_valid_token(), page)
               results = payload.get("results") or []
   
               if not results:
                   break
   
               # Write the Jamf records as returned; do not rename or nest fields.
               batch.extend(results)
               total += len(results)
   
               if len(batch) >= 5000:
                   key = write_ndjson_gz(batch, now)
                   print(f"Wrote {len(batch)} records to gs://{GCS_BUCKET}/{key}")
                   batch = []
   
               if len(results) < PAGE_SIZE:
                   break
   
               page += 1
   
           if batch:
               key = write_ndjson_gz(batch, now)
               print(f"Wrote {len(batch)} records to gs://{GCS_BUCKET}/{key}")
   
           print(f"Successfully processed {total} total records")
   
       except Exception as e:
           print(f"Error processing Jamf Pro context logs: {str(e)}")
           raise
   

   Remarque : Ce script est fourni à titre d'exemple et n'est pas officiellement pris en charge. N'hésitez pas à nous faire part de vos commentaires pour nous permettre de 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).

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, accédez à Cloud Scheduler.
2. Cliquez sur Créer une tâche.

3. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom	jamfpro-context-schedule-1h
   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
   Sujet	Sélectionnez le sujet Pub/Sub (jamf-pro-context-trigger).
   Corps du message	{} (objet JSON vide)

4. Cliquez sur Créer.

Tester le job Scheduler

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

Configurer un flux dans Google SecOps pour ingérer les journaux de contexte Jamf Pro

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, Jamf Pro Context logs).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez Contexte Jamf Pro comme Type de journal.

7. Cliquez sur Obtenir un compte de service. Une adresse e-mail unique de compte de service s'affiche, par exemple :

   [e-mail]
   

8. Copiez cette adresse e-mail. Vous en aurez besoin lors de la tâche 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.

9. Cliquez sur Suivant.

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

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

    gs://jamfpro/jamf-pro/context/
    

    Remplacez jamfpro par le nom réel du bucket.

    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 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 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 du rôle Lecteur des objets Storage. 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.

1. Cliquez sur Suivant.
2. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

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

1. Accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom de votre bucket.
3. Accédez à l'onglet Autorisations.
4. Cliquez sur Accorder l'accès.
5. Fournissez les informations de configuration suivantes :
6. Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
7. Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

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

Journal des modifications

Afficher le journal des modifications pour ce parseur

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