Collecter des journaux d'audit Slack

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 guide explique comment ingérer des journaux d'audit Slack dans Google Security Operations à l'aide de Google Cloud Run Functions ou d'Amazon S3 avec AWS Lambda.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Instance Google SecOps
• Forfait Slack Enterprise Grid avec accès Propriétaire de l'organisation ou Administrateur
• Accès privilégié à l'un des éléments suivants :
  • Google Cloud (pour l'option 1 : Cloud Run Functions et Cloud Scheduler) ou
  • AWS (pour l'option 2 : S3, IAM, Lambda, EventBridge)

Remarque : L’API Slack Audit Logs n’est disponible que pour les organisations Enterprise Grid. Les espaces de travail Slack standards ne peuvent pas accéder à cette API.

Conditions préalables à la collecte des journaux d'audit Slack (ID d'application, jeton OAuth, ID d'organisation)

L'API Slack Audit Logs nécessite un jeton OAuth utilisateur avec le champ d'application auditlogs:read. Ce jeton doit être obtenu en installant une application au niveau de l'organisation Enterprise Grid, et non au niveau de l'espace de travail.

Créer une application Slack pour les journaux d'audit

1. Connectez-vous à la console d'administration Slack avec un compte Propriétaire de l'organisation Enterprise Grid ou Administrateur.
2. Accédez à https://api.slack.com/apps, puis cliquez sur Create New App > From scratch (Créer une application > À partir de zéro).
3. Fournissez les informations de configuration suivantes :
   • App Name (Nom de l'application) : saisissez un nom descriptif (par exemple, Google SecOps Audit Integration).
   • Pick a workspace to develop your app in (Sélectionnez un espace de travail dans lequel développer votre application) : sélectionnez votre espace de travail Slack de développement (n'importe quel espace de travail de l'organisation).
4. Cliquez sur Create App (Créer une application).

Configurer les champs d'application OAuth

1. Accédez à OAuth & Permissions (OAuth et autorisations) dans la barre latérale de gauche.
2. Faites défiler jusqu'à la section Scopes (Champs d'application).
3. Sous User Token Scopes (Champs d'application des jetons utilisateur) (et NON sous Champs d'application des jetons de bot), cliquez sur Add an OAuth Scope (Ajouter un champ d'application OAuth).
4. Ajoutez le champ d'application : auditlogs:read.

Remarque : Si vous rencontrez des problèmes d’installation lors des étapes ultérieures, vous devrez peut-être ajouter un champ d’application de bot de base (tel que users:read) pour activer l’installation au niveau de l’organisation.

Activer la distribution publique

1. Accédez à Manage Distribution (Gérer la distribution) dans la barre latérale de gauche.
2. Sous Share Your App with Other Workspaces (Partager votre application avec d'autres espaces de travail), assurez-vous que les quatre sections sont cochées en vert :
   • Remove Hard Coded Information (Supprimer les informations codées en dur)
   • Activate Public Distribution (Activer la distribution publique)
   • Set a Redirect URL (Définir une URL de redirection)
   • Add an OAuth Scope (Ajouter un champ d'application OAuth)
3. Cliquez sur Activate Public Distribution (Activer la distribution publique).

Remarque : La distribution publique est requise pour les applications au niveau de l'organisation.

Installer l'application dans l'organisation Enterprise Grid

1. Accédez à OAuth & Permissions (OAuth et autorisations) dans la barre latérale de gauche.
2. Cliquez sur Install to Organization (Installer dans l'organisation) (et NON sur « Install to Workspace » (Installer dans l'espace de travail)).

IMPORTANT : Vérifiez le menu déroulant en haut à droite de l'écran d'installation pour vous assurer que vous effectuez l'installation dans l'organisation Enterprise, et non dans un espace de travail individuel.

1. Examinez les autorisations demandées, puis cliquez sur Autoriser.
2. Une fois l'autorisation terminée, vous serez redirigé vers la page OAuth & Permissions (OAuth et autorisations).

Récupérer les identifiants

1. Sous OAuth Tokens for Your Workspace (Jetons OAuth pour votre espace de travail), recherchez le jeton OAuth utilisateur.
2. Copiez et enregistrez de manière sécurisée le jeton commençant par xoxp- (par exemple, xoxp-1234567890-0987654321-1234567890-abc123def456).

Important : Il s'agit de votre SLACK_ADMIN_TOKEN pour la fonction Lambda ou Cloud Run. Stockez-le de manière sécurisée.

1. Notez votre ID d'organisation:
   • Accédez à la console d'administration Slack.
   • Accédez à Settings & Permissions > Organization settings (Paramètres et autorisations > Paramètres de l'organisation).
   • Copiez l'ID d'organisation.

Option 1 : Configurer l'exportation des journaux d'audit Slack à l'aide de Google Cloud Run Functions

Cette option utilise Google Cloud Run Functions et Cloud Scheduler pour collecter les journaux d'audit Slack et les ingérer directement dans Google SecOps.

Configurer le répertoire

1. Créez un répertoire sur votre ordinateur local pour le déploiement de la fonction Cloud Run.
2. Téléchargez les fichiers suivants à partir du dépôt GitHub Chronicle ingestion-scripts :
   • Dans le dossier slack, téléchargez les éléments suivants :
     • .env.yml
     • main.py
     • requirements.txt
   • À la racine du dépôt, téléchargez l'intégralité du répertoire common avec tous ses fichiers :
     • common/__init__.py
     • common/auth.py
     • common/env_constants.py
     • common/ingest.py
     • common/status.py
     • common/utils.py
3. Placez tous les fichiers téléchargés dans votre répertoire de déploiement.

La structure de votre répertoire doit se présenter comme suit :

deployment_directory/
├─common/
│ ├─__init__.py
│ ├─auth.py
│ ├─env_constants.py
│ ├─ingest.py
│ ├─status.py
│ └─utils.py
├─.env.yml
├─main.py
└─requirements.txt

Créer des secrets dans Google Secret Manager

1. Dans la console Google Cloud, accédez à Sécurité > Secret Manager.
2. Cliquez sur Créer un secret.
3. Fournissez les informations de configuration suivantes pour le compte de service Chronicle:
   • Nom : saisissez chronicle-service-account.
   • Valeur du secret : collez le contenu de votre fichier JSON d'authentification d'ingestion Google SecOps.
4. Cliquez sur Créer un secret.
5. Copiez le nom de la ressource secrète au format suivant : projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
6. Cliquez à nouveau sur Créer un secret pour créer un deuxième secret.
7. Fournissez les informations de configuration suivantes pour le jeton Slack:
   • Nom : saisissez slack-admin-token.
   • Valeur du secret : collez votre jeton OAuth utilisateur Slack (commençant par xoxp-).
8. Cliquez sur Créer un secret.
9. Copiez le nom de la ressource secrète au format suivant : projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest.

Définir les variables d'environnement d'exécution requises

1. Ouvrez le fichier .env.yml dans votre répertoire de déploiement.
2. Configurez les variables d'environnement avec vos valeurs :

CHRONICLE_CUSTOMER_ID: "<your-chronicle-customer-id>"
CHRONICLE_REGION: us
CHRONICLE_SERVICE_ACCOUNT: "projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest"
CHRONICLE_NAMESPACE: ""
POLL_INTERVAL: "5"
SLACK_ADMIN_TOKEN: "projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest"

Remplacez les éléments suivants :

• <your-chronicle-customer-id>: votre ID client Google SecOps.
• <PROJECT_ID> : ID de votre projet Google Cloud.
• CHRONICLE_REGION : définissez la région Google SecOps. Valeurs valides : us, asia-northeast1, asia-south1, asia-southeast1, australia-southeast1, europe, europe-west2, europe-west3, europe-west6, europe-west9, europe-west12, me-central1, me-central2, me-west1, northamerica-northeast2, southamerica-east1.
• POLL_INTERVAL : intervalle de fréquence (en minutes) auquel la fonction s'exécute. Cette durée doit être identique à l'intervalle de la tâche Cloud Scheduler.

1. Enregistrez le .env.yml fichier.

Déployer la fonction Cloud Run

1. Ouvrez un terminal ou Cloud Shell dans la Google Cloud Console.
2. Accédez à votre répertoire de déploiement :

cd /path/to/deployment_directory

1. Exécutez la commande suivante pour déployer la fonction Cloud Run :

gcloud functions deploy slack-audit-to-chronicle \
  --entry-point main \
  --trigger-http \
  --runtime python39 \
  --env-vars-file .env.yml \
  --timeout 300s \
  --memory 512MB \
  --service-account <SERVICE_ACCOUNT_EMAIL>

Remplacez <SERVICE_ACCOUNT_EMAIL> par l'adresse e-mail du compte de service que vous souhaitez que votre fonction Cloud Run utilise.

Remarque : Le compte de service exécutant votre fonction Cloud Run doit disposer des rôles Demandeur Cloud Functions (roles/cloudfunctions.invoker) et Accesseur de secret Secret Manager (roles/secretmanager.secretAccessor).

1. Attendez la fin du déploiement.
2. Une fois le déploiement effectué, notez l'URL de la fonction dans la sortie.

Configurer Cloud Scheduler

1. Dans la console Google Cloud, accédez à Cloud Scheduler > Créer une tâche.
2. Fournissez les informations de configuration suivantes :
   • Nom : saisissez slack-audit-scheduler.
   • Région : sélectionnez la même région que celle dans laquelle vous avez déployé la fonction Cloud Run.
   • Fréquence : saisissez */5 * * * * (s'exécute toutes les 5 minutes, ce qui correspond à la valeur POLL_INTERVAL).
   • Fuseau horaire : sélectionnez UTC.
   • Type de cible : sélectionnez HTTP.
   • URL : saisissez l'URL de la fonction Cloud Run à partir de la sortie du déploiement.
   • Méthode HTTP : sélectionnez POST.
   • En-tête de l'authentification : sélectionnez Ajouter un jeton OIDC.
   • Compte de service : sélectionnez le même compte de service que celui utilisé pour la fonction Cloud Run.
3. Cliquez sur Créer.

Option 2 : Configurer l'exportation des journaux d'audit Slack à l'aide d'AWS S3

Cette option utilise AWS Lambda pour collecter les journaux d'audit Slack et les stocker dans S3, puis configure un flux Google SecOps pour ingérer les journaux.

Configurer le 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, slack-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 Security credentials (Identifiants de sécurité).
6. Cliquez sur Create Access Key (Créer une clé d'accès) dans la section Access Keys (Clés d'accès).
7. Sélectionnez Third-party service (Service tiers) comme Use case (Cas d'utilisation).
8. Cliquez sur Suivant.
9. Facultatif : ajoutez un tag de description.
10. Cliquez sur Create access key (Créer une clé d'accès).
11. Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
12. Cliquez sur OK.
13. Sélectionnez l'onglet Permissions (Autorisations).
14. Cliquez sur Add permissions (Ajouter des autorisations) dans la section Permissions policies (Règles d'autorisation).
15. Sélectionnez Add permissions (Ajouter des autorisations).
16. Sélectionnez Attach policies directly (Associer des règles directement).
17. Recherchez la règle AmazonS3FullAccess.
18. Sélectionnez la règle.
19. Cliquez sur Suivant.
20. Cliquez sur Ajouter des autorisations.

Configurer la règle et le rôle IAM pour les importations S3

1. Dans la console AWS, accédez à IAM > Policies > Create policy > JSON tab (IAM > Règles > Créer une règle > Onglet JSON).
2. Copiez et collez la règle ci-dessous.
3. JSON de la règle (remplacez slack-audit-logs si vous avez saisi un autre nom de bucket) :

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

1. Cliquez sur Suivant.
2. Saisissez le nom de la règle SlackAuditS3Policy.
3. Cliquez sur Créer une règle.
4. Accédez à IAM > Roles > Create role > AWS service > Lambda (IAM > Rôles > Créer un rôle > Service AWS > Lambda).
5. Associez la règle nouvellement créée SlackAuditS3Policy.
6. Nommez le rôle SlackAuditToS3Role, puis cliquez sur Create role (Créer un rôle).

Créer la fonction Lambda

1. Dans la console AWS, accédez à Lambda > Functions > Create function (Lambda > Fonctions > Créer une fonction).
2. Cliquez sur Author from scratch (Créer à partir de zéro).
3. Fournissez les informations de configuration suivantes :

Paramètre	Valeur
Nom	slack_audit_to_s3
Durée d'exécution	Python 3.13
Architecture	x86_64
Rôle d'exécution	SlackAuditToS3Role

1. Cliquez sur Créer une fonction.
2. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et collez le code ci-dessous (slack_audit_to_s3.py).

#!/usr/bin/env python3
# Lambda: Pull Slack Audit Logs (Enterprise Grid) to S3 (JSONL format)

import os, json, time, urllib.parse
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
import boto3

BASE_URL = "https://api.slack.com/audit/v1/logs"

TOKEN        = os.environ["SLACK_AUDIT_TOKEN"]  # org-level user token with auditlogs:read
BUCKET       = os.environ["S3_BUCKET"]
PREFIX       = os.environ.get("S3_PREFIX", "slack/audit/")
STATE_KEY    = os.environ.get("STATE_KEY", "slack/audit/state.json")
LIMIT        = int(os.environ.get("LIMIT", "200"))             # Slack recommends <= 200
MAX_PAGES    = int(os.environ.get("MAX_PAGES", "20"))
LOOKBACK_SEC = int(os.environ.get("LOOKBACK_SECONDS", "3600")) # First-run window
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
RETRY_AFTER_DEFAULT = int(os.environ.get("RETRY_AFTER_DEFAULT", "2"))
# Optional server-side filters (comma-separated 'action' values), empty means no filter
ACTIONS      = os.environ.get("ACTIONS", "").strip()

s3 = boto3.client("s3")


def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
        st = json.loads(obj["Body"].read() or b"{}")
        return {"cursor": st.get("cursor")}
    except Exception:
        return {"cursor": None}


def _put_state(state: dict) -> None:
    body = json.dumps(state, separators=(",", ":")).encode("utf-8")
    s3.put_object(Bucket=BUCKET, Key=STATE_KEY, Body=body, ContentType="application/json")


def _http_get(params: dict) -> dict:
    qs  = urllib.parse.urlencode(params, doseq=True)
    url = f"{BASE_URL}?{qs}" if qs else BASE_URL
    req = Request(url, method="GET")
    req.add_header("Authorization", f"Bearer {TOKEN}")
    req.add_header("Accept", "application/json")

    attempt = 0
    while True:
        try:
            with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            # Respect Retry-After on 429/5xx
            if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                retry_after = 0
                try:
                    retry_after = int(e.headers.get("Retry-After", RETRY_AFTER_DEFAULT))
                except Exception:
                    retry_after = RETRY_AFTER_DEFAULT
                time.sleep(max(1, retry_after))
                attempt += 1
                continue
            # Re-raise other HTTP errors
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(RETRY_AFTER_DEFAULT)
                attempt += 1
                continue
            raise


def _write_page(data: dict, page_idx: int) -> str:
    """
    Extract entries from Slack API response and write as JSONL (one event per line).
    Chronicle requires newline-delimited JSON, not a JSON array.
    """
    entries = data.get("entries") or []
    
    if not entries:
        # No entries to write, skip file creation
        return None
    
    # Convert each entry to a single-line JSON string
    lines = [json.dumps(entry, separators=(",", ":")) for entry in entries]
    
    # Join with newlines to create JSONL format
    body = "\n".join(lines).encode("utf-8")
    
    # Write to S3
    ts  = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
    key = f"{PREFIX}{ts}-slack-audit-p{page_idx:05d}.json"
    s3.put_object(Bucket=BUCKET, Key=key, Body=body, ContentType="application/json")
    
    return key


def lambda_handler(event=None, context=None):
    state  = _get_state()
    cursor = state.get("cursor")

    params = {"limit": LIMIT}
    if ACTIONS:
        params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
    if cursor:
        params["cursor"] = cursor
    else:
        # First run (or reset): fetch a recent window by time
        params["oldest"] = int(time.time()) - LOOKBACK_SEC

    pages = 0
    total = 0
    last_cursor = None

    while pages < MAX_PAGES:
        data = _http_get(params)
        
        # Write entries in JSONL format
        written_key = _write_page(data, pages)

        entries = data.get("entries") or []
        total += len(entries)

        # Cursor for next page
        meta = data.get("response_metadata") or {}
        next_cursor = meta.get("next_cursor") or data.get("next_cursor")
        if next_cursor:
            params = {"limit": LIMIT, "cursor": next_cursor}
            if ACTIONS:
                params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
            last_cursor = next_cursor
            pages += 1
            continue
        break

    if last_cursor:
        _put_state({"cursor": last_cursor})

    return {"ok": True, "pages": pages + (1 if total or last_cursor else 0), "entries": total, "cursor": last_cursor}


if __name__ == "__main__":
    print(lambda_handler())

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

1. Accédez à Configuration > Variables d'environnement > Modifier > Ajouter une variable d'environnement.
2. Saisissez les variables d'environnement fournies ci-dessous, en remplaçant par vos valeurs.

Variables d'environnement

Clé	Exemple de valeur
S3_BUCKET	slack-audit-logs
S3_PREFIX	slack/audit/
STATE_KEY	slack/audit/state.json
SLACK_AUDIT_TOKEN	xoxp-*** (jeton utilisateur au niveau de l'organisation avec auditlogs:read)
LIMIT	200
MAX_PAGES	20
LOOKBACK_SECONDS	3600
HTTP_TIMEOUT	60
HTTP_RETRIES	3
RETRY_AFTER_DEFAULT	2
ACTIONS	(facultatif, CSV) user_login,app_installed

1. Cliquez sur Enregistrer.
2. Accédez à l'onglet Configuration.
3. Dans le panneau General configuration (Configuration générale), cliquez sur Edit (Modifier).
4. Définissez Timeout (Délai avant expiration) sur 5 minutes (300 secondes) , puis cliquez sur Enregistrer.

Remarque : Le délai avant expiration est une limite supérieure stricte. Cela signifie que si la fonction est toujours en cours d'exécution lorsque le minuteur atteint 5 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 (Amazon EventBridge > Programmeur > Créer une programmation).
2. Fournissez les informations de configuration suivantes :
   • Nom : saisissez slack-audit-1h.
   • Recurring schedule (Programmation récurrente) : sélectionnez Rate-based schedule (Programmation basée sur la fréquence).
   • Rate expression (Expression de fréquence) : saisissez 1 heures.
   • Flexible time window (Fenêtre temporelle flexible) : sélectionnez Off (Désactivé).
3. Cliquez sur Suivant.
4. Sélectionnez Cible:
   • Target API (API cible) : sélectionnez AWS Lambda Invoke (Appel AWS Lambda).
   • Lambda function (Fonction Lambda) : sélectionnez slack_audit_to_s3.
5. Cliquez sur Suivant.
6. Cliquez sur Suivant (ignorez les paramètres facultatifs).
7. Vérifiez, puis cliquez sur Create schedule (Créer une programmation).

(Facultatif) Créer un utilisateur et des clés IAM en lecture seule pour Google SecOps

1. Accédez à AWS Console > IAM > Users > Create user (Console AWS > IAM > Utilisateurs > Créer un utilisateur).
2. Fournissez les informations de configuration suivantes :
   • User name (Nom d'utilisateur) : saisissez secops-reader.
   • Access type (Type d'accès) : sélectionnez Programmatic access (Accès programmatique).
3. Cliquez sur Suivant.
4. Sélectionnez Attach policies directly (Associer des règles directement).
5. Cliquez sur Créer une règle.
6. Dans l'onglet JSON, collez le texte suivant :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::slack-audit-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::slack-audit-logs"
    }
  ]
}

1. Cliquez sur Suivant.
2. Saisissez le nom de la règle secops-reader-policy.
3. Cliquez sur Créer une règle.
4. Revenez à la page de création de l'utilisateur, actualisez la liste des règles, puis sélectionnez secops-reader-policy.
5. Cliquez sur Suivant.
6. Cliquez sur Créer un utilisateur.
7. Sélectionnez l'utilisateur créé secops-reader.
8. Accédez à Security credentials > Access keys > Create access key (Identifiants de sécurité > Clés d'accès > Créer une clé d'accès).
9. Sélectionnez Third-party service (Service tiers).
10. Cliquez sur Suivant.
11. Cliquez sur Créer une clé d'accès.
12. Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer les identifiants.

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

1. Accédez à Paramètres SIEM > Flux.
2. Cliquez sur Ajouter.
3. Dans le champ Feed name (Nom du flux), saisissez un nom pour le flux (par exemple, Slack Audit Logs).
4. Sélectionnez Amazon S3 V2 comme Source type (Type de source).
5. Sélectionnez Slack Audit comme Log type (Type de journal).
6. Cliquez sur Suivant.
7. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3: s3://slack-audit-logs/slack/audit/
   • Source deletion options (Options de suppression de la source) : sélectionnez l'option de suppression de votre choix.
   • Maximum File Age (Âge maximal des fichiers) : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
   • Access Key ID (ID de clé d'accès) : clé d'accès utilisateur avec accès au bucket S3 (à partir de secops-reader).
   • Secret Access Key (Clé d'accès secrète) : clé secrète utilisateur avec accès au bucket S3 (à partir de secops-reader).
   • Asset namespace (Espace de noms de l'élément) : l'espace de noms de l'élément.
   • Ingestion labels (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 dans l'écran Finalize (Finaliser), puis cliquez sur Envoyer.

Table de mappage UDM

Champ du journal	Mappage UDM	Logique
action	metadata.product_event_type	Mappé directement à partir du champ action dans le journal brut.
actor.type	principal.labels.value	Mappé directement à partir du champ actor.type, avec la clé actor.type ajoutée.
actor.user.email	principal.user.email_addresses	Mappé directement à partir du champ actor.user.email.
actor.user.id	principal.user.product_object_id	Mappé directement à partir du champ actor.user.id.
actor.user.id	principal.user.userid	Mappé directement à partir du champ actor.user.id.
actor.user.name	principal.user.user_display_name	Mappé directement à partir du champ actor.user.name.
actor.user.team	principal.user.group_identifiers	Mappé directement à partir du champ actor.user.team.
context.ip_address	principal.ip	Mappé directement à partir du champ context.ip_address.
context.location.domain	about.resource.attribute.labels.value	Mappé directement à partir du champ context.location.domain, avec la clé context.location.domain ajoutée.
context.location.id	about.resource.id	Mappé directement à partir du champ context.location.id.
context.location.name	about.resource.name	Mappé directement à partir du champ context.location.name.
context.location.name	about.resource.attribute.labels.value	Mappé directement à partir du champ context.location.name, avec la clé context.location.name ajoutée.
context.location.type	about.resource.resource_subtype	Mappé directement à partir du champ context.location.type.
context.session_id	network.session_id	Mappé directement à partir du champ context.session_id.
context.ua	network.http.user_agent	Mappé directement à partir du champ context.ua.
context.ua	network.http.parsed_user_agent	Informations de l'user-agent analysées dérivées du champ context.ua à l'aide du filtre parseduseragent.
country	principal.location.country_or_region	Mappé directement à partir du champ country.
date_create	metadata.event_timestamp.seconds	L'horodatage epoch du champ date_create est converti en objet d'horodatage.
details.inviter.email	target.user.email_addresses	Mappé directement à partir du champ details.inviter.email.
details.inviter.id	target.user.product_object_id	Mappé directement à partir du champ details.inviter.id.
details.inviter.name	target.user.user_display_name	Mappé directement à partir du champ details.inviter.name.
details.inviter.team	target.user.group_identifiers	Mappé directement à partir du champ details.inviter.team.
details.reason	security_result.description	Mappé directement à partir du champ details.reason ou, s'il s'agit d'un tableau, concaténé avec des virgules.
details.type	about.resource.attribute.labels.value	Mappé directement à partir du champ details.type, avec la clé details.type ajoutée.
details.type	security_result.summary	Mappé directement à partir du champ details.type.
entity.app.id	target.resource.id	Mappé directement à partir du champ entity.app.id.
entity.app.name	target.resource.name	Mappé directement à partir du champ entity.app.name.
entity.channel.id	target.resource.id	Mappé directement à partir du champ entity.channel.id.
entity.channel.name	target.resource.name	Mappé directement à partir du champ entity.channel.name.
entity.channel.privacy	target.resource.attribute.labels.value	Mappé directement à partir du champ entity.channel.privacy, avec la clé entity.channel.privacy ajoutée.
entity.file.filetype	target.resource.attribute.labels.value	Mappé directement à partir du champ entity.file.filetype, avec la clé entity.file.filetype ajoutée.
entity.file.id	target.resource.id	Mappé directement à partir du entity.file.id champ.
entity.file.name	target.resource.name	Mappé directement à partir du champ entity.file.name.
entity.file.title	target.resource.attribute.labels.value	Mappé directement à partir du champ entity.file.title, avec la clé entity.file.title ajoutée.
entity.huddle.date_end	about.resource.attribute.labels.value	Mappé directement à partir du champ entity.huddle.date_end, avec la clé entity.huddle.date_end ajoutée.
entity.huddle.date_start	about.resource.attribute.labels.value	Mappé directement à partir du champ entity.huddle.date_start, avec la clé entity.huddle.date_start ajoutée.
entity.huddle.id	about.resource.attribute.labels.value	Mappé directement à partir du champ entity.huddle.id, avec la clé entity.huddle.id ajoutée.
entity.huddle.participants.0	about.resource.attribute.labels.value	Mappé directement à partir du champ entity.huddle.participants.0, avec la clé entity.huddle.participants.0 ajoutée.
entity.huddle.participants.1	about.resource.attribute.labels.value	Mappé directement à partir du champ entity.huddle.participants.1, avec la clé entity.huddle.participants.1 ajoutée.
entity.type	target.resource.resource_subtype	Mappé directement à partir du champ entity.type.
entity.user.email	target.user.email_addresses	Mappé directement à partir du champ entity.user.email.
entity.user.id	target.user.product_object_id	Mappé directement à partir du champ entity.user.id.
entity.user.name	target.user.user_display_name	Mappé directement à partir du champ entity.user.name.
entity.user.team	target.user.group_identifiers	Mappé directement à partir du champ entity.user.team.
entity.workflow.id	target.resource.id	Mappé directement à partir du champ entity.workflow.id.
entity.workflow.name	target.resource.name	Mappé directement à partir du champ entity.workflow.name.
id	metadata.product_log_id	Mappé directement à partir du champ id.
ip	principal.ip	Mappé directement à partir du champ ip. Déterminé par la logique basée sur le champ action. La valeur par défaut est USER_COMMUNICATION, mais elle est remplacée par d'autres valeurs telles que USER_CREATION, USER_LOGIN, USER_LOGOUT, USER_RESOURCE_ACCESS, USER_RESOURCE_UPDATE_PERMISSIONS, ou USER_CHANGE_PERMISSIONS en fonction de la valeur de action. Codé en dur sur "SLACK_AUDIT". Défini sur "Enterprise Grid" si date_create existe, sinon défini sur "Audit Logs" si user_id existe. Codé en dur sur "Slack". Codé en dur sur "REMOTE". Défini sur "SSO" si action contient "user_login" ou "user_logout". Sinon, défini sur "MACHINE". Non mappé dans les exemples fournis. La valeur par défaut est "ALLOW", mais elle est définie sur "BLOCK" si action est "user_login_failed". Défini sur "Slack" si date_create existe, sinon défini sur "SLACK" si user_id existe.
user_agent	network.http.user_agent	Mappé directement à partir du champ user_agent.
user_id	principal.user.product_object_id	Mappé directement à partir du champ user_id.
username	principal.user.product_object_id	Mappé directement à partir du champ username.

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