Journaux d'audit GitHub

info

Aperçu

Lakewatch est en aperçu privé. Pour demander l’accès, contactez l’équipe chargée de votre compte Databricks.

Lakewatch fournit un connecteur API pour ingérer les logs d'audit de l'organisation à partir de GitHub. Cet article couvre les prérequis, les instructions de configuration, le schéma de connecteur et les observables de l'analyseur Lakewatch.

Prérequis

Le connecteur nécessite :

Serverless Lakeflow Spark Declarative Pipelines activé dans votre workspace.
Unity Catalog, avec les privilèges pour créer ou utiliser une connexion Unity Catalog. Voir Autorisations de connexion.
Un compte GitHub ayant accès à l’organisation à partir de laquelle vous souhaitez ingérer des journaux d’audit.
Autorisation de créer des applications OAuth dans les paramètres développeur de votre compte GitHub.

Limitations connues

La table audit_logs est uniquement disponible pour les comptes d'organisation.
Sur le plan GitHub Free, l'historique du journal d'audit sur github.com est limité à 90 jours.
La rétrospection historique ne peut pas dépasser 180 jours. Voir Choisir jusqu'où remonter lors de l'ingestion.
Le connecteur ne prend en charge que les jetons d’accès utilisateur à machine (U2M) OAuth de longue durée. Si l’application OAuth émet des jetons d’accès utilisateur expirants, l’ingestion échoue après l’expiration du jeton.
GitHub inclut les adresses IP des acteurs dans les événements d’audit uniquement lorsque l’affichage des adresses IP est activé dans les paramètres de l’organisation ou de l’entreprise GitHub.

Configurer GitHub pour l'ingestion

Connectez-vous à votre compte GitHub.
Dans le coin supérieur droit de n’importe quelle page, cliquez sur votre photo de profil pour ouvrir le menu de navigation utilisateur.
Cliquez sur Paramètres .
Cliquez sur Paramètres de développement .
Dans la section Applications OAuth , cliquez sur Nouvelle application OAuth .
Saisissez un nom d'application mémorisable dans le champ Nom de l'application .
Dans le champ URL de la page d'accueil , entrez l'URL principale de votre instance Databricks. Par exemple, https://my-databricks-account.cloud.databricks.com. Facultativement, saisissez une description de l'application.
Définissez l’URL de rappel d’autorisation comme suit :

https://<your_workspace_domain>/login/oauth/lakehousefederation.html

Par exemple :

https://my-databricks-account.cloud.databricks.com/login/oauth/lakehousefederation.html
Cliquez sur Enregistrer l’application . Cela vous amène à la page des détails de l’application.
Notez l' ID client . Vous en aurez besoin pour créer votre connexion Unity Catalog.
Cliquez sur Générer un nouveau secret client pour générer un secret client pour votre application.
Notez le secret client généré. Cette valeur n’est affichée qu’une seule fois.

astuce

Lorsque vous créez une connexion via l'interface utilisateur de Lakewatch, entrez l' identifiant du client et le secret du client collectés ci-dessus. Pour GitHub Enterprise Server, entrez également le domaine d’entreprise facultatif. Vous êtes redirigé vers GitHub pour autoriser les périmètres demandés.

Pour en savoir plus, consultez Configurer OAuth U2M pour l'ingestion GitHub.

Étapes suivantes

Une fois la configuration ci-dessus terminée, créez une source de données avec le connecteur GitHub dans l'interface utilisateur de Lakewatch. Voir Connecteurs API pour obtenir des instructions.

Schémas du connecteur et de Lakewatch

Lakewatch ingère la table source suivante à partir du schéma de source default du connecteur GitHub :

Table source	Données GitHub	Analyseur Lakewatch intégré
`audit_logs`	Actions de l'organisation effectuées par les utilisateurs, les intégrations et les systèmes	`github_audit_lfc`

Le connecteur écrit la table source dans la destination brute de la source de données. L'analyseur intégré écrit une table analysée séparée nommée d'après l'analyseur, sauf si vous définissez une destination analysée lors de la configuration de la source de données.

Colonnes gérées par Lakewatch

Le connecteur ajoute les colonnes suivantes à chaque ligne source brute :

lw_id: une chaîne de caractères non nulle que Lakewatch utilise comme clé primaire. Le connecteur dérive un ID stable et triable par date à partir des champs source @timestamp et _document_id.
time: un timestamp UTC non nul converti à partir de la valeur source @timestamp, que GitHub rapporte en millisecondes depuis l’époque Unix. Le connecteur utilise time comme champ curseur pour l’ingestion incrémentielle.

La table analysée transfère lw_id. L'analyseur assigne également la colonne analysée time et ajoute :

lw_meta: métadonnées de traitement Lakewatch standard.
lw_observables: Valeurs extraites des champs marqués comme observables de sécurité dans l’analyseur.

Pour plus d'informations, voir Référence de l'analyseur.

Schéma de table de connecteur brut

Le connecteur extrait les champs d'événement d'audit GitHub courants dans des colonnes typées et conserve l'événement source complet dans payload.

Schéma

Colonne	Type de données
`lw_id`	`STRING`
`_document_id`	`STRING`
`time`	`TIMESTAMP`
`action`	`STRING`
`actor`	`STRING`
`org`	`STRING`
`repo`	`STRING`
`payload`	`VARIANT`

Pour les définitions de champs, consultez l’ API de journal d’audit GitHub.

Observables d’analyseur

Le parser github_audit_lfc conserve l'événement source complet en tant que VARIANT dans payload et extrait les champs suivants dans lw_observables.

Observables

Champ	Observable
`actor`	`username`
`payload.actor_ip`	`ip`
`payload.email`	`email`
`payload.invitee_email`	`email`
`payload.user`	`username`
`payload.blocked_user`	`username`
`payload.external_identity_nameid`	`username`
`payload.external_identity_username`	`username`
`payload.user_programmatic_access_name`	`username`
`payload.invitee`	`username`
`payload.inviter`	`username`
`payload.authorized_actors[]`	`username`
`payload.authorized_actor_names[]`	`username`
`payload.actor_id`	`actor_id`
`payload.user_id`	`actor_id`
`payload.referrer`	`url`
`payload.url`	`url`
`payload.pull_request_url`	`url`
`payload.config.url`	`url`
`payload.config_was.url`	`url`
`payload.head_sha`	`hash`
`payload.after`	`hash`
`payload.before`	`hash`
`payload.calling_workflow_shas[]`	`hash`

Champ	Observable
`actor`	`username`
`payload.actor_ip`	`ip`
`payload.email`	`email`
`payload.invitee_email`	`email`
`payload.user`	`username`
`payload.blocked_user`	`username`
`payload.external_identity_nameid`	`username`
`payload.external_identity_username`	`username`
`payload.user_programmatic_access_name`	`username`
`payload.invitee`	`username`
`payload.inviter`	`username`
`payload.authorized_actors[]`	`username`
`payload.authorized_actor_names[]`	`username`
`payload.actor_id`	`actor_id`
`payload.user_id`	`actor_id`
`payload.referrer`	`url`
`payload.url`	`url`
`payload.pull_request_url`	`url`
`payload.config.url`	`url`
`payload.config_was.url`	`url`
`payload.head_sha`	`hash`
`payload.after`	`hash`
`payload.before`	`hash`
`payload.calling_workflow_shas[]`	`hash`

Prérequis​

Limitations connues​

Configurer GitHub pour l'ingestion​

Étapes suivantes​

Schémas du connecteur et de Lakewatch​

Colonnes gérées par Lakewatch​

Schéma de table de connecteur brut​

Observables d’analyseur​