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.
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ème | Ce qu'elle apporte |
|---|---|
system.billing.usage | La consommation, ligne par ligne, avec usage_metadata.job_id et usage_metadata.job_run_id |
system.billing.list_prices | Le prix catalogue de chaque SKU à chaque date ; la clé effective_list contient le prix utilisé pour calculer le coût |
system.lakeflow.jobs | Le nom de chaque job, une ligne par modification (change_time) |
system.lakeflow.job_run_timeline | L'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_timeline | Les 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
-
Le cluster interactif. Sans
job_idnijob_run_id, la consommation du job reste sur la ligne du cluster. Databricks écrit qu'un job sur SQL warehouse ou sur calcul all-purpose n'est pas facturé comme un job, et que son coût exact sur calcul all-purpose ne peut pas être calculé. -
Plusieurs lignes par exécution. Le pilote et les workers d'un calcul classique ont chacun leur ligne quand leurs types de machine diffèrent. Additionnez toujours. Un filtre sur
usage_datecoupe aussi une exécution à cheval sur la limite de la période. -
Les corrections. Une ligne
RETRACTION, de quantité négative, annule l'originale ; une ligneRESTATEMENTla remplace, sauf quand la correction n'a que le retrait. Ne filtrez pas surrecord_type = 'ORIGINAL': la somme donne l'usage corrigé, et le coût d'une exécution peut changer après coup. - Un prix catalogue, pas la facture. La remise du contrat, les engagements et les crédits n'y sont pas. Databricks prévient aussi d'un léger écart possible avec la facturation réelle pour certaines options.
- Les machines du calcul classique n'y sont pas. Le fournisseur cloud facture les machines virtuelles d'un calcul de job classique. Sur Azure, Microsoft précise que le calcul, le stockage et le réseau sont facturés à part des DBU.
- Le retard. Les lignes d'usage arrivent en général sous 12 heures, celles des tables de jobs sous une heure : une exécution récente peut avoir son issue avant son coût.
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.
-
Databricks, Billable usage system table reference (page mise à jour le 5 novembre 2026) :
job_id,job_run_id,job_name, le calcul all-purpose, les corrections, les lignes du pilote et des workers, le délai de 12 heures. -
Databricks, Pricing system table reference (page mise à jour le 4 février 2025) : la clé
effective_list. - Databricks, Monitor costs using system tables (page mise à jour le 11 septembre 2026) : la jointure de l'usage et des prix, l'écart possible avec la facturation réelle.
-
Databricks, Jobs system table reference (page mise à jour le 5 novembre 2026) : la ligne la plus récente d'un job, les tranches d'une heure,
RUN_JOB_TASK,source_task_run_iddepuis début décembre 2025, les tables régionales, le délai d'une heure, le calcul all-purpose. - Databricks, Monitor job costs & performance with system tables (page mise à jour le 5 novembre 2026) : les issues comptées comme échecs, les jobs sur SQL warehouse et calcul all-purpose.
- Microsoft Learn, Optimize Azure Databricks costs with a prepurchase (page mise à jour le 17 juillet 2026) : le calcul, le stockage et le réseau facturés à part des DBU.