YALineo
FR
Installer

Le coût d'un job Databricks, exécution par exécution

Les tables système de facturation donnent la consommation de chaque job et de chaque exécution. Voici les requêtes qui en tirent un coût, les cas qu'elles ne couvrent pas, et ce que fait YALineo.

Mis à jour le 6 novembre 2026 · Abdouramane Youssouf

Ce que la facturation dit d'un job

La consommation de Databricks se lit dans la table système system.billing.usage. Pour un job, le champ usage_metadata porte job_id, le job, et job_run_id, l'exécution que la ligne facture. Le coût d'une ligne est sa quantité (usage_quantity) multipliée par le prix catalogue de son SKU, lu dans system.billing.list_prices.

Le coût d'une exécution est la somme de ses lignes, celui d'un job la somme des lignes qui portent son job_id. Ce sont des mesures : aucune règle de partage n'intervient.

Selon la documentation, ces deux champs sont remplis pour les jobs serverless et les jobs sur un calcul de job (job compute), pas pour un job lancé sur un cluster interactif (all-purpose).

Les tables système à relier

Cinq tables système, toutes en lecture :

Table systèmeCe qu'elle apporte
system.billing.usageLa consommation, ligne par ligne, avec usage_metadata.job_id et usage_metadata.job_run_id
system.billing.list_pricesLe prix catalogue de chaque SKU à chaque date ; la clé effective_list contient le prix utilisé pour calculer le coût
system.lakeflow.jobsLe nom de chaque job, une ligne par modification (change_time)
system.lakeflow.job_run_timelineL'issue de chaque exécution (result_state), son déclencheur (trigger_type) et la tâche qui l'a lancée (source_task_run_id)
system.lakeflow.job_task_run_timelineLes exécutions de tâches, qui donnent le job lanceur

Étape 1 : le coût de chaque exécution

Le prix retenu est celui en vigueur à la fin de la ligne d'usage, comme dans l'exemple de jointure de la documentation. Sur les 30 derniers jours :

SELECT u.workspace_id,
       u.usage_metadata.job_id AS job_id,
       u.usage_metadata.job_run_id AS run_id,
       SUM(u.usage_quantity * p.pricing.effective_list.default) AS cout_prix_catalogue
FROM system.billing.usage AS u
JOIN system.billing.list_prices AS p
  ON u.cloud = p.cloud
 AND u.sku_name = p.sku_name
 AND u.usage_unit = p.usage_unit
 AND u.usage_end_time >= p.price_start_time
 AND (p.price_end_time IS NULL OR u.usage_end_time < p.price_end_time)
WHERE u.usage_date >= date_sub(current_date(), 30)
  AND u.usage_metadata.job_run_id IS NOT NULL
GROUP BY ALL

Sans la colonne run_id, et avec COUNT(DISTINCT u.usage_metadata.job_run_id), la même requête donne le coût de chaque job et son nombre d'exécutions facturées.

Étape 2 : le nom du job

system.lakeflow.jobs ajoute une ligne à chaque modification d'un job (une table SCD2) : le nom actuel est celui de la plus récente.

SELECT workspace_id, job_id, name,
       ROW_NUMBER() OVER (PARTITION BY workspace_id, job_id ORDER BY change_time DESC) AS rn
FROM system.lakeflow.jobs
QUALIFY rn = 1

Joignez sur workspace_id et job_id : un job_id n'est unique que dans son workspace, et la table couvre tous les workspaces de la région. La facturation porte aussi usage_metadata.job_name, rempli pour les jobs serverless et, depuis septembre 2025, sur calcul de job. Un job créé dans une autre région, ou très récemment, peut manquer de system.lakeflow.jobs.

Étape 3 : l'issue de chaque exécution

Une ligne de system.lakeflow.job_run_timeline couvre au plus une heure, et seule la dernière tranche d'une exécution porte result_state. Regroupez par exécution avant toute jointure, sinon une longue exécution compte son coût une fois par tranche :

SELECT workspace_id, job_id, run_id,
       max_by(result_state, period_end_time) AS issue,
       MIN(period_start_time) AS debut,
       MAX(period_end_time) AS fin
FROM system.lakeflow.job_run_timeline
WHERE period_start_time >= date_sub(current_date(), 31)
GROUP BY ALL

Joignez à l'étape 1 sur workspace_id, job_id et run_id. La fenêtre commence un jour plus tôt : une exécution facturée le premier jour a pu commencer la veille. Les exemples de Databricks comptent comme échecs les issues FAILED, ERROR et TIMED_OUT.

Étape 4 : les jobs lancés par un autre job

Une exécution lancée par une tâche « Run Job » porte trigger_type = 'RUN_JOB_TASK'. Sa colonne source_task_run_id désigne la tâche qui l'a lancée, une ligne de system.lakeflow.job_task_run_timeline qui donne le job lanceur :

WITH lancees AS (
  SELECT DISTINCT r.workspace_id, t.job_id AS job_lanceur, r.job_id, r.run_id
  FROM system.lakeflow.job_run_timeline AS r
  JOIN system.lakeflow.job_task_run_timeline AS t
    ON r.workspace_id = t.workspace_id
   AND r.source_task_run_id = t.run_id
  WHERE r.trigger_type = 'RUN_JOB_TASK'
    AND r.period_start_time >= date_sub(current_date(), 30)
    AND t.period_start_time >= date_sub(current_date(), 31)
    AND t.job_id <> r.job_id
)
SELECT workspace_id, job_lanceur, job_id AS job_lance, COUNT(*) AS executions
FROM lancees
GROUP BY ALL

Leur coût vient de la jointure de lancees avec l'étape 1 sur workspace_id, job_id et run_id. Selon la documentation, source_task_run_id n'est pas rempli pour les lignes émises avant début décembre 2025 : aucune exécution plus ancienne n'est reliée à son lanceur. Ce coût est déjà sur la ligne du job lancé : l'ajouter au lanceur le compterait deux fois.

Les pièges

Ce que fait YALineo

YALineo fait ces jointures dans votre navigateur, avec vos droits Databricks, en lecture seule, sans serveur YALineo. Il valorise chaque ligne comme à l'étape 1, corrections additionnées. Une ligne sans prix catalogue est comptée à part, jamais estimée.

La page « Jobs et calcul » donne pour chaque job son coût, son coût par mois, ses DBU, ses exécutions, son coût moyen par exécution, ses échecs en nombre et en montant, et sa tendance sur 7 jours. Les échecs sont les issues FAILED, ERROR et TIMED_OUT, reliées à leur coût par job_run_id. Dans la liste des jobs de Databricks, un badge donne le coût de chaque job à côté de son nom.

La colonne « Jobs lancés » montre, à côté du coût propre d'un job, ce que coûtent les jobs qu'il lance par des tâches « Run Job », avec leur nombre. Ce montant n'entre dans aucun total. Un job qui ne fait que lancer d'autres jobs est listé à 0, et son badge montre ce coût précédé de « ↳ ». Seul le lanceur direct compte.

Le nom vient de system.lakeflow.jobs, avant celui de la facturation. À défaut, YALineo prend le nom de la dernière exécution et le signale ; sinon, l'identifiant s'affiche avec la raison. Un job sur cluster interactif reste dans la ligne du cluster, et YALineo le rappelle sous la liste des jobs.

La période se choisit en jours ou entre deux dates, face à la période d'avant. Une remise saisie s'applique à tous les montants. La part de chaque exécution qui revient aux tables qu'elle écrit est expliquée dans le guide du coût d'une table. Les règles sont dans la méthode : les charges, les jobs lancés, les noms. Pas à pas : Jobs et calcul, la période.

Questions fréquentes

Pourquoi un job affiche-t-il 0 ?

Il tourne sur un cluster interactif, il ne fait que lancer d'autres jobs, ou ses lignes d'usage ne sont pas encore publiées. Dans YALineo, un coût nul porte un lien « Pourquoi ? » qui donne la raison.

Le coût d'un job lancé est-il compté deux fois ?

Non. Il est compté une fois, sous son propre job_id. Le montant affiché à côté du job lanceur sert de repère et n'est ajouté à aucun total.

Les exécutions en échec coûtent-elles quelque chose ?

Oui : ce qu'elles ont consommé avant de s'arrêter est facturé. YALineo en donne le nombre et le montant, et la synthèse des coûts en fait le total sur la période.

Sources

Documentation lue le 6 novembre 2026.