La méthode de calcul.
Pour chaque chiffre, YALineo indique d'où il vient. Voici la méthode complète, formule par formule, avec les sources officielles de Databricks et de Microsoft sur lesquelles elle s'appuie. Les liens « La méthode de calcul » de l'extension mènent ici.
Observé
Lu dans les tables système de facturation, au prix catalogue en vigueur, avec la jointure de l'exemple officiel de Databricks.
Attribué
Réparti entre les tables exécution par exécution, ou heure par heure pour un SQL warehouse, selon des règles publiées ; la précision s'affiche à côté de chaque coût.
Estimé ou potentiel
Les projections, le Calculateur et les économies à confirmer, toujours signalés comme tels, avec leurs hypothèses et leur calcul pas à pas.
Vérifiable
« Pourquoi ? » donne la raison d'un coût nul ou absent, et une requête SQL de rapprochement donne le même total que YALineo, dans votre propre workspace.
Une identité, au centime.
Pour toute la plateforme, la dépense de la période se décompose sans reste (section 5.6). Le non attribué n'est jamais ramené à zéro. Sur la plateforme d'exemple de l'extension, 90 jours :
- dépense totale
- 12 535,00 $
- Σ rafraîchissement(T)
- 9 734,00 $
- Σ lecture(T)
- 884,40 $
- tables hors du plan
- 0,00 $
- capacité sans requête
- 160,80 $
- non attribué
- 1 755,80 $
Chaque coût de table affiche sa précision.
La règle qui l'a attribué, de la plus sûre à la moins sûre (section 5.7). Une table prend la mention la moins sûre de ses parts.
La plus sûre
- facturéFacturé à cette table par Databricks : vue matérialisée ou table de streaming serverless.
- seule tableSeule table écrite par les exécutions qui lui sont reliées : leur coût lui revient en entier.
- temps de calculExécution qui écrit plusieurs tables : son coût est partagé au temps de calcul des requêtes qui écrivent chacune.
- parts égalesExécution qui écrit plusieurs tables sans temps de calcul connu pour toutes : parts égales entre elles.
- warehousePart d'un SQL warehouse, heure par heure, au temps de calcul des requêtes de cette heure.
- périodeAucune exécution reliée au lineage : coût partagé entre les tables écrites sur la période. La moins sûre des règles.
La moins sûre
Version 0.34.4, 3 novembre 2026.
Ce document dit, pour chaque chiffre des volets FinOps et Calculateur, d'où il vient, comment il est calculé, ce qui est mesuré et ce qui relève d'une convention de répartition. Il est écrit pour être vérifié : chaque formule est reproductible avec les requêtes SQL données en annexe, et chaque propriété annoncée est contrôlée par un test automatique (section 9).
1. Principe
YALineo ne crée aucune donnée de coût. Il lit les tables système que Databricks publie pour la facturation et l'observabilité, dans le workspace de l'utilisateur, avec ses droits, en lecture seule. Il distingue toujours trois natures de chiffres :
| Nature | Définition | Exemple |
|---|---|---|
| Mesuré | Lu tel quel dans une table système, ou somme exacte de valeurs lues | DBU d'un job, coût au prix catalogue d'un warehouse |
| Attribué | Un coût mesuré réparti entre plusieurs objets selon une règle explicite et documentée | Part du coût d'un job qui revient à chacune des tables qu'il écrit |
| Dérivé | Ratio ou extrapolation d'un chiffre mesuré ou attribué | Coût par lecture, coût mensualisé |
L'attribution d'un coût partagé n'a pas de solution unique : c'est une convention, comme en comptabilité analytique. YALineo applique les modèles de répartition reconnus par la FinOps Foundation (répartition proportionnelle à une mesure d'usage, répartition égale à défaut, non-attribution explicite) et affiche pour chaque table le niveau de précision de son attribution. Aucun coût n'est inventé ni perdu : la somme de ce qui est attribué et de ce qui ne l'est pas est égale, au centime près, à la dépense mesurée.
2. Sources
| Table système | Colonnes utilisées | Rôle |
|---|---|---|
system.billing.usage | usage_quantity, usage_unit, sku_name, cloud, usage_start_time, usage_end_time, usage_date, workspace_id, billing_origin_product, usage_metadata (job_id, job_run_id, dlt_pipeline_id, dlt_update_id, warehouse_id, notebook_id, cluster_id, endpoint_name, app_id, app_name, agent_bricks_id, uc_table_catalog, uc_table_schema, uc_table_name, job_name, notebook_path, genie.surface), identity_metadata.run_as, product_features (is_serverless, serving_type, agent_bricks.problem_type), custom_tags | Consommation facturable, une ligne par période d'usage |
system.billing.list_prices | pricing.default, pricing.effective_list.default, price_start_time, price_end_time, currency_code | Prix catalogue en vigueur au moment de l'usage |
system.lakeflow.job_run_timeline | job_id, run_id, result_state, period_start_time, period_end_time | Issue de chaque exécution de job |
system.lakeflow.job_run_timeline (suite) | trigger_type, source_task_run_id | Exécutions lancées par une tâche « Run Job » d'un autre job (section 4.1) |
system.lakeflow.job_task_run_timeline | run_id, job_id, period_start_time, period_end_time | Le job dont la tâche a lancé une exécution |
system.lakeflow.jobs | workspace_id, job_id, name, change_time | Le nom de chaque job, celui du job qui lance et du job lancé (sections 4.1 et 4.2) |
system.query.history | statement_id, compute.warehouse_id, compute.type, total_task_duration_ms, written_rows, read_rows, start_time, end_time, query_source.genie_space_id | Travail réellement effectué par chaque requête, ses heures, et l'espace Genie qui l'a lancée |
system.access.table_lineage | statement_id, source_table_full_name, target_table_full_name, source_path, target_path, source_type, target_type, entity_type, entity_id, entity_run_id, entity_metadata (job_info.job_run_id, dlt_pipeline_info.dlt_update_id, notebook_id), direct_access (depuis la 0.28), event_id, record_id (depuis la 0.29), workspace_id, event_date, event_time | Quelle requête, quelle exécution de job ou de pipeline, quel tableau de bord lit ou écrit quelle table |
system.compute.node_timeline | cluster_id, node_type, driver, start_time, end_time | Heures des machines des clusters classiques (Calculateur, section 13.4) |
system.lakeflow.job_run_timeline (noms) | workspace_id, job_id, run_name, run_type, period_start_time, period_end_time | Le nom d'un job que system.lakeflow.jobs ne connaît pas : celui de sa dernière exécution nommée (sections 4.2 et 6.8) |
system.lakeflow.pipelines | workspace_id, pipeline_id, name, change_time | Le nom de chaque pipeline (section 4.2) |
system.information_schema.tables | table_catalog, table_schema, table_name, table_type, created, last_altered, data_source_format | Le type d'un objet (section 5.8), sa date de création (section 6.7), la date de sa définition, qui n'est jamais une écriture (section 6.9), et l'inventaire qui décide des liens raccordés (section 6.10) |
Toutes les requêtes portent sur le workspace ouvert (workspace_id), sauf si l'utilisateur choisit explicitement « Tout le metastore, autres workspaces compris » (réglage « Catalogues montrés ») : la facturation de tous les workspaces du compte est alors lue. Les requêtes exactes sont dans extension/lib/queries.mjs (identifiants yalineo:costs, yalineo:spend, yalineo:runs, yalineo:work, yalineo:attrib, à la demande yalineo:work-days pour les courbes de la synthèse (section 6.5), pour le Calculateur yalineo:vmhours, et depuis la 0.24 yalineo:series, la dépense de chaque charge par date, section 6.6). La taille et l'arrêt automatique des SQL warehouses viennent de la liste des warehouses du workspace (GET /api/2.0/sql/warehouses, champs cluster_size et auto_stop_mins), lue aussi pour leurs noms.
3. Le coût d'une ligne d'usage
Pour chaque ligne u de system.billing.usage sur la période :
prix(u) = pricing.effective_list.default du prix de list_prices tel que
cloud, sku_name et usage_unit sont égaux à ceux de u,
et price_start_time <= u.usage_end_time
et (price_end_time est NULL ou u.usage_end_time < price_end_time)
(pricing.default si effective_list n'existe pas sur ce metastore)
coût(u) = u.usage_quantity × prix(u)
-
effective_listintègre les prix promotionnels temporaires appliqués à tous les clients ; c'est le prix catalogue effectif selon la documentation Databricks. - Le prix retenu est celui en vigueur à la fin de la ligne d'usage : c'est la jointure de l'exemple officiel de Databricks (« Join the pricing with usage tables », section 12). Les périodes de prix d'un même SKU ne se chevauchent pas : chaque ligne a au plus un prix. Jusqu'à la 0.17, YALineo exigeait qu'un même prix couvre toute la ligne ; une ligne à cheval sur un changement de prix restait alors sans prix (comptée à part, jamais estimée). Depuis la 0.18, elle a le prix en vigueur à sa fin, comme dans l'exemple officiel.
-
Une ligne sans prix correspondant n'est pas valorisée (coût 0) ; sa quantité est comptée à part (
unpriced) et l'écran dit que le total valorisé est partiel. Rien n'est estimé à sa place. -
Depuis la 0.28, une exception, documentée : les DBU de la SKU
GENIE_FREE_USAGE(l'usage gratuit de Genie, section 4.3) n'ont jamais de prix catalogue, puisque cette SKU « does not carry a list price ». Leur coût est 0, ils restent dans les DBU de la charge, mais ils ne comptent pas dansunpriced: un usage gratuit ne rend pas le total partiel. - Les corrections de Databricks (une ligne de retrait négative, puis une ligne de reprise) sont additionnées comme les autres : la somme reste exacte.
-
La période est en jours civils UTC (
usage_date), comme dans la table Databricks. Elle va de:daysjours avant aujourd'hui à:end_daysjours avant aujourd'hui, les deux dates comprises (:end_daysvaut 1 pour une durée choisie et pour un chargement du plan, qui se terminent hier ; 0 quand la période se termine aujourd'hui). Voir « Période » (section 7).
Remise négociée. Les contrats Databricks ont souvent une remise sur le prix catalogue. YALineo ne la connaît pas ; l'utilisateur peut la saisir (0 à 90 %). Tous les montants affichés sont alors multipliés par (1 − remise). Les DBU ne changent pas. Sans remise, l'écran précise « prix catalogue ».
Ce qui n'est pas dans le total. system.billing.usage contient la consommation Databricks (DBU et autres unités Databricks). Le coût des machines virtuelles du fournisseur cloud pour le calcul classique, le stockage et le réseau facturés par le cloud n'y figure pas ; YALineo ne les inclut donc pas et le dit sur chaque page FinOps. Pour le calcul serverless, la machine est incluse dans le prix Databricks.
4. Les charges de travail
Chaque ligne d'usage appartient à une seule charge de travail, déterminée dans cet ordre (requêtes costs et spend, même règle) :
| Ordre | Condition sur la ligne | Charge | Identifiant |
|---|---|---|---|
| 1 | uc_table_catalog, uc_table_schema, uc_table_name renseignés | Table rafraîchie (vue matérialisée, table de streaming) | nom complet de la table |
| 2 | agent_bricks_id renseigné, ou produit AGENT_BRICKS ou SUPERVISOR_AGENT | Agent (Agent Bricks) | agent_bricks_id (à défaut endpoint_name, app_id, puis le produit) |
| 3 | produit GENIE (usage IA de Genie à la demande) | Genie | usage_metadata.genie.surface (GENIE_CODE, GENIE_ONE, GENIE_AGENTS), à défaut GENIE : type non indiqué (section 4.3) |
| 4 | produit VECTOR_SEARCH (y compris la synchronisation d'un index, qui porte aussi un dlt_pipeline_id) | Endpoint AI Search (recherche vectorielle) | endpoint_name (à défaut dlt_pipeline_id, puis le produit) |
| 5 | job_id renseigné | Job | job_id |
| 6 | dlt_pipeline_id renseigné | Pipeline Lakeflow | dlt_pipeline_id |
| 7 | warehouse_id renseigné | SQL warehouse | warehouse_id |
| 8 | notebook_id renseigné | Notebook serverless | notebook_id |
| 9 | cluster_id renseigné | Cluster | cluster_id |
| 10 | endpoint_name renseigné | Endpoint de serving (agents et modèles déployés) | endpoint_name |
| 11 | app_id renseigné | App | app_id (nom : app_name) |
| 12 | sinon | Autre | billing_origin_product |
agent_bricks_id est lu par son nom dans la forme JSON de usage_metadata (une valeur vide compte comme absente) : sur un metastore dont le schéma n'a pas encore ce champ, la requête ne tombe pas en erreur, l'agent est identifié par son endpoint ou son produit. De même, query_source.genie_space_id est lu dans la forme JSON de query_source ; un historique des requêtes sans cette colonne reçoit une requête de repli, sans les espaces Genie. Les noms des espaces Genie viennent de l'API du workspace (GET /api/2.0/genie/spaces, la liste seulement).
Pour une charge W sur la période de N jours :
coût(W) = Σ coût(u) pour les lignes u de W
DBU(W) = Σ usage_quantity pour les lignes u de W dont usage_unit = 'DBU'
Par construction, chaque ligne appartient à exactement une charge, donc Σ coût(W) = dépense totale.
Autres attributs d'une charge, tous mesurés : nombre d'exécutions (pour un job, les exécutions de system.lakeflow.job_run_timeline ; sinon les job_run_id ou dlt_update_id distincts), produit principal (le billing_origin_product de plus grande quantité), « exécuté par » (identity_metadata.run_as de plus grande quantité), tags (les custom_tags de la ligne de plus grande quantité), serverless (au moins une ligne is_serverless), coût des 7 dernières dates complètes et des 7 dates précédentes (section 6), et coût de ses seules lignes en DBU (pour le prix moyen d'un DBU, section 13.4).
Note : un job lancé sur un cluster interactif est facturé au cluster, pas au job (job_id n'est renseigné que pour le calcul serverless et le calcul de jobs, selon la documentation Databricks). YALineo le rappelle sous la liste des jobs.
Note : un job d'orchestration (un « masterjob ») dont les tâches ne font que lancer d'autres jobs (tâches « Run Job ») ne consomme aucun calcul lui-même. Chaque job lancé s'exécute et est facturé sous son propre job_id : c'est lui qui porte le coût, dans la liste des jobs comme dans son badge. Le masterjob n'a donc ni coût ni badge, ou seulement le coût de ses propres tâches de calcul (un notebook ou une vérification en serverless, par exemple). De même, une tâche qui lance un pipeline ou une requête sur un SQL warehouse est facturée au pipeline ou au warehouse. Depuis la version 0.16, le coût des jobs lancés par un masterjob est montré à côté de son coût propre, sans jamais s'ajouter au total (section 4.1).
4.1 Coût des jobs lancés (tâches « Run Job »)
Une exécution lancée par une tâche « Run Job » d'un autre job porte trigger_type = 'RUN_JOB_TASK' dans system.lakeflow.job_run_timeline, et sa colonne source_task_run_id donne la tâche qui l'a lancée. Cette tâche est une ligne de system.lakeflow.job_task_run_timeline (run_id), qui donne le job qui lance (job_id). Databricks remplit ces deux colonnes depuis début décembre 2025 : avant, aucune exécution n'est reliée à son lanceur.
Pour chaque paire (job qui lance P, job lancé C) sur la période :
exécutions(P, C) = nombre d'exécutions de C dans la période dont la tâche source appartient à P
coûtLancé(P, C) = Σ coût des lignes d'usage de ces exécutions (job_run_id), au prix catalogue de la section 3, moins la remise
coûtLancé(P) = Σ_C coûtLancé(P, C)
- Nature : mesuré. Chaque montant est la facturation des exécutions elles-mêmes, pas une répartition.
- Jamais ajouté : ce montant est déjà compté dans le coût de chaque job lancé (section 4). Il est montré à côté du coût propre du job qui lance (colonne « Jobs lancés » de « Jobs et calcul », ligne de sa fiche, badge des pages Databricks) et n'entre dans aucun total, aucune carte ni aucune attribution aux tables. Les totaux restent la somme des coûts propres, au centime.
-
Masterjob sans calcul : un job dont aucune ligne d'usage ne porte le
job_id(que des tâches « Run Job ») est listé à 0, avec ses exécutions, pour que le coût des jobs qu'il lance ait une ligne. Son badge montre ce coût, précédé de « ↳ » et expliqué dans l'infobulle. - Fenêtre : comme pour le nombre d'exécutions, une exécution compte dès qu'une de ses tranches commence dans la période (Databricks découpe une exécution longue en tranches d'une heure) ; la tâche qui l'a lancée est cherchée à partir d'un jour avant la période, car elle a pu commencer la veille.
-
Requête à part, facultative :
yalineo:launches. Sans droit sursystem.lakeflow.job_task_run_timeline, seule la colonne « Jobs lancés » manque, les exécutions et les échecs restent. Sans droit sursystem.lakeflow.jobs, elle se relance sans les noms (les identifiants restent). Les 20 000 paires les plus chères sont lues, 5 000 sont gardées avec le plan. -
Un seul niveau :
source_task_run_iddésigne le lanceur direct. Si A lance B qui lance C, les exécutions de C comptent pour B, pas pour A. Un job ne compte jamais comme se lançant lui-même. - Fiche d'un job lancé : elle dit qui a lancé ses exécutions (« Lancé par »), avec leur nombre et leur coût.
4.2 Le nom d'un job (0.25)
La facturation ne nomme un job que s'il tourne en serverless (usage_metadata.job_name). Les autres noms viennent des tables système, sans calcul ni estimation : un nom est lu, jamais déduit.
-
Les jobs enregistrés de ce workspace (
yalineo:jobs) :system.lakeflow.jobsest régionale (tous les workspaces de la région) et unjob_idn'est unique que dans son workspace (Microsoft Learn, « Jobs system table reference », consulté le 25 octobre 2026). Le nom retenu est celui de la ligne la plus récente par (workspace_id,job_id), comme le fait la documentation pour une table SCD2 ; un job supprimé garde le dernier nom qu'il avait (une ligne sans nom ne le cache jamais). Le workspace est celui des requêtes de coûts (son adresse, sinon l'usage du SQL warehouse) ; sans droit sur la facturation, son adresse seule ; s'il reste inconnu (adresse AWS sans droit sur la facturation), tous les workspaces de la région, comme avant 0.25. Ses lignes passent avant celles des autres, la limite de 100 000 lignes ne les coupe donc jamais. Même règle pour les pipelines (system.lakeflow.pipelines). -
Les exécutions ponctuelles (
yalineo:run-names) : une exécution soumise parPOST /jobs/runs/submit(Azure Data Factory, l'opérateur Airflow DatabricksSubmitRunOperator) est unSUBMIT_RUN, un notebook lancé pardbutils.notebook.rununWORKFLOW_RUN. Elles ne figurent que dans les tables d'exécutions, jamais danssystem.lakeflow.jobs, et leur seul nom estrun_name; le lineage les nomme pourtant comme un job (entity_type = 'JOB'). Pour lesjob_idde ce workspace que le lineage nomme sur la fenêtre des liens (et ceux facturés sur les mêmes jours, pour la vue FinOps) et quesystem.lakeflow.jobsne connaît pas, le nom est lerun_namede la dernière exécution nommée de cette fenêtre (system.lakeflow.job_run_timeline). Il est montré avec la mention « exécution ponctuelle » quandrun_typevautSUBMIT_RUNouWORKFLOW_RUN; l'identifiant reste affiché sur la fiche et dans l'infobulle. - Dans la vue FinOps : un job que la facturation ne nomme pas prend le nom de son propre workspace (jamais celui d'un job d'un autre workspace qui porte le même identifiant), sinon celui de sa dernière exécution, avec la même mention. Un rechargement de la seule période FinOps garde les noms trouvés au dernier chargement complet.
-
Facultatif : sans droit sur
system.lakeflow.job_run_timeline, les identifiants restent comme avant 0.25. Aucun montant ne change : seuls les noms affichés sont concernés. -
Depuis la 0.28 : tout job enregistré qui a une exécution sur la fenêtre des liens reçoit un nom, dans cet ordre :
system.lakeflow.jobs, sinon lerun_namede sa dernière exécution marqué « nom de sa dernière exécution », sinon l'identifiant avec la raison. Le nom desystem.lakeflow.jobspasse aussi avant celui de la facturation. Détail, citations et dates de lecture : section 6.8.
4.3 Quel Genie, quel produit d'IA (0.28)
Le volet « IA et Genie » nomme chaque ligne d'IA par le produit que la facturation indique, et seulement par des champs documentés. Une valeur absente est dite « non indiquée », une valeur que la documentation ne cite pas « non documentée » ; dans les deux cas la ligne garde son coût mesuré, à part : rien n'est deviné. Sources lues le 28 octobre 2026 (2026-10-28) ; la date de mise à jour de chaque page est entre parenthèses, la liste complète en fin de section.
Les produits Genie aujourd'hui. La documentation (page Genie, 18 sept. 2026) décrit une famille de trois produits : « Genie One: A simplified interface for business users », « Genie Agents: Domain-specific environments where data teams configure trusted data, metrics, and business rules that power Genie One answers », « Genie Code: The AI coding and data assistant for developers and technical practitioners inside the Databricks workspace ». Les noms ont changé en 2026, d'après les notes de version : « Databricks Assistant is now Genie Code » (11 mars 2026) ; « Databricks One, the simplified Databricks interface, has been renamed to Genie » (27 avril 2026) puis « Genie [...] has been renamed to Genie One » (9 juin 2026) ; « Genie Agents (formerly Genie Spaces) are now called Genie Agents » (9 juillet 2026). Un « espace Genie » est donc aujourd'hui un Genie Agent, et « Genie dans Databricks One » est Genie One. Le « mode agent » (« Agent mode ») est une façon de travailler de Genie Code et des Genie Agents (notes de version), pas un produit : les valeurs documentées de la facturation n'en ont pas.
Dans la facturation. Chaque ligne de system.billing.usage du produit GENIE porte le produit Genie dans usage_metadata.genie.surface : « Identifies which Genie product generated the usage (GENIE_CODE, GENIE_ONE, or GENIE_AGENTS) » (Monitor and understand your Genie cost, 11 sept. 2026). La même page cite usage_metadata.genie.channel (« The access channel, for example UI ») et product_features.genie.offering_type (« for example PAYGO ») ; YALineo ne les lit pas, leurs valeurs ne sont pas toutes documentées. La page de référence de la table (Billable usage system table reference, 18 oct. 2026) ne liste pas encore le champ genie : il est lu par son nom dans la forme JSON de usage_metadata, comme agent_bricks_id, et un metastore qui ne l'a pas encore donne NULL au lieu d'une erreur.
| Produit affiché | Ce qui le dit dans la facturation | Identifiant affiché | Ce que la facturation ne dit pas |
|---|---|---|---|
| Genie Code, Genie One, Genie Agents | billing_origin_product = 'GENIE' et usage_metadata.genie.surface = GENIE_CODE, GENIE_ONE ou GENIE_AGENTS | aucun : la ligne est le produit, pour tout le workspace | quel Genie Agent (anciennement espace) a consommé le modèle : aucun champ ne porte son identifiant |
| Genie, type non indiqué | GENIE sans surface (ou vide) | GENIE | le produit Genie ; la documentation ne dit pas quand le champ manque |
| Genie, type non lu | une carte chargée avant 0.28 (la requête ne lisait pas le champ) | GENIE | rechargez la carte |
| Genie, type non documenté | une valeur de surface hors des trois citées | la valeur, si elle a la forme d'un code de facturation (capitales, chiffres, _), sinon rien | ce qu'elle désigne |
| Knowledge Assistant (Agent Bricks) | product_features.agent_bricks.problem_type = 'AGENT_BRICKS_KNOWLEDGE_ASSISTANT' | agent_bricks_id | une autre valeur de problem_type : « Agent Bricks, type non documenté » |
| Supervisor Agent (Agent Bricks) | billing_origin_product = 'SUPERVISOR_AGENT' | agent_bricks_id | |
| Agent Bricks, type non indiqué | AGENT_BRICKS sans problem_type (la documentation décrit AGENT_BRICKS comme « Knowledge Assistant Supervisor Agent workloads ») | agent_bricks_id | Knowledge Assistant ou Supervisor Agent |
| Model Serving : modèle de fondation, modèle déployé, modèle sur GPU, Feature Serving | MODEL_SERVING et product_features.serving_type = FOUNDATION_MODEL, MODEL, GPU_MODEL, FEATURE | endpoint_name | sans serving_type : « type non indiqué » ; une autre valeur : « type non documenté » |
| AI Gateway, AI Functions | une ligne qui porte un endpoint_name et le produit AI_GATEWAY ou AI_FUNCTIONS | endpoint_name | |
| Endpoint, produit … ; Endpoint, produit non indiqué | une ligne qui porte un endpoint_name et un autre produit que MODEL_SERVING, AI_GATEWAY ou AI_FUNCTIONS, ou aucun produit | endpoint_name | ce que ce produit désigne ; le coût reste mesuré, sur sa ligne |
| AI Search (recherche vectorielle) | VECTOR_SEARCH | endpoint_name, à défaut dlt_pipeline_id (synchronisation d'un index) | |
| Databricks Apps | app_id | app_id (nom : app_name) |
Pour un Genie Agent, le type vient de l'historique des requêtes : query_source.genie_space_id, « Statement executed from a Genie Agent » (Query history system table reference, 20 oct. 2026). Son nom vient de l'API du workspace (GET /api/2.0/genie/spaces, la liste seulement).
Gratuit ou facturé. « Genie usage is split across two SKUs based on whether the usage is free or billed, not based on the Genie product » : l'usage facturé est sous la SKU Serverless Real-Time Inference de la région, partagée avec d'autres produits (d'où le filtre sur billing_origin_product), et l'usage gratuit sous GENIE_FREE_USAGE, qui « does not carry a list price » (Monitor and understand your Genie cost). Sont gratuits l'allocation mensuelle de 150 DBU par utilisateur et, jusqu'au 31 janvier 2027, Genie One et Genie Agents pour les utilisateurs ; les principaux de service sont facturés. YALineo compte les DBU de GENIE_FREE_USAGE à part (free_dbus de la requête costs) : ils restent dans les DBU de la charge, leur coût est 0 et ils ne sont jamais dits « non tarifés ». Les DBU gratuits consommés avant le 20 juillet 2026 ne figurent pas dans la table (la page le dit). La remise promotionnelle de 25 % est déjà dans usage_quantity de l'usage facturé : le prix catalogue s'applique comme à toute ligne (section 3). Les corrections du 21 juillet 2026 (lignes RETRACTION qui annulent l'usage Genie One et Genie Agents facturé avant) s'additionnent comme toute ligne : leur somme est nulle. Pour estimer ces coûts avant de construire un Genie Agent, voir la page « IA : Genie et agents » (section 13.16).
Ce qui est facturé où, sans double compte. La ligne Genie porte le modèle de langage. Les requêtes SQL que Genie lance sont facturées par le SQL warehouse : « Budgets track large language model (LLM) usage only. Compute used to run the queries Genie generates, such as a SQL warehouse, is billed separately » (Genie consumption guide, 11 sept. 2026), et « Genie Agents require a pro or serverless SQL warehouse » (Create and manage a Genie Agent, 9 oct. 2026). Ces requêtes sont dans la charge du warehouse (warehouse_id) ; la part de chaque Genie Agent (section 5.4, heure par heure, par query_source.genie_space_id) est déjà dans ce coût et ne s'ajoute jamais au coût de l'IA. L'écran montre côte à côte la part SQL de chaque agent et la ligne Genie Agents (le modèle, tous les agents ensemble) : deux coûts distincts, jamais additionnés. Les calculs que Genie Code lance (notebook, éditeur SQL) sont facturés par ce calcul ; la documentation de l'historique des requêtes ne cite pas de source Genie Code : ce calcul n'est pas rattaché à Genie Code (inconnu).
L'ordre des charges. Depuis 0.28, les produits d'IA nommés par billing_origin_product (Agent Bricks, Genie, AI Search) passent avant les champs de calcul (tableau de la section 4). La référence de la table dit que dlt_pipeline_id est aussi rempli pour « AI Search indexing » : avant 0.28, la synchronisation d'un index AI Search était comptée comme un pipeline et sortait du coût de l'IA. Restent hors de « IA et Genie », faute d'un champ documenté qui les distingue : le Model Serving ancien (« legacy model serving »), facturé avec un cluster_id (charge Cluster) ; les produits AI_FUNCTIONS, AI_RUNTIME, FOUNDATION_MODEL_TRAINING, AGENT_EVALUATION et AI_GATEWAY sans endpoint_name, ou dont la ligne porte aussi un champ de calcul (job_id, dlt_pipeline_id, warehouse_id, notebook_id, cluster_id, lus avant endpoint_name dans le tableau de la section 4), qui vont à la charge de ce champ (job, notebook...) ou à « Autre ».
À l'écran et dans l'export. Une ligne Genie porte le nom de son produit (Genie Code, Genie One, Genie Agents) et, dessous, ce qu'il est et son ancien nom ; les autres lignes portent leur produit et, pour un agent ou une app, leur identifiant de facturation. Une ligne dont le type n'est pas indiqué le dit, avec « Pourquoi ? » (les champs absents, la méthode). « Par produit » remplace « Par type » : chaque produit, arrondi par les plus grands restes (section 6.2), somme au coût de l'IA au centime. L'export « IA et Genie » ajoute trois colonnes : ai_product (le produit affiché), ai_product_billing (les champs et valeurs qui le disent, par exemple billing_origin_product = GENIE · usage_metadata.genie.surface = GENIE_CODE) et free_dbus ; les lignes des questions des Genie Agents portent Genie Agent et query_source.genie_space_id. Une valeur lue dans la facturation n'est montrée que si elle a la forme d'un code documenté ; une cellule qui ressemble à une formule reste du texte (lib/csv.mjs).
Vérification. tests/v0280-genie28.test.mjs (classement des lignes de facturation, valeurs inconnues et hostiles, sommes au centime, export), tests/spark/finops_sql.py (Genie Code, Genie One et Genie Agents séparés, DBU gratuits, champ absent ou vide, valeur hostile, synchronisation d'un index AI Search, schémas anciens), tests/security.test.mjs (attaque par une valeur de surface piégée).
Sources (lues le 2026-10-28).
- Databricks, Billable usage system table reference (18 oct. 2026) : https://docs.databricks.com/aws/en/admin/system-tables/billing ; Microsoft Learn, même page (2026-10-18) : https://learn.microsoft.com/azure/databricks/admin/system-tables/billing
- Databricks, Monitor and understand your Genie cost (11 sept. 2026) : https://docs.databricks.com/aws/en/genie/monitor-cost ; Microsoft Learn (2026-09-11) : https://learn.microsoft.com/azure/databricks/genie/monitor-cost
- Databricks, Genie cost and budgets FAQ (11 sept. 2026) : https://docs.databricks.com/aws/en/genie/genie-cost-budgets-faq
- Microsoft Learn, Genie consumption guide (2026-09-11) : https://learn.microsoft.com/azure/databricks/genie/consumption-guide
- Databricks, Genie (18 sept. 2026) : https://docs.databricks.com/aws/en/genie/ ; Genie Agents (7 oct. 2026) : https://docs.databricks.com/aws/en/genie-agents/ ; Create and manage a Genie Agent (9 oct. 2026) : https://docs.databricks.com/aws/en/genie-agents/set-up ; Genie One (12 oct. 2026) : https://docs.databricks.com/aws/en/genie-one/ ; Genie Code (13 oct. 2026) : https://docs.databricks.com/aws/en/genie-code/
- Databricks, Query history system table reference (20 oct. 2026) : https://docs.databricks.com/aws/en/admin/system-tables/query-history
- Notes de version (noms seulement) : March 2026 (25 mars 2026) : https://docs.databricks.com/aws/en/release-notes/product/2026/march ; AI/BI and Genie One release notes 2026 (27 oct. 2026) : https://docs.databricks.com/aws/en/ai-bi/release-notes/2026
5. L'attribution aux tables
C'est la partie « attribuée ». Depuis la 0.20, chaque règle part du lien le plus précis que les tables système donnent entre une dépense et une table : la facturation d'une table, puis l'exécution qui l'a écrite, puis l'heure d'un SQL warehouse, puis, à défaut seulement, la période. Ce qui ne peut pas être relié reste visible comme non attribué ; rien n'est réparti pour faire tomber un total.
5.1 Table facturée directement (précision « facturé »)
Une ligne d'usage qui porte le nom d'une table Unity Catalog (vue matérialisée, table de streaming rafraîchie par Databricks) est attribuée en totalité à cette table. C'est une mesure, pas une répartition.
rafraîchissement(T) += coût(W) pour W de type Table et T = W
5.2 Jobs et pipelines : exécution par exécution (requête attrib)
Le coût d'une exécution. Chaque ligne d'usage d'un job porte l'exécution qu'elle facture (usage_metadata.job_run_id), chaque ligne d'un pipeline sa mise à jour (usage_metadata.dlt_update_id). Pour une exécution R d'une charge W facturée sur la période :
coût(R) = Σ coût(u) pour les lignes u de W dont job_run_id (ou dlt_update_id) = R
Les tables écrites par cette exécution. Le lineage donne, pour chaque écriture, l'exécution qui l'a faite : entity_metadata.job_info.job_run_id pour un job, entity_metadata.dlt_pipeline_info.dlt_update_id pour un pipeline (sur un metastore plus ancien, entity_type et entity_run_id). L(R) est l'ensemble des tables cibles des événements du même workspace dont l'exécution est R, lus sur la période élargie d'un jour de chaque côté (une exécution peut écrire la veille ou le lendemain de sa facturation).
Le partage dans l'exécution, n = |L(R)| :
n = 1 : part(R, T) = 1 précision « seule table »
n > 1 et m(R, Ti) > 0 pour chaque table : part(R, Ti) = m(R, Ti) / Σ m(R, Tj) précision « temps de calcul »
n > 1 sinon : part(R, Ti) = 1 / n précision « parts égales »
rafraîchissement(T) += Σ_R coût(R) × part(R, T)
-
m(R, T)est la somme destotal_task_duration_msdes requêtes de l'exécutionRqui écriventT(jointure desystem.query.historyet du lineage parstatement_id). Une requête qui écritktables compte pour1/kde son temps dans chacune.total_task_duration_msest, selon Databricks, le temps de tâche cumulé sur tous les cœurs de tous les nœuds : une mesure du calcul consommé. -
statement_idn'est renseigné dans le lineage que pour les requêtes exécutées sur un SQL warehouse ou en serverless. Sur un cluster classique, le temps par table n'existe pas : la répartition est égale, et la table le dit. - Une table écrite par une exécution reçoit le coût de cette exécution, pas celui des autres : un job dont les tables changent d'une exécution à l'autre est réparti exécution par exécution.
- Une exécution sans écriture dans le lineage (un échec avant l'écriture, une écriture que le lineage ne capte pas) reste non attribuée. Son coût n'est jamais reporté sur les tables des exécutions réussies.
- Toutes les tables écrites comptent dans le partage, quel que soit leur catalogue. La part d'une table hors des catalogues du plan, ou supprimée depuis (table temporaire, checkpoint), est comptée à part (« tables hors du plan ») et n'est jamais reportée sur les tables visibles. Le chiffre d'une table ne dépend donc pas de ce que l'utilisateur a choisi de charger.
-
Catalogues internes de Databricks (0.34.3). Databricks crée lui-même un catalogue
__databricks_internal« to store internal state for features such as Lakeflow pipelines and AI/BI dashboards », un nom réservé que seul Databricks utilise (Microsoft Learn, What are catalogs in Azure Databricks?, partie « The__databricks_internalcatalog », https://learn.microsoft.com/azure/databricks/catalogs/, lu le 2026-11-03). Le porteur du projet a aussi vu, sur un workspace réel, des catalogues__databricks_internal_catalog_lakeview_<utilisateur>(3 novembre 2026). Depuis la 0.34.3, une table d'un catalogue dont le nom commence par__databricks_internal, quelle que soit la casse, n'est jamais sur le plan, quels que soient les catalogues chargés et l'inventaire (extension/lib/internal-catalog.mjs). Sa part d'une exécution, ou sa part sur la période dans le repli ci-dessous (même règle que les autres tables écrites), compte dans « tables hors du plan » ; elle est dite à part,interne(W), une partie dehors_plan(W)qui ne s'y ajoute jamais une seconde fois. De même pour une ligne d'usage facturée au nom d'une telle table (section 5.1) et pour une requête de SQL warehouse qui en écrit ou en lit une (section 5.4) : ni rafraîchissement ni lecture d'une table, leur coût va àhors_plan(W)et àinterne(W). Une ligne facturée au nom d'une table interne reste une charge (le total tombe juste au centime), jamais nommée : « Table interne de Databricks (masquée) » à l'écran et dans les fichiers, sans identifiant. Les lignes écrites par une requête dans une table interne ne font pas de table des coûts (relecture de la 0.34.3).
Repli sur la période (précision « période »). Deux cas n'ont pas d'exécution à relier :
- une charge dont aucune exécution facturée n'apparaît dans le lineage, alors que le lineage montre ses écritures sur la période (identifiants d'exécution absents ou différents) ;
- les lignes d'usage sans identifiant d'exécution (par exemple un notebook serverless, section 5.3).
Leur coût est alors partagé entre les tables que la charge a écrites sur la période : au temps de calcul quand chaque table en a, à parts égales sinon. Une seule table écrite garde la précision « seule table ». Ce repli est dit à l'écran par sa précision, la moins sûre.
Dans ce repli, une charge dont aucune table écrite n'est sur le plan (toutes supprimées depuis, ou toutes dans des catalogues internes de Databricks) n'a aucune table où partager : tout son coût reste non attribué, ni « tables hors du plan » ni « catalogues internes de Databricks ». Exécution par exécution, la même charge irait à ces lignes. C'est la règle des tables disparues, gardée telle quelle pour les tables internes (relecture de la 0.34.3) : sans exécution reliée, rien ne dit quelle part du coût revient à ces tables plutôt qu'à des exécutions sans écriture.
Contrôle. La requête renvoie aussi, par charge, le nombre et le coût de ses exécutions facturées (runs) et de celles reliées au lineage (tied) : l'écart est le coût des exécutions sans écriture observée.
Les parts d'une exécution somment à 1 : une exécution est attribuée au plus une fois.
5.3 Notebooks serverless
La facturation d'un notebook serverless ne porte pas d'exécution. Son coût sur la période va à la table qu'il a écrite s'il n'en a écrit qu'une (« seule table »), sinon il suit le repli sur la période de la section 5.2 (« période »). Un notebook lancé par un job est facturé au job et suit la section 5.2.
5.4 SQL warehouses : heure par heure (précision « warehouse »)
Un warehouse sert plusieurs usages à la fois. Depuis la 0.20, son coût est réparti heure par heure (requête work) :
coût(W, h) = Σ coût(u) × fraction de la ligne u dans l'heure h (une ligne d'usage est étalée sur les heures qu'elle couvre)
ms(q, h) = total_task_duration_ms(q) × fraction de la durée de q dans l'heure h
coût(q) = Σ_h coût(W, h) × ms(q, h) / Σ_q' ms(q', h) (à parts égales entre les requêtes de l'heure si aucune n'a de temps)
rafraîchissement(T) += Σ coût(q) / k pour les requêtes q qui écrivent T (k tables écrites)
lecture(T) += Σ coût(q) / k pour les requêtes q qui lisent T sans rien écrire (k tables lues)
- Une requête à cheval sur deux heures compte dans chacune pour la part de sa durée qui s'y trouve.
- Une requête a un seul rôle : elle écrit (si elle écrit au moins une table) ou elle lit. Elle n'est jamais comptée deux fois.
- Capacité sans requête : une heure facturée où aucune requête n'a tourné (démarrage, attente avant l'arrêt automatique) n'est répartie sur personne. Elle est montrée à part, par warehouse, sous ce nom.
-
Les requêtes qui ne touchent aucune table du lineage (requêtes ad hoc, métadonnées,
SELECT 1) et celles sur des tables hors des catalogues du plan restent non attribuées. - Depuis la 0.34.3, une requête qui écrit ou lit une table d'un catalogue interne de Databricks (section 5.2) ne donne ni rafraîchissement ni lecture : son coût va à « tables hors du plan », dit à part sous « catalogues internes de Databricks ».
-
Par construction,
Σ_T [rafraîchissement + lecture] + capacité sans requête ≤ coût(W): on n'attribue jamais plus que la dépense.
Les requêtes d'un tableau de bord, d'une requête enregistrée ou d'un espace Genie reçoivent de même le coût de leurs requêtes, heure par heure (section 6) ; ce montant est déjà dans coût(W) et ne s'ajoute à rien.
5.5 Ce qui n'est pas attribué
Clusters interactifs, endpoints, apps, notebooks sans lineage, exécutions sans écriture observée, la part des warehouses qui ne correspond à aucune table : YALineo ne les rattache à aucune table, faute de lien mesuré. Ils restent visibles sous « non attribué ». C'est l'option « ne pas répartir » de la FinOps Foundation, préférée à une répartition arbitraire. Deux montants sont isolés : la part des tables hors du plan (section 5.2) et la capacité sans requête des warehouses (section 5.4).
5.6 Identité comptable
Pour toute charge W :
coût(W) = vers_tables(W) + vers_lectures(W) + hors_plan(W) + capacité_sans_requête(W) + non_attribué(W)
et pour la plateforme :
dépense totale = Σ_T rafraîchissement(T) + Σ_T lecture(T) + tables hors du plan + capacité sans requête + non attribué
Le non attribué n'est jamais ramené à zéro : une correction de Databricks (ligne négative) peut le rendre négatif, et l'identité reste exacte au centime. Elle est vérifiée par les tests (section 9) et visible à l'écran.
Depuis la 0.34.3, hors_plan(W) = tables_disparues(W) + interne(W) : la part des tables des catalogues internes de Databricks (section 5.2) est une partie des tables hors du plan, dite à part et jamais ajoutée une seconde fois. L'identité ne change pas.
5.7 Niveaux de précision affichés
Du plus sûr au moins sûr :
| Mention | Signification |
|---|---|
| facturé | Une ligne d'usage au nom de la table (section 5.1). Seule mention sans « ≈ » sur les badges |
| seule table | La seule table écrite par les exécutions qui lui sont reliées : leur coût lui revient en entier |
| temps de calcul | Une exécution qui écrit plusieurs tables, partagée au temps de calcul mesuré de chaque écriture |
| parts égales | Une exécution qui écrit plusieurs tables sans temps de calcul connu pour toutes |
| warehouse | Une part d'un SQL warehouse, heure par heure, au temps de calcul des requêtes |
| période | Aucune exécution reliée : partagée entre les tables écrites sur la période |
Une table qui reçoit plusieurs parts prend la mention la moins sûre. Un plan chargé avant la 0.20, sans la requête attrib, garde l'ancienne règle (partage sur la fenêtre du lineage) sous la mention « période », et l'écran invite à recharger.
5.8 Tables et vues
Unity Catalog distingue les tables (gérées ou externes), les vues, les vues de métriques, les vues matérialisées et les tables de streaming. Le plan les distingue aussi (une vue a un anneau creux), et depuis la 0.21 chaque liste de coûts dit le type de l'objet, avec un filtre « Type d'objet » (section 7) et une colonne type dans l'export.
- Vue matérialisée, table de streaming : leurs données sont gardées et rafraîchies. Leur rafraîchissement suit les règles de la section 5 : facturé à leur nom quand Databricks le facture ainsi (section 5.1), sinon une part des exécutions qui les rafraîchissent.
-
Vue, vue de métriques : aucune donnée gardée ; Databricks la calcule à chaque lecture à partir de ses sources. Elle n'est jamais rafraîchie :
-
une exécution qui la (re)définit (
CREATE OR REPLACE VIEW: le lineage note la vue comme écrite,target_type=VIEWouMETRIC_VIEW) ne lui donne aucune part. L'exécution paie ses autres tables ; si elle n'a écrit que des vues, son coût reste non attribué (section 5.5) ; - une requête de warehouse qui la (re)définit n'est ni une écriture ni une lecture : sa part de l'heure reste avec le warehouse, non attribuée ;
-
son coût est celui des requêtes qui la lisent,
lecture(V)(section 5.4), affiché « ≈ ».
-
une exécution qui la (re)définit (
- Lectures à travers une vue : lire une vue lit ses sources. Les lectures d'une vue comptent donc aussi pour les tables qu'elle lit, et pour leurs propres sources quand ce sont aussi des vues :
lectures_par_vues(T) = Σ lectures(V) pour chaque vue V bâtie sur T, directement ou à travers d'autres vues
lectures(T) = lectures_directes(T) + lectures_par_vues(T)
Depuis la 0.28, lectures_directes(T) ne compte pas les lignes du lineage marquées direct_access = false (la table sous une vue lue) : sans quoi une lecture à travers une vue compterait deux fois pour T (section 6.8).
Une table lue seulement à travers une vue n'est donc plus « sans lecture observée », ni dans le volet FinOps, ni dans l'analytique (« écrites sans lecture observée »), ni dans le bilan de santé. Le coût de ces lectures reste à la vue : il n'est jamais compté deux fois.
-
Borne du parcours : chaque vue lue compte toujours pour ses sources directes. Au-delà, le parcours s'arrête à 100 vues imbriquées (la limite de Spark pour des vues imbriquées) et à 2 millions de liens parcourus en tout ; les plateformes réelles restent très loin de ces deux bornes. Au-delà de l'une d'elles, les lectures des objets en amont de l'arrêt sont un minimum, marqué « ≥ » : ces objets ne sont jamais dits sans lecture, et leur coût par lecture n'est pas affiché (il serait surestimé). Un avis le dit sous la liste des tables, et la colonne
reads_at_leastde l'export vautyespour eux. - Un plan chargé avant la 0.21 garde les parts qu'il a reçues ; celles qui vont à une vue restent non attribuées, et l'identité de la section 5.6 tient au centime.
5.9 Catalogues et schémas
Depuis la 0.22, la page « Catalogues et schémas » du volet FinOps et les badges de Catalog Explorer disent ce que coûte chaque catalogue et chacun de ses schémas. Aucun chiffre nouveau : ce sont les sommes des chiffres par table des sections 5.1 à 5.8.
rafraîchissement(C) = Σ rafraîchissement(T) pour les tables T du catalogue (ou du schéma) C
lecture(C) = Σ lecture(T)
Un schéma appartient à un seul catalogue : les schémas d'un catalogue somment à lui, et les catalogues au total des tables, au centime (arrondis de la section 6.2, dans l'export aussi). Les tables du plan sans coût sur la période sont comptées, pour qu'un schéma qui n'a rien coûté figure quand même. Les objets sans catalogue (fichiers, chemins) sont comptés à part, « hors catalogue ».
Exact ou réparti. Le montant d'un niveau (catalogue ou schéma) est exact quand aucune règle de partage entre ce niveau et un autre n'intervient :
- une part facturée au nom d'une table (section 5.1) est exacte partout ;
- une charge (job, pipeline, notebook) dont tous les objets écrits sur la période (tables gardées, tables disparues depuis, vues redéfinies) sont dans ce seul catalogue, ou ce seul schéma, lui donne en entier ce qu'elle a payé pour eux : la façon dont ce coût se partage ensuite entre ses tables ne change pas la somme du niveau. Il faut aussi qu'aucune part de cette charge n'aille à une vue (section 5.8) ni à une table hors du plan (section 5.2), une table d'un catalogue interne de Databricks comprise (0.34.3) ;
- une charge qui a écrit dans plusieurs catalogues (ou schémas), et toute part d'un SQL warehouse (partagé heure par heure, section 5.4), sont partagées par les règles des tables : leur part dans le niveau est une estimation.
exact(C) = Σ parts(T, W) pour les tables T de C et les charges W facturées à T, ou qui n'ont écrit que dans C
réparti(C) = rafraîchissement(C) − exact(C)
Exemple : un job qui écrit lake.silver.a et lake.gold.d est exact pour le catalogue lake et réparti entre les schémas silver et gold. L'écran montre « exact » ou « dont x % réparti » sur chaque ligne, et la part exacte du total ; un badge n'a pas de « ≈ » quand son montant est exact.
Lectures. lecture(C) est la part des warehouses payée par les requêtes qui lisent ses tables (section 5.4), toujours une estimation, affichée « ≈ ». Elle ne s'ajoute pas au rafraîchissement : ce sont deux usages différents.
Part du total. La colonne « part » vaut rafraîchissement(C) / dépense totale de la période.
Identité. Sans filtre de tables, l'écran rapproche le tout au centime :
dépense totale = Σ_C rafraîchissement(C) + hors catalogue + Σ_C lecture(C) + capacité sans requête + non attribué + tables hors du plan
Catalogues internes de Databricks (0.34.3). Un catalogue dont le nom commence par __databricks_internal (section 5.2) n'est jamais une ligne de la page, de son export ni d'un badge. Ce que ses tables ont reçu est dit sur une ligne à part du rapprochement, « Catalogues internes de Databricks » ; la ligne « Tables disparues depuis » garde le reste des tables hors du plan. Un chiffre qu'un autre lecteur aurait encore rangé sous une telle table (rafraîchissement ou lecture) va sur cette même ligne, jamais sur une ligne de catalogue. L'identité s'écrit alors :
dépense totale = Σ_C rafraîchissement(C) + hors catalogue + Σ_C lecture(C) + capacité sans requête + non attribué + tables disparues depuis + catalogues internes
tables disparues depuis + catalogues internes = tables hors du plan (section 5.6)
Exemple (tests/v0343-internal.test.mjs) : une dépense de 193,81 $. Un pipeline (100,37 $) écrit lake.gold.orders_daily (60,25 $) et une table de __databricks_internal (40,12 $) ; un job (12,34 $) n'écrit qu'un jeu de données d'un catalogue __databricks_internal_catalog_lakeview_<utilisateur> ; un rafraîchissement est facturé au nom de la table interne (3,33 $), un autre à lake.gold.orders_daily (7,77 $) ; un warehouse (50,00 $) écrit lake.gold.orders_daily (10,01 $), la lit (15,02 $), lit et écrit le jeu de données interne (4,44 $ + 1,11 $), reste à vide 6,66 $ et passe 12,76 $ sur aucune table ; un job (20,00 $) écrit une table supprimée depuis. La page montre lake 78,03 $, lectures 15,02 $, warehouses à vide 6,66 $, calcul sans table écrite 12,76 $, tables disparues depuis 20,00 $, catalogues internes de Databricks 61,34 $ (40,12 + 12,34 + 3,33 + 4,44 + 1,11) : 193,81 $ au centime, et aucune ligne __databricks_internal.
Ce qui garde leurs noms (relecture de la 0.34.3). L'écran, les fichiers CSV, HTML et Excel (fichier de la fiche compris, troisième relecture) et les badges ne nomment jamais une table ni un catalogue interne. Une charge facturée au nom d'une table interne y est dite « Table interne de Databricks (masquée) », sous la clé TABLE:internal et sans identifiant, qu'elle vienne des coûts chargés, de la période d'avant ou de la liste des plus fortes variations des Tendances (seconde relecture). Des champs techniques gardent ces noms, parce que les calculs ou la navigation en ont besoin ; ils restent sur l'appareil de l'utilisateur, comme le plan lui-même : le plan téléchargé en JSON (« Télécharger le plan », l'entrée du pré-vol), qui est le modèle tel que YALineo le calcule (hidden.writes, les écritures gardées pour le partage des coûts ; bridged.through, les tables qu'un raccord traverse ; les lignes de coûts et de requêtes lues, finops ; en mode analyste, les réponses de l'API de lineage, api.rows) ; l'adresse de la page du studio quand la fiche, la tendance ou un filtre de l'exploration porte sur une telle charge (paramètres asset, trend et ex, visibles dans la barre d'adresse du navigateur) ; la clé sous laquelle le suivi d'un constat est gardé. La recherche de « Jobs et calcul » et de l'exploration cherche aussi dans cet identifiant caché : taper le nom d'une table interne fait apparaître sa ligne, toujours sous le nom masqué (limite connue de la 0.34.3).
Des catalogues choisis tous internes. Choisis avant la 0.34.3, ils ne sont plus lus ; s'il n'en reste aucun autre, YALineo ne lit rien (et jamais « tous les catalogues » à leur place) et demande d'en choisir d'autres : le chargement, la période des coûts et chaque requête qui dépend des catalogues (toute instruction qui reçoit le choix enregistré des catalogues : inventaire des colonnes, tendances, « Pourquoi ? », y compris pour un plan enregistré avant la 0.34.3 et au pré-vol) s'arrêtent avant d'envoyer une instruction, et le plan déjà enregistré reste. Une instruction qui ne dépend pas de ce choix (les colonnes d'une table nommée, par exemple) part comme avant. Dans les réglages, enregistrer sans catalogue coché le dit une fois ; enregistrer de nouveau sans en cocher lit alors tous les catalogues, comme choisi. Le message compare toujours au dernier choix enregistré, jamais à celui de l'ouverture de la page. L'estimation du volume des réglages lit les cases cochées du formulaire, où aucun catalogue interne n'est proposé : sans case cochée, elle estime tous les catalogues, comme un enregistrement sans case cochée.
Avec un filtre de tables (section 7), seules les tables choisies sont additionnées et le rapprochement n'est pas affiché : il ne vaut que pour la plateforme entière.
Variation. La carte du total se compare à la même somme sur la période précédente (section 7.1) : les catalogues de cette période, avec les mêmes filtres et la même remise.
6. Indicateurs dérivés
| Indicateur | Formule | Remarque |
|---|---|---|
| Coût mensualisé | x × (365 / 12) / N | Extrapolation linéaire de la période observée sur un mois moyen de 365/12 jours (30,42), le même partout (Calculateur compris : 730 heures, 12 mois font 365 jours) ; affiché « ≈ par mois ». N est le nombre de jours comptés de la période (section 7, « Période ») |
| Projection (coût et DBU) | H × rythme(W), sommée par produit, par table et pour le total | Page « Projections » et carte « Projection, 30 prochains jours » de la synthèse : section 7.2 |
| Lectures d'une table | Nombre de lignes du lineage où la table est source, directes seulement depuis la 0.28 (section 6.8), sur la période du coût (requête attrib), plus les lectures des vues bâties sur elle (section 5.8) | Inclut les lectures par d'autres traitements, qui sont des usages réels. Un plan chargé avant la 0.20 compte sur la fenêtre d'activité du plan |
| Coût par lecture | rafraîchissement(T) / lectures(T) | Vide si la table n'est pas rafraîchie ou pas lue |
| Coût par million de lignes écrites | rafraîchissement(T) / written_rows(T) × 10⁶ | Lignes mesurées par system.query.history |
| Coût de la chaîne amont | rafraîchissement(T) + Σ rafraîchissement(U) pour les tables U en amont de T | Ce dont un actif dépend. Une table partagée compte entièrement pour chaque actif : ces montants ne s'additionnent pas entre actifs |
| Coût des requêtes d'un tableau de bord | Σ coût(q) de ses requêtes, heure par heure (section 5.4) | Requêtes rattachées au tableau de bord par le lineage |
| Coût des questions d'un espace Genie | Σ coût(q) des requêtes dont query_source.genie_space_id est l'espace G (section 5.4) | Déjà dans le coût du warehouse : ne s'ajoute ni au total ni à « IA et applications » |
| IA et applications | Σ coût(W) des charges Agent, Genie, Endpoint de serving, AI Search et App, corrections comprises | Mesuré. Les Apps y figurent : le nom le dit. Les espaces Genie sont montrés à part (ligne précédente) |
| Coût d'une vue | lecture(V) : la part des warehouses payée par les requêtes qui la lisent | Une vue n'est jamais rafraîchie (section 5.8) ; affiché « ≈ » |
| Table sans lecture observée | rafraîchissement(T) > 0 et lectures(T) = 0 sur la période, ni directes ni à travers une vue | Un coût attribué, pas une économie : une lecture hors Databricks, un export ou un usage mensuel n'apparaît pas dans le lineage. À vérifier avec le propriétaire avant d'arrêter quoi que ce soit |
| Coût en hausse | coût 7 j ≥ 1,5 × coût 7 j précédents et écart ≥ max(1, 2 % de la dépense de la semaine) | Seuils fixes et publiés. Les « 7 j » sont les 7 dernières dates complètes de la période : fin − 6 à fin ; pour une période qui se termine aujourd'hui (en cours), les 7 dates qui finissent hier (aujourd'hui − 7 à aujourd'hui − 1). Les « 7 j précédents » sont les 7 dates d'avant. Une dépense constante ne montre aucun écart. La requête costs lit donc au moins 14 jours avant la fin |
| Coût des échecs | Coût des exécutions dont l'état final est FAILED, ERROR ou TIMED_OUT | Joint par job_run_id |
| Estimation d'un passage de l'IA (glossaire, 0.22) | appels = tables choisies ; jetons_entrée = Σ (90 + ⌈nom / 4⌉ + ⌈description / 4⌉ + ⌈60 premières colonnes / 4⌉), en caractères ; jetons_sortie = appels × 400 ; coût = (jetons_entrée × prix_entrée + jetons_sortie × prix_sortie) / 10⁶ | Dérivé, avant d'exécuter. Les prix par million de jetons sont ceux que l'utilisateur saisit (page de prix de Databricks pour le modèle choisi) : sans eux, aucun montant. 400 est la borne max_tokens écrite dans l'instruction, donc un maximum ; quatre caractères par jeton est une approximation. La facture réelle est celle de Databricks (Foundation Model APIs) |
6.1 Badges dans les pages Databricks
Dans les pages Databricks (liste des jobs, Catalog Explorer, navigateur du workspace...), un petit montant suit chaque lien vers un objet de ce workspace qui coûte au moins un centime. Il ne crée aucun chiffre nouveau : c'est l'un des chiffres ci-dessus, sur la période chargée (N jours), au prix catalogue moins la remise saisie, sans filtre.
Depuis la 0.28, chaque objet que le plan connaît a un badge : « < 0,01 $ » sous le centime, ou une courte mention avec sa raison (« 0 $ · vue », « non attribué »...). Les cas et leurs règles sont dans la section 6.8.
Depuis la 0.34.3, un catalogue interne de Databricks (section 5.2), ses schémas et ses tables n'ont aucun badge, ni montant ni mention.
| Lien vers | Montant affiché | Nature | Formule |
|---|---|---|---|
| Job, pipeline, SQL warehouse | Son coût | Mesuré | coût(W) (section 4) |
| Job qui lance d'autres jobs (tâches « Run Job ») | Son coût, et dans l'infobulle le coût des jobs qu'il lance ; sans calcul propre, ce seul coût, précédé de « ↳ » | Mesuré | coûtLancé(P) (section 4.1), jamais ajouté à son coût |
| Table, vue matérialisée, table de streaming | Son rafraîchissement, précédé de « ≈ » sauf s'il est facturé à son nom (précision « facturé ») | Attribué | rafraîchissement(T) (section 5) ; l'infobulle nomme le type, donne la précision et lecture(T) |
| Vue, vue de métriques | Le coût des requêtes qui la lisent, précédé de « ≈ » | Attribué | lecture(V) (section 5.8) ; l'infobulle dit qu'une vue n'est jamais rafraîchie |
| Catalogue, schéma (Catalog Explorer, depuis la 0.22) | Le rafraîchissement de ses tables, précédé de « ≈ » dès qu'une part est répartie | Attribué | rafraîchissement(C) (section 5.9) ; l'infobulle donne la part exacte et la part répartie, les trois charges qui paient le plus, lecture(C) et le nombre de tables qui coûtent |
| Tableau de bord, requête enregistrée | Le coût de ses requêtes, précédé de « ≈ » | Attribué | Σ coût(q) de ses requêtes (ligne « coût des requêtes d'un tableau de bord » ci-dessus) |
Genie Agent, anciennement espace Genie (/genie/rooms/<id>, section 4.3) | Le coût de ses questions sur les warehouses, précédé de « ≈ » | Attribué | Σ coût(q) de ses requêtes |
| Endpoint de serving, app | Son coût ; pour un endpoint, plus celui des agents Agent Bricks qu'il sert (facturés sous usage_metadata.agent_bricks_id, l'endpoint venant comme nom, depuis la 0.21) | Mesuré | coût(W) (pour une app, la charge dont app_name est le nom de la page) ; avec la facturation de plusieurs workspaces, seulement la charge du workspace de la page, et pas de badge si elle ne peut pas être distinguée |
| Notebook | Son calcul serverless, plus le coût de ses requêtes sur les warehouses (« ≈ » dès qu'il y en a) | Mesuré, plus attribué | coût(W) du notebook + Σ coût(q) de ses requêtes |
-
Un lien vers un autre workspace (autre hôte, ou autre
?o=que la page), vers une exécution (/jobs/<id>/runs/...), un onglet, une cellule de notebook ou un autre sous-objet n'a pas de badge : ce n'est pas l'objet dont on connaît le coût. - Quand le dernier jour de la période n'est pas encore facturé (section 8, point 5), la carte de la puce le dit : un dashboard, un espace Genie ou un agent n'a de badge pour ce jour qu'une fois ses heures facturées. Le badge du warehouse, lui, montre déjà la facture arrivée.
- Les badges ne s'additionnent pas entre eux : un warehouse et les tableaux de bord qu'il sert montrent les mêmes dollars, vus de deux côtés. Les totaux exacts sont ceux des écrans FinOps.
- Le montant est arrondi pour l'affichage (deux décimales sous 10, l'unité au-dessus, notation abrégée au-delà de 100 000) ; l'infobulle rappelle la période, le prix, la remise et la source.
6.2 Arrondis au centime
Les calculs se font sur les valeurs exactes ; seul l'affichage arrondit. Quand plusieurs montants arrondis sont montrés avec leur total (les produits de la vue d'ensemble, les équipes d'un tag, les lignes des exports CSV des tables et des projections), ils sont arrondis par la méthode des plus grands restes : chaque montant reçoit son centime inférieur, puis les centimes qui manquent pour atteindre le total arrondi vont aux plus grandes fractions (la première en cas d'égalité). La somme des montants affichés égale donc le total affiché, au centime, avoirs compris.
Cellules des exports (0.23). Tous les fichiers CSV de l'extension suivent une seule règle (lib/csv.mjs) : une cellule de texte qui commence par =, +, -, @, une tabulation ou un retour chariot, même après des blancs, reçoit une apostrophe devant et reste du texte ; un montant reste un nombre, négatif compris (un avoir, une baisse) ; un montant absent ou non fini est une cellule vide, jamais NaN ni 0.
6.3 Constats à traiter (0.23)
La vue « Constats » (rubrique « À traiter » du studio) liste un constat par actif et par situation. Les constats sont recalculés à chaque lecture, à partir de ce qui a été lu : aucune requête nouvelle. Chacun dit l'actif, l'effet possible, la preuve (la table système ou la règle, et les valeurs mesurées) et une prochaine action. Un montant porte toujours sa nature : observé (usage mesuré dans system.billing.usage, au prix catalogue), estimé (le même, moins la remise du workspace) ou potentiel (une économie à confirmer). Sans facturation lisible, les constats de coût sont « non évalués » et l'écran le dit : aucun montant n'est affiché, jamais 0.
| Constat | Règle | Montant | Gravité |
|---|---|---|---|
| Contrôles du bilan de santé | Chaque contrôle du bilan, actif par actif (au plus 1 000 constats par contrôle, les tables les plus lues d'abord ; le bilan et le catalogue les gardent tous) | aucun | celle du contrôle ; « pour info » devient « utile » |
| Règles de l'équipe | Chaque règle importée, table par table, avec la valeur qui l'enfreint (dernière écriture, élément manquant, nom, lecteurs, lien) | aucun | celle de la règle |
| Exécutions en échec | Un job dont au moins une exécution de la période finit en FAILED, ERROR ou TIMED_OUT (section 6, « Coût des échecs ») | le coût des échecs, observé ou estimé | prioritaire si la dernière exécution a échoué ou si la part d'échecs atteint 50 % ; à vérifier à partir de 5 % ; utile en dessous |
| Aucune lecture observée | Une table de l'inventaire sans lecture sur la fenêtre d'activité (bilan), ou une table sans lecture observée sur la période des coûts (ligne « Table sans lecture observée » ci-dessus) | potentiel : rafraîchissement(T) × (365 / 12) / N, dit « à confirmer » | à vérifier avec un montant, utile sinon |
| Dépense en forte hausse | coût(W) ≥ 1,5 × coût_précédent(W) et coût(W) − coût_précédent(W) ≥ max(1, 2 % de la dépense de la période), contre la période précédente de même longueur (section 7.1), après la même remise. Une charge sans dépense la période d'avant n'est pas une hausse | l'écart, observé ou estimé | à vérifier |
| Tag d'équipe manquant | Une charge qui a coûté sur la période sans la clé d'équipe dans ses tags principaux (section 8, limite 4). La clé d'équipe est, parmi team, equipe, équipe, owner_team et squad, celle qui couvre le plus de dépense | sa dépense, observée ou estimée | utile |
Ce que dit le tag d'équipe manquant : la dépense par équipe de YALineo (section 10.1) range chaque charge sous la valeur de cette clé ; une charge sans elle compte dans la ligne « Sans tag ». Aucune autre règle ne l'attribue à une équipe. Sans aucune charge portant une clé d'équipe, ce constat n'est pas évalué, et l'écran le dit. De même, les échecs ne sont évalués que si l'issue des exécutions a été lue, les hausses que si la période précédente l'a été, les économies que si l'attribution aux tables l'a été.
Le suivi personnel. Chaque constat peut être « À examiner » (par défaut), « Vérifié par moi » ou « Ignoré », avec une note. Le suivi garde le jour et la signature de l'observation : les valeurs mesurées (date de la dernière écriture, échecs et exécutions, montant au prix catalogue, sources sensibles en amont, règle et valeur qui l'enfreint, tags lus). Une nouvelle remise ne change donc pas une observation. Si la signature change à une lecture suivante, le constat revient « À examiner » et dit « A changé depuis votre vérification du … ». Un constat qui n'est plus observé quitte la liste, quel que soit son suivi. Le suivi reste sur l'appareil, workspace par workspace, avec la règle de conservation des plans (effacé à la fermeture du navigateur, ou gardé si l'utilisateur choisit « Garder ») : 2 000 constats au plus, notes de 300 caractères.
6.4 La fiche d'un actif (0.23)
La fiche d'une table, d'une vue, d'une charge de travail (job, pipeline, SQL warehouse, notebook serverless...) ou d'un consommateur (tableau de bord, requête) ne crée aucun chiffre : elle reprend ceux des sections 4 à 6, pour un seul actif.
- Tout l'actif : les filtres de dépense et de tables (section 7) ne s'y appliquent pas ; la remise du workspace, si.
-
Une table : son rafraîchissement
rafraîchissement(T)et ses lectureslecture(T)sur la période (sections 5 et 5.8), puis chaque part qui les compose : la charge qui paie, sa règle (précision de la section 5.7), la part de sa charge (part.share) et le montant. Les parts sont arrondies par les plus grands restes (section 6.2) ; le rafraîchissement affiché est la somme des parts affichées, le total la somme des deux lignes affichées. Par lecture, par million de lignes, au rythme d'un mois et chaîne amont sont les indicateurs dérivés de la section 6. -
Une charge :
coût(W), ses DBU, ses exécutions et le coût de ses échecs (section 4), puis l'identité de la section 5.6 (tables, lectures, tables hors du plan, capacité sans requête, non attribué), arrondie de même : les lignes affichées tombent juste sur son coût affiché. La période précédente est la même charge lue sur la période d'avant (section 7.1), après la même remise. - Un consommateur : le coût de ses requêtes sur les SQL warehouses (section 6, déjà dans le coût des warehouses, jamais ajouté) et le coût des données dont il dépend (chaîne amont, section 6).
Nature affichée. Chaque montant porte l'une des trois natures, déduite de sa règle :
| Nature | Règles | Pourquoi |
|---|---|---|
| Observé | coût d'une charge ; part « facturé » (section 5.1) ; coût des échecs | lu tel quel dans system.billing.usage |
| Attribué | « seule table », « temps de calcul », « warehouse » ; coût des requêtes d'un consommateur | un coût mesuré donné par un lien mesuré (l'exécution qui a écrit la table, le temps de calcul, l'heure du warehouse) |
| Estimé | « parts égales », « période » ; lectures sur les SQL warehouses | la règle la moins sûre (section 5.7), ou une lecture toujours estimée (section 5.9) |
Une table qui reçoit plusieurs parts prend la nature la moins sûre de ses parts, comme sa précision.
Facturation non lue. Si la facturation n'a pas été lue (fichier, exemple sans coûts, volet FinOps désactivé, droits refusés, lecture en échec, aucune ligne pour ce workspace), la fiche dit « Coût indisponible » et pourquoi : jamais 0, jamais une ancienne valeur. L'export CSV laisse alors la cellule du montant vide et donne la raison.
Lectures sur 30 et 90 jours. Le plan connaît les lectures de sa fenêtre d'activité (directes et à travers les vues, section 5.8) et, depuis la 0.20, celles de la période FinOps. Pour 30 et 90 jours quand ni l'une ni l'autre n'a cette durée, un clic lit à la demande les événements de la table (yalineo:trend-table, 179 jours) : ce sont les lectures directes des 30 et 90 dernières dates UTC, aujourd'hui compris, sans celles faites à travers une vue.
6.5 La synthèse des coûts (0.24)
La page « Synthèse » de la rubrique Coûts ne crée aucun chiffre : elle reprend ceux des sections 3 à 7, sur la période et avec les filtres choisis, et dit pour chacun sa nature. Une seule barre règle la période (7 jours, 30 jours, 90 jours, 12 mois, ou deux dates dans le calendrier, section 7), les filtres FinOps et l'export.
Quatre natures. Elles précisent les trois de la section 1 pour l'écran :
| Badge | Définition | Nature de la section 1 |
|---|---|---|
| Observé | lu dans system.billing.usage (ou system.lakeflow pour l'issue des exécutions), au prix catalogue | mesuré |
| Attribué | un coût observé réparti entre des tables ou des schémas selon les règles de la section 5 | attribué |
| Estimé | un chiffre observé auquel s'ajoute une hypothèse : la remise saisie du workspace, ou une projection (section 7.2) | dérivé |
| Potentiel | une économie possible, à confirmer avant d'agir (tables sans lecture observée) | dérivé |
Avec une remise saisie, la dépense et le coût des échecs passent d'« Observé » à « Estimé ».
Les six cartes.
| Carte | Chiffre | Nature | Courbe | Écart |
|---|---|---|---|---|
| Dépense | Σ coût(W) | Observé (Estimé avec une remise) | dépense par jour (spend), la période d'avant en pointillé | section 7.1 |
| DBU consommés | Σ DBU(W) | Observé | DBU par jour, quand spend les donne | section 7.1 |
| Part du rafraîchissement des tables | Σ rafraîchissement(T) / dépense | Attribué | aucune | section 7.1, toujours en gris |
| Tables sans lecture observée | Σ rafraîchissement(T) de ces tables, mensualisé (section 6) | Potentiel | aucune | section 7.1 |
| Exécutions en échec | coût des échecs (section 6) | Observé (Estimé avec une remise) | aucune | section 7.1 |
| Projection, 30 prochains jours | projection à 30 jours, entre ses deux rythmes (section 7.2) | Estimé | dépense par jour mesurée | contre la somme des 30 dernières dates mesurées de la période, sans couleur : une projection n'est pas une mesure |
Une carte sans courbe dit pourquoi : la facturation lue ne donne ni la part du rafraîchissement, ni les tables non lues, ni les échecs jour par jour (ils sont calculés sur la période entière). Sous un filtre de tag ou « exécuté par », la dépense par jour ne tombe pas juste (section 7, « Dépense par jour ») : aucune courbe, et la carte le dit. Chaque carte ouvre son détail (analyse des coûts réglée sur sa mesure, tables, jobs ou projections).
L'essentiel. Des phrases écrites à partir des chiffres de la page, sans autre source :
- la dépense et son écart avec la période d'avant (section 7.1) ; puis le groupe de produits et la charge dont l'écart va le plus loin dans le sens du total (montants de « Où va la dépense » et des variations, ci-dessous) ;
-
la moyenne par jour des 7 dernières dates complètes contre celle des autres dates de la période :
(moyenne7 − moyenne_reste) / moyenne_reste, à partir de 14 dates ; un dernier jour non soldé est laissé de côté (section 7.1) ; puis la plus forte baisse d'une charge, si elle dépasse 1 ; - les tables sans lecture observée (potentiel mensualisé), le coût des échecs avec la charge qui en compte le plus, et les deux bornes de la projection à 30 jours.
À regarder d'abord. Les constats de la section 6.3, calculés sur les coûts affichés, filtres compris : l'échec au plus fort montant, la hausse au plus fort écart, les tables sans lecture observée et les charges sans tag d'équipe. Mêmes règles, mêmes seuils et mêmes natures que la page « Constats ».
La dépense jour par jour. La requête spend (section 7), par produit. Les produits sont rangés par dépense de la période chargée ; six au plus sont nommés, sinon cinq et « Autres produits ». Grain : le jour jusqu'à 31 dates, la semaine jusqu'à 120, le mois au-delà ; le jour reste proposé jusqu'à 120 dates. Les semaines sont des blocs de 7 dates qui finissent au dernier jour de la période ; la première peut être plus courte et elle est dite partielle. Les mois sont ceux du calendrier ; un mois incomplet est dit partiel.
La période d'avant est lue jour par jour par la même requête (spend, depuis la 0.24, section 7) et alignée par position : la i-ème date de la période face à la i-ème date de la période d'avant, les deux comptant autant de dates. Son total par colonne forme la ligne en pointillé, dessinée seulement si ses jours somment à son total au centime. Un clic sur une colonne ouvre son détail : par produit et par type de charge, contre les mêmes positions de la période d'avant, arrondi par les plus grands restes (section 6.2). « Voir les données » montre chaque colonne, par produit, avec ses totaux au centime. Aucun repère (mise en production, incident) n'est dessiné : les tables système lues n'en contiennent pas.
Pourquoi la dépense a bougé. Une cascade de la dépense d'avant à celle de la période, un pas par groupe de produits (les groupes ci-dessus). Les dépenses des groupes sont arrondies au centime par les plus grands restes, période par période, chacune sur son total ; le pas d'un groupe est centimes(groupe, période) − centimes(groupe, avant). Donc total d'avant + Σ pas = total de la période, exactement, au centime. Une charge compte sous son produit principal de chaque période. Le survol d'un pas nomme les charges qui l'expliquent ; le clic les liste toutes, avec les montants des deux périodes arrondis de même sur le pas.
Où va la dépense. Trois répartitions, chacune arrondie par les plus grands restes :
-
Produit :
Σ coût(W)par groupe de produits, sa part de la dépense et son écart (section 7.1). Les lignes somment à la dépense. Un clic filtre la page sur ce produit ; -
Équipe :
Σ coût(W)par valeur d'une clé de tag, celle que l'utilisateur choisit, sinon la clé d'équipe de la section 6.3, sinon la clé qui couvre le plus de dépense. Les charges sans cette clé forment la ligne « Sans tag <clé> », si bien que les lignes somment à la dépense ; une valeur qui n'a rien coûté sur aucune des deux périodes n'a pas de ligne. Les tags d'une charge sont ceux de sa plus grande ligne d'usage (section 8, limite 4) ; -
Schéma :
rafraîchissement + lecturedes tables de chaque schéma (sections 5 et 5.9), les huit premiers, les autres réunis. C'est un coût attribué : il ne couvre qu'une partie de la dépense (le reste n'est pas attribué aux tables, section 5.5), et l'écran le dit.
Les plus fortes variations. Chaque charge face à elle-même sur la période d'avant (même workspace, même identifiant ; absente d'une période, elle y vaut 0) : coût(W) − coût_avant(W), les six plus fortes hausses et les six plus fortes baisses d'au moins un centime. Une charge qui ne fait que lancer d'autres jobs (section 4.1) n'y figure pas.
La courbe de chaque charge nommée dans la page vient d'une requête lancée à la demande, yalineo:work-days : la dépense par jour de ces seules charges, sur les deux périodes, avec les expressions de la requête costs (section 4). Les charges sont passées dans un paramètre nommé (:keys, 40 au plus, sous la forme TYPE:identifiant), la fin par un paramètre de type date jamais postérieur à aujourd'hui, la durée par un entier de 365 jours au plus. Elle part une fois par période et par liste de charges, après l'affichage, jamais pendant le chargement du plan. Sur les mêmes dates, la somme des jours d'une charge égale son coût de la requête costs (test Spark). Sans workspace interrogeable (l'exemple, un fichier), il n'y a pas de courbe, et la ligne le dit.
Export. Le CSV de la page donne chaque carte, chaque jour par produit, le total de la période d'avant par jour, chaque pas de la cascade, chaque répartition et chaque variation, avec la période, la période d'avant, l'unité, la nature et la devise. Les montants sont ceux de l'écran, au centime ; chaque répartition (produits, équipes, jours) somme à la dépense. Les cellules sont neutralisées contre les formules, comme les autres exports.
6.6 Les vues par type de charge (0.24)
Le volet Coûts range ses listes « par type de charge » : Jobs et calcul, Tables, SQL warehouses, IA et Genie, Catalogues et schémas, Équipes et tags. Ces vues ne créent aucun coût : chaque montant est l'un de ceux des sections 4 à 6, sur la période et avec les filtres du volet, après la remise saisie. La période d'avant est lue par les mêmes requêtes et la même attribution (section 7.1).
Les chiffres clés et leur nature. Chaque vue commence par une rangée de chiffres. Un montant porte sa nature : Observé, Attribué, Estimé (section 6.4) ou Potentiel (une économie à confirmer, section 6.3). Un nombre ou un rapport n'a pas d'étiquette : il est mesuré ou dérivé (section 1).
| Vue | Chiffre | Formule | Nature |
|---|---|---|---|
| Jobs et calcul | Coût | Σ coût(W) des charges du filtre de la liste | Observé |
| Exécutions | Σ exécutions(W) (section 4) | mesuré | |
| Coût moyen par exécution | Σ coût(W) des charges qui ont des exécutions / Σ leurs exécutions | dérivé | |
| Échecs | exécutions de jobs en échec, et leur part des exécutions des jobs dont l'issue est lue | mesuré | |
| Coût des échecs | section 6 | Observé | |
| Tables | Coût des tables | Σ [rafraîchissement(T) + lecture(T)] des tables listées | Attribué |
| Lectures | Σ lectures(T) des tables listées (section 6) | mesuré | |
| Rafraîchissement par lecture | Σ rafraîchissement(T) des tables lues / Σ leurs lectures | dérivé | |
| Sans lecture observée | nombre de tables (section 6), et Σ rafraîchissement(T) × (365 / 12) / N | Potentiel | |
| SQL warehouses | Coût | Σ coût(W) des warehouses | Observé |
| Requêtes | instructions de system.query.history sur ces warehouses pendant la période (lignes total de la requête work) | mesuré | |
| Coût moyen par requête | Σ coût(W) des warehouses qui ont au moins une requête / Σ leurs requêtes | dérivé | |
| Capacité sans requête | Σ capacité_sans_requête(W) (section 5.4), et sa part du coût des warehouses | Attribué | |
| Lectures de tables | Σ vers_lectures(W) ; dessous, les écritures Σ vers_tables(W) (attribué) | Estimé | |
| IA et Genie | Coût de l'IA | Σ coût(W) des charges Agent, Genie, Endpoint de serving, AI Search et App | Observé |
| Charges d'IA | nombre de ces charges avec un coût | mesuré | |
| Questions Genie sur les warehouses | Σ coût(q) des requêtes des espaces Genie (section 6), déjà dans le coût des warehouses | Attribué | |
| Appels et messages | absents de la facturation, qui compte des DBU : « Non facturés », jamais 0 | ||
| Équipes et tags | Dépense, Sans tag | section 10.1 | Observé |
| Couverture du tag, Équipes | part de la dépense portée par les charges qui ont la clé ; nombre de valeurs | dérivé | |
| Catalogues et schémas | Rafraîchissement ; lectures sur les warehouses | section 5.9 | Attribué ; Estimé |
| Projections | Coût, DBU et coût par jour projetés ; mesuré sur la période | section 7.2 | Estimé ; Observé |
Écart. Chaque carte, chaque charge, chaque table, chaque catalogue et schéma, chaque valeur de tag est comparé à la même chose sur la période d'avant : x − y et (x − y) / y, avec la règle variation de la section 7.1 (bandes, flèche, signe et montant). Une charge, une table ou une valeur absente de la période d'avant y vaut 0 : elle est « nouvelle ». Les échecs ne sont comparés que si l'issue des exécutions a été lue pour les deux périodes ; les tables et les catalogues, que si l'attribution aux tables a été lue de la même façon. Dans la liste des jobs, un filtre qui dépend de la période elle-même (en hausse, avec échecs, non attribué) ou des tables choisies ne se reporte pas sur la période d'avant : ses cartes ne sont pas comparées, et l'écran le dit.
Courbes.
-
Carte « Coût » (Jobs et calcul, SQL warehouses, IA et Genie) : la dépense par jour de la requête
spendpour ces types de charge, chaque date de la période (0 un jour sans ligne d'usage). Pas de courbe sous un filtre de tag ou d'exécutant (la dépense par jour ne les suit pas, section 7), ni quand la somme des jours ne tombe pas au centime sur le coût de la carte (une charge facturée sous deux produits ou deux calculs, sous un filtre de produit ou de calcul) : l'écran dit pourquoi. -
Chaque ligne (charge, warehouse, charge d'IA, valeur de tag) : la requête facultative
yalineo:series, lue avec les coûts. Pour chaque charge (mêmeCASEqu'à la section 4, mêmes prix qu'à la section 3) :Σ coût(u)de ses lignes d'usage par date, jour par jour pour une période de 31 dates ou moins, semaine par semaine au-delà (semaines finissant le dernier jour de la période, la première coupée par son début). Les points d'une charge somment àcoût(W)au centime, vérifié sur Spark. Seules les 2 000 charges au plus grand coût absolu de la période sont lues (au plus 2 000 × 53 lignes) : au-delà, la ligne dit « non lue », jamais une courbe à 0. Un job qui ne fait que lancer d'autres jobs n'a aucune ligne d'usage : ses points valent 0. Une valeur de tag a la somme des points de ses charges, seulement si toutes ont été lues. Sans cette requête (plan chargé avant la 0.24, requête en échec), la colonne n'est pas montrée et l'écran le dit. - Les 5 premières charges (Jobs et calcul, SQL warehouses, IA et Genie) : les points des cinq charges listées les plus coûteuses, empilés, puis « Autres » : la somme des points des autres charges listées, seulement si toutes ont été lues. Chaque barre somme donc à la dépense des charges listées pour sa date ou sa semaine. Une première semaine plus courte que 7 dates est dessinée plus pâle et le dit. Un point négatif (correction de facturation) retire le graphique plutôt que de le fausser.
- Une table n'a pas de courbe : son coût est attribué sur la période, exécution par exécution (section 5.2), jamais jour par jour. L'écran le dit.
-
Projections : la dépense mesurée de chaque date de la période (même règle que la carte « Coût »), puis chaque jour de la fenêtre au même montant,
coût projeté / H, entrebas / Hethaut / H(section 7.2). Dérivé.
SQL warehouses. Par warehouse : coût(W) = capacité_sans_requête(W) + écritures(W) + lectures(W) + reste(W), où reste regroupe le non attribué et les tables hors du plan (identité de la section 5.6), au centime dans l'export. Requêtes : le nombre d'instructions de l'historique des requêtes exécutées sur le warehouse pendant la période. Taille et arrêt automatique : cluster_size et auto_stop_mins de la liste des warehouses du workspace (GET /api/2.0/sql/warehouses, déjà lue pour leurs noms), gardés avec le plan. Un warehouse absent de cette liste (supprimé, non visible avec les droits de l'utilisateur, plan chargé avant la 0.24) affiche « inconnu ». Sans historique des requêtes, les requêtes et la capacité sans requête sont « non lues », jamais 0. L'état des requêtes (échecs) n'est pas lu. La liste « Lectures des tables sur les warehouses » reprend lecture(T) de la section 5.4, estimé.
IA et Genie. Le coût de chaque type (Agent, Genie, Endpoint de serving, AI Search, App), arrondi par les plus grands restes (section 6.2) : les types somment au coût de l'IA au centime. Les questions des espaces Genie sont listées à part : attribuées, déjà dans le coût des warehouses, jamais ajoutées au coût de l'IA. Le nombre d'appels ou de messages n'est pas dans system.billing.usage : il est dit « Non facturés ».
IA et Genie, par produit (0.28). Chaque ligne d'IA porte son produit (Genie Code, Genie One, Genie Agents, Knowledge Assistant, Model Serving...), lu dans des champs documentés de la facturation (section 4.3) ; « Par produit » remplace « Par type » et somme au coût de l'IA au centime. Les espaces Genie s'appellent aujourd'hui Genie Agents : leurs questions restent listées à part, à côté de la ligne Genie Agents (leur modèle de langage, tous ensemble), sans jamais s'y ajouter.
Équipes et tags. La dépense par équipe de la section 10.1, sur la période et avec les filtres du volet : chaque charge sous la valeur de la clé choisie dans ses tags (ceux de sa plus grande ligne d'usage, section 8, limite 4), les charges sans cette clé dans « Sans tag ». Clé par défaut : la clé d'équipe des constats (team, equipe, équipe, owner_team ou squad, celle qui couvre le plus de dépense), sinon la clé qui couvre le plus de dépense ; le lecteur en choisit une autre parmi celles de la facturation. Les lignes, arrondies par les plus grands restes et affichées au centime, somment au total de la période. Charge principale : la charge de la valeur au plus grand coût. Un clic sur une valeur applique le filtre de tag clé = valeur à tout le volet (section 7) ; « Sans tag » ne se filtre pas (il n'existe pas de filtre « sans »), ni une clé qui contient « = ». Une clé ou une valeur de tag n'est jamais une clé d'objet : __proto__ est une clé comme une autre (test d'attaque).
Exports. Jobs et calcul, SQL warehouses, IA et Genie, Équipes et tags : chaque colonne de montants arrondie par les plus grands restes, la ligne « total » égale à leur somme au centime ; chaque charge porte son nom entier tel que facturé (le chemin d'un notebook, que la liste raccourcit), ou à défaut son type et son identifiant ; les cellules passent par lib/csv.mjs (un nom qui ressemble à une formule reste du texte, un montant inconnu est une cellule vide). Les questions Genie suivent la ligne « total » des charges d'IA, sur des lignes à part.
Plan des coûts. La liste « Schémas par coût » somme, pour chaque schéma, Σ [rafraîchissement(T) + lecture(T)] de ses tables (la règle des stations, section 7), arrondie par les plus grands restes ; un schéma ouvre le coût de ses tables.
6.7 Pourquoi un coût est absent ou nul (0.26)
Partout où YALineo montre un coût (fiche d'un actif, bloc « Coûts » du catalogue et des dépendances, listes du volet Coûts), un chiffre nul, absent ou qui n'est qu'une part d'une dépense plus large porte un lien « Pourquoi ? ». Il ouvre une courte liste de raisons. Aucune raison ne crée de chiffre : chacune reprend une règle des sections 3 à 8, avec les valeurs lues (une date du lineage, un coût, un nombre d'exécutions ou de lectures), et l'action qui changerait le chiffre. La fonction costReasons (extension/lib/cost26.mjs) les calcule ; l'écran ne fait que les afficher.
| Code | Ce que YALineo dit | Règle | Action proposée |
|---|---|---|---|
billingDenied, billingFailed, billingEmpty, billingNotLoaded, billingOff, billingFile, billingNoMap | La facturation n'est pas lue : refusée (le droit que nomme le message de Databricks, sinon SELECT sur system.billing.usage et system.billing.list_prices, lues ensemble), en échec, vide pour ce workspace, pas chargée, désactivée, ou absente d'un fichier ou d'un plan pas encore chargé. Aucun montant, jamais 0 | 2, 6.4 | Copier le SQL pour un admin (docs/Admin_Grant.sql), recharger, réglages |
view | Une vue ou une vue de métriques n'est jamais rafraîchie ; son coût est lecture(V), et ses lectures comptent pour ses sources | 5.8 | |
filtered | Les filtres de dépense excluent la charge qui paie ; le montant sans eux est donné | 7 | Retirer les filtres de dépense |
createdAfter | Table créée (information_schema) après le dernier jour de la période | 7 | Inclure aujourd'hui |
noWrite, writesUnknown | Aucune écriture dans le lineage sur sa fenêtre : rien à payer, ou une écriture hors du lineage ; ou l'activité des tables n'a pas été lue avec ce plan | 8, point 2 | Ouvrir dans Databricks, recharger |
writtenBefore | Dernière écriture observée avant le premier jour de la période | 5.2 | Élargir la période (la plus courte durée de la liste qui couvre cette date, un an au plus) |
writerNotBilled | Écrite par un job, un pipeline, un notebook ou une requête sans ligne de facturation à son nom sur la période : job sur cluster interactif (facturé au cluster), notebook sur cluster classique, pas d'exécution, job qui ne fait que lancer d'autres jobs, charge d'un autre workspace (seule la facturation de ce workspace est lue) | 2, 4, 4.1, 5.4, 5.5 | Ouvrir sa fiche, ouvrir dans Databricks, élargir la période |
writerNotTied | Écrite par une charge facturée dont aucune exécution facturée n'est reliée, dans le lineage, à une écriture de cette table ; les exécutions sans écriture observée et leur coût | 5.2 | Ouvrir sa fiche, élargir la période |
writerUnknown | Écrite par des requêtes que le lineage ne relie à aucun job, pipeline ou notebook : un coût seulement sur un SQL warehouse, par l'historique des requêtes | 5.4 | Ouvrir dans Databricks |
sharedWriter | Payée par une charge qui en paie d'autres : son coût, la part de la table (celle de la fiche) et sa règle, les autres tables, le reste ; les trois tombent juste au centime sur le coût de la charge | 5.2, 5.4, 5.7, 6.2 | Ouvrir la fiche de la charge |
belowCent | Un rafraîchissement de moins d'un centime | 6.2 | |
attribPeriod | Plan lu sans la requête attrib : partage sur la période | 5.7 | Recharger les coûts |
perReadTiny | Coût par lecture de moins d'un centime : affiché « moins de 0,01 $ », avec sa valeur | 6 | |
noRead, readsUnknown | Aucune lecture observée sur la période, ni directe ni à travers une vue ; ou les lectures n'ont pas été lues avec ce plan | 6, 8 point 6 | Recharger |
readsNotOnWarehouse | Des lectures, aucune par une requête d'un SQL warehouse : celles des jobs et pipelines sont dans leur propre coût, celles à travers une vue restent à la vue, celles des tableaux de bord, requêtes et espaces Genie comptent seulement sur un warehouse | 5.4, 5.8 | |
noQueryHistory | Historique des requêtes non lu : ni lectures sur les warehouses ni lignes écrites (le droit manquant quand il est refusé) | 5.4 | Copier le SQL pour un admin, recharger |
noRowsMeasured, noRowsWritten | Pas de coût par million de lignes : aucune ligne mesurée (écritures sur calcul classique, absentes de l'historique des requêtes), ou 0 ligne | 5.2, 6 | |
notBilled | Une charge du lineage sans ligne de facturation à son nom sur la période ; sa dernière activité vue | 4 | Ouvrir dans Databricks, élargir la période |
launcherOnly | Un job qui ne fait que lancer d'autres jobs : 0 en propre, le coût des jobs lancés à côté | 4.1 | Ouvrir le job lancé |
unpriced | Usage sans prix catalogue : coût partiel | 3 | |
noTablePaid, partlyUnattributed, clusterNoTable, serviceNoTable | Une dépense reliée à aucune table : exécutions sans écriture observée, vues, tables hors du plan, cluster interactif ; agents, Genie, endpoints et apps, qui n'écrivent aucune table et comptent dans « IA et applications » | 5.5, 5.6, 6 | |
levelTables | Un catalogue ou un schéma à 0 : ses tables comptées par leur première raison | 5.9 | Voir ses tables, élargir la période |
listPrice, openDay | À savoir : prix catalogue sans remise saisie ; dernier jour pas encore entièrement facturé | 3, 7.1 | Saisir une remise |
Les noms lus dans le workspace (jobs, tables, warehouses) restent du texte dans la liste, et l'export CSV de la fiche ajoute une ligne why par raison, neutralisée comme les autres cellules (test d'attaque dans tests/security.test.mjs).
6.8 Ce que YALineo compte, ce que Databricks montre (0.28)
Un chiffre de YALineo qu'on peut comparer à un écran de Databricks dit la même chose que lui, ou dit exactement pourquoi il diffère. Chaque comportement de Databricks cité ici vient d'une page officielle, lue le 2026-10-28 ; ce que ces pages ne disent pas est écrit « non documenté ».
Lectures : directes seulement. La page « Lineage system tables reference » (https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/lineage), colonne direct_access : « When false, the source is an intermediate dependency discovered through view expansion. For example, if a query reads from a view, the lineage record for the view's underlying base table is recorded with direct_access = false. » Une requête sur une vue laisse donc une ligne pour la vue et une ligne pour chaque table sous elle. Avant la 0.28, les requêtes de lecture comptaient les deux : une table lue à travers une vue comptait sa lecture une fois dans sa propre activité, puis une seconde fois par lectures_par_vues (section 5.8), et son coût par lecture était donc trop bas. Depuis la 0.28 :
-
lectures_directes(T)ne compte que les lignes oùdirect_accessn'est pasfalse(coalesce(direct_access, true)) : requêtesactivity,attrib(lectures de la période),trend-table(lectures jour par jour).lectures_par_vues(T)les ajoute ensuite une fois, par le parcours des vues. Une vue lue une fois donne 1 lecture à sa table de base, jamais 2 (test Spark). -
Les lecteurs d'une table (« Lue par », requête
entities) sont ses lecteurs directs : un tableau de bord qui lit une vue gold bâtie sur une table silver lit la vue, pas la table silver. Il n'y a plus de « rapport branché sur bronze ou silver » à tort, et l'analyse d'impact ne le met plus au premier niveau de la table silver. -
Une requête de warehouse qui lit une vue paie la lecture de la vue (
work), en entier : « le coût de ces lectures reste à la vue » (section 5.8) n'était pas tenu quand les tables sous la vue prenaient chacune une part. -
Un metastore qui n'a pas encore la colonne
direct_accessreçoit les formes d'avant (variantes de repli) : ses lectures restent comptées comme avant, avec la limite 15 de la section 8.
La fenêtre d'activité compte les N dernières dates UTC, aujourd'hui compris (en cours) : « 30 j » couvre 30 dates, comme les lectures à la demande de la fiche (trend-table). Avant la 0.28, elle en couvrait 31. La période FinOps, elle, se termine la veille par défaut (section 7). Depuis la 0.29, les requêtes du lineage (liens, lecteurs et écrivains, activité, estimation du volume, colonnes, noms des jobs) comptent ces dates à partir de :today, la date UTC du navigateur que reçoivent aussi les requêtes de coûts du même chargement (section 7, « Aujourd'hui »), envoyée comme paramètre nommé de type date. La tendance d'une table et « Pourquoi aucun lien ? » (section 6.10), lues plus tard à la demande, partent de la date UTC du jour où on les demande. Avant la 0.29, ces requêtes partaient de current_date() du SQL warehouse, qui suit son paramètre TIMEZONE (« The system default is UTC », Microsoft Learn, TIMEZONE, lu le 2026-10-29) : un fuseau réglé autrement par un administrateur décalait leurs fenêtres d'un jour par rapport aux coûts. Deux requêtes gardent current_date() sans rien compter d'affiché : la sonde des droits (probe, un jour de lineage) et la recherche du workspace d'un SQL warehouse dans la facturation des 35 derniers jours.
D'où viennent les lectures et les écritures. La requête activity lit, dans le même passage, les lignes sans entité (entity_id NULL) et les lectures qui écrivent une autre table ou un chemin (target_type renseigné : « Read and write », section « Reading lineage system tables » de la même page). La documentation dit des lignes sans entité : « If all the values in entity_metadata are null, it means no Azure Databricks entity was involved in the event. For example, it could be the result of a JDBC query or from a user clicking into the Sample Data tab ». La fiche ne dit donc plus « aucun lecteur observé » à côté de 44 lectures : elle dit combien de lectures viennent d'un objet nommé (job, notebook, tableau de bord, requête), combien écrivent une autre table (elles sont dans l'aval), et combien n'ont aucun objet Databricks associé. Même chose pour les écritures (« aucun job, pipeline ou notebook identifié ; 22 écritures sans objet Databricks associé »). Depuis la 0.29, une écriture compte une fois par événement d'écriture. Une instruction qui lit plusieurs sources pour écrire une table laisse une ligne par source (l'exemple de la même page : une requête qui joint deux tables laisse deux lignes vers sa cible), et une source qui est une vue ajoute une ligne par table sous elle (direct_access = false) ; ces lignes partagent leur event_id : « Multiple rows may share the same event_id if they were generated by the same event » (même page, lue le 2026-10-29). Les requêtes activity (écritures, écritures sans objet), entities (écritures de chaque écrivain) et trend-table (écritures jour par jour) comptent donc les event_id distincts, et le record_id propre à la ligne quand event_id est vide (une ligne, un événement). Un job qui lit deux tables et une vue pour écrire une table laisse quatre lignes et compte 1 écriture, jamais 4 (test Spark). Avant la 0.29, chaque ligne comptait. Sur un metastore sans la colonne direct_access, les formes d'avant comptent encore une écriture par ligne (section 8, limite 19). Les jours écrits, la dernière écriture, la fraîcheur et le rythme (section 6.9) ne comptent que des dates et n'en dépendent pas.
La « Popularity » de Catalog Explorer compte autre chose. Page « View table insights and popularity » (https://learn.microsoft.com/en-us/azure/databricks/discover/table-insights) : « The popularity metric is determined by the total number of interactive reads of a table, including reads from JDBC, the SQL Statement Execution API, SQL connectors, and sample data clicks in Catalog Explorer. Hover over a table's popularity icon to see how many times it was queried in the last 30 days. » Le lineage, lui, « represent[s] a subset of all read/write events, as it is not always possible to capture lineage. Records are only emitted when lineage can be inferred » (page des tables de lineage). Les deux nombres ne mesurent donc pas la même chose et peuvent différer beaucoup (1 394 requêtes contre 0 ou 44 lectures). La façon exacte dont la popularité est calculée, et si elle compte une vue ou ses tables, n'est pas documentée ; aucune table système ne la donne (non documenté). system.query.history n'a pas de colonne des tables lues (page « Query history system table reference », https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/query-history) : elle ne peut pas donner un compte par table. Le lien statement_id entre les deux tables ne vaut que pour les requêtes sur SQL warehouse ou calcul serverless, et reste limité aux lignes de lineage émises. YALineo garde donc le compte du lineage, avec sa portée dite : l'infobulle de la colonne « Lectures » du catalogue, la fiche et la carte de la puce le rappellent.
Une vue n'est jamais écrite. Les lignes du lineage dont une vue est la cible ne sont pas une écriture de données : une vue ne stocke rien (section 5.8). Quand Databricks les émet (création ou remplacement de la vue, ou chaque requête qui la développe) n'est pas documenté. Pour une vue ou une vue de métriques, YALineo ne montre ni « Dernière écriture », ni « Rythme d'écriture », ni fraîcheur, ni retard : la fiche dit « Sans objet : une vue ne stocke pas de données », « Définie sur » (ses sources directes, comme Catalog Explorer), et « Lignes du lineage vers la vue » avec leur nombre, leurs jours et la dernière, présentées comme des lignes du lineage. Le format de stockage n'est jamais montré pour une vue, ni quand Unity Catalog renvoie UNKNOWN_DATA_SOURCE_FORMAT. Une vue n'entre ni dans « en retard », ni dans « sans lecture observée » (déjà le cas depuis la 0.21).
Badges dans les pages Databricks : jamais une absence muette. Depuis la 0.28, chaque objet que le plan connaît reçoit un badge (section 6.1) ; seul un objet absent du plan chargé n'en a pas, et la carte de sa page dit « Absente du plan chargé ».
| Cas | Badge | Infobulle (raison) | Règle |
|---|---|---|---|
| Un coût d'un centime ou plus | Le montant, comme en 6.1 | Comme en 6.1 | 6.1 |
| Un coût de plus de 0 et de moins d'un centime | « < 0,01 $ » | « Moins d'un centime sur la période. » | 6.2 ; avant la 0.28, aucun badge |
| Vue, vue de métriques sans coût de lecture | « 0 $ · vue » | « Vue · sans coût propre · lue N fois en D jours », puis : une vue n'est jamais rafraîchie ; ses lectures par des jobs sont dans le coût de ces jobs ; sur un SQL warehouse, elles comptent quand l'historique des requêtes est lisible ; la différence avec la « Popularity » | 5.8, code view (6.7) |
| Table sans écriture observée | « 0 $ · sans écriture » | Aucune écriture observée dans le lineage | noWrite, writesUnknown |
| Table écrite avant la période | « 0 $ · écrite avant » | Dernière écriture avant la période | writtenBefore |
| Table créée après la période | « 0 $ · créée après » | Créée après la fin de la période | createdAfter |
| Table dont les écrivains ne sont pas facturés | « 0 $ · non facturé » | Un job sur un cluster all-purpose est facturé au cluster (usage_metadata.job_id « does not populate for jobs run on all-purpose compute », page « Billable usage system table reference ») | writerNotBilled |
| Table écrite par une charge facturée sans exécution reliée, ou par des requêtes sans objet | « non attribué » | La raison de son code | writerNotTied, writerUnknown |
| Table payée par des parts dont le total vaut 0 | « 0 $ » | « Facturé 0 sur la période. » | |
| Catalogue, schéma du plan sans table au coût attribué | « non attribué » | Aucune table de ce niveau n'a de coût attribué | levelTables |
| Job, pipeline du lineage sans ligne de facturation | « 0 $ · non facturé » | Aucune facturation à son nom (cluster all-purpose) | notBilled |
| Job, pipeline, SQL warehouse facturé 0 (toutes ses lignes du workspace de la page) | « 0 $ » | « Facturé 0 sur la période. » | 4 |
| Notebook, tableau de bord, requête du plan sans requête facturée | « 0 $ » ; « coût inconnu » quand l'historique des requêtes n'est pas lisible | La raison | 5.4, noQueryHistory |
Un badge sans montant a un contour en tirets, plus discret qu'un coût. Il ne contient jamais un nom lu dans le workspace : seulement des nombres et un mot choisi dans une liste fixe, dans la langue de l'ordinateur (sept langues). Un endpoint de serving, une app ou un espace Genie que la facturation ne connaît pas n'a pas de badge (le plan ne les connaît que par la facturation). Sans facturation chargée, aucun badge, comme avant : la carte de la puce et les réglages disent pourquoi.
Les noms des jobs (section 4.2). L'ordre est : le nom de system.lakeflow.jobs (la ligne la plus récente par workspace_id, job_id, comme le montre la page « Jobs system table reference », https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/jobs) ; sinon le run_name de sa dernière exécution (system.lakeflow.job_run_timeline), marqué « nom de sa dernière exécution » (ou « exécution ponctuelle » pour un SUBMIT_RUN ou un WORKFLOW_RUN) ; sinon l'identifiant, avec la raison dans l'infobulle (« Nom inconnu » : lu et absent, lecture refusée ou en échec, ou plan chargé sans les noms). La page dit qu'un job peut manquer de system.lakeflow.jobs quand il a été créé dans une autre région ou très récemment (« Recent job creation (table lag) ») ; la table est régionale ; « the latest historical entry for each job_id [...] is always available ». Elle définit run_name comme « The user-supplied run name associated with this job run » : qu'il soit le nom du job pour un JOB_RUN n'est pas documenté, d'où la mention. Depuis la 0.28, tout job enregistré qui a une exécution (run_type = JOB_RUN) sur la fenêtre des liens est lu ainsi, que le lineage ou la facturation le nomment ou non ; les exécutions ponctuelles restent bornées à celles que le lineage ou la facturation nomment (un orchestrateur peut en soumettre des milliers). Dans la vue FinOps, le nom de system.lakeflow.jobs passe avant celui que porte la facturation (usage_metadata.job_name, « User-given name of the job », renseigné pour les jobs serverless seulement) ; quand seule la facturation nomme le job, son nom le plus récent est retenu (max_by sur la fin de la ligne d'usage), jamais le plus grand dans l'ordre alphabétique.
Proposition, non appliquée. Attribuer à une vue une part du coût des jobs qui la lisent demanderait de couper le coût d'une exécution entre ce qu'elle écrit et ce qu'elle lit ; la méthode actuelle donne tout le coût d'une exécution aux tables qu'elle écrit (section 5.2), et l'identité de la section 5.6 tomberait si une part allait aussi à la vue. Ce choix revient au porteur du projet.
6.9 Rythme d'écriture et fraîcheur d'une table (0.28)
Rythme d'écriture. jours_écrits(T) (colonne write_days de la requête activity) compte les dates où le lineage a vu une écriture de T pendant la période d'activité (:days, le réglage « Période »). L'intervalle habituel est max(1, jours d'activité ÷ jours_écrits(T)) jours, dès 3 dates écrites ; T est en retard quand sa dernière écriture observée a plus de max(2 × intervalle, intervalle + 6 h), ou plus de 8 jours sans rythme connu. Le diviseur est toujours la période d'activité, celle sur laquelle write_days est compté : avant 0.28, « Tables en retard » (Analytique), l'explorateur des tables, le tag refresh proposé, la description proposée et le point « rafraîchie chaque jour » de la gravité « retard » (section 11) divisaient par la fenêtre des liens (365 jours par défaut). Une table écrite 20 jours sur 30 puis arrêtée depuis 10 jours avait un intervalle de 18,3 jours au lieu de 1,5 et manquait aux « Tables en retard » ; une table écrite chaque jour recevait refresh=monthly. La fiche et les tables suivies divisaient déjà par la période.
Fraîcheur. Elle vient de la dernière écriture que le lineage a observée pendant la période d'activité, et de rien d'autre. information_schema.tables.last_altered est « Timestamp when the relation definition was last altered in any way » (TABLES, Microsoft Learn, lu le 2026-10-28) : une date de définition, jamais une écriture. Elle ne donne ni niveau de fraîcheur ni retard, et s'affiche « définition modifiée le … » quand rien d'autre n'est connu. Une table sans écriture observée, lue ou non, est dite « aucune écriture observée en N jours », N étant la période d'activité lue (si la réponse activity n'a pas été coupée à sa limite pour une table sans ligne). Une date NULL renvoyée par le SQL warehouse reste inconnue, jamais le 1er janvier 1970. Avant 0.28, une table sans aucun événement prenait sa fraîcheur de last_altered et pouvait être « en retard », tandis qu'une table lue 120 fois sans écriture avait une fraîcheur « inconnue ». L'export du catalogue (last_write), l'explorateur (« dernière écriture ») et le tri par fraîcheur ne prennent plus last_altered pour une écriture.
6.10 Amont, aval, liens raccordés et noms lus (0.28)
Les nombres d'amont et d'aval, les liens raccordés, les chemins externes et les noms lus ne créent aucun coût : ce sont des comptes du lineage chargé (mesurés) ou des chiffres tirés de lui par une règle écrite ici (dérivés). Ils disent ce que le plan voit et pourquoi il peut différer de Catalog Explorer.
Voisins directs, puis chaîne entière. La puce dans Databricks, sa carte, la fiche d'un actif, le catalogue et les panneaux donnent d'abord les voisins directs, comme l'onglet Lineage de Catalog Explorer : les actifs reliés à lui par un lien du plan, lectures des tableaux de bord, requêtes et notebooks comprises, et, pour un job ou un pipeline, les tables qu'il écrit (directNeighbours, extension/lib/model.mjs). Deux sortes de liens n'en font pas partie : un lien que le lineage n'a vu qu'à travers une vue (toutes ses lignes portent direct_access = false ; la vue est le voisin direct, section 6.8) et un lien qui n'existe que comme raccord (plus bas). Vient ensuite la chaîne entière, nommée comme telle (« Sur toute la chaîne : x en amont, y en aval ») : tous les actifs atteints de proche en proche par tous les liens du plan, ces deux sortes comprises. Exemple (tests/v0280-coh28.test.mjs) : une vue définie sur une table de faits, elle-même alimentée par trois tables dont une reçoit 17 flux, montre « 1 en amont » et 21 sur toute la chaîne. Les consommateurs (tableaux de bord, requêtes, notebooks) se comptent de même, directs puis sur la chaîne.
La fenêtre des liens. Le plan lit les liens sur la fenêtre des liens (:link_days jours, 365 par défaut, choisie dans les réglages). L'onglet Lineage de Catalog Explorer montre par défaut une année : « The default selection is 1 year » (Microsoft Learn, Lineage in Unity Catalog, partie Retention, https://learn.microsoft.com/azure/databricks/data-governance/unity-catalog/data-lineage, lu le 2026-10-29). Quand la fenêtre du plan compte moins de 365 jours, la carte de la puce le dit (« Liens lus sur N jours ; Catalog Explorer montre par défaut la dernière année ») : un lien plus ancien peut manquer au plan et figurer dans Catalog Explorer. En mode analyste (API de lineage), cette remarque ne s'applique pas.
Liens raccordés. Quand l'inventaire (system.information_schema.tables) a été lu en entier, une table que seul le lineage connaît, dans un schéma dont l'utilisateur lit d'autres tables, est retirée du plan : supprimée depuis (souvent une table temporaire ou de checkpoint d'un job), ou illisible avec ses droits (« The rows returned are limited to the relations the user is privileged to interact with », Microsoft Learn, TABLES, https://learn.microsoft.com/azure/databricks/sql/language-manual/information-schema/tables, lu le 2026-10-29). Chaque paire formée d'un lien a qui entre dans cette table et d'un lien b qui en sort donne un lien de la source de a à la cible de b, marqué « raccordé », avec la table traversée et sa raison. Ses chiffres sont les siens, gardés à part (edge.bridged) :
événements(raccord) = min(événements(a), événements(b))
premier(raccord) = max(premier(a), premier(b)) inconnu si l'une des deux moitiés n'a pas de date de début
dernier(raccord) = min(dernier(a), dernier(b))
Un raccord est donc aussi ancien que sa moitié la plus récente et aussi récent que sa moitié la plus ancienne. Plusieurs tables traversées entre les deux mêmes actifs additionnent leurs événements et gardent le premier début et la dernière fin ; une moitié qui est elle-même un raccord compte avec ses propres chiffres de raccord. Ces chiffres ne s'ajoutent jamais aux événements, aux dates ni aux objets observés entre les deux actifs. Un lien aussi observé directement garde ses chiffres observés, et le raccord est dit à côté ; un lien qui n'existe que comme raccord n'a aucun chiffre observé (0 événement, dates vides), est dit « déduit » dans la preuve d'une relation, n'est pas un voisin direct, mais reste dans la chaîne entière. Pour les filtres de période des liens et les anciens liens, sa dernière date est la plus récente des deux : la sienne et celle de son raccord. Bornes : une table qui demanderait plus de 2 500 raccords (liens entrants × liens sortants) reste sur le plan, et les raccords faits en tout ne dépassent pas le nombre de liens du lineage, ou 5 000 s'il en a moins ; au-delà, les tables restent. La couverture du plan compte ces liens (« dont N raccordés »), et l'analyse d'impact dit combien de tables ont été retirées (section 11.1). Côté coûts, la part d'une table retirée reste comptée dans « tables hors du plan » (section 5.2).
Tables des catalogues internes de Databricks (0.34.3). Elles quittent le plan de la même façon, mais toujours (inventaire lu ou non, pré-vol compris) et en premier : leurs liens sont raccordés dans les mêmes bornes, et leurs écritures gardées pour le partage des coûts (section 5.2). Une table interne qui demanderait plus de raccords est retirée quand même : ses liens ne sont pas dessinés et leur nombre est dit sur la note du plan. Un raccord ne nomme jamais une table interne, il la compte (« 1 table interne de Databricks ») et donne sa raison (« catalogue interne de Databricks, masqué par YALineo ») ; un raccord qui traverse les deux sortes de tables donne les deux raisons. La couverture, la note du plan, les infobulles et l'analyse d'impact comptent à part les tables internes retirées et les liens raccordés à travers elles ; « tables disparues masquées » et « liens raccordés à travers une table absente de l'inventaire » gardent leur sens. Un plan enregistré avant la 0.34.3, un fichier et un chargement gardé (« ce qui a changé ») sont lus sans elles, leurs liens raccordés dans les mêmes bornes : un chargement gardé n'en montre donc pas les raccords comme des liens nouveaux. Un plan enregistré n'est nettoyé qu'une fois par chargement (même fetchedAt), pas à chaque lecture. En mode analyste, l'exploration traverse une table interne au niveau où elle l'a trouvée, sans l'explorer ni en partir, pour atteindre ce qui suit ; le plan entier ne la demande jamais.
Au pré-vol (relecture de la 0.34.3), une table interne trop reliée pour être raccordée reste sur le plan avec ses liens, comme une table disparue : y couper ses liens sous-estimerait l'impact au-delà d'elle, et au pré-vol, surestimer est le côté sûr. L'extension, elle, la retire.
Limite : un catalogue interne que ce workspace ne voit pas. Le lineage lit bien les liens qui passent par une table interne, et c'est ce qui permet de raccorder les chemins, mais seulement dans le périmètre des catalogues montrés. Avec « ce workspace seulement » (réglage « Catalogues montrés »), un lien dont l'autre bout est dans un catalogue que system.information_schema.catalogs ne liste pas pour l'utilisateur (par exemple le catalogue __databricks_internal_catalog_lakeview_<collègue> d'un collègue) n'est pas lu : le chemin qui passait par cette table n'est pas raccordé. « Tout le metastore » le lit. « Pourquoi ? » compte ces liens sous la règle des catalogues internes.
Chemins externes. Un chemin lu ou écrit hors d'une table (source_path, target_path) est ramené à son dossier, pour qu'un dossier lu fichier par fichier (Auto Loader, par exemple) fasse un seul lien : les dossiers de partition (/clé=valeur) sont retirés, et le dernier élément l'est seulement s'il suit un dossier ou une racine et finit par une extension de fichier connue (liste FILE_EXTENSIONS de extension/lib/queries.mjs : parquet, csv, json, avro...). Le préfixe du chemin (abfss://, s3://...) et la racine du stockage (conteneur@compte, le bucket) restent toujours. Depuis la 0.28, deux comptes de stockage ou deux buckets sont donc deux sources externes, et un dossier au nom pointé (exports/sales.v1) reste entier ; avant, la règle pouvait réunir deux comptes en une seule source, ou couper ce dossier. La même règle sert aux liens (edges), à l'estimation d'un chargement (estimate) et à « Pourquoi aucun lien ? » (why-links).
Pourquoi aucun lien ? (0.27). Pour une table sans amont ou sans aval, « Vérifier sur 365 jours » lance à la demande une requête en lecture seule (yalineo:why-links, une seule table, paramètres nommés) sur les 365 derniers jours de system.access.table_lineage. Chaque lien de cette table (en amont : depuis une table ou un chemin ; en aval : vers une table ou un chemin, et les lectures d'un job, d'un notebook, d'un tableau de bord ou d'une requête) est compté une fois, sous la première règle du plan qui l'écarte, dans cet ordre : depuis la 0.34.3, l'autre bout est une table d'un catalogue interne de Databricks (masquée, ses liens raccordés ; seule la date du plus récent est dite, jamais son nom), même dans un catalogue que ce workspace ne voit pas ; l'autre bout est dans un catalogue que ce workspace ne voit pas ; aucun des deux bouts n'est dans les catalogues choisis ; l'autre bout est une table que l'inventaire ne liste pas alors qu'il liste d'autres tables de son schéma (supprimée ou illisible, ses liens raccordés) ; le lien a été vu pour la dernière fois avant la fenêtre des liens ; sinon, le plan devrait le montrer (vu pour la première fois après le chargement, ou absent du plan). Chaque groupe donne son nombre de liens et la date du plus récent, et le nom du plus récent sauf s'il est dans un catalogue interne. Depuis la 0.29, les lectures d'un job, d'un notebook, d'un tableau de bord ou d'une requête n'y comptent que directes (direct_access n'est pas false), comme les lecteurs du plan (section 6.8) : une lecture à travers une vue est une lecture de la vue, jamais un lien manquant de la table sous elle ; un metastore sans la colonne reçoit la forme d'avant. Les liens absents du plan sont ceux que le plan devrait montrer, moins ceux vus pour la première fois après le chargement, moins les liens que le plan a observés : un lien raccordé n'est pas observé (aucune ligne du lineage ne relie ses deux bouts, la vérification ne peut donc pas le voir), il reste dessiné mais ne cache plus un lien manquant. Ce nombre n'est jamais négatif. Les 365 jours se terminent à la date UTC du jour de la vérification (:today, section 6.8).
Noms des tableaux de bord et des requêtes. Le lineage ne donne que leurs identifiants ; leurs noms viennent des listes de l'API du workspace (/api/2.0/lakeview/dashboards, /api/2.0/sql/queries), lues page par page jusqu'au bout, 20 000 noms au plus par liste (1 000 avant la 0.28) et 1 000 pages au plus. Une liste qui va au-delà, qui renvoie un jeton de page déjà suivi, ou une page vide en annonçant une suite, s'arrête là : les actifs du plan de ce type restés sans nom sont comptés et dits dans la couverture du plan (« N noms de tableaux de bord ou de requêtes non lus : la lecture des noms s'arrête à 20 000 par liste »), et le journal de santé le note. Un actif sans nom lu garde son identifiant. Aucun montant ne change.
6.11 Effacer des termes du glossaire (0.29)
Après un import raté ou une extraction qui ne convient pas, « Effacer des termes » (page Glossaire, au bout de la barre des termes) retire des termes du glossaire gardé sur cet appareil. Rien n'est effacé dans Unity Catalog, ni dans la table publiée : le glossaire n'y arrive que par le script que son propriétaire exécute. Trois choix (eraseTerms, extension/lib/glossary.mjs) :
| Choix | Ce qui part | Ce qui reste |
|---|---|---|
| Tout le glossaire | Tous les termes, validés compris, et la liste des termes rejetés (ils seront de nouveau proposés) | La table publiée, le secteur, le modèle et les prix de l'IA |
| Les termes venus d'un fichier importé | Les termes dont toutes les sources sont un fichier : un classeur Excel ou CSV, ou la réponse de l'IA importée | Un terme validé, un terme qu'une autre source a aussi donné, et la liste des rejetés |
| Les termes extraits d'Unity Catalog | Les termes dont toutes les sources sont l'extraction : commentaires, vues de métriques, tags, colonnes | Même règle |
Avant d'effacer, le panneau donne le nombre de termes qui partent (et, pour tout le glossaire, combien d'entre eux étaient validés), le nombre de termes de la source qui restent, et propose « Exporter d'abord en CSV ». Un terme saisi à la main ou lu dans la table publiée n'est jamais dans le choix d'une source. Après l'effacement, « Annuler » remet le glossaire tel qu'il était, s'il a bien été enregistré.
Le mot de passe de suppression. Il est demandé avant tout effacement ; un mot de passe incorrect n'efface rien. Le code ne contient que son empreinte SHA-256 ; ce qui est saisi est comparé sur place, puis le champ est vidé : ce texte n'est ni gardé, ni envoyé, ni écrit dans un message. C'est un garde-fou contre l'effacement par erreur, pas un contrôle d'accès : l'extension tourne dans le navigateur, et chacun peut aussi retirer des termes en les rejetant dans la liste.
7. Filtres
Deux familles, aux effets différents et annoncés à l'écran.
Filtres de dépense (produit, type de charge, calcul serverless ou classique, tag, exécuté par) : ils choisissent des charges de travail. Tous les chiffres, y compris le coût des tables, sont recalculés à partir de ces charges seules, avec les formules ci-dessus. Plusieurs valeurs d'un même filtre se combinent par « ou », des filtres différents par « et ». Pour les tags : plusieurs valeurs d'une même clé par « ou », des clés différentes par « et ».
Conséquence vérifiée : les valeurs d'un filtre forment une partition. Par exemple, la somme des dépenses de chaque équipe (team=…) égale la dépense totale des charges taguées, et serverless plus classique égale le total.
Filtres de tables (catalogue, schéma, domaine, type d'objet depuis la 0.21) : ils choisissent les tables à additionner et à lister. Ils ne changent jamais le coût d'une table. Le bloc « Tables sélectionnées » donne la somme exacte de leur rafraîchissement et de leur lecture, et, pour chaque charge, la part qui paie ces tables. La somme des sélections de tous les catalogues égale le total attribué aux tables présentes sur le plan (une table supprimée depuis, absente du plan, n'appartient à aucun catalogue affiché).
Période : elle relance uniquement les requêtes de coûts ; le plan du lineage ne change pas. Trois façons de la choisir (depuis la 0.13) :
-
une durée de jours complets (7, 30, 90, 180 ou 365 jours), qui se termine hier :
:days = durée,:end_days = 1. Aujourd'hui en est exclu, parce qu'il n'est pas fini et que la facturation arrive avec quelques heures de retard. C'est aussi la période d'un chargement du plan (la fenêtre d'activité des réglages) ; -
aujourd'hui seul :
:days = 0,:end_days = 0. Ses montants sont partiels et l'écran le dit (« en cours ») ; -
deux dates, « du » et « au », comprises, en dates UTC :
:days = aujourd'hui − du,:end_days = aujourd'hui − au. Un seul jour est une période, aujourd'hui compris. Les dates sont vérifiées avant tout envoi, et chaque refus a son message : une date manquante ou impossible, « du » après « au », « au » après aujourd'hui (la date UTC du jour est rappelée), « du » à plus de 365 jours en arrière. Rien n'est rechargé tant qu'une date est refusée. Les deux valeurs partent comme paramètres entiers nommés, jamais dans le texte de la requête ; un début qui n'est pas un entier de 0 à 365 n'est jamais envoyé (ni remplacé par une autre durée).
Aujourd'hui (:today) : la date UTC du navigateur, prise une fois par chargement et envoyée comme paramètre nommé de type date aux quatre requêtes (et, depuis la 0.29, aux requêtes du lineage du même chargement, section 6.8). Elles lisent donc les mêmes jours, même si le chargement passe minuit, et ces jours sont ceux affichés, quel que soit le fuseau de session du warehouse (usage_date est une date UTC). Une valeur qui n'est pas une vraie date à un jour près de maintenant est remplacée par la date du jour.
Bornes appliquées par les quatre requêtes : usage_date et event_date (lineage) entre date_sub(:today, :days) et date_sub(:today, :end_days) ; pour les horodatages (period_start_time des exécutions, start_time de l'historique des requêtes), à partir de date_sub(:today, :days) et avant date_add(:today, 1 − :end_days), c'est-à-dire jusqu'à la fin du dernier jour. Une exécution compte à la date où sa tranche commence, comme avant.
Jours comptés N (pour le coût mensualisé et les libellés « sur N jours ») : chacune des dates de la période, N = :days − :end_days + 1. Exemples : du premier au 30 septembre, N = 30 ; les 30 derniers jours complets, N = 30 ; aujourd'hui seul, N = 1. Une période qui contient aujourd'hui compte ce jour en entier alors qu'il est en cours : son coût mensualisé est alors sous-estimé jusqu'à la fin de la journée, et l'écran le signale. L'écran affiche le nombre de jours comptés avant d'appliquer. Les coûts chargés avant la 0.13 gardent le nombre de jours enregistré avec eux.
Période précédente : avec chaque chargement des coûts, les mêmes requêtes costs, spend (depuis la 0.24 : la dépense par jour de la synthèse, section 6.5), runs, work et attrib lisent aussi la période qui la précède, du même nombre de dates et finissant la veille de son premier jour : :days' = :days + N, :end_days' = :days + 1. Exemple : les 30 derniers jours complets (30, 1) sont comparés aux 30 jours d'avant (60, 31) ; aujourd'hui (0, 0), à hier (1, 1). Elle n'est pas lue si elle commencerait à plus de 365 jours (les tables système gardent un an) : les cartes disent alors « Pas de comparaison ». Ces requêtes sont facultatives : si elles échouent, les cartes disent « Comparaison indisponible » et rien d'autre ne change ; si seule spend, work, attrib ou runs manque (par exemple un délai dépassé sur un long historique des requêtes), les cartes concernées disent « Non comparable », les autres restent comparées. Elles ajoutent cinq requêtes à chaque chargement des coûts ; avec le plan, la période précédente est gardée sans le travail par consommateur (tableaux de bord, requêtes), qui n'est pas comparé. Un test Spark vérifie que deux périodes côte à côte somment, charge par charge et au centime, à la période qui les réunit.
Plan des coûts avec une table suivie : quand le plan ne montre que le lineage d'une table (filtre de table du plan), chaque station affiche Σ (rafraîchissement(T) + lecture(T)) de ses seules tables dessinées, et la liste à droite les mêmes montants table par table. La somme des stations égale donc, au centime près, celle des tables du lineage montré. Même règle pour une station isolée (focus, depuis la 0.14) : le plan ne garde que les tables de la station et les liens qui passent par elles, et chaque station dessinée ne somme que ses tables dessinées. Sans table suivie ni focus, une station somme toutes les tables de son schéma, comme avant. La carte d'une ligne somme le rafraîchissement des tables de la ligne retenues par les filtres de tables du volet FinOps (le filtre « domaine » de cette section, avec la ligne choisie) ; sur un plan réduit (table suivie, catalogue, focus), seulement celles qui sont dessinées. Isoler la ligne ne change donc pas son chiffre.
Dépense par jour : la requête spend agrège par jour, produit, type de charge et calcul. Le graphique suit donc ces filtres. Un filtre tag ou « exécuté par » ne peut pas être suivi jour par jour sans multiplier le volume lu ; dans ce cas le graphique est masqué avec une explication, plutôt que d'afficher une courbe qui ne correspondrait pas aux totaux. Une charge facturée sous deux produits, ou en partie en serverless, compte dans les totaux sous son produit principal et son calcul principal, mais jour par jour sous chacun : sous un filtre de dépense, le graphique n'est donc affiché que si la somme de ses jours égale le total au centime près, sinon il est masqué avec la même explication.
7.1 Variation des cartes par rapport à la période précédente
Chaque carte de la synthèse (section 6.5) et du panneau montre son écart avec la période précédente, calculé avec exactement les mêmes formules, la même remise et les mêmes filtres que la période affichée (les sections 3 à 6 appliquées à la période précédente) :
| Carte | Chiffre comparé | Mieux quand |
|---|---|---|
| Dépense | Σ coût(W) | il baisse |
| DBU consommés | Σ DBU(W) | il baisse |
| Payé par le rafraîchissement des tables | Σ rafraîchissement(T) / dépense, en points | ni l'un ni l'autre : la part dit seulement comment la dépense se répartit |
| Tables sans lecture observée | Σ rafraîchissement(T) des tables sans lecture observée, mensualisé | il baisse |
| Exécutions en échec | coût des exécutions en échec | il baisse |
| Tables sélectionnées (filtre de tables) | leur coût et celui des tables sans lecture observée | il baisse |
« Sans lecture observée » s'entend sur chaque période, avec ses propres lectures. Les échecs ne sont comparés que si l'issue des exécutions a été lue pour les deux périodes ; la part des tables et les tables sans lecture observée, que si l'attribution aux tables a été lue de la même façon pour les deux.
Règle de l'écart (variation, finops.mjs), avec x la valeur de la période et y celle d'avant :
-
écart
x − y, et en pourcentage(x − y) / y; pour une part, l'écart en points ; -
stable (gris) si l'écart est sous 2 %, ou sous 1 en montant, ou sous un demi-point pour une part ; « nouveau » si
y = 0etx > 0(jamais « +∞ ») ; -
sinon, quand une baisse est meilleure : vert pour une baisse, rouge pour une hausse, en gras à partir de 10 % (depuis la 0.30 ; avant, une hausse de 2 à 10 % était orange). Les seuils sont fixes et publiés (
VARIATION) ; - une part reste grise, quelle que soit sa variation ;
- une période dont la facturation du dernier jour n'était pas complète au chargement garde la couleur de son sens depuis la 0.30 (avant, elle restait grise), et chaque écart est précédé de « ≈ », avec la raison dans l'infobulle : aujourd'hui (en cours), ou un dernier jour terminé depuis moins de 12 heures (UTC) si la facturation n'en contient pas encore la dernière heure (aucune ligne d'usage, toutes charges confondues, ne se termine à minuit après ce jour). La facturation arrive avec quelques heures de retard : une baisse marquée « ≈ » peut venir de lignes pas encore publiées, et l'écran le dit sous le titre ;
- quand les totaux sont négatifs (corrections de facturation dans un sous-ensemble filtré), l'écart en pourcentage se rapporte à la valeur absolue d'avant, et « nouveau » n'est employé que pour un montant qui passe de zéro à un montant positif.
La couleur n'est jamais seule : chaque écart a sa flèche (▲, ▼ ou =), son signe et son montant, et l'infobulle donne les dates et la valeur de la période précédente.
7.2 Projections du coût et des DBU
Depuis la 0.17, la page « Projections » du volet FinOps dit ce que coûteraient les mêmes usages, et combien de DBU ils consommeraient, sur les jours qui viennent s'ils gardaient leur rythme : pour la plateforme, chaque produit, chaque charge de travail et chaque table. Ce sont des chiffres dérivés (section 1) : jamais une mesure ni une prévision de facture, et l'écran le dit sous le titre.
Période mesurée et fenêtre à venir. La période du volet FinOps (« Mesuré sur » sur cette page) est faite de jours passés : c'est là que se mesurent les deux rythmes. La fenêtre projetée est faite de jours à venir.
Horizon (H jours) : la fin du mois, 30, 90 ou 365 jours. Il commence le lendemain du dernier jour de la période, ou aujourd'hui (date UTC) si la période s'est terminée avant : une projection regarde devant, jamais en arrière. « Fin du mois » va jusqu'au dernier jour du mois de ce début (un mois entier si la période finit le dernier jour d'un mois). La fenêtre peut aussi se choisir par deux dates à venir, « du » et « au », incluses : le premier jour au plus tôt le début ci-dessus, le dernier jour après le premier, trois ans au plus (1 096 jours) ; H est alors le nombre de jours de l'un à l'autre. Des dates refusées le sont avec leur raison, et rien n'est recalculé. L'écran affiche les dates et H.
Deux rythmes par charge de travail W, lus dans la même requête costs que les autres chiffres :
| Rythme | Coût par jour | DBU par jour |
|---|---|---|
| De la période | p(W) = coût(W) / N | dbu(W) / N |
| Des 7 derniers jours | r(W) = coût7(W) / 7 | dbu7(W) / 7 |
coût7(W) est la dépense des 7 dernières dates complètes de la période (fin − 6 à fin), la même que pour « coût en hausse » (section 6) ; dbu7(W) (colonne dbus_7d, nouvelle en 0.17) somme les DBU de ces mêmes dates, unité DBU seulement, comme dbu(W). Le rythme récent n'existe que si les 7 dernières dates de la période sont toutes dans la période et complètes : la période se termine avant aujourd'hui, compte au moins 7 dates, et la facturation de son dernier jour était complète au chargement (la règle des 12 heures de la section 7.1). Sinon (période qui contient aujourd'hui, dernier jour pas encore complet, moins de 7 dates, dont les « 7 derniers jours » déborderaient avant la période), la projection suit le seul rythme de la période, sans écart, et l'écran dit pourquoi. Les coûts chargés avant la 0.17 n'ont pas dbus_7d : leurs DBU suivent le rythme de la période.
Charge intermittente : une charge facturée sur moins d'une date par semaine, jours(W) × 7 < N, où jours(W) est le nombre de dates de la période où elle a un usage (active_days). Sept jours ne montrent pas son cycle : une clôture mensuelle passée la semaine dernière serait multipliée par quatre, une clôture de début de mois tomberait à zéro. Elle suit le rythme de la période, et l'écran la marque « intermittent » ; son écart part de zéro quand elle n'a rien coûté ces 7 jours. Une charge régulière arrêtée depuis plus d'une semaine n'est pas intermittente : elle suit son rythme récent, zéro, et son écart monte jusqu'au rythme de la période.
Valeur et écart entre les deux rythmes d'une charge :
-
valeur :
proj(W) = H × r(W), ouH × p(W)pour une charge intermittente ou sans rythme récent ; -
écart : de
H × min(p(W), r(W))àH × max(p(W), r(W)); la même règle pour les DBU. Ce sont les deux rythmes mesurés, pas un intervalle de confiance : aucune probabilité n'y est attachée, et l'écran dit « entre deux rythmes ».
Sommes : le total et chaque produit sont Σ proj(W) de leurs charges, au centime, et leurs écarts la somme des écarts des charges (une enveloppe, plus large que l'écart entre les deux rythmes du total quand des charges évoluent en sens opposés). Un job qui ne fait que lancer d'autres jobs (section 4.1) n'a pas de projection propre : chacun des jobs lancés a la sienne, rien n'est compté deux fois.
Tables : proj(T) = Σ_W part(T, W) × proj(W), avec les parts de la section 5 (rafraîchissement(T) = Σ_W part(T, W) × coût(W)). Une table garde donc sa précision (section 5.7) et la part de chaque charge qui la paie. La somme des projections des tables est la part projetée des charges attribuée aux tables, pas le total.
Évolution du rythme (carte et colonne « Rythme récent ») : (Σ r(W) − Σ p(W)) / Σ p(W), ou (r(W) − p(W)) / p(W) pour une charge. Au-dessus de zéro, la dépense accélère. Elle compare les deux rythmes eux-mêmes, quel que soit celui que suit chaque charge.
Remise et filtres : la projection part des coûts affichés, donc du prix catalogue moins la remise saisie, et des seules charges retenues par les filtres de dépense. Avec des filtres de tables, la page ajoute la projection du rafraîchissement des tables choisies (Σ proj(T), sans leur lecture), ne liste que ces tables et les charges qui les paient (écriture ou lecture), et l'export suit la page. Chaque charge qui a un chiffre est listée, avoirs (négatifs) et DBU sans prix compris : les lignes somment aux cartes.
Carte de la synthèse : « Projection, 30 prochains jours » est la valeur de l'horizon 30 jours, l'écart entre les deux rythmes en dessous (section 6.5) ; un clic ouvre la page.
Export : le bouton CSV écrit une ligne pour le total, une par charge et une par table : mesuré (coût et DBU), projeté, bornes basse et haute, DBU projetés, devise, dates et H. Les montants des charges sont arrondis par la méthode des plus grands restes : leurs lignes somment à la ligne du total, au centime (section 6.2). Les noms passent par la règle commune des exports (section 6.2) : une cellule qui commence par =, +, -, @, une tabulation ou un retour chariot reste du texte.
Ce qui n'est pas projeté : les changements de prix ou de contrat, les charges qui n'existaient pas pendant la période, la saisonnalité (limite 10, section 8), l'usage sans prix (compté à part, section 3).
8. Limites connues
-
Prix catalogue, pas facture. Les montants sont au prix catalogue Databricks, moins la remise saisie. La facture réelle dépend du contrat (engagements, crédits) et des coûts du fournisseur cloud, absents de
system.billing.usage. - Couverture du lineage. Selon Databricks, les tables de lineage sont un sous-ensemble des lectures et écritures : un événement n'est émis que lorsque le lineage peut être déduit. Une écriture non tracée laisse le coût de la charge non attribué, jamais attribué à tort.
-
Temps de calcul comme clé de répartition. Dans une heure de warehouse ou une exécution qui écrit plusieurs tables, la répartition au prorata de
total_task_duration_mssuppose que le coût suit le calcul consommé. C'est l'hypothèse standard ; elle ignore la mémoire et les effets de mise à l'échelle (un pic qui fait démarrer un cluster supplémentaire coûte plus que sa part de temps). Le découpage horaire réduit cet effet sans l'annuler. L'écran l'indique par la précision « warehouse » ou « temps de calcul ». - Attributs principaux d'une charge. Produit, « exécuté par » et tags sont ceux de la plus grande consommation de la charge. Une charge dont les tags changent en cours de période est filtrée selon ses tags principaux.
- Délai de publication. Databricks met à jour les tables système avec quelques heures de retard ; les derniers jours peuvent être incomplets. Une période qui se termine quelques jours avant aujourd'hui évite cet effet.
- Lectures. Le nombre de lectures vient du lineage : une lecture hors Unity Catalog (export, outil externe sans lineage) n'est pas comptée. « Sans lecture observée » est donc un signal à confirmer, jamais une preuve ni une économie.
- Mensualisation. L'extrapolation linéaire sur un mois moyen de 365/12 jours ne tient pas compte de la saisonnalité.
- Comparaison. Deux périodes de même longueur peuvent différer par leur calendrier (un mois de clôture, des jours fériés) : un écart est un signal à expliquer, pas un jugement en soi.
- Jobs lancés. Le lien entre une exécution et la tâche « Run Job » qui l'a lancée n'existe dans les tables système que depuis début décembre 2025, et seulement pour le lanceur direct. Une période plus ancienne montre les jobs lancés à 0 lien.
- Projections. Une projection prolonge un rythme mesuré : elle ne connaît ni les jobs à venir, ni les arrêts prévus, ni la saisonnalité, ni les changements de prix. Le rythme des 7 derniers jours réagit vite à une hausse mais aussi à une semaine exceptionnelle ; l'écart entre les deux rythmes montre l'autre lecture. Une charge facturée moins d'un jour par semaine suit le rythme de la période (section 7.2).
- Calculateur. Ses chiffres sont des estimations aux prix publics d'un relevé daté, plus les prix et remises saisis : ni disques, ni réseau, ni engagements de dépense, ni variations de prix après le relevé (section 13.6). Les heures des machines mesurées ne couvrent que les 90 derniers jours et peuvent manquer les nœuds de moins de 10 minutes : la couverture est affichée (section 13.4).
-
Exécutions et lineage. L'attribution exécution par exécution suppose que le lineage porte l'identifiant d'exécution (
entity_metadata, ouentity_run_idsur un metastore plus ancien). Quand il manque, la charge suit le repli sur la période, avec la précision « période ». Une exécution qui écrit hors du lineage (fichiers non suivis, connecteur externe) reste non attribuée. - Lignes facturées sur plusieurs heures. Une ligne d'usage de warehouse est étalée sur les heures qu'elle couvre au prorata du temps : une ligne d'une heure est exacte, une ligne plus longue suppose une consommation régulière sur sa durée.
-
Requêtes relues en parties. Sur un grand workspace, une réponse qui dépasse la limite de réponse en ligne de Databricks (25 Mio) est relue en 8, puis en 64 parties (lineage,
attrib,work). Chaque partie est une requête de plus sur le SQL warehouse choisi : jusqu'à 1 + 8 + 64 exécutions pour une requête, et autant pour la période précédente. Ce coût est celui de l'utilisateur, sur son warehouse ; il apparaît dans les coûts de ce warehouse au chargement suivant. -
Vues et lineage. Le lineage note une requête sur une vue comme une lecture de la vue, et note aussi chaque table sous la vue, avec
direct_access = false(documenté, section 6.8). Depuis la 0.28, YALineo ne compte que la lecture de la vue et l'ajoute une fois à ses sources (section 5.8). Sur un metastore qui n'a pas encore la colonnedirect_access, les formes d'avant sont lues et cette lecture peut compter deux fois pour les tables sources : un signal d'usage, pas un compte exact. Le type d'un objet vient d'Unity Catalog (information_schema.tables) ou, à défaut, du lineage. - Chaînes de vues très longues. Le lineage garde sur toute sa fenêtre les liens d'une vue redéfinie : une suite de vues redéfinies l'une après l'autre forme une chaîne plus longue que ce que Spark accepte aujourd'hui. Le parcours des lectures à travers les vues est donc borné (section 5.8) ; au-delà, les lectures sont un minimum, marqué « ≥ ».
- Exactitude d'un catalogue ou d'un schéma. Une charge est jugée sur les objets que le lineage lui voit écrire pendant la période. Une écriture hors du lineage (section 8, point 2) peut donc rendre « exact » un niveau qu'elle aurait rendu « réparti » ; le montant, lui, ne change pas.
- Noms lus. Les noms des tableaux de bord et des requêtes enregistrées sont lus jusqu'à 20 000 par liste (section 6.10) : au-delà, un actif garde son identifiant, et le plan dit combien de noms manquent. Les noms des Genie Agents (anciennement espaces Genie) suivent la même borne, sans compte de ceux qui manquent.
-
Lectures comptées par ligne du lineage. Depuis la 0.29, une écriture compte une fois par événement (section 6.8). Une lecture directe compte encore une fois par ligne : une instruction qui lit une table pour écrire deux tables laisse deux lignes, donc deux lectures. C'est un signal d'usage (point 6), pas un nombre de requêtes. Sur un metastore sans la colonne
direct_access, les formes d'avant comptent aussi les écritures par ligne. Les jours écrits, la dernière écriture, la fraîcheur et le rythme ne comptent que des dates et ne dépendent d'aucun de ces deux nombres.
9. Vérification
Tests automatiques, exécutés à chaque version : les tests unitaires avec npm test, et les requêtes SQL elles-mêmes avec python3 tests/spark/finops_sql.py (Spark 4 en mode ANSI, tables de facturation synthétiques dont les réponses sont connues, requêtes extraites telles que l'extension les envoie).
| Propriété | Test |
|---|---|
| Coût par ligne au prix en vigueur, prix effectif prioritaire, corrections négatives incluses, autre workspace exclu, ligne sans prix comptée à part | tests/spark/finops_sql.py |
| La dépense par jour, par type et par calcul, égale la somme des charges | tests/spark/finops_sql.py |
| Tags lus par charge, ancien schéma compris | tests/spark/finops_sql.py |
| Période choisie avec deux dates : chaque requête s'arrête au dernier jour, la semaine comparée est la dernière de la période, une seule date passée compte seule, les jours somment aux charges au centime | tests/spark/finops_sql.py |
| Aujourd'hui seul (0 jour en arrière) ne lit qu'aujourd'hui ; deux périodes côte à côte somment, charge par charge, à la période qui les réunit | tests/spark/finops_sql.py |
| Un seul jour (aujourd'hui compris) est une période, chaque refus a sa raison, la période précédente a autant de dates et finit la veille, un début hors de 0 à 365 n'est jamais envoyé | tests/v0130.test.mjs |
| Les cartes comparées avec les mêmes filtres et la même remise, la règle de l'écart (bandes, sens, zéro, période en cours), une période précédente stockée et piégée sans effet | tests/v0130.test.mjs |
| Dates vérifiées avant tout envoi (ordre, futur, plus d'un an, dates impossibles, texte piégé), fin envoyée comme entier nommé, jours comptés et mensualisation, cartes plus anciennes lues comme avant | tests/v0110.test.mjs |
| Plan des coûts avec une table suivie : la somme des stations égale celle des tables du lineage montré, au centime | tests/v0110.test.mjs |
| Plan des coûts avec une station isolée (focus) : la somme des stations égale celle des tables dessinées, au centime | tests/v0140.test.mjs |
| Temps par table : une requête qui écrit deux tables compte pour moitié dans chacune ; total par warehouse limité à ce workspace | tests/spark/finops_sql.py |
| Warehouses heure par heure : le coût d'une heure partagé entre ses requêtes au temps de calcul, une requête à cheval sur deux heures comptée dans chacune, les heures sans requête en capacité à part, les requêtes sans temps à parts égales | tests/spark/finops_sql.py |
Exécution par exécution : une seule table, temps de calcul, parts égales ; l'exécution échouée non attribuée ; le lineage avec et sans entity_metadata ; le repli sur la période ; un notebook ; les tables hors des catalogues comptées à part | tests/spark/finops_sql.py, tests/v0200.test.mjs |
| Attaques de la convention : tables qui changent d'une exécution à l'autre, exécution échouée, table hors du plan, règle inconnue, noms de prototype, autre workspace, flot de lignes borné, correction négative jamais ramenée à zéro, identité au centime avec remise | tests/v0200.test.mjs |
| Arrondis : les parts arrondies somment au total arrondi (plus grands restes), avoirs et égalités compris ; exports des tables et des projections, équipes | tests/v0200.test.mjs |
| Identité comptable : tables + lectures + hors du plan + capacité sans requête + non attribué = total | tests/v070.test.mjs, tests/v081.test.mjs, tests/v0200.test.mjs |
| Une exécution est attribuée au plus une fois, parts au prorata du temps mesuré | tests/v070.test.mjs, tests/spark/finops_sql.py |
| Les équipes (tag) partitionnent le total ; serverless + classique = total | tests/v080.test.mjs |
| Un filtre de tables ne change pas le coût d'une table ; la somme des catalogues égale le total attribué ; « qui paie » somme à la sélection | tests/v080.test.mjs |
| Un filtre de dépense recalcule le coût de chaque table à partir des seules charges choisies | tests/v080.test.mjs |
| Une table hors du plan (disparue ou hors des catalogues) garde sa part, comptée à part ; la table lisible ne la reçoit pas et l'identité comptable tient | tests/v081.test.mjs |
| Catalogues internes de Databricks (0.34.3) : jamais listés ni lus dans l'inventaire, leurs tables hors du plan et raccordées, leur part dite à part dans « tables hors du plan », aucune ligne de catalogue, rapprochement au centime, noms hostiles | tests/v0343-internal.test.mjs, tests/security.test.mjs, tests/spark/finops_sql.py |
| Relecture de la 0.34.3 : une ligne facturée au nom d'une table interne reste une charge jamais nommée (écran, fichiers, constats, synthèse, fiche), les lignes écrites dans une table interne ne font pas de table des coûts, l'impact d'une colonne traverse les tables internes, « Pourquoi ? » ne nomme jamais une table interne, un plan enregistré est nettoyé une fois par chargement, le pré-vol garde une table interne trop reliée, des catalogues choisis tous internes ne lisent rien, un chargement gardé est raccordé comme le plan | tests/v0343-review.test.mjs, tests/spark/finops_sql.py |
Agents, Genie, endpoints et apps chacun sur sa ligne ; un espace Genie reçoit sa part du warehouse ; un ancien schéma sans agent_bricks_id fonctionne | tests/spark/finops_sql.py, tests/v082.test.mjs |
Genie Code, Genie One et Genie Agents séparés par usage_metadata.genie.surface, DBU gratuits à part, un champ absent dit « non indiqué », une synchronisation d'index AI Search comptée en AI Search (0.28) | tests/spark/finops_sql.py, tests/v0280-genie28.test.mjs |
| Évolutions : deux périodes complètes de même longueur, la même attribution que les coûts, les mouvements triés par écart, les exécutions et échecs par date, lecteurs et écrivains distincts par période | tests/spark/finops_sql.py |
| Évolutions : semaines alignées sur le dernier jour (la première partielle), groupes de dépense qui somment au total, écart, pente et pic | tests/v083.test.mjs |
| Le badge d'un objet donne le chiffre des écrans FinOps (coût d'une charge, rafraîchissement d'une table, requêtes d'un tableau de bord), remise comprise ; rien sous un centime, rien pour un autre workspace | tests/badges.test.mjs, tests/e2e/run_e2e.py |
| Jobs lancés : seules les exécutions démarrées par une tâche « Run Job » comptent, jamais un job pour lui-même, jamais ajoutés aux totaux | tests/spark/finops_sql.py, tests/v0160.test.mjs |
| Projections : DBU des 7 dernières dates lus comme leur coût, horizons, valeur au rythme retenu et écart entre les deux rythmes, charges intermittentes au rythme de la période, total et produits égaux à la somme des charges au centime, tables à la part de leurs charges, remise et filtres comme ailleurs, CSV neutralisé | tests/spark/finops_sql.py, tests/v0170.test.mjs, tests/security.test.mjs |
| Prix d'une ligne d'usage à cheval sur un changement de prix : le prix en vigueur à sa fin, comme l'exemple officiel | tests/spark/finops_sql.py |
| Calculateur : chaque formule vérifiée à la main (jobs, clusters, warehouses Classic et Pro par leurs machines documentées, serverless, Photon, réservation nouvelle ou existante, spot relancé à l'usage, quatre paiements), total d'une estimation égal à la somme de ses lignes au centime, export CSV qui somme à son total | tests/v0180.test.mjs, tests/v0200.test.mjs |
| Calculateur : rien d'inventé (région, prix, type de machine ou taille absents donnent « non chiffré »), prix saisis prioritaires, exemples fictifs chiffrés sur Azure et AWS, machines GCP demandées | tests/v0180.test.mjs |
Calculateur : heures des machines lues sur les 90 jours que garde node_timeline, partagées entre les charges d'un cluster au prorata de leurs DBU, DBU et coût sur les mêmes dates, couverture ; leviers proportionnels d'une charge mesurée | tests/spark/finops_sql.py, tests/v0180.test.mjs |
Vues par type de charge (0.24) : les points de chaque charge (requête series) somment à son coût au centime, jour par jour puis semaine par semaine, en parties et sur l'ancien schéma ; chiffres clés égaux à la somme des lignes ; capacité sans requête, écritures, lectures et reste égaux au coût de chaque warehouse ; types d'IA, valeurs de tag et « Sans tag » qui somment à leur total au centime ; exports au centime ; clés et valeurs de tag piégées (__proto__, balisage, formules) gardées comme texte | tests/spark/finops_sql.py, tests/v0240-fotypes.test.mjs, tests/e2e/run_e2e.py, tests/e2e/security/hostile_metadata.py |
| Catalogues et schémas : les schémas somment à leur catalogue et les catalogues au total ; exact plus réparti égale le rafraîchissement ; un job dans un seul schéma, dans deux schémas d'un catalogue, dans deux catalogues, une part de warehouse, une table facturée ; identité au centime sur l'exemple ; filtres de tables ; export au centime ; badges de Catalog Explorer ; comparaison avec la période précédente | tests/v0220.test.mjs, tests/badges.test.mjs, tests/e2e/run_e2e.py |
Glossaire : inventaire des colonnes en 1 et 8 parties, script de publication enregistré tel quel par Spark (textes piégés compris), table publiée relue par IDENTIFIER, instruction ai_query exécutée jusqu'à une ligne par terme avec un modèle simulé | tests/spark/finops_sql.py, tests/v0220.test.mjs |
| Relevés de prix : un par cloud, daté, alignés, plausibles (spot au plus le prix à l'usage, réservé 3 ans au plus 1 an), sources nommées sans adresse, aucune requête réseau ; stockage des estimations borné et sans pollution de prototype | tests/v0180.test.mjs, tests/e2e/run_e2e.py |
Synthèse et composeur (0.24) : la cascade, les produits, les équipes et les jours somment au centime, la période d'avant alignée par position, les seaux par jour, semaine et mois, les N premiers et « Autres » qui somment au total, les raisons d'une comparaison absente, l'export au centime et neutralisé ; analyses enregistrées piégées nettoyées et bornées ; requête work-days en lecture seule, ses charges en paramètre nommé, ses sommes égales à costs sur les mêmes dates | tests/v0240-fo24.test.mjs, tests/security.test.mjs, tests/spark/finops_sql.py, tests/e2e/run_e2e.py |
Chiffrer un projet de données (0.24) : chaque brique au centime sur un relevé à prix ronds, le modèle Entrepôt BI d'un domaine, les outils de dimensionnement, l'enregistrement project relu comme hostile | tests/v0240-calc24.test.mjs, tests/security.test.mjs |
| Services et outils du Calculateur (0.25) : taux et sources du relevé, formules par type de service, plages, parts gratuites, remises par unité de facturation, prix du compte relus comme hostiles, prix des SKU et des jetons, export Excel, fichier d'estimation, assistant | tests/v0250-rates25.test.mjs, tests/v0250-svc25.test.mjs, tests/v0250-tools25.test.mjs, tests/v0250-account.test.mjs, tests/security.test.mjs |
| Pourquoi un coût est absent ou nul (0.26) : chaque raison avec ses valeurs lues et son action, la part d'une table, celle des autres tables et le reste d'une charge partagée justes au centime, chaque code documenté, textes piégés inertes | tests/v0260-cost26.test.mjs, tests/security.test.mjs |
| Simulations (0.27) : chaque outil de réglage et de dimensionnement sur son exemple, calculé à la main sur un relevé à prix ronds, totaux au centime, chiffre mesuré manquant signalé et jamais deviné ; calculs par capacité et par poste, ligne d'estimation chiffrée au centime de l'outil ; profils qui incluent chaque calcul (0.28) | tests/v0270-tune27.test.mjs, tests/v0270-simcap27.test.mjs, tests/v0280-roles28.test.mjs |
Ce que YALineo compte (0.28) : lectures directes seulement (direct_access), une lecture à travers une vue comptée une fois pour sa table, lecteurs directs, voisins directs et chaîne entière, lectures et écritures par origine, vues jamais écrites, un badge pour chaque actif du plan, noms des jobs, fenêtre des liens, metastores sans direct_access | tests/v0280-coh28.test.mjs, tests/spark/finops_sql.py |
| Effacer des termes du glossaire (0.29) : ce que chaque choix efface et garde (validés, autres sources, rejetés, réglages), l'état d'avant un import raté rendu à l'identique, le mot de passe comparé par son empreinte, refusé sous toute autre forme et gardé nulle part, une portée ou un glossaire piégés sans effet, « Annuler » | tests/v0290-erase29.test.mjs, tests/security.test.mjs, tests/e2e/run_e2e.py |
Comptes du lineage (0.29) : une écriture par événement (event_id, sinon record_id) dans l'activité, les écrivains et la tendance d'une table ; « Pourquoi aucun lien ? » sur les lecteurs directs, comparé aux liens observés (un raccord ne cache plus un lien manquant) ; chaque fenêtre du lineage se termine à :today (date UTC envoyée comme paramètre nommé, une valeur piégée remplacée par la date du jour) ; les formes pour les metastores sans direct_access | tests/v0290-lin29.test.mjs, tests/spark/finops_sql.py |
Données du plan (0.28) : rythme sur la période d'activité, liens raccordés gardés à part, fraîcheur sans last_altered, règle des dossiers (deux comptes de stockage, dossier au nom pointé), noms lus jusqu'à la borne, DBU gratuits hors du prix moyen d'un DBU | tests/v0280-data28.test.mjs, tests/spark/finops_sql.py |
| IA : Genie et agents (0.32) : un Genie Agent chiffré à la main sur un relevé à prix ronds (règle du warehouse de la section 13.9, allocation gratuite, promotion, principal de service), un agent partie par partie depuis le relevé des services et recoupé avec le comparateur des jetons, remises par catégorie, totaux au centime, ce qui manque demandé et jamais compté pour 0, lignes d'estimation chiffrées comme la page, saisies piégées sans effet | tests/v0320-ai32.test.mjs, tests/v0320-ai32-ui.test.mjs |
| Dimensionner une ingestion (0.32) : l'exemple calculé à la main sur un relevé à prix ronds, totaux au centime et égaux au mois de l'estimation, DBU par Go demandés et jamais devinés, passerelle d'un connecteur de base de données, rattrapage à part, saisies piégées sans effet | tests/v0320-ingest32.test.mjs |
Rapprochement par l'utilisateur. La dépense totale de YALineo pour une période se vérifie avec cette requête, à lancer dans un éditeur SQL Databricks (remplacer l'identifiant du workspace et le nombre de jours) :
SELECT SUM(u.usage_quantity * CAST(coalesce(p.pricing.effective_list.`default`, p.pricing.`default`) AS DOUBLE)) AS cout_catalogue,
SUM(CASE WHEN u.usage_unit = 'DBU' THEN u.usage_quantity END) AS dbu
FROM system.billing.usage u
LEFT JOIN system.billing.list_prices 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.workspace_id = '<identifiant du workspace>' -- à retirer si le réglage « Tout le metastore, autres workspaces compris » est choisi
AND u.usage_date >= date_sub(current_date(), <jours>)
AND u.usage_date <= date_sub(current_date(), 1);
current_date() doit être la date UTC : régler le fuseau de la session sur UTC (SET TIME ZONE 'UTC') avant la requête si le warehouse est sur un autre fuseau. La période d'une durée choisie se termine hier (section 7) ; pour une période qui se termine aujourd'hui, retirer la dernière condition. Pour une période choisie avec deux dates, remplacer les deux conditions de date par u.usage_date BETWEEN DATE'<du>' AND DATE'<au>'.
Le résultat doit être égal au total affiché par YALineo sans remise. Le même total se compare au tableau de bord d'usage de Databricks (console du compte) pour le même workspace et la même période.
10. Analytique : les questions et les évolutions dans le temps
La vue « Analytique » du studio ne crée aucun chiffre nouveau : ce sont les coûts des sections 3 et 4 et les événements du lineage de la section 6, regroupés par date. Chaque lecture est une requête en lecture seule lancée à la demande (jamais pendant le chargement du plan).
Deux périodes de même longueur. Pour une période de N jours (7, 30, 90 ou 180), la période courante est formée des N dernières dates, aujourd'hui compris, et la précédente des N dates d'avant. Les requêtes lisent 2N − 1 jours en arrière (paramètre :lookback) : les deux périodes sont complètes. « Aujourd'hui » est la date UTC du navigateur, ou la date la plus récente renvoyée si le warehouse est en avance.
Regroupement. Jour par jour jusqu'à 31 jours, semaine par semaine au-delà. Les semaines se terminent sur le dernier jour de la période ; quand N n'est pas un multiple de 7, la première semaine est plus courte, marquée « partielle » et dessinée plus pâle, pour ne pas être lue comme une baisse.
| Graphe ou chiffre | Requête | Formule |
|---|---|---|
| Dépense de la plateforme | spend sur 2N − 1 jours | Σ coût des lignes d'usage de chaque date, par groupe : Jobs ; SQL warehouses ; Pipelines ; IA (Agent, Genie, AI Search, Endpoint, App) ; Calcul interactif (Notebook, Cluster) ; Vues matérialisées (Table) ; Autres. Chaque type appartient à un seul groupe : la somme des groupes égale le total au centime |
| Ce qui a le plus changé | trend-movers | Pour chaque charge (même attribution qu'en section 4) : coût(W, courante) − coût(W, précédente), trié par écart absolu |
| Coût d'une charge | trend-workload | Σ coût de la charge (type, identifiant) par date, avec les expressions de la section 4 (le même CASE, vérifié par un test) |
| Exécutions facturées | trend-workload | Nombre distinct de job_run_id ou dlt_update_id facturés ; une exécution facturée sur deux dates compte sur chacune |
| Coût par exécution | coût(période) / exécutions facturées(période) | |
| Exécutions, échecs, durée d'un job | trend-runs | Lu dans system.lakeflow.job_run_timeline ; une exécution compte la date où elle démarre ; échec : état final FAILED, ERROR ou TIMED_OUT ; durée moyenne d'un regroupement : moyenne des durées journalières pondérée par le nombre d'exécutions |
| Lectures, écritures d'une table | trend-table | Lignes du lineage où la table est source (lecture, directe seulement depuis la 0.28) ou cible (écriture, une ligne par source lue), comme en sections 6 et 6.8 |
| Lecteurs, écrivains distincts | trend-table | Nombre distinct de (entity_type, entity_id), ou de l'utilisateur pour une requête sans entité, sur chaque période. Seuls les nombres reviennent, jamais les noms |
| Écart | courante − précédente ; en pourcentage (courante − précédente) / précédente, remplacé par « nouveau » si la précédente est nulle et par « stable » sous 0,5 % | |
| Tendance de la période | Droite des moindres carrés sur les valeurs journalières de la période courante : sa pente × (N − 1), rapportée à la moyenne, soit la variation estimée du premier au dernier jour. Vide sous trois points ou sans activité ; « stable » sous 5 % | |
| Pic | Le plus grand regroupement de la période (le premier en cas d'égalité) | |
| Le plan dans le temps | Instantanés gardés | Nombre d'actifs et de liens de chaque chargement gardé sur l'appareil |
Les montants sont au prix catalogue, sans la remise (comme la requête de rapprochement de la section 9). Les deux dernières dates peuvent encore se compléter : la facturation arrive avec quelques heures de retard (section 8, point 5).
10.1 Les réponses aux questions
Chaque question applique des filtres annoncés à l'écran (période, tri, regroupement) et répond par une phrase chiffrée. Les chiffres sont les suivants ; aucun n'est estimé en dehors de ceux qui le sont déjà dans les sections précédentes.
| Question | Source | Chiffres de la réponse |
|---|---|---|
| Qu'est-ce qui coûte le plus ? | trend-movers | coût(W, courante) de chaque charge ; sa part coût(W) / Σ coût ; la part des trois premières |
| Qu'est-ce qui a le plus augmenté ? | trend-movers | La charge au plus grand écart positif, son écart et son pourcentage ; la variation de la dépense totale. Sa courbe s'ouvre en dessous (filtre appliqué pour l'utilisateur) |
| Où va la dépense ? | spend | Le groupe au plus fort montant et sa part de la période |
| Quelle part pour l'IA ? | spend | Σ coût des groupes IA / dépense, sur chaque période ; les deux parts somment avec « le reste » à 100 % |
| Serverless ou classique ? | spend | Même calcul avec l'indicateur is_serverless de chaque ligne d'usage |
| Quels jours coûtent le plus ? | spend | Pour chaque jour de la semaine, la moyenne des totaux journaliers de la période ; le rapport week-end / jours ouvrés |
| Combien coûtent les échecs ? | coûts chargés | Coût des échecs de la section 6, par job, et leur somme, sur la période FinOps |
| Tables sans lecture observée | coûts chargés | rafraîchissement(T) des tables sans lecture observée (section 6), leur somme et son équivalent mensuel ; un coût attribué à vérifier, pas une économie |
| Dépense par équipe | coûts chargés | Coût de chaque charge rangé sous la valeur d'une clé de tag (team, cost_center...) ; les charges sans ce tag forment leur propre ligne, si bien que les lignes somment au total (au centime, section 6.2) ; la couverture du tag est la part du total portée par les charges taguées. Les tags d'une charge sont ceux de sa plus grande ligne d'usage (section 8, limite 4) |
| Tables les plus lues, écrites sans lecture observée, en retard, carrefours, sans description, poids des catalogues | le plan | Comptes d'événements du lineage (section 6), règle de retard sur le rythme propre de chaque table, nombre d'actifs en aval (mesuré pour les 80 tables aux liens directs les plus nombreux), rafraîchissement des tables de chaque catalogue (section 5) |
Trois questions se lisent dans l'explorateur seul (section 10.2) : quand les tables ont été écrites pour la dernière fois (nombre de tables par semaine de leur dernière écriture, par couche), quelles couches sont à jour (nombre de tables par couche et par fraîcheur) et qui possède le plus de tables (nombre par propriétaire). Hors d'un workspace interrogeable (l'exemple, un fichier, le volet FinOps éteint), « Qu'est-ce qui a le plus augmenté ? » prend l'écart des 7 derniers jours sur les 7 d'avant de chaque charge chargée (section 6), et « Qu'est-ce qui coûte le plus ? » le coût de la période FinOps.
10.2 L'explorateur
L'explorateur range les lignes d'un jeu de données selon un axe X, calcule une mesure Y par valeur de X (et, si une couleur est choisie, par valeur de la série), après les filtres. Chaque question de la section 10.1 règle l'explorateur sur sa vue ; le lecteur peut tout changer.
| Jeu de données | Une ligne | Origine | Période |
|---|---|---|---|
| Dépense par jour | un jour, un produit, un type de charge, serverless ou non | system.billing.usage chargé avec le plan (section 2) | la période FinOps, remise comprise |
| Charges | un job, pipeline, warehouse, notebook, agent... | les coûts chargés (sections 4 et 6) | la période FinOps, remise comprise |
| Tables | une table, vue, vue matérialisée ou table de streaming du plan | le plan, et le rafraîchissement de la section 5 | l'activité observée au chargement |
| Variations de coût | une charge | trend-movers (section 10) | les N derniers jours contre les N d'avant, prix catalogue |
| Chargements gardés | un chargement | les plans gardés sur l'appareil | tous les chargements gardés |
Calculs, sur les lignes elles-mêmes, jamais sur des sous-totaux arrondis :
-
Somme :
Σ y(ligne)des lignes du groupe. Nombre : le nombre de lignes du groupe. -
Moyenne :
Σ y / n, n étant le nombre de lignes où la mesure est connue (une table sans activité connue ne compte pas comme zéro). - Maximum, minimum : sur les lignes où la mesure est connue.
-
Rapport des sommes : coût par exécution
Σ coût / Σ exécutions; durée moyenneΣ (durée moyenne × exécutions) / Σ exécutions; évolution(Σ coût courant − Σ coût précédent) / Σ coût précédent. Jamais la moyenne des rapports. -
Moyenne par jour :
Σ coût / nombre de jours du calendrierdu groupe, sur la période du jeu de données (du premier au dernier jour facturé) ; un jour sans facturation compte, pour zéro. Pour un jour de la semaine, ce sont les dates de ce jour dans la période (la moyenne des totaux journaliers de la section 10.1) ; pour un produit ou un type de charge, tous les jours de la période.
Valeurs montrées et « Autres » : sur un axe qui n'est pas le temps, les valeurs sont triées (plus grande d'abord, plus petite, plus grand écart, ou ordre de l'axe) et les N premières sont montrées ; les suivantes sont fusionnées en « Autres », calculé sur leurs lignes avec le même calcul. Pour une somme ou un nombre, les valeurs montrées plus « Autres » font le total, au centime près, et chaque part est valeur / total. Les séries gardent les cinq plus grandes, les autres forment « Autres » ; chaque série garde sa couleur quel que soit le filtre.
Axe de temps : jours, semaines (du lundi) ou mois, sans trou entre la première et la dernière valeur (un jour sans dépense vaut 0), les 400 derniers points au plus. Les lignes plus anciennes que ces points sont laissées hors de la vue et de son total, et leur nombre est affiché : ce qui est montré tombe toujours juste. Semaine de dernière écriture : la semaine de lastWriteMs (lineage), sinon de last_altered (section 5).
Parts : valeur / total seulement pour une somme ou un nombre de montants positifs ; pour un écart (variation de coût, écart sur 7 jours), il n'y a pas de part, les barres montrent le sens de l'écart.
Filtres : chaque filtre garde (ou exclut) des valeurs d'un axe ; « Nom contient » garde les lignes dont le nom (table, propriétaire, charge) contient le texte. Les valeurs proposées par un filtre sont comptées sur les lignes que gardent les autres filtres.
Vérification : tests/v0100.test.mjs contrôle que la dépense regroupée par chaque axe somme à la dépense journalière chargée, que les charges et « Autres » somment au coût total, que le rafraîchissement par catalogue somme à celui de l'index des coûts, que le coût par exécution est le rapport des sommes et que la moyenne par jour de la semaine est celle de la section 10.1, au centime près.
10.3 Le composeur de l'analyse des coûts (0.24)
En tête de la page « Analyse des coûts », le composeur calcule à partir des coûts chargés (sections 4 à 6), sur la période et avec les filtres FinOps des pages Coûts, sans requête nouvelle. Les questions de la section 10.1 restent en dessous.
| Mesure | Valeur d'une ligne | Source |
|---|---|---|
| Coût | coût(W) | charges |
| DBU | DBU(W) | charges |
| Exécutions | les exécutions de la charge (section 4) ; une charge sans exécution n'est pas comptée | charges |
| Échecs | le nombre d'exécutions en échec | charges, si l'issue des exécutions a été lue |
| Coût des échecs | le coût des échecs (section 6) | charges, si l'issue des exécutions a été lue |
| Coût des tables | rafraîchissement(T) + lecture(T) | tables du plan (section 5), attribué |
| Lectures | les lectures de la table (section 6) | tables du plan |
Découpages. Pour une mesure de charges : aucun, produit, type de charge, calcul (serverless ou classique), charge, équipe (la valeur d'une clé de tag, comme en 6.5), exécuté par. Pour une mesure de tables : catalogue, schéma, table. Un découpage qui ne va pas avec la mesure n'est pas proposé. Les filtres produit et équipe du composeur gardent les charges de ce produit ou de cette valeur de tag.
Le temps. L'axe du temps vient seulement de la dépense par jour (spend) : mesure coût ou DBU, découpage aucun, produit, type de charge ou calcul, sans filtre d'équipe, et seulement si les jours somment aux totaux au centime (section 7). Sinon l'écran dit pourquoi et montre les totaux de la période (barres, écarts ou tableau). Grain et colonnes : ceux de la section 6.5.
Les N premiers et « Autres ». Les valeurs sont triées par montant absolu sur la période, puis sur la période d'avant. Les N premières (3, 5, 8 ou 12) sont montrées ; les suivantes sont réunies en « Autres », calculé sur leurs lignes. S'il n'en reste qu'une, elle est montrée sous son nom. Les montants affichés sont des entiers (des centimes pour l'argent, des unités pour les DBU, les exécutions, les échecs et les lectures), arrondis par les plus grands restes : les lignes somment au total, et sur l'axe du temps les colonnes d'une ligne somment à la ligne.
Les couleurs des écarts. Dans une cascade (« Pourquoi la dépense a bougé » et le graphique « Écarts » du compositeur), une hausse est en rouge et une baisse en vert, quelle que soit la mesure : y compris pour les exécutions et les lectures, alors que la règle de l'écart (section 7.1) les laisse grises sur les cartes, une hausse n'y étant pas forcément mauvaise. L'image exportée de ce graphique (PNG, SVG, rapport de la page) écrit les mêmes montants au centime, avec les mêmes couleurs, mais dessine chaque barre depuis zéro, comme un classement, et non en cascade. Les deux choix sont ceux du porteur du projet (0.34).
La période d'avant. Mêmes formules, même remise, mêmes filtres (section 7.1) ; sur l'axe du temps, la comparaison se fait par position, comme en 6.5. Elle n'est pas proposée, et l'écran dit pourquoi, si elle n'a pas été lue (trop ancienne ou en échec), si sa dépense par jour manque pour un graphique dans le temps, ou si l'attribution aux tables ou l'issue des exécutions n'a pas été lue de la même façon pour les deux périodes.
La phrase et les données. La phrase reprend les montants arrondis du tableau : le total, l'écart avec la période d'avant, la première valeur et sa part, la plus forte hausse. Le tableau donne chaque ligne, ses colonnes, son total, la période d'avant et l'écart, au centime pour l'argent et à l'unité pour les DBU et les comptes ; l'export CSV donne les mêmes valeurs, avec la mesure, l'unité, la devise et les dates des deux périodes.
Analyses enregistrées. Une analyse garde son nom (80 caractères au plus), sa configuration (mesure, découpage, grain, graphique, filtres produit et équipe, N, comparaison), les filtres FinOps et les dates de sa période, jamais un montant : rouverte, elle est recalculée sur les coûts chargés, et l'écran dit quand la période chargée n'est pas la sienne. Les analyses restent sur l'appareil, workspace par workspace (yalineo.analyses:<adresse du workspace>), avec la règle de conservation des plans : effacées à la fermeture du navigateur, ou gardées avec « Garder le plan et l'historique sur cet appareil ». Cinquante au plus par workspace. Elles sont nettoyées champ par champ à chaque lecture et à chaque écriture : clés connues seulement, valeurs prises dans leurs listes, tailles bornées, aucun caractère de contrôle ni de sens d'écriture ; une entrée qui ne passe pas est ignorée. Oublier un workspace les efface. Pour l'exemple et un fichier, elles ne vivent que le temps de la fenêtre. Le lien d'une analyse porte sa configuration dans l'adresse (paramètre fa, 1 000 caractères au plus, nettoyé de même), sans aucune donnée de coût.
10.4 Période choisie, questions par actif, comparaison et analyses enregistrées (0.33)
La période choisie. En plus des quatre longueurs (7, 30, 90 ou 180 dernières dates, aujourd'hui compris), deux calendriers indépendants donnent deux dates du et au (dates UTC réelles, du ≤ au ≤ aujourd'hui, un an au plus). La période courante est formée de ces n dates, la précédente des n dates juste avant du. Les requêtes de tendance ne lisent que les 2d dernières dates (d parmi 7, 30, 90, 180, section 10) : la page choisit le plus petit d tel que 2d − 1 ≥ (aujourd'hui − du) + n, si bien que les deux périodes sont lues en entier, puis garde les lignes de ces dates. Si même d = 180 ne suffit pas (les deux périodes remontent au-delà de 359 jours), la période est refusée et l'écran dit pourquoi : aucune date non lue n'est comptée pour zéro. Les sommes, écarts, tendances et pics sont ceux de la section 10, sur ces dates.
Ce qui ne suit pas la période choisie le dit en une ligne : les réponses qui lisent les coûts chargés avec le plan (période FinOps) ou l'activité du chargement, et, quand les deux dates sortent en tout ou partie des coûts chargés, la ligne le précise (« rechargez les coûts sur ces dates »). « Ce qui a le plus changé » et « Ce qui coûte le plus » comparent des périodes glissantes (trend-movers) : pour deux dates choisies, ils lisent les d dernières dates contre les d d'avant, et la puce de filtre l'annonce. Dans l'explorateur, la dépense par jour est réduite aux dates choisies qui sont dans les coûts chargés. Les lecteurs et écrivains distincts d'une table sont comptés par la requête sur ses périodes glissantes : ils ne sont pas affichés pour deux dates choisies.
Questions sur un actif. Sous « Analyse détaillée », chaque actif a ses questions, chacune répondue avec ce que YALineo a déjà ; une donnée absente est « non lu », jamais 0.
| Actif | Question | Chiffres de la réponse |
|---|---|---|
| Table | Qui la lit ? | Les actifs du plan qui la lisent directement (tableaux de bord, jobs, notebooks, requêtes ; section 6, liens directs), les tables écrites à partir d'elle, ses lectures observées sur la fenêtre d'activité |
| Table | Dernière écriture | La dernière écriture observée dans le lineage, son âge, le retard sur son rythme propre (section 10.1) |
| Table | Rafraîchissement et lecture | rafraîchissement(T), lecture(T) (section 5) et leur somme sur la période FinOps ; l'équivalent mensuel du rafraîchissement |
| Table | Qui l'écrit ? | Les charges dont une part est attribuée à son rafraîchissement (section 5), puis les producteurs du lineage ; montant par charge |
| Table | Lectures ou écritures | trend-table sur la période choisie : lectures et écritures, chacune contre la période d'avant ; le verdict compare les deux pourcentages (seuil de 5 %) |
| Table | Coût de ses lecteurs | Σ coût(W) des lecteurs facturés (jobs, notebooks) sur la période FinOps : leur coût entier, jamais la part de la table ; et lecture(T) attribuée sur SQL warehouse |
| Table | Ce qui dépend d'elle | Le nombre d'actifs en aval (parcours complet), tables et usages |
| Job | Exécutions et échecs | Exécutions et échecs de la charge sur la période FinOps (section 4), le taux échecs / exécutions ; sinon trend-runs sur la période choisie |
| Job | Coût des échecs | Le coût des échecs (section 6) et sa part du coût de la charge |
| Job | Durée | Durée moyenne de trend-runs sur la période choisie contre la précédente (section 10) |
| Job, pipeline | Coût par exécution ou par mise à jour | coût(W) / exécutions(W) sur la période FinOps (dérivé) |
| Job, pipeline | Ce qu'il écrit | Les tables auxquelles une part de son coût est attribuée (section 5), sinon celles du lineage ; la part attribuée |
| Job, pipeline | Évolution du coût | trend-workload : coût de la période choisie contre la précédente |
| Job | Identité d'exécution | run_as de la charge (section 4) |
| Pipeline | Qui lit ce qu'il écrit | Les lecteurs directs, sur le plan, des tables qu'il écrit |
Comparer des actifs. Jusqu'à six tables, jobs ou pipelines sur un même graphique, sur la période choisie : pour une charge, coût, DBU ou exécutions facturées (trend-workload) ; pour une table, lectures ou écritures (trend-table). Une mesure qui ne s'applique pas à un actif le dit, sans valeur. Les regroupements sont les mêmes pour tous (section 10) ; le tableau donne pour chaque actif le total de la période, celui de la précédente et l'écart. Chaque actif reçoit une couleur au moment où il est ajouté (la première libre des six) et la garde tant qu'il reste comparé : retirer ou réordonner les autres ne la change pas. Chaque série est la somme des lignes de sa requête : la somme de ses regroupements égale son total.
Analyses enregistrées. Une analyse de la page garde son nom (80 caractères au plus), la question, la vue de l'explorateur, la période choisie, l'actif analysé, les actifs comparés avec leurs couleurs, la mesure et le graphique de la comparaison, la configuration de la carte des coûts et les filtres FinOps, avec les dates des coûts chargés ; jamais un montant : rouverte, elle est recalculée. Elle reste sur l'appareil, workspace par workspace (yalineo.an33:<adresse du workspace>), avec la règle de conservation des plans, trente au plus ; « Tout effacer » et l'oubli d'un workspace l'effacent. Elle est nettoyée champ par champ à chaque lecture et à chaque écriture (clés connues seulement, listes bornées, aucune clé de prototype, aucun caractère de contrôle ni de sens d'écriture). Supprimée, elle revient à sa place avec « Annuler » pendant quelques secondes.
Images et rapport. Un graphique se télécharge en SVG ou en PNG (dessiné dans la page) avec ses valeurs ; la page entière en un fichier HTML autonome : ses phrases, ses questions et réponses, chaque graphique en image et ses valeurs en tableau, sans script ni ressource extérieure, chaque texte échappé.
Vérification : tests/v0330-analytics33.test.mjs contrôle les deux périodes de deux dates, la couverture des requêtes, les réponses par actif face aux index de coûts et au lineage, la stabilité des couleurs, le nettoyage des analyses enregistrées et l'échappement du rapport.
11. Analyse d'impact : gravité et rafraîchissement mensuel
La gravité d'un actif touché par un changement suit une règle à points, affichée avec ses raisons :
| Raison | Points |
|---|---|
| Tableau de bord | 3 |
| Requête ou notebook (lus par des personnes) | 2 |
| Couche gold ou platinum | 2 |
| Couche silver | 1 |
| 100 lectures ou plus sur la période | 2 |
| 10 lectures ou plus | 1 |
Tag de certification (certif, trusted, golden) | 2 |
Tag de données sensibles (pii, personal, sensitive, confidential, gdpr, rgpd) | 1 |
| Directement en aval | 1 |
| Scénario « suppression » (d'une table ou d'une colonne) ou « renommage » d'une colonne : lecteur direct (il casse tout de suite) | 2 |
| Scénario « retard » : table rafraîchie chaque jour ou plus souvent | 1 |
Critique à 5 points et plus, élevé à 3 ou 4, moyen à 1 ou 2, faible à 0.
Rafraîchissement mensuel des tables touchées : Σ rafraîchissement(T) × (365 / 12) / N des tables touchées, au rythme de la période FinOps. Ce n'est pas une perte chiffrée : c'est ce que ces tables mobilisent chaque mois, à mettre en regard d'une panne. C'est l'attribution de la section 5 ; il n'y a pas de double compte entre tables, chacune n'apparaissant qu'une fois dans l'aval.
11.1 Ce que l'analyse lit (0.23)
L'analyse lit tout le plan chargé : toute la fenêtre de lineage du chargement (system.access.table_lineage sur link_days jours jusqu'à la date du chargement, liens plus vus récemment compris ; en mode analyste, ce que l'API de lineage rend pour les tables explorées), les catalogues du chargement (un lien est lu quand sa source ou sa cible y est), tous les types d'actifs du plan et tout l'aval (pour un job ou un pipeline : les tables qu'il écrit, puis leur aval). Les filtres de la carte et de la vue des dépendances (période des liens, catalogue, schéma, natures de liens, table suivie, sens, profondeur) ne s'y appliquent pas ; la page le dit toujours et nomme ceux qui sont réglés. Les limites du chargement sont dites aussi : tables supprimées depuis (leurs liens raccordés), lineage coupé à sa limite de lignes, lecteurs, lectures ou tags non lus.
11.2 Une colonne : trois réponses, jamais mélangées (0.23)
Pour une colonne d'une table, l'analyse lit à la demande system.access.column_lineage (sur la fenêtre de lineage du réglage) pour la table et ses tables en aval, les plus proches d'abord, 2 000 au plus. Chaque actif de l'aval reçoit une seule réponse :
Depuis la relecture de la 0.34.3, la lecture comprend aussi les tables des catalogues internes de Databricks que traversent les liens raccordés de cet aval (section 6.10) : la chaîne de colonnes passe par elles comme avant la 0.34.3. Une telle table n'est jamais un actif de la réponse ni une colonne dérivée, et la traverser ne compte pas de lien de colonne : une table qui la suit garde la réponse « relation observée », à la distance où le plan la montre.
| Réponse | Règle |
|---|---|
| Relation observée | un lien de colonne part de cette colonne et arrive à l'actif, directement ou par d'autres colonnes |
| Dépendance de table à vérifier | la relation de tables est observée, mais aucun lien de colonne n'est connu entre la table et l'actif (un tableau de bord, une requête ou un notebook n'en a jamais) |
| Couverture insuffisante | des liens de colonne de la table arrivent à l'actif, aucun de cette colonne : « Aucun lien de cette colonne observé dans les données disponibles : couverture à confirmer » |
Les points sont ceux du tableau ci-dessus, avec la distance comptée en liens de colonne pour une relation observée. Une réponse « Couverture insuffisante » reste au niveau faible, avec la raison « gravité non évaluée, couverture à confirmer » : ses points disent seulement ce que l'actif pèserait s'il était touché, et le point « lecteur direct » ne s'y applique pas. Les propriétaires à prévenir et le rafraîchissement mensuel des tables touchées ne comptent que les relations observées et les dépendances à vérifier.
Les trois changements d'une colonne ont chacun leur plan : renommer (colonne de transition ou vue de compatibilité, colonnes dérivées, tableaux de bord et requêtes qui citent l'ancien nom, retrait de l'ancien nom après une période sans lecture qui le cite), changer le type (conversions des colonnes dérivées, agrégats et jointures comparés sur un environnement de test, formats et filtres des tableaux de bord), supprimer (qui lit encore la table : ni le lineage ni system.query.history ne disent quelle colonne est lue ; calculs à retirer ; période d'observation ; script de retour arrière). S'y ajoutent la vérification à la main des dépendances à vérifier et l'avertissement de couverture.
Exports CSV : « Exporter cette vue » écrit les lignes affichées après les filtres de gravité, de type et de recherche ; « Exporter toutes les données disponibles » écrit toutes les lignes. Chaque ligne dit de quel export elle vient, la fenêtre de lineage, que les filtres du graphe ne sont pas appliqués (et lesquels sont réglés), les filtres de la vue, la source et l'instantané. Le rafraîchissement mensuel des lignes comptées (counted_at_stake = yes) est arrondi au centime par la méthode du plus grand reste, si bien que ces lignes tombent juste sur leur total ; une table sans coût connu, un tableau de bord ou un notebook ont une cellule vide, jamais 0.
12. Les fondements officiels de la méthode
Chaque règle de ce document s'appuie sur la documentation publique de Databricks et de Microsoft, relue pour la 0.18 (octobre 2026) ; les cinq dernières lignes, ajoutées pour la 0.28, ont été lues le 28 octobre 2026 et vérifiées le 29 octobre 2026. Le tableau dit ce que la source établit et ce que YALineo en fait ; une règle qui relève d'une convention le dit (section 1).
| Règle de YALineo | Ce que dit la source officielle | Source |
|---|---|---|
Le coût d'une ligne d'usage est usage_quantity × pricing.effective_list.default (section 3) | La clé effective_list « résout prix catalogue et prix promotionnel et contient le prix catalogue effectif utilisé pour calculer le coût » | Microsoft Learn, Pricing system table reference |
| Le prix retenu est celui en vigueur à la fin de la ligne d'usage (section 3) | L'exemple officiel « Join the pricing with usage tables » joint usage_end_time >= price_start_time et usage_end_time < price_end_time | Microsoft Learn, Monitor costs using system tables |
| Les retraits et reprises de Databricks sont additionnés (section 3) | Une correction ajoute un retrait (RETRACTION, quantité négative qui annule la ligne d'origine) puis une reprise (RESTATEMENT) : la somme des quantités donne l'usage corrigé | Microsoft Learn, Billable usage system table reference |
| Le dernier jour d'une période est « en cours » pendant 12 heures (section 7.1) | « Les enregistrements sont en général disponibles sous 12 heures » | Microsoft Learn, Billable usage system table reference |
Une charge est identifiée par usage_metadata (job, pipeline, warehouse, notebook, cluster, endpoint, app) (section 4) | Le champ usage_metadata décrit les ressources et objets impliqués dans l'usage | Microsoft Learn, Monitor costs using system tables |
| Le coût des machines du calcul classique n'est pas dans le total FinOps (section 3) | Une réservation Azure Databricks (DBCU) « ne couvre que l'usage DBU ; le calcul, le stockage et le réseau sont facturés à part » | Microsoft Learn, What are Azure Reservations? et Optimize Azure Databricks costs with a prepurchase |
| Le temps de calcul d'une requête répartit le coût d'un warehouse, heure par heure (section 5.4) | total_task_duration_ms est « la somme des durées de toutes les tâches », sur tous les cœurs de tous les nœuds ; start_time et end_time bornent la requête | Microsoft Learn, Query history system table reference |
| Le coût d'une exécution de job ou de pipeline est la somme de ses lignes d'usage (section 5.2) | usage_metadata.job_run_id et usage_metadata.dlt_update_id identifient l'exécution facturée | Microsoft Learn, Billable usage system table reference |
| Les tables écrites par une exécution viennent du lineage (section 5.2) | entity_metadata porte job_info (job_id, job_run_id) et dlt_pipeline_info (dlt_pipeline_id, dlt_update_id) de l'entité qui écrit | Microsoft Learn, Lineage system tables reference |
| Une écriture sans lineage laisse le coût non attribué, jamais attribué à tort (section 8, limite 2) | Les tables de lineage sont « un sous-ensemble de tous les événements de lecture et d'écriture » ; un enregistrement n'est émis que si le lineage peut être déduit | Microsoft Learn, Lineage system tables reference |
| Une période d'un an au plus | Rétention gratuite de 365 jours pour l'usage, les jobs, l'historique des requêtes et le lineage | Microsoft Learn, System tables reference |
| Les heures des machines (Calculateur) sont lues sur 90 jours au plus, et leurs DBU sur les mêmes dates (section 13.4) | system.compute.node_timeline : rétention gratuite de 90 jours ; un nœud qui a tourné moins de 10 minutes peut manquer ; ni serverless ni SQL warehouses | Microsoft Learn, System tables reference et Compute system tables reference |
| Une réservation se paie chaque heure, utilisée ou non (section 13.3) | Une réservation est « à utiliser ou perdre » heure par heure | Microsoft Learn, How the Azure reservation discount is applied to virtual machines |
| La répartition des coûts partagés suit des modèles reconnus (section 5) | Répartition proportionnelle à une mesure d'usage, égale à défaut, non-attribution explicite | FinOps Foundation, Allocation |
| Seules les lectures directes comptent ; une lecture à travers une vue revient à la vue, puis une fois à ses sources (sections 5.8 et 6.8) | direct_access : « When false, the source is an intermediate dependency discovered through view expansion » | Microsoft Learn, Lineage system tables reference |
| Une écriture compte une fois par événement, quel que soit le nombre de ses lignes (section 6.8) | event_id : « Multiple rows may share the same event_id if they were generated by the same event » | Microsoft Learn, Lineage system tables reference |
Les fenêtres du lineage partent de la date UTC envoyée par YALineo, pas de current_date() (section 6.8) | TIMEZONE : « The system default is UTC » ; un administrateur peut le régler autrement | Microsoft Learn, TIMEZONE |
La fraîcheur ne vient que d'une écriture observée, jamais de last_altered (section 6.9) | LAST_ALTERED : « Timestamp when the relation definition was last altered in any way » | Microsoft Learn, TABLES (information schema) |
| Une table que l'inventaire ne liste pas quitte le plan, ses liens sont raccordés à part (section 6.10) | « The rows returned are limited to the relations the user is privileged to interact with » | Microsoft Learn, TABLES (information schema) |
Le produit Genie vient de usage_metadata.genie.surface ; les DBU de GENIE_FREE_USAGE sont à part, jamais dits sans prix, et ne baissent pas le prix moyen d'un DBU (sections 3, 4.3 et 13.4) | surface « Identifies which Genie product generated the usage » ; GENIE_FREE_USAGE « does not carry a list price » | Microsoft Learn, Monitor and understand your Genie cost |
| La synchronisation d'un index AI Search compte en AI Search, jamais en pipeline (section 4.3) | dlt_pipeline_id est rempli pour les pipelines et les fonctions qui en utilisent, « such as materialized views, online tables, AI Search indexing, and Lakeflow Connect » | Microsoft Learn, Billable usage system table reference |
13. Calculateur : estimer une charge, nouvelle ou mesurée
Depuis la 0.18, le troisième volet, « Calculateur », dit ce que coûterait une charge de travail sur Azure, AWS ou GCP : une charge nouvelle, décrite par l'utilisateur, ou une charge mesurée par le volet FinOps dont on change le nombre d'exécutions, le volume ou la façon de payer les machines. Ce sont des chiffres dérivés (section 1), jamais des mesures : chaque page le dit sous son titre, et le Calculateur n'ajoute aucun chiffre aux écrans FinOps. Il ne lance aucune requête : il lit les coûts déjà chargés par le volet FinOps et un relevé de prix publics embarqué dans l'extension.
13.1 Une estimation et ses charges
Une estimation réunit des charges (60 au plus) sur un cloud, une région et un plan Databricks (Premium ou Enterprise ; Premium seulement sur Azure), avec deux remises. Chaque charge est chiffrée seule, puis :
- chaque montant d'une charge (coût des DBU, coût des machines) est arrondi au centime une fois ; son total est leur somme ;
- le total de l'estimation est la somme des totaux de ses charges, au centime ; par an = 12 × par mois ;
- une charge qui ne peut pas être chiffrée (prix absent, type de machine inconnu, région non choisie) n'est jamais comptée pour zéro : elle est listée « non chiffré » avec la raison, et le total se dit « partiel ».
Les estimations (30 au plus) restent sur l'appareil, vérifiées à la lecture (nombres bornés, noms et identifiants contrôlés, aucune clé de prototype), et suivent la règle de conservation des réglages : effacées à la fermeture du navigateur par défaut, gardées sur le disque si l'utilisateur l'a choisi. Depuis la 0.23, une estimation garde aussi les valeurs des prix qu'elle utilise et la date de ses mesures : elle se rouvre telle qu'enregistrée, au centime (section 13.8).
État du chiffrage (0.23). Chaque estimation porte un état, avec ce qui lui manque listé charge par charge :
| État | Quand |
|---|---|
| chiffrée | chaque charge est chiffrée avec toutes les valeurs dont elle a besoin |
| partiellement chiffrée | une part existe sans prix : un prix de DBU ou de machine absent du relevé, un coût mesuré sur un autre cloud |
| hypothèses manquantes | une valeur reste à saisir : la région, un type de machine ou une taille connus du relevé, le coût des machines d'une charge mesurée ou d'un warehouse, des DBU par exécution, une mesure actuelle illisible |
« Hypothèses manquantes » l'emporte sur « partiellement chiffrée ». Une région absente compte une fois, pas une fois par charge. Deux autres listes l'accompagnent sans changer l'état : les hypothèses à vérifier (une capacité déjà achetée, section 13.3 ; une durée tirée d'un essai ; des leviers d'exécutions ou de volume, section 13.4) et ce qui est hors périmètre par règle (disques et réseau des machines classiques, section 13.6). Un job ou un pipeline serverless sans DBU par exécution n'est plus compté pour 0 : il est « non chiffré », avec la valeur à saisir.
13.2 Les prix et leur origine
Chaque entrée d'un calcul porte son origine, affichée à côté du chiffre :
| Origine | Ce que c'est |
|---|---|
| Prix public | Le relevé embarqué dans l'extension, à sa date |
| Mesuré | Lu dans ce workspace par le volet FinOps : system.billing.usage (DBU, coût, exécutions) et system.compute.node_timeline (heures des machines) |
| Saisi | Tapé par l'utilisateur : un prix, une remise, un nombre d'exécutions, des DBU par exécution |
Le relevé (extension/lib/prices/<cloud>.mjs, écrit par tools/cloud-prices.mjs, jamais à la main) vient de données publiques :
| Cloud | DBU : types de machines, DBU par heure, Photon, prix d'un DBU par produit et par plan | Prix des machines (Linux, par heure) |
|---|---|---|
| Azure | Données du calculateur de prix Azure Databricks de Microsoft | Données du calculateur de machines virtuelles de Microsoft : à l'usage, spot, réservé 1 an et 3 ans |
| AWS | Données du calculateur de prix de Databricks (AWS) | AWS Price List (EC2, location partagée, sans logiciel ni licence) : à la demande, réservations standard sans paiement initial 1 an et 3 ans ; spot : données de la page des prix spot d'AWS |
| GCP | Données du calculateur de prix de Databricks (GCP) | Non embarqués : Google ne les publie que par une API à clé (Cloud Billing Catalog API). L'utilisateur les saisit |
L'extension n'appelle jamais ces services. Le mainteneur refait le relevé avec node tools/cloud-prices.mjs, qui vérifie chaque nom (types de machines, régions) et chaque nombre (prix positifs et inférieurs à 1 000 par heure), et écarte un prix spot supérieur au prix à l'usage du même type et de la même région (deux sources qui se contredisent, par exemple une page spot pas encore mise à jour après une baisse de prix : deux types GPU AWS au relevé du 15 octobre 2026). Une alerte hebdomadaire (.github/workflows/cloud-prices.yml) compare les prix publics du jour au relevé et ouvre un ticket quand ils changent (le spot, qui bouge chaque jour, est compté à part). Un relevé de plus de 90 jours est signalé à l'écran.
Machines des SQL warehouses Classic et Pro. Databricks documente, pour chaque cloud, les machines d'un cluster de warehouse : un driver dont le type suit la taille, et des workers tous du même type (Azure Standard_E8ds_v4, AWS i3.2xlarge, GCP n2-highmem-8) :
| Taille | Workers | Driver Azure | Driver AWS | Driver GCP |
|---|---|---|---|---|
| 2X-Small | 1 | Standard_E8ds_v4 | i3.2xlarge | n2-highmem-8 |
| X-Small | 2 | Standard_E8ds_v4 | i3.2xlarge | n2-highmem-8 |
| Small | 4 | Standard_E16ds_v4 | i3.4xlarge | n2-highmem-16 |
| Medium | 8 | Standard_E32ds_v4 | i3.8xlarge | n2-highmem-32 |
| Large | 16 | Standard_E32ds_v4 | i3.8xlarge | n2-highmem-32 |
| X-Large | 32 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
| 2X-Large | 64 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
| 3X-Large | 128 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
| 4X-Large | 256 | Standard_E64ds_v4 | i3.16xlarge | n2-highmem-64 |
Les DBU par heure d'une taille (de 4 pour 2X-Small à 528 pour 4X-Large) viennent des mêmes données publiques de prix et de la page Serverless DBU consumption by SKU de Microsoft.
Prix saisis et remises. Un prix saisi (DBU d'un produit, machine d'un type et d'un paiement) remplace le prix public pour ce cloud et s'affiche « saisi ». Deux remises, en pourcentage de 0 à 90, s'appliquent au prix catalogue : sur les DBU (contrat Databricks, par exemple des unités prépayées) et sur les machines (contrat du cloud). Le spot et les réservations ont déjà leur propre prix : la remise machines s'applique aussi sur eux, comme sur une facture qui remise tous les compteurs ; à régler à 0 si le contrat ne couvre pas ces prix.
13.3 Estimer une charge nouvelle
H, les heures de fonctionnement par mois, se disent de trois façons : en exécutions (exécutions par jour × jours par mois × minutes par exécution ÷ 60), en heures par jour (heures par jour × jours par mois) ou en heures par mois (saisies ; 730 pour un mois entier, la moyenne 365 × 24 ÷ 12). Les jours par mois valent par défaut ceux d'un mois moyen, 365 ÷ 12, comme dans le volet FinOps.
| Charge | DBU par heure | Machines par heure |
|---|---|---|
| Job, pipeline, cluster interactif (classiques) | dbu(driver) + w × dbu(worker), × multiplicateur Photon de la famille si coché | prix(driver, paiement du driver) + w × prix(worker, paiement des workers) |
| SQL warehouse Classic ou Pro | DBU(taille) × c | (prix(driver(taille)) + n(taille) × prix(worker)) × c |
| SQL warehouse serverless | DBU(taille) × c | 0 : les machines sont dans le prix du DBU |
| Job, pipeline serverless | sans objet : DBU par mois = DBU par exécution × exécutions | 0 |
-
w: le nombre moyen de workers (avec l'autoscaling, la moyenne) ;dbu(type): les DBU par heure du type de machine pour la famille de la charge (relevé) ; le driver est du même type que les workers sauf choix contraire, comme dans Databricks.c: le nombre moyen de clusters du warehouse ;n(taille): ses workers (tableau ci-dessus). - Coût des DBU = DBU par mois × prix d'un DBU du produit (jobs, calcul interactif, pipelines Core, Pro ou Advanced, SQL Classic, Pro ou serverless, jobs ou pipelines serverless) × (1 − remise DBU).
-
Coût des machines = machines par heure ×
H× (1 − remise machines). Total = coût des DBU + coût des machines. -
Spot : les workers en spot, le driver à l'usage. Databricks l'impose : avec des instances spot, « le premier nœud est toujours à la demande (le driver est toujours à la demande) » (Azure et AWS, Compute configuration reference). Le driver se paie donc à l'usage ou réservé, jamais en spot. Il en va de même pour un SQL warehouse Classic ou Pro : sa politique « Cost optimized » utilise surtout des instances spot et une instance à la demande (Databricks SQL release notes, 3 février 2022) ; le Calculateur paie donc ses workers en spot et son driver à l'usage. Le cloud peut reprendre une machine spot : le travail repart alors sur des machines à l'usage. L'utilisateur saisit la part des heures relancées à l'usage
f(0 % par défaut, dit à l'écran) ; le prix horaire d'un worker devient(1 − f) × prix spot + f × prix à l'usage. YALineo ne devine pas ce taux. -
Réservation, deux modes, choisis à l'écran (depuis la 0.20 ; l'écran donne toujours l'autre mode à côté, avec le coût des machines et les heures inutilisées par machine réservée) :
-
nouvel engagement (par défaut) : la réservation est achetée pour cette charge. Microsoft rappelle qu'une réservation est « à utiliser ou perdre » heure par heure : chaque machine réservée se paie
max(H, 730)heures par mois, utilisées ou non ; les machines non réservées (par exemple un driver à l'usage) se paient leurs heures ; -
capacité déjà achetée (appelée « réservation existante » avant la 0.23) : elle est déjà achetée et a des heures libres ; cette charge compte ses heures au tarif réservé (
Hheures). - La règle et sa source. Microsoft Learn, How the Azure reservation discount is applied to virtual machines (lu le 24 octobre 2026) : la remise d'une réservation est « use-it-or-lose-it » ; elle s'applique heure par heure, une heure réservée sans machine qui tourne est perdue et ne se reporte pas, et l'usage au-delà de la réservation se paie à l'usage. La règle est écrite pour Azure ; sur AWS et GCP, l'écran dit qu'elle est à vérifier dans les conditions du cloud. L'écran la donne à côté du choix, avec sa source.
- Hypothèse à vérifier. Pour une capacité déjà achetée, le chiffre suppose que ses heures libres sont disponibles aux heures où la charge tourne. YALineo ne lit pas l'usage horaire des réservations : l'hypothèse est listée « à vérifier » dans l'estimation, jamais tenue pour acquise ; une heure non couverte se paierait à l'usage.
-
nouvel engagement (par défaut) : la réservation est achetée pour cette charge. Microsoft rappelle qu'une réservation est « à utiliser ou perdre » heure par heure : chaque machine réservée se paie
- Photon : le relevé donne le multiplicateur de DBU par famille (par exemple 2,5 pour les jobs sur Azure, 2 pour le calcul interactif). L'accélération qu'apporte Photon dépend de la charge et n'est pas connue : l'utilisateur la reflète dans la durée. Si Photon n'a pas de multiplicateur pour la famille du type choisi, l'estimation se fait sans, et l'écran le dit.
-
Dimensionner à partir du volume : Databricks facture le temps de calcul (des DBU par heure de machine), pas les gigaoctets ni les lignes ; le volume compte à travers la durée et le nombre de workers. Le type d'ingestion règle la charge et son usage : batch planifié, Auto Loader incrémental planifié et pipeline déclenché se comptent en exécutions ; streaming continu et pipeline continu tournent tout le mois (730 h), et c'est alors le nombre de workers que le volume décide. Pour une exécution, la durée se déduit d'une exécution de référence mesurée par l'utilisateur (un essai, ou un job comparable : volume traité
V₀, duréeT₀, workersw₀) par une règle proportionnelle, dite comme telle :T = T₀ × (V ÷ V₀) × (w₀ ÷ w), oùVest le volume par exécution etwles workers de la charge. Elle suppose que la durée suit le volume et se partage également entre les workers (le meilleur cas). Aucun débit n'est supposé : sans les quatre chiffres, rien n'est calculé et l'écran dit ce qui manque. La durée n'est appliquée qu'à la demande (« Utiliser cette durée ») et le calcul pas à pas dit d'où elle vient. Depuis la 0.23, un récapitulatif s'affiche d'abord : le paramètre transféré (minutes par exécution, avant et après, et l'origine de la durée), les réglages gardés avec la charge (volume, essai, workers), les limites gardées (règle proportionnelle au mieux ; la durée ne suit pas d'office un changement ; le démarrage du cluster compté seulement s'il était dans l'essai ; durée plafonnée à 44 640 minutes) et l'effet sur le montant de la charge et de l'estimation par mois, chiffré comme la page l'affiche, avec l'état du chiffrage après. Rien ne change avant « Confirmer et appliquer » ; la charge garde ensuite tout le dimensionnement, avec sa date. Si le volume ou les workers changent ensuite, la durée utilisée ne change pas d'office : le calcul pas à pas ne montre plus le dimensionnement comme son origine, et la ligne d'aide donne la nouvelle durée à appliquer. -
Serverless : un job ou un pipeline serverless n'a pas de taille. Ses DBU par exécution se reprennent d'une charge serverless mesurée (
DBU ÷ exécutionssur la période, origine « mesuré ») ou se saisissent. - Les quatre paiements : la même charge est chiffrée à l'usage, en spot (driver à l'usage, part relancée comprise), réservée 1 an et 3 ans dans le mode de réservation choisi ; la moins chère est marquée et l'écart à l'usage donné. Avec un nouvel engagement, une charge à temps partiel n'est donc jamais « la moins chère » en réservé par la seule grâce du tarif horaire.
- Changer de cloud garde les charges : chaque type de machine est remplacé par le moins cher du nouveau cloud qui a au moins autant de vCPU et de mémoire, et la région par la plus proche dans le même ensemble géographique (par exemple East US, us-east-1, us-east4) ; sans région proche, aucune n'est choisie et l'écran la demande. Le message le dit : c'est une machine proche (vCPU et mémoire), pas la même ; processeur, disque et réseau diffèrent, et la durée d'une exécution est à vérifier par un essai.
- Ce qui manque n'est jamais remplacé : un type de machine inconnu du relevé, un prix absent dans la région, une taille inconnue donnent « non chiffré » avec la raison et la saisie qui le complète.
- Cas pratiques (page Estimations) : six situations fictives, chacune une estimation prête à ouvrir avec son guide (le besoin, les informations à réunir, quoi essayer, quoi retenir). Leurs entrées sont des hypothèses de l'exemple, dites dans le guide et les notes de chaque charge ; elles sont chiffrées par les formules ci-dessus, sans autre règle. Deux durées viennent d'un volume par la règle proportionnelle : 40 millions de lignes au rythme de 10 millions en 18 minutes sur 4 workers (72 minutes sur 4 workers), et 2 000 Go au rythme de 100 Go en 25 minutes sur 8 workers (250 minutes sur 16 workers). Sur GCP, leurs machines demandent leur prix comme toute charge.
13.4 Une charge mesurée et ses leviers
Pour une charge W du volet FinOps mesurée sur N jours, ramenée à un mois moyen (× (365 ÷ 12) ÷ N) :
- DBU et exécutions : mesurés (section 4) ;
- coût des DBU : son coût au prix catalogue (avant la remise du volet FinOps) × (1 − remise DBU de l'estimation) ;
-
heures des machines : mesurées par type de machine et rôle (driver ou worker) dans
system.compute.node_timeline(requête facultativeyalineo:vmhours), somme des durées des lignes de chaque cluster. La table ne garde que 90 jours : les heures sont lues sur la partie de la période qu'elle couvre (vm_daysdates, au plus 90). Depuis la 0.20, les DBU et leur coût sont lus sur ces mêmes dates : la charge est alors ramenée à un mois survm_days(× (365 ÷ 12) ÷ vm_days), et ses DBU et ses heures décrivent les mêmes jours ; -
cluster partagé : les heures d'un cluster utilisé par plusieurs charges (un cluster interactif où tournent aussi des jobs) sont partagées entre elles au prorata des DBU que chacune y a consommés sur ces dates (
heures × DBU(charge, cluster) ÷ DBU(cluster)). Une heure n'est comptée qu'une fois, et un cluster utilisé à 51 % et 49 % n'est plus donné entier au premier ; -
couverture : la part des DBU de la charge consommés sur des clusters présents dans
node_timeline. Un nœud qui a tourné moins de 10 minutes peut manquer à la table : sous 100 %, l'écran dit que le reste n'a pas d'heures de machine dans le chiffre ; -
coût des machines : ces heures × prix du relevé pour le type et le paiement choisis × (1 − remise machines). En spot, la part relancée à l'usage suit la section 13.3. En réservé, dans le mode « nouvel engagement », chaque type et rôle se paie
⌈heures ÷ 730⌉ × 730heures (autant de machines réservées que les heures en demandent, payées tout le mois) ; dans le mode « réservation existante », ses heures. C'est une estimation au prix public, pas la facture du cloud (contrat, disques, réseau).
Les leviers : un multiplicateur d'exécutions a et un multiplicateur de volume v. Les DBU, leur coût et les heures des machines du scénario sont ceux d'aujourd'hui × a × v, les exécutions × a. C'est une règle proportionnelle, affichée comme telle : elle multiplie aussi les temps fixes (démarrage du cluster, petites tables), si bien qu'elle donne un chiffre un peu haut quand le volume croît ; un plus gros volume peut aussi demander une autre taille de cluster ou déborder de la mémoire, ce qu'elle ne prévoit pas. C'est un scénario, pas une prévision.
Une charge serverless n'a pas d'heures de machines : son prix de DBU les comprend. Une charge classique sans heures lues (requête yalineo:vmhours refusée, ou SQL warehouse Classic ou Pro, absent de node_timeline) a des machines au coût inconnu : la charge est « non chiffrée », jamais comptée pour zéro, jusqu'à ce que l'utilisateur saisisse le coût de ses machines sur un mois (facture du cloud, origine « saisi »). Ce coût suit ensuite les leviers comme les DBU (× a × v), puis la remise machines s'applique.
Depuis la 0.23, une charge mesurée garde aussi le dernier jour couvert par ses mesures et l'identifiant de son workspace : la page dit « mesures jusqu'au … », et « Recalculer avec les données actuelles » retrouve la même charge (même clé, même workspace) dans les coûts du moment. Une charge ajoutée avant la 0.23 n'a pas cette date : elle est dite « sans date », et retrouvée par sa seule clé, ce que l'écran dit aussi.
Facturation illisible. Quand system.billing.usage n'est pas lisible avec les droits de l'utilisateur, la page Charges mesurées dit « donnée indisponible » (aucune liste vide présentée comme un résultat, aucun montant à 0), le prix moyen mesuré d'un DBU et le repère mesuré des DBU par exécution aussi. Une estimation garde ses dernières mesures connues, montrées avec leur date ; « Recalculer avec les données actuelles » est alors désactivé, avec la raison.
Une charge mesurée garde le cloud de son workspace : son coût catalogue est celui de ce cloud. Si l'estimation passe sur un autre cloud, la charge devient « non chiffrée » avec la raison (son coût ne vaut pas ailleurs) ; elle reprend son prix au retour sur son cloud, ou se décrit comme une charge nouvelle sur l'autre.
Prix moyen mesuré d'un DBU (page Prix et remises) : pour chaque produit facturé (le produit principal de chaque charge, section 4), Σ coût catalogue des lignes en DBU ÷ Σ DBU de ses charges sur la période. Depuis la 0.20, le numérateur ne compte que les lignes dont l'unité est le DBU : l'usage dans d'autres unités (par exemple des jetons) ne gonfle plus le prix d'un DBU. Il sert de repère pour saisir son prix, jamais de prix appliqué en silence. Depuis 0.28, le dénominateur ne compte que les DBU facturés : les DBU gratuits de Genie (SKU GENIE_FREE_USAGE, qui « does not carry a list price », section 4.3) n'abaissent plus le prix moyen, ils sont dits à côté (« dont X DBU gratuits ») ; un produit qui n'a que des DBU gratuits n'a pas de prix mesuré. Une charge dont des DBU facturés n'ont aucun coût lu (sans prix catalogue) est laissée de côté, comme un job qui ne fait que lancer d'autres jobs. Exemple : une ligne Genie de 100 DBU dont 60 gratuits et 40 facturés à 0,07 $ donnait 0,028 $ par DBU, elle donne 0,07 $.
13.5 Comparer et exporter
Deux à quatre estimations se comparent côte à côte, chacune avec ses propres prix et remises (ceux qu'elle a gardés) : total par mois et par an, DBU, machines, et l'écart à la moins chère. Depuis la 0.23, la comparaison montre l'état du chiffrage de chacune (section 13.1) avec ce qui lui manque, ses données gardées, et si elle peut être désignée la moins chère : seule une estimation chiffrée en entier est classée ; une estimation partiellement chiffrée ou avec des hypothèses manquantes ne l'est jamais (ni « la moins chère », ni écart), même si son total partiel est plus bas. Il en faut au moins deux chiffrées pour en désigner une ; sinon, la page dit pourquoi aucune ne l'est. Le Calculateur n'a ni budget ni heure limite : aucune contrainte n'est évaluée. Une estimation s'exporte en CSV (une ligne par charge avec une colonne priced, puis le total des charges chiffrées, qui dit combien sont laissées de côté ; nombres au centime ; depuis la 0.23, deux dernières colonnes : state, l'état de chaque charge et de l'estimation, et data, les données avec lesquelles elle est calculée : prix gardés et date de leur relevé, dernier jour des mesures, ou données actuelles) ou se copie en Markdown (avec ses notes, le total partiel dit comme tel, et depuis la 0.23 son état, ce qui manque, les hypothèses à vérifier, ce qui est hors périmètre et ses données) ; une cellule qui commence par =, +, -, @, une tabulation ou un retour chariot, même après des blancs, n'est jamais une formule (section 6.2), et le Markdown neutralise ses caractères de mise en forme, ses adresses et ses mentions.
13.6 Ce que le Calculateur ne chiffre pas
- Les disques attachés aux machines (Azure attache par exemple un disque géré Premium SSD de 256 Go, facturé à l'heure, à chaque nœud d'un warehouse Classic ou Pro), le réseau, les adresses IP publiques, le stockage des données (sauf le stockage par défaut du serverless, Lakebase et AI Search, facturés au Go, et la brique de stockage de « Chiffrer un projet », au prix par Go saisi), les licences autres que Linux, les taxes.
- Les prix négociés au-delà des deux remises, les crédits, les prix d'un engagement de dépense (savings plan).
- Les variations de prix après la date du relevé ; le spot, qui change chaque jour.
- L'autoscaling au-delà d'une moyenne de workers et de clusters ; le temps de démarrage d'un cluster, sauf s'il est compté dans la durée saisie.
- Les machines de GCP, tant qu'elles ne sont pas saisies.
13.7 Sources officielles du Calculateur
- Microsoft Learn, SQL warehouse sizing, scaling, and queuing behavior (machines d'un warehouse Classic ou Pro par taille, disques attachés) : https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/warehouse-behavior
- Databricks, SQL warehouse sizing, scaling, and queuing behavior, AWS : https://docs.databricks.com/aws/en/compute/sql-warehouse/warehouse-behavior et GCP : https://docs.databricks.com/gcp/en/compute/sql-warehouse/warehouse-behavior
- Microsoft Learn, Serverless DBU consumption by SKU (DBU par heure des tailles de SQL warehouse) : https://learn.microsoft.com/azure/databricks/resources/pricing
- Microsoft Learn, Compute configuration reference (driver toujours à la demande avec des instances spot, type du driver) : https://learn.microsoft.com/azure/databricks/compute/configure ; Databricks, AWS : https://docs.databricks.com/aws/en/compute/configure
- Microsoft Learn, Databricks SQL release notes 2022, 3 février 2022 (politique spot d'un SQL warehouse : « Cost optimized » utilise surtout des instances spot et une instance à la demande) : https://learn.microsoft.com/azure/databricks/sql/release-notes/2022
- Microsoft Learn, What is Photon? (les types Photon consomment des DBU à un autre rythme) : https://learn.microsoft.com/azure/databricks/compute/photon
-
Microsoft Learn, Compute system tables reference (
node_timeline, nœuds de moins de 10 minutes) : https://learn.microsoft.com/azure/databricks/admin/system-tables/compute - Microsoft Learn, How the Azure reservation discount is applied to virtual machines (réservation « à utiliser ou perdre » heure par heure, pas de réservation pour le spot) : https://learn.microsoft.com/azure/cost-management-billing/manage/understand-vm-reservation-charges
- Microsoft Learn, Optimize Azure Databricks costs with a prepurchase (les unités prépayées ne remisent que les DBU) : https://learn.microsoft.com/azure/cost-management-billing/reservations/prepay-databricks-reserved-capacity
- Microsoft, Azure Databricks pricing : https://azure.microsoft.com/pricing/details/databricks/ ; Databricks, Pricing : https://www.databricks.com/product/pricing
- AWS, Amazon EC2 On-Demand Pricing : https://aws.amazon.com/ec2/pricing/on-demand/ ; Amazon EC2 Spot Instances Pricing : https://aws.amazon.com/ec2/spot/pricing/ ; AWS Price List bulk API : https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/using-ppslong.html
- Google Cloud, VM instance pricing : https://cloud.google.com/compute/vm-instance-pricing ; Cloud Billing Catalog API : https://cloud.google.com/billing/docs/how-to/get-pricing-information-api
Depuis la 0.24, pour « Chiffrer un projet de données » et ses outils de dimensionnement (sections 13.9 et 13.10), lus le 25 octobre 2026 sauf mention contraire :
- Microsoft Learn, Create a SQL warehouse (un cluster pour 10 requêtes simultanées ; arrêt automatique par défaut de 10 minutes en serverless et de 45 en Pro et Classic, minimum de l'interface de 5 minutes en serverless et de 10 en Pro et Classic ; vérifié le 29 octobre 2026) : https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/create
- Microsoft Learn, Genie consumption guide (le calcul des requêtes de Genie est facturé par le SQL warehouse, à part) : https://learn.microsoft.com/azure/databricks/genie/consumption-guide
- Microsoft Learn, Create and manage a Genie Agent (un SQL warehouse Pro ou Serverless est requis) : https://learn.microsoft.com/azure/databricks/genie-agents/set-up
- Microsoft Learn, Manage classic compute (arrêt automatique de 10 à 10 000 minutes ou désactivé ; un cluster inactif reste facturé) : https://learn.microsoft.com/azure/databricks/compute/clusters-manage
- Microsoft Learn, Serving concepts (concurrence provisionnée = requêtes par seconde × durée d'exécution du modèle) : https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/glossary
- Microsoft Learn, Create custom model serving endpoints (tailles Small, Medium, Large, concurrence en multiples de 4, répliques GPU) : https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/create-manage-serving-endpoints
- Microsoft Learn, Custom models overview (scale to zero après 30 minutes sans trafic) : https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/custom-models
- Microsoft Learn, Model Serving limits and regions (1 024 requêtes simultanées au plus par modèle) : https://learn.microsoft.com/azure/databricks/machine-learning/model-serving/model-serving-limits
- Microsoft Learn, Serverless DBU consumption by SKU (déjà cité : DBU par heure des tailles de warehouse ; en Model Serving, 1 DBU par heure et par requête simultanée en CPU, et les DBU par heure d'une réplique GPU : GPU_SMALL 10,48, GPU_LARGE 78,6, GPU_LARGE_2 157,2, GPU_LARGE_4 314,4) : https://learn.microsoft.com/azure/databricks/resources/pricing
- Microsoft Learn, VACUUM (fichiers supprimés gardés 7 jours par défaut) : https://learn.microsoft.com/azure/databricks/sql/language-manual/delta-vacuum
- Microsoft Learn, Work with table history (plus de rétention, plus de fichiers gardés et de stockage) : https://learn.microsoft.com/azure/databricks/tables/history
- Little, J. D. C. (1961), A Proof for the Queuing Formula: L = λW, Operations Research 9(3), 383 à 387, DOI 10.1287/opre.9.3.383
- Amdahl, G. M. (1967), Validity of the single processor approach to achieving large scale computing capabilities, AFIPS Conference Proceedings 30, 483 à 485, DOI 10.1145/1465482.1465560
13.8 Ce qu'une estimation garde, et ses deux façons de la rouvrir (0.23)
Une estimation enregistrée doit redonner le même résultat. Avant la 0.23, ses charges mesurées gardaient leurs mesures, mais ses prix étaient relus à chaque ouverture : un prix saisi changé plus tard, ou un relevé plus récent livré avec une nouvelle version, changeait en silence une estimation enregistrée.
Ce qu'elle garde. À chaque écriture, l'estimation garde les valeurs de chaque prix que ses charges utilisent : prix d'un DBU par produit, prix d'une machine par type et par paiement, DBU par heure d'un type de machine (Photon compris), DBU et machines d'une taille de warehouse ; chacun avec son origine (public ou saisi) et la date de son relevé. Ce qui est déjà gardé l'emporte ; un prix qu'elle ne tenait pas encore (une charge ajoutée, un autre paiement) est pris au relevé du jour et gardé à son tour ; un prix qui ne sert plus n'est plus gardé. Un changement de cloud, de région ou de plan est un réglage : les prix gardés pour l'ancien ne s'appliquent plus, ceux du nouveau sont gardés. Ses charges mesurées gardent leurs mesures (section 13.4), avec leur dernier jour et leur workspace. Le total par mois au moment de l'écriture est gardé aussi : si les mêmes données donnent un autre total plus tard (le calcul a changé avec une version), l'écran le dit.
Deux actions explicites.
- Rouvrir telle qu'enregistrée (par défaut) : ses réglages, ses remises, ses prix gardés et ses mesures gardées. C'est le même résultat qu'à l'enregistrement, au centime, et la page le dit.
- Recalculer avec les données actuelles : ses réglages et ses remises, les prix du relevé du jour avec les prix saisis aujourd'hui, et les mesures actuelles de ses charges (chaque charge mesurée retrouvée dans les coûts du moment, ses leviers gardés). Rien n'est remplacé : « Garder les données actuelles » le fait sur demande (les charges mesurées prennent leurs mesures actuelles, l'estimation garde désormais les prix du jour) ; « Rouvrir telle qu'enregistrée » revient au résultat gardé.
L'écart, partie par partie. Avec T(réglages, prix, mesures) le total par mois d'une estimation, arrondi au centime :
-
A = T(réglages à l'ouverture, prix gardés, mesures gardées): enregistrée ; -
B = T(réglages actuels, prix gardés, mesures gardées): ce que montre « telle qu'enregistrée » ; -
C = T(réglages actuels, prix gardés, mesures actuelles); -
D = T(réglages actuels, prix actuels, mesures actuelles): avec les données actuelles.
Réglages et remises = B − A, mesures = C − B, prix = D − C. Chaque total est arrondi au centime avant la différence : les trois parts s'additionnent à D − A au centime, par construction. Les réglages d'une estimation sont gardés à chaque changement : la part des réglages est nulle à l'ouverture et compte ce qui change pendant que les données actuelles sont affichées. Exemple (celui de la revue) : une charge serverless mesurée à 817,49 $ de DBU au prix catalogue sur 30 jours donne 817,49 × (365 ÷ 12) ÷ 30 = 828,8440…, soit 828,84 $ par mois ; ses données doublent ensuite (1 634,98 $ sur 30 jours, 1 657,688… soit 1 657,69 $). Rouverte telle qu'enregistrée : 828,84 $. Recalculée : 1 657,69 $, avec réglages 0,00 $, mesures +828,85 $, prix 0,00 $ (et non 828,84 $ : chaque total est arrondi avant la différence).
Ce qui n'est jamais un écart contre zéro. Une part n'est calculée que si ses deux totaux laissent de côté les mêmes charges. Une mesure actuelle illisible (facturation non lisible, coûts non chargés, charge absente des coûts actuels ou d'un autre workspace) rend la charge « non chiffrée » avec les données actuelles, et la part des mesures et l'écart total « inconnus ». Une estimation enregistrée avant la 0.23, sans enregistrement complet, est marquée comme telle : ses prix n'ont pas été gardés (ceux du jour sont lus à leur place, puis gardés au prochain changement), sa part des prix est « non séparable », et l'écart total est alors réglages + mesures. Une charge mesurée ajoutée avant la 0.23 est dite « sans date ».
Données relues comme hostiles. Ce qu'une estimation garde est relu champ par champ (version connue, cloud, région et plan connus, produits connus, types de machines par leur forme et jamais une clé de prototype, les quatre paiements, des nombres seulement et dans leurs bornes, 120 types au plus, dates au format jour) ; un enregistrement non reconnu est ignoré et l'estimation dite sans enregistrement complet. Un test d'attaque le vérifie (tests/security.test.mjs).
13.9 Chiffrer un projet de données (0.24)
Un projet se décrit en termes simples, brique par brique : ingestion, transformations, tableaux de bord (BI), Genie, notebooks et analyses libres, modèle en service, stockage, environnements et remises. YALineo en déduit des charges du Calculateur et les chiffre avec le même moteur (section 13.3), sur le prix de l'estimation : relevé public embarqué, prix saisis, remises du contrat, règles de réservation. Un projet est une estimation qui porte un enregistrement project : il se garde, se rouvre tel qu'enregistré et se recalcule avec les données actuelles comme toute estimation (section 13.8). Le code est dans extension/lib/calc-project.mjs.
Les modèles. Cinq points de départ : Entrepôt BI d'un domaine, Temps réel e-commerce, Libre-service analystes et Genie, Science des données et modèle en service, Projet vide. Leurs valeurs sont des exemples à adapter, dits comme tels à l'écran ; aucune n'est présentée comme une mesure. Une valeur que personne ne connaît à l'avance reste vide et le projet le dit : le prix du stockage, les DBU d'une session de notebook serverless, le prix d'un modèle servi. Les types de machines des modèles sont, par cloud, un type généraliste et un type mémoire présents dans chaque relevé (par exemple Standard_D4ds_v5 et Standard_E8ds_v5 sur Azure).
Ingestion et transformations. k flux ou jobs identiques, chacun une charge du moteur : en exécutions (exécutions par jour × 365 ÷ 12 jours × minutes ÷ 60), ou toujours allumé, 730 h (streaming continu, pipeline continu). Un job ou un pipeline serverless demande ses DBU par exécution (section 13.3). La brique vaut k × le montant d'une charge, arrondi au centime avant la multiplication. Le montant haut chiffre les minutes au pic quand elles sont saisies ; sinon il égale le probable.
Tableaux de bord : un SQL warehouse décrit par son usage. Avec q requêtes simultanées au pic, m clusters au minimum (1 à 30), h heures ouvertes par jour, p heures au pic, a minutes d'arrêt automatique et r reprises par jour :
-
clusters au pic
M = min(30, max(m, ⌈q ÷ 10⌉)): Databricks recommande un cluster pour 10 requêtes simultanées (Create a SQL warehouse) ; -
traîne d'arrêt
t = a ÷ 60 × rheures : un warehouse inactif reste facturé jusqu'à son arrêt ; -
journée entière
J = min(24, h + t); hors picH = max(0, min(24 − p, h − p + t)); -
probable =
Hheures àmclusters +pheures àMclusters ; bas =Jheures àmclusters ; haut =Jheures àMclusters ; chaque partie est la charge warehouse du moteur (DBU de la taille × clusters, et pour Pro et Classic leurs machines), sur les jours du mois saisis.
Exemple : Small serverless, 12 DBU par heure au prix de 0,70 $, q = 15, m = 1, h = 10, p = 2, a = 10, r = 1, 22 jours : M = 2, t = 1/6 h, probable (8 1/6 × 1 + 2 × 2) × 12 × 0,70 × 22 = 2 248,40 $, bas 1 878,80 $, haut 3 757,60 $.
Quand l'utilisateur choisit le type du warehouse, l'arrêt automatique prend la valeur par défaut de Databricks : 10 minutes en serverless, 45 en Pro et Classic (Create a SQL warehouse, section 13.7). Les modèles gardent leurs valeurs d'exemple (10 minutes, y compris pour le warehouse Pro de « Libre-service analystes et Genie », qui est le minimum de l'interface pour Pro), dites comme des exemples à adapter.
Genie. Ses requêtes SQL tournent sur un warehouse Pro ou Serverless (Create and manage a Genie Agent) et sont facturées par ce warehouse (Genie consumption guide). Sur le warehouse BI, ses requêtes simultanées au pic g s'ajoutent à celles du BI ; Genie porte la différence T(q + g) − T(q), pour le probable, le bas et le haut : rien n'est compté deux fois, et un Genie qui tient dans les clusters déjà là n'ajoute rien : la ligne de la brique montre les clusters au pic avant et après Genie (par exemple 2 → 2). Genie n'utilise que les heures et les jours ouverts pour le BI : des jours en plus sont « non chiffrés » avec leur nombre. Sur un warehouse BI Classic, Genie ne tourne pas : la brique demande un warehouse Pro ou Serverless. Sans warehouse BI, Genie a son propre warehouse serverless, chiffré par la même règle. Le nombre de questions décrit le besoin ; YALineo ne le lit pas et ne le convertit pas en coût. La facturation propre du modèle de langage de Genie est hors du périmètre du projet, dite à l'écran ; la page « IA : Genie et agents » la chiffre (section 13.16).
Notebooks. Des clusters polyvalents partagés : ⌈personnes ÷ personnes par cluster⌉ clusters, chacun la charge cluster du moteur (heures allumé par jour × jours). Ou des notebooks serverless : personnes × sessions par jour × jours sessions × DBU par session (mesurés sur un essai et saisis) × prix du DBU des notebooks serverless du relevé × (1 − remise DBU). Sans DBU par session, la brique a une hypothèse manquante, jamais un zéro.
Modèle en service. Les requêtes (requêtes par jour × jours) au prix saisi pour 1 000 requêtes, ou les DBU par jour de la concurrence provisionnée (outil de la section 13.10) au prix d'un DBU Model Serving, absent du relevé : saisi, ou repris à la demande du prix moyen mesuré du produit (section 13.4). La remise DBU s'applique aux deux. L'entraînement est un job de tant d'heures par mois, chiffré par le moteur.
Stockage, facturé par le cloud. Avec S₀ Go au départ, v Go nouveaux par jour, w Go réécrits par jour, R jours de rétention des fichiers (7 par défaut pour VACUUM) et un horizon de N mois : données nouvelles par mois v × 365 ÷ 12 ; fichiers gardés pour le voyage dans le temps w × R ; le mois m garde S₀ + m × v × 365 ÷ 12 + w × R Go. Le probable est le mois moyen de 1 à N, S₀ + w × R + v × 365 ÷ 12 × (N + 1) ÷ 2 ; le bas le premier mois, le haut le dernier. Seulement au prix par Go et par mois saisi (le contrat du cloud), jamais remisé ; les opérations de lecture et d'écriture sont hors périmètre.
Développement et recette. Une part d saisie, 0 % par défaut, du calcul de toutes les briques sauf le stockage : round(Σ coûts DBU × d) + round(Σ machines × d), de même pour le bas et le haut.
Les totaux, au centime. Chaque brique est une somme de centimes ; le total probable est Σ briques + développement. Les montants « Par brique » et « Par produit Databricks » (chaque partie chiffrée rangée sous son produit, le développement et le stockage à part) s'additionnent au total au centime, comme DBU + machines + stockage. Par an : 12 mois. La plage entre le montant bas et le montant haut vient seulement des règles ci-dessus (minutes au pic, autoscaling d'un warehouse, premier et dernier mois du stockage) ; aucun pourcentage n'est ajouté par défaut, et seules les parties chiffrées y entrent.
L'état du chiffrage. Celui des estimations (section 13.1) : « chiffré » quand chaque brique a toutes ses valeurs, « partiellement chiffré » quand une part existe sans prix (un prix absent du relevé, des jours Genie au-delà du BI), « hypothèses manquantes » quand une valeur reste à saisir. Une brique incomplète est listée dans « Non chiffré : valeur à compléter », jamais comptée pour zéro. Ce qui n'est pas chiffré par construction est listé dans « Hors périmètre » : disques des machines, modèle de langage de Genie, opérations de stockage.
Votre plateforme et « Ce projet ajouterait », à périmètre égal. Le volet FinOps mesure des DBU au prix catalogue (system.billing.usage × prix catalogue, section 4) : ni machines du cloud, ni stockage, ni remise. La plateforme est donc Σ coût des DBU au catalogue de ses charges (le lanceur d'une charge mise à part), sur les N jours chargés, ramenée à un mois moyen (× (365 ÷ 12) ÷ N). Le projet est ramené au même périmètre : ses DBU au prix catalogue (sans remise), développement compris. « Ce projet ajouterait » = DBU du projet au catalogue ÷ DBU de la plateforme au catalogue par mois. Le rapprochement est affiché et tombe juste au centime : total du projet = DBU au catalogue − remise DBU + machines + stockage. Quand une partie en DBU n'est pas chiffrée, la part est dite « au moins ». Sans coûts FinOps chargés, ou avec une facturation illisible, la page le dit et aucun pourcentage n'est calculé.
Ce qui pèse le plus sur le total. Chaque valeur saisie d'une brique allumée est déplacée de 20 % dans un sens puis dans l'autre, les autres fixes ; le total probable est recalculé chaque fois avec les mêmes prix. Un entier (workers, personnes, clusters, flux) est arrondi, et chaque valeur reste dans ses bornes (24 h par jour, 31 jours, 30 clusters...) : les valeurs essayées sont données avec la ligne. Les lignes sont rangées par le plus grand écart ; une valeur qui ne change pas le total au centime n'a pas de ligne.
Changer de cloud. Comme pour une estimation (section 13.3) : chaque type de machine est remplacé par le moins cher du nouveau cloud qui a au moins autant de vCPU et de mémoire ; les réglages gardés par un outil de dimensionnement, qui nomment des types de l'ancien cloud, sont retirés.
Exemple. Le modèle Entrepôt BI d'un domaine sur le relevé Azure embarqué (15 octobre 2026), East US, Premium, sans remise : 3 443,92 $ par mois probables, de 3 000,40 $ à 5 427,76 $, dont 20 % de développement, le stockage restant à saisir (« hypothèses manquantes »). Un test le vérifie (tests/v0240-calc24.test.mjs), avec chaque brique au centime sur un relevé à prix ronds.
Données relues comme hostiles. L'enregistrement project est relu champ par champ : version connue, briques connues et champs connus (tout autre nom ignoré, jamais une clé de prototype), des nombres seulement et dans leurs bornes (une chaîne n'est jamais convertie), des choix connus, des types de machines par leur forme ; les réglages d'un outil par une liste de noms permis. Un enregistrement non reconnu fait de l'estimation une estimation ordinaire. Un test d'attaque le vérifie (tests/security.test.mjs).
13.10 Les outils de dimensionnement d'une brique (0.24)
« Dimensionner cette brique » ouvre un outil qui calcule, pas à pas, une valeur de la brique à partir des chiffres de l'utilisateur ; chaque pas cite sa source (Microsoft Learn ou une loi publiée) ou est dit « dérivé ». Rien n'est supposé quand un chiffre mesuré manque : l'outil dit quoi saisir. « Appliquer au projet » montre d'abord un récapitulatif (les valeurs avant et après, l'effet sur la brique et sur le total), comme « Utiliser cette durée » (section 13.3) ; la brique garde ensuite les réglages de l'outil avec la date. Le code est dans extension/lib/calc-size.mjs.
-
Fenêtre d'un job (ingestion, transformations). Un essai mesuré (volume
V₀, duréeT₀,w₀workers dec₀cœurs) donne le travailT₀ × w₀ × c₀en minutes-cœur ; le travail suit le volume (règle proportionnelle, section 13.3) :T₁ = T₀ × V ÷ V₀sur les cœurs de l'essai. Le temps disponible est(fenêtre × 60 − démarrage) × (1 − marge). Une partsqui ne se partage pas borne l'accélération (loi d'Amdahl) : cœurs= ⌈(1 − s) × T₁ × C₀ ÷ (disponible − s × T₁)⌉avecC₀ = w₀ × c₀, workers= ⌈cœurs ÷ cœurs par machine⌉, durée= T₁ × (s + (1 − s) × C₀ ÷ cœurs) + démarrage. Sis × T₁dépasse à lui seul le temps disponible, aucun nombre de workers ne suffit, et l'outil le dit. Le démarrage du cluster n'est compté que s'il est saisi (mesuré). Le prix d'une exécution est celui du moteur pour une heure, au prorata des minutes. -
SQL warehouse (tableaux de bord). Requêtes par seconde au moment le plus chargé
λ = personnes × requêtes par personne et par heure ÷ 3 600 × facteur de pointe; requêtes simultanéesL = λ × W,Wla durée moyenne d'une requête en secondes (loi de Little ; la moyenne, pas la médiane) ; clusters= ⌈L ÷ 10⌉. Le mois suit la règle de la brique (section 13.9). Un maximum de clusters saisi plus bas que le besoin est signalé : des requêtes attendront au pic. Un arrêt automatique sous le minimum de l'interface est signalé. -
Cluster et arrêt automatique (notebooks). À chaque départ de l'équipe, le cluster tourne à vide jusqu'à son arrêt :
min(pause, arrêt automatique)minutes ; une pause plus courte que le délai est payée en entière. Heures allumé par jour= heures actives + départs × minutes à vide ÷ 60; coût à vide par mois= départs × jours × minutes à vide ÷ 60 × prix d'une heure du cluster, comparé entre le délai actuel et le délai proposé (10 à 10 000 minutes). -
Concurrence et taille d'endpoint (modèle en service). Concurrence
= requêtes par seconde × durée d'exécution du modèle en secondes, provisionnée en multiples de 4 jusqu'à 1 024 par modèle ; tailles Small (0 à 4), Medium (8 à 16), Large (16 à 64), au-delà personnalisée. Hypothèse dite : tant que l'endpoint tourne, sa concurrence reste à 4 au moins ; elle ne descend à 0 qu'avec le scale to zero, et 30 minutes restent facturées après l'arrêt du trafic. En CPU, 1 DBU par heure et par requête simultanée ; en GPU,concurrence ÷ 4répliques, chacune à ses DBU par heure. DBU par jour= heures au pic × DBU/h au pic + heures hors pic avec trafic × DBU/h hors pic + heures sans trafic × DBU/h de la concurrence minimale. Le prix d'un DBU Model Serving est saisi (absent du relevé). -
Stockage dans le temps. La règle de la brique (section 13.9), pas à pas : fichiers gardés
w × R, données nouvelles par mois, dernier mois, mois moyen, coût au prix saisi.
Données relues comme hostiles. Les réglages gardés par une brique sont relus par une liste de noms permis, des nombres dans leurs bornes, des booléens et des noms courts de forme simple ; un outil inconnu ou une brique inconnue sont ignorés (section 13.9).
13.11 Services : unités, taux et sources (0.25)
Depuis la 0.25, le Calculateur dispose des données pour chiffrer les services facturés autrement que le calcul classique et SQL : Model Serving, AI Search, Foundation Model APIs, modèles propriétaires, Lakebase, Databricks Apps, AI Parse, AI Extract, AI Classify, Unity AI Gateway, Agent Evaluation, AI Runtime, Shutterstock ImageAI, Lakeflow Connect, Zerobus Ingest, le stockage par défaut et les options de plateforme. Cette section dit d'où viennent les taux et les prix, comment ils se combinent et ce qui n'est pas publié. Les écrans qui s'en servent suivent les mêmes règles.
Le relevé. extension/lib/prices/services.mjs est écrit par tools/service-rates.mjs, jamais à la main, à partir de données officielles lues le 26 octobre 2026 :
-
les pages de prix de Databricks (
databricks.com/product/pricing/<produit>) : leur contenu est publié en JSON (en-pricing-assets/page-data/.../page-data.json), tableau par tableau, avec la règle de visibilité qui dit pour quel cloud vaut chaque tableau ; l'outil lit les tableaux cellule par cellule et les phrases des FAQ par des motifs fixes. Une phrase qui ne correspond plus arrête l'outil : elle est relue à la main, rien n'est deviné ; -
les données de prix de ces pages (
en-pricing-assets/data/pricing/cards.json) : le prix catalogue d'un DBU, d'un DSU ou d'une unité, par plan, cloud et région, avant toute promotion ; - Microsoft Learn, Serverless DBU consumption by SKU : les multiplicateurs de DBU et de DSU d'Azure Databricks ;
- Microsoft Learn, pages de référence des tables système (facturation, prix, coûts de Model Serving, stockage par défaut) : noms de SKU, produits facturés, unités ; l'outil vérifie que chaque texte cité y figure encore ;
- les données du calculateur Azure Databricks de Microsoft, lues pour comparaison seulement (voir plus bas).
L'extension n'appelle jamais ces sources. node tools/service-rates.mjs --check relit chaque source et compare chaque valeur au relevé : 0 (identique), 3 (changé), 1 (erreur), comme tools/cloud-prices.mjs.
Les règles. Une valeur est gardée telle qu'une source la donne, avec le nom de sa source. Un chiffre de Microsoft Learn vaut pour Azure seulement ; un tableau de databricks.com vaut pour les clouds que sa règle de visibilité nomme ; une phrase de FAQ sans règle vaut pour les trois. Deux sources qui donnent la même valeur à un arrondi près : la plus précise est gardée, les deux sont citées (AI Search Storage Optimized : 18,286 DBU par heure dans la FAQ, 18,29 dans le tableau et sur Learn ; les exemples de la page tombent sur 18,286). Deux sources officielles qui se contredisent pour la même chose, le même cloud et la même unité : la valeur est laissée de côté (un conflit), les deux sont listées, et le Calculateur la demande. Un taux en DBU par unité et un prix public de l'unité doivent s'accorder (taux × prix public d'un DBU = prix public de l'unité, à l'arrondi des données près : 1,5 % ou 0,0015 $) ; s'ils divergent dans la plupart des régions d'un cloud, c'est un conflit.
Prix et origine. Comme pour les autres charges (section 13.2), chaque réponse porte son origine : saisi, sinon prix du compte, sinon prix public.
-
Prix d'un DBU (ou d'un DSU) : saisi ; sinon le prix catalogue du compte, lu dans
system.billing.list_pricespar la requêteyalineo:list-prices; sinon le prix public de la région et du plan. - Prix d'une unité (heure de GPU, Go, million de jetons...) : saisi ; sinon taux × prix d'un DBU saisi ou du compte (un taux saisi passe toujours par un prix d'un DBU) ; sinon le prix public de l'unité quand les données de prix le donnent ; sinon taux × prix public d'un DBU. Avec les seules données publiques, le prix affiché par Databricks est donc gardé tel quel ; le taux sert à convertir le prix du compte.
- Une valeur que rien ne donne n'est jamais 0 : la réponse est vide et l'écran demande la saisie.
La requête yalineo:list-prices lit, à la demande seulement (jamais dans une actualisation), une instruction SELECT sur system.billing.list_prices : sku_name, cloud, currency_code, usage_unit, le prix catalogue (pricing.default), le prix catalogue effectif (pricing.effective_list.default, promotions comprises, quand la colonne existe ; une forme sans elle sert aux schémas plus anciens) et le jour de début, pour les prix commencés et non terminés, un cloud ou tous (paramètre nommé :cloud), 5 000 lignes au plus. Ses lignes sont relues comme hostiles par accountPrices() : un nom de SKU de la forme documentée (capitales, chiffres, _ et parenthèses), une unité connue (DBU ou DSU), une devise de trois lettres, un prix qui est un nombre fini de 0 à 1 000 ; le prix effectif s'il existe, sinon le prix catalogue. Les noms __proto__ ou constructor ne deviennent jamais des clés (une Map). Un test d'attaque le vérifie (tests/security.test.mjs).
Le SKU du compte. Microsoft Learn documente la forme <tier>_SERVERLESS_REAL_TIME_INFERENCE_<region> (et ..._LAUNCH_... pour les démarrages après un scale to zero) ; les autres noms exacts ne sont pas publiés. Un prix du compte s'applique donc par une règle dite : le sku_name commence par le plan (ou par aucun plan), contient tous les mots d'un groupe tiré du nom de SKU que donnent les pages de prix (par exemple DATABASE et SERVERLESS pour « Database Serverless Compute »), aucun mot exclu (LAUNCH), et a la bonne unité et la bonne devise. Un seul prix parmi les SKU retenus : il s'applique. Plusieurs : celui dont le nom finit par les mots de la région. Toujours plusieurs, ou aucun : pas de prix du compte, jamais un choix au hasard. Le nom du SKU retenu accompagne le prix.
Formules par type de service. Pour une ligne, q est la quantité dans l'unité de sa mesure.
| Type | Unités | Formule |
|---|---|---|
| Model Serving | heures de nœud CPU ; heures de requête simultanée (Azure) ; heures d'instance GPU | q × DBU par unité × prix d'un DBU (SKU Serverless Real-Time Inference) ; q = instances (répliques) × heures |
| AI Search | heures d'unité ; milliers de requêtes du reranker ; Go-mois | unités = ⌈vecteurs × dimensions ÷ 768 ÷ capacité d'une unité⌉ (2 millions en Standard, 64 millions en Storage Optimized) ; unités × heures × DBU par heure × prix d'un DBU ; stockage Standard au-delà de 30 Go × prix du Go-mois ; reranker milliers × DBU × prix d'un DBU |
| Foundation Model APIs | millions de jetons (entrée, sortie, lecture en cache) ; heures par bloc de 50 unités de modèle ; heures | jetons : Σ millions × DBU par million × prix d'un DBU ; débit provisionné : heures × (unités de modèle ÷ 50) × DBU par heure ; lot : heures × DBU par heure ; point d'accès régional d'un modèle marqué ⌖ : DBU × 1,1 |
| Modèles propriétaires | millions de jetons (entrée, sortie, lecture et écriture en cache) ; heures (lot) | Σ millions × DBU par million × prix d'un DBU du SKU du fournisseur, un prix global ; régional : × 1,1 pour un modèle marqué ⌖ |
| Lakebase | heures de CU ; Go-mois | q = nœuds × CU × heures ; prix de l'heure de CU (règle des prix ci-dessus) ; minimum d'une instance toujours allumée (scale to zero coupé plus de 24 heures) au prix « always-on », le reste au prix autoscaling ; stockage et instantanés Go-mois × DSU par Go-mois × prix d'un DSU, ou le prix public du Go-mois |
| Databricks Apps | heures d'application active | applications × heures × DBU par heure × prix d'un DBU (Interactive Serverless) |
| AI Parse, AI Extract, AI Classify | milliers de pages, d'entrées, de documents | bas = milliers × DBU le plus bas × prix d'un DBU ; haut = × DBU le plus haut (estimations publiées, sur des travaux de plus de 3 000 pages pour AI Parse) |
| Unity AI Gateway | Go de charge utile ; millions de jetons | Go × DBU par Go × prix d'un DBU, ou le prix public du Go ; millions × prix public du million |
| Agent Evaluation | millions de jetons ; questions | (millions en entrée × DBU + millions en sortie × DBU) × prix d'un DBU ; questions × DBU par question × prix d'un DBU ; ou les prix publics |
| AI Runtime | heures de GPU | GPU × heures × prix public de l'heure de GPU (facturé en DBU sur le SKU Model Training) |
| Shutterstock ImageAI | images | images × DBU par image × prix d'un DBU, ou le prix public de l'image |
| Lakeflow Connect | DBU | DBU facturables par jour = max(0, DBU du jour − 100) par workspace (100 DBU gratuits par jour) ; DBU facturables × jours × prix d'un DBU (Jobs Serverless) ; la passerelle d'une base de données est un pipeline classique Advanced, chiffré comme tout pipeline (section 13.3) |
| Zerobus Ingest | Go ingérés | Go × DBU par Go × prix d'un DBU (Jobs Serverless), ou le prix public du Go |
| Stockage par défaut | Go-mois ; milliers d'opérations | (Go-mois × 1 + milliers d'opérations de niveau 1 × DSU + de niveau 2 × DSU) × prix d'un DSU ; un mois compte 730 heures |
| Options de plateforme | part de la dépense | part × dépense des produits au prix catalogue, avant remises, dans les workspaces où l'option est active ; Mission Critical comprend Enhanced Security and Compliance (l'une ou l'autre) ; réplication de reprise après sinistre Go × prix public du Go |
Ce qui n'est pas publié (pages vérifiées le 26 octobre 2026). Le Calculateur demande la valeur :
- Model Serving : les DBU par requête simultanée en CPU sur AWS et GCP (seul Azure les publie ; databricks.com donne 4 DBU par heure de nœud CPU pour les trois clouds) ;
- AI Search : les DSU par Go-mois sur AWS et GCP ; ceux du stockage Storage Optimized et sa part gratuite, partout (le prix public du Go-mois est publié) ;
- Foundation Model APIs : le prix d'un DBU des SKU dédiés d'Azure (service ADI, vendu par Databricks) pour les modèles Kimi, DeepSeek, Inkling et GLM ;
- Lakebase : les DBU par heure de CU sur AWS et GCP, et ceux du minimum « always-on » partout (le prix public de l'heure de CU est publié) ;
- AI Extract et AI Classify : leur nom de SKU (leur prix d'un DBU est publié) ;
- Unity AI Gateway, Agent Evaluation, Shutterstock ImageAI : les DBU par unité sur AWS et GCP (les prix publics par unité sont publiés) ;
- AI Runtime : les DBU par heure de GPU, partout ; aucun prix sur GCP ;
-
Lakeflow Connect : des DBU par heure ou par Go pour un connecteur ; ils se mesurent sur un essai (
system.billing.usage, produitLAKEFLOW_CONNECT).
Conflits. Deux au relevé du 26 octobre 2026 :
- Lakebase, restauration à un instant (PITR) : 8,7 DSU par Go-mois sur Microsoft Learn, 8,60 sur la page Lakebase. Le taux est laissé de côté ; le prix public du Go-mois (par exemple 0,200 $ sur AWS us-east-1) s'applique, sinon la saisie.
- Unity AI Gateway, tables d'inférence des endpoints CPU et GPU, Azure : 7,143 DBU par Go sur Microsoft Learn, alors que le prix public est de 0,100 $ par Go à 0,07 $ le DBU (soit 1,429 DBU). Le taux Azure est laissé de côté ; le prix public du Go s'applique.
Promotions. Les prix publics sont des prix catalogue avant promotion : par exemple 50 % sur Lakebase jusqu'au 31 janvier 2027, 15 % au lieu de 30 % pour Mission Critical jusqu'au 30 juin 2027 (gardé à part dans le relevé). Certaines lignes de modèles propriétaires portent une note de la page (promotion incluse ou non, avec sa date) : le relevé garde la marque de la note (footnote) et l'écran la montre. Le prix effectif du compte (effective_list) comprend les promotions en cours.
Comparaison avec le calculateur Azure de Microsoft (prix Azure Premium, par région, 26 octobre 2026) : Serverless Real-Time Inference 37 régions identiques ; Automated Serverless 38 identiques ; DSU 15 identiques et 26 à l'arrondi près (3 décimales contre 4) ; réplication de reprise après sinistre 18 identiques, 21 à l'arrondi, 1 différente (North Central US : 0,020 $ contre 0,024 $) ; Model Training 35 identiques, 2 différentes (Switzerland North et West : 0,85 $ contre 0,78 $) ; Anthropic 0,105 $ identique ; Database Serverless Compute 2 identiques et 39 différentes, le calculateur Microsoft donnant le prix en promotion (environ la moitié, par exemple East Asia 0,71 $ contre 0,36 $). Le relevé garde les données de Databricks ; les écarts sont listés par --check.
Les taux du relevé. Chaque ligne : le type de service, la clé (modèle, taille, mode ; · sépare les parties), les clouds, les DBU (ou DSU) par unité, la clé du prix public de l'unité quand elle existe, et les sources (liste plus bas). Unités : node-hour heure de nœud, concurrency-hour heure de requête simultanée, instance-hour heure d'instance, unit-hour heure d'unité, k-requests mille requêtes, gb-month Go-mois, input-mtok, output-mtok, cache-read-mtok, cache-write-mtok, cache-write-1h-mtok million de jetons, hour-50mu heure par bloc de 50 unités de modèle, cu-hour heure de CU, app-hour heure d'application, k-pages, k-inputs, k-documents mille pages, entrées, documents, gb Go, mtok million de jetons, question, gpu-hour heure de GPU, image, dbu DBU, k-ops mille opérations, share part de la dépense. Les prix publics par région et par plan sont dans le relevé (prices, globalPrices).
| Service | Clé | Clouds | DBU (ou DSU) par unité | Prix public par unité | Sources |
|---|---|---|---|---|---|
| agent-evaluation | judge | azure | 2,14 / input-mtok, 8,57 / output-mtok | agent-eval-input-mtok / input-mtok, agent-eval-output-mtok / output-mtok | learnServerless, dbxCards |
| agent-evaluation | synthetic | azure | 5 / question | agent-eval-question / question | learnServerless, dbxCards |
| ai-classify | short-text | aws, azure, gcp | 3 à 6 / k-documents | dbxAiFunctions | |
| ai-classify | rental-contracts | aws, azure, gcp | 40 à 60 / k-documents | dbxAiFunctions | |
| ai-extract | short-text | aws, azure, gcp | 30 à 60 / k-inputs | dbxAiFunctions | |
| ai-extract | invoices | aws, azure, gcp | 30 à 60 / k-inputs | dbxAiFunctions | |
| ai-extract | precision-complex-reasoning | aws, azure, gcp | 400 à 725 / k-inputs | dbxAiFunctions | |
| ai-extract | precision-deep-nesting | aws, azure, gcp | 375 à 700 / k-inputs | dbxAiFunctions | |
| ai-gateway | inference-tables-gb | tous | conflit | inference-tables-gb / gb | learnServerless, dbxCards |
| ai-gateway | usage-tracking-gb | azure | 1,429 / gb | usage-tracking-gb / gb | learnServerless, dbxCards |
| ai-gateway | inference-tables-mtok | tous | non publié | inference-tables-mtok / mtok | dbxCards |
| ai-gateway | usage-tracking-mtok | tous | non publié | usage-tracking-mtok / mtok | dbxCards |
| ai-parse | low-simple-text | aws, azure, gcp | 10 à 15 / k-pages | dbxAiFunctions | |
| ai-parse | low-simple-text-with-sparse-tables-or-images | aws, azure, gcp | 20 à 25 / k-pages | dbxAiFunctions | |
| ai-parse | medium-text-with-complex-tables-figures-or-captions | aws, azure, gcp | 60 à 65 / k-pages | dbxAiFunctions | |
| ai-parse | high-dense-forms-or-complex-diagrams | aws, azure, gcp | 85 à 90 / k-pages | dbxAiFunctions | |
| ai-runtime | a10 | tous | non publié | ai-runtime-a10-gpu-hour / gpu-hour | dbxAiRuntime, dbxCards |
| ai-runtime | h100 | tous | non publié | ai-runtime-h100-gpu-hour / gpu-hour | dbxAiRuntime, dbxCards |
| ai-runtime | b300 | tous | non publié | ai-runtime-b300-gpu-hour / gpu-hour | dbxAiRuntime, dbxCards |
| apps | medium | aws, azure, gcp | 0,5 / app-hour | dbxApps, learnServerless | |
| apps | large | aws, azure, gcp | 1 / app-hour | dbxApps, learnServerless | |
| apps | xlarge | aws, azure, gcp | 3 / app-hour | dbxApps | |
| default-storage | stored | aws, azure, gcp | 1 / gb-month | dbxStorage, learnServerless | |
| default-storage | tier1 | aws, gcp | 0,2174 / k-ops | dbxStorage, learnServerless | |
| default-storage | tier1 | azure | 0,3535 / k-ops | dbxStorage, learnServerless | |
| default-storage | tier2 | aws, gcp | 0,0174 / k-ops | dbxStorage, learnServerless | |
| default-storage | tier2 | azure | 0,0226 / k-ops | dbxStorage, learnServerless | |
| fm-api | bge-large · batch | aws, azure, gcp | 24 / hour | dbxFoundationModels | |
| fm-api | bge-large · ppt | aws, azure, gcp | 1,429 / input-mtok | dbxFoundationModels | |
| fm-api | bge-large · pt | aws, azure, gcp | 24 / hour-50mu | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · ppt | aws, azure, gcp | 4,286 / input-mtok, 17,143 / output-mtok, 0,429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · priority | aws, azure, gcp | 7,5 / input-mtok, 30 / output-mtok, 0,75 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · pt-1m | aws, azure, gcp | 142,857 / hour-50mu | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-0910 · pt-3m | aws, azure, gcp | 128,571 / hour-50mu | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-1017 · ppt | aws, gcp | 4,286 / input-mtok, 17,143 / output-mtok, 0,1 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-1-flash-1017 · ppt | azure | 4,286 / input-mtok, 17,143 / output-mtok, 0,429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-flash · ppt | aws, azure, gcp | 2 / input-mtok, 4 / output-mtok, 0,4 / cache-read-mtok | dbxFoundationModels | |
| fm-api | deepseek-v4-pro · ppt | aws, azure, gcp | 18,857 / input-mtok, 56,571 / output-mtok, 1,886 / cache-read-mtok | dbxFoundationModels | |
| fm-api | gemma-3-12b · batch | aws, azure, gcp | 71,429 / hour | dbxFoundationModels | |
| fm-api | gemma-3-12b · ppt | aws, azure, gcp | 2,143 / input-mtok, 7,143 / output-mtok | dbxFoundationModels | |
| fm-api | gemma-3-12b · pt | aws, azure, gcp | 71,429 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · ppt | aws, azure, gcp | 20 / input-mtok, 62,857 / output-mtok, 3,714 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · priority | aws, azure, gcp | 35 / input-mtok, 110 / output-mtok, 6,5 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · pt-1m | aws, azure, gcp | 142,857 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-2-5-3 · pt-3m | aws, azure, gcp | 128,571 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-3-flash · ppt | aws, azure, gcp | 2,143 / input-mtok, 7,143 / output-mtok, 0,429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-3-flash · priority | aws, azure, gcp | 3,75 / input-mtok, 12,5 / output-mtok, 0,75 / cache-read-mtok | dbxFoundationModels | |
| fm-api | glm-5-3-flash · pt-1m | aws, azure, gcp | 142,857 / hour-50mu | dbxFoundationModels | |
| fm-api | glm-5-3-flash · pt-3m | aws, azure, gcp | 128,571 / hour-50mu | dbxFoundationModels | |
| fm-api | gpt-oss-120b · batch | aws, azure, gcp | 71,429 / hour | dbxFoundationModels | |
| fm-api | gpt-oss-120b · ppt | aws, azure, gcp | 2,143 / input-mtok, 8,571 / output-mtok | dbxFoundationModels | |
| fm-api | gpt-oss-120b · pt | aws, azure, gcp | 71,429 / hour-50mu | dbxFoundationModels | |
| fm-api | gpt-oss-20b · batch | aws, azure, gcp | 53,571 / hour | dbxFoundationModels | |
| fm-api | gpt-oss-20b · ppt | aws, azure, gcp | 1 / input-mtok, 4,286 / output-mtok | dbxFoundationModels | |
| fm-api | gpt-oss-20b · pt | aws, azure, gcp | 53,571 / hour-50mu | dbxFoundationModels | |
| fm-api | gte · batch | aws, azure, gcp | 100 / hour | dbxFoundationModels | |
| fm-api | gte · ppt | aws, azure, gcp | 1,857 / input-mtok | dbxFoundationModels | |
| fm-api | gte · pt | aws, azure, gcp | 100 / hour-50mu | dbxFoundationModels | |
| fm-api | inkling · ppt | aws, azure, gcp | 14,286 / input-mtok, 57,857 / output-mtok, 2,429 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k2-7 · ppt | aws, azure, gcp | 13,571 / input-mtok, 57,143 / output-mtok, 2,714 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k3 · ppt | aws, azure, gcp | 42,857 / input-mtok, 214,286 / output-mtok, 4,286 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k3 · priority | aws, azure, gcp | 75 / input-mtok, 375 / output-mtok, 7,5 / cache-read-mtok | dbxFoundationModels | |
| fm-api | kimi-k3 · pt-1m | aws, azure, gcp | 142,857 / hour-50mu | dbxFoundationModels | |
| fm-api | kimi-k3 · pt-3m | aws, azure, gcp | 128,571 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-1-8b · batch | aws, azure, gcp | 53,571 / hour | dbxFoundationModels | |
| fm-api | llama-3-1-8b · ppt | aws, azure, gcp | 2,143 / input-mtok, 6,429 / output-mtok | dbxFoundationModels | |
| fm-api | llama-3-1-8b · pt | aws, azure, gcp | 53,571 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-2-1b · batch | aws, azure, gcp | 42,857 / hour | dbxFoundationModels | |
| fm-api | llama-3-2-1b · pt | aws, azure, gcp | 42,857 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-2-3b · batch | aws, azure, gcp | 46,429 / hour | dbxFoundationModels | |
| fm-api | llama-3-2-3b · pt | aws, azure, gcp | 46,429 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-3-3-70b · batch | aws, azure, gcp | 85,714 / hour | dbxFoundationModels | |
| fm-api | llama-3-3-70b · ppt | aws, azure, gcp | 7,143 / input-mtok, 21,429 / output-mtok | dbxFoundationModels | |
| fm-api | llama-3-3-70b · pt | aws, azure, gcp | 85,714 / hour-50mu | dbxFoundationModels | |
| fm-api | llama-4-maverick · batch | aws, azure, gcp | 85,714 / hour | dbxFoundationModels | |
| fm-api | llama-4-maverick · ppt | aws, azure, gcp | 7,143 / input-mtok, 21,429 / output-mtok | dbxFoundationModels | |
| fm-api | llama-4-maverick · pt | aws, azure, gcp | 85,714 / hour-50mu | dbxFoundationModels | |
| fm-api | openjev-qwen-3-5-4b · ppt | aws, azure, gcp | 0,6 / input-mtok | dbxFoundationModels | |
| fm-api | qwen-3-0-6b-embedding · batch | aws, azure, gcp | 50 / hour | dbxFoundationModels | |
| fm-api | qwen-3-0-6b-embedding · ppt | aws, azure, gcp | 0,286 / input-mtok | dbxFoundationModels | |
| fm-api | qwen-3-0-6b-embedding · pt | aws, azure, gcp | 50 / hour-50mu | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · batch | aws, azure, gcp | 85,714 / hour | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · ppt | aws, azure, gcp | 3,143 / input-mtok, 31,429 / output-mtok | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · priority | aws, azure, gcp | 5,5 / input-mtok, 55 / output-mtok | dbxFoundationModels | |
| fm-api | qwen-3-5-122b · pt | aws, azure, gcp | 85,714 / hour-50mu | dbxFoundationModels | |
| fm-api | qwen-3-80b-instruct · batch | aws, azure, gcp | 104,762 / hour | dbxFoundationModels | |
| fm-api | qwen-3-80b-instruct · ppt | aws, azure, gcp | 2,143 / input-mtok, 17,143 / output-mtok | dbxFoundationModels | |
| fm-api | qwen-3-80b-instruct · pt | aws, azure, gcp | 104,762 / hour-50mu | dbxFoundationModels | |
| fm-proprietary | anthropic · claude-fable-5-1 · ppt | aws, azure, gcp | 142,857 / input-mtok, 714,286 / output-mtok, 3,571 / cache-read-mtok, 178,571 / cache-write-mtok, 285,714 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-fable-5-5-1 · batch | aws, azure, gcp | 357,143 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-fable-5 · ppt | aws, azure, gcp | 142,857 / input-mtok, 714,286 / output-mtok, 14,286 / cache-read-mtok, 178,571 / cache-write-mtok, 285,714 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-4-5 · batch | aws, azure, gcp | 114,286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-4-5 · ppt | aws, azure, gcp | 14,286 / input-mtok, 71,429 / output-mtok, 1,429 / cache-read-mtok, 17,857 / cache-write-mtok, 28,571 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-5-5 · batch | aws, azure, gcp | 21,429 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-5-5 · long-context · ppt | aws, azure, gcp | 7,143 / input-mtok, 35,714 / output-mtok, 0,714 / cache-read-mtok, 8,929 / cache-write-mtok, 14,286 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-haiku-5-5 · short-context · ppt | aws, azure, gcp | 1,429 / input-mtok, 7,143 / output-mtok, 0,143 / cache-read-mtok, 1,786 / cache-write-mtok, 2,857 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-4-1 · batch | aws, azure, gcp | 514,286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-4-1 · ppt | aws, azure, gcp | 214,286 / input-mtok, 1071,43 / output-mtok, 21,429 / cache-read-mtok, 267,857 / cache-write-mtok, 428,571 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-5-4-6-4-7-4-8-5 · batch | aws, azure, gcp | 178,571 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-4-5-4-6-4-7-4-8-5 · ppt | aws, azure, gcp | 71,429 / input-mtok, 357,143 / output-mtok, 7,143 / cache-read-mtok, 89,286 / cache-write-mtok, 142,857 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-opus-5-5 · ppt | aws, azure, gcp | 57,143 / input-mtok, 285,714 / output-mtok, 2,857 / cache-read-mtok, 71,429 / cache-write-mtok, 114,286 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4-5-4-6 · batch | aws, azure, gcp | 214,286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4-5-4-6 · ppt | aws, azure, gcp | 42,857 / input-mtok, 214,286 / output-mtok, 4,286 / cache-read-mtok, 53,571 / cache-write-mtok, 85,714 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4 · batch | aws, azure, gcp | 214,286 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-4 · ppt | aws, azure, gcp | 42,857 / input-mtok, 214,286 / output-mtok, 4,286 / cache-read-mtok, 53,571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-5-5-5 · batch | aws, azure, gcp | 142,857 / hour | dbxProprietary | |
| fm-proprietary | anthropic · claude-sonnet-5-5-5 · ppt | aws, azure, gcp | 28,571 / input-mtok, 142,857 / output-mtok, 2,857 / cache-read-mtok, 35,714 / cache-write-mtok, 57,143 / cache-write-1h-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-2-5-flash-lite · audio-tokens · ppt | aws, azure, gcp | 5,357 / input-mtok, 0,536 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-2-5-flash-lite · image-tokens · ppt | aws, azure, gcp | 1,786 / input-mtok, 0,179 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-2-5-flash-lite · text-tokens · ppt | aws, azure, gcp | 1,786 / input-mtok, 7,143 / output-mtok, 0,179 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · audio-tokens · ppt | aws, azure, gcp | 17,857 / input-mtok, 1,786 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · audio-tokens · priority | aws, azure, gcp | 32,143 / input-mtok, 3,214 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · batch | aws, azure, gcp | 125 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · image-tokens · ppt | aws, azure, gcp | 8,929 / input-mtok, 0,893 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · image-tokens · priority | aws, azure, gcp | 16,071 / input-mtok, 1,607 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · text-tokens · ppt | aws, azure, gcp | 8,929 / input-mtok, 53,571 / output-mtok, 0,893 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-0-flash · text-tokens · priority | aws, azure, gcp | 16,071 / input-mtok, 96,429 / output-mtok, 1,607 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-image · image-tokens · ppt | aws, azure, gcp | 8,929 / input-mtok, 1071,43 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-image · text-tokens · ppt | aws, azure, gcp | 8,929 / input-mtok, 53,571 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite-image · image-tokens · ppt | aws, azure, gcp | 4,464 / input-mtok, 535,714 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite-image · text-tokens · ppt | aws, azure, gcp | 4,464 / input-mtok, 26,786 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · audio-tokens · ppt | aws, azure, gcp | 8,929 / input-mtok, 0,893 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · audio-tokens · priority | aws, azure, gcp | 16,071 / input-mtok, 1,607 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · batch | aws, azure, gcp | 89,286 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · image-tokens · ppt | aws, azure, gcp | 4,464 / input-mtok, 0,446 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · image-tokens · priority | aws, azure, gcp | 8,036 / input-mtok, 0,804 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · text-tokens · ppt | aws, azure, gcp | 4,464 / input-mtok, 26,786 / output-mtok, 0,446 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-flash-lite · text-tokens · priority | aws, azure, gcp | 8,036 / input-mtok, 48,214 / output-mtok, 0,804 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · batch | aws, azure, gcp | 230,429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · long-context · ppt | aws, azure, gcp | 71,429 / input-mtok, 321,429 / output-mtok, 7,143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · long-context · priority | aws, azure, gcp | 128,571 / input-mtok, 578,571 / output-mtok, 12,857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · short-context · ppt | aws, azure, gcp | 35,714 / input-mtok, 214,286 / output-mtok, 3,571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-1-pro · short-context · priority | aws, azure, gcp | 64,286 / input-mtok, 385,714 / output-mtok, 6,429 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash-lite · batch | aws, azure, gcp | 121,429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash-lite · ppt | aws, azure, gcp | 5,357 / input-mtok, 44,643 / output-mtok, 0,536 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash-lite · priority | aws, azure, gcp | 9,643 / input-mtok, 80,357 / output-mtok, 0,964 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash · batch | aws, azure, gcp | 196,429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash · ppt | aws, azure, gcp | 26,786 / input-mtok, 160,714 / output-mtok, 2,679 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-5-flash · priority | aws, azure, gcp | 48,214 / input-mtok, 289,286 / output-mtok, 4,821 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-6-flash · batch | aws, azure, gcp | 74,286 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-6-flash · ppt | aws, azure, gcp | 10,714 / input-mtok, 53,571 / output-mtok, 1,071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-6-flash · priority | aws, azure, gcp | 19,286 / input-mtok, 96,429 / output-mtok, 1,929 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-7-flash-3-8-flash · batch | aws, azure, gcp | 74,286 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-3-7-flash-3-8-flash · ppt | aws, azure, gcp | 10,714 / input-mtok, 53,571 / output-mtok, 1,071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-7-flash-3-8-flash · priority | aws, azure, gcp | 19,286 / input-mtok, 96,429 / output-mtok, 1,929 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-pro-image · image-tokens · ppt | aws, azure, gcp | 35,714 / input-mtok, 2142,86 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-3-pro-image · text-tokens · ppt | aws, azure, gcp | 35,714 / input-mtok, 214,286 / output-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-4-argon · batch | aws, azure, gcp | 71,429 / hour | dbxProprietary | |
| fm-proprietary | google · gemini-4-argon · ppt | aws, azure, gcp | 35,714 / input-mtok, 178,571 / output-mtok, 1,786 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | google · gemini-4-argon · priority | aws, azure, gcp | 64,286 / input-mtok, 321,429 / output-mtok, 3,214 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-2 · batch | aws, azure, gcp | 184,286 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-2 · ppt | aws, azure, gcp | 25 / input-mtok, 200 / output-mtok, 2,5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-2 · priority | aws, azure, gcp | 50 / input-mtok, 400 / output-mtok, 5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-3-codex · ppt | aws, azure, gcp | 25 / input-mtok, 200 / output-mtok, 2,5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-3-codex · priority | aws, azure, gcp | 50 / input-mtok, 400 / output-mtok, 5 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-mini · batch | aws, azure, gcp | 107,143 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-mini · ppt | aws, azure, gcp | 10,714 / input-mtok, 64,286 / output-mtok, 1,071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-mini · priority | aws, azure, gcp | 21,429 / input-mtok, 128,571 / output-mtok, 2,143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-nano · batch | aws, azure, gcp | 71,429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-nano · ppt | aws, azure, gcp | 2,857 / input-mtok, 17,857 / output-mtok, 0,286 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-pro-5-5-pro · batch | aws, azure, gcp | 1142,86 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-pro-5-5-pro · long-context · ppt | aws, azure, gcp | 857,143 / input-mtok, 3857,14 / output-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4-pro-5-5-pro · short-context · ppt | aws, azure, gcp | 428,571 / input-mtok, 2571,43 / output-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · batch | aws, azure, gcp | 192,857 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · long-context · ppt | aws, azure, gcp | 71,429 / input-mtok, 321,429 / output-mtok, 7,143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · priority | aws, azure, gcp | 71,429 / input-mtok, 428,571 / output-mtok, 7,143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-4 · short-context · ppt | aws, azure, gcp | 35,714 / input-mtok, 214,286 / output-mtok, 3,571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5-1 · batch | aws, azure, gcp | 131,429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5-1 · ppt | aws, azure, gcp | 17,857 / input-mtok, 142,857 / output-mtok, 1,786 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5-1 · priority | aws, azure, gcp | 35,714 / input-mtok, 285,714 / output-mtok, 3,571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · batch | aws, azure, gcp | 214,286 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · long-context · ppt | aws, azure, gcp | 142,857 / input-mtok, 642,857 / output-mtok, 14,286 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · priority | aws, azure, gcp | 178,571 / input-mtok, 1071,43 / output-mtok, 17,857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-5 · short-context · ppt | aws, azure, gcp | 71,429 / input-mtok, 428,571 / output-mtok, 7,143 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · batch | aws, azure, gcp | 22,857 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · long-context · ppt | aws, azure, gcp | 5,714 / input-mtok, 25,714 / output-mtok, 0,571 / cache-read-mtok, 7,143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · long-context · priority | aws, azure, gcp | 11,429 / input-mtok, 51,429 / output-mtok, 1,143 / cache-read-mtok, 14,286 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · short-context · ppt | aws, azure, gcp | 2,857 / input-mtok, 17,143 / output-mtok, 0,286 / cache-read-mtok, 3,571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-luna · short-context · priority | aws, azure, gcp | 5,714 / input-mtok, 34,286 / output-mtok, 0,571 / cache-read-mtok, 7,143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · batch | aws, azure, gcp | 171,429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · long-context · ppt | aws, azure, gcp | 114,286 / input-mtok, 428,571 / output-mtok, 11,429 / cache-read-mtok, 142,857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · long-context · priority | aws, azure, gcp | 228,571 / input-mtok, 857,143 / output-mtok, 22,857 / cache-read-mtok, 285,714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · short-context · ppt | aws, azure, gcp | 57,143 / input-mtok, 285,714 / output-mtok, 5,714 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-sol · short-context · priority | aws, azure, gcp | 114,286 / input-mtok, 571,429 / output-mtok, 11,429 / cache-read-mtok, 142,857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · batch | aws, azure, gcp | 153,571 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · long-context · ppt | aws, azure, gcp | 57,143 / input-mtok, 257,143 / output-mtok, 5,714 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · long-context · priority | aws, azure, gcp | 114,286 / input-mtok, 514,286 / output-mtok, 11,429 / cache-read-mtok, 142,857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · short-context · ppt | aws, azure, gcp | 28,571 / input-mtok, 171,429 / output-mtok, 2,857 / cache-read-mtok, 35,714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-6-terra · short-context · priority | aws, azure, gcp | 57,143 / input-mtok, 342,857 / output-mtok, 5,714 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-mini · batch | aws, azure, gcp | 71,429 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-mini · ppt | aws, azure, gcp | 3,571 / input-mtok, 28,571 / output-mtok, 0,357 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-mini · priority | aws, azure, gcp | 6,429 / input-mtok, 51,429 / output-mtok, 0,643 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-5-nano · batch | aws, azure, gcp | 53,571 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-5-nano · ppt | aws, azure, gcp | 0,714 / input-mtok, 5,714 / output-mtok, 0,071 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · long-context · ppt | aws, azure, gcp | 57,143 / input-mtok, 214,286 / output-mtok, 2,857 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · long-context · priority | aws, azure, gcp | 114,286 / input-mtok, 428,57 / output-mtok, 5,714 / cache-read-mtok, 142,857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · short-context · ppt | aws, azure, gcp | 28,571 / input-mtok, 142,857 / output-mtok, 1,429 / cache-read-mtok, 35,714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-1-sol · short-context · priority | aws, azure, gcp | 57,143 / input-mtok, 285,71 / output-mtok, 2,857 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · batch | aws, azure, gcp | 357,143 / hour | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · long-context · ppt | aws, azure, gcp | 285,714 / input-mtok, 1071,43 / output-mtok, 28,571 / cache-read-mtok, 357,143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · long-context · priority | aws, azure, gcp | 571,429 / input-mtok, 2142,86 / output-mtok, 57,143 / cache-read-mtok, 714,286 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · short-context · ppt | aws, azure, gcp | 142,857 / input-mtok, 714,286 / output-mtok, 14,286 / cache-read-mtok, 178,571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-astra · short-context · priority | aws, azure, gcp | 285,714 / input-mtok, 1428,57 / output-mtok, 28,571 / cache-read-mtok, 357,143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · long-context · ppt | aws, azure, gcp | 2,857 / input-mtok, 10,71 / output-mtok, 0,286 / cache-read-mtok, 3,571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · long-context · priority | aws, azure, gcp | 5,714 / input-mtok, 21,43 / output-mtok, 0,571 / cache-read-mtok, 7,143 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · short-context · ppt | aws, azure, gcp | 1,429 / input-mtok, 7,143 / output-mtok, 0,143 / cache-read-mtok, 1,786 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-luna · short-context · priority | aws, azure, gcp | 2,857 / input-mtok, 14,29 / output-mtok, 0,286 / cache-read-mtok, 3,571 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · long-context · ppt | aws, azure, gcp | 57,143 / input-mtok, 214,29 / output-mtok, 5,714 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · long-context · priority | aws, azure, gcp | 114,286 / input-mtok, 428,57 / output-mtok, 11,429 / cache-read-mtok, 142,857 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · short-context · ppt | aws, azure, gcp | 28,571 / input-mtok, 142,857 / output-mtok, 2,857 / cache-read-mtok, 35,714 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-6-sol · short-context · priority | aws, azure, gcp | 57,143 / input-mtok, 285,71 / output-mtok, 5,714 / cache-read-mtok, 71,429 / cache-write-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-5 · image-tokens · ppt | aws, azure, gcp | 114,286 / input-mtok, 457,143 / output-mtok, 28,571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-5 · text-tokens · ppt | aws, azure, gcp | 71,429 / input-mtok, 142,857 / output-mtok, 17,857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-mini · image-tokens · ppt | aws, azure, gcp | 35,714 / input-mtok, 114,286 / output-mtok, 3,571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1-mini · text-tokens · ppt | aws, azure, gcp | 28,571 / input-mtok, 2,857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1 · image-tokens · ppt | aws, azure, gcp | 142,857 / input-mtok, 571,429 / output-mtok, 35,714 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-1 · text-tokens · ppt | aws, azure, gcp | 71,429 / input-mtok, 17,857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-2 · image-tokens · ppt | aws, azure, gcp | 114,286 / input-mtok, 428,571 / output-mtok, 28,571 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | openai · gpt-image-2 · text-tokens · ppt | aws, azure, gcp | 71,429 / input-mtok, 17,857 / cache-read-mtok | dbxProprietary | |
| fm-proprietary | spacexai · grok-4-6-4-7 · batch | aws, azure, gcp | 153,571 / hour | dbxProprietary | |
| fm-proprietary | spacexai · grok-4-6-4-7 · ppt | aws, azure, gcp | 35,714 / input-mtok, 107,143 / output-mtok, 8,929 / cache-read-mtok | dbxProprietary | |
| lakebase | autoscaling | azure | 0,213 / cu-hour | lakebase-cu-hour / cu-hour | learnServerless, dbxCards |
| lakebase | always-on | tous | non publié | lakebase-always-on-cu-hour / cu-hour | dbxLakebase, dbxCards |
| lakebase | storage | aws, azure, gcp | 15 / gb-month | lakebase-storage-gb-month / gb-month | learnServerless, dbxLakebase, dbxCards |
| lakebase | pitr | tous | conflit | lakebase-pitr-gb-month / gb-month | dbxCards |
| lakebase | snapshot | aws, azure, gcp | 3,91 / gb-month | lakebase-snapshot-gb-month / gb-month | learnServerless, dbxLakebase, dbxCards |
| lakeflow-connect | pipeline | aws, azure, gcp | 1 / dbu | dbxLakeflowConnect | |
| model-serving | cpu | aws, azure, gcp | 4 / node-hour | dbxModelServing | |
| model-serving | cpu-concurrency | azure | 1 / concurrency-hour | learnServerless | |
| model-serving | gpu-a100-40gb-x8 | aws, azure | 538,4 / instance-hour | dbxModelServing | |
| model-serving | gpu-a100-80gb-x1 | azure | 78,6 / instance-hour | learnServerless | |
| model-serving | gpu-a100-80gb-x2 | azure | 157,2 / instance-hour | learnServerless | |
| model-serving | gpu-a100-80gb-x4 | azure | 314,4 / instance-hour | learnServerless | |
| model-serving | gpu-a100-80gb-x8 | aws, azure | 628 / instance-hour | dbxModelServing | |
| model-serving | gpu-a10g-x1 | aws, azure, gcp | 20 / instance-hour | dbxModelServing | |
| model-serving | gpu-a10g-x4 | aws, azure | 112 / instance-hour | dbxModelServing | |
| model-serving | gpu-a10g-x8 | aws, azure | 290,8 / instance-hour | dbxModelServing | |
| model-serving | gpu-h100-x1 | aws, azure | 100 / instance-hour | dbxModelServing | |
| model-serving | gpu-h100-x8 | aws, azure | 800 / instance-hour | dbxModelServing | |
| model-serving | gpu-l40s-x1 | aws | 44,86 / instance-hour | dbxModelServing | |
| model-serving | gpu-rtx-pro-6000-x1 | aws | 80 / instance-hour | dbxModelServing | |
| model-serving | gpu-rtx-pro-6000-x1 | azure | 94,29 / instance-hour | dbxModelServing | |
| model-serving | gpu-t4-x1 | aws, azure | 10,48 / instance-hour | dbxModelServing, learnServerless | |
| platform-addons | esc | aws, gcp | 0,15 / share | dbxPlatformAddons | |
| platform-addons | esc | azure | 0,1 / share | dbxPlatformAddons | |
| platform-addons | mission-critical | aws, azure | 0,3 / share | dbxPlatformAddons | |
| platform-addons | dr-replication | tous | non publié | dr-replication-gb / gb | dbxCards |
| shutterstock | image | azure | 0,857 / image | shutterstock-image / image | learnServerless, dbxCards |
| vector-search | standard | aws, azure, gcp | 4 / unit-hour | vs-standard-unit-hour / unit-hour | dbxAiSearch, learnServerless, dbxCards |
| vector-search | storage-optimized | aws, azure, gcp | 18,286 / unit-hour | vs-storage-optimized-unit-hour / unit-hour | dbxAiSearch, learnServerless |
| vector-search | reranker | aws, azure, gcp | 28,571 / k-requests | learnServerless, dbxAiSearch | |
| vector-search | standard-storage | azure | 10 / gb-month | vs-standard-gb-month / gb-month | learnServerless, dbxAiSearch, dbxCards |
| vector-search | storage-optimized-storage | tous | non publié | vs-storage-optimized-gb-month / gb-month | dbxCards |
| zerobus | standard | aws, azure, gcp | 0,143 / gb | zerobus-gb / gb | dbxLakeflowConnect, dbxCards |
| zerobus | otel | aws, azure, gcp | 0,222 / gb | zerobus-otel-gb / gb | dbxLakeflowConnect, dbxCards |
Sources (lues le 2026-10-26) :
-
dbxCards: Databricks: pricing pages data, list prices per product, plan, cloud and region (databricks.com), https://www.databricks.com/product/pricing (données de prix des pages,cards.json) -
dbxModelServing: Databricks: Model Serving pricing page (databricks.com), https://www.databricks.com/product/pricing/model-serving (données de la page en JSON) -
dbxFoundationModels: Databricks: Foundation Model Serving pricing page (databricks.com), https://www.databricks.com/product/pricing/foundation-model-serving (données de la page en JSON) -
dbxProprietary: Databricks: Proprietary Foundation Model Serving pricing page (databricks.com), https://www.databricks.com/product/pricing/proprietary-foundation-model-serving (données de la page en JSON) -
dbxAiSearch: Databricks: AI Search pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-search (données de la page en JSON) -
dbxLakebase: Databricks: Lakebase pricing page (databricks.com), https://www.databricks.com/product/pricing/lakebase (données de la page en JSON) -
dbxApps: Databricks: Databricks Apps pricing page (databricks.com), https://www.databricks.com/product/pricing/databricks-apps (données de la page en JSON) -
dbxLakeflowConnect: Databricks: Lakeflow Connect pricing page (databricks.com), https://www.databricks.com/product/pricing/lakeflow-connect (données de la page en JSON) -
dbxAiFunctions: Databricks: AI Functions pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-functions (données de la page en JSON) -
dbxAiGateway: Databricks: Unity Gateway pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-gateway (données de la page en JSON) -
dbxAgentEvaluation: Databricks: Agent Evaluation pricing page (databricks.com), https://www.databricks.com/product/pricing/agent-evaluation (données de la page en JSON) -
dbxAiRuntime: Databricks: AI Runtime pricing page (databricks.com), https://www.databricks.com/product/pricing/ai-runtime (données de la page en JSON) -
dbxStorage: Databricks: Storage pricing page (databricks.com), https://www.databricks.com/product/pricing/storage (données de la page en JSON) -
dbxPlatformAddons: Databricks: Platform tiers and add-ons pricing page (databricks.com), https://www.databricks.com/product/pricing/platform-addons (données de la page en JSON) -
learnServerless: Microsoft Learn: Serverless DBU consumption by SKU (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/resources/pricing -
learnServingCost: Microsoft Learn: Monitor model serving costs (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/model-serving-cost -
learnBilling: Microsoft Learn: Billable usage system table reference (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/billing -
learnListPrices: Microsoft Learn: Pricing system table reference (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/system-tables/pricing -
learnDefaultStorage: Microsoft Learn: Monitor default storage costs (Azure Databricks), https://learn.microsoft.com/en-us/azure/databricks/admin/usage/default-storage -
azureCalculator: Microsoft Azure: Azure Databricks pricing calculator data (azure.microsoft.com), https://azure.microsoft.com/pricing/details/databricks (données : https://azure.microsoft.com/api/v3/pricing/databricks/calculator/)
Données relues comme hostiles. Les lignes de list-prices passent par accountPrices() ; les valeurs saisies par cleanServiceOverrides() (noms connus, nombres seulement, de 0 à 1 000 pour un prix, jamais une clé de prototype). Le code est dans extension/lib/calc-services-price.mjs ; les tests dans tests/v0250-rates25.test.mjs, dont les exemples publiés recalculés (AI Search : 5 millions de vecteurs, 3 unités, 720 heures, 8 640 DBU, 605 $ ; Databricks Apps : 5 applications Medium pendant 30 jours, 1 800 DBU, 1 350 $).
13.12 Chiffrer un service dans une estimation (0.25)
Depuis la 0.25, une estimation chiffre aussi les services de la section 13.11, à côté de ses jobs, pipelines, SQL warehouses et clusters : « Service » dans la barre d'ajout ouvre un menu en deux groupes, « IA et modèles » (Model Serving, Foundation Model APIs, modèles propriétaires, AI Search, Agent Evaluation, Unity AI Gateway, AI Parse, AI Extract, AI Classify, AI Runtime, Shutterstock ImageAI) et « Données et plateforme » (Lakebase, Databricks Apps, Lakeflow Connect, Zerobus Ingest, stockage par défaut, options de plateforme). Une charge de service passe par le même moteur que les autres (estimateLine, estimateTotals) : elle compte dans le total au centime, dans l'état du chiffrage, la comparaison, les exports et les deux façons de rouvrir une estimation. Le code est dans extension/lib/calc-services.mjs (moteur, pur) et extension/lib/calc-services-ui.mjs (formulaires).
Une charge de service. Elle porte un type, une clé de taux (un modèle et son mode, une taille, un type d'endpoint ; les choix sont ceux que le cloud de l'estimation propose dans le relevé) et des quantités par mois. Elle se découpe en parties, une par clé de taux et par unité, chacune avec sa quantité q :
| Type | Quantités saisies | Parties et q |
|---|---|---|
| Model Serving | instances (ou nœuds, ou requêtes simultanées), heures par mois | instances × heures, dans l'unité du taux choisi |
| AI Search | vecteurs (millions), dimensions, heures, stockage (Go), requêtes reclassées (milliers) | unités = ⌈vecteurs × dimensions ÷ 768 ÷ capacité d'une unité⌉, q = unités × heures ; stockage max(0, Go − part gratuite) ; reclassement en milliers de requêtes |
| Foundation Model APIs, modèles propriétaires | millions de jetons par type (entrée, sortie, cache) ; ou unités de modèle et heures (débit provisionné) ; ou heures (lots) | un q par type de jeton ; heures × unités ÷ 50 ; heures |
| Agent Evaluation | jetons du juge (entrée, sortie), questions synthétiques | une partie par unité |
| Unity AI Gateway | Go et millions de jetons, tables d'inférence et suivi d'usage | une partie par fonction et par unité |
| AI Parse, AI Extract, AI Classify | milliers de pages, d'entrées, de documents | une partie, à plage |
| AI Runtime | GPU, heures par GPU | GPU × heures |
| Shutterstock ImageAI | images | images |
| Lakebase | nœuds, CU minimum et maximum, heures au maximum, mise à zéro et heures actives, stockage, PITR, instantanés (Go) | voir plus bas |
| Databricks Apps | applications, heures actives | applications × heures |
| Lakeflow Connect | DBU par jour et par workspace (mesurés sur un essai), workspaces, jours | workspaces × max(0, DBU par jour − part gratuite) × jours |
| Zerobus Ingest | Go ingérés | Go |
| Stockage par défaut | Go stockés (moyenne du mois, en Go-mois), milliers d'opérations de niveau 1 et 2 | une partie par unité |
| Options de plateforme | aucune (part de la dépense) ; Go répliqués pour la reprise après sinistre | voir plus bas |
Une quantité principale vide reste à saisir : la charge est « hypothèses manquantes », jamais chiffrée à 0. Une quantité facultative laissée vide (par exemple des jetons lus en cache) compte pour « pas utilisée ».
Le prix d'une unité et son origine. Pour chaque partie, la règle de la section 13.11, appliquée aux valeurs saisies dans la charge : un prix par unité saisi ; sinon le taux (saisi, ou celui du relevé) × un prix d'un DBU (ou d'un DSU) saisi ou du compte (system.billing.list_prices, lu à la demande) ; sinon le prix public de l'unité quand les données de prix le donnent ; sinon le taux × le prix public d'un DBU. Coût de la partie = q × prix de l'unité × facteur × (1 − remise), arrondi au centime ; la charge est la somme de ses parties, l'estimation la somme de ses charges. Chaque partie montre son origine : saisi, prix du compte ou prix public, et la ligne « Origine des prix » les résume. Les DBU (ou DSU) d'une partie sont q × taux × facteur quand le taux est publié ; une partie au seul prix public par unité n'a pas de DBU connus, ce que l'écran dit.
Plages. AI Parse, AI Extract et AI Classify publient des DBU par millier sous forme de plage (par exemple 10 à 15 DBU par millier de pages de texte simple). La partie a alors un bas q × min × prix et un haut q × max × prix, chacun arrondi au centime ; son chiffre est le milieu de la plage, (bas + haut) ÷ 2 en centimes, une règle dite comme telle (hypothèse listée « à vérifier »). Le bas et le haut s'additionnent dans le total de l'estimation (« plage des services ») et dans son année (× 12). Exemple : 10 milliers de pages de texte simple à 0,07 $ le DBU donnent 7,00 $ à 10,50 $, soit 8,75 $.
Parts gratuites, par une règle publiée.
- AI Search Standard : le stockage au-delà de 30 Go seulement (FAQ de la page AI Search : « Storage Overage for storage volumes greater than 30GB »), pour l'index de la charge. Aucune part gratuite n'est publiée pour Storage Optimized : tout son stockage est compté, et l'écran le dit.
- Lakeflow Connect : 100 DBU gratuits par jour et par workspace pour les connecteurs gérés (FAQ de la page Lakeflow Connect). Les DBU par jour d'un workspace se mesurent sur un essai ; au-dessous de la part gratuite, le coût est 0 $, chiffré et dit. La passerelle d'une base de données est un pipeline classique Advanced, à ajouter comme pipeline.
-
Lakebase : une instance sans mise à zéro pendant plus de 24 heures est « toujours allumée » (FAQ de la page Lakebase). Toujours allumée :
nœuds × CU minimum × 730 hau prix « always-on », puisnœuds × (CU maximum − CU minimum) × heures au maximumau prix autoscaling. Avec mise à zéro :nœuds × (CU minimum × (heures actives − heures au maximum) + CU maximum × heures au maximum)au prix autoscaling. Le stockage, la restauration à un instant et les instantanés se paient au Go-mois.
Majoration régionale. Un modèle marqué ⌖ servi depuis un point d'accès régional (pour garder les données dans une zone) coûte DBU × (1 + majoration) : la majoration est une saisie de la charge, 10 % par défaut, la valeur du relevé (inGeoUplift) ; le facteur multiplie aussi les DBU affichés.
Options de plateforme, calculées après les autres charges. Enhanced Security and Compliance (15 % sur AWS et GCP Enterprise, 10 % sur Azure Premium) et Mission Critical (30 % sur AWS Enterprise et Azure Premium ; 15 % en promotion jusqu'au 30 juin 2027, à cocher, la date affichée) sont une part de la dépense des produits au prix catalogue, avant remises, des autres charges de l'estimation (prises comme les charges des workspaces où l'option est active, une hypothèse de l'estimation) : les DBU × le prix d'un DBU utilisé pour une charge nouvelle, le coût catalogue d'une charge mesurée, le coût avant remise d'une charge de service ; jamais les machines du cloud, ni les options elles-mêmes. Une autre charge non chiffrée rend la base incomplète : l'option n'est alors pas chiffrée (jamais sur une partie de la dépense), et l'écran dit combien de charges manquent. Mission Critical comprend Enhanced Security and Compliance : avec les deux, ou deux fois la même, l'option comprise est à retirer (« hypothèses manquantes »). Une option demande son plan (Enhanced Security and Compliance sur AWS : Enterprise). La réplication de reprise après sinistre se paie au Go, au prix public. Une plage dans la base donne une plage à l'option.
Remises du contrat, par unité de facturation. Les deux remises existantes s'appliquent ainsi :
| Ce que la partie facture | Remise | Raison |
|---|---|---|
| des DBU (taux en DBU, ou prix par unité d'un service facturé en DBU : modèles, AI Search, Apps, Lakebase calcul, AI Runtime, Zerobus, Lakeflow Connect, AI Functions, Gateway, Agent Evaluation, Shutterstock) | remise DBU | le contrat Databricks remise les DBU |
| du stockage : DSU, ou stockage au Go-mois (stockage par défaut, stockage AI Search, Lakebase stockage, PITR et instantanés) | aucune | Microsoft Learn, Optimize Azure Databricks costs with a prepurchase : la remise d'un prépaiement « s'applique seulement à l'usage en DBU », le stockage est « facturé à part » |
| une option de plateforme (part de la dépense, réplication) | aucune | elle se calcule sur la dépense au prix catalogue avant remises |
La remise machines ne s'applique jamais à un service : il n'a pas de machines du cloud ici. Un contrat qui remise aussi le stockage se reflète par un prix d'un DSU saisi. Exemple : 100 heures d'une application Medium (0,375 $ l'heure sur AWS us-east-1) avec 25 % de remise DBU font 100 × 0,375 × 0,75 = 28,13 $ ; 1 000 Go-mois de stockage par défaut à 0,023 $ le DSU restent 23,00 $.
Ce qui n'est pas publié. Quand rien ne donne le prix d'une unité (section 13.11 : non publié, ou deux sources officielles qui se contredisent sans prix public de l'unité), la partie n'est pas chiffrée et la charge non plus : « hypothèses manquantes », avec la raison (taux non publié pour ce cloud, prix d'un DBU du SKU non publié, conflit et ses deux valeurs) et les pages vérifiées (notPublished). La charge propose alors de saisir le taux en DBU par unité (multiplié par le prix d'un DBU), le prix d'un DBU de son SKU, ou directement le prix de l'unité ; la valeur saisie est gardée avec la charge et s'affiche « saisi ». Un choix qui n'existe pas sur le cloud de l'estimation (un GPU absent, Mission Critical sur GCP) est dit, avec la demande d'en choisir un autre ; une estimation qui change de cloud garde ses charges de services, chiffrées pour le nouveau cloud, et le message dit combien n'y existent pas. Sans région, rien n'est chiffré (« région à choisir »). Une région que le relevé des services ne couvre pas laisse la partie « non chiffrée », avec la raison.
Les prix du compte. Une ligne au-dessus des charges dit combien de prix des services viennent du compte et quand ils ont été lus ; « Lire les prix de mon compte » lance la requête en lecture seule yalineo:list-prices quand un workspace est connecté. Une estimation enregistrée garde les prix qu'elle a utilisés : la relire telle qu'enregistrée garde ses prix publics même après la lecture du compte ; « Recalculer avec les données actuelles » prend ceux du compte.
Ce qu'une estimation garde. Pour chaque clé de taux utilisée, l'estimation garde le taux (DBU ou DSU par unité, un nombre ou une plage), le prix d'un DBU ou d'un DSU (public ou du compte, avec le nom du SKU du compte) et les prix publics des unités, chacun avec la date de son relevé. Rouverte telle qu'enregistrée, elle redonne le même total au centime ; un relevé plus récent ne la change que dans « Recalculer avec les données actuelles », l'écart étant compté dans la part des prix (section 13.8). Les valeurs saisies dans une charge sont ses réglages : elles s'appliquent toujours. Tant que le relevé des services se charge, ce qui était gardé reste gardé. Relus comme hostiles : un type connu, une clé de la forme documentée (jamais __proto__ ni constructor), des unités connues, des nombres seulement et dans leurs bornes (une chaîne, NaN ou un nombre énorme est laissé de côté, jamais converti), des origines connues ; une charge d'un type inconnu est laissée de côté. La part d'une option de plateforme n'est gardée que comme un nombre de 0 à 1 ; une part qui n'en est pas une (une autre unité, une plage, plus de 100 %) ne chiffre jamais l'option : elle reste « hypothèses manquantes » (R-140). Une quantité dont la clé de taux manque aux données est dite de même, jamais comptée pour 0 dans une charge chiffrée (R-141). Des tests d'attaque le vérifient (tests/security.test.mjs).
Exports. Le CSV garde ses colonnes de la 0.23 (une ligne par charge, de type service <type>, puis le total) et ajoute, quand l'estimation a des services, une seconde table, partie par partie : type, clé de taux, unité, quantité par mois, taux et son unité, origine du taux, prix d'un DBU ou d'un DSU et son origine, prix de l'unité et son origine, remise, coût par mois, bas et haut, état. Le résumé copié en Markdown donne la plage et chaque charge de service partie par partie. Toutes les cellules et tous les textes restent inertes (lib/csv.mjs, mdText).
Cas pratiques de services. Quatre cas s'ajoutent aux six de la section 13.3, avec la même structure (le besoin, les informations à réunir, quoi essayer, quoi retenir) ; leurs entrées sont des hypothèses fictives, dites dans le guide et les notes, leurs taux et leurs prix viennent du relevé :
- l'assistant documentaire (AI Search Standard, 2 millions de vecteurs de 1 024 dimensions, 50 Go ; Llama 3.3 70B au jeton, 60 et 12 millions de jetons ; un nœud Model Serving CPU ; une application Medium 264 heures) ;
- les factures des fournisseurs (AI Parse, 30 000 pages ; AI Extract, 20 000 factures ; un job serverless de 4 DBU par exécution, une par jour) ;
- l'application des techniciens (Lakebase, 1 nœud de 1 à 4 CU, toujours allumée, 120 heures au maximum, 100 Go et 50 Go de restauration ; deux applications Medium tout le mois) : 675,49 $ par mois sur AWS us-east-1 ;
-
les capteurs et le CRM en continu (Zerobus, 600 Go ; Lakeflow Connect, 160 DBU par jour sur un workspace) : 668,75 $ par mois sur AWS us-east-1, dont
(160 − 100) × 365 ÷ 12 × 0,35 =638,75 $ de Lakeflow Connect.
Une estimation ouverte d'un cas garde la clé du cas (caseId), comme les six autres. Son titre, ses notes et le nom de ses charges suivent la langue de la page tant que l'utilisateur ne les a pas renommés, comme ceux des six autres cas ; le nom d'une charge ajoutée par le menu « Service » (le nom de son type) aussi.
Chiffrer un projet de données (section 13.9). Le modèle en service d'un projet, dimensionné en DBU par jour, prend le prix d'un DBU de Model Serving (SKU Serverless Real-Time Inference : celui du compte, sinon le prix public de la région et du plan) tant qu'aucun prix n'est saisi ; le champ le dit, un prix saisi l'emporte. Genie n'a pas de taux dans le relevé des services (son modèle de langage reste hors du périmètre d'un projet, section 13.9) ; depuis la 0.32, la page « IA : Genie et agents » le chiffre à partir des DBU par question mesurés, au prix d'un DBU de ce même SKU Serverless Real-Time Inference (section 13.16).
Vérification. tests/v0250-svc25.test.mjs recalcule chaque formule par type, les exemples publiés à travers l'estimation (AI Search : 5 millions de vecteurs, 3 unités, 720 heures, 8 640 DBU, 604,80 $ soit 605 $ ; Storage Optimized : 50 millions de vecteurs, 1 unité, 13 166 DBU, 921,60 $ soit 922 $ ; Databricks Apps : 5 applications Medium 720 heures, 1 800 DBU, 1 350 $ ; Kimi K3 : 3,00 $ par million de jetons en entrée sur AWS), les plages, les parts gratuites, la majoration, les options, la règle des remises, les totaux au centime, les prix gardés et les quatre cas sur les trois clouds.
13.13 Outils d'estimation : prix du compte, jetons, Excel, fichier, assistant (0.25)
Depuis la 0.25, le Calculateur a cinq outils de plus. Aucun n'ajoute de règle de calcul : ils lisent, comparent ou exportent les chiffres des sections 13.1 à 13.11.
Prix des SKU (page « Prix des SKU », volet Simulations). « Lire les prix de mon compte » lance la requête yalineo:list-prices (section 13.11), seulement sur ce clic ; ses lignes passent par accountPrices() et restent dans la mémoire de la page. Chaque SKU montre son unité, son prix catalogue, son prix effectif (promotions comprises, quand la colonne existe) et son premier jour. La famille d'un SKU est un mot de son nom (le plan laissé de côté), par exemple JOBS, SQL, SERVERLESS. Pour un SKU, quantité × prix = quantité saisie × prix effectif (sinon prix catalogue), arrondi au centime une fois ; le total des quantités saisies est la somme de ces montants arrondis. Ce sont des prix avant les remises contractuelles. Sans prix du compte (exemple fictif, pas de workspace, droit de lecture refusé, aucune ligne lisible), la page montre les prix publics des relevés embarqués, dits comme tels avec leur date : le prix du DBU de chaque produit du relevé du cloud pour la région et le plan choisis, puis le prix de chaque SKU du relevé des services (un prix mondial pour les fournisseurs de modèles). Un SKU des services au même prix qu'un produit du relevé du cloud n'est pas répété ; à un autre prix, les deux restent, chacun avec sa source. L'export CSV passe par lib/csv.mjs.
Prix des jetons (page « Prix des jetons »). Pour chaque modèle coché (servi par Databricks ou propriétaire, tirés du relevé des services), un mois d'utilisation est chiffré par les formules de la section 13.11 : jetons Σ millions × DBU par million × prix d'un DBU ; lot heures × DBU par heure × prix d'un DBU ; débit provisionné heures × (unités de modèle ÷ 50) × DBU par heure × prix d'un DBU (sans réservation, réservé 1 mois ou 3 mois) ; un point de terminaison dans la zone géographique d'un modèle marqué ⌖ : DBU × (1 + 10 %). Le prix d'un DBU suit l'ordre de la section 13.11 (saisi, sinon du compte, sinon public) et son origine est affichée. Le coût par mois est arrondi au centime une fois, par an = 12 × par mois. Le tableau classe d'abord les modèles chiffrés en entier, du moins cher au plus cher ; puis les modèles partiels (une quantité saisie sans taux publié pour ce modèle, par exemple des jetons de sortie pour un modèle d'embeddings) ; puis ceux sans prix ou sans taux du type choisi, avec la raison. Rien de ce qui n'est pas publié ne compte pour zéro. Un prix d'un DBU non publié nomme le SKU en entier, tel que le relevé l'écrit (en anglais, jamais coupé ni traduit), et les pages vérifiées. « Ajouter à l'estimation », sur chaque modèle chiffré, en fait une charge de service (section 13.12) : son type, sa clé de taux pour le tarif affiché et les quantités saisies (millions de jetons de chaque sorte, ou heures et unités de modèle), le point de terminaison régional quand il est appliqué. Elle rejoint l'estimation ouverte du même cloud, sinon une nouvelle estimation « Modèles comparés » (60 charges et 30 estimations au plus) ; elle y est chiffrée avec la région, le plan et les remises de l'estimation, chaque partie arrondie au centime : son coût avant remise peut différer de celui du comparateur d'un centime par partie au plus.
Export Excel (« Exporter en Excel », à côté de « Exporter en CSV »). Un classeur de quatre feuilles, écrit sans bibliothèque (lib/sheet.mjs) : Résumé (l'estimation, son cloud, sa région, son plan, ses remises, ses totaux par mois et par an, son état de chiffrage avec ce qui manque, les hypothèses à vérifier et ce qui est hors périmètre, les données avec lesquelles elle est calculée, la date des relevés et des prix du compte, d'où viennent les valeurs) ; Lignes (une ligne par charge, lue de façon générique dans le résultat de son calcul : nom, type, description, champs, heures et exécutions par mois, DBU, chaque part du coût, total par mois et par an, état, origines, manques, calcul pas à pas) ; Prix utilisés (chaque valeur qu'une charge a utilisée, avec son origine et le nom de ses sources) ; Notes (les sections de cette méthodologie). Les nombres sont des nombres, le texte est du texte en ligne, jamais une formule ; les caractères que XML refuse sont retirés. Les lignes s'additionnent au total au centime, comme à l'écran. Une charge de service y a ses propres parts, en mots (bas et haut d'une plage, prix catalogue avant remise, DSU, une quantité et non un montant), son calcul pas à pas et, dans « Prix utilisés », chaque prix d'unité avec son type, le nom de son taux, son unité et les sources du relevé des services.
Fichier d'une estimation (« Exporter le fichier de l'estimation », « Importer une estimation »). Pour partager une estimation sans serveur : un fichier JSON { format: 'yalineo-estimate', version: 1, exported, estimate }, l'estimation telle qu'elle est gardée, avec les valeurs de ses prix (section 13.8). L'import lit un fichier choisi par l'utilisateur comme une donnée hostile : 1 Mo au plus, JSON.parse seulement, format et version vérifiés, puis cleanEstimate champ par champ (noms connus, nombres bornés, aucune clé de prototype, 60 charges au plus) ; une charge d'un type inconnu, ou une charge de service d'un type de service inconnu, est écartée et comptée, jamais changée en une autre ; les charges au-delà de 60 sont comptées à part. L'estimation importée reçoit un nouvel identifiant, de nouveaux identifiants de charges et un nom marqué « (importée) » ; la limite de 30 estimations s'applique. Ses prix gardés viennent du fichier : « Recalculer avec les données actuelles » les compare aux prix du jour.
Assistant (réglage du Calculateur, désactivé par défaut). L'utilisateur donne le nom d'un point de terminaison de service de son workspace (lettres, chiffres, _, ., -, 64 caractères au plus) et l'active. Sur la page d'une estimation, « Décrire une charge » envoie, sur le clic « Proposer » seulement, une requête yalineo:assistant : SELECT ai_query(:endpoint, :prompt) AS answer, deux paramètres nommés, passée par la garde de lecture seule. Le prompt est fait d'instructions fixes, des types de charge et de leurs champs tirés du code du Calculateur (valeurs permises de ses listes, bornes de son propre nettoyage), des types de service sous la forme d'une charge de service (le type, une clé de taux proposée sur le cloud de l'estimation, les saisies du type avec leurs bornes, ses mesures tirées du relevé des services), puis de la description (2 000 caractères au plus) ; il ne dépasse jamais sa borne et la description n'est jamais coupée. La réponse est une donnée hostile : le premier objet ou tableau JSON est lu (balayage borné, JSON.parse seulement), 20 propositions au plus, chacune vérifiée champ par champ (champs connus, nombres finis dans les bornes, valeurs des listes, types de machine de la forme documentée, texte comme texte) avant que cleanLine en fasse une charge ; une charge de service passe par cleanServiceProposal (un type connu, une clé de taux proposée sur ce cloud, jamais devinée quand le type demande un choix, des saisies du type dans leurs bornes) ; ce qui est écarté est dit, avec la raison. Rien n'est ajouté sans un clic de l'utilisateur, charge par charge ou toutes. La description n'est pas enregistrée ; le journal de santé ne garde que le code d'une erreur de cette requête. Databricks facture l'appel au compte de l'utilisateur et peut garder la requête dans son historique. La description part vers le point de terminaison nommé ; s'il sert un modèle externe (OpenAI, Anthropic, Google…), Databricks la transmet à ce fournisseur ; un point de terminaison sans outils est à choisir, un agent doté d'outils pourrait agir. L'écran le dit.
13.14 Régler, dimensionner, acheter : les outils des Simulations par capacité (0.27)
Depuis la 0.27, le volet Simulations range ses calculs par capacité (ingénierie, science des données, analytique, tableaux de bord, architecture) et par poste. Huit outils s'ajoutent aux cinq de la section 13.10 ; leur code est dans extension/lib/calc-tune.mjs. Depuis la 0.32, un neuvième, « Dimensionner une ingestion de données » (ingestion, section 13.14.9), suit les mêmes règles ; son code est dans extension/lib/calc-ingest32.mjs et ses pages ont été lues le 30 octobre 2026. Chacun dit sa formule en mots, pas à pas, avec les chiffres de l'utilisateur ; chaque pas cite sa page officielle (lue le 27 octobre 2026) ou est dit « dérivé » (une opération sur les pas précédents). Les prix viennent seulement du moteur du Calculateur : estimate pour une heure de la charge (DBU × prix du DBU et machines, moins les remises de l'estimation), avec le relevé daté de l'estimation ou les prix saisis ; l'outil n'écrit aucun prix. Il rend chaque prix que sa réponse a utilisé (prices), tel que l'estimation l'a lu, avec son origine : le DBU du produit, chaque machine avec son mode de paiement (le driver à part), les machines d'un cluster de warehouse saisies, le coût d'une heure mesuré (timeout d'un job) ou le prix du stockage saisi (fichiers Delta) ; « Prix utilisés et leur origine » les montre (section 13.15). Un chiffre mesuré qui manque est listé (missing) et rien n'est calculé à sa place ; sans prix pour une machine ou un produit (par exemple les machines GCP, que le relevé ne publie pas), le dimensionnement est donné sans coût, et l'écran le dit. Les montants sont arrondis au centime une fois ; un total affiché comme somme de parties est la somme de ces parties arrondies. Les exemples racontent des cas fictifs (aucune entreprise réelle) ; leurs prix sont ceux du relevé de l'estimation.
Les saisies sont relues comme des données hostiles : seules les propriétés propres de valeur sont lues (jamais un accesseur, jamais __proto__, constructor ni prototype), un nombre doit être un nombre fini et il est ramené dans ses bornes, une liste est lue sur 200 valeurs au plus, un choix doit appartenir à sa liste. Un calcul ne lève jamais d'exception : au pire, il ne calcule rien.
Valeurs par défaut. Une valeur par défaut est soit celle de Databricks, avec sa page (relances, délai, rétention, arrêt automatique), soit une convention de YALineo dite comme telle (marge de 20 % d'un timeout, comme la fenêtre d'un job de la section 13.10 ; 22 jours de lecture par mois, comme les briques de la section 13.9 ; mois moyen de 365 ÷ 12 jours), soit 0 quand 0 veut dire « non compté ».
13.14.1 Timeout et relances d'un job (jobTimeout)
-
Base : le 95e centile mesuré des durées. Saisi, il l'emporte ; sinon il est calculé sur la liste des exécutions par la méthode du rang le plus proche, rang
⌈0,95 × n⌉des durées triées (avec moins de 20 exécutions, ce rang est la dernière : l'outil le dit) ; sinon la durée la plus longue, dite comme une base plus large. -
Timeout
T = ⌈base × (1 + marge)⌉minutes. Databricks ne publie aucune règle chiffrée pour choisir un timeout : la marge est un choix de l'utilisateur (20 % par défaut, une convention de YALineo). Le seuil d'avertissement de durée proposé est la base. -
Tentatives après un timeout
A = relances + 1si la relance après timeout est activée, sinon 1 : par défaut aucun timeout, aucune relance, relance immédiate et pas de relance après un timeout (Microsoft Learn, Jobs API 2.0, https://learn.microsoft.com/azure/databricks/reference/jobs-2.0-api, lu le 27 octobre 2026). -
Pire durée totale
T + (A − 1) × max(T, délai): le timeout s'applique à chaque relance et le délai entre relances se compte depuis le début de l'exécution échouée (Microsoft Learn, Configure and edit tasks in Lakeflow Jobs, https://learn.microsoft.com/azure/databricks/jobs/configure-task, lu le 27 octobre 2026). -
Pire coût d'une exécution
A × T ÷ 60 × prix d'une heure; l'heure est celle du calcul de job à la demande (pilote et workers, Photon s'il est coché), ou le coût d'une heure mesuré et saisi. -
Timeout trop court (le timeout actuel
Csaisi) : la part des exécutions tuées est mesurée sur la liste (durées > C ÷ n) ; sans liste, une borne basse seulement (au moins 50 % sous la médiane, au moins 5 % sous le 95e centile). Coût par moisexécutions par mois × part × A × C ÷ 60 × heure, si chaque tentative dure autant que la première (dit). Un blocage sans timeout coûteheures de blocage × heure. -
Saisies : les durées viennent de
system.lakeflow.job_run_timeline(Microsoft Learn, Jobs system table reference, https://learn.microsoft.com/azure/databricks/admin/system-tables/jobs, lu le 27 octobre 2026). En serverless, l'auto-optimisation relance déjà par défaut (Microsoft Learn, Run your Lakeflow Jobs with serverless compute for workflows, https://learn.microsoft.com/azure/databricks/jobs/run-serverless-jobs, lu le 27 octobre 2026).
13.14.2 Minimum et maximum de workers en autoscaling (autoscale)
-
Workers d'un niveau
⌈cœurs occupés ÷ cœurs d'une machine⌉pour les niveaux bas, moyen et pointe (heures par jour et cœurs mesurés, par exemplecpu_user_percent× cœurs danssystem.compute.node_timeline: Microsoft Learn, Compute system tables reference, https://learn.microsoft.com/azure/databricks/admin/system-tables/compute, lu le 27 octobre 2026). Les cœurs d'une machine viennent du relevé du Calculateur. Minimum = le plus bas, maximum = le plus haut. -
Mois en autoscaling
jours × Σ heures du niveau × prix d'une heure à ses workers; mois à taille fixejours × Σ heures × prix d'une heure au maximum; économie = la différence, au centime. - Ce qui est supposé, et dit : le cluster suit la charge, c'est le meilleur cas. L'autoscaling optimisé (workspaces Premium) monte du minimum au maximum en deux étapes au plus et ne réduit qu'après 40 secondes de sous-utilisation sur un job, 150 secondes sur un cluster polyvalent ; le plan standard ajoute d'abord 8 machines ; un cluster peut descendre sous le minimum quand le cloud reprend des machines ; l'autoscaling réduit mal un flux Structured Streaming (Microsoft Learn, Compute configuration reference, https://learn.microsoft.com/azure/databricks/compute/configure, lu le 27 octobre 2026). Un calcul de job coûte moins qu'un cluster polyvalent pour ce qui tourne sans personne (Microsoft Learn, Best practices for cost optimization, https://learn.microsoft.com/azure/databricks/lakehouse-architecture/cost-optimization/best-practices, lu le 27 octobre 2026).
13.14.3 Dimensionner un flux continu (streamSize)
-
Cœurs
⌈pic × (1 + réserve) ÷ débit d'un cœur⌉; le débit d'un cœur est mesuré lors d'un test (débit tenu ÷ cœurs des workers du test) et supposé constant avec plus de cœurs, un cas favorable dit comme tel. Workers⌈cœurs ÷ cœurs d'une machine⌉; capacitéμ = cœurs du cluster × débit d'un cœur; chargeρ = débit ÷ μ. Le cluster est de taille fixe pour le pic, sans autoscaling (Microsoft Learn, FAQ Apache Kafka, https://learn.microsoft.com/azure/databricks/connect/streaming/kafka/faq, lu le 27 octobre 2026). -
Partitions de shuffle : avec état, 1 à 2 fois les cœurs du cluster, nombre figé par le checkpoint (Microsoft Learn, What is stateful streaming?, https://learn.microsoft.com/azure/databricks/structured-streaming/stateful-streaming, lu le 27 octobre 2026) ; sans état, la valeur par défaut 200 (Microsoft Learn, Adaptive query execution, https://learn.microsoft.com/azure/databricks/optimizations/aqe, lu le 27 octobre 2026). Avec Kafka, sans
minPartitions, une partition Spark par partition du topic (Microsoft Learn, Spark API options reference, https://learn.microsoft.com/azure/databricks/spark/api-options, lu le 27 octobre 2026) : moins de partitions que de cœurs fait attendre des cœurs. -
Déclencheur, d'après le délai voulu
L: sous 1 seconde, le mode temps réel ; sous 5 secondes, le déclencheur par défaut (processingTime 0, latence de 3 à 5 secondes) ; sinonprocessingTime = ⌊L ÷ (1 + ρ au pic)⌋secondes, une règle dérivée (un événement attend au plus un intervalle, puis son lot dure l'intervalle × la charge). Sources : Microsoft Learn, Configure Structured Streaming trigger intervals, https://learn.microsoft.com/azure/databricks/structured-streaming/triggers, lu le 27 octobre 2026 ; en serverless, seul AvailableNow (Microsoft Learn, Serverless compute limitations, https://learn.microsoft.com/azure/databricks/compute/serverless/limitations, lu le 27 octobre 2026). -
En continu
prix d'une heure × 730(au tarif choisi : à la demande ou réservé). Par lots AvailableNow toutes les N minutes : un lot duredémarrage mesuré + N × ρ moyenneminutes et n'est possible que s'il dure moins queN;365 ÷ 12 × 1 440 ÷ Nlots par mois au prix à la demande ; fraîcheur au pireN + durée d'un lot. Le mode par lots n'est recommandé que s'il tient le délai voulu et coûte moins. Sans démarrage mesuré, les lots ne sont pas chiffrés ; sans débit moyen, le pic sert de moyenne (borne haute, dit). -
Rattrapage après un arrêt de
Ominutes : retarddébit moyen × O × 60événements, rattrapé enretard ÷ (μ − débit moyen)(jamais siμne dépasse pas le débit moyen). Volume :pic × Ko ÷ 1 024Mo/s ;moyenne × Ko × 86 400 ÷ 1 024²Go par jour.
13.14.4 Fichiers et partitions d'une table Delta (deltaFiles)
-
Taille cible des fichiers (autotuning) : 256 Mo sous 2,56 To, puis linéaire jusqu'à 1 Go à 10 To (
256 + (To − 2,56) ÷ 7,44 × 768Mo), 1 Go au-delà (Microsoft Learn, Control data file size, https://learn.microsoft.com/azure/databricks/tables/tune-file-size, lu le 27 octobre 2026). Unités : 1 To = 1 024 Go et 1 Go = 1 024 Mo, comme la ligne « 1 TB, 256 MB, 4 096 fichiers » de la page ; le tableau d'exemples de la page peut différer de quelques Mo entre 2,56 et 10 To (la page le dit « seulement un exemple »). Fichiers attendus⌈Go × 1 024 ÷ cible⌉; aujourd'hui, taille moyenneGo × 1 024 ÷ numFiles, avecsizeInBytesetnumFilesde DESCRIBE DETAIL (Microsoft Learn, Review table details with describe detail, https://learn.microsoft.com/azure/databricks/tables/operations/table-details, lu le 27 octobre 2026). -
Taille à l'horizon
Go + croissance par jour × 365 ÷ 12 × mois. Disposition, sur la plus grande des deux tailles : sous 1 To, pas de partitions ; de 1 à 100 To, liquid clustering plutôt que des partitions ; à partir de 100 To, liquid clustering d'abord ; une partition contient au moins 1 Go (Microsoft Learn, When to partition tables on Azure Databricks, https://learn.microsoft.com/azure/databricks/tables/partitions, lu le 27 octobre 2026) ; moins de 10 000 partitions, et une maintenance quotidienne pour les tables très alimentées, hebdomadaire sinon (Microsoft Learn, Architecture best practices for Azure Databricks, https://learn.microsoft.com/azure/well-architected/service-guides/azure-databricks, lu le 27 octobre 2026). Le liquid clustering est recommandé pour toutes les nouvelles tables, quatre clés au plus (Microsoft Learn, Use liquid clustering for tables, https://learn.microsoft.com/azure/databricks/tables/clustering, lu le 27 octobre 2026). -
OPTIMIZE : commencer chaque jour, puis ajuster (Microsoft Learn, Optimize data file layout, https://learn.microsoft.com/azure/databricks/tables/operations/optimize, lu le 27 octobre 2026) ; au-delà de 1 To, un OPTIMIZE planifié en plus de l'auto compaction (Control data file size). VACUUM : régulièrement, rétention de 7 jours par défaut et au minimum recommandé (Microsoft Learn, Remove unused data files with vacuum, https://learn.microsoft.com/azure/databricks/tables/operations/vacuum, lu le 27 octobre 2026) ; fichiers gardés pour le voyage dans le temps
Go réécrits par jour × rétention, mesurables avec ANALYZE TABLE … COMPUTE STORAGE METRICS (Microsoft Learn, https://learn.microsoft.com/azure/databricks/sql/language-manual/sql-ref-syntax-aux-analyze-compute-storage-metrics, lu le 27 octobre 2026). Leur coût n'est calculé qu'au prix du stockage saisi (le relevé n'en contient pas). Sur une table gérée, l'optimisation prédictive lance OPTIMIZE, VACUUM et ANALYZE, facturés en jobs serverless (Microsoft Learn, Predictive optimization for Unity Catalog managed tables, https://learn.microsoft.com/azure/databricks/optimizations/predictive-optimization, lu le 27 octobre 2026).
13.14.5 Photon : l'accélération qu'il faut (photonBreakEven)
- Heure sans et avec Photon, par le moteur : Photon multiplie les DBU des machines par le taux du relevé pour ce produit et cette machine (une machine Photon consomme ses DBU à un autre taux : Microsoft Learn, What is Photon?, https://learn.microsoft.com/azure/databricks/compute/photon, lu le 27 octobre 2026) ; les machines coûtent le même prix. Sans taux Photon dans le relevé, rien n'est calculé.
-
Accélération au seuil
s* = heure avec ÷ heure sans; durée maximale avec Photon pour le même coûtminutes ÷ s*. Mois sansheure sans × minutes ÷ 60 × exécutions; avec une accélération mesurées, mois avecheure avec × minutes ÷ s ÷ 60 × exécutions; écart au centime. Aucun gain n'est supposé : sans accélération mesurée, seul le seuil est donné. - Limites dites : Photon ne prend en charge ni les UDF, ni les API RDD et Dataset, ni le streaming avec état, et n'améliore pas les requêtes de moins de deux secondes ; il est déjà actif en serverless et sur les SQL warehouses (What is Photon?) ; il ne fonctionne pas sur GPU (Microsoft Learn, GPU-enabled compute, https://learn.microsoft.com/azure/databricks/compute/gpu, lu le 27 octobre 2026).
13.14.6 Workers en spot ou à la demande (spotRisk)
- Heures : à la demande, et avec les workers en spot et le pilote à la demande (le pilote est toujours à la demande ; une machine spot évincée est remplacée en spot, ou à la demande à défaut : Microsoft Learn, Compute configuration reference). Le DBU ne change pas, seule la part machines baisse.
-
Travail en plus attendu
x = part des exécutions touchées × part refaite: deux saisies mesurées sur les exécutions de l'utilisateur, jamais supposées, car une machine spot n'a aucune garantie et peut être reprise à tout moment (Azure : 30 secondes de préavis, Microsoft Learn, Azure Spot Virtual Machines, https://learn.microsoft.com/azure/virtual-machines/spot-vms ; AWS : deux minutes, Spot Instance interruption notices, https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-instance-termination-notices.html ; Google Cloud : à tout moment, 0 ou 120 secondes, Spot VMs, https://cloud.google.com/compute/docs/instances/spot ; lus le 27 octobre 2026). -
Exécution en spot attendue
heure spot × minutes ÷ 60 × (1 + x); à la demandeheure × minutes ÷ 60; mois = exécution × exécutions, chacun au centime ; économie = la différence. Le spot reste moins cher tant quex < heure à la demande ÷ heure spot − 1. Allongement moyenminutes × x. Le travail refait est compté au prix spot (dit : sur des machines de remplacement à la demande, il coûte plus). Le spot convient aux charges à la latence souple (Microsoft Learn, Classic compute configuration best practices, https://learn.microsoft.com/azure/databricks/compute/cluster-config-best-practices, lu le 27 octobre 2026).
13.14.7 Le coût d'un tableau de bord (dashboardRefresh)
-
Secondes de warehouse par jour : rafraîchissements
planifiés × requêtes par rafraîchissement × durée moyenne(chaque mise à jour planifiée exécute tous les jeux de données : Microsoft Learn, Manage scheduled dashboard updates and subscriptions, https://learn.microsoft.com/azure/databricks/dashboards/share/schedule-subscribe, lu le 27 octobre 2026) ; lectureslecteurs × ouvertures × requêtes par ouverture × durée moyenne × (1 − part servie par le cache)(un tableau de bord garde ses résultats 24 heures, un résultat en cache ne démarre pas le warehouse, et un jeu de données de 100 000 lignes et 100 Mo au plus est filtré dans le navigateur, sans requête : Microsoft Learn, Dataset optimization and caching, https://learn.microsoft.com/azure/databricks/dashboards/caching, lu le 27 octobre 2026). Toutes ces durées et la part du cache se mesurent danssystem.query.history(query_source.dashboard_id,total_duration_ms,from_result_cache: Microsoft Learn, Query history system table reference, https://learn.microsoft.com/azure/databricks/admin/system-tables/query-history, lu le 27 octobre 2026). -
Heures par mois : rafraîchissements
secondes × jours de rafraîchissement ÷ 3 600(un mois moyen par défaut) ; lecturessecondes × jours de lecture ÷ 3 600(22 par défaut, une convention) ; réveilsdémarrages pour ce seul tableau de bord × arrêt automatique ÷ 60 × jours: un warehouse inactif reste facturé jusqu'à son arrêt automatique, 10 minutes par défaut en serverless, 45 en pro et classic (Microsoft Learn, Create a SQL warehouse, https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/create, lu le 27 octobre 2026). -
Coût : chaque part
heures × prix d'une heure d'un cluster(taille du warehouse : DBU × prix du DBU, et machines pour pro et classic) arrondie au centime ; total = la somme des trois parts. Par rafraîchissementrequêtes × durée ÷ 3 600 × heure; par lecteurtotal ÷ lecteurs. Rafraîchissements sans donnée nouvellemax(0, rafraîchissements − mises à jour des données par jour) × jours × coût d'un rafraîchissement. - Convention dite : une seconde de requête compte pour une seconde d'un cluster, comme si les requêtes du tableau de bord passaient l'une après l'autre. Sur un warehouse partagé, l'attribution mesurée de la section 5.4 (heure par heure, au temps des tâches) peut donner moins ; l'écran invite à comparer les deux. La taille du warehouse aux heures chargées relève de l'outil de la section 13.10 (un cluster pour 10 requêtes simultanées).
13.14.8 Le coût d'un entraînement (trainingRun)
-
Heure du calcul d'entraînement (pilote et workers, GPU ou CPU, par le relevé ; calcul de job ou polyvalent ; workers à la demande ou en spot, le pilote à la demande). Une exécution
heure × heures par exécution; mois : part DBUDBU par heure × heures × exécutionset part machines, chacune au centime, total = leur somme ; heures-machines(1 + workers) × heures × exécutions. Durée de la campagne⌈exécutions ÷ exécutions simultanées⌉ × heures par exécution(le coût ne change pas). - Règles : un calcul GPU demande le runtime Machine Learning, Photon n'y fonctionne pas, un nœud unique est possible (Microsoft Learn, GPU-enabled compute) ; un entraînement planifié coûte moins sur un calcul de job (Best practices for cost optimization). Quand le modèle sera servi, l'écran renvoie à l'outil « Concurrence et taille d'endpoint » (section 13.10).
Sources (lues le 27 octobre 2026), en plus de celles citées ci-dessus : le relevé du Calculateur (section 13.2) pour tous les prix, les DBU par heure, les cœurs des machines et les multiplicateurs de Photon.
13.14.9 Dimensionner une ingestion de données (ingestion, 0.32)
Depuis la 0.32, un calcul de data engineering, de type taille, pour le développeur data, l'architecte data et le FinOps : combien de cœurs, de workers, d'heures et de DBU pour charger ses données, et à quel coût par mois. Il suit les règles de cette section (prix du seul moteur du Calculateur, chaque pas avec sa page ou « dérivé », un chiffre mesuré manquant demandé et jamais deviné, saisies relues comme des données hostiles) ; ses pages officielles ont été lues le 30 octobre 2026, et Monitor managed ingestion pipeline cost relue le 31 octobre 2026 pour la facturation des connecteurs gérés. Le code est dans extension/lib/calc-ingest32.mjs, ses mots dans extension/lib/i18n-ingest32.mjs, son cours dans extension/lib/learn32-h.mjs.
-
Façon d'ingérer et calcul. Quatre façons : Auto Loader (des fichiers d'un stockage cloud), COPY INTO (des fichiers, par lots), un connecteur géré Lakeflow Connect (une application SaaS, ou une base de données avec sa passerelle), un flux Kafka ou Event Hubs. Quatre calculs : cluster de job classique, jobs serverless, pipeline déclaratif classique (édition Core, Pro ou Advanced), pipeline déclaratif serverless. Un connecteur géré tourne toujours dans un pipeline serverless : le calcul choisi ne s'applique pas, et l'écran le dit (Managed connector FAQs, Lakeflow Connect connector concepts). Trois rythmes :
nchargements par jour, un chargement toutes lesNminutes (n = 1 440 ÷ N), ou en continu. Les règles de chaque façon sont dites sous la réponse, avec leur page : Auto Loader planifié avecTrigger.AvailableNow, les événements de fichiers plutôt que le listage de répertoire, COPY INTO qui se rejoue sans doublon et ne s'utilise pas dans un pipeline déclaratif, Event Hubs lu par le connecteur Kafka. -
Volume. Par mois
G × 365 ÷ 12Go,Gétant le volume par jour ; chargements par moisn × 365 ÷ 12; volume d'un chargementG ÷ n, une règle qui suppose une arrivée régulière dans la journée (dite : une heure de pointe demande plus). -
Fichiers (Auto Loader et COPY INTO). Taille moyenne
G × 1 024 ÷ FMo pourFfichiers par jour ; fichiers par chargementF ÷ n. Sous 4 Mo, ce que Spark compte pour ouvrir un fichier (spark.sql.files.openCostInBytes), les petits fichiers sont signalés ; Spark regroupe jusqu'à 128 Mo par partition (spark.sql.files.maxPartitionBytes) (Performance Tuning, Apache Spark). Auto Loader traite au plus 1 000 fichiers par micro-lot par défaut (cloudFiles.maxFilesPerTrigger) : au-delà, micro-lots d'un chargement⌈fichiers par chargement ÷ 1 000⌉(Configure Auto Loader for production workloads, Spark API options reference). COPY INTO convient aux fichiers « in the order of thousands », Auto Loader aux « millions or more » (Ingest data from cloud object storage) : YALineo lit cette frontière comme un million de fichiers par an, une convention dite, et conseille Auto Loader quandF × 365l'atteint. La table cible a ses propres fichiers : l'écran renvoie au calculdeltaFiles(section 13.14.4). -
Flux (Kafka, Event Hubs). Débit au pic
événements par seconde × Ko ÷ 1 024Mo/s ; débit moyenG × 1 024 ÷ 86 400Mo/s ; un pic saisi sous la moyenne est signalé. Sur Event Hubs au niveau standard, une unité de débit sert au plus 2 Mo/s en lecture :max(1, ⌈pic ÷ 2⌉)unités au moins (Azure Event Hubs Scalability Guide). Pour le délai voulu, le déclencheur, les partitions et le rattrapage après un arrêt, l'écran renvoie au calculstreamSize(section 13.14.3). -
Calcul classique : cœurs et workers. Le débit d'un cœur
d(Mo lus et écrits par seconde et par cœur de worker) se mesure lors d'un essai ; la réserverest un choix (20 % au départ). Planifié : secondes de traitementA = (temps accordé − démarrage) × 60; siAne dépasse pas 0, aucun cluster ne tient, et l'écran le dit ; débit nécessairevolume d'un chargement × 1 024 ÷ AMo/s ; cœurs= max(1, ⌈débit nécessaire × (1 + r) ÷ d⌉). En continu : cœurs= max(1, ⌈débit × (1 + r) ÷ d⌉), le débit étant le pic pour un flux et la moyenne pour des fichiers. Workers= max(1, ⌈cœurs ÷ cœurs d'une machine⌉), les cœurs de la machine venant du relevé du Calculateur ; au-delà de 1 000 workers (la borne d'une ligne d'estimation), rien n'est chiffré. Travail du moisG × 365 ÷ 12 × 1 024 ÷ d ÷ 3 600cœur-heures, pour information. Sans machine choisie, l'outil donne les cœurs seulement. La règle suppose que le débit d'un cœur reste le même avec plus de cœurs, un cas favorable dit comme tel ; pour une fenêtre stricte tirée d'un essai complet, l'écran renvoie au calculjobWindow(section 13.10). -
Heures, DBU et coût. Planifié : durée d'un chargement
démarrage + volume d'un chargement × 1 024 ÷ (workers × cœurs d'une machine × d) ÷ 60minutes ; heures par moischargements par mois × durée ÷ 60. En continu : 730 heures par mois. La charge est un job (ou un pipeline, à son édition) de ces workers sur cette machine, sans Photon ; en spot, les workers en spot et le pilote à la demande ; réservé, les machines au prix horaire réservé, comme une capacité déjà achetée (section 13.3). Le moteur du Calculateur (estimate) la chiffre : DBU par mois= DBU par heure (pilote et workers) × heures; au prix public, une part DBUDBU × prix du DBUet une part machines, chacune arrondie au centime, total = leur somme ; après remises,part DBU × (1 − remise DBU) + part machines × (1 − remise machines), chaque part au centime. Un démarrage non saisi (0) n'est ni dans la durée ni dans le coût, et l'écran le dit ; des chargements qui se chevauchent, un temps accordé plus long que l'intervalle et un démarrage qui fait au moins la moitié d'un chargement sont signalés. -
Serverless : des DBU par Go. Aucune machine n'est dimensionnée : Databricks choisit les machines et facture des DBU. DBU par mois
= G × 365 ÷ 12 × DBU par Go; les DBU par Go sont une mesure (les DBU d'exécutions passées danssystem.billing.usage, divisés par les Go chargés) : sans elle, rien n'est calculé et le champ est demandé (dbuPerGb). La charge est un job serverless ou un pipeline serverless devolume d'un chargement × DBU par GoDBU par exécution (en continu, une exécution par jour deG × DBU par Go),nexécutions par jour, 365 ÷ 12 jours par mois ; coûtDBU × prix du DBU du produit(jobs serverless ou pipelines serverless, au relevé), après remise× (1 − remise DBU), chacun au centime. Les règles disent aussi que le mode standard du serverless consomme moins de DBU pour le même SKU mais démarre en 4 à 6 minutes (Run your Lakeflow Jobs with serverless compute for workflows, Configure a serverless pipeline), qu'un pipeline serverless exige l'édition Advanced, et que les jobs serverless n'acceptent queTrigger.AvailableNow(Serverless compute limitations). -
Connecteur géré Lakeflow Connect : la ligne de service du Calculateur. L'usage d'un connecteur géré se facture sous son propre produit :
billing_origin_product = 'LAKEFLOW_CONNECT',usage_typeCOMPUTE_TIME, unité DBU, avec des frais de maintenance entre les mises à jour comme un pipeline Lakeflow (Monitor managed ingestion pipeline cost, relue le 31 octobre 2026). La FAQ des connecteurs gérés parle de DBU de pipelines Lakeflow serverless (Managed connector FAQs) ; YALineo suit l'usage et chiffre le connecteur exactement comme la ligne de servicelakeflow-connectdu Calculateur (sections 13.11 et 13.12), par le moteur de toute ligne (estimateLine, qui envoie une ligne de service àestimateService) : DBU par jour= G × DBU par Go(la même mesure, demandée de la même façon), un espace de travail, 365 ÷ 12 jours ; la règle de la ligne de service déduit la part gratuite une seule fois, DBU facturables par jour= max(0, DBU par jour − 100)(100 DBU gratuits par jour et par espace de travail pour les connecteurs gérés, Architecture Best Practices for Azure Databricks et le relevé des services), DBU facturables par mois= DBU facturables par jour × 1 × 365 ÷ 12; au prix publicarrondi(DBU facturables × prix du DBU Lakeflow Connect), après remisearrondi(DBU facturables × prix × (1 − remise DBU)). Le prix vient du relevé des services, ou des prix de votre compte quand ils ont été lus, avec son origine. La part gratuite est partagée entre les connecteurs d'un espace de travail : la déduire pour ce seul connecteur suppose qu'il est le seul à en profiter, et l'écran le dit. Les DBU par Go mesurées sur tout l'usageLAKEFLOW_CONNECTcomprennent les frais de maintenance. Au-delà de 10 000 000 DBU par jour (la borne d'une ligne Lakeflow Connect), rien n'est chiffré. Sans le relevé des services, le connecteur n'est pas chiffré, jamais compté pour zéro. -
Passerelle d'un connecteur de base de données. Elle tourne en continu sur du calcul classique, payée même quand le pipeline d'ingestion ne tourne pas (Managed database connectors) : un pipeline classique de l'édition choisie, un pilote sur la machine choisie et autant de workers de la même machine que le champ en donne (1 par défaut, la valeur de la politique de calcul documentée ; Databricks conseille les plus petits workers possibles, la machine du pilote est donc une borne haute), 730 heures par mois, chiffré comme ci-dessus. Un pilote de moins de 8 cœurs est signalé (Ingest data from SQL Server). L'édition facturée pour la passerelle n'est pas donnée par les pages lues : elle est comptée à l'édition choisie, et l'écran invite à la vérifier (
product_features.dlt_tieretsku_namedanssystem.billing.usage). Total par mois= pipeline d'ingestion + passerelle, au prix public et après remises, chacun la somme de ses parties au centime. Sans machine, la passerelle n'est pas chiffrée, et rien n'est ajouté à l'estimation. -
Rattrapage de l'historique, une dépense unique.
HGo à reprendre enDjours, le calcul tournant jour et nuit. Classique : cœurs= max(1, ⌈H × 1 024 × (1 + r) ÷ (d × D × 86 400)⌉), workers= max(1, ⌈cœurs ÷ cœurs d'une machine⌉), heures= démarrage ÷ 60 + H × 1 024 ÷ (workers × cœurs d'une machine × d) ÷ 3 600; coût au prix publicarrondi(DBU par heure × prix du DBU × heures) + arrondi(machines par heure × heures), après remises chaque part multipliée par (1 − sa remise), au centime. Serverless : DBU= H × DBU par Go, coûtarrondi(DBU × prix du DBU), après remisearrondi(DBU × prix du DBU × (1 − remise DBU)); pour un connecteur, au prix du DBU Lakeflow Connect, sans part gratuite, déjà déduite une fois dans le mois. Le rattrapage reste hors du mois et des lignes ajoutées à l'estimation. Avec Auto Loader,cloudFiles.includeExistingFilesvauttruepar défaut : le premier démarrage prend aussi les fichiers déjà présents (Spark API options reference). -
Hypothèses à remplacer par une mesure. Cinq valeurs de départ ne sont ni publiées ni mesurées, et leur champ le dit (« hypothèse de départ, à remplacer par votre mesure ») : 100 Go par jour, 1 000 fichiers par jour, 2 000 événements par seconde au pic, 1 Ko par événement, 10 Mo/s par cœur. Tant que le volume ou le débit par cœur gardent leur valeur de départ, une règle le rappelle sous la réponse. Le démarrage du cluster et les DBU par Go sont des mesures (0 et vide au départ) ; le cours de l'outil donne des requêtes en lecture seule qui les lisent dans
system.lakeflow.job_run_timelineetsystem.billing.usage. Les workers de la passerelle prennent la valeur par défaut de Databricks, avec sa page. - La ligne d'estimation. « Ajouter à l'estimation » (section 13.15) ajoute la charge telle que l'estimation la chiffre : le job ou le pipeline classique avec ses workers, sa machine, son achat, ses chargements par jour et la durée d'un chargement, ou 730 heures ; le job ou le pipeline serverless avec ses DBU par exécution (origine « mesuré ») ; pour un connecteur géré, la ligne de service Lakeflow Connect elle-même (ses DBU par jour, 1 espace de travail, 365 ÷ 12 jours), et pour un connecteur de base de données la passerelle en plus, un pipeline classique de 730 heures. L'estimation en donne le même mois, au centime : la part gratuite y est déduite par la même règle, une fois. Aucune ligne sans machine, quand le temps accordé ne suffit pas, au-delà des bornes, sans prix, ou quand la passerelle n'est pas chiffrée ; le rattrapage n'est jamais ajouté.
-
Exemple (fictif : une enseigne de distribution). 900 Go par jour en 36 000 fichiers, 4 chargements par jour de 45 minutes au plus, 6 Mo/s par cœur mesurés, 6 minutes de démarrage, 20 % de réserve, une machine de 8 cœurs (
Standard_D8ds_v5sur Azure). Un chargement porte 225 Go ; un fichier fait 25,6 Mo en moyenne ; 9 micro-lots par chargement ; 2 340 secondes de traitement ; 98,46 Mo/s nécessaires ; 20 cœurs, soit 3 workers (24 cœurs) ; un chargement dure6 + 225 × 1 024 ÷ (24 × 6) ÷ 60 = 32,67minutes. Reprendre 2 To (2 048 Go) en 2 jours demande 3 cœurs, 1 worker et 12,24 heures, une fois. Les prix sont ceux du relevé de l'estimation : au relevé livré (15 octobre 2026, Azure East US, Premium, prix publics : 0,30 $ le DBU de job, 0,452 $ l'heure deStandard_D8ds_v5), l'heure coûte4 × (2 × 0,30 + 0,452) = 4,208 $; 66,24 heures et 529,93 DBU par mois, 278,74 $ par mois au prix public ; le rattrapage 25,74 $, une fois. Le même volume par un connecteur SaaS (fictif, 0,2 DBU par Go mesurées) : 180 DBU par jour, 80 facturables après les 100 gratuits, 2 433,33 DBU facturables par mois ; au relevé des services livré (26 octobre 2026, Azure East US, Premium, prix public de 0,45 $ le DBU Lakeflow Connect),2 433,33 × 0,45 = 1 095,00 $par mois, au centime le mois de la ligne de service Lakeflow Connect pour 180 DBU par jour, 1 espace de travail et 365 ÷ 12 jours. Pour une base de données, la passerelle (un pilote et 1 workerStandard_D8ds_v5, édition Core, 730 heures, 2 920 DBU) ajoute876,00 + 659,92 = 1 535,92 $, soit 2 630,92 $ par mois. Ces montants sont ceux du moteur sur les relevés livrés avec cette version, sans remise ; sur GCP, sans prix des machines, la taille est donnée sans coût.tests/v0320-ingest32.test.mjsrecalcule chaque chiffre à la main sur un relevé à prix ronds, et compare chaque connecteur à la ligne de service construite à part. -
Sources (lues le 30 octobre 2026), avec le relevé du Calculateur (section 13.2) pour les prix, les DBU par heure et les cœurs des machines :
- Microsoft Learn, What is Auto Loader? : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/
- Microsoft Learn, Ingest data from cloud object storage : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/
- Microsoft Learn, Compare Auto Loader file detection modes : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/file-detection-modes
- Microsoft Learn, Configure Auto Loader for production workloads : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/production
- Microsoft Learn, Auto Loader best practices : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/best-practices
- Microsoft Learn, Configure schema inference and evolution in Auto Loader : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/auto-loader/schema
- Microsoft Learn, Spark API options reference : https://learn.microsoft.com/azure/databricks/spark/api-options
- Microsoft Learn, Get started using COPY INTO to load data : https://learn.microsoft.com/azure/databricks/ingestion/cloud-object-storage/copy-into/
- Microsoft Learn, Lakeflow Connect connector concepts : https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/
- Microsoft Learn, Managed database connectors : https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/cdc-overview
- Microsoft Learn, Managed connector FAQs : https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/faq
-
Microsoft Learn, Monitor managed ingestion pipeline cost (relue le 31 octobre 2026 :
billing_origin_product = 'LAKEFLOW_CONNECT',usage_typeCOMPUTE_TIME, unité DBU, frais de maintenance comme un pipeline Lakeflow) : https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/monitor-costs - Microsoft Learn, Ingest data from SQL Server : https://learn.microsoft.com/azure/databricks/ingestion/lakeflow-connect/sql-server-pipeline
- Microsoft Learn, Connect to Apache Kafka : https://learn.microsoft.com/azure/databricks/connect/streaming/kafka/
- Microsoft Learn, Authentication (connecteur Kafka, Azure Event Hubs) : https://learn.microsoft.com/azure/databricks/connect/streaming/kafka/authentication
- Microsoft Learn, Azure Event Hubs Scalability Guide : https://learn.microsoft.com/azure/event-hubs/event-hubs-scalability
- Microsoft Learn, Configure Structured Streaming trigger intervals : https://learn.microsoft.com/azure/databricks/structured-streaming/triggers
- Microsoft Learn, Run your Lakeflow Jobs with serverless compute for workflows : https://learn.microsoft.com/azure/databricks/jobs/run-serverless-jobs
- Microsoft Learn, Serverless compute limitations : https://learn.microsoft.com/azure/databricks/compute/serverless/limitations
- Microsoft Learn, Configure a serverless pipeline : https://learn.microsoft.com/azure/databricks/ldp/serverless
- Microsoft Learn, Triggered vs. continuous pipeline mode : https://learn.microsoft.com/azure/databricks/ldp/concepts/pipeline-mode
- Microsoft Learn, Configure pipelines (Choose a product edition) : https://learn.microsoft.com/azure/databricks/ldp/configure-pipeline
- Microsoft Learn, Billable usage system table reference : https://learn.microsoft.com/azure/databricks/admin/system-tables/billing
- Microsoft Learn, Jobs system table reference : https://learn.microsoft.com/azure/databricks/admin/system-tables/jobs
- Microsoft Learn, Control data file size : https://learn.microsoft.com/azure/databricks/tables/tune-file-size
-
Apache Spark, Performance Tuning (documentation de Spark 4.3.0) :
https://spark.apache.org/docs/latest/sql-performance-tuning.html - Microsoft Learn, Architecture Best Practices for Azure Databricks (Well-Architected Framework) : https://learn.microsoft.com/azure/well-architected/service-guides/azure-databricks
13.15 Dimensionner et régler : les calculs par capacité et par poste (0.27)
La page « Dimensionner et régler » (volet Simulations, entre « Chiffrer un projet » et « Estimation ouverte ») rassemble les calculs de taille, de réglage, de coût et d'achat. Elle n'ajoute aucune règle de calcul : chaque outil garde la sienne (section 13.10 pour les cinq outils des briques d'un projet, section 13.14 pour les réglages) et la page les montre tous de la même façon. Le code est dans extension/lib/calc-capabilities.mjs (la liste des calculs) et extension/lib/calc-sizing-ui.mjs (les pages).
Organisation. Cinq capacités : data engineering (ingestion, transformations), data science (notebooks, entraînement, modèles servis), analytics (les requêtes des analystes et des tableaux de bord sur un SQL warehouse, au moment le plus chargé), tableaux de bord (ce que coûte un tableau de bord, rafraîchissements et lectures compris), architecture (stockage, conservation et choix d'achat qui valent pour toute la plateforme). Chaque calcul appartient à une capacité et a un type : coût, taille, réglage (délai d'expiration, arrêt automatique, autoscaling...) ou achat (à la demande, spot, réservé...). Chacun dit la question à laquelle il répond, ses champs avec leur unité et leurs bornes, un exemple concret (fictif, dit comme tel) et sa réponse en une phrase. Les dix cas complets du Calculateur restent dans « Mes estimations » ; la page y mène (« Chiffrer un cas complet »).
Qui utilise quel calcul, et pourquoi. Chaque calcul nomme les postes qui s'en servent (sa liste profiles, parmi métier, data steward ou owner, développeur data, architecte data, responsable FinOps, data scientist, analyste BI) ; le tableau « Qui utilise quoi » est tiré de ces listes, et le profil d'usage aussi (0.28) : un profil inclut les calculs qui le nomment, « Complet » les inclut tous, un calcul ajouté y entre seul. Le métier ne chiffre pas : un data steward ou owner chiffre pour les analystes (taille d'un SQL warehouse, coût d'un tableau de bord), et une estimation faite pour le métier lui arrive dans le classeur Excel de l'estimation. Les quatorze calculs (les cinq outils de dimensionnement de la section 13.10, les huit des sections 13.14.1 à 13.14.8 et, depuis la 0.32, l'ingestion de la section 13.14.9) :
| Calcul | Capacité | Type | Postes | Pourquoi |
|---|---|---|---|---|
Workers pour tenir une fenêtre (jobWindow) | Data engineering | Taille | Développeur data, architecte data, FinOps | Le développeur dimensionne son job ; l'architecte choisit la machine et la fenêtre ; le FinOps lit le coût par exécution et par mois. |
Arrêt automatique d'un cluster (clusterIdle) | Data science | Réglage | Développeur data, FinOps, data scientist | Le cluster partagé des notebooks est l'outil de travail du data scientist ; le développeur le règle ; le FinOps compte le temps à vide évité. |
Concurrence et taille d'endpoint (serving) | Data science | Taille | Architecte data, FinOps, data scientist | Le data scientist met le modèle en service ; l'architecte choisit CPU ou GPU ; le FinOps veut le coût d'un usage avant qu'il soit demandé. |
Clusters et taille au pic (warehouse) | Analytics | Taille | Data steward ou owner, architecte data, FinOps, analyste BI | L'analyste BI garde ses requêtes et ses tableaux rapides au pic ; le data steward ou owner chiffre pour les analystes de son domaine ; l'architecte et le FinOps choisissent le type et le nombre de clusters. |
Croissance, rétention et stockage (storage) | Architecture | Taille | Développeur data, architecte data, FinOps, data steward ou owner | Le data steward ou owner fixe combien de jours d'historique garder ; l'architecte et le développeur prévoient la taille ; le FinOps le coût. |
Timeout et relances d'un job (jobTimeout) | Data engineering | Réglage | Développeur data, architecte data, FinOps | Le développeur règle le délai et les relances de son job ; l'architecte fixe la règle commune ; le FinOps chiffre une exécution bloquée et un délai trop court. |
Minimum et maximum de workers en autoscaling (autoscale) | Data engineering | Réglage | Développeur data, architecte data, FinOps | Le développeur choisit le minimum et le maximum ; l'architecte la politique ; le FinOps l'écart avec une taille fixe. |
Dimensionner un flux continu (streamSize) | Data engineering | Taille | Développeur data, architecte data, FinOps | Le développeur dimensionne le flux ; l'architecte choisit continu ou par lots ; le FinOps compare les deux coûts. |
Fichiers et partitions d'une table Delta (deltaFiles) | Data engineering | Réglage | Développeur data, architecte data, data steward ou owner, FinOps | Le développeur et l'architecte choisissent la disposition des fichiers ; le data steward ou owner décide de la rétention de VACUUM ; le FinOps voit le stockage gardé. |
Photon : l'accélération qu'il faut (photonBreakEven) | Architecture | Achat | Architecte data, FinOps, développeur data | L'architecte et le développeur décident d'activer Photon ; le FinOps vérifie que l'accélération le rembourse. |
Workers en spot ou à la demande (spotRisk) | Architecture | Achat | Architecte data, FinOps, développeur data | L'architecte et le développeur choisissent la façon d'acheter les machines ; le FinOps pèse l'économie contre le travail refait. |
Le coût d'un tableau de bord (dashboardRefresh) | Tableaux de bord | Coût | Analyste BI, FinOps, data steward ou owner | L'analyste BI règle les rafraîchissements et le cache ; le FinOps le refacture ; le data steward ou owner décide de la fraîcheur utile et chiffre le tableau demandé par le métier. |
Le coût d'un entraînement (trainingRun) | Data science | Coût | Data scientist, FinOps, architecte data | Le data scientist chiffre sa campagne ; le FinOps son budget ; l'architecte le choix GPU ou CPU. |
Dimensionner une ingestion de données (ingestion) | Data engineering | Taille | Développeur data, architecte data, FinOps | Le développeur dimensionne le chargement ; l'architecte choisit la façon d'ingérer et le calcul ; le FinOps lit le coût du mois et celui du rattrapage. |
Le profil d'usage se choisit dans les réglages, à l'étape « Votre profil » (0.28, qui remplace « Mon poste ») : une préférence d'affichage (access), relue comme une donnée, l'un des huit profils, sinon « Complet ». Un calcul que le profil n'inclut pas garde sa place dans la page avec un cadenas et s'ouvre sur une page qui le dit ; c'est une commodité pour se concentrer sur son rôle, pas un contrôle d'accès.
Une page de calcul. Les champs, chacun avec son unité, ses bornes et l'origine de sa valeur (saisi, mesuré par vous, votre choix) ; un champ requis laissé vide est « à saisir », jamais deviné, et la réponse l'attend. « Remplir avec cet exemple » met les chiffres de l'exemple (sur AWS et GCP, des machines de même taille : 4 vCPU et 16 Go, 8 vCPU et 64 Go). Une liste de valeurs (les durées des exécutions d'un job) se saisit séparée par des virgules ou des espaces, 200 valeurs au plus, chacune un nombre au-dessus de 0 dans sa borne ; le reste est écarté. Une valeur par défaut de Databricks cite sa page. Quand le Calculateur n'a pas de prix pour la machine ou le produit (les machines de GCP, une région non choisie), le prix est dit « à saisir », avec un lien vers « Prix et remises » ; rien n'est supposé. Une règle qui renvoie à un autre calcul (le dimensionnement d'un SQL warehouse, celui d'un endpoint) l'ouvre d'un clic. Viennent la réponse en une phrase, puis le calcul pas à pas : chaque étape avec sa formule et vos chiffres, son résultat et sa source numérotée (une page officielle, une loi publiée, le relevé embarqué) ou « dérivé ». « Prix utilisés et leur origine » donne la base du Calculateur (cloud, région, plan, date du relevé, remises DBU et machines, prix du compte lus ou non) et chaque prix utilisé avec son origine (prix public du relevé, saisi, prix du compte, mesuré), pour les quatorze calculs ; sans aucun prix utilisé, la carte le dit. « Copier le calcul » copie le tout en texte. Pour un endpoint de modèle, le prix d'un DBU est celui saisi, sinon celui du relevé des services (Serverless Real-Time Inference : le prix du compte s'il a été lu, sinon le prix public de la région et du plan) ; coût par mois = DBU par jour × 365 ÷ 12 × prix du DBU × (1 − remise DBU). Sans prix, le mois n'est pas chiffré et une règle le dit.
Du résultat à une ligne d'estimation. « Ajouter à l'estimation » montre d'abord ce qui sera ajouté, chaque ligne chiffrée comme l'estimation la chiffrera (sa région, son plan, ses remises, chaque montant au centime), puis l'ajoute à l'estimation ouverte du même cloud, sinon à une nouvelle estimation « Dimensionnements » (60 charges et 30 estimations au plus) ; chaque ligne passe par cleanLine. L'estimation arrondit chaque partie d'une ligne (DBU, machines) au centime : son montant peut différer de celui de l'outil d'un centime par partie au plus, et c'est le montant de l'estimation que le récapitulatif montre.
- Workers pour une fenêtre : un job classique de ces workers sur cette machine, le même mode d'achat (une réservation comptée à l'heure, comme l'outil), les exécutions par jour et la durée d'une exécution arrondie au dixième de minute, 365 ÷ 12 jours par mois.
- Clusters au pic : deux charges SQL warehouse, comme la brique tableaux de bord (section 13.9) : les heures hors pic au minimum de clusters, les heures de pic au nombre trouvé ; leur somme est le mois de l'outil.
- Arrêt automatique : un cluster all-purpose allumé les heures par jour du délai proposé (heures actives et temps à vide).
- Taille d'endpoint : une charge de service Model Serving (section 13.12) au taux du processeur (par requête simultanée en CPU, par réplique en GPU), autant d'unités qu'au pic, et les heures par mois qui donnent les mêmes unités × heures que la journée de l'outil (DBU par jour × 365 ÷ 12) ; un prix saisi dans l'outil la suit. Seulement là où le relevé des services publie ce taux sur ce cloud (le CPU par requête simultanée : Azure) ; ailleurs, la raison est dite.
- Stockage : pas de ligne, le stockage est facturé par le cloud ; « Appliquer à un projet » le porte dans la brique stockage.
- Dimensionner une ingestion (section 13.14.9) : la charge de la réponse, un job ou un pipeline classique de ces workers sur cette machine (chargements par jour et durée d'un chargement, ou 730 heures en continu), ou un job ou un pipeline serverless de ces DBU par exécution ; pour un connecteur de base de données, sa passerelle en plus, un pipeline classique de 730 heures. Le rattrapage de l'historique n'est jamais ajouté.
-
Les huit calculs des sections 13.14.1 à 13.14.8 n'ajoutent pas de ligne, et la page dit pourquoi sous la réponse (
NO_LINEdecalc-tune.mjs) : le timeout et les relances, l'autoscaling et les fichiers Delta sont des réglages (d'un job, d'un cluster, d'une table), pas une nouvelle charge ; Photon et le spot comparent deux façons de payer la même charge, à régler dans la charge de l'estimation ; un tableau de bord occupe une part d'un SQL warehouse, chiffré et ajouté par « Clusters et taille au pic » ; un flux continu et un entraînement sont des charges que l'estimation sait chiffrer, mais sans bouton pour l'instant : la page invite à les saisir dans l'estimation avec la machine, les workers et les heures de la réponse.
« Appliquer à un projet » ouvre l'outil de la brique (ingestion ou transformations pour un job) dans le projet en cours, avec ces valeurs ; « Appliquer au projet » y montre le récapitulatif de la section 13.10 avant tout changement.
Données relues comme hostiles. L'adresse porte le calcul ouvert (sim) et ses valeurs (si, des paires clé:valeur séparées par des virgules) ; les flèches précédent et suivant les rendent. Un calcul inconnu ramène à la vue d'ensemble ; une valeur n'est lue que pour un champ du calcul : un nombre dans ses bornes, une valeur de sa liste, un nom de machine de la forme documentée, sinon la valeur de départ ; aucune clé de prototype n'est lue. Un calcul d'une autre forme (capacité, type ou poste inconnu, champ sans bornes) est écarté des pages, jamais montré à moitié.
13.16 IA : Genie et agents (0.32)
Depuis la 0.32, la page « IA : Genie et agents » du volet Simulations accompagne la construction d'un Genie Agent (appelé espace Genie avant juillet 2026, section 4.3) ou d'un agent d'IA, étape par étape avec une liste de contrôle (8 étapes pour un Genie Agent, 10 pour un agent, chacune avec la page officielle qu'elle suit et les parties du coût qu'elle règle), dit ce qu'est un DBU, et chiffre le mois de l'usage saisi, partie par partie, en DBU et en dollars, au prix catalogue puis après les remises du contrat. Ce sont des chiffres dérivés (section 1), jamais des mesures. Le moteur est extension/lib/calc-ai32.mjs (pur : ni page, ni réseau, ni stockage), la page extension/lib/calc-ai32-ui.mjs, ses mots extension/lib/i18n-ai32.mjs. Chaque formule de cette section est celle que la page affiche avec vos chiffres dans « Le calcul pas à pas », chaque pas avec sa page officielle (lue le 30 octobre 2026 ; le 31 octobre 2026 pour les écritures en cache et les Go de Unity AI Gateway, depuis la 0.33), le relevé du Calculateur, ou « dérivé ».
Règles communes.
-
Un DBU est l'unité normalisée de puissance de traitement dans laquelle Databricks mesure et facture la consommation (Databricks technical terminology glossary). Coût
= DBU × prix d'un DBU du produit × (1 − remise DBU); en calcul classique (un warehouse Pro), les machines du cloud s'ajoutent,heures × prix des machines × (1 − remise machines); en serverless, le prix du DBU comprend déjà les machines (Best practices for cost optimization). -
Aucun prix n'est écrit dans le moteur. Le warehouse d'un Genie Agent est chiffré par le moteur du Calculateur sur le relevé daté du cloud (section 13.2) ou les prix saisis ; le modèle de langage de Genie et chaque partie d'un agent, par les services du Calculateur (sections 13.11 et 13.12) : prix saisi, sinon prix du compte (
system.billing.list_prices, lu à la demande), sinon prix public du relevé des services. La page choisit son cloud, sa région, son plan et ses deux remises (au départ, ceux du Calculateur) ; chaque ligne garde l'origine de ses prix. - Ce qui manque est demandé. Une valeur que Databricks ne publie pas (les DBU d'une question Genie), une région, un prix absent du relevé, un modèle que le relevé n'a pas sur ce cloud : la partie n'est pas chiffrée, jamais comptée pour 0 ; elle est listée « À compléter » avec la valeur à saisir, et le total est dit partiel.
-
Chaque champ dit l'origine de sa valeur : hypothèse à remplacer, convention de YALineo, valeur par défaut de Databricks (avec sa page), votre choix, ou à mesurer. Les saisies sont relues comme des données hostiles : seules les propriétés propres de valeur sont lues (jamais
__proto__,constructorniprototype) ; un nombre doit être un nombre fini, il est ramené dans ses bornes, et une chaîne,NaNou un objet prend la valeur de départ sans jamais être converti ; un entier est arrondi, un choix appartient à sa liste, un modèle a la forme d'un identifiant du relevé des services. Le calcul ne lève jamais d'exception.
13.16.1 Un Genie Agent : les requêtes SQL et le warehouse
Les requêtes SQL que Genie lance tournent sur un SQL warehouse Pro ou Serverless et sont facturées par lui, à part du modèle de langage (Create and manage a Genie Agent, Genie consumption guide). Les valeurs de départ :
| Champ | Départ | Origine |
|---|---|---|
| Utilisateurs ; questions par utilisateur et par jour | 20 ; 5 | hypothèses à remplacer |
| Jours d'usage par mois | 22 | convention de YALineo (celle des briques de la section 13.9) |
| Requêtes SQL par question ; durée moyenne d'une requête ; facteur de pointe | 1 ; 8 s ; 1 | hypothèses à remplacer (la durée se mesure dans system.query.history) |
| Type et taille du warehouse | Serverless (ou Pro) ; X-Small | votre choix |
| Clusters au minimum | 1 | valeur par défaut de Databricks (Create a SQL warehouse) |
| Heures d'ouverture par jour ; heures au pic ; reprises par jour | 8 h ; 1 h ; 1 | hypothèses à remplacer |
| Arrêt automatique | vide : 10 minutes en Serverless, 45 en Pro | valeur par défaut de Databricks (Create a SQL warehouse) |
| Machines d'un cluster Pro, par heure | vide | à mesurer, seulement quand le relevé ne les publie pas (GCP) |
| Facturation du modèle de langage | utilisateurs, après la promotion | votre choix (Monitor and understand your Genie cost) |
| DBU du modèle par question | vide | à mesurer |
Pas à pas, avec U utilisateurs, q questions par jour, j jours, s requêtes SQL par question, W la durée moyenne d'une requête en secondes, f le facteur de pointe, h les heures d'ouverture (24 au plus), p les heures au pic, m les clusters au minimum, a l'arrêt automatique en minutes et r les reprises par jour :
-
Questions par mois
Q = U × q × j; requêtes SQL par jourS = U × q × s. -
Requêtes simultanées à l'heure la plus chargée, par la loi de Little :
λ = S ÷ (h × 3 600) × frequêtes par seconde,L = λ × W(la moyenne, pas la médiane). La durée se mesure danssystem.query.history, colonnetotal_duration_ms, sur les lignes dontquery_source.genie_space_idest celui de l'agent (Query history system table reference). -
Clusters au pic
M = min(30, max(m, ⌈L ÷ 10⌉)): un cluster pour 10 requêtes simultanées (Create a SQL warehouse). -
Part du temps où le warehouse calcule
S × W ÷ 3 600 ÷ h(100 % au plus) ; sous 10 %, une règle propose une taille plus petite, un arrêt automatique plus court ou un warehouse partagé. -
Heures de cluster par jour, la règle de la brique tableaux de bord (section 13.9) : traîne d'arrêt
t = a ÷ 60 × rheures, heures au picp' = min(p, h), hors picH = max(0, min(24 − p', h − p' + t)); heures de clusterH × m + p' × M. Des heures au pic au-delà des heures d'ouverture sont ramenées à celles-ci, et un arrêt automatique sous le minimum de l'interface (5 minutes en Serverless, 10 en Pro) est signalé. -
DBU du warehouse par mois
= DBU par heure d'un cluster de la taille (relevé) × heures de cluster par jour × j. Le moteur chiffre deux charges SQL warehouse (section 13.3) :Hheures par jour àmclusters etp'heures àMclusters, surjjours ; chacune est arrondie au centime, et la ligne « SQL warehouse » est la somme de leurs coûts de DBU :DBU × prix d'un DBU du produit (SQL serverless ou SQL Pro) × (1 − remise DBU). -
Machines d'un warehouse Pro, une ligne à part : le prix des machines de ses clusters (pilote et workers de la taille, section 13.2), ou le coût saisi par heure et par cluster,
× (1 − remise machines). Les disques et le réseau restent hors du calcul (section 13.6).
Deux hypothèses sont dites : le warehouse sert Genie seul (partagé avec des tableaux de bord, il coûterait moins pour Genie : la brique Genie d'un projet ne compte alors que la différence, section 13.9) ; il reste allumé pendant les heures d'ouverture saisies, plus l'arrêt automatique après chaque reprise. Sans heures d'ouverture, rien n'est chiffré et elles sont demandées.
13.16.2 Le modèle de langage de Genie
La ligne « Modèle de langage de Genie » suit Monitor and understand your Genie cost (section 4.3) :
-
DBU du modèle
= Q × d,détant les DBU par question. Databricks ne les publie pas : ils se mesurent sur un essai, les DBU du produitGENIE(usage_metadata.genie.surface = GENIE_AGENTS, SKUGENIE_FREE_USAGEcompris) danssystem.billing.usage, divisés par le nombre de questions de la période. Sansd, la ligne n'est pas chiffrée etdest demandé. -
Trois façons d'être facturé, au choix :
-
utilisateurs, jusqu'au 31 janvier 2027 : l'usage de Genie One et des Genie Agents est gratuit pour les utilisateurs (SKU
GENIE_FREE_USAGE, sans prix catalogue). La ligne coûte 0 ; ses DBU, quanddest saisi, sont comptés et dits gratuits, et rien n'est demandé tant quedmanque. Une hypothèse le dit : ensuite, l'allocation s'applique ; -
utilisateurs, après la promotion : chaque utilisateur a 150 DBU gratuits par mois. DBU facturés
= U × max(0, q × j × d − 150), gratuits= Q × d − facturés. Le seuil150 ÷ (q × j)dit à partir de combien de DBU par question l'usage est facturé. Deux hypothèses sont dites : les questions sont réparties également entre les utilisateurs (l'usage réel est inégal, et la part facturée réelle est au moins celle-ci) ; les 150 DBU de chaque utilisateur servent tous à ce Genie Agent (Genie Code ou d'autres Genie Agents les entameraient) ; -
principal de service : tout est facturé, DBU facturés
= Q × d.
-
utilisateurs, jusqu'au 31 janvier 2027 : l'usage de Genie One et des Genie Agents est gratuit pour les utilisateurs (SKU
-
Coût, au prix d'un DBU du SKU Serverless Real-Time Inference, sur lequel Databricks facture l'usage de Genie (le prix d'un DBU Model Serving du relevé des services : saisi, sinon du compte, sinon public) : au prix catalogue
arrondi(facturés × prix), après remisesarrondi(facturés × prix × (1 − remise DBU)). Des DBU tous dans l'allocation gratuite coûtent 0 : la ligne est chiffrée, jamais « non chiffrée ». - La remise promotionnelle de 25 % sur l'usage facturé, jusqu'au 31 janvier 2027, est déjà dans les DBU mesurés : une hypothèse le dit, des DBU par question mesurés avant cette date seront plus élevés ensuite.
Ici, la part SQL et le modèle décrivent le même Genie Agent et s'additionnent dans le total de la page. Dans le volet FinOps (section 4.3), la ligne Genie Agents couvre le modèle de tous les agents ensemble : elle n'est jamais ajoutée à la part SQL d'un agent.
13.16.3 Un agent d'IA : ses parties
Chaque partie est une charge de service du Calculateur (section 13.12), chiffrée par son moteur (estimateService) au taux et au prix du relevé des services ; la clé de taux d'un modèle et de son mode vient du comparateur des jetons (section 13.13). Les valeurs de départ :
| Groupe | Champs et départ | Origine |
|---|---|---|
| Usage | 100 utilisateurs, 5 requêtes par utilisateur et par jour ; 22 jours | hypothèses à remplacer ; convention de YALineo |
| Modèle | 3 appels par requête ; par appel, 2 000 jetons en entrée, 300 en sortie, 0 lu en cache | hypothèses à remplacer, à lire sur les traces MLflow d'un prototype |
| Modèle | llama-3-3-70b des Foundation Model APIs, au jeton ; en débit provisionné, sans engagement, 50 unités de modèle, 730 heures | votre choix ; 730 heures, convention de YALineo |
| Modèle propriétaire (0.33) | 0 jeton écrit en cache par appel ; écriture standard | à mesurer (system.ai_gateway.usage) ; votre choix |
| Recherche dans des documents | activée ; 0,5 million de morceaux de 500 jetons ; 1 024 dimensions ; endpoint Standard, 730 heures ; 0 Go de stockage ; 1 recherche par requête ; sans reclassement ; embeddings gte ; 10 % revectorisés par mois ; 50 jetons par question | hypothèses à remplacer ; dimensions et endpoint, votre choix ; 730 heures, convention ; stockage, à mesurer |
| Serveur | Agent Runtime sur Databricks Apps, taille Medium, 1 instance (Model Serving : 1 nœud CPU), 730 heures | votre choix ; Medium, valeur par défaut de Databricks (Configure compute resources for a Databricks app) ; 730 heures, convention |
| Unity AI Gateway | tables d'inférence et suivi d'usage, non cochés ; 0 Go de charge utile par mois (0.33) | votre choix ; à mesurer |
| Évaluation | 4 campagnes par mois de 50 questions ; 3 juges ; par jugement, 2 000 jetons en entrée et 200 en sortie ; 0 % des requêtes de production notées ; 0 question synthétique | hypothèses à remplacer ; part notée et questions synthétiques, votre choix |
Avec R = utilisateurs × requêtes par jour × jours requêtes par mois et E = campagnes × questions questions d'évaluation (chaque question d'évaluation fait tourner l'agent une fois, une hypothèse dite) :
-
Le modèle. Appels
(R + E) × appels par requête; millions de jetons en entrée, en sortie et lus en cache, chacunappels × jetons par appel ÷ 1 000 000. Au jeton ou prioritaire :Σ millions × DBU par million × prix d'un DBU(section 13.11) ; pour un modèle propriétaire, les jetons lus en cache sont des lectures du cache (cache-read-mtok). Les écritures en cache (0.33). Un modèle propriétaire facture aussi les jetons écrits dans son cache des prompts, comptés à part des jetons en entrée :W = appels × jetons écrits par appel ÷ 1 000 000millions, au taux de la durée choisie,cache-write-mtok(prix « Cache write », l'écriture standard) oucache-write-1h-mtok(prix « Cache write (1hr) », un cache d'une heure),× prix d'un DBUdu SKU du fournisseur. La charge de service porteWdanscacheWriteMtokou danscacheWrite1hMtok, l'autre restant à 0. Au relevé des services du 26 octobre 2026,cache-write-mtokest publié pour tous les modèles Anthropic au jeton et pour GPT-5.6, GPT-6 et GPT-6.1 d'OpenAI (au jeton et prioritaire),cache-write-1h-mtokpour les modèles Anthropic sauf Claude Sonnet 4 ; Gemini, Grok et les autres modèles OpenAI n'en publient pas, et les taux des Foundation Model APIs n'ont pas de mesure d'écriture en cache (entrée, sortie, lecture en cache seulement) : le champ n'est demandé que pour un modèle propriétaire. Avec un modèle sans prix pour la durée choisie, ces jetons ne sont pas chiffrés et une règle le dit, avec leur nombre ; aucun prix n'est supposé. Ils se mesurent danssystem.ai_gateway.usage:token_details.cache_creation_input_tokenspar appel, et la durée de vie danscache_creation_5m_input_tokensetcache_creation_1h_input_tokens(Track model usage). Exemple, Azure East US, Premium, sans remise, relevé du 26 octobre 2026 : aux valeurs de départ avec Claude Haiku 4.5 et 1 000 jetons écrits par appel,W = 33 600 × 1 000 ÷ 1 000 000 = 33,6millions ; écriture standard33,6 × 17,857 = 600,0DBU, à 0,105 $ le DBU du SKU Anthropic, soit 63,00 $ ; écriture d'une heure33,6 × 28,571 = 960,0DBU, soit 100,80 $. En débit provisionné sans engagement :heures saisies × (unités de modèle ÷ 50) × DBU par heure × prix d'un DBU. Réservé 1 ou 3 mois : unités prises par blocs de 50,max(50, ⌈unités ÷ 50⌉ × 50), et 730 heures quelles que soient les heures saisies, car une réservation est facturée pour toute sa durée, utilisée ou non (Reserved provisioned throughput Foundation Model APIs). Un modèle ou un mode que le relevé n'a pas sur ce cloud, ou un prix d'un DBU non publié pour son SKU (par exemple Kimi sur Azure, section 13.11), est demandé. -
Les embeddings (recherche activée). Corpus
C = morceaux (millions) × jetons par morceaumillions de jetons ; recherches(R + E) × recherches par requête; par moisC × part revectorisée + recherches × jetons d'une question ÷ 1 000 000millions de jetons en entrée, au taux du modèle d'embeddings. La première vectorisation du corpus,Cmillions de jetons au même taux, est une dépense unique : elle est dite à part, hors du mois et du total. -
AI Search (des morceaux indexés). Unités
⌈vecteurs × dimensions ÷ 768 ÷ capacité d'une unité⌉(2 millions de vecteurs en Standard, 64 millions en Storage Optimized), puisunités × heures × DBU par heure d'unité × prix d'un DBU; le stockage au-delà des 30 Go gratuits en Standard (tout le stockage en Storage Optimized) au prix du Go-mois, jamais remisé ; le reclassement, s'il est coché,recherches ÷ 1 000milliers de requêtes× DBU × prix d'un DBU. Un endpoint est facturé dès qu'un index existe, et la synchronisation déclenchée est la moins chère, la seule d'un endpoint Storage Optimized (AI Search cost management guide). L'endpoint tourne les heures saisies, avec ou sans trafic (une hypothèse dite). -
Le serveur de l'agent. Agent Runtime sur Databricks Apps, le mode des nouveaux agents (Deploy agents on Databricks) :
instances × heures × DBU par heure de la taille (Medium 0,5, Large 1, XLarge 3) × prix d'un DBU; le coût croît avec les instances, 5 au plus sans demande à Databricks (Horizontal scaling for Databricks apps). Model Serving, l'ancien mode :nœuds CPU × heures × 4 DBU par heure de nœud × prix d'un DBU. « Aucun » : pas de serveur, ce qui est dit hors du calcul. -
Unity AI Gateway. Chaque fonction cochée, tables d'inférence ou suivi d'usage, a deux parties dans la charge de service (
calc-services.mjs), chacune sur sa propre quantité : les jetons au prix public du million (inference-tables-mtok,usage-tracking-mtok) et la charge utile au prix public du Go (inference-tables-gb,usage-tracking-gb), section 13.11. Les jetons, sur les endpoints de Foundation Model :G = millions en entrée + en sortie + lus en cache + écrits en cachedes appels au modèle (évaluation comprise) ; une hypothèse le dit : tous les jetons du modèle passent par la passerelle. Les Go (0.33) : la charge utile, requêtes et réponses, que la passerelle journalise ou suit sur des endpoints CPU ou GPU (par exemple le serveur de l'agent sur Model Serving), saisie en Go par mois (à mesurer, 0 au départ, demandée seulement quand une fonction est cochée). Microsoft Learn (Serverless DBU consumption by SKU) facture « Inference Tables for CPU, GPU endpoints » et « Usage Tracking for CPU, GPU endpoints » en DBU « / 1 GB of payload », chacune à son taux ; avec les seules données publiques, la page prend le prix public du Go du relevé. Avec les deux fonctions cochées, les mêmes Go sont comptés une fois pour chacune (itGbetutGb), comme les jetons (itMtoketutMtok) : chaque fonction facture la charge utile qu'elle traite (Log requests and responses to inference tables : Databricks facture les requêtes et les réponses que les tables d'inférence journalisent ; Track model usage : l'usage que le suivi écrit danssystem.ai_gateway.usage) ; une hypothèse le dit. La page de prix de Unity Gateway précise que les deux fonctions sont facturées par tranches de 1 Ko de charge utile : la facture peut dépasser un peu les Go mesurés. Les Go se mesurent sur une table d'inférence de Unity Gateway, dont les colonnesrequestetresponsegardent le JSON brut ; la requête de l'aide du champ en fait la somme par mois, en Go de 10⁹ octets. Exemple, Azure East US, Premium, sans remise, relevé du 26 octobre 2026, aux valeurs de départ (G = 77,28millions) avec les deux fonctions et 12,5 Go : tables d'inférence77,28 × 0,07 = 5,41 $et12,5 × 0,100 = 1,25 $, soit 6,66 $ ; suivi d'usage77,28 × 0,04 = 3,09 $et 1,25 $, soit 4,34 $. -
L'évaluation (MLflow). Appels aux juges
J = (E + R × part notée en production) × juges;J × jetons par jugement ÷ 1 000 000millions de jetons en entrée et en sortie, au taux des juges d'Agent Evaluation ; les questions synthétiques× prix d'une question. Pour des juges coûteux, Databricks conseille de noter 5 à 20 % des requêtes de production (Set up production monitoring) ; au-delà de 20 %, la règle est un avertissement. - Les remises, par catégorie (section 13.12) : la remise DBU sur ce que Databricks facture en DBU, aucune sur le stockage au Go-mois, jamais la remise machines.
-
Les DBU d'une ligne sont
q × tauxquand le taux est publié ; une partie au seul prix public par unité (par exemple Unity AI Gateway au million de jetons) a des DBU inconnus, et le total des DBU est alors dit « au moins » (marqué +).
13.16.4 Le coût par question ou par requête, et les arrondis
-
Chaque partie est arrondie au centime une fois. Genie : les deux charges du warehouse, par le moteur du Calculateur, DBU et machines à part ; le modèle,
arrondi(facturés × prix)etarrondi(facturés × prix × (1 − remise DBU)). Agent : chaque partie d'une charge de service, par le moteur des services (section 13.12) ; une ligne de la page est la somme de ses parties en centimes. - Les totaux, au prix catalogue et après remises, sont la somme des lignes, au centime ; les DBU du mois, la somme des DBU connus ; les DBU gratuits de Genie sont dits à part.
-
Par question
= total après remises ÷ Q; par requête= total après remises ÷ R: l'évaluation est dans le total, pas dansR. Ce quotient est un prix unitaire, non arrondi au centime ; quand le total est partiel, il l'est aussi. -
Exemples, aux valeurs de départ, sans remise, Azure East US, Premium. Un Genie Agent pendant la promotion, sur le relevé du 15 octobre 2026 : 2 200 questions ; 100 requêtes SQL par jour ;
L = 100 ÷ (8 × 3 600) × 8 ≈ 0,028requête simultanée, donc 1 cluster ; 7 h 10 hors pic et 1 h au pic, soit(7 h 10 + 1 h) × 6 DBU × 22 jours = 1 078DBU X-Small et 754,60 $ (946 et 132 DBU à 0,70 $) ; 0,343 $ par question, le modèle étant gratuit. Un agent, sur le relevé des services du 26 octobre 2026 : 11 000 requêtes et 200 questions d'évaluation, 33 600 appels, 67,2 millions de jetons en entrée et 10,08 en sortie ; le modèle 48,72 $, les embeddings (25,56 millions de jetons) 3,32 $, AI Search (1 unité, 730 heures) 204,40 $, le serveur Medium (365 DBU) 346,75 $, les juges 0,25 $ : 603,44 $ par mois, 0,0549 $ par requête ; la première vectorisation (250 millions de jetons) coûte 32,50 $, une fois. -
Vérification.
tests/v0320-ai32.test.mjsrecalcule à la main un Genie Agent sur un relevé à prix ronds (la règle de la section 13.9, l'allocation, la promotion, le principal de service) et un agent partie par partie sur le relevé des services, recoupé avec le comparateur des jetons ; il vérifie les remises par catégorie, les totaux au centime, ce qui manque, les lignes d'estimation et les saisies piégées.tests/v0320-ai32-ui.test.mjsvérifie la page, l'estimation enregistrée, le rapport et le brouillon de courriel. Depuis la 0.33,tests/v0330-ai33.test.mjsvérifie les écritures en cache et les Go de Unity AI Gateway : chaque quantité change le prix exactement dequantité × prix unitairedu relevé, la durée choisie prend son propre taux, un modèle sans prix le dit, le total reste la somme des lignes au centime, l'estimation porte les mêmes quantités et redonne le même total, et les saisies piégées (texte,NaN, négatif, énorme,__proto__) sont refusées.
13.16.5 Ce qui est enregistré comme estimation, et ce qui reste dans ses notes
« Ajouter à une estimation » crée une estimation dans « Mes estimations » (30 au plus), avec le cloud, la région, le plan, les remises et le nom de la page ; chaque ligne passe par cleanLine, comme toute charge (section 13.1).
-
Un Genie Agent donne deux charges SQL warehouse, comme la brique tableaux de bord (section 13.9) : les heures hors pic
Hau minimum de clustersm, les heures au picp'aux clusters trouvésM, à la taille, au type (Serverless ou Pro, avec le coût saisi de ses machines) et aux jours de la page, à l'usage. L'estimation en donne la part SQL de la page, au centime. Le modèle de langage n'a pas de type de charge dans une estimation : il reste dans ses notes, avec ses DBU par mois et son coût après remises (ou « gratuit pendant la promotion ») ; le total de l'estimation est donc celui du warehouse seul. - Un agent donne ses charges de service (modèle, embeddings, AI Search, serveur, Unity AI Gateway, évaluation) telles que la section 13.12 les garde, avec les quantités de la page, jetons écrits en cache et Go de la passerelle compris ; l'estimation en donne le même total, au centime. La première vectorisation, une dépense unique, et une partie qui attend une valeur (avec la valeur à saisir) restent dans les notes.
- Les notes disent d'abord que l'estimation vient de cette page, puis ce qu'aucune ligne ne porte ; elles sont coupées à 1 000 caractères. Sans aucune ligne, rien n'est enregistré, et l'écran le dit. Les lignes sont refaites à partir des saisies quand le résultat donné n'est pas celui de ces saisies.
- L'envoyer, sans que rien ne parte de YALineo : un rapport HTML autonome (sans script ni ressource extérieure, avec sa propre politique de sécurité du contenu, chaque valeur échappée comme du texte : les totaux, chaque partie et son calcul, chaque pas, les saisies et leur origine, les règles, les hypothèses, ce qui est hors du calcul, la liste de contrôle et ses cases cochées, les pages officielles avec leur date de lecture) ; le fichier d'estimation qu'un autre YALineo importe (section 13.13) ; un résumé en texte à coller ; un brouillon de courriel ouvert dans la messagerie de l'utilisateur, sans destinataire.
13.16.6 Ce qui n'est pas calculé
Listé sous la réponse, par règle :
- Genie : l'usage de Genie Code par les auteurs pendant la construction (facturé à part au-delà de leur allocation gratuite) ; le stockage des tables sources ; pour un warehouse Pro, les disques et le réseau de ses machines.
- Agent : le calcul de ses outils (requêtes SQL sur un warehouse, fonctions Unity Catalog, Genie Agent utilisé comme outil, serveurs MCP), chacun à chiffrer par son propre calcul ; le stockage des tables sources et des tables de morceaux ; le pipeline de synchronisation de l'index (aucun taux publié ; le mode continu provisionne un cluster de streaming) ; l'extraction du texte des documents (AI Parse, par exemple, un service à ajouter dans une estimation) ; le serveur, avec « aucun » (un agent lancé depuis un job ou un notebook, à chiffrer à part).
13.16.7 Sources officielles (lues le 30 octobre 2026, sauf mention)
Avec le relevé daté du Calculateur (section 13.2) et celui des services (section 13.11) pour les prix :
- Databricks, Databricks technical terminology glossary (DBUs) : https://docs.databricks.com/aws/en/resources/glossary
- Microsoft Learn, Best practices for cost optimization : https://learn.microsoft.com/azure/databricks/lakehouse-architecture/cost-optimization/best-practices
- Databricks, Monitor and understand your Genie cost : https://docs.databricks.com/aws/en/genie/monitor-cost
- Microsoft Learn, Genie consumption guide : https://learn.microsoft.com/azure/databricks/genie/consumption-guide
- Databricks, Create and manage a Genie Agent : https://docs.databricks.com/aws/en/genie-agents/set-up
- Databricks, Curate an effective Genie Agent : https://docs.databricks.com/aws/en/genie-agents/best-practices
- Databricks, Tune Genie Agent quality : https://docs.databricks.com/aws/en/genie-agents/tune-quality
- Databricks, Query history system table reference : https://docs.databricks.com/aws/en/admin/system-tables/query-history
- Microsoft Learn, Create a SQL warehouse : https://learn.microsoft.com/azure/databricks/compute/sql-warehouse/create
- Databricks, What is Agent Bricks? : https://docs.databricks.com/aws/en/generative-ai/guide/mosaic-ai-gen-ai-capabilities
- Databricks, Deploy agents on Databricks : https://docs.databricks.com/aws/en/agents/deploy/
- Databricks, Agent Runtime : https://docs.databricks.com/aws/en/agents/deploy/agent-runtime
- Microsoft Learn, Configure compute resources for a Databricks app : https://learn.microsoft.com/azure/databricks/dev-tools/databricks-apps/compute-size
- Microsoft Learn, Horizontal scaling for Databricks apps : https://learn.microsoft.com/azure/databricks/dev-tools/databricks-apps/horizontal-scaling
- Databricks, AI Search cost management guide : https://docs.databricks.com/aws/en/vector-search/vector-search-cost-management
- Databricks, Reserved provisioned throughput Foundation Model APIs : https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/reserved-provisioned-throughput
- Databricks, AI governance with Unity Gateway : https://docs.databricks.com/aws/en/ai-gateway/
-
Databricks, Track model usage (lue le 31 octobre 2026 : le suivi d'usage est facturé,
system.ai_gateway.usageet ses colonnestoken_details) : https://docs.databricks.com/aws/en/ai-gateway/usage-tracking -
Databricks, Log requests and responses to inference tables (lue le 31 octobre 2026 : Databricks facture les requêtes et les réponses journalisées ; colonnes
request,response,event_time) : https://docs.databricks.com/aws/en/ai-gateway/inference-tables - Microsoft Learn, Serverless DBU consumption by SKU (lue le 31 octobre 2026 : « Inference Tables for CPU, GPU endpoints », 7,143 DBU / 1 GB of payload ; « Usage Tracking for CPU, GPU endpoints », 1,429 DBU / 1 GB of payload) : https://learn.microsoft.com/azure/databricks/resources/pricing
- Databricks, page de prix Unity Gateway (lue le 31 octobre 2026 : « Inference Tables and Usage Tracking are charged in payload increments of 1KB ») : https://www.databricks.com/product/pricing/ai-gateway
- Microsoft Learn, Built-in LLM judges : https://learn.microsoft.com/azure/databricks/mlflow3/genai/eval-monitor/concepts/judges/
- Databricks, Set up production monitoring : https://docs.databricks.com/aws/en/mlflow3/genai/eval-monitor/production-monitoring
- Little, J. D. C. (1961), A Proof for the Queuing Formula: L = λW, Operations Research 9(3), 383 à 387, DOI 10.1287/opre.9.3.383 (une loi publiée, sans date de lecture)
14. Références
- Databricks, Billable usage system table reference : https://docs.databricks.com/aws/en/admin/system-tables/billing
- Databricks, Pricing system table reference : https://docs.databricks.com/aws/en/admin/system-tables/pricing
- Databricks, Query history system table reference : https://docs.databricks.com/aws/en/admin/system-tables/query-history
- Databricks, Lineage system tables reference : https://docs.databricks.com/aws/en/admin/system-tables/lineage
- Databricks, Jobs system table reference : https://docs.databricks.com/aws/en/admin/system-tables/jobs
- FinOps Foundation, Allocation (modèles de répartition des coûts partagés : proportionnel, égal, fixe) : https://www.finops.org/framework/capabilities/allocation/